merge 1

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

libs/libdingaling/src/libdingaling.c

@@ -731,6 +731,8 @@ static int on_presence(void *user_data, ikspak *pak)
 	struct ldl_buffer *buffer;
 	ldl_signal_t dl_signal = LDL_SIGNAL_PRESENCE_IN;
 
+
+
     if (type && *type) {
         if (!strcasecmp(type, "unavailable")) {
             dl_signal = LDL_SIGNAL_PRESENCE_OUT;
@@ -754,6 +756,7 @@ static int on_presence(void *user_data, ikspak *pak)
 		*resource++ = '\0';
 	}
 	
+
 	if (!apr_hash_get(handle->sub_hash, from, APR_HASH_KEY_STRING)) {
 		iks *msg;
 		apr_hash_set(handle->sub_hash, 	apr_pstrdup(handle->pool, from), APR_HASH_KEY_STRING, &marker);
@@ -766,6 +769,8 @@ static int on_presence(void *user_data, ikspak *pak)
 		apr_cpystrn(buffer->buf, from, buffer->len);
 		fflush(stderr);
 		buffer->hit = 1;
+	} else {
+		printf("DAMMIT Lookup %s\n", from);
 	}
 	
     if (handle->session_callback) {
@@ -1953,42 +1958,33 @@ char *ldl_handle_probe(ldl_handle_t *handle, char *id, char *from, char *buf, un
 	iks *pres, *msg;
 	char *lid = NULL, *low_id = NULL;
 	struct ldl_buffer buffer;
-	apr_time_t started;
+	time_t started;
 	unsigned int elapsed;
 	char *notice = "Call Me!";
-	int again = 0;
+	int next = 0;
 	
 	buffer.buf = buf;
 	buffer.len = len;
 	buffer.hit = 0;
 
-	pres = iks_new("presence");
-	iks_insert_attrib(pres, "type", "probe");
-	iks_insert_attrib(pres, "from", from);
-	iks_insert_attrib(pres, "to", id);
-	
-
 	apr_hash_set(handle->probe_hash, id, APR_HASH_KEY_STRING, &buffer);
+
 	msg = iks_make_s10n (IKS_TYPE_SUBSCRIBE, id, notice); 
 	iks_insert_attrib(msg, "from", from);
 	apr_queue_push(handle->queue, msg);
-	msg = iks_make_s10n (IKS_TYPE_SUBSCRIBED, id, notice); 
-	iks_insert_attrib(msg, "from", from);
-	apr_queue_push(handle->queue, msg);
-	apr_queue_push(handle->queue, pres);
-
-	//schedule_packet(handle, next_id(), pres, LDL_RETRY);
 
-	started = apr_time_now();
+	started = time(NULL);
 	for(;;) {
-		elapsed = (unsigned int)((apr_time_now() - started) / 1000);
-		if (elapsed > 5000 && ! again) {
-			msg = iks_make_s10n (IKS_TYPE_SUBSCRIBE, id, notice); 
-			iks_insert_attrib(msg, "from", from);
-			apr_queue_push(handle->queue, msg);
-			again++;
+		elapsed = time(NULL) - started;
+		if (elapsed == next) {
+			pres = iks_new("presence");
+			iks_insert_attrib(pres, "type", "probe");
+			iks_insert_attrib(pres, "from", from);
+			iks_insert_attrib(pres, "to", id);
+			apr_queue_push(handle->queue, pres);
+			next += 5;
 		}
-		if (elapsed > 10000) {
+		if (elapsed >= 17) {
 			break;
 		}
 		if (buffer.hit) {

src/mod/endpoints/mod_dingaling/mod_dingaling.c

@@ -851,7 +851,6 @@ static int activate_rtp(struct private_object *tech_pvt)
 					  tech_pvt->local_port, tech_pvt->remote_ip, tech_pvt->remote_port);
 	
 	flags = SWITCH_RTP_FLAG_GOOGLEHACK | SWITCH_RTP_FLAG_AUTOADJ | SWITCH_RTP_FLAG_RAW_WRITE | SWITCH_RTP_FLAG_AUTO_CNG;
-	//flags = SWITCH_RTP_FLAG_AUTOADJ;
 
 	if (switch_test_flag(tech_pvt->profile, TFLAG_TIMER)) {
 		flags |= SWITCH_RTP_FLAG_USE_TIMER;
@@ -874,7 +873,11 @@ static int activate_rtp(struct private_object *tech_pvt)
 		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);
+			if (switch_rtp_enable_vad(tech_pvt->rtp_session, tech_pvt->session, &tech_pvt->read_codec, SWITCH_VAD_FLAG_TALKING) != SWITCH_STATUS_SUCCESS) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "VAD ERROR %s\n", err);
+				switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
+				return 0;
+			}
 			switch_set_flag_locked(tech_pvt, TFLAG_VAD);
 		}
 		switch_rtp_set_cng_pt(tech_pvt->rtp_session, 13);
@@ -1065,7 +1068,8 @@ static switch_status_t negotiate_media(switch_core_session_t *session)
 
 	while (!(switch_test_flag(tech_pvt, TFLAG_CODEC_READY) &&
 			 switch_test_flag(tech_pvt, TFLAG_RTP_READY) &&
-			 switch_test_flag(tech_pvt, TFLAG_ANSWER) && switch_test_flag(tech_pvt, TFLAG_TRANSPORT_ACCEPT)
+			 switch_test_flag(tech_pvt, TFLAG_ANSWER) && switch_test_flag(tech_pvt, TFLAG_TRANSPORT_ACCEPT) &&
+			 tech_pvt->remote_ip && tech_pvt->remote_port
 			 && switch_test_flag(tech_pvt, TFLAG_TRANSPORT))) {
 		now = switch_time_now();
 		elapsed = (unsigned int) ((now - started) / 1000);
@@ -1329,89 +1333,101 @@ static switch_status_t channel_send_dtmf(switch_core_session_t *session, char *d
 static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
 {
 	struct private_object *tech_pvt = NULL;
-	uint32_t bytes = 0;
-	switch_size_t samples = 0, frames = 0, ms = 0;
 	switch_channel_t *channel = NULL;
-	switch_payload_t payload = 0;
-	switch_status_t status;
+	int payload = 0;
 
 	channel = switch_core_session_get_channel(session);
 	assert(channel != NULL);
 
-	tech_pvt = switch_core_session_get_private(session);
+	tech_pvt = (struct private_object *) switch_core_session_get_private(session);
 	assert(tech_pvt != NULL);
 
-
-	if (!tech_pvt->rtp_session) {
-		return SWITCH_STATUS_FALSE;
+	while (!(tech_pvt->read_codec.implementation && switch_rtp_ready(tech_pvt->rtp_session))) {
+		if (switch_channel_ready(channel)) {
+			switch_yield(10000);
+		} else {
+			return SWITCH_STATUS_GENERR;
 		}
-
-	if (switch_test_flag(tech_pvt, TFLAG_BYE)) {
-		//terminate_session(&session,  __LINE__, SWITCH_CAUSE_NORMAL_CLEARING);
-		return SWITCH_STATUS_FALSE;
 	}
 
 
 	tech_pvt->read_frame.datalen = 0;
 	switch_set_flag_locked(tech_pvt, TFLAG_READING);
 
-	bytes = tech_pvt->read_codec.implementation->encoded_bytes_per_frame;
-	samples = tech_pvt->read_codec.implementation->samples_per_frame;
-	ms = tech_pvt->read_codec.implementation->microseconds_per_frame;
+#if 0
+	if (tech_pvt->last_read) {
+		elapsed = (unsigned int) ((switch_time_now() - tech_pvt->last_read) / 1000);
+		if (elapsed > 60000) {
+			return SWITCH_STATUS_TIMEOUT;
+		}
+	}
+#endif
+
+
+	if (switch_test_flag(tech_pvt, TFLAG_IO)) {
+		switch_status_t status;
+
+		assert(tech_pvt->rtp_session != NULL);
 		tech_pvt->read_frame.datalen = 0;
 
 
-	while (!switch_test_flag(tech_pvt, TFLAG_BYE) && switch_test_flag(tech_pvt, TFLAG_IO)
-		   && tech_pvt->read_frame.datalen == 0) {
-		tech_pvt->read_frame.flags = 0;
-		status = switch_rtp_zerocopy_read_frame(tech_pvt->rtp_session, &tech_pvt->read_frame);
+		while (switch_test_flag(tech_pvt, TFLAG_IO) && tech_pvt->read_frame.datalen == 0) {
+			tech_pvt->read_frame.flags = SFF_NONE;
 
+			status = switch_rtp_zerocopy_read_frame(tech_pvt->rtp_session, &tech_pvt->read_frame);
 			if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
 				return SWITCH_STATUS_FALSE;
 			}
+
+
+
 			payload = tech_pvt->read_frame.payload;
 
+#if 0
+			elapsed = (unsigned int) ((switch_time_now() - started) / 1000);
+
+			if (timeout > -1) {
+				if (elapsed >= (unsigned int) timeout) {
+					return SWITCH_STATUS_BREAK;
+				}
+			}
+
+			elapsed = (unsigned int) ((switch_time_now() - last_act) / 1000);
+			if (elapsed >= hard_timeout) {
+				return SWITCH_STATUS_BREAK;
+			}
+#endif
 			if (switch_rtp_has_dtmf(tech_pvt->rtp_session)) {
 				char dtmf[128];
 				switch_rtp_dequeue_dtmf(tech_pvt->rtp_session, dtmf, sizeof(dtmf));
 				switch_channel_queue_dtmf(channel, dtmf);
-			switch_set_flag_locked(tech_pvt, TFLAG_DTMF);
 			}
 
-		if (switch_test_flag(tech_pvt, TFLAG_DTMF)) {
-			switch_clear_flag_locked(tech_pvt, TFLAG_DTMF);
-			return SWITCH_STATUS_BREAK;
-		}
-
-		if (switch_test_flag(&tech_pvt->read_frame, SFF_CNG)) {
-			tech_pvt->read_frame.datalen = tech_pvt->last_read ? tech_pvt->last_read : tech_pvt->read_codec.implementation->encoded_bytes_per_frame;
-		}
 
 			if (tech_pvt->read_frame.datalen > 0) {
+				size_t bytes = 0;
+				int frames = 1;
+
 				if (!switch_test_flag((&tech_pvt->read_frame), SFF_CNG)) {
-				if (tech_pvt->read_codec.implementation->encoded_bytes_per_frame && bytes) {
-					bytes = tech_pvt->read_codec.implementation->encoded_bytes_per_frame;
+					if ((bytes = tech_pvt->read_codec.implementation->encoded_bytes_per_frame)) {
 						frames = (tech_pvt->read_frame.datalen / bytes);
-				} else {
-					frames = 1;
 					}
-				samples = frames * tech_pvt->read_codec.implementation->samples_per_frame;
-				ms = frames * tech_pvt->read_codec.implementation->microseconds_per_frame;
-				tech_pvt->timestamp_recv += (int32_t) samples;
-				tech_pvt->read_frame.samples = (int) samples;
-				tech_pvt->last_read = tech_pvt->read_frame.datalen;
+					tech_pvt->read_frame.samples = (int) (frames * tech_pvt->read_codec.implementation->samples_per_frame);
 				}
 				break;
 			}
-
-		switch_yield(1000);
 		}
-
+	}
 
 	switch_clear_flag_locked(tech_pvt, TFLAG_READING);
 
+	if (tech_pvt->read_frame.datalen == 0) {
+		*frame = NULL;
+		return SWITCH_STATUS_GENERR;
+	}
 
 	*frame = &tech_pvt->read_frame;
+
 	return SWITCH_STATUS_SUCCESS;
 }
 
@@ -1422,45 +1438,46 @@ static switch_status_t channel_write_frame(switch_core_session_t *session, switc
 	switch_status_t status = SWITCH_STATUS_SUCCESS;
 	int bytes = 0, samples = 0, frames = 0;
 
-
 	channel = switch_core_session_get_channel(session);
 	assert(channel != NULL);
 
-	tech_pvt = switch_core_session_get_private(session);
+	tech_pvt = (struct private_object *) switch_core_session_get_private(session);
 	assert(tech_pvt != NULL);
 
-	if (!tech_pvt->rtp_session) {
-		return SWITCH_STATUS_FALSE;
+	while (!(tech_pvt->read_codec.implementation && switch_rtp_ready(tech_pvt->rtp_session))) {
+		if (switch_channel_ready(channel)) {
+			switch_yield(10000);
+		} else {
+			return SWITCH_STATUS_GENERR;
 		}
-
-	if (!switch_test_flag(tech_pvt, TFLAG_RTP_READY)) {
-		return SWITCH_STATUS_SUCCESS;
 	}
 
-
-	if (switch_test_flag(tech_pvt, TFLAG_BYE)) {
-		return SWITCH_STATUS_FALSE;
+	if (!switch_test_flag(tech_pvt, TFLAG_IO)) {
+		return SWITCH_STATUS_SUCCESS;
 	}
 
 	switch_set_flag_locked(tech_pvt, TFLAG_WRITING);
 
+	if (!switch_test_flag(frame, SFF_CNG)) {
 		if (tech_pvt->read_codec.implementation->encoded_bytes_per_frame) {
 			bytes = tech_pvt->read_codec.implementation->encoded_bytes_per_frame;
 			frames = ((int) frame->datalen / bytes);
-	} else {
+		} else
 			frames = 1;
-	}
 
 		samples = frames * tech_pvt->read_codec.implementation->samples_per_frame;
-	tech_pvt->timestamp_send += samples;
-	if (switch_rtp_write_frame(tech_pvt->rtp_session, frame, 0) < 0) {
-		terminate_session(&session, __LINE__, SWITCH_CAUSE_NORMAL_CLEARING);
-		return SWITCH_STATUS_FALSE;
 	}
+#if 0
+	printf("%s %s->%s send %d bytes %d samples in %d frames ts=%d\n",
+		   switch_channel_get_name(channel),
+		   tech_pvt->local_sdp_audio_ip, tech_pvt->remote_sdp_audio_ip, frame->datalen, samples, frames, tech_pvt->timestamp_send);
+#endif
 
+	tech_pvt->timestamp_send += samples;
+	//switch_rtp_write_frame(tech_pvt->rtp_session, frame, tech_pvt->timestamp_send);
+	switch_rtp_write_frame(tech_pvt->rtp_session, frame, 0);
 
 	switch_clear_flag_locked(tech_pvt, TFLAG_WRITING);
-
 	return status;
 }
 

src/switch_rtp.c

@@ -772,7 +772,6 @@ static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_
 			return -1;
 		}
 
-
 		if (!bytes && switch_test_flag(rtp_session, SWITCH_RTP_FLAG_BREAK)) {
 			switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_BREAK);
 
@@ -787,22 +786,6 @@ static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_
 
 		if (bytes < 0) {
 			return (int) bytes;
-		} else if (bytes > 0 && switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE)) {
-			int sbytes = (int) bytes;
-			err_status_t stat;
-
-			stat = srtp_unprotect(rtp_session->recv_ctx, &rtp_session->recv_msg.header, &sbytes);
-			if (stat) {
-				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
-								  "error: srtp unprotection failed with code %d%s\n", stat,
-								  stat == err_status_replay_fail ? " (replay check failed)" : stat == err_status_auth_fail ? " (auth check failed)" : "");
-				return -1;
-			}
-			bytes = sbytes;
-		}
-
-		if (bytes && rtp_session->cng_pt && rtp_session->recv_msg.header.pt == rtp_session->cng_pt) {
-			continue;
 		}
 
 		if (rtp_session->timer.interval) {
@@ -818,24 +801,61 @@ static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_
 			}
 		}
 
-
-
 		if (check) {
 			do_2833(rtp_session);
 
 			if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER)) {
+				uint8_t *data = (uint8_t *) rtp_session->recv_msg.body;
 				/* We're late! We're Late! */
 				if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK) && status == SWITCH_STATUS_BREAK) {
 					switch_yield(1000);
 					continue;
 				}
-				memset(&rtp_session->recv_msg, 0, SWITCH_RTP_CNG_PAYLOAD);
-				rtp_session->recv_msg.header.pt = SWITCH_RTP_CNG_PAYLOAD;
+					
+				memset(data, 0, 2);
+				data[0] = 65;
+				
+				rtp_session->recv_msg.header.pt = (uint32_t) rtp_session->cng_pt ? rtp_session->cng_pt : SWITCH_RTP_CNG_PAYLOAD;
 				*flags |= SFF_CNG;
-				/* Return a CNG frame */
-				*payload_type = SWITCH_RTP_CNG_PAYLOAD;
-				return SWITCH_RTP_CNG_PAYLOAD + rtp_header_len;
+				*payload_type = rtp_session->recv_msg.header.pt;
+				return 2 + rtp_header_len;
+			}
+		}
+
+		if (bytes && rtp_session->recv_msg.header.version != 2) {
+			uint8_t *data = (uint8_t *) rtp_session->recv_msg.body;
+			if (rtp_session->recv_msg.header.version == 0 && rtp_session->ice_user) {
+				handle_ice(rtp_session, (void *) &rtp_session->recv_msg, bytes);
+			}
+
+			if (rtp_session->invalid_handler) {
+				rtp_session->invalid_handler(rtp_session, rtp_session->sock, (void *) &rtp_session->recv_msg, bytes, rtp_session->from_addr);
 			}
+			
+			memset(data, 0, 2);
+			data[0] = 65;
+
+			rtp_session->recv_msg.header.pt = (uint32_t) rtp_session->cng_pt ? rtp_session->cng_pt : SWITCH_RTP_CNG_PAYLOAD;
+			*flags |= SFF_CNG;
+			*payload_type = rtp_session->recv_msg.header.pt;
+			return 2 + rtp_header_len;
+		}
+		
+
+
+
+		if (bytes && switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE)) {
+			int sbytes = (int) bytes;
+			err_status_t stat;
+
+			stat = srtp_unprotect(rtp_session->recv_ctx, &rtp_session->recv_msg.header, &sbytes);
+			if (stat) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+								  "error: srtp unprotection failed with code %d%s\n", stat,
+								  stat == err_status_replay_fail ? " (replay check failed)" : stat == err_status_auth_fail ? " (auth check failed)" : "");
+				return -1;
+			}
+			bytes = sbytes;
 		}
 
 		if (status == SWITCH_STATUS_BREAK || bytes == 0) {
@@ -847,9 +867,9 @@ static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_
 		}
 
 		
