diff --git a/src/lynq/framework/lynq-ril-service/src/cc.cpp b/src/lynq/framework/lynq-ril-service/src/cc.cpp
index 8afb2d3..de73cd9 100755
--- a/src/lynq/framework/lynq-ril-service/src/cc.cpp
+++ b/src/lynq/framework/lynq-ril-service/src/cc.cpp
@@ -50,6 +50,7 @@
 #ifdef LED_SUPPORT
 #include "led.h"
 #endif
+#include "call_rtp.h"
 using android::Parcel;
 /*Warren add for t800 ril servie 2021/12/23 end*/
 
@@ -170,10 +171,19 @@
 
      //set mixer ctl to om:1 or off:0
     if(value){
-        ret = set_mixer_ctrl_value_int(isEcallAudioPath() ? g_mixer_name_ecall: g_mixer_name, value);
-        RLOGD("mixer_set(%s) = %d, ret: %d", (isEcallAudioPath() ? g_mixer_name_ecall: g_mixer_name), value, ret);
-    } else {
-        //setEcallAudioPathOn(false);
+        //ret = set_mixer_ctrl_value_int(isEcallAudioPath() ? g_mixer_name_ecall: g_mixer_name, value);
+        if(isEcallAudioPath())
+        {
+            exe_set_voice_audio_mode(AUDIO_MODE_CODEC);
+        }
+        else 
+        {
+            exe_set_voice_audio_mode(AUDIO_MODE_RTP);
+        }
+     // RLOGD("mixer_set(%s) = %d, ret: %d", (isEcallAudioPath() ? g_mixer_name_ecall: g_mixer_name), value, ret);
+    } else {   
+        exe_set_voice_audio_mode(AUDIO_MODE_ALL_CLOSE);
+/*        
         ret = get_mixer_ctrl_value_int(g_mixer_name);
         RLOGD("mixer_set(get_mixer_ctrl_value_int: %s) = %d", g_mixer_name, ret);
         if(ret > 0) {
@@ -183,6 +193,7 @@
             ret = set_mixer_ctrl_value_int(g_mixer_name_ecall, value);
             RLOGD("mixer_set(%s) = %d", g_mixer_name_ecall, ret);
         }
+*/
     }
 
 
@@ -390,7 +401,7 @@
     }
     }
     p.setDataPosition(pos);
-    setEcallAudioPathOn(false);
+//  setEcallAudioPathOn(false);
     pRI->pCI->dispatchFunction(p, pRI);
     inCallstatus = CALL_ON;
     return 0;
@@ -710,7 +721,7 @@
 #endif
 
     p.setDataPosition(pos);
-    setEcallAudioPathOn(false);
+//  setEcallAudioPathOn(false);
     pRI->pCI->dispatchFunction(p, pRI);
     return 0;
 }
@@ -1013,7 +1024,7 @@
     }
   }
   p.setDataPosition(pos);
-  setEcallAudioPathOn(false);
+//setEcallAudioPathOn(false);
   pRI->pCI->dispatchFunction(p, pRI);
   return 0;
 }
@@ -1398,8 +1409,9 @@
     static int callIndex = 0;
     RLOGD("callnum = %d, Call State Change then judge speech on/off!", callnum);
     callIndex = callnum;
+    lock_rtp_audio_mtx(); 	
 #ifdef GSW_RIL_CFG
