try to improve audio stream sync

diff --git a/src/mod/endpoints/mod_sofia/mod_sofia.c b/src/mod/endpoints/mod_sofia/mod_sofia.c
index deedea0802bfe94cabb648224b0b0d48ab37eeb1..0b11abf7030008d7b16d473a233d00a1675131ac 100644 (file)
--- a/src/mod/endpoints/mod_sofia/mod_sofia.c
+++ b/src/mod/endpoints/mod_sofia/mod_sofia.c
@@ -1565,7 +1565,17 @@ static switch_status_t sofia_receive_message(switch_core_session_t *session, swi
                if (switch_core_session_in_thread(session)) {
                        de->session = session;
                }
-               sofia_process_dispatch_event(&de);
+
+               if (de->data->e_event == nua_i_cancel || de->data->e_event == nua_i_bye) {
+                       sofia_set_flag(tech_pvt, TFLAG_SIGDEAD);
+               }
+
+               if (!sofia_test_flag(tech_pvt, TFLAG_SIGDEAD) && (switch_channel_media_up(channel) || switch_channel_get_state(channel) > CS_ROUTING)) {
+                       sofia_queue_message(de);
+               } else {
+                       sofia_process_dispatch_event(&de);
+               }
+
                switch_mutex_unlock(tech_pvt->sofia_mutex);
                goto end;
        }

diff --git a/src/mod/endpoints/mod_sofia/mod_sofia.h b/src/mod/endpoints/mod_sofia/mod_sofia.h
index dc62141f2e22ffec1fc5235e6d7ed087607c9ff1..44f17a320fcae14f75b5735a70a48532e651f29c 100644 (file)
--- a/src/mod/endpoints/mod_sofia/mod_sofia.h
+++ b/src/mod/endpoints/mod_sofia/mod_sofia.h
@@ -353,6 +353,7 @@ typedef enum {
        TFLAG_PASS_ACK,
        TFLAG_CRYPTO_RECOVER,
        TFLAG_DROP_DTMF,
+       TFLAG_SIGDEAD,
        /* No new flags below this line */
        TFLAG_MAX
 } TFLAGS;
