|
|
|
@ -15,6 +15,7 @@ |
|
|
|
#include "t38.h" |
|
|
|
#include "media_player.h" |
|
|
|
#include "timerthread.h" |
|
|
|
#include "log_funcs.h" |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@ -63,6 +64,24 @@ static GList *__delete_receiver_codec(struct call_media *receiver, GList *link) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct codec_ssrc_handler; |
|
|
|
|
|
|
|
struct dtx_buffer { |
|
|
|
struct timerthread_queue ttq; |
|
|
|
mutex_t lock; |
|
|
|
struct codec_ssrc_handler *csh; |
|
|
|
int ptime; // ms per packet |
|
|
|
int tspp; // timestamp increment per packet |
|
|
|
struct call *call; |
|
|
|
unsigned long ts; |
|
|
|
}; |
|
|
|
struct dtx_entry { |
|
|
|
struct timerthread_queue_entry ttq_entry; |
|
|
|
struct transcode_packet *packet; |
|
|
|
struct media_packet mp; |
|
|
|
unsigned long ts; |
|
|
|
}; |
|
|
|
|
|
|
|
struct codec_ssrc_handler { |
|
|
|
struct ssrc_entry h; // must be first |
|
|
|
struct codec_handler *handler; |
|
|
|
@ -77,6 +96,7 @@ struct codec_ssrc_handler { |
|
|
|
struct timeval first_send; |
|
|
|
unsigned long first_send_ts; |
|
|
|
GString *sample_buffer; |
|
|
|
struct dtx_buffer *dtx_buffer; |
|
|
|
|
|
|
|
// DTMF DSP stuff |
|
|
|
dtmf_rx_state_t *dtmf_dsp; |
|
|
|
@ -1380,7 +1400,7 @@ static int __handler_func_sequencer(struct media_packet *mp, struct transcode_pa |
|
|
|
atomic64_set(&ssrc_in->packets_lost, ssrc_in_p->sequencer.lost_count); |
|
|
|
atomic64_set(&ssrc_in->last_seq, ssrc_in_p->sequencer.ext_seq); |
|
|
|
|
|
|
|
ilog(LOG_DEBUG, "Decoding RTP packet: seq %u, TS %lu", |
|
|
|
ilog(LOG_DEBUG, "Processing RTP packet: seq %u, TS %lu", |
|
|
|
packet->p.seq, packet->ts); |
|
|
|
|
|
|
|
if (seq_ret == 1) { |
|
|
|
@ -1834,6 +1854,153 @@ static int codec_decoder_event(enum codec_event event, void *ptr, void *data) { |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
static void __dtx_add_callback(struct dtx_buffer *dtxb, const struct timeval *base, unsigned int offset, |
|
|
|
const struct media_packet *mp, unsigned long ts, int seq_add) |
|
|
|
{ |
|
|
|
struct dtx_entry *dtxe = g_slice_alloc0(sizeof(*dtxe)); |
|
|
|
dtxe->ttq_entry.when = *base; |
|
|
|
timeval_add_usec(&dtxe->ttq_entry.when, offset); |
|
|
|
dtxe->ts = ts; |
|
|
|
media_packet_copy(&dtxe->mp, mp); |
|
|
|
dtxe->mp.rtp->seq_num += htons(seq_add); |
|
|
|
timerthread_queue_push(&dtxb->ttq, &dtxe->ttq_entry); |
|
|
|
} |
|
|
|
|
|
|
|
static void __dtx_entry_free(void *p) { |
|
|
|
struct dtx_entry *dtxe = p; |
|
|
|
if (dtxe->packet) |
|
|
|
__transcode_packet_free(dtxe->packet); |
|
|
|
media_packet_release(&dtxe->mp); |
|
|
|
g_slice_free1(sizeof(*dtxe), dtxe); |
|
|
|
} |
|
|
|
static void __dtx_send_later(struct timerthread_queue *ttq, void *p) { |
|
|
|
struct dtx_buffer *dtxb = (void *) ttq; |
|
|
|
struct dtx_entry *dtxe = p; |
|
|
|
struct transcode_packet *packet = dtxe->packet; |
|
|
|
struct media_packet *mp = &dtxe->mp; |
|
|
|
struct packet_stream *ps = mp->stream; |
|
|
|
struct packet_stream *sink = ps->rtp_sink; |
|
|
|
int ret = 0; |
|
|
|
|
|
|
|
mutex_lock(&dtxb->lock); |
|
|
|
struct codec_ssrc_handler *ch = dtxb->csh ? obj_get(&dtxb->csh->h) : NULL; |
|
|
|
struct call *call = dtxb->call ? obj_get(dtxb->call) : NULL; |
|
|
|
mutex_unlock(&dtxb->lock); |
|
|
|
|
|
|
|
if (!call) |
|
|
|
goto out; // shut down |
|
|
|
|
|
|
|
log_info_stream_fd(mp->sfd); |
|
|
|
|
|
|
|
rwlock_lock_r(&call->master_lock); |
|
|
|
__ssrc_lock_both(mp); |
|
|
|
|
|
|
|
if (packet) { |
|
|
|
ilog(LOG_DEBUG, "Decoding DTX-buffered RTP packet (TS %lu) now", packet->ts); |
|
|
|
|
|
|
|
ret = decoder_input_data(ch->decoder, packet->payload, packet->ts, |
|
|
|
ch->handler->packet_decoded, ch, &dtxe->mp); |
|
|
|
mp->ssrc_out->parent->seq_diff--; |
|
|
|
if (ret) |
|
|
|
ilog(LOG_WARN | LOG_FLAG_LIMIT, "Decoder error while processing buffered RTP packet"); |
|
|
|
} |
|
|
|
else { |
|
|
|
unsigned long dtxe_ts = dtxe->ts; |
|
|
|
|
|
|
|
mutex_lock(&dtxb->lock); |
|
|
|
unsigned long dtxb_ts = dtxb->ts; |
|
|
|
|
|
|
|
if (dtxe_ts == dtxb_ts) { |
|
|
|
ilog(LOG_DEBUG, "RTP media for TS %lu+ missing, triggering DTX", |
|
|
|
dtxe_ts); |
|
|
|
|
|
|
|
dtxb_ts += dtxb->tspp; |
|
|
|
dtxe_ts = dtxb_ts; |
|
|
|
dtxb->ts = dtxb_ts; |
|
|
|
mutex_unlock(&dtxb->lock); |
|
|
|
|
|
|
|
ret = decoder_lost_packet(ch->decoder, dtxe_ts, |
|
|
|
ch->handler->packet_decoded, ch, &dtxe->mp); |
|
|
|
if (ret) |
|
|
|
ilog(LOG_WARN | LOG_FLAG_LIMIT, "Decoder error handling DTX/lost packet"); |
|
|
|
|
|
|
|
__dtx_add_callback(dtxb, &dtxe->ttq_entry.when, dtxb->ptime * 1000, mp, dtxe_ts, 0); |
|
|
|
} |
|
|
|
else |
|
|
|
mutex_unlock(&dtxb->lock); |
|
|
|
} |
|
|
|
|
|
|
|
__ssrc_unlock_both(mp); |
|
|
|
|
|
|
|
if (mp->packets_out.length && ret == 0) { |
|
|
|
if (ps->handler && media_packet_encrypt(ps->handler->out->rtp_crypt, sink, mp)) |
|
|
|
ilog(LOG_ERR | LOG_FLAG_LIMIT, "Error encrypting buffered RTP media"); |
|
|
|
|
|
|
|
mutex_lock(&sink->out_lock); |
|
|
|
if (media_socket_dequeue(mp, sink)) |
|
|
|
ilog(LOG_ERR | LOG_FLAG_LIMIT, "Error sending buffered media to RTP sink"); |
|
|
|
mutex_unlock(&sink->out_lock); |
|
|
|
} |
|
|
|
|
|
|
|
rwlock_unlock_r(&call->master_lock); |
|
|
|
obj_put(call); |
|
|
|
obj_put(&ch->h); |
|
|
|
|
|
|
|
out: |
|
|
|
__dtx_entry_free(dtxe); |
|
|
|
log_info_clear(); |
|
|
|
} |
|
|
|
static void __dtx_shutdown(struct dtx_buffer *dtxb) { |
|
|
|
if (dtxb->csh) |
|
|
|
obj_put(&dtxb->csh->h); |
|
|
|
dtxb->csh = NULL; |
|
|
|
if (dtxb->call) |
|
|
|
obj_put(dtxb->call); |
|
|
|
dtxb->call = NULL; |
|
|
|
} |
|
|
|
static void __dtx_free(void *p) { |
|
|
|
struct dtx_buffer *dtxb = p; |
|
|
|
ilog(LOG_DEBUG, "__dtx_free"); |
|
|
|
__dtx_shutdown(dtxb); |
|
|
|
mutex_destroy(&dtxb->lock); |
|
|
|
} |
|
|
|
static void __dtx_setup(struct codec_ssrc_handler *ch) { |
|
|
|
if (!ch->handler->source_pt.codec_def->packet_lost || ch->dtx_buffer) |
|
|
|
return; |
|
|
|
|
|
|
|
if (!rtpe_config.dtx_delay) |
|
|
|
return; |
|
|
|
|
|
|
|
struct dtx_buffer *dtx = |
|
|
|
ch->dtx_buffer = timerthread_queue_new("dtx_buffer", sizeof(*ch->dtx_buffer), |
|
|
|
&codec_timers_thread, NULL, __dtx_send_later, __dtx_free, __dtx_entry_free); |
|
|
|
dtx->csh = obj_get(&ch->h); |
|
|
|
dtx->call = obj_get(ch->handler->media->call); |
|
|
|
mutex_init(&dtx->lock); |
|
|
|
dtx->ptime = ch->ptime; |
|
|
|
if (!dtx->ptime) |
|
|
|
dtx->ptime = 20; // XXX ? |
|
|
|
dtx->tspp = dtx->ptime * ch->handler->source_pt.clock_rate / 1000; |
|
|
|
} |
|
|
|
void __ssrc_handler_stop(void *p) { |
|
|
|
struct codec_ssrc_handler *ch = p; |
|
|
|
if (ch->dtx_buffer) { |
|
|
|
mutex_lock(&ch->dtx_buffer->lock); |
|
|
|
__dtx_shutdown(ch->dtx_buffer); |
|
|
|
mutex_unlock(&ch->dtx_buffer->lock); |
|
|
|
|
|
|
|
obj_put(&ch->dtx_buffer->ttq.tt_obj); |
|
|
|
ch->dtx_buffer = NULL; |
|
|
|
} |
|
|
|
} |
|
|
|
void codec_handlers_stop(GQueue *q) { |
|
|
|
for (GList *l = q->head; l; l = l->next) { |
|
|
|
struct codec_handler *h = l->data; |
|
|
|
ssrc_hash_foreach(h->ssrc_hash, __ssrc_handler_stop); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static struct ssrc_entry *__ssrc_handler_transcode_new(void *p) { |
|
|
|
struct codec_handler *h = p; |
|
|
|
|
|
|
|
@ -1894,6 +2061,8 @@ static struct ssrc_entry *__ssrc_handler_transcode_new(void *p) { |
|
|
|
ch->bytes_per_packet = (ch->encoder->samples_per_packet ? : ch->encoder->samples_per_frame) |
|
|
|
* h->dest_pt.codec_def->bits_per_sample / 8; |
|
|
|
|
|
|
|
__dtx_setup(ch); |
|
|
|
|
|
|
|
ilog(LOG_DEBUG, "Encoder created with clockrate %i, %i channels, using sample format %i " |
|
|
|
"(ptime %i for %i samples per frame and %i samples (%i bytes) per packet, bitrate %i)", |
|
|
|
ch->encoder_format.clockrate, ch->encoder_format.channels, ch->encoder_format.format, |
|
|
|
@ -1930,6 +2099,8 @@ static void __free_ssrc_handler(void *chp) { |
|
|
|
dtmf_rx_free(ch->dtmf_dsp); |
|
|
|
resample_shutdown(&ch->dtmf_resampler); |
|
|
|
g_queue_clear_full(&ch->dtmf_events, dtmf_event_free); |
|
|
|
if (ch->dtx_buffer) |
|
|
|
obj_put(&ch->dtx_buffer->ttq.tt_obj); |
|
|
|
} |
|
|
|
|
|
|
|
static int packet_encoded_rtp(encoder_t *enc, void *u1, void *u2) { |
|
|
|
@ -2116,11 +2287,43 @@ static int packet_decoded_direct(decoder_t *decoder, AVFrame *frame, void *u1, v |
|
|
|
|
|
|
|
static int packet_decode(struct codec_ssrc_handler *ch, struct transcode_packet *packet, struct media_packet *mp) |
|
|
|
{ |
|
|
|
int ret = 0; |
|
|
|
|
|
|
|
if (!ch->first_ts) |
|
|
|
ch->first_ts = packet->ts; |
|
|
|
int ret = decoder_input_data(ch->decoder, packet->payload, packet->ts, ch->handler->packet_decoded, ch, mp); |
|
|
|
//mp->iter_in++; |
|
|
|
mp->ssrc_out->parent->seq_diff--; |
|
|
|
|
|
|
|
if (ch->dtx_buffer && mp->sfd && mp->ssrc_in && mp->ssrc_out) { |
|
|
|
ilog(LOG_DEBUG, "Adding packet to DTX buffer"); |
|
|
|
|
|
|
|
struct dtx_buffer *dtxb = ch->dtx_buffer; |
|
|
|
unsigned long ts = packet->ts; |
|
|
|
|
|
|
|
mutex_lock(&dtxb->lock); |
|
|
|
if (ts != dtxb->ts) |
|
|
|
dtxb->ts = ts; |
|
|
|
mutex_unlock(&dtxb->lock); |
|
|
|
|
|
|
|
struct dtx_entry *dtxe = g_slice_alloc0(sizeof(*dtxe)); |
|
|
|
dtxe->ttq_entry.when = rtpe_now; |
|
|
|
timeval_add_usec(&dtxe->ttq_entry.when, rtpe_config.dtx_delay * 1000); |
|
|
|
dtxe->packet = packet; |
|
|
|
media_packet_copy(&dtxe->mp, mp); |
|
|
|
timerthread_queue_push(&dtxb->ttq, &dtxe->ttq_entry); |
|
|
|
// packet now consumed |
|
|
|
packet = NULL; |
|
|
|
|
|
|
|
__dtx_add_callback(dtxb, &rtpe_now, (rtpe_config.dtx_delay + dtxb->ptime) * 1000, mp, ts, 1); |
|
|
|
|
|
|
|
ret = 1; |
|
|
|
} |
|
|
|
else { |
|
|
|
ilog(LOG_DEBUG, "Decoding RTP packet now"); |
|
|
|
ret = decoder_input_data(ch->decoder, packet->payload, packet->ts, ch->handler->packet_decoded, |
|
|
|
ch, mp); |
|
|
|
ret = ret ? -1 : 0; |
|
|
|
mp->ssrc_out->parent->seq_diff--; |
|
|
|
} |
|
|
|
|
|
|
|
return ret; |
|
|
|
} |
|
|
|
|
|
|
|
|
Richard Fuchs
5 years ago