-    if( callIndex >= 1 && speechStatus == SPEECH_OFF) {  //speech on
+    if( callIndex > 0 && speechStatus == SPEECH_OFF) {  //speech on
         //RLOGD("DemoAPP Call shell command (pactl set-card-profile 0 phonecall)");
         //system("pactl set-card-profile 0 phonecall");
         //RLOGD("DemoAPP Call shell command end");
@@ -1407,7 +1419,7 @@
 #endif
 
 #ifdef MOBILETEK_RIL_CFG
-    if( callIndex == 1 && speechStatus == SPEECH_OFF) {  //speech on
+    if( callIndex > 0 && speechStatus == SPEECH_OFF) {  //speech on
         //RLOGD("DemoAPP Call shell command (pactl set-card-profile 0 phonecall)");
         //system("pactl set-card-profile 0 phonecall");
         //RLOGD("DemoAPP Call shell command end");
@@ -1420,6 +1432,7 @@
             speechStatus = BT_SPEECH_ON;
         }
         inCallstatus = CALL_ON;
+        unlock_rtp_audio_mtx();
         RLOGD("[speech]: set on");
         sendCallMsg(true); //for Power Manager test
     } else if (callIndex == 0
@@ -1440,11 +1453,13 @@
         speechStatus = SPEECH_OFF;
         inCallstatus = CALL_OFF;
         resetMute();
+        unlock_rtp_audio_mtx();
 #ifdef GSW_RIL_CFG
         set_codec(0); //hqing add for Geely demand on 11/07/2022, after cs call, close codec for power Manager
 #endif
         RLOGD("[speech]: set off");
     } else {
+        unlock_rtp_audio_mtx();
         RLOGD("callIndex is %d, speechStatus is %d.",callIndex, speechStatus);
     }
 
diff --git a/src/lynq/framework/lynq-ril-service/src/commands.h b/src/lynq/framework/lynq-ril-service/src/commands.h
index c1686ed..115e16d 100755
--- a/src/lynq/framework/lynq-ril-service/src/commands.h
+++ b/src/lynq/framework/lynq-ril-service/src/commands.h
@@ -235,6 +235,20 @@
     {"RIL_REQUEST_DEMO_LOCAL_SET_GOST_DEFAULT",gostTransmitDefaultSet,"Set gost ecall default",-1},
     #endif /*ECALL_SUPPORT*/
 
+	//rtp
+    {"LYNQ_REQUEST_SET_VOICE_AUDIO_MODE",set_voice_audio_mode,"set voice audio mode",LYNQ_REQUEST_SET_VOICE_AUDIO_MODE},
+    {"LYNQ_REQUEST_SET_REMOTE_RTP_IP",set_remote_rtp_ip,"set remote rtp ip",LYNQ_REQUEST_SET_REMOTE_RTP_IP},
+    {"LYNQ_REQUEST_SET_VLAN_INFO",set_vlan_info,"set vlan info",LYNQ_REQUEST_SET_VLAN_INFO},
+    {"LYNQ_REQUEST_SET_RTP_PORT",set_rtp_port,"set rtp port",LYNQ_REQUEST_SET_RTP_PORT},
+    {"LYNQ_REQUEST_SET_RTP_PARAM",set_rtp_param,"set rtp para",LYNQ_REQUEST_SET_RTP_PARAM},
+    {"LYNQ_REQUEST_GET_VOICE_AUDIO_MODE",get_voice_audio_mode,"get voice audio mode",LYNQ_REQUEST_GET_VOICE_AUDIO_MODE},
+    {"LYNQ_REQUEST_GET_REMOTE_RTP_IP",get_remote_rtp_ip,"get remote rtp ip",LYNQ_REQUEST_GET_REMOTE_RTP_IP},
+    {"LYNQ_REQUEST_GET_VLAN_INFO",get_vlan_info,"get vlan info",LYNQ_REQUEST_GET_VLAN_INFO},
+    {"LYNQ_REQUEST_GET_RTP_PORT",get_rtp_port,"get rtp port",LYNQ_REQUEST_GET_RTP_PORT},
+    {"LYNQ_REQUEST_GET_RTP_PARAM",get_rtp_param,"get rtp para",LYNQ_REQUEST_GET_RTP_PARAM},   
+    {"LYNQ_REQUEST_SET_CALL_RTP_SSRC",set_call_rtp_ssrc,"set call rtp ssrc",LYNQ_REQUEST_SET_CALL_RTP_SSRC},
+    {"LYNQ_REQUEST_GET_CALL_RTP_SSRC",get_call_rtp_ssrc,"get call rtp ssrc",LYNQ_REQUEST_GET_CALL_RTP_SSRC},
+ 
 #ifdef MODE_DSDS
     {"SET_DEFAULT_SIM_ALL",set_default_sim_all, "set default sim_all", -1},
     {"GET_DEFAULT_SIM_ALL",get_default_sim_all, "get default sim_all", -1},
diff --git a/src/lynq/framework/lynq-ril-service/src/common.cpp b/src/lynq/framework/lynq-ril-service/src/common.cpp
index 9132652..402aad1 100755
--- a/src/lynq/framework/lynq-ril-service/src/common.cpp
+++ b/src/lynq/framework/lynq-ril-service/src/common.cpp
@@ -99,6 +99,8 @@
 
 /*Warren add for SZZT 2021/11/14 end*/
 
+int g_ril_test;
+
 
 /*hq add for key information output start 2022/03/01*/
 // extern int lynq_output_LINFO_enable =0;
diff --git a/src/lynq/framework/lynq-ril-service/src/common.h b/src/lynq/framework/lynq-ril-service/src/common.h
index b0bdb3e..a7f2a6b 100755
--- a/src/lynq/framework/lynq-ril-service/src/common.h
+++ b/src/lynq/framework/lynq-ril-service/src/common.h
@@ -82,6 +82,10 @@
 #define PROP_DEFAULT_DATA_SIM_STATUS "vendor.radio.data.enable"
 #define ATCI_SIM "persist.vendor.service.atci.sim"
 //#define PROP_DATA_ALLOW_STATUS "vendor.ril.data.allow.status"
+
+#define RIL_STUB_TEST_SWTICH_RTP_RECORD (1)
+extern int g_ril_test;
+
 //Warren add for plantform 2021_08_11 start
 /* 
 **The range of error values unique to LYNQ is 8000 to 10000.
diff --git a/src/lynq/framework/lynq-ril-service/src/ecall/eCall.cpp b/src/lynq/framework/lynq-ril-service/src/ecall/eCall.cpp
index 5d1ea71..7cffc64 100755
--- a/src/lynq/framework/lynq-ril-service/src/ecall/eCall.cpp
+++ b/src/lynq/framework/lynq-ril-service/src/ecall/eCall.cpp
@@ -70,7 +70,7 @@
 static ECALL_TYPE ecall_type = ECALL_TYPE::EN16454_ECALL;
 static bool inNeedRegister = false;
 static bool gostFastEcallFlg = false;
-static bool is_ecall_audio_path = false;
+static bool is_ecall_audio_path = true;
 
 int gost_sms_argc = 0;
 std::vector<std::string> gost_sms_argv;
@@ -187,19 +187,23 @@
 }
 
 void setEcallAudioPathOn(bool on) {
+#if 0
     RLOGD("%s() , is_ecall_audio_path: %d, on: %d", __FUNCTION__, is_ecall_audio_path, on);
 
     if((is_ecall_audio_path != on) && (isEcallAutoanswerTimerFinish())) {
         is_ecall_audio_path = on;
     }
     RLOGD("%s() , is_ecall_audio_path: %d", __FUNCTION__, is_ecall_audio_path);
+#endif
 }
 
+void setEcallAudioPathOn_New(bool on) {
+    is_ecall_audio_path = on;
+    RLOGD("%s() , set is_ecall_audio_path: %d, on: %d", __FUNCTION__, is_ecall_audio_path, on);
+}
+
+
 void autoAnswerEcall(bool on) {
-    RLOGD("%s() , is_ecall_audio_path: %d, on: %d", __FUNCTION__, is_ecall_audio_path, on);
-    if(is_ecall_audio_path != on) {
-        is_ecall_audio_path = on;
-    }
     if(on) {
         char* argv[2] = {"", "1"};
         autoAnswerCall(2, argv, RIL_SOCKET_ID(0), NULL); //unused socket id;
@@ -423,8 +427,7 @@
     }
     else if(sig.sival_int == redial_sig_value) {
         redial_tag = REDIAL_EXPIRES;
-        RequestInfo* pRI = creatRILInfoAndInit(RIL_REQUEST_ECALL_RESET_IVS, UDP,RIL_SOCKET_ID(fast_ecall_socket_id));
-        resetIVS(0, NULL, RIL_SOCKET_ID(fast_ecall_socket_id), pRI);
+          resetEcallIVSandAudio(UDP, RIL_SOCKET_ID(fast_ecall_socket_id));      
         fast_argc = 0;
         fast_argv.clear();
      
@@ -627,9 +630,9 @@
         stop_ecall_timer(sT6,sT6_sig_value);
         stop_ecall_timer(sT7,sT7_sig_value);
         stop_ecall_timer(sRedialTimer, redial_sig_value);
-		
+        
         redial_tag = REDIAL_SUCCESS;
-        resetEcallIVSandAudio(RSPD, soc_id);
+        resetEcallIVSandAudio(RSPD, RIL_SOCKET_ID(fast_ecall_socket_id));
         saveEcallRecord(p_cur->ind);
 
         act_fecall_socid = soc_id;
@@ -638,7 +641,7 @@
     }
     case RIL_UNSOL_ECALL_ALACK_CLEARDOWN_RECEIVED: // = 5,
     {
-	    fast_argc = 0;
+        fast_argc = 0;
         fast_argv.clear();
         stop_ecall_timer(sT2,sT2_sig_value);
         stop_ecall_timer(sT5,sT5_sig_value);
@@ -721,8 +724,7 @@
             stop_ecall_timer(sT6,sT6_sig_value);
             stop_ecall_timer(sT7,sT7_sig_value);
             ecall_test_sub_recover();
-            RequestInfo* pRI = creatRILInfoAndInit(RIL_REQUEST_ECALL_RESET_IVS, UDP, soc_id);
-            resetIVS(0, NULL, soc_id, pRI);
+            resetEcallIVSandAudio(UDP, soc_id);                 
             redialFastEcall(soc_id);
         }
         else {   /* redial_tag == REDIAL_SUCCESS || redial_tag == REDIAL_EXPIRES */
@@ -795,7 +797,7 @@
         redial_tag = REDIAL_SUCCESS;
         
         stop_ecall_timer(sAutoAnsTimer, autoAns_sig_value);
-        stop_ecall_timer(sAutoAnsTimer_ims, autoAns_sig_value_ims);		
+        stop_ecall_timer(sAutoAnsTimer_ims, autoAns_sig_value_ims);        
         autoAnswerEcall(false);  
 
         fast_argc = 0;
@@ -871,6 +873,14 @@
      free(pRI);
      return 0;
   }
+  else if(-300 < enable && enable<=-200)
+  {
+    g_ril_test=-enable-200;
+    android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,RIL_REQUEST_ECALL_SET_IVS,0,0);
+    android::LYNQ_RIL_respSocket_sp(p,pRI);
+    free(pRI);
+    return 0;
+  }
 
   if (getSpeechStatus() == SPEECH_OFF) {
     if (get_audio_path() == 0) {
@@ -1009,7 +1019,7 @@
 //RIL_REQUEST_ECALL_RESET_IVS
 int resetIVS(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI) {
   android::Parcel p;
-
+/*
   if (getSpeechStatus() == SPEECH_OFF) {
     if (get_audio_path() == 0) {
       setSpeechAndStatus(1);
@@ -1017,7 +1027,7 @@
       setSpeechAndStatus(2);
     }
   }
-
+*/
   //paramter none
   pRI->pCI->dispatchFunction(p, pRI);
   return 0;
diff --git a/src/lynq/framework/lynq-ril-service/src/ecall/eCall.h b/src/lynq/framework/lynq-ril-service/src/ecall/eCall.h
index 7c5e668..5c44eff 100755
--- a/src/lynq/framework/lynq-ril-service/src/ecall/eCall.h
+++ b/src/lynq/framework/lynq-ril-service/src/ecall/eCall.h
@@ -97,6 +97,7 @@
 void gostFastEcallFlgSet(bool flags);
 bool isEcallAudioPath();
 void setEcallAudioPathOn(bool on);
+void setEcallAudioPathOn_New(bool on);
 void init_redial_flag();
 #endif /*ECALL_SUPPORT*/
 #endif
diff --git a/src/lynq/framework/lynq-ril-service/src/lynq_interface.h b/src/lynq/framework/lynq-ril-service/src/lynq_interface.h
index 4a94b10..431154a 100755
--- a/src/lynq/framework/lynq-ril-service/src/lynq_interface.h
+++ b/src/lynq/framework/lynq-ril-service/src/lynq_interface.h
@@ -23,6 +23,19 @@
 #define LYNQ_REQUEST_OOS_DEEP_SLEEP_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +13)
 #define LYNQ_REQUEST_CHANGE_SCREEN_STATE (LYNQ_REQUEST_VENDOR_BASE + 14)/*jb.qi add for two sim suspend 2022/9/19*/
 #define LYNQ_REQUEST_CHANGE_RADIO (LYNQ_REQUEST_VENDOR_BASE + 15)
+#define LYNQ_REQUEST_SET_VOICE_AUDIO_MODE (LYNQ_REQUEST_VENDOR_BASE + 16)
+#define LYNQ_REQUEST_SET_REMOTE_RTP_IP (LYNQ_REQUEST_VENDOR_BASE + 17)
+#define LYNQ_REQUEST_SET_VLAN_INFO (LYNQ_REQUEST_VENDOR_BASE + 18)
+#define LYNQ_REQUEST_SET_RTP_PORT (LYNQ_REQUEST_VENDOR_BASE + 19)
+#define LYNQ_REQUEST_SET_RTP_PARAM (LYNQ_REQUEST_VENDOR_BASE + 20)
+#define LYNQ_REQUEST_GET_VOICE_AUDIO_MODE (LYNQ_REQUEST_VENDOR_BASE + 21)
+#define LYNQ_REQUEST_GET_REMOTE_RTP_IP (LYNQ_REQUEST_VENDOR_BASE + 22)
+#define LYNQ_REQUEST_GET_VLAN_INFO (LYNQ_REQUEST_VENDOR_BASE + 23)
+#define LYNQ_REQUEST_GET_RTP_PORT (LYNQ_REQUEST_VENDOR_BASE + 24)
+#define LYNQ_REQUEST_GET_RTP_PARAM (LYNQ_REQUEST_VENDOR_BASE + 25)
+#define LYNQ_REQUEST_SET_CALL_RTP_SSRC (LYNQ_REQUEST_VENDOR_BASE + 26)
+#define LYNQ_REQUEST_GET_CALL_RTP_SSRC (LYNQ_REQUEST_VENDOR_BASE + 27)
+
 #ifdef ECALL_SUPPORT
 #define RIL_UNSOL_ECALL_T2_TIMER_OUT  9000
 #define RIL_UNSOL_ECALL_T5_TIMER_OUT  9001
diff --git a/src/lynq/framework/lynq-ril-service/src/makefile b/src/lynq/framework/lynq-ril-service/src/makefile
index 7eaf082..b9cb52b 100755
--- a/src/lynq/framework/lynq-ril-service/src/makefile
+++ b/src/lynq/framework/lynq-ril-service/src/makefile
@@ -91,6 +91,7 @@
   -I$(LOCAL_PATH)/factory \
   -I$(LOCAL_PATH)/temp \
   -I$(LOCAL_PATH)/led/include \
+  -I$(LOCAL_PATH)/rtp \
   -I$(ROOT)$(includedir)/logger \
   -I$(ROOT)$(includedir)/liblog \
   -I$(ROOT)$(includedir)/liblynq-thermal \
@@ -148,7 +149,7 @@
 endif
 
 
-SOURCES = $(wildcard util/*.cpp *.cpp ecall/*.cpp ecall/gost/*.cpp ecall/gost/utils/*.cpp ecall/gost/sslp/*.cpp ecall/gost/sslp/auth/*.cpp ecall/gost/sslp/firmware/*.cpp ecall/gost/sslp/commands/*.cpp ecall/gost/sslp/ecall/*.cpp ecall/gost/sslp/teledata/*.cpp data/*.cpp  em/rfdesense/*.cpp em/networkinfo/*.cpp em/*.cpp sms/*.cpp sms/gsm/*.cpp sms/cdma/*.cpp atci/*.cpp stateManager/*.cpp sms/lynqSmsManager/*.cpp  rndis/*.cpp factory/*.cpp  temp/*.cpp led/*.cpp)
+SOURCES = $(wildcard util/*.cpp *.cpp ecall/*.cpp ecall/gost/*.cpp ecall/gost/utils/*.cpp ecall/gost/sslp/*.cpp ecall/gost/sslp/auth/*.cpp ecall/gost/sslp/firmware/*.cpp ecall/gost/sslp/commands/*.cpp ecall/gost/sslp/ecall/*.cpp ecall/gost/sslp/teledata/*.cpp data/*.cpp  em/rfdesense/*.cpp em/networkinfo/*.cpp em/*.cpp sms/*.cpp sms/gsm/*.cpp sms/cdma/*.cpp atci/*.cpp stateManager/*.cpp sms/lynqSmsManager/*.cpp  rndis/*.cpp factory/*.cpp  temp/*.cpp led/*.cpp rtp/*.cpp)
 
 EXECUTABLE = lynq-ril-service
 
diff --git a/src/lynq/framework/lynq-ril-service/src/ril.cpp b/src/lynq/framework/lynq-ril-service/src/ril.cpp
index 6bce06e..1233c90 100755
--- a/src/lynq/framework/lynq-ril-service/src/ril.cpp
+++ b/src/lynq/framework/lynq-ril-service/src/ril.cpp
@@ -94,6 +94,7 @@
 #include "led.h"
 #endif
 #include "lynq_shm.h"
+#include "call_rtp.h"
 
 #define LOG_TAG "DEMO_RIL"
 #define WAIT_TIME_FOR_SIM_SWITCH 30
@@ -5136,6 +5137,18 @@
         case LYNQ_REQUEST_SET_DEFAULT_SIM_ALL:return "SET_DEFAULT_SIM_ALL";
         case LYNQ_REQUEST_CHANGE_SCREEN_STATE:return "LYNQ_REQUEST_CHANGE_SCREEN_STATE";/*jb.qi add for two sim sleep 2022/9/19*/
         case LYNQ_REQUEST_CHANGE_RADIO:return "LYNQ_REQUEST_CHANGE_RADIO";/*lei add for factory test of sleep 2022/9/19*/
+        case LYNQ_REQUEST_SET_VOICE_AUDIO_MODE:return "LYNQ_REQUEST_SET_VOICE_AUDIO_MODE";
+        case LYNQ_REQUEST_SET_REMOTE_RTP_IP:return "LYNQ_REQUEST_SET_REMOTE_RTP_IP";
+        case LYNQ_REQUEST_SET_VLAN_INFO:return "LYNQ_REQUEST_SET_VLAN_INFO";
+        case LYNQ_REQUEST_SET_RTP_PORT:return "LYNQ_REQUEST_SET_RTP_PORT";
+        case LYNQ_REQUEST_SET_RTP_PARAM:return "LYNQ_REQUEST_SET_RTP_PARAM";
+        case LYNQ_REQUEST_GET_VOICE_AUDIO_MODE:return "LYNQ_REQUEST_GET_VOICE_AUDIO_MODE";
+        case LYNQ_REQUEST_GET_REMOTE_RTP_IP:return "LYNQ_REQUEST_GET_REMOTE_RTP_IP";
+        case LYNQ_REQUEST_GET_VLAN_INFO:return "LYNQ_REQUEST_GET_VLAN_INFO";
+        case LYNQ_REQUEST_GET_RTP_PORT:return "LYNQ_REQUEST_GET_RTP_PORT";
+        case LYNQ_REQUEST_GET_RTP_PARAM:return "LYNQ_REQUEST_GET_RTP_PARAM";
+        case LYNQ_REQUEST_SET_CALL_RTP_SSRC:return "LYNQ_REQUEST_SET_CALL_RTP_SSRC";
+        case LYNQ_REQUEST_GET_CALL_RTP_SSRC:return "LYNQ_REQUEST_GET_CALL_RTP_SSRC";
         /*warren add for t800 ril service 2022/1/22 end*/
         default: return "<unknown request>";
     }
@@ -5405,6 +5418,18 @@
         case LYNQ_REQUEST_SET_DEFAULT_SIM_ALL:return "SET_DEFAULT_SIM_ALL";
         case LYNQ_REQUEST_CHANGE_SCREEN_STATE:return "LYNQ_REQUEST_CHANGE_SCREEN_STATE";/*jb.qi add for two sim sleep 2022/9/19*/
         case LYNQ_REQUEST_CHANGE_RADIO:return "LYNQ_REQUEST_CHANGE_RADIO";/*lei add for factory test of sleep 2022/9/19*/
+        case LYNQ_REQUEST_SET_VOICE_AUDIO_MODE:return "LYNQ_REQUEST_SET_VOICE_AUDIO_MODE";
+        case LYNQ_REQUEST_SET_REMOTE_RTP_IP:return "LYNQ_REQUEST_SET_REMOTE_RTP_IP";
+        case LYNQ_REQUEST_SET_VLAN_INFO:return "LYNQ_REQUEST_SET_VLAN_INFO";
+        case LYNQ_REQUEST_SET_RTP_PORT:return "LYNQ_REQUEST_SET_RTP_PORT";
+        case LYNQ_REQUEST_SET_RTP_PARAM:return "LYNQ_REQUEST_SET_RTP_PARAM";
+        case LYNQ_REQUEST_GET_VOICE_AUDIO_MODE:return "LYNQ_REQUEST_GET_VOICE_AUDIO_MODE";
+        case LYNQ_REQUEST_GET_REMOTE_RTP_IP:return "LYNQ_REQUEST_GET_REMOTE_RTP_IP";
+        case LYNQ_REQUEST_GET_VLAN_INFO:return "LYNQ_REQUEST_GET_VLAN_INFO";
+        case LYNQ_REQUEST_GET_RTP_PORT:return "LYNQ_REQUEST_GET_RTP_PORT";
+        case LYNQ_REQUEST_GET_RTP_PARAM:return "LYNQ_REQUEST_GET_RTP_PARAM";
+        case LYNQ_REQUEST_SET_CALL_RTP_SSRC:return "LYNQ_REQUEST_SET_CALL_RTP_SSRC";
+        case LYNQ_REQUEST_GET_CALL_RTP_SSRC:return "LYNQ_REQUEST_GET_CALL_RTP_SSRC";
         /*warren add for t800 ril service 2022/1/22 end*/
         default: return "<unknown request>";
     }
@@ -5593,6 +5618,8 @@
     mbtk_netled_init();
 #endif
     mixer_init();
+    lynq_init_rtp();
+
     if(utils::is_support_dsds()) {
         for(int i = 0; i < 2 ; i++) {
             init(i);
@@ -5602,7 +5629,7 @@
     if(utils::is_suppport_dsss()) {
         int id = Phone_utils::get_enable_sim_for_dsss();
         init(id);
-    }	
+    }    
 }
 
 
diff --git a/src/lynq/framework/lynq-ril-service/src/rtp/call_rtp.cpp b/src/lynq/framework/lynq-ril-service/src/rtp/call_rtp.cpp
new file mode 100755
index 0000000..af38e3d
--- /dev/null
+++ b/src/lynq/framework/lynq-ril-service/src/rtp/call_rtp.cpp
@@ -0,0 +1,766 @@
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include "liblog/lynq_deflog.h"
+#include <sys/time.h>
+#include <string.h>
+//#include "lynq_call.h"
+//#include "lynq_module_common.h"
+//#include "lynq_call_common.h"
+#include "common.h"
+#include "call_rtp.h"
+#include "call_rtp_inner.h"
+#include "lynq_interface.h"
+#include "ecall/eCall.h"
+#include "cc.h"
+
+#undef LOG_TAG
+#define LOG_TAG "ECALL_RTP"
+
+static lynq_rtp_client_info g_rtp_client_info;
+static lynq_rtp_server_info g_rtp_server_info;
+
+static pthread_t g_rtp_thread[RTP_MODE_MAX];
+static bool g_rtp_thread_valid[RTP_MODE_MAX]={0};
+
+static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
+
+int lock_rtp_audio_mtx()
+{
+    return pthread_mutex_lock(&mtx);
+}
+
+int unlock_rtp_audio_mtx()
+{
+    return pthread_mutex_unlock(&mtx);
+}
+
+
+int set_voice_audio_mode(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{    
+    android::Parcel p;
+    int setValue = 0;
+
+    if(argc < 2) {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_VOICE_AUDIO_MODE,0,2);
+        android::LYNQ_RIL_respSocket_sp(p,pRI);
+        free(pRI);
+        RLOGW("%s fail! argc is %d",__FUNCTION__,argc);
+        return -1;
+    }
+
+    setValue = atoi(argv[1]);
+    RLOGD("%s %d start",__FUNCTION__,setValue);
+    if(setValue < AUDIO_MODE_CODEC || setValue > AUDIO_MODE_RTP ) {
+        RLOGW("Warning: parameter %d is over-range!",setValue);
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_VOICE_AUDIO_MODE,0,3);
+        android::LYNQ_RIL_respSocket_sp(p,pRI);
+        free(pRI);
+        return -1;
+    }
+
+    int s = lock_rtp_audio_mtx();
+    if(s != 0) {
+        RLOGE("%s lock_rtp_audio_mtx fail",__FUNCTION__);
+    }
+
+    int old_EcallAudioPath = isEcallAudioPath();
+
+    setEcallAudioPathOn_New(setValue==AUDIO_MODE_CODEC);     
+
+    if((get_call_status() == CALL_ON) && getSpeechStatus() == NORMAL_SPEECH_ON)        
+    {
+        if(isEcallAudioPath()!=old_EcallAudioPath)
+        {
+            RLOGD("%s, change mode in real time",__FUNCTION__);
+            if(exe_set_voice_audio_mode((isEcallAudioPath())? AUDIO_MODE_CODEC:AUDIO_MODE_RTP)!=RESULT_OK)
+            {
+                setEcallAudioPathOn_New(old_EcallAudioPath);                
+                s = unlock_rtp_audio_mtx();
+                if(s != 0) {
+                    RLOGE("%s, unlock_rtp_audio_mtx fail",__FUNCTION__);
+                }
+                
+                android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_VOICE_AUDIO_MODE,0,5);
+                android::LYNQ_RIL_respSocket(p,(void *)pRI);  
+                free(pRI);
+                return RESULT_ERROR; 
+            }
+        }        
+    }    
+
+    s = unlock_rtp_audio_mtx();
+    if(s != 0) {
+        RLOGE("%s, unlock_rtp_audio_mtx fail",__FUNCTION__);
+    }
+
+    android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_VOICE_AUDIO_MODE,0,0);
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);  
+    free(pRI);
+       RLOGD("%s %d finish",__FUNCTION__,setValue);
+    return RESULT_OK; 
+}
+
+int set_remote_rtp_ip(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    RLOGD("%s start!",__FUNCTION__);
+    android::Parcel p;
+
+    if(argc < 2) {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_REMOTE_RTP_IP,0,2);
+        android::LYNQ_RIL_respSocket_sp(p,pRI);
+        free(pRI);
+        RLOGW("Warning: no %s!",__FUNCTION__);
+        return -1;
+    } 
+
+    if(exe_set_remote_rtp_ip(argv[1],strlen(argv[1])+1)==RESULT_OK)
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_REMOTE_RTP_IP,0,0);
+        RLOGD(">>>>%s<<<< success value is %s!\n", __FUNCTION__, argv[1]);
+    }
+    else
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_REMOTE_RTP_IP,0,4);
+        RLOGD(">>>>%s <<<< failure value is %s!\n",__FUNCTION__, argv[1]);
+    }       
+
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);  
+    free(pRI);
+    return RESULT_OK; 
+}
+int set_vlan_info(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    RLOGD("%s start!",__FUNCTION__);
+    android::Parcel p;
+
+    if(argc < 2) 
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_VLAN_INFO,0,2);
+        android::LYNQ_RIL_respSocket_sp(p,pRI);
+        free(pRI);
+        RLOGW("Warning: no %s!",__FUNCTION__);
+        return -1;
+    } 
+
+    if(exe_set_vlan_info(argv[1],strlen(argv[1])+1)==RESULT_OK)
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_VLAN_INFO,0,0);
+        RLOGD(">>>>%s<<<< success value is %s!\n", __FUNCTION__, argv[1]);
+    }
+    else
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_VLAN_INFO,0,4);
+        RLOGE(">>>>%s <<<< failure value is %s!\n",__FUNCTION__, argv[1]);
+    }       
+
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);  
+    free(pRI);
+    return RESULT_OK; 
+}
+
+int set_rtp_port(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    RLOGD("%s start!",__FUNCTION__);
+    android::Parcel p;
+
+    if(argc < 3) 
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_RTP_PORT,0,2);
+        android::LYNQ_RIL_respSocket_sp(p,pRI);
+        free(pRI);
+        RLOGW("Warning: no %s!",__FUNCTION__);
+        return -1;
+    } 
+
+    if(exe_set_rtp_port((LYNQ_Rtp_Mode)(atoi(argv[1])),atoi(argv[2])==RESULT_OK))
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_RTP_PORT,0,0);
+        RLOGD(">>>>%s<<<< success value is %s %s!\n", __FUNCTION__, argv[1],argv[2]);
+    }
+    else
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_RTP_PORT,0,4);
+        RLOGE(">>>>%s <<<< failure value is %s %s!\n",__FUNCTION__, argv[1],argv[2]);
+    }
+
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);  
+    free(pRI);
+ 
+    return RESULT_OK; 
+}
+    
+
+int set_rtp_param(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    RLOGD("%s start!",__FUNCTION__);
+    android::Parcel p;
+
+    if(argc < 4) {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_RTP_PARAM,0,2);
+        android::LYNQ_RIL_respSocket_sp(p,pRI);
+        free(pRI);
+        RLOGW("Warning: no %s!",__FUNCTION__);
+        return -1;
+    } 
+
+    if(exe_set_rtp_param(atoi(argv[1]),atoi(argv[2]),atoi(argv[3])))
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_RTP_PARAM,0,0);
+        RLOGD(">>>>%s<<<< success value is %s %s %s!\n", __FUNCTION__, argv[1],argv[2],argv[3]);
+    }
+    else
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_RTP_PARAM,0,4);   
+        RLOGE(">>>>%s <<<< failure value is %s %s %s!\n",__FUNCTION__, argv[1],argv[2],argv[3]);
+    } 
+    
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);  
+    free(pRI);
+
+    return RESULT_OK; 
+}
+
+int set_call_rtp_ssrc(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    RLOGD("%s start!",__FUNCTION__);
+    android::Parcel p;
+
+    if(argc < 3) {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_CALL_RTP_SSRC,0,2);
+        android::LYNQ_RIL_respSocket_sp(p,pRI);
+        free(pRI);
+        RLOGW("Warning: no %s!",__FUNCTION__);
+        return -1;
+    } 
+
+    if(exe_set_call_rtp_ssrc(atoi(argv[1]),strtoul(argv[2],0,0))==RESULT_OK)
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_CALL_RTP_SSRC,0,0);
+        RLOGD(">>>>%s<<<< success value is %s %s!\n", __FUNCTION__, argv[1],argv[2]);
+    }
+    else
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_CALL_RTP_SSRC,0,4);
+        RLOGE(">>>>%s <<<< failure value is %s %s!\n",__FUNCTION__, argv[1],argv[2]);
+    } 
+    
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);  
+    free(pRI);
+
+    return RESULT_OK; 
+}
+
+
+int get_voice_audio_mode(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    android::Parcel p;
+    int mode = exe_get_voice_audio_mode();
+ 
+    android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_VOICE_AUDIO_MODE,0,0);
+   
+    p.writeInt32(mode);
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);
+    free(pRI);
+    return RESULT_OK;
+}
+
+int get_remote_rtp_ip(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    char rtp_ip[MAX_VLAN_INFO_LENGTH]={0};
+
+    android::Parcel p;
+    if(exe_get_remote_rtp_ip(rtp_ip,MAX_IP_LENGTH)==RESULT_OK)
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_REMOTE_RTP_IP,0,0);
+        p.writeInt32(1);
+        android::writeStringToParcel(p,rtp_ip);        
+    }
+    else 
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_REMOTE_RTP_IP,0,2);
+    } 
+   
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);
+    free(pRI);
+    return RESULT_OK;
+}
+
+int get_vlan_info(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    char vlan_info[MAX_VLAN_INFO_LENGTH]={0};
+
+    android::Parcel p;
+    if(exe_get_vlan_info(vlan_info,MAX_VLAN_INFO_LENGTH)==RESULT_OK)
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_VLAN_INFO,0,0);
+        p.writeInt32(1);
+        android::writeStringToParcel(p,vlan_info);        
+    }
+    else 
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_VLAN_INFO,0,2);
+    } 
+   
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);
+    free(pRI);
+    return RESULT_OK;
+}
+
+int get_rtp_port(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    int rtp_port;
+    android::Parcel p;
+
+    
+    if(argc < 2) {
+           android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_SET_RTP_PORT,0,2);
+           android::LYNQ_RIL_respSocket_sp(p,pRI);
+           free(pRI);
+           RLOGW("Warning: no %s!",__FUNCTION__);
+           return RESULT_ERROR;
+    } 
+    if(exe_get_rtp_port((LYNQ_Rtp_Mode) (atoi(argv[1])),&rtp_port)==RESULT_OK)
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_VLAN_INFO,0,0);
+        p.writeInt32(rtp_port);        
+    }
+    else 
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_VLAN_INFO,0,3);
+    } 
+   
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);
+    free(pRI);
+    return RESULT_OK;
+}
+
+int get_rtp_param(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    int clock_rate, channels, latency;
+    android::Parcel p;
+    
+    if(exe_get_rtp_param(&clock_rate, &channels, &latency)==RESULT_OK)
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_RTP_PARAM,0,0);
+        p.writeInt32(clock_rate);    
+        p.writeInt32(channels);    
+        p.writeInt32(latency);    
+    }
+    else 
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_RTP_PARAM,0,2);
+    } 
+   
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);
+    free(pRI);
+    return RESULT_OK;
+}
+
+int get_call_rtp_ssrc(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI)
+{
+    android::Parcel p;
+
+    int ssrc_mode;
+    unsigned int ssrc;
+    
+    if(exe_get_call_rtp_ssrc(&ssrc_mode, &ssrc)==RESULT_OK)
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_CALL_RTP_SSRC,0,0);
+        p.writeInt32(ssrc_mode);    
+        p.writeUint32(ssrc);            
+    }
+    else 
+    {
+        android::lynqAssemblyParcelheader(p,socket_id,pRI->uToken,LYNQ_REQUEST_GET_CALL_RTP_SSRC,0,2);
+    } 
+   
+    android::LYNQ_RIL_respSocket(p,(void *)pRI);
+    free(pRI);
+    return RESULT_OK;
+}
+
+
+void lynq_init_rtp()
+{   
+    memset(&g_rtp_client_info,0,sizeof(g_rtp_client_info));
+    memset(&g_rtp_server_info,0,sizeof(g_rtp_server_info));    
+  
+
+    exe_set_rtp_param(8000,1,400);
+
+    for(int i=0;i<RTP_MODE_MAX;i++)
+    {
+        exe_set_rtp_port((LYNQ_Rtp_Mode)i,6666);
+        g_rtp_thread_valid[i] = 0;
+    }          
+
+    exe_set_voice_audio_mode(AUDIO_MODE_INIT);
+    
+    RLOGD("lynq init rtp success!!!");
+    return;
+}
+
+/*Audio Path setting begin*/
+/*sub function*/
+void exe_set_rtp_mixer_ctrl(int audio_mode)
+{
+    char cmd[256];
+    RLOGD("set_rtp_mixer_ctrl, audio mode is %d", audio_mode);
+    if(audio_mode==AUDIO_MODE_RTP)
+    {
+        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on_ecall\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 1);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 1);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 1);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 1);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 1);
+        system(cmd);    
+    }
+    else if(audio_mode==AUDIO_MODE_CODEC)
+    {        
+        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 0);
+        system(cmd);    
+        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on_ecall\" %d", 1);
+        system(cmd);
+    }    
+    else 
+    {
+        if(audio_mode==AUDIO_MODE_INIT)
+        {
+            sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 0);
+            system(cmd);
+        }
+        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on_ecall\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 0);
+        system(cmd);
+        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 0);
+        system(cmd);    
+    }
+}
+
+static int record_count=0;
+void* exe_start_rtp_cmd(void *arg)
+{
+    int* rtp_mode= (int*) arg;
+    char cmd[384];
+    char vlan_para_string[sizeof(RTP_VLAN_INFO_FORMAT)+MAX_VLAN_INFO_LENGTH-2/*sizeof "%s"*/]={0};
+    char ssrc_para_string[sizeof(RTP_SSRC_INFO_FORMAT)+MAX_SSRC_INFO_LENGTH-2/*sizeof "%u"*/]={0};
+    RLOGD("exe_start_rtp_cmd: rtp_mode is %d",(*rtp_mode));    
+    if ((*rtp_mode) == RTP_CLIENT)
+    {
+         if(g_ril_test==RIL_STUB_TEST_SWTICH_RTP_RECORD)
+         {
+             system("sleep 30");
+         }
+         else             
+         {
+              sprintf(cmd,RTP_FROM_CMD, \
+                    g_rtp_client_info.port,g_rtp_client_info.clockrate,g_rtp_client_info.channels, \
+                    g_rtp_client_info.latency);            
+              RLOGD("start from rtp play: cmd is %s",cmd);    
+              system(cmd);
+           }
+    }
+    else if ((*rtp_mode) == RTP_SERVER)
+    {
+        if(g_ril_test==RIL_STUB_TEST_SWTICH_RTP_RECORD)
+        {
+            const char* record_fmt="arecord -D hw:0,6 -c 2 -d 10 -r 32000 -f S16_LE --period-size=1280    --buffer-size=5120 /data/record_%d.wav";
+            sprintf(cmd,record_fmt,record_count);     
+            RLOGD("start to rtp play: cmd is %s",cmd);
+            record_count++;
+            system(cmd);        
+        }
+        else
+        {        
+            if(strlen(g_rtp_server_info.vlan_info)>0)
+            {
+               sprintf(vlan_para_string,RTP_VLAN_INFO_FORMAT,g_rtp_server_info.vlan_info);
+            }
+    
+            if(g_rtp_server_info.ssrc_mode == Rtp_Ssrc_specific)
+            {
+               sprintf(ssrc_para_string,RTP_SSRC_INFO_FORMAT,g_rtp_server_info.ssrc);
+            }
+            sprintf(cmd,RTP_TO_CMD,   \
+            ssrc_para_string, g_rtp_server_info.ip,vlan_para_string,g_rtp_server_info.port);       
+            
+            RLOGD("start to rtp play: cmd is %s",cmd);
+            system(cmd);    
+        }
+        
+    }
+    return NULL;
+}
+
+int exe_start_rtp_thread(int rtp_mode)
+{
+    int ret;
+    pthread_attr_t attr;
+    static int start_mode[RTP_MODE_MAX]={0,1};  
+
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    ret = pthread_create(&(g_rtp_thread[rtp_mode]),&attr,exe_start_rtp_cmd,&(start_mode[rtp_mode]));
+    if(ret != 0)
+    {
+        g_rtp_thread_valid[rtp_mode]=0;
+        RLOGE("rtp create %d pthread error, ret is %d",rtp_mode, ret);
+        return ret;
+    }
+    g_rtp_thread_valid[rtp_mode]=1;
+    return RESULT_OK;  
+}
+
+/*set*/
+int exe_set_voice_audio_mode(const LYNQ_Audio_Mode audio_mode)
+{
+    int ret;
+    int i;
+
+    RLOGD("%s %d",__FUNCTION__,audio_mode);
+    if(audio_mode==AUDIO_MODE_RTP)
+    {  
+        exe_set_rtp_mixer_ctrl(audio_mode);
+        for(i=0;i<RTP_MODE_MAX;i++)
+        {
+            if(!g_rtp_thread_valid[i])
+            {
+                if(exe_start_rtp_thread(i)!= 0)
+                {
+                    RLOGE("start rtp thread %d fail",i);
+                    break;
+                }
+                else 
+                {
+                    RLOGD("start rtp thread %d suc",i);        
+                }
+            }
+            else 
+            {
+                RLOGE("rtp thread %d needn't start",i); 
+            }
+        }
+        if(i!= RTP_MODE_MAX)            
+        {
+            RLOGD("%s %d fail",__FUNCTION__,audio_mode);
+            exe_set_voice_audio_mode(AUDIO_MODE_CODEC);
+            return RESULT_ERROR;
+        }              
+    }
+    else if(audio_mode==AUDIO_MODE_CODEC)
+    {
+        for(i=0;i<RTP_MODE_MAX;i++)
+        {
+            if(g_rtp_thread_valid[i]) 
+            {
+                 ret = pthread_cancel(g_rtp_thread[i]);
+                 RLOGD("pthread cancel rtp %d ret = %d",i,ret);
+                 ret = pthread_join(g_rtp_thread[i],NULL);
+                 RLOGD("pthread join rtp %d ret = %d",i,ret);
+                 g_rtp_thread_valid[i] = 0;
+            }
+            else 
+            {
+                RLOGD("rtp thread %d needn't stop",i);
+            }
+        }          
+        exe_set_rtp_mixer_ctrl(audio_mode);        
+    }
+    else // audio_mode==AUDIO_MODE_ALL_CLOSE /AUDIO_MODE_INIT
+    {        
+        for(i=0;i<RTP_MODE_MAX;i++)
+        {
+            if(g_rtp_thread_valid[i]) 
+            {
+                 ret = pthread_cancel(g_rtp_thread[i]);
+                 RLOGD("pthread cancel rtp %d ret = %d",i,ret);
+                 ret = pthread_join(g_rtp_thread[i],NULL);
+                 RLOGD("pthread join rtp %d ret = %d",i,ret);
+                 g_rtp_thread_valid[i] = 0;
+            }
+            else 
+            {
+                RLOGD("rtp thread %d needn't stop",i);
+            }
+        }    
+        exe_set_rtp_mixer_ctrl(audio_mode);           
+    }
+    RLOGD("%s %d suc",__FUNCTION__,audio_mode);
+    return RESULT_OK;    
+}
+int exe_set_remote_rtp_ip(const char* ip, const int ip_length)
+{
+    if (NULL == ip)
+    {
+        RLOGE("ip is NULL!!!");
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+    if ((ip_length < strlen(ip)+1) || (ip_length > MAX_IP_LENGTH))
+    {
+        RLOGE("incoming ip length error %d", ip_length);
+        return LYNQ_E_PARAMETER_ANONALY;
+    }    
+
+    bzero(g_rtp_server_info.ip,MAX_IP_LENGTH);
+    strcpy(g_rtp_server_info.ip,ip);
+    
+    RLOGD("exe_set_remote_rtp_ip suc: ip is %s, length is %d", ip,ip_length);
+    
+    return RESULT_OK;  
+}
+int exe_set_vlan_info(const char* vlan_info, const int vlan_info_length)
+{
+    if (NULL == vlan_info)
+    {
+        RLOGE("vlan_info is NULL!!!");
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+    
+    if ((vlan_info_length < strlen(vlan_info)+1) || (vlan_info_length > MAX_VLAN_INFO_LENGTH))
+    {
+        RLOGE("incoming vlan_info error, vlan info length %d", vlan_info_length);
+        return LYNQ_E_PARAMETER_ANONALY;
+    }    
+
+    
+    bzero(g_rtp_server_info.vlan_info,MAX_VLAN_INFO_LENGTH);
+    strcpy(g_rtp_server_info.vlan_info,vlan_info);
+   
+    RLOGD("exe_set_vlan_info suc: vlan is %s, length is %d", vlan_info,vlan_info_length);
+    
+    return RESULT_OK;  
+}
+int exe_set_rtp_port(const LYNQ_Rtp_Mode rtp_mode, const int port)
+{  
+    if (port < 0)
+    {
+        RLOGE("invalid port number %d", port);
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+    if (rtp_mode == 0)
+    {
+        g_rtp_client_info.port = port;
+    }
+    else if (rtp_mode == 1)
+    {
+        g_rtp_server_info.port = port;
+    }
+    RLOGD("exe_set_rtp_port suc: LYNQ_Rtp_Mode is %d, port is %d", rtp_mode, port);
+    return RESULT_OK;  
+}
+int exe_set_rtp_param(const int clock_rate,const int channels,const int latency) //only for client mode
+{
+    g_rtp_client_info.clockrate = clock_rate;
+    g_rtp_client_info.channels = channels;
+    g_rtp_client_info.latency = latency;
+    RLOGD("exe_set_rtp_param suc: clockrate is %d, channels is %d, latency is %d", clock_rate, channels, latency);
+    return RESULT_OK;  
+}
+int exe_set_call_rtp_ssrc(const int ssrc_mode,const unsigned int ssrc)
+{
+    if(ssrc_mode < Rtp_Ssrc_random || ssrc_mode > Rtp_Ssrc_specific)
+    {
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+    g_rtp_server_info.ssrc_mode = ssrc_mode;
+    g_rtp_server_info.ssrc = ssrc ;
+    RLOGD("%s suc: param is %d %u", __func__, ssrc_mode, ssrc);
+    return RESULT_OK;
+}
+/*get*/
+LYNQ_Audio_Mode exe_get_voice_audio_mode()
+{
+    if(g_rtp_thread_valid[0])
+    {
+        return AUDIO_MODE_RTP;
+    }
+    else 
+    {
+        return AUDIO_MODE_CODEC;
+    }
+}
+int exe_get_remote_rtp_ip(char* ip, const int ip_length)
+{
+    if(ip_length < strlen(g_rtp_server_info.ip)+1)
+    {
+        RLOGE("ip length %d is shorter than saved ip length %d",ip_length,strlen(g_rtp_server_info.ip)+1);
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+    
+    bzero(ip,ip_length);
+    strcpy(ip,g_rtp_server_info.ip);
+    
+    return RESULT_OK;  
+}
+int exe_get_vlan_info(char* vlan_info, const int vlan_info_length)
+{
+    if(vlan_info_length < strlen(g_rtp_server_info.vlan_info)+1)
+    {
+        RLOGE("vlan info length %d is shorter than saved vlan info length %d",vlan_info_length,strlen(g_rtp_server_info.vlan_info)+1);
+        return LYNQ_E_PARAMETER_ANONALY;
+    }
+   
+    bzero(vlan_info,vlan_info_length);
+    strcpy(vlan_info,g_rtp_server_info.vlan_info);        
+   
+    return RESULT_OK;  
+}
+int exe_get_rtp_port(const LYNQ_Rtp_Mode rtp_mode, int* port)
+{    
+    if (rtp_mode == 0)
+    {
+        *port = g_rtp_client_info.port;
+    }
+    else if (rtp_mode == 1)
+    {
+        *port = g_rtp_server_info.port;
+    }
+    return RESULT_OK;  
+}
+int exe_get_rtp_param(int* clock_rate, int* channels, int* latency)//only for client mode
+{
+    *clock_rate = g_rtp_client_info.clockrate;
+    *channels = g_rtp_client_info.channels ;
+    *latency = g_rtp_client_info.latency;
+
+    return RESULT_OK;  
+}
+int exe_get_call_rtp_ssrc(int* ssrc_mode, unsigned int* ssrc)
+{   
+    *ssrc_mode = g_rtp_server_info.ssrc_mode;
+    *ssrc = g_rtp_server_info.ssrc ;   
+    
+    return RESULT_OK;
+}
diff --git a/src/lynq/framework/lynq-ril-service/src/rtp/call_rtp.h b/src/lynq/framework/lynq-ril-service/src/rtp/call_rtp.h
new file mode 100755
index 0000000..093d5ea
--- /dev/null
+++ b/src/lynq/framework/lynq-ril-service/src/rtp/call_rtp.h
@@ -0,0 +1,30 @@
+#ifndef CALL_RTP_H
+#define CALL_RTP 1
+
+void lynq_init_rtp();
+int set_voice_audio_mode(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int set_remote_rtp_ip(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int set_vlan_info(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int set_rtp_port(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int set_rtp_param(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int set_call_rtp_ssrc(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int get_voice_audio_mode(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int get_remote_rtp_ip(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int get_vlan_info(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int get_rtp_port(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int get_rtp_param(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+int get_call_rtp_ssrc(int argc, char **argv, RIL_SOCKET_ID socket_id, RequestInfo *pRI);
+
+
+typedef enum{
+    AUDIO_MODE_CODEC = 0,     /* Codec */
+    AUDIO_MODE_RTP,      /* RTP */   
+    AUDIO_MODE_INIT,
+    AUDIO_MODE_ALL_CLOSE,
+}LYNQ_Audio_Mode;
+int exe_set_voice_audio_mode(const LYNQ_Audio_Mode audio_mode);
+
+int lock_rtp_audio_mtx();
+int unlock_rtp_audio_mtx();
+
+#endif
diff --git a/src/lynq/framework/lynq-ril-service/src/rtp/call_rtp_inner.h b/src/lynq/framework/lynq-ril-service/src/rtp/call_rtp_inner.h
new file mode 100755
index 0000000..7e5614f
--- /dev/null
+++ b/src/lynq/framework/lynq-ril-service/src/rtp/call_rtp_inner.h
@@ -0,0 +1,69 @@
+#ifndef CALL_RTP_INNER_H
+#define CALL_RTP_INNER_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MAX_IP_LENGTH 128
+#define MAX_VLAN_INFO_LENGTH 32
+#define MAX_SSRC_INFO_LENGTH 10   /*2^32=4294967296, 10 digit*/
+
+typedef enum{
+    RTP_CLIENT = 0,     
+    RTP_SERVER =1,
+    RTP_MODE_MAX
+}LYNQ_Rtp_Mode;
+
+#define RTP_FROM_CMD "gst-launch-1.0 -v udpsrc port=%d caps=\'application/x-rtp, media=(string)audio, clock-rate=(int)%d, channels=(int)%d\' ! rtpjitterbuffer latency=%d ! rtppcmadepay ! alawdec ! alsasink device=\'hw:0,2\'"
+#define RTP_TO_CMD   "gst-launch-1.0 -v alsasrc device=\'hw:0,6\' ! alawenc ! rtppcmapay ! %s udpsink host=%s %s auto-multicast=true port=%d"
+#define RTP_VLAN_INFO_FORMAT "multicast-iface=\"%s\""
+#define RTP_SSRC_INFO_FORMAT " rtpmux name=mux ssrc=%u !"
+
+#define USER_LOG_TAG "LYNQ_CALL"
+
+#define RESULT_OK (0)
+#define RESULT_ERROR (-1)
+#define LYNQ_E_PARAMETER_ANONALY 7000
+
+typedef enum{
+    Rtp_Ssrc_random = 0,     
+    Rtp_Ssrc_specific =1,   
+}LYNQ_Rtp_Ssrc_Mode;
+
+typedef struct
+{   
+    char ip[MAX_IP_LENGTH];
+    int port;   
+    int ssrc_mode;
+    unsigned int ssrc;
+    char vlan_info[MAX_VLAN_INFO_LENGTH];
+}lynq_rtp_server_info;
+
+typedef struct
+{       
+    int port;
+    int clockrate;  
+    int latency;
+    int channels;
+}lynq_rtp_client_info;
+
+/*set*/
+int exe_set_remote_rtp_ip(const char* ip, const int ip_length);
+int exe_set_vlan_info(const char* vlan_info, const int vlan_info_length);
+int exe_set_rtp_port(const LYNQ_Rtp_Mode rtp_mode, const int port);
+int exe_set_rtp_param(const int clock_rate,const int channels,const int latency); //only for client
+int exe_set_call_rtp_ssrc(const int ssrc_mode, const unsigned int ssrc);
+/*get*/
+LYNQ_Audio_Mode exe_get_voice_audio_mode();
+int exe_get_remote_rtp_ip(char* ip, const int ip_length);
+int exe_get_vlan_info(char* vlan_info, const int vlan_info_length);
+int exe_get_rtp_port(const LYNQ_Rtp_Mode rtp_mode, int* port);
+int exe_get_rtp_param(int* clock_rate,int* channels, int* latency);//only for client
+int exe_get_call_rtp_ssrc(int* ssrc_mod, unsigned int* ssrc);
+/*Audio Path setting end*/
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h b/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
index 21de03b..00f8f4c 100755
--- a/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
+++ b/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
@@ -151,7 +151,7 @@
 
 typedef enum{
     Rtp_Ssrc_random = 0,     
-    RTP_Ssrc_specific =1,   
+    Rtp_Ssrc_specific =1,   
 }LYNQ_Rtp_Ssrc_Mode;
 
 /*set*/
@@ -163,12 +163,12 @@
 int lynq_set_call_rtp_ssrc(const LYNQ_Rtp_Ssrc_Mode ssrc_mode, const unsigned int ssrc);
 
 /*get*/
-LYNQ_Audio_Mode lynq_get_voice_audio_mode();
+int lynq_get_voice_audio_mode(int* voice_audio_mode);
 int lynq_get_remote_rtp_ip(char* ip, const int ip_length);
 int lynq_get_vlan_info(char* vlan_info, const int vlan_info_length);
 int lynq_get_rtp_port(const LYNQ_Rtp_Mode rtp_mode, int* port);
 int lynq_get_rtp_param(int* clock_rate,int* channels, int* latency);//only for client
-int lynq_get_call_rtp_ssrc(LYNQ_Rtp_Ssrc_Mode* ssrc_mod, unsigned int* ssrc);
+int lynq_get_call_rtp_ssrc(int* ssrc_mod, unsigned int* ssrc);
 /*Audio Path setting end*/
 
 void lynq_set_test_mode(const int test_mode);
diff --git a/src/lynq/lib/liblynq-call/lynq_call.cpp b/src/lynq/lib/liblynq-call/lynq_call.cpp
index d973bc7..65ce400 100755
--- a/src/lynq/lib/liblynq-call/lynq_call.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call.cpp
@@ -797,8 +797,6 @@
         return LYNQ_E_INNER_ERROR;
     }      
 
-    lynq_init_rtp();
-
     g_module_init_flag = MODULE_RUNNING;
     return 0;
 }
@@ -810,8 +808,7 @@
        LYERRLOG("module state is %d",g_module_init_flag);
        return LYNQ_E_CONFLICT;
     }      
-    lynq_call_hungup_all();  
-    lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
+    lynq_call_hungup_all();      
     g_module_init_flag = MODULE_SWITCHING;
     lynq_close_all_urc_socket_thread();
     lynq_close_all_rc_socket_thread();    
diff --git a/src/lynq/lib/liblynq-call/lynq_call_common.h b/src/lynq/lib/liblynq-call/lynq_call_common.h
index 21077df..e65f243 100755
--- a/src/lynq/lib/liblynq-call/lynq_call_common.h
+++ b/src/lynq/lib/liblynq-call/lynq_call_common.h
@@ -19,5 +19,5 @@
 void urc_ecall_msg_process(Parcel *p);
 #endif
 
-void lynq_init_rtp();
+int lynq_get_common_request(int request_id, int* status);
 #endif
diff --git a/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp b/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp
index b012907..3471245 100755
--- a/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp
@@ -483,7 +483,7 @@
     }
     if(enable<0)
     {
-       if(enable >-200)
+       if(enable >-300)
        {
            goto set_ivs_end;
 //         lynq_set_common_request(RIL_REQUEST_ECALL_SET_IVS,1,"%d",enable);
@@ -494,7 +494,7 @@
        } 
        else
        {
-           s_ecall_whether_preempt= ((-200-enable) & 0x11);           
+           s_ecall_whether_preempt= ((-300-enable) & 0x11);           
        }
        return RESULT_OK;   
     }
diff --git a/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp b/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp
index 9e0d546..ae3c536 100755
--- a/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp
@@ -17,208 +17,51 @@
 #include "lynq_call.h"
 #include "lynq_module_common.h"
 #include "lynq_call_common.h"
-
-#define RTP_FROM_CMD "gst-launch-1.0 -v udpsrc port=%d caps=\'application/x-rtp, media=(string)audio, clock-rate=(int)%d, channels=(int)%d\' ! rtpjitterbuffer latency=%d ! rtppcmadepay ! alawdec ! audioresample ! audioconvert ! alsasink device=\'hw:0,2\'"
-#define RTP_TO_CMD   "gst-launch-1.0 -v alsasrc device=\'hw:0,6\' ! audioconvert ! audioresample ! alawenc ! rtppcmapay ! %s udpsink host=%s %s auto-multicast=true port=%d"
-#define RTP_VLAN_INFO_FORMAT "multicast-iface=\"%s\""
-#define RTP_SSRC_INFO_FORMAT " rtpmux name=mux ssrc=%u !"
+#include "lynq_module_socket.h"
 
 #define USER_LOG_TAG "LYNQ_CALL"
 
-typedef struct
-{   
-    char ip[MAX_IP_LENGTH];
-    int port;   
-    LYNQ_Rtp_Ssrc_Mode ssrc_mode;
-    unsigned int ssrc;
-    char vlan_info[MAX_VLAN_INFO_LENGTH];
-}lynq_rtp_server_info;
+#define MAX_IP_LENGTH 128
+#define MAX_VLAN_INFO_LENGTH 128
 
-typedef struct
-{       
-    int port;
-    int clockrate;  
-    int latency;
-    int channels;
-}lynq_rtp_client_info;
 
-static lynq_rtp_client_info g_rtp_client_info;
-static lynq_rtp_server_info g_rtp_server_info;
+static char * lynqStrdupReadString(Parcel* &p) {
+    size_t stringlen;
+    const char16_t *s16;
 
-static pthread_t g_rtp_thread[RTP_MODE_MAX];
-static bool g_rtp_thread_valid[RTP_MODE_MAX];
-
-void lynq_init_rtp()
-{   
-    memset(&g_rtp_client_info,0,sizeof(g_rtp_client_info));
-    memset(&g_rtp_server_info,0,sizeof(g_rtp_server_info));    
-  
-
-    lynq_set_rtp_param(8000,1,400);
-
-    for(int i=0;i<RTP_MODE_MAX;i++)
-    {
-        lynq_set_rtp_port(i,6666);
-        g_rtp_thread_valid[i] = 0;
-    }          
-    
-    LYDBGLOG("lynq init rtp success!!!");
-    return;
-}
-
-/*Audio Path setting begin*/
-/*sub function*/
-void lynq_set_rtp_mixer_ctrl(int enable_rtp)
-{
-    char cmd[256];
-    LYINFLOG("set_rtp_mixer_ctrl %d", enable_rtp);
-    if(enable_rtp)
-    {
-        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 1);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 1);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 1);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 1);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 1);
-        system(cmd);    
-    }
-    else 
-    {        
-        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 0);
-        system(cmd);
-        sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 0);
-        system(cmd);    
-        sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 1);
-        system(cmd);
-    }    
-}
-
-void* lynq_start_rtp_cmd(void *arg)
-{
-    int* rtp_mode= (int*) arg;
-    char cmd[384];
-    char vlan_para_string[sizeof(RTP_VLAN_INFO_FORMAT)+MAX_VLAN_INFO_LENGTH-2/*sizeof "%s"*/]={0};
-    char ssrc_para_string[sizeof(RTP_SSRC_INFO_FORMAT)+MAX_SSRC_INFO_LENGTH-2/*sizeof "%u"*/]={0};
-    LYINFLOG("lynq_start_rtp_cmd: rtp_mode is %d",(*rtp_mode));    
-    if ((*rtp_mode) == RTP_CLIENT)
-    {
-        sprintf(cmd,RTP_FROM_CMD, \
-            g_rtp_client_info.port,g_rtp_client_info.clockrate,g_rtp_client_info.channels, \
-            g_rtp_client_info.latency);            
-    //  LYINFLOG("start from rtp play: cmd is %s",cmd);    
-        system(cmd);
-    }
-    else if ((*rtp_mode) == RTP_SERVER)
-    {
-        if(strlen(g_rtp_server_info.vlan_info)>0)
-        {
-           sprintf(vlan_para_string,RTP_VLAN_INFO_FORMAT,g_rtp_server_info.vlan_info);
-        }
-
-        if(g_rtp_server_info.ssrc_mode == RTP_Ssrc_specific)
-        {
-           sprintf(ssrc_para_string,RTP_SSRC_INFO_FORMAT,g_rtp_server_info.ssrc);
-        }
-        sprintf(cmd,RTP_TO_CMD,   \
-        ssrc_para_string, g_rtp_server_info.ip,vlan_para_string,g_rtp_server_info.port);       
-        
-        LYINFLOG("start to rtp play: cmd is %s",cmd);
-        system(cmd);    
-    }
-    return NULL;
-}
-
-int lynq_start_rtp_thread(int rtp_mode)
-{
-    int ret;
-    pthread_attr_t attr;
-    static int start_mode[RTP_MODE_MAX]={0,1};  
-
-    pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-    ret = pthread_create(&(g_rtp_thread[rtp_mode]),&attr,lynq_start_rtp_cmd,&(start_mode[rtp_mode]));
-    if(ret != 0)
-    {
-        g_rtp_thread_valid[rtp_mode]=0;
-        LYERRLOG("rtp create %d pthread error, ret is %d",rtp_mode, ret);
-        return ret;
-    }
-    g_rtp_thread_valid[rtp_mode]=1;
-    return RESULT_OK;  
+    s16 = p->readString16Inplace(&stringlen);
+    return strndup16to8(s16, stringlen);
 }
 
 /*set*/
 int lynq_set_voice_audio_mode(const LYNQ_Audio_Mode audio_mode)
 {
-    int ret;
-    int i;
-    
-    if(audio_mode==AUDIO_MODE_RTP)
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        lynq_set_rtp_mixer_ctrl(1);
-        for(i=0;i<RTP_MODE_MAX;i++)
-        {
-            if(!g_rtp_thread_valid[i])
-            {
-                if(lynq_start_rtp_thread(i)!= 0)
-                {
-                    LYERRLOG("start rtp %d fail",i);
-                    break;
-                }
-                else 
-                {
-                    LYINFLOG("start rtp %d suc",i);        
-                }
-            }
-            else 
-            {
-                LYERRLOG("rtp %d needn't start",i); 
-            }
-        }
-        if(i!= RTP_MODE_MAX)            
-        {
-            LYERRLOG("start rtp whole fail");
-            lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
-            return RESULT_ERROR;
-        }
-        LYINFLOG("start rtp whole suc");          
-        return RESULT_OK;  
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
-    else if(audio_mode==AUDIO_MODE_CODEC)
+    if(audio_mode > AUDIO_MODE_RTP || audio_mode < AUDIO_MODE_CODEC)
     {
-         for(i=0;i<RTP_MODE_MAX;i++)
-        {
-            if(g_rtp_thread_valid[i]) 
-            {
-                 ret = pthread_cancel(g_rtp_thread[i]);
-                 LYINFLOG("pthread cancel rtp %d ret = %d",i,ret);
-                 ret = pthread_join(g_rtp_thread[i],NULL);
-                 LYINFLOG("pthread join rtp %d ret = %d",i,ret);
-                 g_rtp_thread_valid[i] = 0;
-            }
-            else 
-            {
-                LYINFLOG("rtp %d needn't stop",i);
-            }
-        }
-        lynq_set_rtp_mixer_ctrl(0);     
-        LYINFLOG("stop rtp suc");
+        return LYNQ_E_PARAMETER_ANONALY;
     }
-    return RESULT_OK;    
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_VOICE_AUDIO_MODE,1,"%d",audio_mode);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
 }
+
 int lynq_set_remote_rtp_ip(const char* ip, const int ip_length)
 {
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
     if (NULL == ip)
     {
         LYERRLOG("ip is NULL!!!");
@@ -230,15 +73,22 @@
         return LYNQ_E_PARAMETER_ANONALY;
     }    
 
-    bzero(g_rtp_server_info.ip,MAX_IP_LENGTH);
-    strcpy(g_rtp_server_info.ip,ip);
-    
-    LYINFLOG("lynq_set_remote_rtp_ip suc: ip is %s, length is %d", ip,ip_length);
-    
-    return RESULT_OK;  
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_REMOTE_RTP_IP,1,"%s",ip);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
 }
 int lynq_set_vlan_info(const char* vlan_info, const int vlan_info_length)
 {
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+
     if (NULL == vlan_info)
     {
         LYERRLOG("vlan_info is NULL!!!");
@@ -251,141 +101,258 @@
         return LYNQ_E_PARAMETER_ANONALY;
     }    
 
-    
-    bzero(g_rtp_server_info.vlan_info,MAX_VLAN_INFO_LENGTH);
-    strcpy(g_rtp_server_info.vlan_info,vlan_info);
-   
-    LYINFLOG("lynq_set_vlan_info suc: vlan is %s, length is %d", vlan_info,vlan_info_length);
-    
-    return RESULT_OK;  
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_VLAN_INFO,1,"%s",vlan_info);
+    if(ret==RESULT_OK)
+    {
+        delete p;        
+    }
+    return ret;
 }
 int lynq_set_rtp_port(const LYNQ_Rtp_Mode rtp_mode, const int port)
 {  
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+
     if (port < 0)
     {
         LYERRLOG("invalid port number %d", port);
         return LYNQ_E_PARAMETER_ANONALY;
     }
-    if (rtp_mode == 0)
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_RTP_PORT,2,"%d %d",rtp_mode,port);
+    if(ret==RESULT_OK)
     {
-        g_rtp_client_info.port = port;
+        delete p;        
     }
-    else if (rtp_mode == 1)
-    {
-        g_rtp_server_info.port = port;
-    }
-    LYINFLOG("lynq_set_rtp_port suc: LYNQ_Rtp_Mode is %d, port is %d", rtp_mode, port);
-    return RESULT_OK;  
+    return ret;
 }
 int lynq_set_rtp_param(const int clock_rate,const int channels,const int latency) //only for client mode
 {
-    g_rtp_client_info.clockrate = clock_rate;
-    g_rtp_client_info.channels = channels;
-    g_rtp_client_info.latency = latency;
-    LYINFLOG("lynq_set_rtp_param suc: clockrate is %d, channels is %d, latency is %d", clock_rate, channels, latency);
-    return RESULT_OK;  
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_RTP_PARAM,3,"%d %d %d",clock_rate,channels,latency);
+    if(ret==RESULT_OK)
+    {
+        delete p;         
+    }
+    return ret;
 }
