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

TT#92250 split up __accept_transcode_codecs

Browse Source 
Change-Id: I52b602961c2e60f5e73576bcea8e9af47528111a
pull/1164/head
Richard Fuchs 5 years ago
parent 99ba631fd0
commit a02134cd06
1 changed files with 99 additions and 86 deletions
Show Stats Download Patch File Download Diff File

185
daemon/codec.c
Unescape View File

@ -655,101 +655,114 @@ static int __check_receiver_codecs(struct call_media *receiver, struct call_medi
return ret; return ret;
} }
static void __accept_transcode_codecs(struct call_media *receiver, struct call_media *sink, static void __accept_pt(struct call_media *receiver, struct call_media *sink, int payload_type,
const struct sdp_ng_flags *flags, int accept_only_tc) int fallback_type, int accept_only_tc, GList **insert_pos)
{ {
// if the other side is transcoding, we need to accept codecs that were struct rtp_payload_type *pt = g_hash_table_lookup(receiver->codecs_send, &payload_type);
// originally offered (recv->send) if we support them, even if the
// response (sink->send) doesn't include them
GList *insert_pos = NULL;
for (GList *l = receiver->codecs_prefs_send.head; l; l = l->next) {
struct rtp_payload_type *pt = l->data;
ensure_codec_def(pt, receiver);
if (!pt->codec_def)
continue;
if (accept_only_tc && !pt->for_transcoding)
continue;
//ilog(LOG_DEBUG, "XXXXXXXXXXX accept codec " STR_FORMAT " flag %i", STR_FMT(&pt->encoding_with_params), pt->for_transcoding);
struct rtp_payload_type *existing_pt
= g_hash_table_lookup(receiver->codecs_recv, &pt->payload_type);
if (existing_pt && !rtp_payload_type_cmp_nf(existing_pt, pt)) {
// already present.
// to keep the order intact, we seek the list for the position
// of this codec entry. all newly added codecs must come after
// this entry.
if (!insert_pos)
insert_pos = receiver->codecs_prefs_recv.head;
while (insert_pos) {
if (!insert_pos->next)
break; // end of list - we insert everything after
struct rtp_payload_type *test_pt = insert_pos->data;
if (test_pt->payload_type == pt->payload_type)
break;
insert_pos = insert_pos->next;
}
continue;
}
if (existing_pt) { // fallback PT in case the codec handler is a dummy or a passthrough
// PT collision. We must renumber one of the entries. `pt` is taken // or some other internal problem
// from the send list, so the PT should remain the same. Renumber if (!pt && fallback_type != -1)
// the existing entry. pt = g_hash_table_lookup(receiver->codecs_send, &fallback_type);
int new_pt = __unused_pt_number(receiver, sink, existing_pt); if (!pt)
if (new_pt < 0) { return;
ilogs(codec, LOG_WARN, "Ran out of RTP payload type numbers while accepting '"
STR_FORMAT "' due to '" STR_FORMAT "'", ensure_codec_def(pt, receiver);
STR_FMT(&pt->encoding_with_params), if (!pt->codec_def)
STR_FMT(&existing_pt->encoding_with_params)); return;
continue; if (accept_only_tc && !pt->for_transcoding)
} return;
ilogs(codec, LOG_DEBUG, "Renumbering '" STR_FORMAT "' from PT %i to %i due to '" STR_FORMAT "'", //ilog(LOG_DEBUG, "XXXXXXXXXXX accept codec " STR_FORMAT " flag %i", STR_FMT(&pt->encoding_with_params), pt->for_transcoding);
STR_FMT(&existing_pt->encoding_with_params), struct rtp_payload_type *existing_pt
existing_pt->payload_type, = g_hash_table_lookup(receiver->codecs_recv, &pt->payload_type);
new_pt, if (existing_pt && !rtp_payload_type_cmp_nf(existing_pt, pt)) {
STR_FMT(&pt->encoding_with_params)); // already present.
g_hash_table_steal(receiver->codecs_recv, &existing_pt->payload_type); // to keep the order intact, we seek the list for the position
existing_pt->payload_type = new_pt; // of this codec entry. all newly added codecs must come after
g_hash_table_insert(receiver->codecs_recv, &existing_pt->payload_type, existing_pt); // this entry.
if (!*insert_pos)
*insert_pos = receiver->codecs_prefs_recv.head;
while (*insert_pos) {
if (!(*insert_pos)->next)
break; // end of list - we insert everything after
struct rtp_payload_type *test_pt = (*insert_pos)->data;
if (test_pt->payload_type == pt->payload_type)
break;
*insert_pos = (*insert_pos)->next;
} }
return;
}
//ilog(LOG_DEBUG, "XXXXXXXXXXXXX offered codec %i", pt->for_transcoding); if (existing_pt) {
ilogs(codec, LOG_DEBUG, "Accepting offered codec " STR_FORMAT " due to transcoding", // PT collision. We must renumber one of the entries. `pt` is taken
STR_FMT(&pt->encoding_with_params)); // from the send list, so the PT should remain the same. Renumber
MEDIA_SET(receiver, TRANSCODE); // the existing entry.
int new_pt = __unused_pt_number(receiver, sink, existing_pt);
if (new_pt < 0) {
ilogs(codec, LOG_WARN, "Ran out of RTP payload type numbers while accepting '"
STR_FORMAT "' due to '" STR_FORMAT "'",
STR_FMT(&pt->encoding_with_params),
STR_FMT(&existing_pt->encoding_with_params));
return;
}
ilogs(codec, LOG_DEBUG, "Renumbering '" STR_FORMAT "' from PT %i to %i due to '" STR_FORMAT "'",
STR_FMT(&existing_pt->encoding_with_params),
existing_pt->payload_type,
new_pt,
STR_FMT(&pt->encoding_with_params));
g_hash_table_steal(receiver->codecs_recv, &existing_pt->payload_type);
existing_pt->payload_type = new_pt;
g_hash_table_insert(receiver->codecs_recv, &existing_pt->payload_type, existing_pt);
}
//ilog(LOG_DEBUG, "XXXXXXXXXXXXX offered codec %i", pt->for_transcoding);
ilogs(codec, LOG_DEBUG, "Accepting offered codec " STR_FORMAT " due to transcoding",
STR_FMT(&pt->encoding_with_params));
MEDIA_SET(receiver, TRANSCODE);
// we need a new pt entry // we need a new pt entry
pt = __rtp_payload_type_copy(pt); pt = __rtp_payload_type_copy(pt);
pt->for_transcoding = 1; pt->for_transcoding = 1;
codec_touched(pt, receiver); codec_touched(pt, receiver);
// this somewhat duplicates __rtp_payload_type_add_recv // this somewhat duplicates __rtp_payload_type_add_recv
g_hash_table_insert(receiver->codecs_recv, &pt->payload_type, pt); g_hash_table_insert(receiver->codecs_recv, &pt->payload_type, pt);
__rtp_payload_type_add_name(receiver->codec_names_recv, pt); __rtp_payload_type_add_name(receiver->codec_names_recv, pt);
// keep supplemental codecs last // keep supplemental codecs last
ensure_codec_def(pt, receiver); ensure_codec_def(pt, receiver);
if (!pt->codec_def || !pt->codec_def->supplemental) { if (!pt->codec_def || !pt->codec_def->supplemental) {
while (insert_pos) { while (*insert_pos) {
struct rtp_payload_type *ipt = insert_pos->data; struct rtp_payload_type *ipt = (*insert_pos)->data;
ensure_codec_def(ipt, receiver); ensure_codec_def(ipt, receiver);
if (!ipt->codec_def || !ipt->codec_def->supplemental) if (!ipt->codec_def || !ipt->codec_def->supplemental)
break; break;
insert_pos = insert_pos->prev; *insert_pos = (*insert_pos)->prev;
}
}
else {
if (!insert_pos)
insert_pos = receiver->codecs_prefs_recv.tail;
} }
}
else {
if (!*insert_pos)
*insert_pos = receiver->codecs_prefs_recv.tail;
}
if (!insert_pos) { if (!*insert_pos) {
g_queue_push_head(&receiver->codecs_prefs_recv, pt); g_queue_push_head(&receiver->codecs_prefs_recv, pt);
insert_pos = receiver->codecs_prefs_recv.head; *insert_pos = receiver->codecs_prefs_recv.head;
} }
else { else {
g_queue_insert_after(&receiver->codecs_prefs_recv, insert_pos, pt); g_queue_insert_after(&receiver->codecs_prefs_recv, *insert_pos, pt);
insert_pos = insert_pos->next; *insert_pos = (*insert_pos)->next;
} }
}
static void __accept_transcode_codecs(struct call_media *receiver, struct call_media *sink,
const struct sdp_ng_flags *flags, int accept_only_tc)
{
// if the other side is transcoding, we need to accept codecs that were
// originally offered (recv->send) if we support them, even if the
// response (sink->send) doesn't include them
GList *insert_pos = NULL;
for (GList *l = receiver->codecs_prefs_send.head; l; l = l->next) {
struct rtp_payload_type *pt = l->data;
__accept_pt(receiver, sink, pt->payload_type, -1, accept_only_tc, &insert_pos);
} }
__single_codec(receiver, flags); __single_codec(receiver, flags);

Write Preview
Loading…
Cancel
Save