@@ -1205,6 +1206,7 @@ void sofia_glue_parse_rtp_bugs(switch_rtp_bug_flag_t *flag_pole, const char *str
 char *sofia_glue_gen_contact_str(sofia_profile_t *profile, sip_t const *sip, nua_handle_t *nh, sofia_dispatch_event_t *de, sofia_nat_parse_t *np);
 void sofia_glue_pause_jitterbuffer(switch_core_session_t *session, switch_bool_t on);
 void sofia_process_dispatch_event(sofia_dispatch_event_t **dep);
+void sofia_process_dispatch_event_in_thread(sofia_dispatch_event_t **dep);
 char *sofia_glue_get_host(const char *str, switch_memory_pool_t *pool);
 void sofia_presence_check_subscriptions(sofia_profile_t *profile, time_t now);
 void sofia_msg_thread_start(int idx);
@@ -1215,6 +1217,7 @@ private_object_t *sofia_glue_new_pvt(switch_core_session_t *session);
 switch_status_t sofia_init(void);
 void sofia_glue_fire_events(sofia_profile_t *profile);
 void sofia_event_fire(sofia_profile_t *profile, switch_event_t **event);
+void sofia_queue_message(sofia_dispatch_event_t *de);
 
 /* For Emacs:
  * Local Variables:

diff --git a/src/mod/endpoints/mod_sofia/sofia.c b/src/mod/endpoints/mod_sofia/sofia.c
index 092b1dca27dedbb38c9d37745aeb9366bb91979c..ed3428555eea173a62d66a87370a8a67c9260558 100644 (file)
--- a/src/mod/endpoints/mod_sofia/sofia.c
+++ b/src/mod/endpoints/mod_sofia/sofia.c
@@ -1686,7 +1686,7 @@ void sofia_msg_thread_start(int idx)
 }
 
 //static int foo = 0;
-static void sofia_queue_message(sofia_dispatch_event_t *de)
+void sofia_queue_message(sofia_dispatch_event_t *de)
 {
        int launch = 0;
 

diff --git a/src/switch_channel.c b/src/switch_channel.c
index 903bb6be76bacc6ae3ab7b9bd1b4eda1f840818b..9ac36c589a5e60412eb680e844a002deab79c219 100644 (file)
--- a/src/switch_channel.c
+++ b/src/switch_channel.c
@@ -291,7 +291,7 @@ SWITCH_DECLARE(switch_channel_callstate_t) switch_channel_str2callstate(const ch
 
 SWITCH_DECLARE(void) switch_channel_perform_audio_sync(switch_channel_t *channel, const char *file, const char *func, int line)
 {
-       if (switch_channel_media_ready(channel)) {
+       if (switch_channel_media_up(channel)) {
                switch_core_session_message_t msg = { 0 };
                msg.message_id = SWITCH_MESSAGE_INDICATE_AUDIO_SYNC;
                msg.from = channel->name;
@@ -3446,7 +3446,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_perform_mark_answered(switch_chan
 
        switch_channel_presence(channel, "unknown", "answered", NULL);
 
-       switch_channel_audio_sync(channel);
+       //switch_channel_audio_sync(channel);
 
        switch_core_recovery_track(channel->session);
 

diff --git a/src/switch_ivr_bridge.c b/src/switch_ivr_bridge.c
index 7eb96b287a17b0a0336a98b0da5e1ee26668c07b..b8b04cdbd0bac90f8f1cbf5cbc661558c60a6206 100644 (file)
--- a/src/switch_ivr_bridge.c
+++ b/src/switch_ivr_bridge.c
@@ -1232,8 +1232,8 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_multi_threaded_bridge(switch_core_ses
        switch_channel_set_flag_recursive(caller_channel, CF_BRIDGE_ORIGINATOR);
        switch_channel_clear_flag(peer_channel, CF_BRIDGE_ORIGINATOR);
 
-       switch_channel_audio_sync(caller_channel);
-       switch_channel_audio_sync(peer_channel);
+       //switch_channel_audio_sync(caller_channel);
+       //switch_channel_audio_sync(peer_channel);
 
        b_leg->session = peer_session;
        switch_copy_string(b_leg->b_uuid, switch_core_session_get_uuid(session), sizeof(b_leg->b_uuid));
@@ -1368,6 +1368,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_multi_threaded_bridge(switch_core_ses
                        
                        switch_channel_set_private(peer_channel, "_bridge_", b_leg);
                        switch_channel_set_state(peer_channel, CS_EXCHANGE_MEDIA);
+
                        audio_bridge_thread(NULL, (void *) a_leg);
 
                        switch_channel_clear_flag_recursive(caller_channel, CF_BRIDGE_ORIGINATOR);

diff --git a/src/switch_ivr_originate.c b/src/switch_ivr_originate.c
index d8a555c512b2c2a077358fcbb7048d7dcf3ffade..52d903c79d782a6d86f6bf1240fef6923c0d5907 100644 (file)
--- a/src/switch_ivr_originate.c
+++ b/src/switch_ivr_originate.c
@@ -3115,7 +3115,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *sess
                        do_continue:
 
                                if (!read_packet) {
-                                       switch_cond_next();
+                                       switch_yield(20000);
                                }
                        }
 
@@ -3373,13 +3373,13 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *sess
                                        if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
                                                status = SWITCH_STATUS_SUCCESS;
                                        } else {
-                                       status = switch_channel_answer(caller_channel);
+                                               status = switch_channel_answer(caller_channel);
                                        }
                                } else if (switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA)) {
                                        if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
                                                status = SWITCH_STATUS_SUCCESS;
                                        } else {
-                                       status = switch_channel_pre_answer(caller_channel);
+                                               status = switch_channel_pre_answer(caller_channel);
                                        }
                                } else {
                                        status = SWITCH_STATUS_SUCCESS;
@@ -3707,11 +3707,11 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *sess
                        switch_cond_next();
                }
 
-               switch_channel_audio_sync(bchan);
+               //switch_channel_audio_sync(bchan);
 
-               if (caller_channel) {
-                       switch_channel_audio_sync(caller_channel);
-               }
+               //if (caller_channel) {
+               //      switch_channel_audio_sync(caller_channel);
+               //}
        }
 
        if (oglobals.session) {

diff --git a/src/switch_rtp.c b/src/switch_rtp.c
index e469066fcee0e40bd867ab3ec563d9cd28aa99bd..ec003f956903d92a3de1d25baa217b788117d5c9 100644 (file)
--- a/src/switch_rtp.c
+++ b/src/switch_rtp.c
@@ -67,6 +67,7 @@ static switch_port_t START_PORT = RTP_START_PORT;
 static switch_port_t END_PORT = RTP_END_PORT;
 static switch_port_t NEXT_PORT = RTP_START_PORT;
 static switch_mutex_t *port_lock = NULL;
+static void do_flush(switch_rtp_t *rtp_session);
 
 typedef srtp_hdr_t rtp_hdr_t;
 
@@ -2071,6 +2072,7 @@ SWITCH_DECLARE(switch_rtp_t *) switch_rtp_new(const char *rx_host,
                rtp_session->ready = 2;
                rtp_session->rx_host = switch_core_strdup(rtp_session->pool, rx_host);
                rtp_session->rx_port = rx_port;
+               //switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_FLUSH);
        } else {
                switch_rtp_release_port(rx_host, rx_port);
        }
@@ -2761,7 +2763,7 @@ SWITCH_DECLARE(void) rtp_flush_read_buffer(switch_rtp_t *rtp_session, switch_rtp
        
                if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA) && 
                        !switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO)) {
-                       switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_FLUSH);
+                       
                        switch (flush) {
                        case SWITCH_RTP_FLUSH_STICK:
                                switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH);
@@ -2780,6 +2782,7 @@ static void do_flush(switch_rtp_t *rtp_session)
 {
        int was_blocking = 0;
        switch_size_t bytes;
+       uint32_t flushed = 0;
 
        if (!switch_rtp_ready(rtp_session) || 
                switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA) || 
@@ -2787,11 +2790,11 @@ static void do_flush(switch_rtp_t *rtp_session)
                ) {
                return;
        }
+       
 
        READ_INC(rtp_session);
 
        if (switch_rtp_ready(rtp_session)) {
-               uint32_t flushed = 0;
                
                if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_DEBUG_RTP_READ)) {
                        switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
@@ -2869,34 +2872,35 @@ static switch_status_t read_rtp_packet(switch_rtp_t *rtp_session, switch_size_t
                
                if (rtp_session->last_seq && rtp_session->last_seq+1 != seq) {
 #ifdef DEBUG_MISSED_SEQ
+                       //2012-11-28 18:33:11.799070 [ERR] switch_rtp.c:2883 Missed -65536 RTP frames from sequence [65536] to [-1] (missed). Time since last read [20021]
                        switch_size_t flushed_packets_diff = rtp_session->stats.inbound.flush_packet_count - rtp_session->last_flush_packet_count;
                        switch_size_t num_missed = (switch_size_t)seq - (rtp_session->last_seq+1);
 
                        if (num_missed == 1) { /* We missed one packet */
-                               switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Missed one RTP frame with sequence [%d]%s. Time since last read [%d]\n",
+                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missed one RTP frame with sequence [%d]%s. Time since last read [%ld]\n",
                                                                  rtp_session->last_seq+1, (flushed_packets_diff == 1) ? " (flushed by FS)" : " (missed)",
                                                                  rtp_session->last_read_time ? switch_micro_time_now()-rtp_session->last_read_time : 0);
                        } else { /* We missed multiple packets */
                                if (flushed_packets_diff == 0) { 
-                                       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
-                                                                         "Missed %d RTP frames from sequence [%d] to [%d] (missed). Time since last read [%d]\n",
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+                                                                         "Missed %ld RTP frames from sequence [%d] to [%d] (missed). Time since last read [%ld]\n",
                                                                          num_missed, rtp_session->last_seq+1, seq-1,
                                                                          rtp_session->last_read_time ? switch_micro_time_now()-rtp_session->last_read_time : 0);
                                } else if (flushed_packets_diff == num_missed) {
-                                       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
-                                                                         "Missed %d RTP frames from sequence [%d] to [%d] (flushed by FS). Time since last read [%d]\n",
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+                                                                         "Missed %ld RTP frames from sequence [%d] to [%d] (flushed by FS). Time since last read [%ld]\n",
                                                                          num_missed, rtp_session->last_seq+1, seq-1,
                                                                          rtp_session->last_read_time ? switch_micro_time_now()-rtp_session->last_read_time : 0);
                                } else if (num_missed > flushed_packets_diff) {
-                                       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
-                                                                         "Missed %d RTP frames from sequence [%d] to [%d] (%d packets flushed by FS, %d packets missed)."
-                                                                         " Time since last read [%d]\n",
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+                                                                         "Missed %ld RTP frames from sequence [%d] to [%d] (%ld packets flushed by FS, %ld packets missed)."
+                                                                         " Time since last read [%ld]\n",
                                                                          num_missed, rtp_session->last_seq+1, seq-1,
                                                                          flushed_packets_diff, num_missed-flushed_packets_diff,
                                                                          rtp_session->last_read_time ? switch_micro_time_now()-rtp_session->last_read_time : 0);
                                } else {
-                                       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
-                                                                         "Missed %d RTP frames from sequence [%d] to [%d] (%d packets flushed by FS). Time since last read [%d]\n",
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+                                                                         "Missed %ld RTP frames from sequence [%d] to [%d] (%ld packets flushed by FS). Time since last read [%ld]\n",
                                                                          num_missed, rtp_session->last_seq+1, seq-1,
                                                                          flushed_packets_diff, rtp_session->last_read_time ? switch_micro_time_now()-rtp_session->last_read_time : 0);
                                }