+
 int lynq_set_call_rtp_ssrc(const LYNQ_Rtp_Ssrc_Mode ssrc_mode,const unsigned int ssrc)
 {
-    if(ssrc_mode < Rtp_Ssrc_random || ssrc_mode > RTP_Ssrc_specific)
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+
+    if(ssrc_mode < Rtp_Ssrc_random || ssrc_mode > Rtp_Ssrc_specific)
     {
         return LYNQ_E_PARAMETER_ANONALY;
     }
-    g_rtp_server_info.ssrc_mode = ssrc_mode;
-    g_rtp_server_info.ssrc = ssrc ;
-    LYINFLOG("%s suc: param is %d %d", __func__, ssrc_mode, ssrc);
-    return RESULT_OK;
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_CALL_RTP_SSRC,2,"%d %u",ssrc_mode,ssrc);
+    if(ret==RESULT_OK)
+    {
+        delete p;         
+    }
+    return ret;      
 }
 /*get*/
-LYNQ_Audio_Mode lynq_get_voice_audio_mode()
+int lynq_get_voice_audio_mode(int* voice_audio_mode)
 {
-    if(g_rtp_thread_valid[0])
+    if(g_module_init_flag != MODULE_RUNNING)
     {
-        return AUDIO_MODE_RTP;
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
     }
-    else 
-    {
-        return AUDIO_MODE_CODEC;
-    }
+    
+    return lynq_get_common_request(LYNQ_REQUEST_GET_VOICE_AUDIO_MODE,voice_audio_mode);
 }
 int lynq_get_remote_rtp_ip(char* ip, const int ip_length)
 {
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+
     if(ip==NULL)
     {
         LYERRLOG("ip is NULL");
         return LYNQ_E_PARAMETER_ANONALY;
     }    
 
-    if(ip_length < strlen(g_rtp_server_info.ip)+1)
+    if(ip_length > MAX_IP_LENGTH)
     {
-        LYERRLOG("ip length %d is shorter than saved ip length %d",ip_length,strlen(g_rtp_server_info.ip)+1);
+        LYERRLOG("ip length %d is greater than max ip length %d",ip_length,MAX_IP_LENGTH);
         return LYNQ_E_PARAMETER_ANONALY;
+    }    
+   
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_GET_REMOTE_RTP_IP,0,"");
+
+    if(ret!=RESULT_OK)
+    {
+        LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+        return ret;  
+    }       
+ 
+    int num ;
+    char *resp;
+
+    p->readInt32(&num);
+    if(num != 1)
+    {
+        LYERRLOG("no paramters or num %d too great",num);        
+        delete p;      
+        return LYNQ_E_INNER_ERROR;    
+    }else{
+        resp = lynqStrdupReadString(p);
+        strcpy(ip,resp);
+        free(resp);                             
     }
