sipwise
/
rtpengine
mirror of https://github.com/sipwise/rtpengine.git
1
0
Fork 0
Code Issues Releases Wiki Activity

MT#55283 move SSRC hash from monologue to media

Browse Source 
Change-Id: Id03603982692e9f6aef3b96d2a04514459eb30a7
pull/1126/merge
Richard Fuchs 2 months ago
parent 56f171b64e
commit 954bac923b
15 changed files with 119 additions and 123 deletions
Show Stats Download Patch File Download Diff File

100
daemon/call.c
Unescape View File

@ -669,6 +669,7 @@ struct call_media *call_media_new(call_t *call) {
mutex_init(&med->dtmf_lock);
med->sdp_attr_print = sdp_insert_media_attributes;
RESET_BANDWIDTH(med->sdp_media_bandwidth, -1);
med->ssrc_hash = create_ssrc_hash_call();
return med;
}
@ -4180,57 +4181,57 @@ void call_destroy(call_t *c) {
atomic64_get_na(&ps->stats_out->bytes),
atomic64_get_na(&ps->stats_out->errors));
}
}
for (k = ml->ssrc_hash->nq.head; k; k = k->next) {
struct ssrc_entry_call *se = k->data;
for (k = md->ssrc_hash->nq.head; k; k = k->next) {
struct ssrc_entry_call *se = k->data;
// stats output only - no cleanups
// stats output only - no cleanups
if (!se->stats_blocks.length || !se->lowest_mos || !se->highest_mos)
continue;
int mos_samples = (se->stats_blocks.length - se->no_mos_count);
if (mos_samples < 1) mos_samples = 1;
ilog(LOG_INFO, "--- SSRC %s%" PRIx32 "%s", FMT_M(se->h.ssrc));
ilog(LOG_INFO, "------ Average MOS %" PRIu64 ".%" PRIu64 ", "
"lowest MOS %" PRIu64 ".%" PRIu64 " (at %u:%02u), "
"highest MOS %" PRIu64 ".%" PRIu64 " (at %u:%02u) lost:%u",
se->average_mos.mos / mos_samples / 10,
se->average_mos.mos / mos_samples % 10,
se->lowest_mos->mos / 10,
se->lowest_mos->mos % 10,
(unsigned int) (timeval_diff(&se->lowest_mos->reported, &c->created) / 1000000) / 60,
(unsigned int) (timeval_diff(&se->lowest_mos->reported, &c->created) / 1000000) % 60,
se->highest_mos->mos / 10,
se->highest_mos->mos % 10,
(unsigned int) (timeval_diff(&se->highest_mos->reported, &c->created) / 1000000) / 60,
(unsigned int) (timeval_diff(&se->highest_mos->reported, &c->created) / 1000000) % 60,
(unsigned int) se->packets_lost);
ilog(LOG_INFO, "------ respective (avg/min/max) jitter %" PRIu64 "/%" PRIu64 "/%" PRIu64 " ms, "
"RTT-e2e %" PRIu64 ".%" PRIu64 "/%" PRIu64 ".%" PRIu64
"/%" PRIu64 ".%" PRIu64 " ms, "
"RTT-dsct %" PRIu32 ".%" PRIu32 "/%" PRIu32 ".%" PRIu32
"/%" PRIu32 ".%" PRIu32 " ms, "
"packet loss %" PRIu64 "/%" PRIu64 "/%" PRIu64 "%%",
se->average_mos.jitter / mos_samples,
se->lowest_mos->jitter,
se->highest_mos->jitter,
se->average_mos.rtt / mos_samples / 1000,
(se->average_mos.rtt / mos_samples / 100) % 10,
se->lowest_mos->rtt / 1000,
(se->lowest_mos->rtt / 100) % 10,
se->highest_mos->rtt / 1000,
(se->highest_mos->rtt / 100) % 10,
se->average_mos.rtt_leg / mos_samples / 1000,
(se->average_mos.rtt_leg / mos_samples / 100) % 10,
se->lowest_mos->rtt_leg / 1000,
(se->lowest_mos->rtt_leg / 100) % 10,
se->highest_mos->rtt_leg / 1000,
(se->highest_mos->rtt_leg / 100) % 10,
se->average_mos.packetloss / mos_samples,
se->lowest_mos->packetloss,
se->highest_mos->packetloss);
if (!se->stats_blocks.length || !se->lowest_mos || !se->highest_mos)
continue;
int mos_samples = (se->stats_blocks.length - se->no_mos_count);
if (mos_samples < 1) mos_samples = 1;
ilog(LOG_INFO, "--- SSRC %s%" PRIx32 "%s", FMT_M(se->h.ssrc));
ilog(LOG_INFO, "------ Average MOS %" PRIu64 ".%" PRIu64 ", "
"lowest MOS %" PRIu64 ".%" PRIu64 " (at %u:%02u), "
"highest MOS %" PRIu64 ".%" PRIu64 " (at %u:%02u) lost:%u",
se->average_mos.mos / mos_samples / 10,
se->average_mos.mos / mos_samples % 10,
se->lowest_mos->mos / 10,
se->lowest_mos->mos % 10,
(unsigned int) (timeval_diff(&se->lowest_mos->reported, &c->created) / 1000000) / 60,
(unsigned int) (timeval_diff(&se->lowest_mos->reported, &c->created) / 1000000) % 60,
se->highest_mos->mos / 10,
se->highest_mos->mos % 10,
(unsigned int) (timeval_diff(&se->highest_mos->reported, &c->created) / 1000000) / 60,
(unsigned int) (timeval_diff(&se->highest_mos->reported, &c->created) / 1000000) % 60,
(unsigned int) se->packets_lost);
ilog(LOG_INFO, "------ respective (avg/min/max) jitter %" PRIu64 "/%" PRIu64 "/%" PRIu64 " ms, "
"RTT-e2e %" PRIu64 ".%" PRIu64 "/%" PRIu64 ".%" PRIu64
"/%" PRIu64 ".%" PRIu64 " ms, "
"RTT-dsct %" PRIu32 ".%" PRIu32 "/%" PRIu32 ".%" PRIu32
"/%" PRIu32 ".%" PRIu32 " ms, "
"packet loss %" PRIu64 "/%" PRIu64 "/%" PRIu64 "%%",
se->average_mos.jitter / mos_samples,
se->lowest_mos->jitter,
se->highest_mos->jitter,
se->average_mos.rtt / mos_samples / 1000,
(se->average_mos.rtt / mos_samples / 100) % 10,
se->lowest_mos->rtt / 1000,
(se->lowest_mos->rtt / 100) % 10,
se->highest_mos->rtt / 1000,
(se->highest_mos->rtt / 100) % 10,
se->average_mos.rtt_leg / mos_samples / 1000,
(se->average_mos.rtt_leg / mos_samples / 100) % 10,
se->lowest_mos->rtt_leg / 1000,
(se->lowest_mos->rtt_leg / 100) % 10,
se->highest_mos->rtt_leg / 1000,
(se->highest_mos->rtt_leg / 100) % 10,
se->average_mos.packetloss / mos_samples,
se->lowest_mos->packetloss,
se->highest_mos->packetloss);
}
}
}
@ -4299,6 +4300,7 @@ void call_media_free(struct call_media **mdp) {
t38_gateway_put(&md->t38_gateway);
ice_candidates_free(&md->ice_candidates);
mutex_destroy(&md->dtmf_lock);
free_ssrc_hash(&md->ssrc_hash);
g_free(md);
*mdp = NULL;
}
@ -4307,7 +4309,6 @@ void __monologue_free(struct call_monologue *m) {
t_ptr_array_free(m->medias, true);
g_hash_table_destroy(m->associated_tags);
t_hash_table_destroy(m->media_ids);
free_ssrc_hash(&m->ssrc_hash);
if (m->last_out_sdp)
g_string_free(m->last_out_sdp, TRUE);
if (m->session_sdp_orig)
@ -4683,7 +4684,6 @@ struct call_monologue *__monologue_create(call_t *call) {
ret->associated_tags = g_hash_table_new(g_direct_hash, g_direct_equal);
ret->medias = medias_arr_new();
ret->media_ids = media_id_ht_new();
ret->ssrc_hash = create_ssrc_hash_call();
ret->sdp_attr_print = sdp_insert_monologue_attributes;
/* explicitely set b=RR/b=RS to -1 so it's not considered as 0 inadvertently */
RESET_BANDWIDTH(ret->sdp_session_bandwidth, -1);

8
daemon/call_interfaces.c
Unescape View File

@ -2832,7 +2832,7 @@ stats:
#define BF_M(k, f) if (MEDIA_ISSET(m, f)) parser->list_add_string(flags, k)
static void ng_stats_media(ng_command_ctx_t *ctx, parser_arg list, const struct call_media *m,
struct call_stats *totals)
struct call_stats *totals, parser_arg ssrc)
{
parser_arg dict, streams = {0}, flags;
struct packet_stream *ps;
@ -2888,6 +2888,8 @@ static void ng_stats_media(ng_command_ctx_t *ctx, parser_arg list, const struct
BF_M("transcoding", TRANSCODING);
BF_M("block egress", BLOCK_EGRESS);
ng_stats_ssrc(parser, ssrc, m->ssrc_hash);
stats:
for (auto_iter(l, m->streams.head); l; l = l->next) {
ps = l->data;
@ -2967,8 +2969,6 @@ static void ng_stats_monologue(ng_command_ctx_t *ctx, parser_arg dict, const str
}
}
ng_stats_ssrc(parser, ssrc, ml->ssrc_hash);
medias = parser->dict_add_list(sub, "medias");
parser_arg list = parser->dict_add_list(sub, "VSC");
@ -2995,7 +2995,7 @@ stats:
m = ml->medias->pdata[i];
if (!m)
continue;
ng_stats_media(ctx, medias, m, totals);
ng_stats_media(ctx, medias, m, totals, ssrc);
}
}

2
daemon/codec.c
Unescape View File

@ -823,7 +823,7 @@ reset:
__handler_stats_entry(handler);
ssrc_hash_foreach(handler->media->monologue->ssrc_hash, __reset_sequencer, NULL);
ssrc_hash_foreach(handler->media->ssrc_hash, __reset_sequencer, NULL);
no_handler_reset:
__delay_buffer_setup(&handler->delay_buffer, handler, handler->media->call, handler->media->buffer_delay);

5
daemon/dtmf.c
Unescape View File

@ -724,15 +724,14 @@ static const char *dtmf_inject_pcm(struct call_media *media, struct call_media *
for (__auto_type l = ps->rtp_sinks.head; l; l = l->next) {
struct sink_handler *sh = l->data;
struct packet_stream *sink_ps = sh->sink;
struct call_monologue *sink_ml = sink_ps->media->monologue;
__auto_type sink_media = sink_ps->media;
packet_sequencer_t *seq = g_hash_table_lookup(ssrc_in->parent->sequencers, sink_ps->media);
if (!seq)
continue;
struct ssrc_ctx *ssrc_out = get_ssrc_ctx(sh->attrs.transcoding ?
ssrc_in->ssrc_map_out : ssrc_in->parent->h.ssrc,
sink_ml->ssrc_hash, SSRC_DIR_OUTPUT,
monologue);
sink_media->ssrc_hash, SSRC_DIR_OUTPUT);
if (!ssrc_out)
return "No output SSRC context present"; // XXX generate stream

19
daemon/media_player.c
Unescape View File

@ -244,14 +244,11 @@ void media_player_new(struct media_player **mpp, struct call_monologue *ml, stru
if (!(mp = *mpp)) {
//ilog(LOG_DEBUG, "creating media_player");
uint32_t ssrc = 0;
while (ssrc == 0)
ssrc = ssl_random();
struct ssrc_ctx *ssrc_ctx = get_ssrc_ctx(ssrc, ml->ssrc_hash, SSRC_DIR_OUTPUT, ml);
ssrc_ctx->next_rtcp = rtpe_now;
mp = *mpp = obj_alloc0(struct media_player, __media_player_free);
while (mp->ssrc == 0)
mp->ssrc = ssl_random();
mp->tt_obj.tt = &media_player_thread;
mutex_init(&mp->lock);
mp->kernel_idx = -1;
@ -264,7 +261,6 @@ void media_player_new(struct media_player **mpp, struct call_monologue *ml, stru
else
mp->seq = ssl_random();
mp->buffer_ts = ssl_random();
mp->ssrc_out = ssrc_ctx;
}
/* add opts if given */
@ -966,7 +962,7 @@ int media_player_setup(struct media_player *mp, const rtp_payload_type *src_pt,
if (!mp->coder.handler)
mp->coder.handler = codec_handler_make_playback(src_pt, dst_pt, mp->sync_ts, mp->media,
mp->ssrc_out->parent->h.ssrc, codec_set);
mp->ssrc, codec_set);
if (!mp->coder.handler)
return -1;
@ -982,7 +978,7 @@ static int __media_player_setup_internal(struct media_player *mp, const rtp_payl
if (!mp->coder.handler)
mp->coder.handler = codec_handler_make_media_player(src_pt, dst_pt, mp->sync_ts, mp->media,
mp->ssrc_out->parent->h.ssrc, codec_set);
mp->ssrc, codec_set);
if (!mp->coder.handler)
return -1;
@ -1146,6 +1142,11 @@ void media_player_set_media(struct media_player *mp, struct call_media *media) {
mp->sink = media->streams.head->data;
mp->crypt_handler = determine_handler(&transport_protocols[PROTO_RTP_AVP], media, true);
}
if (!mp->ssrc_out || mp->ssrc_out->parent->h.ssrc != mp->ssrc) {
struct ssrc_ctx *ssrc_ctx = get_ssrc_ctx(mp->ssrc, media->ssrc_hash, SSRC_DIR_OUTPUT);
ssrc_ctx->next_rtcp = rtpe_now;
mp->ssrc_out = ssrc_ctx;
}
}

10
daemon/media_socket.c
Unescape View File

@ -2089,7 +2089,7 @@ static const char *__stream_ssrc_inout(struct packet_stream *ps, uint32_t ssrc,
ssrc_ctx_put(&list[ctx_idx]);
// get new entry
list[ctx_idx] =
get_ssrc_ctx(ssrc, ssrc_hash, dir, ps->media->monologue);
get_ssrc_ctx(ssrc, ssrc_hash, dir);
ret = "SSRC changed";
ilog(LOG_DEBUG, "New %s SSRC for: %s%s:%d SSRC: %x%s", label,
@ -2275,7 +2275,7 @@ static void media_packet_rtp_in(struct packet_handler_ctx *phc)
if (G_LIKELY(!phc->rtcp && !rtp_payload(&phc->mp.rtp, &phc->mp.payload, &phc->s))) {
unkern = __stream_ssrc_in(phc->in_srtp, phc->mp.rtp->ssrc, &phc->mp.ssrc_in,
phc->mp.media->monologue->ssrc_hash);
phc->mp.media->ssrc_hash);
// check the payload type
// XXX redundant between SSRC handling and codec_handler stuff -> combine
@ -2305,7 +2305,7 @@ static void media_packet_rtp_in(struct packet_handler_ctx *phc)
}
else if (phc->rtcp && !rtcp_payload(&phc->mp.rtcp, NULL, &phc->s)) {
unkern = __stream_ssrc_in(phc->in_srtp, phc->mp.rtcp->ssrc, &phc->mp.ssrc_in,
phc->mp.media->monologue->ssrc_hash);
phc->mp.media->ssrc_hash);
}
if (unkern)
@ -2320,12 +2320,12 @@ static void media_packet_rtp_out(struct packet_handler_ctx *phc, struct sink_han
if (G_LIKELY(!phc->rtcp && phc->mp.rtp)) {
unkern = __stream_ssrc_out(phc->out_srtp, phc->mp.rtp->ssrc, phc->mp.ssrc_in,
&phc->mp.ssrc_out, phc->mp.media_out->monologue->ssrc_hash,
&phc->mp.ssrc_out, phc->mp.media_out->ssrc_hash,
sh->attrs.transcoding ? true : false);
}
else if (phc->rtcp && phc->mp.rtcp) {
unkern = __stream_ssrc_out(phc->out_srtp, phc->mp.rtcp->ssrc, phc->mp.ssrc_in,
&phc->mp.ssrc_out, phc->mp.media_out->monologue->ssrc_hash,
&phc->mp.ssrc_out, phc->mp.media_out->ssrc_hash,
sh->attrs.transcoding ? true : false);
}

56
daemon/redis.c
Unescape View File

@ -112,7 +112,7 @@ static int redis_ports_release_balance = 0; // negative = releasers, positive =
static int redis_check_conn(struct redis *r);
static void json_restore_call(struct redis *r, const str *id, bool foreign);
static int redis_connect(struct redis *r, int wait, bool resolve);
static int json_build_ssrc(struct call_monologue *ml, parser_arg arg);
static int json_build_ssrc(struct call_media *, parser_arg arg);
// mutually exclusive multi-A multi-B lock
@ -1565,9 +1565,6 @@ static int redis_tags(call_t *c, struct redis_list *tags, parser_arg arg) {
ml->logical_intf = get_logical_interface(NULL, ml->desired_family, 0);
}
if (json_build_ssrc(ml, arg))
return -1;
tags->ptrs[i] = ml;
}
@ -1660,6 +1657,9 @@ static int json_medias(call_t *c, struct redis_list *medias, struct redis_list *
/* link monologue */
med->monologue = redis_list_get_ptr(tags, &medias->rh[i], "tag");
if (json_build_ssrc(med, arg))
return -1;
medias->ptrs[i] = med;
}
@ -1971,10 +1971,10 @@ static int json_link_maps(call_t *c, struct redis_list *maps,
}
static void json_build_ssrc_iter(const ng_parser_t *parser, parser_arg dict, helper_arg arg) {
struct call_monologue *ml = arg.ml;
struct call_media *md = arg.md;
uint32_t ssrc = parser_get_ll(dict, "ssrc");
struct ssrc_entry_call *se = get_ssrc(ssrc, ml->ssrc_hash);
struct ssrc_entry_call *se = get_ssrc(ssrc, md->ssrc_hash);
if (!se)
return;
@ -1988,15 +1988,15 @@ static void json_build_ssrc_iter(const ng_parser_t *parser, parser_arg dict, hel
obj_put(&se->h);
}
static int json_build_ssrc(struct call_monologue *ml, parser_arg arg) {
static int json_build_ssrc(struct call_media *md, parser_arg arg) {
char tmp[2048];
snprintf(tmp, sizeof(tmp), "ssrc_table-%u", ml->unique_id);
snprintf(tmp, sizeof(tmp), "ssrc_table-%u", md->unique_id);
parser_arg list = redis_parser->dict_get_expect(arg, tmp, BENCODE_LIST);
if (!list.gen) {
// non-fatal for backwards compatibility
return 0;
}
redis_parser->list_iter(redis_parser, list, NULL, json_build_ssrc_iter, ml);
redis_parser->list_iter(redis_parser, list, NULL, json_build_ssrc_iter, md);
return 0;
}
@ -2634,25 +2634,6 @@ static str redis_encode_json(ng_parser_ctx_t *ctx, call_t *c, void **to_free) {
struct call_media *media = ml->medias->pdata[j];
JSON_ADD_LIST_STRING("%u", media ? media->unique_id : -1);
}
// SSRC table dump
LOCK(&ml->ssrc_hash->lock);
snprintf(tmp, sizeof(tmp), "ssrc_table-%u", ml->unique_id);
parser_arg list = parser->dict_add_list_dup(root, tmp);
for (GList *m = ml->ssrc_hash->nq.head; m; m = m->next) {
struct ssrc_entry_call *se = m->data;
inner = parser->list_add_dict(list);
JSON_SET_SIMPLE("ssrc", "%" PRIu32, se->h.ssrc);
// XXX use function for in/out
JSON_SET_SIMPLE("in_srtp_index", "%u", atomic_get_na(&se->input_ctx.stats->ext_seq));
JSON_SET_SIMPLE("in_srtcp_index", "%u", atomic_get_na(&se->input_ctx.stats->rtcp_seq));
JSON_SET_SIMPLE("in_payload_type", "%i", se->input_ctx.tracker.most[0]);
JSON_SET_SIMPLE("out_srtp_index", "%u", atomic_get_na(&se->output_ctx.stats->ext_seq));
JSON_SET_SIMPLE("out_srtcp_index", "%u", atomic_get_na(&se->output_ctx.stats->rtcp_seq));
JSON_SET_SIMPLE("out_payload_type", "%i", se->output_ctx.tracker.most[0]);
// XXX add rest of info
}
} // --- for monologues.head
for (__auto_type l = c->medias.head; l; l = l->next) {
@ -2730,6 +2711,25 @@ static str redis_encode_json(ng_parser_ctx_t *ctx, call_t *c, void **to_free) {
pt->clock_rate, STR_FMT(&pt->encoding_parameters),
STR_FMT(&pt->format_parameters), pt->bitrate, pt->ptime);
}
// SSRC table dump
LOCK(&media->ssrc_hash->lock);
snprintf(tmp, sizeof(tmp), "ssrc_table-%u", media->unique_id);
parser_arg list = parser->dict_add_list_dup(root, tmp);
for (GList *m = media->ssrc_hash->nq.head; m; m = m->next) {
struct ssrc_entry_call *se = m->data;
inner = parser->list_add_dict(list);
JSON_SET_SIMPLE("ssrc", "%" PRIu32, se->h.ssrc);
// XXX use function for in/out
JSON_SET_SIMPLE("in_srtp_index", "%u", atomic_get_na(&se->input_ctx.stats->ext_seq));
JSON_SET_SIMPLE("in_srtcp_index", "%u", atomic_get_na(&se->input_ctx.stats->rtcp_seq));
JSON_SET_SIMPLE("in_payload_type", "%i", se->input_ctx.tracker.most[0]);
JSON_SET_SIMPLE("out_srtp_index", "%u", atomic_get_na(&se->output_ctx.stats->ext_seq));
JSON_SET_SIMPLE("out_srtcp_index", "%u", atomic_get_na(&se->output_ctx.stats->rtcp_seq));
JSON_SET_SIMPLE("out_payload_type", "%i", se->output_ctx.tracker.most[0]);
// XXX add rest of info
}
} // --- for medias.head
for (__auto_type l = c->endpoint_maps.head; l; l = l->next) {

14
daemon/rtcp.c
Unescape View File

@ -1303,8 +1303,8 @@ static void transcode_rr(struct rtcp_process_ctx *ctx, struct report_block *rr)
return;
// reverse SSRC mapping
struct ssrc_ctx *map_ctx = get_ssrc_ctx(ctx->scratch.rr.ssrc, ctx->mp->media->monologue->ssrc_hash,
SSRC_DIR_OUTPUT, ctx->mp->media->monologue);
struct ssrc_ctx *map_ctx = get_ssrc_ctx(ctx->scratch.rr.ssrc, ctx->mp->media->ssrc_hash,
SSRC_DIR_OUTPUT);
rr->ssrc = htonl(map_ctx->ssrc_map_out);
if (!ctx->mp->media_out)
@ -1312,8 +1312,8 @@ static void transcode_rr(struct rtcp_process_ctx *ctx, struct report_block *rr)
// for reception stats
struct ssrc_ctx *input_ctx = get_ssrc_ctx(map_ctx->ssrc_map_out,
ctx->mp->media_out->monologue->ssrc_hash,
SSRC_DIR_INPUT, NULL);
ctx->mp->media_out->ssrc_hash,
SSRC_DIR_INPUT);
if (!input_ctx)
return;
@ -1534,13 +1534,11 @@ static GString *rtcp_sender_report(struct ssrc_sender_report *ssr,
return ret;
}
void rtcp_receiver_reports(GQueue *out, struct ssrc_hash *hash, struct call_monologue *ml) {
static void rtcp_receiver_reports(GQueue *out, struct ssrc_hash *hash) {
LOCK(&hash->lock);
for (GList *l = hash->nq.head; l; l = l->next) {
struct ssrc_entry_call *e = l->data;
struct ssrc_ctx *i = &e->input_ctx;
if (i->ref != ml)
continue;
if (!atomic64_get_na(&i->stats->packets))
continue;
@ -1574,7 +1572,7 @@ void rtcp_send_report(struct call_media *media, struct ssrc_ctx *ssrc_out) {
log_info_stream_fd(ps->selected_sfd);
GQueue rrs = G_QUEUE_INIT;
rtcp_receiver_reports(&rrs, media->monologue->ssrc_hash, ps->media->monologue);
rtcp_receiver_reports(&rrs, media->ssrc_hash);
ilogs(rtcp, LOG_DEBUG, "Generating and sending RTCP SR for %x and up to %i source(s)",
ssrc_out->parent->h.ssrc, rrs.length);

16
daemon/ssrc.c
Unescape View File

@ -300,13 +300,11 @@ struct ssrc_hash *create_ssrc_hash_call(void) {
return create_ssrc_hash_full(create_ssrc_entry_call, NULL);
}
struct ssrc_ctx *get_ssrc_ctx(uint32_t ssrc, struct ssrc_hash *ht, enum ssrc_dir dir, void *ref) {
struct ssrc_ctx *get_ssrc_ctx(uint32_t ssrc, struct ssrc_hash *ht, enum ssrc_dir dir) {
struct ssrc_entry *s = get_ssrc(ssrc, ht /* , NULL */);
if (G_UNLIKELY(!s))
return NULL;
struct ssrc_ctx *ret = ((void *) s) + dir;
if (ref)
ret->ref = ref;
return ret;
}
@ -324,7 +322,7 @@ static void *__do_time_report_item(struct call_media *m, size_t struct_size, siz
sti->ntp_middle_bits = ntp_msw << 16 | ntp_lsw >> 16;
sti->ntp_ts = ntp_ts_to_double(ntp_msw, ntp_lsw);
e = get_ssrc(ssrc, m->monologue->ssrc_hash);
e = get_ssrc(ssrc, m->ssrc_hash);
if (G_UNLIKELY(!e)) {
free_func(sti);
return NULL;
@ -350,7 +348,7 @@ static struct ssrc_entry_call *hunt_ssrc(struct call_media *media, uint32_t ssrc
for (__auto_type sub = media->media_subscriptions.head; sub; sub = sub->next)
{
struct media_subscription * ms = sub->data;
struct ssrc_entry_call *e = find_ssrc(ssrc, ms->monologue->ssrc_hash, NULL);
struct ssrc_entry_call *e = find_ssrc(ssrc, ms->media->ssrc_hash, NULL);
if (e)
return e;
}
@ -451,7 +449,7 @@ void ssrc_receiver_report(struct call_media *m, stream_fd *sfd, const struct ssr
int pt;
long long rtt = calc_rtt(m,
.ht = m->monologue->ssrc_hash,
.ht = m->ssrc_hash,
.tv = tv,
.pt_p = &pt,
.ssrc = rr->ssrc,
@ -459,7 +457,7 @@ void ssrc_receiver_report(struct call_media *m, stream_fd *sfd, const struct ssr
.delay = rr->dlsr,
.reports_queue_offset = G_STRUCT_OFFSET(struct ssrc_entry_call, sender_reports));
struct ssrc_entry_call *other_e = get_ssrc(rr->from, m->monologue->ssrc_hash);
struct ssrc_entry_call *other_e = get_ssrc(rr->from, m->ssrc_hash);
if (G_UNLIKELY(!other_e))
goto out_nl;
@ -582,7 +580,7 @@ void ssrc_receiver_dlrr(struct call_media *m, const struct ssrc_xr_dlrr *dlrr,
dlrr->lrr, dlrr->dlrr);
calc_rtt(m,
.ht = m->monologue->ssrc_hash,
.ht = m->ssrc_hash,
.tv = tv,
.pt_p = NULL,
.ssrc = dlrr->ssrc,
@ -604,7 +602,7 @@ void ssrc_voip_metrics(struct call_media *m, const struct ssrc_xr_voip_metrics *
vm->ext_r_factor, vm->mos_lq, vm->mos_cq, vm->rx_config, vm->jb_nom,
vm->jb_max, vm->jb_abs_max);
struct ssrc_entry_call *e = get_ssrc(vm->ssrc, m->monologue->ssrc_hash);
struct ssrc_entry_call *e = get_ssrc(vm->ssrc, m->ssrc_hash);
if (!e)
return;
e->last_rtt_xr = vm->rnd_trip_delay;

2
include/call.h
Unescape View File

@ -506,6 +506,7 @@ struct call_media {
packet_stream_q streams; /* normally RTP + RTCP */
endpoint_map_q endpoint_maps;
struct ssrc_hash *ssrc_hash;
struct codec_store codecs;
struct codec_store offered_codecs;
@ -614,7 +615,6 @@ struct call_monologue {
str sdp_session_uri;
str sdp_session_phone;
str sdp_session_email;
struct ssrc_hash *ssrc_hash;
str metadata;
struct janus_session *janus_session;

1
include/control_ng.h
Unescape View File

@ -86,6 +86,7 @@ typedef union {
void (**call_fn)(call_t *);
GHashTable *ht;
struct call_monologue *ml;
struct call_media *md;
struct ng_media *media;
struct ng_codec *codec;
struct rtp_payload_type *pt;

1
include/media_player.h
Unescape View File

@ -81,6 +81,7 @@ struct media_player {
unsigned int kernel_idx;
struct media_player_media_file *media_file;
uint32_t ssrc;
struct ssrc_ctx *ssrc_out;
unsigned long seq;
unsigned long buffer_ts;

1
include/rtcp.h
Unescape View File

@ -38,7 +38,6 @@ rtcp_filter_func rtcp_avpf2avp_filter;
void rtcp_init(void);
void rtcp_receiver_reports(GQueue *out, struct ssrc_hash *hash, struct call_monologue *ml);
void rtcp_send_report(struct call_media *media, struct ssrc_ctx *ssrc_out);
#endif

3
include/ssrc.h
Unescape View File

@ -43,7 +43,6 @@ struct payload_tracker {
struct ssrc_ctx {
struct ssrc_entry_call *parent;
struct payload_tracker tracker;
void *ref; // points to the call_monologue but is opaque
// XXX move entire crypto context in here?
@ -219,7 +218,7 @@ INLINE void *get_ssrc(uint32_t ssrc, struct ssrc_hash *ht) {
return get_ssrc_full(ssrc, ht, NULL);
}
struct ssrc_ctx *get_ssrc_ctx(uint32_t, struct ssrc_hash *, enum ssrc_dir, void *ref); // creates new entry if not found
struct ssrc_ctx *get_ssrc_ctx(uint32_t, struct ssrc_hash *, enum ssrc_dir); // creates new entry if not found
void ssrc_sender_report(struct call_media *, const struct ssrc_sender_report *, const struct timeval *);

4
t/test-transcode.c
Unescape View File

@ -261,13 +261,13 @@ static void __packet_seq_ts(const char *file, int line, struct call_media *media
.call = &call,
.media = media,
.media_out = other_media,
.ssrc_in = get_ssrc_ctx(ssrc, media->monologue->ssrc_hash, SSRC_DIR_INPUT, NULL),
.ssrc_in = get_ssrc_ctx(ssrc, media->ssrc_hash, SSRC_DIR_INPUT),
.sfd = &sfd,
};
// from __stream_ssrc()
if (!MEDIA_ISSET(media, TRANSCODING))
mp.ssrc_in->ssrc_map_out = ntohl(ssrc);
mp.ssrc_out = get_ssrc_ctx(mp.ssrc_in->ssrc_map_out, other_media->monologue->ssrc_hash, SSRC_DIR_OUTPUT, NULL);
mp.ssrc_out = get_ssrc_ctx(mp.ssrc_in->ssrc_map_out, other_media->ssrc_hash, SSRC_DIR_OUTPUT);
payload_tracker_add(&mp.ssrc_in->tracker, pt_in & 0x7f);
int packet_len = sizeof(struct rtp_header) + pl.len;

Write Preview
Loading…
Cancel
Save