@@ -3240,15 +3244,17 @@ static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_
 
                                        if (bytes) {
                                                if (switch_poll(rtp_session->read_pollfd, 1, &fdr, 0) == SWITCH_STATUS_SUCCESS) {
-                                                       /* switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Trigger %d\n", rtp_session->hot_hits); */
-                                                       rtp_session->hot_hits += rtp_session->samples_per_interval;
+                                                       rtp_session->hot_hits++;//+= rtp_session->samples_per_interval;
+                                                       
+                                                       //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "%s Trigger %d\n", 
+                                                       //switch_core_session_get_name(session),
+                                                       //                                rtp_session->hot_hits); 
                                                } else {
                                                        rtp_session->hot_hits = 0;
                                                }
                                        }
                                        
-                                       if (rtp_session->hot_hits >= rtp_session->samples_per_second * 5) {
-                                               switch_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
+                                       if (rtp_session->hot_hits > 1 && !rtp_session->sync_packets) {// >= (rtp_session->samples_per_second * 30)) {
                                                hot_socket = 1;
                                        }
                                } else {
@@ -3256,19 +3262,27 @@ static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_
                                }
                        }
 
-                       if (hot_socket) {
+
+                       if (hot_socket) { 
+                               //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Skip timer\n");
                                rtp_session->sync_packets++;
                                switch_core_timer_sync(&rtp_session->timer);
+                               
                        } else {
+                               
                                if (rtp_session->sync_packets) {
 #if 0
-                                       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
+                                       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT,
                                                                          "Auto-Flush catching up %d packets (%d)ms.\n",
                                                                          rtp_session->sync_packets, (rtp_session->ms_per_packet * rtp_session->sync_packets) / 1000);
 #endif
-                                       rtp_session->sync_packets = 0;
+                                       //switch_core_timer_sync(&rtp_session->timer);
+                               } else {
+
+                                       switch_core_timer_next(&rtp_session->timer);
                                }
-                               switch_core_timer_next(&rtp_session->timer);
+
+                               rtp_session->sync_packets = 0;
                        }
                }
 
@@ -4787,3 +4801,4 @@ SWITCH_DECLARE(void *) switch_rtp_get_private(switch_rtp_t *rtp_session)
  * For VIM:
  * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
  */
+