-    
-    bzero(ip,ip_length);
-    strcpy(ip,g_rtp_server_info.ip);
-    
-    return RESULT_OK;  
+
+    LYINFLOG("%s suc",__func__);   
+    delete p;       
+    return RESULT_OK;    
 }
 int lynq_get_vlan_info(char* vlan_info, const int vlan_info_length)
 {
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+
     if(vlan_info==NULL) 
     {
         LYERRLOG("vlan info is NULL");
         return LYNQ_E_PARAMETER_ANONALY;
     }
 
-    if(vlan_info_length < strlen(g_rtp_server_info.vlan_info)+1)
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_GET_VLAN_INFO,0,"");
+
+    if(ret!=RESULT_OK)
     {
-        LYERRLOG("vlan info length %d is shorter than saved vlan info length %d",vlan_info_length,strlen(g_rtp_server_info.vlan_info)+1);
-        return LYNQ_E_PARAMETER_ANONALY;
+        LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+        return ret;  
+    }       
+    
+    int num ;
+    char *resp;
+
+    p->readInt32(&num);
+    if(num != 1)
+    {
+        LYERRLOG("no paramters or num %d too great",num);        
+        delete p;      
+        return LYNQ_E_INNER_ERROR;    
+    }else{
+        resp = lynqStrdupReadString(p);
+        strcpy(vlan_info,resp);
+        free(resp);                             
     }
