|
|
|
@ -1284,12 +1284,12 @@ static void __codec_rtcp_timer_schedule(struct call_media *media) { |
|
|
|
rt->ct.tt_obj.tt = &codec_timers_thread; |
|
|
|
rt->call = obj_get(media->call); |
|
|
|
rt->media = media; |
|
|
|
rt->ct.next = rtpe_now; |
|
|
|
rt->ct.next = timeval_from_us(rtpe_now); |
|
|
|
rt->ct.timer_func = __rtcp_timer_run; |
|
|
|
} |
|
|
|
|
|
|
|
timeval_add_usec(&rt->ct.next, rtpe_config.rtcp_interval * 1000 + (ssl_random() % 1000000)); |
|
|
|
timerthread_obj_schedule_abs(&rt->ct.tt_obj, &rt->ct.next); |
|
|
|
rt->ct.next = timeval_add_usec(rt->ct.next, rtpe_config.rtcp_interval * 1000 + (ssl_random() % 1000000)); |
|
|
|
timerthread_obj_schedule_abs(&rt->ct.tt_obj, rt->ct.next); |
|
|
|
} |
|
|
|
// no lock held |
|
|
|
static void __rtcp_timer_run(struct codec_timer *ct) { |
|
|
|
@ -1978,8 +1978,8 @@ static void __mqtt_timer_run_summary(struct codec_timer *ct) { |
|
|
|
mqtt_timer_run_summary(); |
|
|
|
} |
|
|
|
static void __codec_mqtt_timer_schedule(struct mqtt_timer *mqt) { |
|
|
|
timeval_add_usec(&mqt->ct.next, rtpe_config.mqtt_publish_interval * 1000); |
|
|
|
timerthread_obj_schedule_abs(&mqt->ct.tt_obj, &mqt->ct.next); |
|
|
|
mqt->ct.next = timeval_add_usec(mqt->ct.next, rtpe_config.mqtt_publish_interval * 1000); |
|
|
|
timerthread_obj_schedule_abs(&mqt->ct.tt_obj, mqt->ct.next); |
|
|
|
} |
|
|
|
// master lock held in W |
|
|
|
void mqtt_timer_start(struct mqtt_timer **mqtp, call_t *call, struct call_media *media) { |
|
|
|
@ -1991,7 +1991,7 @@ void mqtt_timer_start(struct mqtt_timer **mqtp, call_t *call, struct call_media |
|
|
|
mqt->call = call ? obj_get(call) : NULL; |
|
|
|
mqt->self = mqtp; |
|
|
|
mqt->media = media; |
|
|
|
mqt->ct.next = rtpe_now; |
|
|
|
mqt->ct.next = timeval_from_us(rtpe_now); |
|
|
|
|
|
|
|
if (media) |
|
|
|
mqt->ct.timer_func = __mqtt_timer_run_media; |
|
|
|
@ -2117,7 +2117,7 @@ static int handler_func_passthrough(struct codec_handler *h, struct media_packet |
|
|
|
uint32_t ts = 0; |
|
|
|
if (mp->rtp) { |
|
|
|
ts = ntohl(mp->rtp->timestamp); |
|
|
|
codec_calc_jitter(mp->ssrc_in, ts, h->source_pt.clock_rate, &mp->tv); |
|
|
|
codec_calc_jitter(mp->ssrc_in, ts, h->source_pt.clock_rate, mp->tv); |
|
|
|
codec_calc_lost(mp->ssrc_in, ntohs(mp->rtp->seq_num)); |
|
|
|
|
|
|
|
if (ML_ISSET(mp->media->monologue, BLOCK_SHORT) && h->source_pt.codec_def |
|
|
|
@ -2401,15 +2401,15 @@ void codec_output_rtp(struct media_packet *mp, struct codec_scheduler *csch, |
|
|
|
ssrc_ctx_hold(ssrc_out); |
|
|
|
p->ssrc_out = ssrc_out; |
|
|
|
|
|
|
|
long long ts_diff_us = 0; |
|
|
|
int64_t ts_diff_us = 0; |
|
|
|
|
|
|
|
gettimeofday(&rtpe_now, NULL); |
|
|
|
rtpe_now = now_us(); |
|
|
|
|
|
|
|
// ignore scheduling if a sequence number was supplied. in that case we're just doing |
|
|
|
// passthrough forwarding (or are handling some other prepared RTP stream) and want |
|
|
|
// to send the packet out immediately. |
|
|
|
if (seq != -1) { |
|
|
|
p->ttq_entry.when = rtpe_now; |
|
|
|
p->ttq_entry.when = timeval_from_us(rtpe_now); |
|
|
|
goto send; |
|
|
|
} |
|
|
|
|
|
|
|
@ -2420,40 +2420,40 @@ void codec_output_rtp(struct media_packet *mp, struct codec_scheduler *csch, |
|
|
|
p->ttq_entry.when = csch->first_send; |
|
|
|
uint32_t ts_diff = (uint32_t) ts - (uint32_t) csch->first_send_ts; // allow for wrap-around |
|
|
|
ts_diff += ts_delay; |
|
|
|
ts_diff_us = (unsigned long long) ts_diff * 1000000 / handler->dest_pt.clock_rate; |
|
|
|
timeval_add_usec(&p->ttq_entry.when, ts_diff_us); |
|
|
|
ts_diff_us = ts_diff * 1000000LL / handler->dest_pt.clock_rate; |
|
|
|
p->ttq_entry.when = timeval_add_usec(p->ttq_entry.when, ts_diff_us); |
|
|
|
|
|
|
|
// how far in the future is this? |
|
|
|
ts_diff_us = timeval_diff(&p->ttq_entry.when, &rtpe_now); |
|
|
|
ts_diff_us = timeval_diff(p->ttq_entry.when, timeval_from_us(rtpe_now)); |
|
|
|
if (ts_diff_us > 1000000 || ts_diff_us < -1000000) // more than one second, can't be right |
|
|
|
csch->first_send.tv_sec = 0; // fix it up below |
|
|
|
} |
|
|
|
if (!csch->first_send.tv_sec || !p->ttq_entry.when.tv_sec) { |
|
|
|
p->ttq_entry.when = csch->first_send = rtpe_now; |
|
|
|
p->ttq_entry.when = csch->first_send = timeval_from_us(rtpe_now); |
|
|
|
csch->first_send_ts = ts; |
|
|
|
} |
|
|
|
|
|
|
|
ts_diff_us = timeval_diff(&p->ttq_entry.when, &rtpe_now); |
|
|
|
ts_diff_us = timeval_diff(p->ttq_entry.when, timeval_from_us(rtpe_now)); |
|
|
|
|
|
|
|
csch->output_skew = csch->output_skew * 15 / 16 + ts_diff_us / 16; |
|
|
|
if (csch->output_skew > 50000 && ts_diff_us > 10000) { // arbitrary value, 50 ms, 10 ms shift |
|
|
|
ilogs(transcoding, LOG_DEBUG, "Steady clock skew of %li.%01li ms detected, shifting send timer back by 10 ms", |
|
|
|
csch->output_skew / 1000, |
|
|
|
(csch->output_skew % 1000) / 100); |
|
|
|
timeval_add_usec(&p->ttq_entry.when, -10000); |
|
|
|
p->ttq_entry.when = timeval_add_usec(p->ttq_entry.when, -10000); |
|
|
|
csch->output_skew -= 10000; |
|
|
|
csch->first_send_ts += handler->dest_pt.clock_rate / 100; |
|
|
|
ts_diff_us = timeval_diff(&p->ttq_entry.when, &rtpe_now); |
|
|
|
ts_diff_us = timeval_diff(p->ttq_entry.when, timeval_from_us(rtpe_now)); |
|
|
|
} |
|
|
|
else if (ts_diff_us < 0) { |
|
|
|
ts_diff_us *= -1; |
|
|
|
ilogs(transcoding, LOG_DEBUG, "Negative clock skew of %lli.%01lli ms detected, shifting send timer forward", |
|
|
|
ilogs(transcoding, LOG_DEBUG, "Negative clock skew of %" PRId64 ".%01" PRId64 " ms detected, shifting send timer forward", |
|
|
|
ts_diff_us / 1000, |
|
|
|
(ts_diff_us % 1000) / 100); |
|
|
|
timeval_add_usec(&p->ttq_entry.when, ts_diff_us); |
|
|
|
p->ttq_entry.when = timeval_add_usec(p->ttq_entry.when, ts_diff_us); |
|
|
|
csch->output_skew = 0; |
|
|
|
csch->first_send_ts -= (long long) handler->dest_pt.clock_rate * ts_diff_us / 1000000; |
|
|
|
ts_diff_us = timeval_diff(&p->ttq_entry.when, &rtpe_now); // should be 0 now |
|
|
|
ts_diff_us = timeval_diff(p->ttq_entry.when, timeval_from_us(rtpe_now)); // should be 0 now |
|
|
|
} |
|
|
|
|
|
|
|
send: |
|
|
|
@ -2953,7 +2953,7 @@ static int handler_func_passthrough_ssrc(struct codec_handler *h, struct media_p |
|
|
|
return 0; |
|
|
|
|
|
|
|
uint32_t ts = ntohl(mp->rtp->timestamp); |
|
|
|
codec_calc_jitter(mp->ssrc_in, ts, h->source_pt.clock_rate, &mp->tv); |
|
|
|
codec_calc_jitter(mp->ssrc_in, ts, h->source_pt.clock_rate, mp->tv); |
|
|
|
codec_calc_lost(mp->ssrc_in, ntohs(mp->rtp->seq_num)); |
|
|
|
|
|
|
|
// save original payload in case DTMF mangles it |
|
|
|
@ -3110,17 +3110,17 @@ static int codec_decoder_event(enum codec_event event, void *ptr, void *data) { |
|
|
|
case CE_AMR_CMR_RECV: |
|
|
|
// ignore locking and races for this |
|
|
|
media->encoder_callback.amr.cmr_in = GPOINTER_TO_UINT(ptr); |
|
|
|
media->encoder_callback.amr.cmr_in_ts = rtpe_now; |
|
|
|
media->encoder_callback.amr.cmr_in_ts = timeval_from_us(rtpe_now); |
|
|
|
break; |
|
|
|
case CE_AMR_SEND_CMR: |
|
|
|
// ignore locking and races for this |
|
|
|
media->encoder_callback.amr.cmr_out = GPOINTER_TO_UINT(ptr); |
|
|
|
media->encoder_callback.amr.cmr_out_ts = rtpe_now; |
|
|
|
media->encoder_callback.amr.cmr_out_ts = timeval_from_us(rtpe_now); |
|
|
|
break; |
|
|
|
case CE_EVS_CMR_RECV: |
|
|
|
// ignore locking and races for this |
|
|
|
media->encoder_callback.evs.cmr_in = GPOINTER_TO_UINT(ptr); |
|
|
|
media->encoder_callback.evs.cmr_in_ts = rtpe_now; |
|
|
|
media->encoder_callback.evs.cmr_in_ts = timeval_from_us(rtpe_now); |
|
|
|
break; |
|
|
|
default: |
|
|
|
break; |
|
|
|
@ -3138,9 +3138,9 @@ static void __delay_buffer_schedule(struct delay_buffer *dbuf) { |
|
|
|
return; |
|
|
|
|
|
|
|
struct timeval to_run = dframe->mp.tv; |
|
|
|
timeval_add_usec(&to_run, dbuf->delay * 1000); |
|
|
|
to_run = timeval_add_usec(to_run, dbuf->delay * 1000); |
|
|
|
dbuf->ct.next = to_run; |
|
|
|
timerthread_obj_schedule_abs(&dbuf->ct.tt_obj, &dbuf->ct.next); |
|
|
|
timerthread_obj_schedule_abs(&dbuf->ct.tt_obj, dbuf->ct.next); |
|
|
|
} |
|
|
|
|
|
|
|
static bool __buffer_delay_do_direct(struct delay_buffer *dbuf) { |
|
|
|
@ -3153,7 +3153,7 @@ static bool __buffer_delay_do_direct(struct delay_buffer *dbuf) { |
|
|
|
} |
|
|
|
|
|
|
|
static int delay_frame_cmp(const struct delay_frame *a, const struct delay_frame *b, void *ptr) { |
|
|
|
return -1 * timeval_cmp(&a->mp.tv, &b->mp.tv); |
|
|
|
return -1 * timeval_cmp(a->mp.tv, b->mp.tv); |
|
|
|
} |
|
|
|
|
|
|
|
INLINE struct codec_ssrc_handler *ssrc_handler_get(struct codec_ssrc_handler *ch) { |
|
|
|
@ -3315,7 +3315,7 @@ static bool __buffer_dtx(struct dtx_buffer *dtxb, struct codec_ssrc_handler *dec |
|
|
|
|
|
|
|
mutex_lock(&dtxb->lock); |
|
|
|
|
|
|
|
dtxb->start = rtpe_now.tv_sec; |
|
|
|
dtxb->start = timeval_from_us(rtpe_now).tv_sec; |
|
|
|
t_queue_push_tail(&dtxb->packets, dtxp); |
|
|
|
ilogs(dtx, LOG_DEBUG, "Adding packet (TS %lu) to DTX buffer; now %i packets in DTX queue", |
|
|
|
ts, dtxb->packets.length); |
|
|
|
@ -3325,8 +3325,8 @@ static bool __buffer_dtx(struct dtx_buffer *dtxb, struct codec_ssrc_handler *dec |
|
|
|
if (!dtxb->ssrc) |
|
|
|
dtxb->ssrc = mp->ssrc_in->parent->h.ssrc; |
|
|
|
dtxb->ct.next = mp->tv; |
|
|
|
timeval_add_usec(&dtxb->ct.next, rtpe_config.dtx_delay * 1000); |
|
|
|
timerthread_obj_schedule_abs(&dtxb->ct.tt_obj, &dtxb->ct.next); |
|
|
|
dtxb->ct.next = timeval_add_usec(dtxb->ct.next, rtpe_config.dtx_delay * 1000); |
|
|
|
timerthread_obj_schedule_abs(&dtxb->ct.tt_obj, dtxb->ct.next); |
|
|
|
} |
|
|
|
|
|
|
|
// packet now consumed if there was one |
|
|
|
@ -3629,7 +3629,7 @@ static bool __dtx_drift_shift(struct dtx_buffer *dtxb, unsigned long ts, |
|
|
|
"(%li ms < %i ms), " |
|
|
|
"pushing DTX timer forward my %i ms", |
|
|
|
tv_diff / 1000, rtpe_config.dtx_delay, rtpe_config.dtx_shift); |
|
|
|
timeval_add_usec(&dtxb->ct.next, rtpe_config.dtx_shift * 1000); |
|
|
|
dtxb->ct.next = timeval_add_usec(dtxb->ct.next, rtpe_config.dtx_shift * 1000); |
|
|
|
} |
|
|
|
else if (ts_diff < dtxb->tspp) { |
|
|
|
// TS underflow |
|
|
|
@ -3642,7 +3642,7 @@ static bool __dtx_drift_shift(struct dtx_buffer *dtxb, unsigned long ts, |
|
|
|
"(TS %lu, diff %li), " |
|
|
|
"pushing DTX timer forward by %i ms and discarding packet", |
|
|
|
ts, ts_diff, rtpe_config.dtx_shift); |
|
|
|
timeval_add_usec(&dtxb->ct.next, rtpe_config.dtx_shift * 1000); |
|
|
|
dtxb->ct.next = timeval_add_usec(dtxb->ct.next, rtpe_config.dtx_shift * 1000); |
|
|
|
discard = true; |
|
|
|
} |
|
|
|
} |
|
|
|
@ -3656,7 +3656,7 @@ static bool __dtx_drift_shift(struct dtx_buffer *dtxb, unsigned long ts, |
|
|
|
ilogs(dtx, LOG_DEBUG, "DTX timer queue overflowing (%i packets in queue, " |
|
|
|
"%lli ms delay), speeding up DTX timer by %i ms", |
|
|
|
dtxb->packets.length, ts_diff_us / 1000, rtpe_config.dtx_shift); |
|
|
|
timeval_add_usec(&dtxb->ct.next, rtpe_config.dtx_shift * -1000); |
|
|
|
dtxb->ct.next = timeval_add_usec(dtxb->ct.next, rtpe_config.dtx_shift * -1000); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
@ -3712,7 +3712,7 @@ static void __dtx_send_later(struct codec_timer *ct) { |
|
|
|
int ret = 0; |
|
|
|
unsigned long ts; |
|
|
|
int p_left = 0; |
|
|
|
long tv_diff = -1, ts_diff = 0; |
|
|
|
int64_t tv_diff = -1, ts_diff = 0; |
|
|
|
|
|
|
|
mutex_lock(&dtxb->lock); |
|
|
|
|
|
|
|
@ -3769,7 +3769,7 @@ static void __dtx_send_later(struct codec_timer *ct) { |
|
|
|
ts = dtxb->head_ts = dtxp->packet->ts; |
|
|
|
else |
|
|
|
ts = dtxb->head_ts; |
|
|
|
tv_diff = timeval_diff(&rtpe_now, &mp_copy.tv); |
|
|
|
tv_diff = timeval_diff(timeval_from_us(rtpe_now), mp_copy.tv); |
|
|
|
} |
|
|
|
else { |
|
|
|
// no packet ready to decode: DTX |
|
|
|
@ -3921,7 +3921,7 @@ static void __dtx_send_later(struct codec_timer *ct) { |
|
|
|
"Decoder error while processing buffered RTP packet"); |
|
|
|
} |
|
|
|
else { |
|
|
|
int diff = rtpe_now.tv_sec - dtxb_start; |
|
|
|
int diff = timeval_from_us(rtpe_now).tv_sec - dtxb_start; |
|
|
|
|
|
|
|
if (rtpe_config.max_dtx <= 0 || diff < rtpe_config.max_dtx) { |
|
|
|
ilogs(dtx, LOG_DEBUG, "RTP media for TS %lu missing, triggering DTX", ts); |
|
|
|
@ -3954,8 +3954,8 @@ static void __dtx_send_later(struct codec_timer *ct) { |
|
|
|
} |
|
|
|
|
|
|
|
// schedule next run |
|
|
|
timeval_add_usec(&dtxb->ct.next, dtxb->ptime * 1000); |
|
|
|
timerthread_obj_schedule_abs(&dtxb->ct.tt_obj, &dtxb->ct.next); |
|
|
|
dtxb->ct.next = timeval_add_usec(dtxb->ct.next, dtxb->ptime * 1000); |
|
|
|
timerthread_obj_schedule_abs(&dtxb->ct.tt_obj, dtxb->ct.next); |
|
|
|
|
|
|
|
mutex_unlock(&dtxb->lock); |
|
|
|
|
|
|
|
@ -4215,7 +4215,7 @@ static void async_chain_finish(AVPacket *pkt, void *async_cb_obj) { |
|
|
|
struct transcode_job *j = async_cb_obj; |
|
|
|
struct call *call = j->mp.call; |
|
|
|
|
|
|
|
gettimeofday(&rtpe_now, NULL); |
|
|
|
rtpe_now = now_us(); |
|
|
|
|
|
|
|
if (pkt) { |
|
|
|
rwlock_lock_r(&call->master_lock); |
|
|
|
@ -4615,7 +4615,7 @@ static int packet_decoded_common(decoder_t *decoder, AVFrame *frame, void *u1, v |
|
|
|
|
|
|
|
struct codec_handler *h = ch->handler; |
|
|
|
if (h->stats_entry) { |
|
|
|
int idx = rtpe_now.tv_sec & 1; |
|
|
|
int idx = timeval_from_us(rtpe_now).tv_sec & 1; |
|
|
|
atomic64_add(&h->stats_entry->pcm_samples[idx], frame->nb_samples); |
|
|
|
atomic64_add(&h->stats_entry->pcm_samples[2], frame->nb_samples); |
|
|
|
} |
|
|
|
@ -4827,7 +4827,7 @@ void codec_update_all_source_handlers(struct call_monologue *ml, const sdp_ng_fl |
|
|
|
|
|
|
|
|
|
|
|
void codec_calc_jitter(struct ssrc_ctx *ssrc, unsigned long ts, unsigned int clockrate, |
|
|
|
const struct timeval *tv) |
|
|
|
const struct timeval tv) |
|
|
|
{ |
|
|
|
if (!ssrc || !clockrate) |
|
|
|
return; |
|
|
|
@ -4927,14 +4927,14 @@ static int handler_func_transcode(struct codec_handler *h, struct media_packet * |
|
|
|
ntohl(mp->rtp->timestamp), mp->payload.len); |
|
|
|
|
|
|
|
codec_calc_jitter(mp->ssrc_in, ntohl(mp->rtp->timestamp), h->input_handler->source_pt.clock_rate, |
|
|
|
&mp->tv); |
|
|
|
mp->tv); |
|
|
|
|
|
|
|
if (h->stats_entry) { |
|
|
|
unsigned int idx = rtpe_now.tv_sec & 1; |
|
|
|
unsigned int idx = timeval_from_us(rtpe_now).tv_sec & 1; |
|
|
|
int last_tv_sec = atomic_get_na(&h->stats_entry->last_tv_sec[idx]); |
|
|
|
if (last_tv_sec != (int) rtpe_now.tv_sec) { |
|
|
|
if (last_tv_sec != (int) timeval_from_us(rtpe_now).tv_sec) { |
|
|
|
if (g_atomic_int_compare_and_exchange(&h->stats_entry->last_tv_sec[idx], |
|
|
|
last_tv_sec, rtpe_now.tv_sec)) |
|
|
|
last_tv_sec, timeval_from_us(rtpe_now).tv_sec)) |
|
|
|
{ |
|
|
|
// new second - zero out stats. slight race condition here |
|
|
|
atomic64_set(&h->stats_entry->packets_input[idx], 0); |
|
|
|
@ -6245,9 +6245,9 @@ void codec_timer_callback(call_t *c, void (*func)(call_t *, codec_timer_callback |
|
|
|
cb->timer_callback_func = func; |
|
|
|
cb->arg = a; |
|
|
|
cb->ct.timer_func = __codec_timer_callback_fire; |
|
|
|
cb->ct.next = rtpe_now; |
|
|
|
timeval_add_usec(&cb->ct.next, delay); |
|
|
|
timerthread_obj_schedule_abs(&cb->ct.tt_obj, &cb->ct.next); |
|
|
|
cb->ct.next = timeval_from_us(rtpe_now); |
|
|
|
cb->ct.next = timeval_add_usec(cb->ct.next, delay); |
|
|
|
timerthread_obj_schedule_abs(&cb->ct.tt_obj, cb->ct.next); |
|
|
|
} |
|
|
|
|
|
|
|
static void codec_timers_run(void *p) { |
|
|
|
@ -6329,7 +6329,7 @@ static void codec_worker(void *d) { |
|
|
|
|
|
|
|
mutex_unlock(&transcode_lock); |
|
|
|
|
|
|
|
gettimeofday(&rtpe_now, NULL); |
|
|
|
rtpe_now = now_us(); |
|
|
|
transcode_job_do(j); |
|
|
|
|
|
|
|
mutex_lock(&transcode_lock); |
|
|
|
|
Richard Fuchs
8 months ago