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;
*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);
apr_cpystrn(buffer->buf, from, buffer->len);
fflush(stderr);
buffer->hit = 1;
+ } else {
+ printf("DAMMIT Lookup %s\n", from);
}
if (handle->session_callback) {
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) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SETUP RTP %s:%d -> %s:%d\n", tech_pvt->profile->ip,
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;
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);
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);
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;
- }
-
- if (switch_test_flag(tech_pvt, TFLAG_BYE)) {
- //terminate_session(&session, __LINE__, SWITCH_CAUSE_NORMAL_CLEARING);
- 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;
+ }
}
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;
- tech_pvt->read_frame.datalen = 0;
+#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
- 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);
+ if (switch_test_flag(tech_pvt, TFLAG_IO)) {
+ switch_status_t status;
- if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
- return SWITCH_STATUS_FALSE;
- }
- payload = tech_pvt->read_frame.payload;
+ assert(tech_pvt->rtp_session != NULL);
+ tech_pvt->read_frame.datalen = 0;
- 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;
- }
+ while (switch_test_flag(tech_pvt, TFLAG_IO) && tech_pvt->read_frame.datalen == 0) {
+ tech_pvt->read_frame.flags = SFF_NONE;
- 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;
- }
+ 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;
+ }
- if (tech_pvt->read_frame.datalen > 0) {
- 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;
- frames = (tech_pvt->read_frame.datalen / bytes);
- } else {
- frames = 1;
+
+
+ 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;
}
- 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;
}
- break;
- }
- switch_yield(1000);
- }
+ 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);
+ }
+
+ 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 ((bytes = tech_pvt->read_codec.implementation->encoded_bytes_per_frame)) {
+ frames = (tech_pvt->read_frame.datalen / bytes);
+ }
+ tech_pvt->read_frame.samples = (int) (frames * tech_pvt->read_codec.implementation->samples_per_frame);
+ }
+ break;
+ }
+ }
+ }
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;
}
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)) {
+ if (!switch_test_flag(tech_pvt, TFLAG_IO)) {
return SWITCH_STATUS_SUCCESS;
}
-
- if (switch_test_flag(tech_pvt, TFLAG_BYE)) {
- return SWITCH_STATUS_FALSE;
- }
-
switch_set_flag_locked(tech_pvt, TFLAG_WRITING);
- 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 {
- frames = 1;
- }
+ 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
+ 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;
+ samples = frames * tech_pvt->read_codec.implementation->samples_per_frame;
}
+#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;
}
return -1;
}
-
if (!bytes && switch_test_flag(rtp_session, SWITCH_RTP_FLAG_BREAK)) {
switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_BREAK);
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) {
}
}
-
-
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) {
return 0;
}
-
- 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)) {
- char *tx_host;
- char *old_host;
- char bufa[30], bufb[30];
- tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->from_addr);
- old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
-
- if ((switch_sockaddr_get_port(rtp_session->from_addr) != rtp_session->remote_port)
- || strcmp(tx_host, old_host)) {
- const char *err;
- uint32_t old = rtp_session->remote_port;
-
- if (!switch_strlen_zero(tx_host) && switch_sockaddr_get_port(rtp_session->from_addr) > 0) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
- "Auto Changing port from %s:%u to %s:%u\n", old_host, old, tx_host,
- switch_sockaddr_get_port(rtp_session->from_addr));
- switch_rtp_set_remote_address(rtp_session, tx_host, switch_sockaddr_get_port(rtp_session->from_addr), &err);
- }
+
+
+ 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];
+ tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->from_addr);
+ old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
+
+ if ((switch_sockaddr_get_port(rtp_session->from_addr) != rtp_session->remote_port)
+ || strcmp(tx_host, old_host)) {
+ const char *err;
+ uint32_t old = rtp_session->remote_port;
+
+ if (!switch_strlen_zero(tx_host) && switch_sockaddr_get_port(rtp_session->from_addr) > 0) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
+ "Auto Changing port from %s:%u to %s:%u\n", old_host, old, tx_host,
+ switch_sockaddr_get_port(rtp_session->from_addr));
+ switch_rtp_set_remote_address(rtp_session, tx_host, switch_sockaddr_get_port(rtp_session->from_addr), &err);
}
- switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
}
+ switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
}
- 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 (bytes && rtp_session->cng_pt && rtp_session->recv_msg.header.pt == rtp_session->cng_pt) {
+ continue;
+ }
- 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;
+
+
+ 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;
+
+
/* RFC2833 ... TBD try harder to honor the duration etc. */
if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_PASS_RFC2833)
&& rtp_session->recv_msg.header.pt == rtp_session->te) {
rtp_session->dtmf_data.dc = 0;
}
}
-
+
continue;
-
}
break;
}
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;
datalen,
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);
energy += abs(decoded[y]);
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 {
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;
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;
projects / thirdparty / freeswitch.git / commitdiff