-   
-    bzero(vlan_info,vlan_info_length);
-    strcpy(vlan_info,g_rtp_server_info.vlan_info);        
-   
-    return RESULT_OK;  
+
+    LYINFLOG("%s suc",__func__);   
+    delete p;       
+    return RESULT_OK;    
 }
+
 int lynq_get_rtp_port(const LYNQ_Rtp_Mode rtp_mode, int* port)
 {
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+
     if(port==NULL)
     {
         return LYNQ_E_PARAMETER_ANONALY;
     }   
-    if (rtp_mode == 0)
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_GET_RTP_PORT,1,"%d",rtp_mode);
+    if(ret==RESULT_OK)
     {
-        *port = g_rtp_client_info.port;
+        p->readInt32(port);
+        delete p;        
     }
-    else if (rtp_mode == 1)
-    {
-        *port = g_rtp_server_info.port;
-    }
-    return RESULT_OK;  
+    return ret;       
 }
 int lynq_get_rtp_param(int* clock_rate, int* channels, int* latency)//only for client mode
 {
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+
     if(clock_rate == NULL || channels ==NULL || latency ==NULL)
     {
         LYERRLOG("input parameter is NULL");
         return LYNQ_E_PARAMETER_ANONALY;
     }
 
-    *clock_rate = g_rtp_client_info.clockrate;
-    *channels = g_rtp_client_info.channels ;
-    *latency = g_rtp_client_info.latency;
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_GET_RTP_PARAM,0,"");
 
