add VAD

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@1222 d0543943-73ff-0310-b7d9-9358b9ac24b2

diff --git a/conf/freeswitch.conf b/conf/freeswitch.conf
index e4af9cb8a755e81c1e2076ad9e411c51c1310340..f94f5864c26dad278a9b607dc77503dddd41a9cc 100644 (file)
--- a/conf/freeswitch.conf
+++ b/conf/freeswitch.conf
@@ -123,6 +123,10 @@ rtp-ip => guess
 ; exosip/!myrealm!1000@dest
 ;srtp:myrealm => ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 
+; VAD choose one (out is a good choice);
+; vad => in
+; vad => out
+; vad => both
 
 ;---- WOOMERA PROTOCOL
 ;--------------------------------------------------------------------------------
@@ -262,3 +266,8 @@ codec_prefs => PCMU
  ;rtp-ip => my_lan_ip
  ;ext-rtp-ip => stun:stun.server.com
  exten => 1000
+
+; VAD choose one
+; vad => in
+; vad => out
+; vad => both

diff --git a/src/include/switch_caller.h b/src/include/switch_caller.h
index 9eaba7d92fd44fb992d73ffa6ce739e0e18512c2..f9ff50762e61cee12ce2a23fb780a55e1c229354 100644 (file)
--- a/src/include/switch_caller.h
+++ b/src/include/switch_caller.h
@@ -77,8 +77,12 @@ struct switch_caller_profile {
        char *ani;
        /*! ANI II (when applicable) */
        char *ani2;
+       /*! RDNIS */
+       char *rdnis;
        /*! Destination Number */
        char *destination_number;
+       /*! channel type */
+       char *source;
        /*! channel name */
        char *chan_name;
        /*! unique id */
@@ -154,6 +158,8 @@ SWITCH_DECLARE(switch_caller_profile *) switch_caller_profile_new(switch_memory_
                                                                                                                                  char *network_addr,
                                                                                                                                  char *ani,
                                                                                                                                  char *ani2,
+                                                                                                                                 char *rdnis,
+                                                                                                                                 char *source,
                                                                                                                                  char *destination_number);
 
 /*!

diff --git a/src/include/switch_rtp.h b/src/include/switch_rtp.h
index 762e5b9802164f1deeb597009a39366c56a71a3d..3215cfd7584c0784bc91038e4630b19ea93959bc 100644 (file)
--- a/src/include/switch_rtp.h
+++ b/src/include/switch_rtp.h
@@ -263,6 +263,23 @@ SWITCH_DECLARE(switch_status) switch_rtp_zerocopy_read_frame(switch_rtp *rtp_ses
 */
 SWITCH_DECLARE(int) switch_rtp_write(switch_rtp *rtp_session, void *data, uint32_t datalen, uint32_t ts, switch_frame_flag *flags);
 
+/*!
+  \brief Enable VAD on an RTP Session
+  \param rtp_session the RTP session
+  \param session the core session associated with the RTP session
+  \param codec the codec the channel is currenty using
+  \param flags flags for control
+  \return SWITCH_STAUTS_SUCCESS on success
+*/
+SWITCH_DECLARE(switch_status) switch_rtp_enable_vad(switch_rtp *rtp_session, switch_core_session *session, switch_codec *codec, switch_vad_flag_t flags);
+
+/*!
+  \brief Disable VAD on an RTP Session
+  \param rtp_session the RTP session
+  \return SWITCH_STAUTS_SUCCESS on success
+*/
+SWITCH_DECLARE(switch_status) switch_rtp_disable_vad(switch_rtp *rtp_session);
+
 /*! 
   \brief Write data to a given RTP session
   \param rtp_session the RTP session to write to

diff --git a/src/include/switch_types.h b/src/include/switch_types.h
index 125a0e8bb2d0d0d485d3e8e0a49126a62164a0e0..701a50c7175362c25ebeb8b87ed432491758fbd4 100644 (file)
--- a/src/include/switch_types.h
+++ b/src/include/switch_types.h
@@ -94,27 +94,47 @@ SWITCH_DECLARE_DATA extern switch_directories SWITCH_GLOBAL_dirs;
 #define SWITCH_TRUE 1
 #define SWITCH_FALSE 0
 
+/*!
+  \enum switch_vad_flags
+  \brief RTP Related Flags
+<pre>
+    SWITCH_VAD_FLAG_TALKING         - Currently Talking
+    SWITCH_VAD_FLAG_EVENTS_TALK     - Fire events when talking is detected
+       SWITCH_VAD_FLAG_EVENTS_NOTALK   - Fire events when not talking is detected
+</pre>
+ */
+typedef enum {
+       SWITCH_VAD_FLAG_TALKING = ( 1 << 0 ),
+       SWITCH_VAD_FLAG_EVENTS_TALK = ( 1 << 1 ),
+       SWITCH_VAD_FLAG_EVENTS_NOTALK = ( 1 << 2 ),
+} switch_vad_flag_t;
+
+
 /*!
   \enum switch_rtp_flag_t
   \brief RTP Related Flags
 <pre>
-    SWITCH_RTP_FLAG_NOBLOCK      - Do not block
-    SWITCH_RTP_FLAG_IO           - IO is ready
-       SWITCH_RTP_FLAG_USE_TIMER    - Timeout Reads and replace with a CNG Frame
-       SWITCH_RTP_FLAG_SECURE       - Secure RTP
-       SWITCH_RTP_FLAG_AUTOADJ      - Auto-Adjust the dest based on the source
-       SWITCH_RTP_FLAG_RAW_WRITE    - Try to forward packets unscathed
-       SWITCH_RTP_FLAG_GOOGLEHACK   - Convert payload from 102 to 97
+    SWITCH_RTP_FLAG_NOBLOCK       - Do not block
+    SWITCH_RTP_FLAG_IO            - IO is ready
+       SWITCH_RTP_FLAG_USE_TIMER     - Timeout Reads and replace with a CNG Frame
+       SWITCH_RTP_FLAG_TIMER_RECLOCK - Resync the timer to the current clock on slips
+       SWITCH_RTP_FLAG_SECURE        - Secure RTP
+       SWITCH_RTP_FLAG_AUTOADJ       - Auto-Adjust the dest based on the source
+       SWITCH_RTP_FLAG_RAW_WRITE     - Try to forward packets unscathed
+       SWITCH_RTP_FLAG_GOOGLEHACK    - Convert payload from 102 to 97
+       SWITCH_RTP_FLAG_VAD           - Enable VAD
 </pre>
  */
 typedef enum {
        SWITCH_RTP_FLAG_NOBLOCK = ( 1 << 0),
        SWITCH_RTP_FLAG_IO = (1 << 1),
        SWITCH_RTP_FLAG_USE_TIMER = (1 << 2),
-       SWITCH_RTP_FLAG_SECURE = (1 << 3),
-       SWITCH_RTP_FLAG_AUTOADJ = (1 << 4),
-       SWITCH_RTP_FLAG_RAW_WRITE = (1 << 5),
-       SWITCH_RTP_FLAG_GOOGLEHACK = (1 << 6)
+       SWITCH_RTP_FLAG_TIMER_RECLOCK = (1 << 3),
+       SWITCH_RTP_FLAG_SECURE = (1 << 4),
+       SWITCH_RTP_FLAG_AUTOADJ = (1 << 5),
+       SWITCH_RTP_FLAG_RAW_WRITE = (1 << 6),
+       SWITCH_RTP_FLAG_GOOGLEHACK = (1 << 7),
+       SWITCH_RTP_FLAG_VAD = (1 << 8)
 } switch_rtp_flag_t;
 
 /*!
@@ -484,6 +504,8 @@ typedef enum {
     SWITCH_EVENT_SHUTDOWN                      - The system has been shutdown
        SWITCH_EVENT_PUBLISH                    - Publish
        SWITCH_EVENT_UNPUBLISH                  - UnPublish
+       SWITCH_EVENT_TALK                               - Talking Detected
+       SWITCH_EVENT_NOTALK                             - Not Talking Detected
     SWITCH_EVENT_ALL                           - All events at once
 </pre>
 
@@ -505,6 +527,8 @@ typedef enum {
        SWITCH_EVENT_SHUTDOWN,
        SWITCH_EVENT_PUBLISH,
        SWITCH_EVENT_UNPUBLISH,
+       SWITCH_EVENT_TALK,
+       SWITCH_EVENT_NOTALK,
        SWITCH_EVENT_ALL
 } switch_event_t;
 

diff --git a/src/mod/applications/mod_bridgecall/mod_bridgecall.c b/src/mod/applications/mod_bridgecall/mod_bridgecall.c
index 157628033c2947b403b22914cad4eb8ad6b7dbf9..7f0ccde07fd3746b365a5fe3e6ba76eed374f6af 100644 (file)
--- a/src/mod/applications/mod_bridgecall/mod_bridgecall.c
+++ b/src/mod/applications/mod_bridgecall/mod_bridgecall.c
@@ -59,7 +59,12 @@ static void audio_bridge_function(switch_core_session *session, char *data)
                                                                                           caller_caller_profile->dialplan,
                                                                                           caller_caller_profile->caller_id_name,
                                                                                           caller_caller_profile->caller_id_number,
-                                                                                          caller_caller_profile->network_addr, NULL, NULL, chan_data);
+                                                                                          caller_caller_profile->network_addr, 
+                                                                                          NULL, 
+                                                                                          NULL, 
+                                                                                          caller_caller_profile->rdnis,
+                                                                                          caller_caller_profile->source,
+                                                                                          chan_data);
 
 
 

diff --git a/src/mod/dialplans/mod_pcre/mod_pcre.c b/src/mod/dialplans/mod_pcre/mod_pcre.c
index 6c0a6ff87df38b202c7f76d64a273df70cde7aed..a66985d8657d6bb066db535f515d0faa0c6faa22 100644 (file)
--- a/src/mod/dialplans/mod_pcre/mod_pcre.c
+++ b/src/mod/dialplans/mod_pcre/mod_pcre.c
@@ -82,6 +82,11 @@ static switch_caller_extension *dialplan_hunt(switch_core_session *session)
                                skip = 1;
                        } else if (!strcasecmp(exten_name, "inbound") && switch_channel_test_flag(channel, CF_OUTBOUND)) {
                                skip = 1;
+                       } else if (*exten_name == 's' && *(exten_name+1) == ':') {
+                               exten_name += 2;
+                               if (strcasecmp(exten_name, caller_profile->source)) {
+                                       skip = 1;
+                               }
                        }
                }
 

diff --git a/src/mod/endpoints/mod_dingaling/mod_dingaling.c b/src/mod/endpoints/mod_dingaling/mod_dingaling.c
index a162013ab2f5bc329e6e89fda4cbeebbd1da99c1..7815e947630c0653335aed429ac6f3c8d9995a26 100644 (file)
--- a/src/mod/endpoints/mod_dingaling/mod_dingaling.c
+++ b/src/mod/endpoints/mod_dingaling/mod_dingaling.c
@@ -51,6 +51,9 @@ typedef enum {
        TFLAG_CODEC_READY = (1 << 8),
        TFLAG_TRANSPORT = (1 << 9),
        TFLAG_ANSWER = (1 << 10),
+       TFLAG_VAD_IN = ( 1 << 11),
+       TFLAG_VAD_OUT = ( 1 << 12),
+       TFLAG_VAD = ( 1 << 13)
 } TFLAGS;
 
 typedef enum {
@@ -83,8 +86,8 @@ struct mdl_profile {
        char *extip;
        char *lanaddr;
        char *exten;
-       unsigned int flags;
        ldl_handle_t *handle;
+       unsigned int flags;
 };
 
 struct private_object {
@@ -282,9 +285,16 @@ static int activate_rtp(struct private_object *tech_pvt)
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "RTP ERROR %s\n", err);
                switch_channel_hangup(channel);
                return -1;
+       } else {
+               uint8_t vad_in = switch_test_flag(tech_pvt, TFLAG_VAD_IN) ? 1 : 0;
+               uint8_t vad_out = switch_test_flag(tech_pvt, TFLAG_VAD_OUT) ? 1 : 0;
+               uint8_t inb = switch_test_flag(tech_pvt, TFLAG_OUTBOUND) ? 0 : 1;
+               switch_rtp_activate_ice(tech_pvt->rtp_session, tech_pvt->remote_user, tech_pvt->local_user);
+               if ((vad_in && inb) || (vad_out && !inb)) {
+                       switch_rtp_enable_vad(tech_pvt->rtp_session, tech_pvt->session, &tech_pvt->read_codec, SWITCH_VAD_FLAG_TALKING);
+                       switch_set_flag(tech_pvt, TFLAG_VAD);
+               }
        }
-       switch_rtp_activate_ice(tech_pvt->rtp_session, tech_pvt->remote_user, tech_pvt->local_user);
-       
 
        return 0;
 }
@@ -1017,6 +1027,8 @@ static switch_status channel_outgoing_channel(switch_core_session *session, swit
                switch_core_session_add_stream(*new_session, NULL);
                if ((tech_pvt = (struct private_object *) switch_core_session_alloc(*new_session, sizeof(struct private_object))) != 0) {
                        memset(tech_pvt, 0, sizeof(*tech_pvt));
+                       tech_pvt->flags |= globals.flags;
+                       tech_pvt->flags |= mdl_profile->flags;
                        channel = switch_core_session_get_channel(*new_session);
                        switch_core_session_set_private(*new_session, tech_pvt);
                        tech_pvt->session = *new_session;
@@ -1167,6 +1179,7 @@ static switch_status load_config(void)
                                globals.codec_rates_last =
                                        switch_separate_string(globals.codec_rates_string, ',', globals.codec_rates, SWITCH_MAX_CODECS);
                        }
+
                } else if (!strcasecmp(cfg.category, "interface")) {
                        if (!globals.init) {
                                ldl_global_init(globals.debug);
@@ -1204,6 +1217,17 @@ static switch_status load_config(void)
                                profile->lanaddr = switch_core_strdup(module_pool, val);
                        } else if (!strcmp(var, "exten")) {
                                profile->exten = switch_core_strdup(module_pool, val);
+                       } else if (!strcmp(var, "vad")) {
+                               if (!strcasecmp(val, "in")) {
+                                       switch_set_flag(profile, TFLAG_VAD_IN);
+                               } else if (!strcasecmp(val, "out")) {
+                                       switch_set_flag(profile, TFLAG_VAD_OUT);
+                               } else if (!strcasecmp(val, "both")) {
+                                       switch_set_flag(profile, TFLAG_VAD_IN);
+                                       switch_set_flag(profile, TFLAG_VAD_OUT);
+                               } else {
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invald option %s for VAD\n", val);
+                               }
                        }
                }
        }
@@ -1262,6 +1286,8 @@ static ldl_status handle_signalling(ldl_handle_t *handle, ldl_session_t *dlsessi
                        switch_core_session_add_stream(session, NULL);
                        if ((tech_pvt = (struct private_object *) switch_core_session_alloc(session, sizeof(struct private_object))) != 0) {
                                memset(tech_pvt, 0, sizeof(*tech_pvt));
+                               tech_pvt->flags |= globals.flags;
+                               tech_pvt->flags |= profile->flags;
                                channel = switch_core_session_get_channel(session);
                                switch_core_session_set_private(session, tech_pvt);
                                tech_pvt->session = session;
@@ -1269,6 +1295,7 @@ static ldl_status handle_signalling(ldl_handle_t *handle, ldl_session_t *dlsessi
                                tech_pvt->profile = profile;
                                tech_pvt->local_port = switch_rtp_request_port();
                                switch_set_flag(tech_pvt, TFLAG_ANSWER);
+                               
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Hey where is my memory pool?\n");
                                switch_core_session_destroy(&session);
@@ -1284,6 +1311,8 @@ static ldl_status handle_signalling(ldl_handle_t *handle, ldl_session_t *dlsessi
                                                                                                                                          ldl_session_get_ip(dlsession),
                                                                                                                                          NULL,
                                                                                                                                          NULL,
+                                                                                                                                         NULL,
+                                                                                                                                         (char *)modname,
                                                                                                                                          profile->exten)) != 0) {
                                char name[128];
                                snprintf(name, sizeof(name), "DingaLing/%s-%04x", tech_pvt->caller_profile->destination_number,

diff --git a/src/mod/endpoints/mod_exosip/mod_exosip.c b/src/mod/endpoints/mod_exosip/mod_exosip.c
index d15bbd21541a93fb8ef03d8c84f8bf1f984f6427..501ead7ac773262d4b4e895865219d299ec0fc4a 100644 (file)
--- a/src/mod/endpoints/mod_exosip/mod_exosip.c
+++ b/src/mod/endpoints/mod_exosip/mod_exosip.c
@@ -67,8 +67,10 @@ typedef enum {
        TFLAG_BYE = (1 << 8),
        TFLAG_ANS = (1 << 9),
        TFLAG_EARLY_MEDIA = (1 << 10),
-       TFLAG_SECURE = (1 << 11)
-       
+       TFLAG_SECURE = (1 << 11),
+       TFLAG_VAD_IN = ( 1 << 12),
+       TFLAG_VAD_OUT = ( 1 << 13),
+       TFLAG_VAD = ( 1 << 14)
 } TFLAGS;
 
 
@@ -505,13 +507,22 @@ static switch_status activate_rtp(struct private_object *tech_pvt)
                                                                                   tech_pvt->read_codec.codec_interface->ianacode,
                                                                                   tech_pvt->read_codec.implementation->encoded_bytes_per_frame,
                                                                                   ms,
-                                                                                  SWITCH_RTP_FLAG_NOBLOCK | SWITCH_RTP_FLAG_RAW_WRITE,
+                                                                                  SWITCH_RTP_FLAG_USE_TIMER | SWITCH_RTP_FLAG_TIMER_RECLOCK | SWITCH_RTP_FLAG_RAW_WRITE,
                                                                                   key,
                                                                                   &err, switch_core_session_get_pool(tech_pvt->session));
 
        if (tech_pvt->rtp_session) {
+               uint8_t vad_in = switch_test_flag(tech_pvt, TFLAG_VAD_IN) ? 1 : 0;
+               uint8_t vad_out = switch_test_flag(tech_pvt, TFLAG_VAD_OUT) ? 1 : 0;
+               uint8_t inb = switch_test_flag(tech_pvt, TFLAG_OUTBOUND) ? 0 : 1;
+
                tech_pvt->ssrc = switch_rtp_get_ssrc(tech_pvt->rtp_session);
                switch_set_flag(tech_pvt, TFLAG_RTP);
+               
+               if ((vad_in && inb) || (vad_out && !inb)) {
+                       switch_rtp_enable_vad(tech_pvt->rtp_session, tech_pvt->session, &tech_pvt->read_codec, SWITCH_VAD_FLAG_TALKING);
+                       switch_set_flag(tech_pvt, TFLAG_VAD);
+               }
        } else {
                switch_channel *channel = switch_core_session_get_channel(tech_pvt->session);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "RTP REPORTS ERROR: [%s]\n", err);
@@ -965,6 +976,7 @@ static switch_status exosip_outgoing_channel(switch_core_session *session, switc
                if ((tech_pvt =
                         (struct private_object *) switch_core_session_alloc(*new_session, sizeof(struct private_object))) != 0) {
                        memset(tech_pvt, 0, sizeof(*tech_pvt));
+                       tech_pvt->flags = globals.flags;
                        channel = switch_core_session_get_channel(*new_session);
                        switch_core_session_set_private(*new_session, tech_pvt);
                        tech_pvt->session = *new_session;
@@ -1097,6 +1109,7 @@ static switch_status exosip_create_call(eXosip_event_t * event)
                switch_core_session_add_stream(session, NULL);
                if ((tech_pvt = (struct private_object *) switch_core_session_alloc(session, sizeof(struct private_object))) != 0) {
                        memset(tech_pvt, 0, sizeof(*tech_pvt));
+                       tech_pvt->flags = globals.flags;
                        channel = switch_core_session_get_channel(session);
                        switch_core_session_set_private(session, tech_pvt);
                        tech_pvt->session = session;
@@ -1113,8 +1126,6 @@ static switch_status exosip_create_call(eXosip_event_t * event)
                        tech_pvt->realm = switch_core_session_strdup(session, osip_header_get_value(tedious));
                }
 
-
-
                if (!(from = osip_message_get_from(event->request))) {
                        switch_core_session_destroy(&session);
             return SWITCH_STATUS_MEMERR;
@@ -1148,7 +1159,11 @@ static switch_status exosip_create_call(eXosip_event_t * event)
                                                                                                                                  displayname,
                                                                                                                                  username,
                                                                                                                                  event->request->from->url->host,
-                                                                                                                                 NULL, NULL, event->request->req_uri->username)) != 0) {
+                                                                                                                                 NULL,
+                                                                                                                                 NULL,
+                                                                                                                                 NULL,
+                                                                                                                                 (char *)modname,
+                                                                                                                                 event->request->req_uri->username)) != 0) {
                        switch_channel_set_caller_profile(channel, tech_pvt->caller_profile);
                }
 
@@ -1666,6 +1681,17 @@ static int config_exosip(int reload)
                                globals.debug = atoi(val);
                        } else if (!strcmp(var, "port")) {
                                globals.port = atoi(val);
+                       } else if (!strcmp(var, "vad")) {
+                               if (!strcasecmp(val, "in")) {
+                                       switch_set_flag(&globals, TFLAG_VAD_IN);
+                               } else if (!strcasecmp(val, "out")) {
+                                       switch_set_flag(&globals, TFLAG_VAD_OUT);
+                               } else if (!strcasecmp(val, "both")) {
+                                       switch_set_flag(&globals, TFLAG_VAD_IN);
+                                       switch_set_flag(&globals, TFLAG_VAD_OUT);
+                               } else {
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invald option %s for VAD\n", val);
+                               }
                        } else if (!strcmp(var, "ext-rtp-ip")) {
                                set_global_extrtpip(val);
                        } else if (!strcmp(var, "rtp-ip")) {

diff --git a/src/mod/endpoints/mod_iax/mod_iax.c b/src/mod/endpoints/mod_iax/mod_iax.c
index 29dcc54a8db6ec4e62d1bab34182b6d32814e483..d47b05dea47ad9329cd06918855223dbd2b30dc2 100644 (file)
--- a/src/mod/endpoints/mod_iax/mod_iax.c
+++ b/src/mod/endpoints/mod_iax/mod_iax.c
@@ -1001,7 +1001,10 @@ SWITCH_MOD_DECLARE(switch_status) switch_module_runtime(void)
                                                                                                                                                                  iaxevent->ies.calling_number,
                                                                                                                                                                  iax_get_peer_ip(iaxevent->session),
                                                                                                                                                                  iaxevent->ies.calling_ani,
-                                                                                                                                                                 NULL, iaxevent->ies.called_number)) != 0) {
+                                                                                                                                                                 NULL, 
+                                                                                                                                                                 NULL,
+                                                                                                                                                                 (char *)modname,
+                                                                                                                                                                 iaxevent->ies.called_number)) != 0) {
                                                        char name[128];
                                                        snprintf(name, sizeof(name), "IAX/%s-%04x", tech_pvt->caller_profile->destination_number,
                                                                         rand() & 0xffff);

diff --git a/src/mod/endpoints/mod_portaudio/mod_portaudio.c b/src/mod/endpoints/mod_portaudio/mod_portaudio.c
index 2df3814026ccdcad7fcc93d79ea675d0385a7ef1..2b6580bf87f2017f74bfa83e8e707e78c035406a 100644 (file)
--- a/src/mod/endpoints/mod_portaudio/mod_portaudio.c
+++ b/src/mod/endpoints/mod_portaudio/mod_portaudio.c
@@ -811,7 +811,7 @@ static switch_status place_call(char *dest, char *out, size_t outlen)
                if ((tech_pvt->caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session),
                                                                                                                                  globals.dialplan,
                                                                                                                                  globals.cid_name,
-                                                                                                                                 globals.cid_num, NULL, NULL, NULL, dest)) != 0) {
+                                                                                                                                 globals.cid_num, NULL, NULL, NULL, NULL, (char *)modname, dest)) != 0) {
                        char name[128];
                        snprintf(name, sizeof(name), "PortAudio/%s-%04x",
                                         tech_pvt->caller_profile->destination_number ? tech_pvt->caller_profile->

diff --git a/src/mod/endpoints/mod_wanpipe/mod_wanpipe.c b/src/mod/endpoints/mod_wanpipe/mod_wanpipe.c
index 0baf56d061ca6827664571db51819ff9c16de59a..7141fcbc9f7c6605eaa43920a0f428a5da6f7b96 100644 (file)
--- a/src/mod/endpoints/mod_wanpipe/mod_wanpipe.c
+++ b/src/mod/endpoints/mod_wanpipe/mod_wanpipe.c
@@ -1133,6 +1133,8 @@ static int on_ring(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri
                                                                                                                                  event->ring.callingani,
                                                                                                                                  switch_strlen_zero(ani2str) ? NULL : ani2str,
                                                                                                                                  NULL,
+                                                                                                                                 NULL,
+                                                                                                                                 (char *)modname,
                                                                                                                                  event->ring.callednum))) {
                        switch_channel_set_caller_profile(channel, tech_pvt->caller_profile);
                }

diff --git a/src/mod/endpoints/mod_woomera/mod_woomera.c b/src/mod/endpoints/mod_woomera/mod_woomera.c
index 383992602233b0785de3dff73c891d4a359d44ee..5aff61ed6b63be13311fe2f1ff62b7f32590367a 100644 (file)
--- a/src/mod/endpoints/mod_woomera/mod_woomera.c
+++ b/src/mod/endpoints/mod_woomera/mod_woomera.c
@@ -375,6 +375,7 @@ static switch_status woomerachan_read_frame(switch_core_session *session, switch
        switch_channel *channel = NULL;
        struct private_object *tech_pvt = NULL;
        switch_frame *pframe;
+       switch_size_t len;
 
        channel = switch_core_session_get_channel(session);
        assert(channel != NULL);
@@ -393,8 +394,9 @@ static switch_status woomerachan_read_frame(switch_core_session *session, switch
        pframe = &tech_pvt->frame;
        *frame = pframe;
 
-       pframe->datalen = sizeof(tech_pvt->databuf);
-       if (switch_socket_recvfrom(tech_pvt->udpread, tech_pvt->udp_socket, 0, tech_pvt->databuf, &pframe->datalen) == SWITCH_STATUS_SUCCESS) {
+       len = sizeof(tech_pvt->databuf);
+       if (switch_socket_recvfrom(tech_pvt->udpread, tech_pvt->udp_socket, 0, tech_pvt->databuf, &len) == SWITCH_STATUS_SUCCESS) {
+               pframe->datalen = len;
                pframe->samples = (int) pframe->datalen / 2;
                return SWITCH_STATUS_SUCCESS;
        }
@@ -407,8 +409,9 @@ static switch_status woomerachan_write_frame(switch_core_session *session, switc
 {
        switch_channel *channel = NULL;
        struct private_object *tech_pvt = NULL;
+       switch_size_t len;
        //switch_frame *pframe;
-
+       
        channel = switch_core_session_get_channel(session);
        assert(channel != NULL);
 
@@ -420,7 +423,9 @@ static switch_status woomerachan_write_frame(switch_core_session *session, switc
        }
 
        //pframe = &tech_pvt->frame;
-       if (switch_socket_sendto(tech_pvt->udp_socket, tech_pvt->udpwrite, 0, frame->data, &frame->datalen) == SWITCH_STATUS_SUCCESS) {
+       len = frame->datalen;
+       if (switch_socket_sendto(tech_pvt->udp_socket, tech_pvt->udpwrite, 0, frame->data, &len) == SWITCH_STATUS_SUCCESS) {
+               frame->datalen = len;
                return SWITCH_STATUS_SUCCESS;
        }
 
@@ -1063,7 +1068,7 @@ static void *woomera_channel_thread_run(switch_thread *thread, void *obj)
 
                                if ((tech_pvt->caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session),
                                                                                                                                                  tech_pvt->profile->dialplan,
-                                                                                                                                                 cid_name, cid_num, ip, NULL, NULL, exten)) != 0) {
+                                                                                                                                                 cid_name, cid_num, ip, NULL, NULL, NULL, (char *)modname, exten)) != 0) {
                                        char name[128];
                                        snprintf(name, sizeof(name), "Woomera/%s-%04x", tech_pvt->caller_profile->destination_number,
                                                         rand() & 0xffff);

diff --git a/src/mod/languages/mod_spidermonkey/mod_spidermonkey.c b/src/mod/languages/mod_spidermonkey/mod_spidermonkey.c
index 5214f8c3a38074cb6296a5fa144b1111a3d2e939..19cf6696291232e378a5ff20ae599f9141165c86 100644 (file)
--- a/src/mod/languages/mod_spidermonkey/mod_spidermonkey.c
+++ b/src/mod/languages/mod_spidermonkey/mod_spidermonkey.c
@@ -979,6 +979,7 @@ static JSBool session_construct(JSContext *cx, JSObject *obj, uintN argc, jsval
                char *network_addr = "";
                char *ani = "";
                char *ani2 = "";
+               char *rdnis = "";
 
                *rval = BOOLEAN_TO_JSVAL( JS_FALSE );
 
@@ -1010,13 +1011,16 @@ static JSBool session_construct(JSContext *cx, JSObject *obj, uintN argc, jsval
                if (argc > 8) {
                        ani2 = JS_GetStringBytes(JS_ValueToString(cx, argv[8]));
                }
+               if (argc > 9) {
+                       rdnis = JS_GetStringBytes(JS_ValueToString(cx, argv[9]));
+               }
                
                if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no pool\n");
                        return JS_FALSE;
                }
 
-               caller_profile = switch_caller_profile_new(pool, dialplan, cid_name, cid_num, network_addr, ani, ani2, dest);
+               caller_profile = switch_caller_profile_new(pool, dialplan, cid_name, cid_num, network_addr, ani, ani2, rdnis, (char *)modname, dest);
                if (switch_core_session_outgoing_channel(session, channel_type, caller_profile, &peer_session, pool) == SWITCH_STATUS_SUCCESS) {
                        jss = switch_core_session_alloc(peer_session, sizeof(*jss));
                        jss->session = peer_session;

diff --git a/src/switch_caller.c b/src/switch_caller.c
index 2b81a06a3304cebe8c2c95369605074f41fac8cf..beaa1b760d5cbd5ef1a86fe5750fbb2eac6bd098 100644 (file)
--- a/src/switch_caller.c
+++ b/src/switch_caller.c
@@ -36,7 +36,11 @@ SWITCH_DECLARE(switch_caller_profile *) switch_caller_profile_new(switch_memory_
                                                                                                                                  char *caller_id_name,
                                                                                                                                  char *caller_id_number,
                                                                                                                                  char *network_addr,
-                                                                                                                                 char *ani, char *ani2, char *destination_number)
+                                                                                                                                 char *ani,
+                                                                                                                                 char *ani2, 
+                                                                                                                                 char *rdnis,
+                                                                                                                                 char *source,
+                                                                                                                                 char *destination_number)
 {
 
 
@@ -49,6 +53,8 @@ SWITCH_DECLARE(switch_caller_profile *) switch_caller_profile_new(switch_memory_
                profile->network_addr = switch_core_strdup(pool, network_addr);
                profile->ani = switch_core_strdup(pool, ani);
                profile->ani2 = switch_core_strdup(pool, ani2);
+               profile->rdnis = switch_core_strdup(pool, rdnis);
+               profile->source = switch_core_strdup(pool, source);
                profile->destination_number = switch_core_strdup(pool, destination_number);
        }
 
@@ -56,8 +62,8 @@ SWITCH_DECLARE(switch_caller_profile *) switch_caller_profile_new(switch_memory_
 }
 
 
-SWITCH_DECLARE(switch_caller_profile *) switch_caller_profile_clone(switch_core_session *session,
-                                                                                                                                       switch_caller_profile *tocopy)
+SWITCH_DECLARE(switch_caller_profile *) switch_caller_profile_clone(switch_core_session *session, switch_caller_profile *tocopy)
+                                                                                                                                       
 {
        switch_caller_profile *profile = NULL;
        if ((profile = switch_core_session_alloc(session, sizeof(switch_caller_profile))) != 0) {
@@ -67,8 +73,10 @@ SWITCH_DECLARE(switch_caller_profile *) switch_caller_profile_clone(switch_core_
                profile->ani2 = switch_core_session_strdup(session, tocopy->ani2);
                profile->caller_id_number = switch_core_session_strdup(session, tocopy->caller_id_number);
                profile->network_addr = switch_core_session_strdup(session, tocopy->network_addr);
+               profile->rdnis = switch_core_session_strdup(session, tocopy->rdnis);
                profile->destination_number = switch_core_session_strdup(session, tocopy->destination_number);
                profile->uuid = switch_core_session_strdup(session, tocopy->uuid);
+               profile->source = switch_core_session_strdup(session, tocopy->source);
                profile->chan_name = switch_core_session_strdup(session, tocopy->chan_name);
        }
 
@@ -112,6 +120,14 @@ SWITCH_DECLARE(void) switch_caller_profile_event_set_data(switch_caller_profile
                snprintf(header_name, sizeof(header_name), "%s-Unique-ID", prefix);
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, header_name, caller_profile->uuid);
        }
+       if (caller_profile->source) {
+               snprintf(header_name, sizeof(header_name), "%s-RDNIS", prefix);
+               switch_event_add_header(event, SWITCH_STACK_BOTTOM, header_name, caller_profile->source);
+       }
+       if (caller_profile->rdnis) {
+               snprintf(header_name, sizeof(header_name), "%s-RDNIS", prefix);
+               switch_event_add_header(event, SWITCH_STACK_BOTTOM, header_name, caller_profile->rdnis);
+       }
        if (caller_profile->chan_name) {
                snprintf(header_name, sizeof(header_name), "%s-Channel-Name", prefix);
                switch_event_add_header(event, SWITCH_STACK_BOTTOM, header_name, caller_profile->chan_name);

diff --git a/src/switch_core.c b/src/switch_core.c
index 013d244a659736eee6348a6a1a498c6fc94bbbb8..1cc675e5e35e5083470a586de0f15037fadbea54 100644 (file)
--- a/src/switch_core.c
+++ b/src/switch_core.c
@@ -373,7 +373,9 @@ SWITCH_DECLARE(switch_status) switch_core_codec_decode(switch_codec *codec,
                                                                                                           uint32_t encoded_data_len,
                                                                                                           uint32_t encoded_rate,
                                                                                                           void *decoded_data,
-                                                                                                          uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag)
+                                                                                                          uint32_t *decoded_data_len, 
+                                                                                                          uint32_t *decoded_rate, 
+                                                                                                          unsigned int *flag)
 {
 
        assert(codec != NULL);

diff --git a/src/switch_event.c b/src/switch_event.c
index f74fb7761b9f82f6dd5ee0d40194a5f057c73e65..2d52f7b1741fc96b029e98ca42dd4a7a86bae1b5 100644 (file)
--- a/src/switch_event.c
+++ b/src/switch_event.c
@@ -99,6 +99,8 @@ static char *EVENT_NAMES[] = {
        "SHUTDOWN",
        "PUBLISH",
        "UNPUBLISH",
+       "TALK",
+       "NOTALK",
        "ALL"
 };
 

diff --git a/src/switch_rtp.c b/src/switch_rtp.c
index 49fd624a61df18d466ab8de76f3345fc801f032d..e9dfafcab5165aa8ce4f2f33c88a1ac10b791fc0 100644 (file)
--- a/src/switch_rtp.c
+++ b/src/switch_rtp.c
@@ -57,6 +57,29 @@ typedef struct {
        char body[SWITCH_RTP_MAX_BUF_LEN];  
 } rtp_msg_t;
 
+
+struct switch_rtp_vad_data {
+       switch_core_session *session;
+       switch_codec vad_codec;
+       switch_codec *read_codec;
+       uint32_t bg_level;
+       uint32_t bg_count;
+       uint32_t bg_len;
+       uint32_t diff_level;
+       uint8_t hangunder;
+       uint8_t hangunder_hits;
+       uint8_t hangover;
+       uint8_t hangover_hits;
+       uint8_t cng_freq;
+       uint8_t cng_count;
+       switch_vad_flag_t flags;
+       uint32_t ts;
+       uint8_t start;
+       uint8_t start_count;
+       uint8_t scan_freq;
+       time_t next_scan;
+};
+
 struct switch_rtp {
        switch_socket_t *sock;
 
@@ -89,6 +112,7 @@ struct switch_rtp {
        uint32_t remote_port;
        uint8_t stuncount;
        switch_buffer *packet_buffer;
+       struct switch_rtp_vad_data vad_data;
 };
 
 static int global_init = 0;
@@ -427,6 +451,9 @@ SWITCH_DECLARE(void) switch_rtp_destroy(switch_rtp **rtp_session)
        switch_rtp_kill_socket(*rtp_session);
        switch_socket_close((*rtp_session)->sock);
 
+       if (switch_test_flag((*rtp_session), SWITCH_RTP_FLAG_VAD)) {
+               switch_rtp_disable_vad(*rtp_session);
+       }
        if (switch_test_flag((*rtp_session), SWITCH_RTP_FLAG_SECURE)) {
                srtp_dealloc((*rtp_session)->recv_ctx);
                srtp_dealloc((*rtp_session)->send_ctx);
@@ -525,7 +552,11 @@ static int rtp_common_read(switch_rtp *rtp_session, switch_payload_t *payload_ty
                                rtp_session->recv_msg.header.pt = SWITCH_RTP_CNG_PAYLOAD;
                                *flags |= SFF_CNG;
                                /* Set the next waypoint and return a CNG frame */
-                               rtp_session->next_read += rtp_session->ms_per_packet;
+                               if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_TIMER_RECLOCK)) {
+                                       rtp_session->next_read = switch_time_now() + rtp_session->ms_per_packet;
+                               } else {
+                                       rtp_session->next_read += rtp_session->ms_per_packet;
+                               }
                                *payload_type = SWITCH_RTP_CNG_PAYLOAD;
                                return SWITCH_RTP_CNG_PAYLOAD;
                        }