-		if (rtp_session->recv_msg.header.version) {
-			if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ)
-				&& switch_sockaddr_get_port(rtp_session->from_addr)) {
+		
+		if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ) && switch_sockaddr_get_port(rtp_session->from_addr)) {
+			
 			char *tx_host;
 			char *old_host;
 			char bufa[30], bufb[30];
@@ -870,24 +890,20 @@ static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_
 			}
 			switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
 		}
+
+		if (bytes && rtp_session->cng_pt && rtp_session->recv_msg.header.pt == rtp_session->cng_pt) {
+			continue;
 		}
 
-		if (rtp_session->recv_msg.header.version == 2) {
+
+		
 		if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_GOOGLEHACK) && rtp_session->recv_msg.header.pt == 102) {
 			rtp_session->recv_msg.header.pt = 97;
 		}
+
 		rtp_session->rseq = ntohs((uint16_t) rtp_session->recv_msg.header.seq);
 		rtp_session->rpayload = (switch_payload_t) rtp_session->recv_msg.header.pt;
-		} else {
-			if (rtp_session->recv_msg.header.version == 0 && rtp_session->ice_user) {
-				handle_ice(rtp_session, (void *) &rtp_session->recv_msg, bytes);
-			}
 		
-			if (rtp_session->invalid_handler) {
-				rtp_session->invalid_handler(rtp_session, rtp_session->sock, (void *) &rtp_session->recv_msg, bytes, rtp_session->from_addr);
-			}
-			return 0;
-		}
 
 		/* RFC2833 ... TBD try harder to honor the duration etc. */
 		if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PASS_RFC2833)