-    return RESULT_OK;  
+    if(ret!=RESULT_OK)
+    {
+        LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+        return ret;  
+    }           
+
+    p->readInt32(clock_rate);
+    p->readInt32(channels);
+    p->readInt32(latency);    
+
+    LYINFLOG("%s suc",__func__);   
+    delete p;       
+    return RESULT_OK;       
 }
-int lynq_get_call_rtp_ssrc(LYNQ_Rtp_Ssrc_Mode* ssrc_mode, unsigned int* ssrc)
+
+int lynq_get_call_rtp_ssrc(int* ssrc_mode, unsigned int* ssrc)
 {
+    if(g_module_init_flag != MODULE_RUNNING)
+    {
+        LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+        return LYNQ_E_CONFLICT;
+    }
+
     if(ssrc_mode == NULL || ssrc ==NULL)
     {
         LYERRLOG("input parameter is NULL");
         return LYNQ_E_PARAMETER_ANONALY;
     }
-    
-    *ssrc_mode = g_rtp_server_info.ssrc_mode;
-    *ssrc = g_rtp_server_info.ssrc ;   
-    
-    return RESULT_OK;
+
+    Parcel* p=NULL;
+    int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_GET_CALL_RTP_SSRC,0,"");
+
+    if(ret!=RESULT_OK)
+    {
+        LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+        return ret;  
+    }           
+
+    p->readInt32(ssrc_mode);
+    p->readUint32(ssrc); 
+
+    LYINFLOG("%s suc",__func__);   
+    delete p;       
+    return RESULT_OK;                
 }