@@ -642,6 +673,7 @@ static int rtp_common_write(switch_rtp *rtp_session, void *data, uint32_t datale
        uint8_t packetize = (rtp_session->packet_size > datalen && (payload == rtp_session->payload)) ? 1 : 0;
        uint8_t fwd = (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_RAW_WRITE) && (*flags & SFF_RAW_RTP)) ? 1 : 0;
        rtp_msg_t *send_msg;
+       uint8_t send = 1;
 
        if (fwd) {
                bytes = datalen;
@@ -649,7 +681,7 @@ static int rtp_common_write(switch_rtp *rtp_session, void *data, uint32_t datale
        } else {
                send_msg = &rtp_session->send_msg;
                send_msg->header.pt = payload;
-               send_msg->header.m = m;
+               send_msg->header.m = m ? 1 : 0;
                if (packetize) {
                        if (!rtp_session->packet_buffer) {
                                if (switch_buffer_create(rtp_session->pool, &rtp_session->packet_buffer, rtp_session->packet_size * 2) != SWITCH_STATUS_SUCCESS) {
@@ -685,8 +717,120 @@ static int rtp_common_write(switch_rtp *rtp_session, void *data, uint32_t datale
        if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_GOOGLEHACK) && rtp_session->send_msg.header.pt == 97) {
                rtp_session->recv_msg.header.pt = 102;
        }
-       switch_socket_sendto(rtp_session->sock, rtp_session->remote_addr, 0, (void*)send_msg, &bytes);
        
+       if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VAD)) {
+               int16_t decoded[SWITCH_RECCOMMENDED_BUFFER_SIZE/sizeof(int16_t)];
+               uint32_t rate;
+               uint32_t flags;
+               uint32_t len = sizeof(decoded);
+               send = 0;
+               time_t now = time(NULL);
+
+               if (rtp_session->vad_data.scan_freq && rtp_session->vad_data.next_scan <= now) {
+                       rtp_session->vad_data.bg_count = rtp_session->vad_data.bg_level = 0;
+                       rtp_session->vad_data.next_scan = now + rtp_session->vad_data.scan_freq;
+                       //printf("RESCAN\n");
+               }
+
+               if (switch_core_codec_decode(&rtp_session->vad_data.vad_codec,
+                                                                        rtp_session->vad_data.read_codec,
+                                                                        data,
+                                                                        datalen,
+                                                                        rtp_session->vad_data.read_codec->implementation->samples_per_second,
+                                                                        decoded,
+                                                                        &len,
+                                                                        &rate,
+                                                                        &flags) == SWITCH_STATUS_SUCCESS) {
+
+                       double energy = 0;
+                       uint32_t x, y = 0, z = len / sizeof(int16_t);
+                       uint32_t score = 0;
+                       
+                       if (z) {
+                               for (x = 0; x < z; x++) {
+                                       energy += abs(decoded[y] * 1.0);
+                                       y += rtp_session->vad_data.read_codec->implementation->number_of_channels;
+                               }
+                               
+                               if (++rtp_session->vad_data.start_count < rtp_session->vad_data.start) {
+                                       send = 1;
+                               } else {
+                                       score = energy / z;
+                                       if (score && (rtp_session->vad_data.bg_count < rtp_session->vad_data.bg_len)) {
+                                               rtp_session->vad_data.bg_level += score;
+                                               if (++rtp_session->vad_data.bg_count == rtp_session->vad_data.bg_len) {
+                                                       rtp_session->vad_data.bg_level /= rtp_session->vad_data.bg_len;
+                                                       rtp_session->vad_data.bg_level += (rtp_session->vad_data.bg_level / 3);
+                                                       //printf("AVG %u\n", rtp_session->vad_data.bg_level);
+                                               }
+                                               send = 1;
+                                       } else {
+                                               if (score > rtp_session->vad_data.bg_level) {
+                                                       uint32_t diff = score - rtp_session->vad_data.bg_level;
+
+                                                       if (rtp_session->vad_data.hangover_hits) {
+                                                               rtp_session->vad_data.hangover_hits--;
+                                                       }
+
+                                                       if (diff >= rtp_session->vad_data.diff_level || ++rtp_session->vad_data.hangunder_hits >= rtp_session->vad_data.hangunder) {
+                                                               switch_set_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING);
+                                                               send_msg->header.m = 1;
+                                                               rtp_session->vad_data.hangover_hits = rtp_session->vad_data.hangunder_hits = rtp_session->vad_data.cng_count = 0;
+                                                               if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_TALK)) {
+                                                                       switch_event *event;
+                                                                       if (switch_event_create(&event, SWITCH_EVENT_TALK) == SWITCH_STATUS_SUCCESS) {
+                                                                               switch_channel *channel = switch_core_session_get_channel(rtp_session->vad_data.session);
+                                                                               switch_channel_event_set_data(channel, event);
+                                                                               switch_event_fire(&event);
+                                                                       }
+                                                               }
+                                                       } 
+                                               } else {
+                                                       if (rtp_session->vad_data.hangunder_hits) {
+                                                               rtp_session->vad_data.hangunder_hits--;
+                                                       }
+                                                       if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
+                                                               if (++rtp_session->vad_data.hangover_hits >= rtp_session->vad_data.hangover) {
+                                                                       switch_clear_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING);
+                                                                       rtp_session->vad_data.hangover_hits = rtp_session->vad_data.hangunder_hits = rtp_session->vad_data.cng_count = 0;
+                                                                       if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_NOTALK)) {
+                                                                               switch_event *event;
+                                                                               if (switch_event_create(&event, SWITCH_EVENT_NOTALK) == SWITCH_STATUS_SUCCESS) {
+                                                                                       switch_channel *channel = switch_core_session_get_channel(rtp_session->vad_data.session);
+                                                                                       switch_channel_event_set_data(channel, event);
+                                                                                       switch_event_fire(&event);
+                                                                               }                                       
+                                                                       }
+                                                               }
+                                                       }
+                                               }
+                                       }
+                               }
+                               
+                               if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
+                                       send = 1;
+                               } else {
+                                       if (++rtp_session->vad_data.cng_count >= rtp_session->vad_data.cng_freq) {
+                                               rtp_session->send_msg.header.pt = SWITCH_RTP_CNG_PAYLOAD;
+                                               memset(rtp_session->send_msg.body, 255, SWITCH_RTP_CNG_PAYLOAD);
+                                               rtp_session->send_msg.header.ts = htonl(rtp_session->vad_data.ts);
+                                               rtp_session->vad_data.ts++;
+                                               bytes = SWITCH_RTP_CNG_PAYLOAD;
+                                               send = 1;
+                                               rtp_session->vad_data.cng_count = 0;
+                                       }
+                               }
+                                          
+                       }
+               } else {
+                       return SWITCH_STATUS_GENERR;
+               }
+       }
+
+       if (send) {
+               switch_socket_sendto(rtp_session->sock, rtp_session->remote_addr, 0, (void*)send_msg, &bytes);
+       }
+
        if (rtp_session->ice_user) {
                if (ice_out(rtp_session) != SWITCH_STATUS_SUCCESS) {
                        return -1;
@@ -697,6 +841,53 @@ static int rtp_common_write(switch_rtp *rtp_session, void *data, uint32_t datale
 
 }
 
+
+SWITCH_DECLARE(switch_status) switch_rtp_disable_vad(switch_rtp *rtp_session)
+{
+       if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VAD)) {
+               return SWITCH_STATUS_GENERR;
+       }
+       switch_core_codec_destroy(&rtp_session->vad_data.vad_codec);
+       switch_clear_flag(rtp_session, SWITCH_RTP_FLAG_VAD);
+       return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_DECLARE(switch_status) switch_rtp_enable_vad(switch_rtp *rtp_session, switch_core_session *session, switch_codec *codec, switch_vad_flag_t flags)
+{
+       if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VAD)) {
+               return SWITCH_STATUS_GENERR;
+       }
+       memset(&rtp_session->vad_data, 0, sizeof(rtp_session->vad_data));
+       
+       if (switch_core_codec_init(&rtp_session->vad_data.vad_codec,
+                                                          codec->codec_interface->iananame,
+                                                          codec->implementation->samples_per_second,
+                                                          codec->implementation->microseconds_per_frame / 1000,
+                                                          codec->implementation->number_of_channels,
+                                                          SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
+                                                          NULL, 
+                                                          rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
+               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n");
+               return SWITCH_STATUS_FALSE;
+       }
+
+       rtp_session->vad_data.diff_level = 400;
+       rtp_session->vad_data.hangunder = 15;
+       rtp_session->vad_data.hangover = 40;
+       rtp_session->vad_data.bg_len = 20;
+       rtp_session->vad_data.read_codec = codec;
+       rtp_session->vad_data.session = session;
+       rtp_session->vad_data.flags = flags;
+       rtp_session->vad_data.cng_freq = 50;
+       rtp_session->vad_data.ts = 1;
+       rtp_session->vad_data.start = 5;
+       rtp_session->vad_data.next_scan = time(NULL);
+       rtp_session->vad_data.scan_freq = 0;
+       switch_set_flag(rtp_session, SWITCH_RTP_FLAG_VAD);
+       
+       return SWITCH_STATUS_SUCCESS;
+}
+
 SWITCH_DECLARE(int) switch_rtp_write(switch_rtp *rtp_session, void *data, uint32_t datalen, uint32_t ts, switch_frame_flag *flags)
 {