@@ -925,7 +941,6 @@ static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_
 			}
 			
 			continue;
-
 		}
 
 		break;
@@ -1182,12 +1197,11 @@ static int rtp_common_write(switch_rtp_t *rtp_session, void *data, uint32_t data
 	}
 
 	if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VAD) &&
-		rtp_session->recv_msg.header.pt == rtp_session->vad_data.read_codec->implementation->ianacode &&
-		((datalen == rtp_session->vad_data.read_codec->implementation->encoded_bytes_per_frame) ||
-		 (datalen > SWITCH_RTP_CNG_PAYLOAD && rtp_session->vad_data.read_codec->implementation->encoded_bytes_per_frame == 0))) {
-		int16_t decoded[SWITCH_RECOMMENDED_BUFFER_SIZE / sizeof(int16_t)];
-		uint32_t rate;
-		uint32_t flags;
+		rtp_session->recv_msg.header.pt == rtp_session->vad_data.read_codec->implementation->ianacode) {
+		
+		int16_t decoded[SWITCH_RECOMMENDED_BUFFER_SIZE / sizeof(int16_t)] = {0};
+		uint32_t rate = 0;
+		uint32_t flags = 0;
 		uint32_t len = sizeof(decoded);
 		time_t now = time(NULL);
 		send = 0;
@@ -1206,6 +1220,7 @@ static int rtp_common_write(switch_rtp_t *rtp_session, void *data, uint32_t data
 									 rtp_session->vad_data.read_codec->implementation->samples_per_second,
 									 decoded, &len, &rate, &flags) == SWITCH_STATUS_SUCCESS) {
 			
+
 			uint32_t energy = 0;
 			uint32_t x, y = 0, z = len / sizeof(int16_t);
 			uint32_t score = 0;
@@ -1274,35 +1289,23 @@ static int rtp_common_write(switch_rtp_t *rtp_session, void *data, uint32_t data
 
 				if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
 					send = 1;
-				} else {
-					if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_CNG)
-						&& ++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;
 		}
 	}
 