diff --git a/src/lynq/lib/liblynq-call/lynq_module_common.h b/src/lynq/lib/liblynq-call/lynq_module_common.h
index 590971a..1143b8c 100755
--- a/src/lynq/lib/liblynq-call/lynq_module_common.h
+++ b/src/lynq/lib/liblynq-call/lynq_module_common.h
@@ -30,6 +30,20 @@
 #define LYNQ_REQUEST_OOS_DEEP_SLEEP_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +13)
 #define LYNQ_REQUEST_CHANGE_SCREEN_STATE (LYNQ_REQUEST_VENDOR_BASE + 14)/*jb.qi add for two sim suspend 2022/9/19*/
 #define LYNQ_REQUEST_CHANGE_RADIO (LYNQ_REQUEST_VENDOR_BASE + 15)
+#define LYNQ_REQUEST_SET_VOICE_AUDIO_MODE (LYNQ_REQUEST_VENDOR_BASE + 16)
+#define LYNQ_REQUEST_SET_REMOTE_RTP_IP (LYNQ_REQUEST_VENDOR_BASE + 17)
+#define LYNQ_REQUEST_SET_VLAN_INFO (LYNQ_REQUEST_VENDOR_BASE + 18)
+#define LYNQ_REQUEST_SET_RTP_PORT (LYNQ_REQUEST_VENDOR_BASE + 19)
+#define LYNQ_REQUEST_SET_RTP_PARAM (LYNQ_REQUEST_VENDOR_BASE + 20)
+#define LYNQ_REQUEST_GET_VOICE_AUDIO_MODE (LYNQ_REQUEST_VENDOR_BASE + 21)
+#define LYNQ_REQUEST_GET_REMOTE_RTP_IP (LYNQ_REQUEST_VENDOR_BASE + 22)
+#define LYNQ_REQUEST_GET_VLAN_INFO (LYNQ_REQUEST_VENDOR_BASE + 23)
+#define LYNQ_REQUEST_GET_RTP_PORT (LYNQ_REQUEST_VENDOR_BASE + 24)
+#define LYNQ_REQUEST_GET_RTP_PARAM (LYNQ_REQUEST_VENDOR_BASE + 25)
+#define LYNQ_REQUEST_SET_CALL_RTP_SSRC (LYNQ_REQUEST_VENDOR_BASE + 26)
+#define LYNQ_REQUEST_GET_CALL_RTP_SSRC (LYNQ_REQUEST_VENDOR_BASE + 27)
+
+
 /*the same with lynq_interface.h end*/
 
 typedef enum{
diff --git a/src/lynq/lib/liblynq-call/lynq_module_socket.cpp b/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
index ff45c02..378d7a9 100755
--- a/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
@@ -320,7 +320,7 @@
     int res = 0;
     lynq_head_t* phead;
     int level,index,size;
-	uint8_t * shm_buffer;
+    uint8_t * shm_buffer;
    
     LYINFLOG("urc recv thread is running");
     while(module_urc_status)
@@ -1007,6 +1007,18 @@
         case LYNQ_REQUEST_SET_DEFAULT_SIM_ALL:return "SET_DEFAULT_SIM_ALL";
         case LYNQ_REQUEST_CHANGE_SCREEN_STATE:return "LYNQ_REQUEST_CHANGE_SCREEN_STATE";/*jb.qi add for two sim sleep 2022/9/19*/
         case LYNQ_REQUEST_CHANGE_RADIO:return "LYNQ_REQUEST_CHANGE_RADIO";/*lei add for factory test of sleep 2022/9/19*/
+        case LYNQ_REQUEST_SET_VOICE_AUDIO_MODE:return "LYNQ_REQUEST_SET_VOICE_AUDIO_MODE";
+        case LYNQ_REQUEST_SET_REMOTE_RTP_IP:return "LYNQ_REQUEST_SET_REMOTE_RTP_IP";
+        case LYNQ_REQUEST_SET_VLAN_INFO:return "LYNQ_REQUEST_SET_VLAN_INFO";
+        case LYNQ_REQUEST_SET_RTP_PORT:return "LYNQ_REQUEST_SET_RTP_PORT";
+        case LYNQ_REQUEST_SET_RTP_PARAM:return "LYNQ_REQUEST_SET_RTP_PARAM";
+        case LYNQ_REQUEST_GET_VOICE_AUDIO_MODE:return "LYNQ_REQUEST_GET_VOICE_AUDIO_MODE";
+        case LYNQ_REQUEST_GET_REMOTE_RTP_IP:return "LYNQ_REQUEST_GET_REMOTE_RTP_IP";
+        case LYNQ_REQUEST_GET_VLAN_INFO:return "LYNQ_REQUEST_GET_VLAN_INFO";
+        case LYNQ_REQUEST_GET_RTP_PORT:return "LYNQ_REQUEST_GET_RTP_PORT";
+        case LYNQ_REQUEST_GET_RTP_PARAM:return "LYNQ_REQUEST_GET_RTP_PARAM";
+        case LYNQ_REQUEST_SET_CALL_RTP_SSRC:return "LYNQ_REQUEST_SET_CALL_RTP_SSRC";
+        case LYNQ_REQUEST_GET_CALL_RTP_SSRC:return "LYNQ_REQUEST_GET_CALL_RTP_SSRC";
         /*warren add for t800 ril service 2022/1/22 end*/
         default: return "<unknown request>";
     }
