| /***************************************************************************** |
| * Copyright Statement: |
| * -------------------- |
| * This software is protected by Copyright and the information contained |
| * herein is confidential. The software may not be copied and the information |
| * contained herein may not be used or disclosed except with the written |
| * permission of MediaTek Inc. (C) 2005 |
| * |
| * BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES |
| * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") |
| * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON |
| * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT. |
| * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE |
| * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR |
| * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH |
| * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO |
| * NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S |
| * SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM. |
| * |
| * BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE |
| * LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE, |
| * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE, |
| * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO |
| * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. |
| * |
| * THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE |
| * WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF |
| * LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND |
| * RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER |
| * THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC). |
| * |
| *****************************************************************************/ |
| |
| /******************************************************************************* |
| * |
| * Filename: |
| * --------- |
| * sp_ps.c |
| * |
| * Project: |
| * -------- |
| * UMOLYE |
| * |
| * Description: |
| * ------------ |
| * Packet-switching speech interface |
| * |
| * Author: |
| * ------- |
| * ------- |
| * |
| *------------------------------------------------------------------------------ |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * removed! |
| * |
| * removed! |
| * removed! |
| * removed! |
| * |
| |
| *******************************************************************************/ |
| |
| #include "kal_public_api.h" |
| #include "kal_general_types.h" |
| #include "string.h" |
| #include "kal_trace.h" |
| #include "reg_base.h" |
| #include "sync_data.h" |
| |
| #include "audio_dsp_d2c_def.h" |
| #include "l1aud_common_def.h" |
| #include "l1audio.h" |
| #include "am.h" |
| #include "l1audio_trace_utmd.h" |
| #include "media.h" |
| #include "l1sp_trc.h" |
| #include "amr_table.h" |
| #include "sal_exp.h" |
| #include "sal_def.h" |
| #include "dcl.h" |
| #include "drv_sap.h" |
| #include "ltecsr_msgid.h" |
| #include "audio_msgid.h" |
| #include "sp_drv.h" |
| |
| #include "sp_ps.h" |
| #include "sp_ps_aam.h" |
| |
| #include "sp_ps_codec_amr.h" |
| #if defined(__EVS_CODEC_SUPPORT__) |
| #include "sp_ps_codec_evs.h" |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| //#if defined(__G_CODEC_SUPPORT__) |
| #include "sp_ps_codec_g.h" |
| //#endif //#if defined(__G_CODEC_SUPPORT__) |
| |
| #include "sp_ps_dsp_opt.h" |
| #include "sp_ps_aamp.h" |
| |
| //for query OP |
| #include "ps_public_utility.h" |
| |
| //AAM related |
| #include "l1sp_el2_struct.h" |
| #include "el2_msgid.h" |
| //#ifndef TK6291_FAKE_COMPILE |
| //#include "uas_export_api.h" |
| //#include "csr_export_api.h" |
| //#endif //#ifndef TK6291_FAKE_COMPILE |
| |
| |
| /***************************** |
| Definitions |
| *****************************/ |
| |
| |
| /***************************** |
| External variables |
| *****************************/ |
| extern kal_enhmutexid sp_handover_mutex;//sp_4g.c |
| |
| |
| /***************************** |
| External functions |
| *****************************/ |
| extern void CSR_Codec_Close(int rab_id); |
| extern void CSR_Codec_Ready(int rab_id); |
| extern kal_uint32 SP3G_Rab_Id( void ); |
| extern uint32 L1I_GetTimeStamp( void ); |
| extern void sp4g_vmRecordService( uint32 *l1_info, uint16 crc_result, uint16 buf_status, uint16 *ul_frame_data, uint16* dl_frame_data, kal_bool bBufferOK); |
| volatile uint16* SAL_PcmEx_Get4GULBuf(int *len); |
| extern kal_uint32 get_is_fake_4g(void); |
| |
| |
| /***************************** |
| Local variables |
| *****************************/ |
| static kal_uint8 spPS_reset_flag; // speech on and InterRAT : set TRUE |
| static kal_bool spPS_dtx_mode; |
| static int spPS_fake_EVS_IO; |
| static uint8 spPS_est_codec_mode; |
| static kal_uint32 spPS_rab_id; |
| static kal_uint32 spPS_rab_id_record[SPPS_RAB_ID_MAX]; //valid element: 1~(SPPS_RAB_ID_MAX-1) |
| static kal_bool spPS_rab_state; |
| static SP_PS_RADIO_TYPE spPS_RadioType; |
| |
| static kal_uint8 encodebits_null[32]; |
| static kal_uint8 bitlen_null; |
| |
| VoLTE_JBM_TS_Info_t JBM_info_local; |
| |
| SPPS_Struct_t *spPS; |
| SPPS_Struct_t stSPPS; |
| kal_spinlockid spinlock_sp4g; |
| |
| SP4G_PSR_CallType sp4g_PSR_CallType = SP4G_PSR_CallType_None; |
| |
| /***************************** |
| Local functions |
| *****************************/ |
| |
| void SP4G_PSR_SetCallType(SP4G_PSR_CallType type){ |
| sp4g_PSR_CallType = type; |
| } |
| SP4G_PSR_CallType SP4G_PSR_GetCallType(void){ |
| return(sp4g_PSR_CallType); |
| } |
| |
| void spPS_RadioType_set(SP_PS_RADIO_TYPE radio_type) |
| { |
| spPS_RadioType = radio_type; |
| } |
| |
| |
| SP_PS_RADIO_TYPE spPS_RadioType_get(void) |
| { |
| return(spPS_RadioType); |
| } |
| |
| |
| void spPS_reset_flag_set(kal_uint8 val) |
| { |
| spPS_reset_flag = val; |
| } |
| |
| |
| kal_uint8 spPS_reset_flag_get(void) |
| { |
| return(spPS_reset_flag); |
| } |
| |
| |
| bool is_g_codec(uint8 codec) |
| { |
| return( sp_ps_codec_g_is_g_codec(codec) ); |
| } |
| |
| |
| bool is_EVS_codec(uint8 codec) |
| { |
| return( sp_ps_codec_evs_is_EVS_codec(codec) ); |
| } |
| |
| |
| int UseEVSIO2ReplaceAWB(void) |
| { |
| #if defined(__USE_EVS_IO_REPLACE_AWB__) |
| int ret = (int)L1Audio_GetDebugInfo(SPH_DEBUGINFO); |
| |
| ret = ret & SPH_DEBUGINFO12_BIT0; |
| if(ret == 0x00) |
| return(1); |
| else |
| return(0); |
| #else //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| return(0); |
| #endif //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| } |
| |
| |
| void PSR_SP4G_Callback( SP4G_Event event, void *data ){ |
| if(get_is_fake_4g() == 0) |
| { |
| if(SP4G_UL_DATA_NOTIFY == event){ |
| msg_send4( MOD_L1SP, /* source module id */ |
| MOD_LTECSR, /* destination module id */ |
| L1SP_LTECSR_SAP, /* sap id */ |
| MSG_ID_LTECSR_VOICE_UL_DATA_NOTIFY /* message id */ |
| ); |
| }else if(SP4G_UL_MUTE_NOTIFY == event){ |
| msg_send4( MOD_L1SP, /* source module id */ |
| MOD_LTECSR, /* destination module id */ |
| L1SP_LTECSR_SAP, /* sap id */ |
| MSG_ID_LTECSR_VOICE_UL_MUTE_NOTIFY /* message id */ |
| ); |
| }else if(SP4G_DL_DATA_NOTIFY == event){ |
| #if 1 |
| ilm_SP4G_PSR_DL_INFO_t *local_para; |
| local_para = (ilm_SP4G_PSR_DL_INFO_t *) construct_local_para( sizeof(ilm_SP4G_PSR_DL_INFO_t), TD_CTRL ); |
| local_para->JBM_info.TS_Switch = (kal_uint8)SAL_4G_GetTSSwitch(); |
| local_para->JBM_info.TS_Remain_Length_ms = (kal_int16)SAL_Get_RingBuf_RemainLen(); |
| local_para->JBM_info.TS_Total_Length_ms = (kal_int16)SAL_Get_RingBuf_TotalLen(); |
| msg_send6(MOD_L1SP, MOD_LTECSR, L1SP_LTECSR_SAP, MSG_ID_LTECSR_VOICE_DL_DATA_NOTIFY, (local_para_struct *)local_para, NULL); |
| |
| #endif |
| } |
| else if(SP4G_DL_MUTE_NOTIFY == event){ |
| #if 1 |
| msg_send4( MOD_L1SP, /* source module id */ |
| MOD_LTECSR, /* destination module id */ |
| L1SP_LTECSR_SAP, /* sap id */ |
| MSG_ID_LTECSR_VOICE_DL_MUTE_NOTIFY /* message id */ |
| ); |
| #endif |
| } |
| } |
| else |
| { |
| if(SP4G_UL_DATA_NOTIFY == event){ |
| msg_send4( MOD_L1SP, /* source module id */ |
| MOD_MED, /* destination module id */ |
| L1SP_LTECSR_SAP, /* sap id */ |
| MSG_ID_LTECSR_VOICE_UL_DATA_NOTIFY /* message id */ |
| ); |
| }else if(SP4G_UL_MUTE_NOTIFY == event){ |
| msg_send4( MOD_L1SP, /* source module id */ |
| MOD_MED, /* destination module id */ |
| L1SP_LTECSR_SAP, /* sap id */ |
| MSG_ID_LTECSR_VOICE_UL_MUTE_NOTIFY /* message id */ |
| ); |
| }else if(SP4G_DL_DATA_NOTIFY == event){ |
| msg_send4( MOD_L1SP, /* source module id */ |
| MOD_MED, /* destination module id */ |
| L1SP_LTECSR_SAP, /* sap id */ |
| MSG_ID_LTECSR_VOICE_DL_DATA_NOTIFY /* message id */ |
| ); |
| } |
| else if(SP4G_DL_MUTE_NOTIFY == event){ |
| msg_send4( MOD_L1SP, /* source module id */ |
| MOD_MED, /* destination module id */ |
| L1SP_LTECSR_SAP, /* sap id */ |
| MSG_ID_LTECSR_VOICE_DL_MUTE_NOTIFY /* message id */ |
| ); |
| } |
| } |
| } |
| |
| |
| int get_spps_fake_EVS_IO(void) |
| { |
| return spPS_fake_EVS_IO; |
| } |
| |
| |
| int get_sp4g_fake_EVS_IO(void) |
| { |
| return( get_spps_fake_EVS_IO() ); |
| } |
| |
| |
| kal_int32 SP4G_PSR_getToneDeteResult(void) |
| { |
| #ifdef __SP_4G_OPT_TONE_DETECTION_EXECUTED_IN_DSP__ |
| return( (kal_int32)SAL_Get_DuDuPtnFlag() ); |
| #else // __SP_4G_OPT_TONE_DETECTION_EXECUTED_IN_DSP__ |
| #if defined(__SP_4G_OPT_TONE_DETECTION__) |
| return( sp_ps_dsp_opt_ToneDeteGetResult() ); |
| #else //#if defined(__SP_4G_OPT_TONE_DETECTION__) |
| return( 0 ); |
| #endif //#if defined(__SP_4G_OPT_TONE_DETECTION__) |
| #endif // __SP_4G_OPT_TONE_DETECTION_EXECUTED_IN_DSP__ |
| } |
| |
| |
| kal_int32 SP4G_PSR_getEarPhone(void) |
| { |
| if( SPH_EXTDEVINFO_EARPHONE == SP_GetExtDevInfo() ) { |
| return( 1 ); |
| } |
| else { |
| return( 0 ); |
| } |
| } |
| |
| |
| kal_uint32 SP4G_GetGCodecMode(void) |
| { |
| return spPS->ul_codec_mode; |
| |
| } |
| |
| |
| kal_bool SP4G_IsGCodecMode() |
| { |
| return sp_ps_codec_g_is_g_codec(spPS->ul_codec_mode); |
| } |
| |
| |
| kal_bool SP4G_IsEVSCodecMode() |
| { |
| return sp_ps_codec_evs_is_EVS_codec(spPS->ul_codec_mode); |
| } |
| |
| |
| kal_uint32 SP4G_GetCodecMode(void) |
| { |
| if(spPS != NULL) |
| return spPS->ul_codec_mode; |
| else |
| return INIT_CODEC; |
| } |
| |
| |
| void sp_ps_link_est( uint32 rab_id, kal_uint8 default_speech_codec ) |
| { |
| kal_uint8 old_ul_codec_mode = spPS->ul_codec_mode; |
| #if defined(__USE_EVS_IO_REPLACE_AWB__) |
| kal_bool retval; |
| kal_uint8 new_SP4G_Codec; |
| #endif //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| |
| spPS_rab_id = rab_id; |
| spPS_rab_state = KAL_TRUE; |
| |
| #if defined(__USE_EVS_IO_REPLACE_AWB__) |
| if( UseEVSIO2ReplaceAWB() ) |
| { |
| MD_TRC_SPPS_RAB_EST_USE_EVS_IO_REPLACE_AWB_IN(default_speech_codec, default_speech_codec); |
| retval = convert_AWB_to_EVSIOEnum( (SP4G_Codec)default_speech_codec, (SP4G_Codec*)&new_SP4G_Codec ); |
| if(retval == KAL_TRUE) { |
| spPS_fake_EVS_IO = 1; |
| } |
| else { |
| spPS_fake_EVS_IO = 0; |
| } |
| default_speech_codec = new_SP4G_Codec; |
| MD_TRC_SPPS_RAB_EST_USE_EVS_IO_REPLACE_AWB_OUT(default_speech_codec, default_speech_codec); |
| } |
| else |
| { |
| spPS_fake_EVS_IO = 0; |
| } |
| #endif //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| |
| spPS_est_codec_mode = default_speech_codec; |
| if( (sp_ps_codec_g_is_g_codec(spPS_est_codec_mode) == false) && (sp_ps_codec_evs_is_EVS_codec(spPS_est_codec_mode) == false) ) |
| { |
| spPS_est_codec_mode = sp_ps_codec_amr_Get_AmrFrameType2DspMode_spps(spPS_est_codec_mode);//GetFrameType2DspMode(spPS_est_codec_mode); |
| } |
| if(spPS != (SPPS_Struct_t *)NULL) |
| { |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| spPS->ul_codec_mode = spPS_est_codec_mode;//default_speech_codec; |
| kal_give_spinlock(spinlock_sp4g); |
| } |
| MD_TRC_SPPS_RAB_EST1(default_speech_codec, default_speech_codec, spPS_est_codec_mode); |
| MD_TRC_SPPS_RAB_EST2(rab_id, default_speech_codec, default_speech_codec/*spPS_est_codec_mode*/); /* Notice!! Due to the procedure of PSR, SP4G_Rab_Est must follow SetULFrameType so that spPS_est_codec_mode has been set properly*/ |
| #if defined(__C2K_SPEECH_SUPPORT__) |
| if( L1SP_GetState() == L1SP_STATE_C2K_SPEECH_ON ){// |
| //C2K_Codec_Close(SP3G_Rab_Id()); |
| PSR_SP4G_Callback(SP4G_CODEC_READY, (void*)0 ); |
| SP4G_Reset(); |
| AM_InterRAT_C2K_to_4G(SP4G_GetCodecMode()); |
| L1SP_SetState( L1SP_STATE_4G_SPEECH_ON ); |
| }else |
| #endif |
| if( L1SP_GetState() == L1SP_STATE_3G_SPEECH_ON ){// |
| CSR_Codec_Close(SP3G_Rab_Id()); |
| PSR_SP4G_Callback(SP4G_CODEC_READY, (void*)0 ); |
| SP4G_Reset(); |
| |
| AM_InterRAT_3G_to_4G(SP4G_GetCodecMode()); |
| |
| //fix me , depend on codec |
| |
| L1SP_SetState( L1SP_STATE_4G_SPEECH_ON ); |
| }else |
| if( L1SP_GetState() == L1SP_STATE_2G_SPEECH_ON ){//prepare InterRAT HO |
| PSR_SP4G_Callback(SP4G_CODEC_READY, (void*)0 ); |
| SP4G_Reset(); |
| AM_InterRAT_2G_to_4G(SP4G_GetCodecMode()); |
| |
| //fix me , depend on codec |
| |
| L1SP_SetState( L1SP_STATE_4G_SPEECH_ON ); |
| }else |
| if( L1SP_GetState() == L1SP_STATE_4G_SPEECH_ON ){//prepare InterRAT HO |
| uint32 resetType = PS_SRST_TYPE_HO_WITHOUT_VBIEND; |
| PSR_SP4G_Callback(SP4G_CODEC_READY, (void*)0 ); |
| SP4G_Reset(); |
| if( (sp_ps_codec_g_is_g_codec(old_ul_codec_mode) == true) || (sp_ps_codec_g_is_g_codec(default_speech_codec) == true) ) |
| { |
| resetType = PS_SRST_TYPE_HO_WITH_VBIEND; |
| } |
| AM_4G_INTRARAT(SP4G_GetCodecMode(), resetType); |
| |
| //fix me , depend on codec |
| |
| L1SP_SetState( L1SP_STATE_4G_SPEECH_ON ); |
| } |
| } |
| |
| |
| //CSR inform RAB is established, the rab_id should be set as parameter when callback to CSR |
| kal_uint32 SPPS_PSR_Link_Est(SP4G_Codec default_speech_codec, SP_PS_RADIO_TYPE radio_type) // function call |
| { |
| kal_int32 i; |
| kal_uint8 speech_codec_local = (kal_uint8)default_speech_codec; |
| //spPS_rab_id++; |
| //if(spPS_rab_id > 5)//just want to get unique id without any extra purpose |
| // spPS_rab_id = 0; |
| |
| spPS_rab_id = 0; |
| for(i=1; i<SPPS_RAB_ID_MAX; i++) |
| { |
| if(spPS_rab_id_record[i] == 0) |
| { |
| spPS_rab_id = i; |
| spPS_rab_id_record[i] = 1; |
| break; |
| } |
| } |
| ASSERT(spPS_rab_id > 0); |
| |
| kal_take_enh_mutex( sp_handover_mutex ); |
| //AM_SetBlockMED( SAL_APP_TYPE_4GCall, true, 4); |
| |
| SAL_Set_LinkStatus(SAL_LINKSTATUS_4G , true); |
| spPS_RadioType = radio_type; |
| sp_ps_link_est( spPS_rab_id, speech_codec_local ); |
| |
| //AM_SetBlockMED( SAL_APP_TYPE_4GCall, false, 4); |
| kal_give_enh_mutex( sp_handover_mutex ); |
| |
| MD_TRC_SPPS_PSR_LINK_EST(spPS_rab_id); |
| return spPS_rab_id; |
| } |
| |
| |
| //CSR inform RAB is established, the rab_id should be set as parameter when callback to CSR |
| kal_uint32 SP4G_PSR_Link_Est( SP4G_Codec default_speech_codec ) // function call |
| { |
| return( SPPS_PSR_Link_Est(default_speech_codec, SP_PS_RADIO_TYPE_LTE) ); |
| } |
| |
| |
| void SP4G_PSR_Link_Deest(kal_uint32 id) // function call |
| { |
| kal_int32 i; |
| kal_uint32 spPS_rab_id_total; |
| MD_TRC_SPPS_RAB_DEEST(id); |
| //ASSERT(id == spPS_rab_id); |
| ASSERT(spPS_rab_id_record[id] == 1); |
| |
| spPS_rab_id_record[id] = 0; |
| spPS_rab_id_total = 0; |
| for(i=1; i<SPPS_RAB_ID_MAX; i++) |
| { |
| spPS_rab_id_total |= spPS_rab_id_record[i]; |
| } |
| if(spPS_rab_id_total == 0) |
| { |
| spPS_rab_state = KAL_FALSE; |
| spPS_est_codec_mode = INIT_CODEC; |
| spPS_RadioType = SP_PS_RADIO_TYPE_UNKNOWN; |
| } |
| |
| MD_TRC_SPPS_PSR_LINK_DEEST(spPS_rab_state); |
| |
| SAL_Set_LinkStatus(SAL_LINKSTATUS_4G , false); |
| kal_take_enh_mutex( sp_handover_mutex ); |
| #if defined(__C2K_SPEECH_SUPPORT__) |
| if( L1SP_isC2KSO_Connected() && L1SP_GetState() != L1SP_STATE_C2K_SPEECH_ON && L1SP_GetState() != L1SP_STATE_IDLE ){//4G->C2K |
| PSR_SP4G_Callback(SP4G_CODEC_CLOSED, (void*)0 ); |
| AM_InterRAT_4G_to_C2K(L1SP_GetC2KSO_Codec()); |
| L1SP_SetState( L1SP_STATE_C2K_SPEECH_ON ); |
| }else |
| #endif |
| if( SP3G_Rab_State() && L1SP_GetState() != L1SP_STATE_3G_SPEECH_ON && L1SP_GetState() != L1SP_STATE_IDLE ){//4G->3G |
| PSR_SP4G_Callback(SP4G_CODEC_CLOSED, (void*)0 ); |
| CSR_Codec_Ready(SP3G_Rab_Id()); |
| AM_InterRAT_4G_to_3G(SP3G_GetCodecMode()); |
| L1SP_SetState( L1SP_STATE_3G_SPEECH_ON ); |
| }else |
| if( L1SP_TCH_State() && L1SP_GetState() != L1SP_STATE_2G_SPEECH_ON && L1SP_GetState() != L1SP_STATE_IDLE ){//4G->2G |
| PSR_SP4G_Callback(SP4G_CODEC_CLOSED, (void*)0 ); |
| AM_InterRAT_4G_to_2G(); |
| L1SP_SetState( L1SP_STATE_2G_SPEECH_ON ); |
| } |
| kal_give_enh_mutex( sp_handover_mutex ); |
| } |
| |
| |
| kal_bool spPS_Rab_State_get( void ) |
| { |
| return spPS_rab_state; |
| } |
| |
| |
| kal_bool SP4G_Rab_State( void ) |
| { |
| return( spPS_Rab_State_get() ); |
| } |
| |
| |
| kal_uint32 SP4G_Rab_Id( void ) |
| { |
| return spPS_rab_id; |
| } |
| |
| |
| void SP4G_GetSyncDelayRW( kal_uint16 *u16DelayR, kal_uint16 *u16DelayW, kal_uint16 *u16DelayM, kal_uint32 *u32CurTime64us) |
| { |
| sp_ps_aam_GetSyncDelayRW(u16DelayR, u16DelayW, u16DelayM, u32CurTime64us); |
| } |
| |
| |
| void SP4G_Set_G711Parameters(kal_int32 law, kal_int32 dec_init_CNG_enable) |
| { |
| //#if defined(__G_CODEC_SUPPORT__) |
| sp_ps_codec_g_Set_G711Parameters(law, dec_init_CNG_enable); |
| //#endif //#if defined(__G_CODEC_SUPPORT__) |
| } |
| |
| |
| void SP4G_PSR_UL_GSeries_GetSpeechFrame(SP4G_Codec *codec, kal_uint8 *encodebits, kal_uint8 *bitlen) |
| { |
| //#if defined(__G_CODEC_SUPPORT__) |
| MD_TRC_SPPS_PSR_UL_GSERIES_GETSPEECHFRAME(); |
| sp_ps_codec_g_GetFrame((int8 *)codec, (int8 *)bitlen, (uint8 *)encodebits); |
| MD_TRC_SPPS_PSR_UL_GSERIES_GETSPEECHFRAME_INFO(*codec, *codec, encodebits[0], encodebits[1], encodebits[2], encodebits[3], *bitlen); |
| // SP_updateEmCodec(true, *codec, false, 0); |
| //#endif |
| } |
| |
| |
| void SP4G_PSR_DL_GSeries_PutSpeechFrame(SP4G_Codec codec, kal_uint8 *encodebits, kal_uint8 *bitlen) |
| { |
| //#if defined(__G_CODEC_SUPPORT__) |
| if(encodebits == NULL) |
| { |
| encodebits = encodebits_null; |
| bitlen = &bitlen_null; |
| *bitlen = 0; |
| } |
| MD_TRC_SPPS_PSR_DL_GSERIES_PUTSPEECHFRAME(); |
| sp_ps_codec_g_PutFrame((int)codec, (int)(*bitlen), (uint8 *)encodebits); |
| MD_TRC_SPPS_PSR_DL_GSERIES_PUTSPEECHFRAME_INFO(codec, codec, encodebits[0], encodebits[1], encodebits[2], encodebits[3], *bitlen); |
| // SP_updateEmCodec(false, 0, true, codec); |
| //#endif |
| } |
| |
| |
| /* |
| return value: |
| 0: No more data in ul_buf. |
| 1: Have more data in ul_buf |
| */ |
| int SP4G_PSR_UL_GSeries_IsMoreData(void) |
| { |
| return( sp_ps_codec_g_UL_GSeries_IsMoreData() ); |
| } |
| |
| |
| void sp4g_hisr_ul_g(void *data) |
| { |
| sp_ps_codec_g_hisr_ul_g((void *)0); |
| } |
| |
| void sp4g_hisr_dl_g(void *data) |
| { |
| sp_ps_codec_g_hisr_dl_g((void *)0); |
| } |
| |
| void SP4G_EVS_CallOpenSetPar(void) |
| { |
| sp_ps_codec_evs_CallOpenSetPar(); |
| } |
| |
| |
| void SP4G_PSR_SetEVSEncCAPara(EVS_ENC_CA_PARAMETER *pEVS_CA_Par) |
| { |
| #if defined(__EVS_CODEC_SUPPORT__) |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| sp_ps_codec_evs_SetEVSEncCAPara(pEVS_CA_Par); |
| kal_give_spinlock(spinlock_sp4g); |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| } |
| |
| |
| void SP4G_PSR_SetEVSDecCAPara(EVS_DEC_CA_PARAMETER *pEVS_CA_Par) |
| { |
| #if defined(__EVS_CODEC_SUPPORT__) |
| sp_ps_codec_evs_SetEVSDecCAPara(pEVS_CA_Par); |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| } |
| |
| kal_bool SP4G_PSR_GetEVSDecCAPara(kal_uint8* CA_RF_Flag, kal_uint8* CA_RF_Offset, SP4G_Codec codec, kal_uint8* frame_pt, kal_uint8 offset) |
| { |
| #if defined(__EVS_CODEC_SUPPORT__) |
| kal_uint32 rf_flag, rf_offset, rf_type; |
| *CA_RF_Flag = 0; |
| *CA_RF_Offset = 0; |
| |
| if (codec==SP4G_CODEC_EVS_16K_013_2 || codec==SP4G_CODEC_EVS_32K_013_2) // EVS 13.2 |
| { |
| rf_flag = SP4G_Get_Bit_Value(frame_pt, offset, 5); |
| rf_offset = SP4G_Get_Bit_Value(frame_pt, offset + 259, 2); |
| rf_type = SP4G_Get_Bit_Value(frame_pt, offset + 261, 3); |
| //FPRINT_04("VoLTE JBM Get_Payload_Info: rf_flag: %d, rf_offset: %d, rf_type: %d\n", rf_flag, rf_offset, rf_type); |
| if (rf_flag >=21 && rf_flag <=28 && rf_type != 0) |
| { |
| *CA_RF_Flag = 1; |
| if (rf_offset == 0) |
| *CA_RF_Offset = 2; |
| else if (rf_offset == 1) |
| *CA_RF_Offset = 3; |
| else if (rf_offset == 2) |
| *CA_RF_Offset = 5; |
| else if (rf_offset == 3) |
| *CA_RF_Offset = 7; |
| else |
| *CA_RF_Offset = 0; |
| } |
| return KAL_TRUE; |
| } |
| |
| return KAL_FALSE; |
| #else //#if defined(__EVS_CODEC_SUPPORT__) |
| return KAL_FALSE; |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| } |
| |
| kal_uint32 SP4G_Get_Bit_Value(kal_uint8* frame_pt, kal_uint32 offset, kal_uint8 size) |
| { |
| kal_uint8 index, bit_offset, data; |
| kal_uint32 ret = 0; |
| kal_uint8 bits; |
| |
| if (size >32) |
| { |
| return 0; |
| } |
| bits = sizeof(kal_uint8)*8; |
| index = offset/bits; |
| bit_offset = bits - 1 - offset%bits; |
| for (; size>0; size--) |
| { |
| ret = ret << 1; |
| data = frame_pt[index]; |
| if (((data >> bit_offset) & 0x1) == 1) |
| { |
| ret++; |
| } |
| if (bit_offset == 0) |
| { |
| bit_offset = bits - 1; |
| index++; |
| } |
| else |
| { |
| bit_offset--; |
| } |
| } |
| return ret; |
| } |
| |
| void SP4G_PSR_UL_EVS_GetSpeechFrame(SP4G_Codec *frame_type, kal_uint8 *encodebits, kal_uint32 *bitlen, VoLTE_JBM_TS_Info_t *JBM_info) |
| { |
| #if defined(__EVS_CODEC_SUPPORT__) |
| //kal_prompt_trace(MOD_L1SP, "SP4G_PSR_UL_EVS_GetSpeechFrame"); |
| MD_TRC_SPPS_PSR_UL_EVS_GETSPEECHFRAME(); |
| |
| kal_take_enh_mutex( sp_handover_mutex ); |
| |
| sp_ps_codec_evs_UL_GetSpeechFrame(frame_type, encodebits, (kal_int32 *) bitlen); |
| |
| kal_give_enh_mutex( sp_handover_mutex ); |
| |
| // SP_updateEmCodec(true, *frame_type, false, 0); |
| #else //#if defined(__EVS_CODEC_SUPPORT__) |
| *frame_type = SP4G_CODEC_EVS_32K_000_0_NODATA; |
| *bitlen = 0; |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| } |
| |
| |
| void SP4G_PSR_DL_EVS_PutSpeechFrame(kal_uint32 CFN, SP4G_Codec frame_type, kal_uint8 *encodebits, EVS_DEC_CA_PARAMETER *pEVS_Dec_CA_Par, kal_bool crc_status, VoLTE_JBM_TS_Info_t *JBM_info) |
| { |
| kal_take_enh_mutex( sp_handover_mutex ); |
| if( (VoLTE_JBM_TS_Info_t *)NULL == JBM_info ) |
| { |
| JBM_info = &JBM_info_local; |
| } |
| sp_ps_codec_evs_DL_PutSpeechFrame(CFN, frame_type, encodebits, pEVS_Dec_CA_Par, crc_status, JBM_info); |
| kal_give_enh_mutex( sp_handover_mutex ); |
| } |
| |
| |
| void sp4g_hisr_dl(void *data) |
| { |
| uint8 ul_codec_mode_local; |
| |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| |
| ASSERT(spPS != (SPPS_Struct_t*) 0); |
| |
| ul_codec_mode_local = spPS->ul_codec_mode; |
| |
| if( (L1SP_GetState() != L1SP_STATE_4G_SPEECH_ON) || (sp_ps_codec_g_is_g_codec(ul_codec_mode_local)) ) |
| { |
| MD_TRC_SPPS_DL_HISR_SKIP(L1SP_GetState(), sp_ps_codec_g_is_g_codec(ul_codec_mode_local)); |
| kal_give_spinlock(spinlock_sp4g); |
| return; |
| } |
| kal_give_spinlock(spinlock_sp4g); |
| |
| |
| #if defined(__EVS_CODEC_SUPPORT__) |
| if(sp_ps_codec_evs_is_EVS_codec(ul_codec_mode_local)) |
| { |
| sp_ps_codec_evs_hisr_dl_EVS(data); |
| } |
| else |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| { |
| sp_ps_codec_amr_hisr_dl_amr(data); |
| } |
| } |
| |
| void SP4G_Reset( void ) |
| { |
| spPS_reset_flag = 1; |
| } |
| |
| |
| kal_bool spPS_IsDTXOn(void) |
| { |
| return spPS_dtx_mode; |
| } |
| |
| |
| kal_bool SP4G_IsDTXOn(void) |
| { |
| return( spPS_IsDTXOn() ); |
| } |
| |
| |
| void SP4G_SetDTX(kal_bool on) |
| { |
| spPS_dtx_mode = on; |
| MD_TRC_SPPS_SET_DTX(on); |
| if( L1SP_GetState() == L1SP_STATE_4G_SPEECH_ON ) |
| { |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| |
| SAL_3G_SetDtx(on); |
| |
| kal_give_spinlock(spinlock_sp4g); |
| } |
| } |
| |
| |
| void SP4G_PSR_SetDTX(kal_bool on) |
| { |
| SP4G_SetDTX(on); |
| } |
| |
| |
| void SP4G_SetRxTypeToNoData( void ) |
| { |
| //SAL_3G_Set_RxType(SAL_3G_RX_NO_DATA); |
| SAL_4G_Set_RxType(SAL_3G_RX_NO_DATA, SAL_3G_RX_NO_DATA); |
| } |
| |
| |
| kal_uint32 SP4G_JBM_GetDLVADFlag() |
| { |
| return SAL_GetDLVADFlag(); |
| } |
| |
| |
| void sp4g_hisr_ul(void *data) |
| { |
| uint8 ul_codec_mode_local; |
| |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| |
| ASSERT(spPS != (SPPS_Struct_t*) 0); |
| |
| ul_codec_mode_local = spPS->ul_codec_mode; |
| |
| if( (L1SP_GetState() != L1SP_STATE_4G_SPEECH_ON) || (sp_ps_codec_g_is_g_codec(ul_codec_mode_local)) ) |
| { |
| MD_TRC_SPPS_UL_HISR_SKIP(L1SP_GetState(), sp_ps_codec_g_is_g_codec(ul_codec_mode_local)); |
| kal_give_spinlock(spinlock_sp4g); |
| return; |
| } |
| kal_give_spinlock(spinlock_sp4g); |
| |
| |
| #if defined(__EVS_CODEC_SUPPORT__) |
| if(sp_ps_codec_evs_is_EVS_codec(ul_codec_mode_local)) |
| { |
| sp_ps_codec_evs_hisr_ul_EVS(data); |
| } |
| else |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| { |
| sp_ps_codec_amr_hisr_ul_amr(data); |
| } |
| |
| #if defined(__SP_4G_OPT_TONE_DETECTION__) |
| /**************************/ |
| // Execute Tone Detection |
| /**************************/ |
| L1Audio_SetEvent( sp_ps_dsp_opt_ToneDeteGetAudID(), (void *)0 ); |
| #endif //#if defined(__SP_4G_OPT_TONE_DETECTION__) |
| } |
| |
| |
| void sp_ps_reset_internal( void ) |
| { |
| // DL side(G-series) |
| //#if defined(__G_CODEC_SUPPORT__) |
| if(sp_ps_codec_g_is_g_codec(spPS->ul_codec_mode)){ |
| sp_ps_codec_g_reset_internal(); |
| spPS_reset_flag = 2; |
| }else |
| //#endif //#if defined(__G_CODEC_SUPPORT__) |
| { |
| #if defined(__EVS_CODEC_SUPPORT__) |
| if(sp_ps_codec_evs_is_EVS_codec(spPS->ul_codec_mode)) { |
| sp_ps_codec_evs_reset_internal(); |
| spPS_reset_flag = 0; |
| }else |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| { |
| sp_ps_codec_amr_reset_internal(); |
| spPS_reset_flag = 0; // clear reset flag, wait it to be 2 |
| } |
| spPS->ul_waiting = KAL_FALSE; |
| spPS->dl_waiting = KAL_FALSE; |
| } |
| } |
| |
| |
| void sp4g_init( void ) |
| { |
| int i; |
| |
| spPS_rab_id = 0; |
| for(i=0; i<SPPS_RAB_ID_MAX; i++) |
| { |
| spPS_rab_id_record[i] = 0; |
| } |
| spPS_rab_state = KAL_FALSE; |
| spPS_fake_EVS_IO = 0; |
| spPS_dtx_mode = 1; |
| |
| spPS_RadioType = SP_PS_RADIO_TYPE_UNKNOWN; |
| |
| JBM_info_local.TS_Switch = 0; |
| JBM_info_local.TS_HB_Frm_Num = 1; |
| JBM_info_local.TS_Frm_ID = 1; |
| JBM_info_local.TS_isRemainFrame = 0; |
| JBM_info_local.TS_Scale = 100; |
| JBM_info_local.TS_Max_Scale = 0; |
| JBM_info_local.TS_JBM_Reset_Flag = 0; |
| JBM_info_local.TS_DSP_Reset_Flag = 0; |
| JBM_info_local.TS_Remain_Length_ms = 0; |
| JBM_info_local.TS_Total_Length_ms = 0; |
| //JBM_info_local.TS_Reserve[JBM_TS_RESERVE]; |
| JBM_info_local.Nodata_Type = JBM_NODATA_NORMAL; |
| |
| #if defined(__EVS_CODEC_SUPPORT__) |
| sp_ps_codec_evs_init(); |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| |
| #if defined(__SP4G_UL_RESYNC__) |
| sp_ps_aam_init(); |
| #endif |
| |
| spPS = &stSPPS; |
| spinlock_sp4g = kal_create_spinlock("SP4GSL"); |
| } |
| |
| |
| void sp4g_speech_init(uint8 RAT_Mode) |
| { |
| ASSERT( RAT_Mode == RAT_4G_MODE ); |
| ASSERT( L1SP_GetState() == L1SP_STATE_IDLE ); |
| |
| memset(spPS, 0, sizeof(SPPS_Struct_t)); |
| spPS->sp4g_mode = RAT_Mode; |
| // UL side |
| spPS->ul_waiting = KAL_FALSE; |
| spPS->dl_waiting = KAL_FALSE; |
| spPS->ul_write_idx = 0; |
| spPS->ul_read_idx = 0; |
| spPS->ul_count = 0; |
| spPS->is_getting_ul_data = KAL_FALSE; |
| spPS->ul_delay = 0; |
| spPS->dl_delay = 0; |
| spPS->pre_ul_report = spPS->pre_dl_report = spPS->ul_report = spPS->dl_report = spPS_est_codec_mode;//INIT_CODEC; |
| MD_TRC_SPPS_DEBUG_SPPS_SPEECH_INIT(spPS_est_codec_mode); |
| if( spPS->sp4g_mode == RAT_4G_MODE ) |
| { |
| spPS->ul_buffer_size = RAT_4G_UL_BUFFER_NUM; |
| } |
| |
| #if defined(UL_HARD_REAL_TIME_DEMAND) |
| spPS->ul_buffer_size = HARD_REAL_TIME_UL_BUFFER_NUM; |
| #endif |
| |
| spPS->ul_codec_mode = spPS_est_codec_mode;//INIT_CODEC;// use 12.20kbps rate initially |
| |
| spPS->ul_refresh = KAL_FALSE; // detect change codec_mode |
| spPS->ul_intrarat = KAL_FALSE; |
| |
| // DL side |
| spPS->dl_count = 0; |
| spPS->dl_write_idx = 0; |
| spPS->dl_read_idx = 0; |
| |
| if( spPS->sp4g_mode == RAT_4G_MODE ){ |
| MD_TRC_SPPS_PP5_SP4G_RESET_FLAG_INFO(spPS_reset_flag, spPS->dl_count, spPS->dl_read_idx, spPS->dl_write_idx, spPS->dl_buffer_size); |
| MD_TRC_SPPS_PP5_1(RAT_4G_DL_BUFFER_NUM_BEFORE_RESYNC); |
| spPS->dl_buffer_size = RAT_4G_DL_BUFFER_NUM_BEFORE_RESYNC; |
| spPS->dl_buffer_size = 2; |
| MD_TRC_SPPS_PP6_SP4G_RESET_FLAG_INFO(spPS_reset_flag, spPS->dl_count, spPS->dl_read_idx, spPS->dl_write_idx, spPS->dl_buffer_size); |
| spPS_reset_flag = 1; |
| } |
| else{ // 4G324M |
| spPS->dl_buffer_size = MAX_DL_BUFFER_NUM; |
| spPS_reset_flag = 2; |
| } |
| |
| #if defined(__SP4G_UL_RESYNC__) |
| spPS->time[SP_PSCALL_EMAC][0] = spPS->time[SP_PSCALL_EMAC][1] = spPS->time[SP_PSCALL_EMAC][2] = 0; |
| spPS->time[SP_PSCALL_NMAC][0] = spPS->time[SP_PSCALL_NMAC][1] = spPS->time[SP_PSCALL_NMAC][2] = 0; |
| spPS->request_resync = KAL_FALSE; |
| spPS->time2nextULHISR[SP_PSCALL_EMAC] = spPS->time2nextULHISR[SP_PSCALL_NMAC] = 0; //unit: ms |
| #endif |
| |
| #if defined(__SP4G_UL_RESYNC__) |
| sp_ps_aam_speech_init(); |
| #endif |
| |
| sp_ps_aam_speech_init_SilenceDetection(); |
| |
| #if defined(SP4G_UNIT_TEST) |
| L1Audio_HookHisrHandler(DP_D2C_4G,(L1Audio_EventHandler)sp4g_hisr_2, 0); |
| #else |
| L1Audio_HookHisrHandler(DP_D2C_4G_AMR_DONE_UL,(L1Audio_EventHandler)sp4g_hisr_ul, 0); |
| L1Audio_HookHisrHandler(DP_D2C_4G_AMR_DONE_DL,(L1Audio_EventHandler)sp4g_hisr_dl, 0); |
| #endif |
| |
| #if defined(__SP4G_UL_RESYNC__) |
| L1Audio_HookHisrHandler(DP_D2C_4G_AAM,(L1Audio_EventHandler)sp_ps_AAM_hisr, 0); |
| #endif |
| |
| #ifdef __SP_PS_AAM_PLUS__ |
| L1Audio_HookHisrHandler(DP_D2C_4G_AAMPLUS,(L1Audio_EventHandler)sp_ps_AAMPlus_notify_EMAC, 0);//fix |
| #endif //#ifdef __SP_PS_AAM_PLUS__ |
| |
| |
| //#if defined(__G_CODEC_SUPPORT__) |
| sp_ps_codec_g_speech_init(); |
| //#endif//#if defined(__G_CODEC_SUPPORT__) |
| |
| #if defined(__EVS_CODEC_SUPPORT__) |
| sp_ps_codec_evs_speech_init(); |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| |
| #if defined(__SP_4G_OPT_TONE_DETECTION__) |
| sp_ps_dsp_opt_ToneDeteInit(); |
| sp_ps_dsp_opt_ToneDeteTaskInit(); |
| #endif //#if defined(__SP_4G_OPT_TONE_DETECTION__) |
| |
| spPS->l1_info_idx = 0; |
| spPS->dtx_state = 0; |
| |
| #ifdef __SP_PS_AAM_PLUS__ |
| sp_ps_AAMPlus_enable(); |
| #endif //#ifdef __SP_PS_AAM_PLUS__ |
| |
| } |
| |
| SP_PSCALL_L2_MODE SP4G_GetL2Mode() |
| { |
| return spPS->sph_l2_mode; |
| } |
| //#if defined(__G_CODEC_SUPPORT__) |
| void GSeries_Encode_Init(SP4G_Codec codec_) |
| { |
| sp_ps_codec_g_Encode_Init(codec_); |
| } |
| |
| |
| void GSeries_Encode_DeInit() |
| { |
| |
| } |
| |
| |
| void GSeries_Decode_Init(SP4G_Codec codec_) |
| { |
| sp_ps_codec_g_Decode_Init(codec_); |
| } |
| |
| |
| void GSeries_Decode_DeInit() |
| { |
| |
| } |
| |
| |
| void sp4g_speech_close( void ) |
| { |
| L1Audio_UnhookHisrHandler(DP_D2C_4G_AMR_DONE_DL); |
| L1Audio_UnhookHisrHandler(DP_D2C_4G_AMR_DONE_UL); |
| L1Audio_UnhookHisrHandler(DP_D2C_4G_AAM); |
| #ifdef __SP_PS_AAM_PLUS__ |
| L1Audio_UnhookHisrHandler(DP_D2C_4G_AAMPLUS); |
| #endif //#ifdef __SP_PS_AAM_PLUS__ |
| |
| sp_ps_codec_g_close(); |
| |
| #if defined(__SP_4G_OPT_TONE_DETECTION__) |
| sp_ps_dsp_opt_ToneDeteClose(); |
| #endif //#if defined(__SP_4G_OPT_TONE_DETECTION__) |
| |
| #ifdef __SP_PS_AAM_PLUS__ |
| sp_ps_AAMPlus_disable(); |
| #endif //#ifdef __SP_PS_AAM_PLUS__ |
| } |
| |
| |
| kal_uint16 SP4G_PSR_GetCodecBitLength(SP4G_Codec codec) // function call |
| { |
| int len = 0/*, I*/; |
| |
| if(sp_ps_codec_g_is_g_codec(codec)){ |
| if(codec == SP4G_CODEC_G711) |
| { |
| kal_uint16 G711_codec_bitlength = 80*8; |
| return G711_codec_bitlength; |
| } |
| ASSERT(false);//FIX ME |
| }else if(GET_IS_SP4G_CODEC_ENUM_EVS_ID(codec)){ |
| #if defined(__EVS_CODEC_SUPPORT__) |
| return( sp_ps_codec_evs_GetCodecBitLength(codec) ); |
| #else //#if defined(__EVS_CODEC_SUPPORT__) |
| ASSERT(false);//FIX ME |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| }else{//AMR, WB-AMR |
| return( sp_ps_codec_amr_GetCodecBitLength(codec) ); |
| } |
| return len; |
| } |
| |
| |
| void SP4G_UL_SetFrameType(uint8 amr_frame_type) // function call |
| { |
| uint8 state; |
| uint32 codec; |
| spPS_est_codec_mode = sp_ps_codec_amr_Get_AmrFrameType2DspMode_spps(amr_frame_type);//AmrFrameType2DspMode_spps[amr_frame_type]; |
| |
| if( (state = L1SP_GetState()) != L1SP_STATE_4G_SPEECH_ON){ |
| return; |
| } |
| |
| ASSERT(spPS != (SPPS_Struct_t*) 0); |
| |
| MD_TRC_SPPS_REQUEST_UL_FRAME_TYPE(amr_frame_type, amr_frame_type); |
| codec = sp_ps_codec_amr_Get_AmrFrameType2DspMode_spps(amr_frame_type);//AmrFrameType2DspMode_spps[amr_frame_type]; |
| if( (sp_ps_codec_g_is_g_codec(spPS->ul_codec_mode)==true) || (sp_ps_codec_evs_is_EVS_codec(spPS->ul_codec_mode)==true) ) |
| { |
| uint32 resetType = PS_SRST_TYPE_HO_WITHOUT_VBIEND; |
| if( sp_ps_codec_g_is_g_codec(spPS->ul_codec_mode) == true ) |
| { |
| resetType = PS_SRST_TYPE_HO_WITH_VBIEND; |
| } |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| spPS->ul_codec_mode = codec; |
| kal_give_spinlock(spinlock_sp4g); |
| AM_4G_INTRARAT(codec, resetType); |
| //may add at 3G |
| //spPS->ul_intrarat = KAL_TRUE; |
| SP4G_Reset(); |
| MD_TRC_SPPS_SETCODEC_SETFRAMETYPE1(spPS->ul_codec_mode, spPS->ul_codec_mode, codec, amr_frame_type, amr_frame_type, spPS->ul_intrarat); |
| //L1SP_SetState( L1SP_STATE_4G_SPEECH_ON ); |
| }else if( (spPS->ul_codec_mode >= 0x20 && codec <= 0x0A) || (spPS->ul_codec_mode <= 0x0A && codec >= 0x20) ){//Intrarat |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| spPS->ul_codec_mode = codec; |
| kal_give_spinlock(spinlock_sp4g); |
| AM_4G_INTRARAT(codec, PS_SRST_TYPE_HO_WITHOUT_VBIEND); |
| //may add at 3G |
| spPS->ul_intrarat = KAL_TRUE; |
| SP4G_Reset(); |
| MD_TRC_SPPS_SETCODEC_SETFRAMETYPE2(spPS->ul_codec_mode, codec, amr_frame_type, amr_frame_type, spPS->ul_intrarat); |
| //L1SP_SetState( L1SP_STATE_4G_SPEECH_ON ); |
| }else{ |
| if(spPS->ul_codec_mode != codec){ |
| MD_TRC_SPPS_SETCODEC_SETFRAMETYPE3(spPS->ul_codec_mode, codec,amr_frame_type, amr_frame_type, spPS->ul_intrarat); |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| spPS->ul_codec_mode = codec; |
| spPS->ul_refresh = KAL_TRUE; |
| kal_give_spinlock(spinlock_sp4g); |
| } |
| } |
| } |
| |
| |
| void SP4G_PSR_UL_SetFrameType(SP4G_Codec codec) |
| { |
| #if defined(__USE_EVS_IO_REPLACE_AWB__) |
| kal_bool retval; |
| kal_uint8 new_SP4G_Codec; |
| #endif //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| |
| kal_take_enh_mutex( sp_handover_mutex ); |
| |
| MD_TRC_SPPS_SETCODEC0(codec, codec); |
| |
| MD_TRC_SPPS_PSR_UL_SETFRAMETYPE1(codec, L1SP_GetState(), sp_ps_codec_g_is_g_codec(codec), sp_ps_codec_evs_is_EVS_codec(codec)); |
| |
| #if defined(__USE_EVS_IO_REPLACE_AWB__) |
| if( UseEVSIO2ReplaceAWB() ) |
| { |
| MD_TRC_SPPS_SETCODEC_USE_EVS_IO_REPLACE_AWB_IN(codec); |
| retval = convert_AWB_to_EVSIOEnum( codec, (SP4G_Codec*)&new_SP4G_Codec ); |
| if(retval == KAL_TRUE) { |
| spPS_fake_EVS_IO = 1; |
| } |
| else { |
| spPS_fake_EVS_IO = 0; |
| } |
| codec = new_SP4G_Codec; |
| MD_TRC_SPPS_SETCODEC_USE_EVS_IO_REPLACE_AWB_OUT(codec); |
| } |
| else |
| { |
| spPS_fake_EVS_IO = 0; |
| } |
| #endif //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| |
| spPS_est_codec_mode = codec; |
| if( (sp_ps_codec_g_is_g_codec(spPS_est_codec_mode)==false) && (sp_ps_codec_evs_is_EVS_codec(spPS_est_codec_mode)==false) ){ |
| spPS_est_codec_mode = sp_ps_codec_amr_Get_AmrFrameType2DspMode_spps(spPS_est_codec_mode);//GetFrameType2DspMode(spPS_est_codec_mode); |
| } |
| |
| if( L1SP_GetState() != L1SP_STATE_4G_SPEECH_ON){ |
| if( 1/*L1SP_STATE_IDLE == L1SP_GetState()*/ ){ |
| if( spPS != (SPPS_Struct_t *)NULL ){ |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| spPS->ul_codec_mode = spPS_est_codec_mode;//default_speech_codec; |
| kal_give_spinlock(spinlock_sp4g); |
| } |
| MD_TRC_SPPS_SETCODEC(codec, codec, spPS_est_codec_mode); |
| } |
| kal_give_enh_mutex( sp_handover_mutex ); |
| return; |
| } |
| |
| if(sp_ps_codec_g_is_g_codec(codec)){ |
| if(codec == spPS->ul_codec_mode){ |
| MD_TRC_SPPS_SETCODEC_IS_EQUAL(codec, codec); |
| //return; |
| } |
| else{ |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| spPS->ul_codec_mode = codec; |
| kal_give_spinlock(spinlock_sp4g); |
| AM_4G_INTRARAT(codec, PS_SRST_TYPE_HO_WITH_VBIEND); |
| SP4G_Reset(); |
| } |
| }else if(sp_ps_codec_evs_is_EVS_codec(codec)){ |
| if( /*sp_ps_codec_evs_is_EVS_codec(codec) ==*/ sp_ps_codec_evs_is_EVS_codec(spPS->ul_codec_mode) ){ |
| if( GET_SP4G_CODEC_ENUM_NON_EVS_ID(codec) != GET_SP4G_CODEC_ENUM_NON_EVS_ID(spPS->ul_codec_mode) ) |
| { |
| sp_ps_codec_evs_set_network_bw(codec); |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| spPS->ul_codec_mode = codec; |
| kal_give_spinlock(spinlock_sp4g); |
| AM_4G_INTRARAT(codec, PS_SRST_TYPE_HO_WITHOUT_VBIEND); |
| SP4G_Reset(); |
| } |
| else if( codec != (spPS->ul_codec_mode) ) |
| { |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| spPS->ul_codec_mode = codec; |
| kal_give_spinlock(spinlock_sp4g); |
| } |
| } |
| else |
| { |
| uint32 reset_type = PS_SRST_TYPE_HO_WITHOUT_VBIEND; |
| if( sp_ps_codec_g_is_g_codec(spPS->ul_codec_mode) == true ) |
| { |
| reset_type = PS_SRST_TYPE_HO_WITH_VBIEND; |
| } |
| kal_take_spinlock(spinlock_sp4g, KAL_INFINITE_WAIT); |
| spPS->ul_codec_mode = codec; |
| kal_give_spinlock(spinlock_sp4g); |
| AM_4G_INTRARAT(codec, reset_type); |
| SP4G_Reset(); |
| } |
| }else{ |
| SP4G_UL_SetFrameType(codec); |
| } |
| |
| kal_give_enh_mutex( sp_handover_mutex ); |
| } |
| |
| |
| void SP4G_PSR_UL_AMR_GetSpeechFrame(SP4G_Codec *frame_type, kal_uint8 *encodebits, kal_uint8 *bitlen, VoLTE_JBM_TS_Info_t *JBM_info) |
| { |
| kal_take_enh_mutex( sp_handover_mutex ); |
| |
| #if defined(__USE_EVS_IO_REPLACE_AWB__) |
| if(spPS_fake_EVS_IO == 0) { |
| #endif //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| sp_ps_codec_amr_UL_GetSpeechFrame(frame_type, encodebits, bitlen); |
| // SP_updateEmCodec(true, convert_SP4G_CODEC_AMR_AMRWB_to_SPH_CODEC((*frame_type)), false, 0); |
| #if defined(__USE_EVS_IO_REPLACE_AWB__) |
| } else { |
| kal_bool retval; |
| SP4G_Codec EVSIO_frame_type; |
| kal_uint32 u32bitlen; |
| uint8 EVS_codec_rate = 0; |
| |
| //MD_TRC_SPPS_UL_GETSPEECHFRAME_USE_EVS_IO_REPLACE_AWB(); |
| |
| { |
| #if defined(__EVS_CODEC_SUPPORT__) |
| sp_ps_codec_evs_UL_GetSpeechFrame(&EVSIO_frame_type, encodebits, (kal_int32 *)&u32bitlen); |
| #else //#if defined(__EVS_CODEC_SUPPORT__) |
| *frame_type = SP4G_CODEC_EVS_32K_000_0_NODATA; |
| *bitlen = 0; |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| } |
| |
| EVS_codec_rate = GET_SP4G_CODEC_ENUM_EVS_RATE(EVSIO_frame_type); |
| *bitlen = (kal_uint8)sp_ps_codec_evs_Get_EVS_AWB_RAB_subflow(EVS_codec_rate, 3);//EVS_AWB_RAB_subflow[EVS_codec_rate][3]; |
| MD_TRC_SPPS_UL_GETSPEECHFRAME_USE_EVS_IO_REPLACE_AWB_LEN(u32bitlen, *bitlen); |
| |
| retval = convert_EVSIO_to_AWBEnum(EVSIO_frame_type, frame_type); |
| if(retval == KAL_FALSE) { |
| *frame_type = AMR_NO_DATA; |
| *bitlen = 0; |
| } |
| } |
| #endif //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| |
| kal_give_enh_mutex( sp_handover_mutex ); |
| } |
| |
| |
| void SP4G_PSR_DL_AMR_PutSpeechFrame(kal_uint32 CFN, SP4G_PSR_Codec codec, SP4G_Codec frame_type, kal_bool crc_status, kal_uint8 *encodebits, VoLTE_JBM_TS_Info_t *JBM_info) |
| { |
| kal_take_enh_mutex( sp_handover_mutex ); |
| |
| if( (VoLTE_JBM_TS_Info_t *)NULL == JBM_info ) |
| { |
| JBM_info = &JBM_info_local; |
| } |
| |
| #if defined(__USE_EVS_IO_REPLACE_AWB__) |
| if(spPS_fake_EVS_IO == 0) { |
| #endif //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| sp_ps_codec_amr_DL_PutSpeechFrame(CFN, codec, frame_type, encodebits, crc_status, JBM_info); |
| #if defined(__USE_EVS_IO_REPLACE_AWB__) |
| } else { |
| kal_bool retval; |
| SP4G_Codec EVSIO_frame_type; |
| |
| //MD_TRC_SPPS_DL_PUTSPEECHFRAME_USE_EVS_IO_REPLACE_AWB(); |
| |
| retval = convert_AWB_to_EVSIOEnum(frame_type, &EVSIO_frame_type); |
| if(retval == KAL_FALSE) { |
| EVSIO_frame_type = SP4G_CODEC_EVS_AWB_00_00_NODATA; |
| } |
| |
| sp_ps_codec_evs_DL_PutSpeechFrame(CFN, EVSIO_frame_type, encodebits, (EVS_DEC_CA_PARAMETER*)NULL, crc_status, JBM_info); |
| } |
| #endif //#if defined(__USE_EVS_IO_REPLACE_AWB__) |
| |
| kal_give_enh_mutex( sp_handover_mutex ); |
| } |
| |
| |
| //===================================== |
| // Fake 4G llopbck |
| //===================================== |
| kal_uint32 get_is_fake_4g(void); |
| kal_uint32 encodebits_buf[1000]; |
| kal_uint8 encodebits[128]; |
| |
| SP4G_Codec pscall_loopback_frame_type; |
| kal_uint32 pscall_loopback_bitlen; |
| kal_uint8 pscall_loopback_uint8_bitlen; |
| |
| void sp4g_EVS_loopback_ul(void) |
| { |
| #if defined(__EVS_CODEC_SUPPORT__) |
| kal_uint8 *encodebits = (kal_uint8 *)encodebits_buf; |
| MD_TRC_SPPS_PSR_EVS_LOOPBACK_UL_1(); |
| if( sp_ps_codec_evs_is_EVS_codec(spPS->ul_codec_mode) ) |
| { |
| SP4G_PSR_UL_EVS_GetSpeechFrame(&pscall_loopback_frame_type, encodebits, &pscall_loopback_bitlen, (VoLTE_JBM_TS_Info_t *)NULL); |
| { |
| l1sp_emac_resync_info_struct *local_para; |
| local_para = (l1sp_emac_resync_info_struct *) construct_local_para( sizeof(l1sp_emac_resync_info_struct), TD_CTRL ); |
| local_para->RX_period = 0; |
| local_para->TX_period = 20; |
| local_para->time2nextRX = 0; |
| local_para->time2nextTX = 7; |
| local_para->issueTime = ust_get_current_time(); |
| |
| msg_send6(MOD_EMAC, MOD_MED, AUDIO_SAP, MSG_ID_AUDIO_M2M_VOLTE_MAC_TIMING_INFO, (local_para_struct *)local_para, NULL); |
| } |
| MD_TRC_SPPS_PSR_EVS_LOOPBACK_UL_2(pscall_loopback_frame_type, pscall_loopback_bitlen); |
| } |
| #endif //#if 0 |
| } |
| |
| void sp4g_EVS_loopback_dl(void) |
| { |
| #if defined(__EVS_CODEC_SUPPORT__) |
| kal_uint8 *encodebits = (kal_uint8 *)encodebits_buf; |
| EVS_DEC_CA_PARAMETER EVS_Dec_CA_Par; |
| EVS_DEC_CA_PARAMETER *pEVS_Dec_CA_Par = &EVS_Dec_CA_Par; |
| |
| EVS_Dec_CA_Par.FrameMode = FRAMEMODE_NORMAL; |
| MD_TRC_SPPS_PSR_EVS_LOOPBACK_DL_1(); |
| if( sp_ps_codec_evs_is_EVS_codec(spPS->ul_codec_mode) ) |
| { |
| MD_TRC_SPPS_PSR_EVS_LOOPBACK_DL_2(pscall_loopback_frame_type, pscall_loopback_bitlen); |
| //SP4G_PSR_UL_EVS_GetSpeechFrame(&frame_type, encodebits, &bitlen, (VoLTE_JBM_TS_Info_t *)NULL); |
| if(pscall_loopback_bitlen == 0) |
| { |
| SP4G_PSR_DL_EVS_PutSpeechFrame(0, pscall_loopback_frame_type, NULL, pEVS_Dec_CA_Par, KAL_TRUE, (VoLTE_JBM_TS_Info_t *)NULL); |
| } |
| else |
| { |
| SP4G_PSR_DL_EVS_PutSpeechFrame(0, pscall_loopback_frame_type, encodebits, pEVS_Dec_CA_Par, KAL_TRUE, (VoLTE_JBM_TS_Info_t *)NULL); |
| } |
| } |
| #endif //#if 0 |
| } |
| |
| |
| void sp4g_EVS_loopback_SetEVSEncCAPara(void) |
| { |
| #if defined(__EVS_CODEC_SUPPORT__) |
| EVS_ENC_CA_PARAMETER EVS_CA_Par; |
| |
| EVS_CA_Par.enable = 0; |
| EVS_CA_Par.rf_fec_indicator = 0; |
| EVS_CA_Par.rf_fec_offset = 0; |
| EVS_CA_Par.rev3 = 0; |
| EVS_CA_Par.rev4 = 0; |
| EVS_CA_Par.rev5 = 0; |
| |
| SP4G_PSR_SetEVSEncCAPara(&EVS_CA_Par); |
| #endif //#if defined(__EVS_CODEC_SUPPORT__) |
| } |
| |
| |
| void sp4g_AMR_NB_loopback_ul(void) |
| { |
| SP4G_PSR_UL_AMR_GetSpeechFrame(&pscall_loopback_frame_type, encodebits, &pscall_loopback_uint8_bitlen, (VoLTE_JBM_TS_Info_t *)NULL); |
| } |
| |
| void sp4g_AMR_NB_loopback_dl(void) |
| { |
| if( (pscall_loopback_frame_type >= SP4G_CODEC_WBAMR_6_6) && (pscall_loopback_frame_type <= SP4G_CODEC_WBAMR_SID) ) |
| { |
| return; |
| } |
| |
| if( (pscall_loopback_frame_type==SP4G_CODEC_AMR_NO_DATA) || (pscall_loopback_frame_type==SP4G_CODEC_LOST_FRAME) ) |
| { |
| SP4G_PSR_DL_AMR_PutSpeechFrame(0, SP4G_PSR_AMR, pscall_loopback_frame_type, KAL_TRUE, NULL, (VoLTE_JBM_TS_Info_t *)NULL); |
| } |
| else |
| { |
| SP4G_PSR_DL_AMR_PutSpeechFrame(0, SP4G_PSR_AMR, pscall_loopback_frame_type, KAL_TRUE, encodebits, (VoLTE_JBM_TS_Info_t *)NULL); |
| } |
| } |
| |
| void sp4g_AMR_WB_loopback_ul(void) |
| { |
| SP4G_PSR_UL_AMR_GetSpeechFrame(&pscall_loopback_frame_type, encodebits, &pscall_loopback_uint8_bitlen, (VoLTE_JBM_TS_Info_t *)NULL); |
| } |
| |
| void sp4g_AMR_WB_loopback_dl(void) |
| { |
| if( pscall_loopback_frame_type <= SP4G_CODEC_AMR_SID ) |
| { |
| return; |
| } |
| |
| if( (pscall_loopback_frame_type==SP4G_CODEC_AMR_NO_DATA) || (pscall_loopback_frame_type==SP4G_CODEC_LOST_FRAME) ) |
| { |
| SP4G_PSR_DL_AMR_PutSpeechFrame(0, SP4G_PSR_WBAMR, pscall_loopback_frame_type, KAL_TRUE, NULL, (VoLTE_JBM_TS_Info_t *)NULL); |
| } |
| else |
| { |
| SP4G_PSR_DL_AMR_PutSpeechFrame(0, SP4G_PSR_WBAMR, pscall_loopback_frame_type, KAL_TRUE, encodebits, (VoLTE_JBM_TS_Info_t *)NULL); |
| } |
| } |
| |
| |
| void sp4g_G711_loopback(void) |
| { |
| SP4G_Codec frame_type; |
| kal_uint8 bitlen; |
| |
| while(SP4G_PSR_UL_GSeries_IsMoreData()) |
| { |
| MD_TRC_SPPS_PSR_G711_LOOPBACK(0); |
| SP4G_PSR_UL_GSeries_GetSpeechFrame(&frame_type, encodebits, &bitlen); |
| MD_TRC_SPPS_PSR_G711_LOOPBACK(1); |
| SP4G_PSR_DL_GSeries_PutSpeechFrame(frame_type, encodebits, &bitlen); |
| MD_TRC_SPPS_PSR_G711_LOOPBACK(2); |
| } |
| } |
| |
| |
| void sp4g_fake_loopback_ul(void) |
| { |
| uint8 local_ul_codec_mode = spPS->ul_codec_mode; |
| |
| if( get_is_fake_4g() == 0 ) |
| { |
| return; |
| } |
| |
| #ifdef TEST_AAM |
| if(KAL_TRUE == SPPS_is_trigger_mac_notify) |
| { |
| if(0 == test_aam_resync) |
| { |
| SP4G_Set_AAM_Info(40, 20, 30, 5); |
| } |
| else |
| { |
| SP4G_Set_AAM_Info(40, 20, 30, 15); |
| test_aam_resync = 0; |
| } |
| } |
| #endif //#ifdef TEST_AAM |
| |
| //EVS |
| if( sp_ps_codec_evs_is_EVS_codec(local_ul_codec_mode) ) |
| { |
| sp4g_EVS_loopback_ul(); |
| } |
| //G series |
| else if( sp_ps_codec_g_is_g_codec(local_ul_codec_mode) ) |
| { |
| sp4g_G711_loopback(); |
| } |
| //AMR-NB |
| else if( local_ul_codec_mode <= 0xA ) |
| { |
| sp4g_AMR_NB_loopback_ul(); |
| } |
| //AMR-WB |
| else if( local_ul_codec_mode >= 0x20 ) |
| { |
| sp4g_AMR_WB_loopback_dl(); |
| } |
| } |
| |
| void sp4g_fake_loopback_dl(void) |
| { |
| uint8 local_ul_codec_mode = spPS->ul_codec_mode; |
| |
| if( get_is_fake_4g() == 0 ) |
| { |
| return; |
| } |
| |
| #ifdef TEST_AAM |
| if(KAL_TRUE == SPPS_is_trigger_mac_notify) |
| { |
| if(0 == test_aam_resync) |
| { |
| SP4G_Set_AAM_Info(40, 20, 30, 5); |
| } |
| else |
| { |
| SP4G_Set_AAM_Info(40, 20, 30, 15); |
| test_aam_resync = 0; |
| } |
| } |
| #endif //#ifdef TEST_AAM |
| |
| //EVS |
| if( sp_ps_codec_evs_is_EVS_codec(local_ul_codec_mode) ) |
| { |
| sp4g_EVS_loopback_dl(); |
| } |
| //G series |
| //else if( sp_ps_codec_g_is_g_codec(local_ul_codec_mode) ) |
| //{ |
| // sp4g_G711_loopback(); |
| //} |
| //AMR-NB |
| else if( local_ul_codec_mode <= 0xA ) |
| { |
| sp4g_AMR_NB_loopback_dl(); |
| } |
| //AMR-WB |
| else if( local_ul_codec_mode >= 0x20 ) |
| { |
| sp4g_AMR_WB_loopback_dl(); |
| } |
| } |
| |
| |
| |
| //#endif // __UMTS_RAT__ |
| |
| |
| |
| |