-	rtp_session->last_write_ts = ntohl(send_msg->header.ts);
-	rtp_session->last_write_ssrc = ntohl(send_msg->header.ssrc);
-	rtp_session->last_write_seq = rtp_session->seq;
 
-	if (rtp_session->last_write_seq <= rtp_session->dtmf_data.out_digit_seq) {
+	if (rtp_session->last_write_seq >0 && rtp_session->last_write_seq <= rtp_session->dtmf_data.out_digit_seq) {
 		send = 0;
 	}
 
 	if (send) {
+
+		rtp_session->last_write_ts = ntohl(send_msg->header.ts);
+		rtp_session->last_write_ssrc = ntohl(send_msg->header.ssrc);
+		rtp_session->last_write_seq = rtp_session->seq;
 		if (rtp_session->timer.interval) {
 			switch_core_timer_check(&rtp_session->timer);
 			rtp_session->last_write_samplecount = rtp_session->timer.samplecount;
@@ -1360,7 +1363,8 @@ SWITCH_DECLARE(switch_status_t) switch_rtp_enable_vad(switch_rtp_t *rtp_session,
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n");
 		return SWITCH_STATUS_FALSE;
 	}
-
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Activate VAD codec %s %dms\n", codec->implementation->iananame, 
+					  codec->implementation->microseconds_per_frame / 1000);
 	rtp_session->vad_data.diff_level = 400;
 	rtp_session->vad_data.hangunder = 15;
 	rtp_session->vad_data.hangover = 40;