diff --git a/src/multimedia/audio-misc/audio-ctrl-service/audio_big_sw/audio-ctrl-service.c b/src/multimedia/audio-misc/audio-ctrl-service/audio_big_sw/audio-ctrl-service.c
old mode 100644
new mode 100755
index a510514..6ae29eb
--- a/src/multimedia/audio-misc/audio-ctrl-service/audio_big_sw/audio-ctrl-service.c
+++ b/src/multimedia/audio-misc/audio-ctrl-service/audio_big_sw/audio-ctrl-service.c
@@ -691,7 +691,7 @@
     if (ret) {
         return ret;
     }
-
+    updateVolume(XML_SPEECH_VOLUME);
     return 0;
 }
 
@@ -711,7 +711,7 @@
 
     g_is_speech_on = enable;
     input_device = AUDIO_DEVICE_IN_BUILTIN_MIC;
-    g_current_output_device = AUDIO_DEVICE_OUT_SPEAKER;
+    g_current_output_device = AUDIO_DEVICE_OUT_TBOX_HANDSFREE;
 
     do {
         if (enable || !g_record_buf) {
diff --git a/src/multimedia/libspeech_drv/audio_big_sw/AudioSpeechEnhancement/ENH_Parser/SpeechParser.cpp b/src/multimedia/libspeech_drv/audio_big_sw/AudioSpeechEnhancement/ENH_Parser/SpeechParser.cpp
old mode 100644
new mode 100755
index 1aa2980..e2574c2
--- a/src/multimedia/libspeech_drv/audio_big_sw/AudioSpeechEnhancement/ENH_Parser/SpeechParser.cpp
+++ b/src/multimedia/libspeech_drv/audio_big_sw/AudioSpeechEnhancement/ENH_Parser/SpeechParser.cpp
@@ -50,7 +50,8 @@
         "Tty_HCO_Handset",
         "Tty_HCO_Handsfree",
         "Tty_VCO_Handset",
-        "Tty_VCO_Handsfree"
+        "Tty_VCO_Handsfree",
+        "TBOX_Handsfree"
     };
 
     //--------------------------------------------------------------------------------
@@ -577,6 +578,10 @@
                 idxSphProfile = PARSER_SPEECH_PROFILE_USB_HEADSET;
                 break;
 
+            case AUDIO_DEVICE_OUT_TBOX_HANDSFREE:
+                idxSphProfile = PARSER_SPEECH_PROFILE_TBOX_HANDSFREE;
+                break;
+
             default:
                 if (getFeatureOn(SPEECH_FEATURE_HAC, speechParserAttribute.speechFeatureOn)) {
                     idxSphProfile = PARSER_SPEECH_PROFILE_HAC;
diff --git a/src/multimedia/libspeech_drv/audio_big_sw/AudioSpeechEnhancement/ENH_Parser/SpeechParser.h b/src/multimedia/libspeech_drv/audio_big_sw/AudioSpeechEnhancement/ENH_Parser/SpeechParser.h
old mode 100644
new mode 100755
index c0a7649..a374a08
--- a/src/multimedia/libspeech_drv/audio_big_sw/AudioSpeechEnhancement/ENH_Parser/SpeechParser.h
+++ b/src/multimedia/libspeech_drv/audio_big_sw/AudioSpeechEnhancement/ENH_Parser/SpeechParser.h
@@ -153,8 +153,9 @@
         PARSER_SPEECH_PROFILE_TTY_HCO_HANDSFREE = 17,
         PARSER_SPEECH_PROFILE_TTY_VCO_HANDSET = 18,
         PARSER_SPEECH_PROFILE_TTY_VCO_HANDSFREE = 19,
+        PARSER_SPEECH_PROFILE_TBOX_HANDSFREE = 20,
 
-        PARSER_SPEECH_PROFILE_MAX_NUM = 20
+        PARSER_SPEECH_PROFILE_MAX_NUM = 21
     };
 
     typedef struct _PARSER_SPEECH_PARAM_SUPPORT_STRUCT {
diff --git a/src/multimedia/libspeech_drv/audio_big_sw/hardware/src/AudioALSAGainController.cpp b/src/multimedia/libspeech_drv/audio_big_sw/hardware/src/AudioALSAGainController.cpp
old mode 100644
new mode 100755
index b0c0477..3dd7b9d
--- a/src/multimedia/libspeech_drv/audio_big_sw/hardware/src/AudioALSAGainController.cpp
+++ b/src/multimedia/libspeech_drv/audio_big_sw/hardware/src/AudioALSAGainController.cpp
@@ -357,7 +357,7 @@
         // get gain device
         GAIN_DEVICE gainDevice = GAIN_DEVICE_NONE;
         gainDevice = getGainDevice(devices);
-
+        ALOGD("%s(), gainDevice = %d", __FUNCTION__, gainDevice);
         // set digital gain
         //setAMPGain(ampgain, AMP_CONTROL_POINT, device);
         uint8_t digitalDegradeDb = mGainTable.nonSceneGain.speechGain[mBand][mNetwork][gainDevice][index].digital;
@@ -406,7 +406,13 @@
             gainDevice = GAIN_DEVICE_SPEAKER;
     } else {
         /* output device */
+        if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
             gainDevice = GAIN_DEVICE_SPEAKER;
+        } else if (devices & AUDIO_DEVICE_OUT_TBOX_HANDSFREE) {
+            gainDevice = GAIN_DEVICE_SPEAKER_TBOX;
+        } else {
+            gainDevice = GAIN_DEVICE_SPEAKER;
+        }
     }
 
     //ALOGG("%s(), input devices = 0x%x, return gainDevice = %d", __FUNCTION__, devices, gainDevice);
diff --git a/src/multimedia/libspeech_drv/audio_big_sw/os/system/audio-base-utils.h b/src/multimedia/libspeech_drv/audio_big_sw/os/system/audio-base-utils.h
old mode 100644
new mode 100755
index 5d44423..9b3c373
--- a/src/multimedia/libspeech_drv/audio_big_sw/os/system/audio-base-utils.h
+++ b/src/multimedia/libspeech_drv/audio_big_sw/os/system/audio-base-utils.h
@@ -119,6 +119,7 @@
                                 AUDIO_DEVICE_OUT_USB_HEADSET |
                                 AUDIO_DEVICE_OUT_HEARING_AID |
                                 AUDIO_DEVICE_OUT_ECHO_CANCELLER |
+                                AUDIO_DEVICE_OUT_TBOX_HANDSFREE |
                                 AUDIO_DEVICE_OUT_DEFAULT,
 
     AUDIO_DEVICE_OUT_ALL_A2DP = AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
diff --git a/src/multimedia/libspeech_drv/audio_big_sw/os/system/audio-base.h b/src/multimedia/libspeech_drv/audio_big_sw/os/system/audio-base.h
old mode 100644
new mode 100755
index 7121af6..e9f08b0
--- a/src/multimedia/libspeech_drv/audio_big_sw/os/system/audio-base.h
+++ b/src/multimedia/libspeech_drv/audio_big_sw/os/system/audio-base.h
@@ -322,6 +322,7 @@
     AUDIO_DEVICE_OUT_USB_HEADSET               = 0x4000000u,
     AUDIO_DEVICE_OUT_HEARING_AID               = 0x8000000u,
     AUDIO_DEVICE_OUT_ECHO_CANCELLER            = 0x10000000u,
+    AUDIO_DEVICE_OUT_TBOX_HANDSFREE            = 0x20000000u,
     AUDIO_DEVICE_OUT_DEFAULT                   = 0x40000000u, // BIT_DEFAULT
 
     AUDIO_DEVICE_IN_COMMUNICATION              = 0x80000001u, // BIT_IN | 0x1