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

MT#55283 use typed GHashTables for codec_store

Browse Source 
Change-Id: I746b7a39897343b9fa7a2b382ced0403601b8025
pull/1776/head
Richard Fuchs 1 year ago
parent 9999098024
commit e4fb02bedb
6 changed files with 76 additions and 76 deletions
Show Stats Download Patch File Download Diff File

11
daemon/call.c
Unescape View File

@ -1142,16 +1142,15 @@ int __init_stream(struct packet_stream *ps) {
void __rtp_stats_update(GHashTable *dst, struct codec_store *cs) {
struct rtp_stats *rs;
struct rtp_payload_type *pt;
GList *values, *l;
GHashTable *src = cs->codecs;
codecs_ht src = cs->codecs;
/* "src" is a call_media->codecs table, while "dst" is a
* packet_stream->rtp_stats table */
values = g_hash_table_get_values(src);
codecs_ht_iter iter;
t_hash_table_iter_init(&iter, src);
for (l = values; l; l = l->next) {
pt = l->data;
while (t_hash_table_iter_next(&iter, NULL, &pt)) {
rs = g_hash_table_lookup(dst, GINT_TO_POINTER(pt->payload_type));
if (rs)
continue;
@ -1161,8 +1160,6 @@ void __rtp_stats_update(GHashTable *dst, struct codec_store *cs) {
g_hash_table_insert(dst, GINT_TO_POINTER(rs->payload_type), rs);
}
g_list_free(values);
/* we leave previously added but now removed payload types in place */
}

120
daemon/codec.c
Unescape View File

@ -56,7 +56,7 @@ static void rtp_payload_type_copy(struct rtp_payload_type *dst, const struct rtp
static void codec_store_add_raw_order(struct codec_store *cs, struct rtp_payload_type *pt);
static struct rtp_payload_type *codec_store_find_compatible(struct codec_store *cs,
const struct rtp_payload_type *pt);
static void __rtp_payload_type_add_name(GHashTable *, struct rtp_payload_type *pt);
static void __rtp_payload_type_add_name(codec_names_ht, struct rtp_payload_type *pt);
static void codec_calc_lost(struct ssrc_ctx *ssrc, uint16_t seq);
@ -70,20 +70,20 @@ static struct codec_handler codec_handler_stub = {
static void __ht_queue_del(GHashTable *ht, const void *key, const void *val) {
GQueue *q = g_hash_table_lookup(ht, key);
static void __ht_queue_del(codec_names_ht ht, const str *key, int pt) {
GQueue *q = t_hash_table_lookup(ht, key);
if (!q)
return;
g_queue_remove_all(q, val);
g_queue_remove_all(q, GINT_TO_POINTER(pt));
}
static rtp_pt_list *__codec_store_delete_link(rtp_pt_list *link, struct codec_store *cs) {
struct rtp_payload_type *pt = link->data;
g_hash_table_remove(cs->codecs, GINT_TO_POINTER(pt->payload_type));
__ht_queue_del(cs->codec_names, &pt->encoding, GINT_TO_POINTER(pt->payload_type));
__ht_queue_del(cs->codec_names, &pt->encoding_with_params, GINT_TO_POINTER(pt->payload_type));
__ht_queue_del(cs->codec_names, &pt->encoding_with_full_params, GINT_TO_POINTER(pt->payload_type));
t_hash_table_remove(cs->codecs, GINT_TO_POINTER(pt->payload_type));
__ht_queue_del(cs->codec_names, &pt->encoding, pt->payload_type);
__ht_queue_del(cs->codec_names, &pt->encoding_with_params, pt->payload_type);
__ht_queue_del(cs->codec_names, &pt->encoding_with_full_params, pt->payload_type);
__auto_type next = link->next;
if (cs->supp_link == link)
@ -691,15 +691,15 @@ static int __unused_pt_number(struct call_media *media, struct call_media *other
if (num < 0)
num = 96; // default first dynamic payload type number
while (1) {
if ((pt_match = g_hash_table_lookup(media->codecs.codecs, GINT_TO_POINTER(num))))
if ((pt_match = t_hash_table_lookup(media->codecs.codecs, GINT_TO_POINTER(num))))
goto next;
if (other_media) {
if ((pt_match = g_hash_table_lookup(other_media->codecs.codecs,
if ((pt_match = t_hash_table_lookup(other_media->codecs.codecs,
GINT_TO_POINTER(num))))
goto next;
}
if (extra_cs) {
if ((pt_match = g_hash_table_lookup(extra_cs->codecs,
if ((pt_match = t_hash_table_lookup(extra_cs->codecs,
GINT_TO_POINTER(num))))
goto next;
}
@ -1166,7 +1166,7 @@ void __codec_handlers_update(struct call_media *receiver, struct call_media *sin
if (!sink_pt) {
// can we send the same codec that we want to receive?
sink_pt = g_hash_table_lookup(sink->codecs.codecs,
sink_pt = t_hash_table_lookup(sink->codecs.codecs,
GINT_TO_POINTER(pt->payload_type));
// is it actually the same?
if (sink_pt && !rtp_payload_type_eq_compat(pt, sink_pt))
@ -1390,7 +1390,7 @@ transcode:
// look up the reverse side of this payload type, which is the decoder to our
// encoder. if any codec options such as bitrate were set during an offer,
// they're in the decoder PT. copy them to the encoder PT.
struct rtp_payload_type *reverse_pt = g_hash_table_lookup(sink->codecs.codecs,
struct rtp_payload_type *reverse_pt = t_hash_table_lookup(sink->codecs.codecs,
GINT_TO_POINTER(sink_pt->payload_type));
if (reverse_pt) {
if (!sink_pt->bitrate)
@ -3383,7 +3383,8 @@ static void __dtx_send_later(struct codec_timer *ct) {
// another possibility is that the most used PT is actually a supplemental type. check this,
// and if true move on to the next most used PT.
struct rtp_payload_type *pt = g_hash_table_lookup(ps->media->codecs.codecs, GUINT_TO_POINTER(most_pt));
struct rtp_payload_type *pt = t_hash_table_lookup(ps->media->codecs.codecs,
GUINT_TO_POINTER(most_pt));
if (pt && pt->codec_def && pt->codec_def->supplemental)
continue;
@ -4544,12 +4545,12 @@ struct rtp_payload_type *rtp_payload_type_dup(const struct rtp_payload_type *pt)
rtp_payload_type_copy(pt_copy, pt);
return pt_copy;
}
static void __rtp_payload_type_add_name(GHashTable *ht, struct rtp_payload_type *pt) {
GQueue *q = g_hash_table_lookup_queue_new(ht, str_dup(&pt->encoding), free);
static void __rtp_payload_type_add_name(codec_names_ht ht, struct rtp_payload_type *pt) {
GQueue *q = codec_names_ht_lookup_insert(ht, str_dup(&pt->encoding));
g_queue_push_tail(q, GINT_TO_POINTER(pt->payload_type));
q = g_hash_table_lookup_queue_new(ht, str_dup(&pt->encoding_with_params), free);
q = codec_names_ht_lookup_insert(ht, str_dup(&pt->encoding_with_params));
g_queue_push_tail(q, GINT_TO_POINTER(pt->payload_type));
q = g_hash_table_lookup_queue_new(ht, str_dup(&pt->encoding_with_full_params), free);
q = codec_names_ht_lookup_insert(ht, str_dup(&pt->encoding_with_full_params));
g_queue_push_tail(q, GINT_TO_POINTER(pt->payload_type));
}
#ifdef WITH_TRANSCODING
@ -4735,10 +4736,10 @@ void codec_tracker_update(struct codec_store *cs, struct codec_store *orig_cs) {
// see if we have a matching PT from before
struct rtp_payload_type *pt = NULL;
if (orig_cs) {
GQueue *ptq = g_hash_table_lookup(orig_cs->codec_names, &pt_str);
GQueue *ptq = t_hash_table_lookup(orig_cs->codec_names, &pt_str);
if (ptq) {
for (GList *n = ptq->head; n; n = n->next) {
pt = g_hash_table_lookup(orig_cs->codecs, n->data);
pt = t_hash_table_lookup(orig_cs->codecs, n->data);
if (!pt)
continue;
pt = rtp_payload_type_dup(pt);
@ -4793,10 +4794,10 @@ void codec_tracker_update(struct codec_store *cs, struct codec_store *orig_cs) {
#endif
void codec_store_cleanup(struct codec_store *cs) {
if (cs->codecs)
g_hash_table_destroy(cs->codecs);
if (cs->codec_names)
g_hash_table_destroy(cs->codec_names);
if (t_hash_table_is_set(cs->codecs))
t_hash_table_destroy(cs->codecs);
if (t_hash_table_is_set(cs->codec_names))
t_hash_table_destroy(cs->codec_names);
t_queue_clear_full(&cs->codec_prefs, payload_type_free);
cs->supp_link = NULL;
codec_tracker_destroy(&cs->tracker);
@ -4809,9 +4810,8 @@ void codec_store_init(struct codec_store *cs, struct call_media *media) {
codec_store_cleanup(cs);
cs->codecs = g_hash_table_new(g_direct_hash, g_direct_equal);
cs->codec_names = g_hash_table_new_full(str_case_hash, str_case_equal, free,
(void (*)(void*)) g_queue_free);
cs->codecs = codecs_ht_new();
cs->codec_names = codec_names_ht_new();
cs->media = media;
cs->tracker = codec_tracker_init();
}
@ -4839,18 +4839,18 @@ static void codec_store_find_matching_codecs(rtp_pt_q *out_compat, struct rtp_pa
pt = pt_store = codec_make_payload_type_sup(codec, cs->media);
}
GQueue *pts = g_hash_table_lookup(cs->codec_names, codec);
GQueue *pts = t_hash_table_lookup(cs->codec_names, codec);
if (pt) {
if (!pts)
pts = g_hash_table_lookup(cs->codec_names, &pt->encoding_with_params);
pts = t_hash_table_lookup(cs->codec_names, &pt->encoding_with_params);
if (!pts)
pts = g_hash_table_lookup(cs->codec_names, &pt->encoding);
pts = t_hash_table_lookup(cs->codec_names, &pt->encoding);
}
if (!pts)
return; // no matches
// see if given format parameters match
for (GList *k = pts->head; k; k = k->next) {
struct rtp_payload_type *pt2 = g_hash_table_lookup(cs->codecs, k->data);
struct rtp_payload_type *pt2 = t_hash_table_lookup(cs->codecs, k->data);
if (!pt2)
continue;
ensure_codec_def(pt2, cs->media);
@ -4882,7 +4882,7 @@ static void codec_store_add_raw_link(struct codec_store *cs, struct rtp_payload_
STR_FMT(&pt->encoding_with_params),
STR_FMT0(&pt->format_parameters),
STR_FMT(&pt->encoding_with_full_params), link);
g_hash_table_insert(cs->codecs, GINT_TO_POINTER(pt->payload_type), pt);
t_hash_table_insert(cs->codecs, GINT_TO_POINTER(pt->payload_type), pt);
__rtp_payload_type_add_name(cs->codec_names, pt);
if (!link) {
t_queue_push_tail(&cs->codec_prefs, pt);
@ -4940,7 +4940,7 @@ static struct rtp_payload_type *codec_store_find_compatible_q(struct codec_store
if (!q)
return NULL;
for (GList *l = q->head; l; l = l->next) {
struct rtp_payload_type *ret = g_hash_table_lookup(cs->codecs, l->data);
struct rtp_payload_type *ret = t_hash_table_lookup(cs->codecs, l->data);
if (rtp_payload_type_fmt_eq_compat(ret, pt))
return ret;
}
@ -4951,17 +4951,17 @@ static struct rtp_payload_type *codec_store_find_compatible(struct codec_store *
{
struct rtp_payload_type *ret;
ret = codec_store_find_compatible_q(cs,
g_hash_table_lookup(cs->codec_names, &pt->encoding_with_full_params),
t_hash_table_lookup(cs->codec_names, &pt->encoding_with_full_params),
pt);
if (ret)
return ret;
ret = codec_store_find_compatible_q(cs,
g_hash_table_lookup(cs->codec_names, &pt->encoding_with_params),
t_hash_table_lookup(cs->codec_names, &pt->encoding_with_params),
pt);
if (ret)
return ret;
ret = codec_store_find_compatible_q(cs,
g_hash_table_lookup(cs->codec_names, &pt->encoding),
t_hash_table_lookup(cs->codec_names, &pt->encoding),
pt);
if (ret)
return ret;
@ -4975,7 +4975,7 @@ void __codec_store_populate_reuse(struct codec_store *dst, struct codec_store *s
for (__auto_type l = src->codec_prefs.head; l; l = l->next) {
struct rtp_payload_type *pt = l->data;
struct rtp_payload_type *orig_pt = g_hash_table_lookup(dst->codecs,
struct rtp_payload_type *orig_pt = t_hash_table_lookup(dst->codecs,
GINT_TO_POINTER(pt->payload_type));
pt->reverse_payload_type = pt->payload_type;
@ -5005,7 +5005,7 @@ void __codec_store_populate_reuse(struct codec_store *dst, struct codec_store *s
}
for (__auto_type l = dst->codec_prefs.head; l;) {
struct rtp_payload_type *pt = l->data;
struct rtp_payload_type *orig_pt = g_hash_table_lookup(src->codecs,
struct rtp_payload_type *orig_pt = t_hash_table_lookup(src->codecs,
GINT_TO_POINTER(pt->payload_type));
if(!orig_pt){
if (a.merge_cs)
@ -5035,7 +5035,7 @@ static void codec_store_merge(struct codec_store *dst, struct codec_store *src)
// src codecs take preference over existing entries in dst: if there's
// a collision in payload types, remove the existing entry in dst,
// then replace with the entry from src
struct rtp_payload_type *old_pt = g_hash_table_lookup(dst->codecs,
struct rtp_payload_type *old_pt = t_hash_table_lookup(dst->codecs,
GINT_TO_POINTER(pt->payload_type));
if (old_pt)
__codec_store_delete_link(old_pt->prefs_link, dst);
@ -5056,7 +5056,7 @@ void __codec_store_populate(struct codec_store *dst, struct codec_store *src, st
for (__auto_type l = src->codec_prefs.head; l; l = l->next) {
struct rtp_payload_type *pt = l->data;
struct rtp_payload_type *orig_pt = g_hash_table_lookup(orig_dst.codecs,
struct rtp_payload_type *orig_pt = t_hash_table_lookup(orig_dst.codecs,
GINT_TO_POINTER(pt->payload_type));
if (a.answer_only && !orig_pt) {
if (a.allow_asymmetric)
@ -5134,7 +5134,7 @@ void codec_store_strip(struct codec_store *cs, str_q *strip, GHashTable *except)
continue;
}
// strip just this one
GQueue *pts = g_hash_table_lookup(cs->codec_names, codec);
GQueue *pts = t_hash_table_lookup(cs->codec_names, codec);
if (!pts || !pts->length) {
ilogs(codec, LOG_DEBUG, "Codec " STR_FORMAT
" not present for stripping",
@ -5143,7 +5143,7 @@ void codec_store_strip(struct codec_store *cs, str_q *strip, GHashTable *except)
}
while (pts->length) {
int pt_num = GPOINTER_TO_INT(pts->head->data);
struct rtp_payload_type *pt = g_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num));
struct rtp_payload_type *pt = t_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num));
if (pt) {
ilogs(codec, LOG_DEBUG, "Stripping codec " STR_FORMAT "/" STR_FORMAT " (%i)",
STR_FMT(&pt->encoding_with_params),
@ -5167,14 +5167,14 @@ void codec_store_offer(struct codec_store *cs, str_q *offer, struct codec_store
// in `cs`
for (__auto_type l = offer->head; l; l = l->next) {
str *codec = l->data;
GQueue *pts = g_hash_table_lookup(cs->codec_names, codec);
GQueue *pts = t_hash_table_lookup(cs->codec_names, codec);
if (pts && pts->length) {
ilogs(codec, LOG_DEBUG, "Codec " STR_FORMAT
" already present (%i)",
STR_FMT(codec), GPOINTER_TO_INT(pts->head->data));
continue;
}
GQueue *orig_list = g_hash_table_lookup(orig->codec_names, codec);
GQueue *orig_list = t_hash_table_lookup(orig->codec_names, codec);
if (!orig_list || !orig_list->length) {
ilogs(codec, LOG_DEBUG, "Codec " STR_FORMAT
" not present for offering",
@ -5183,14 +5183,14 @@ void codec_store_offer(struct codec_store *cs, str_q *offer, struct codec_store
}
for (GList *k = orig_list->head; k; k = k->next) {
int pt_num = GPOINTER_TO_INT(k->data);
struct rtp_payload_type *orig_pt = g_hash_table_lookup(orig->codecs,
struct rtp_payload_type *orig_pt = t_hash_table_lookup(orig->codecs,
GINT_TO_POINTER(pt_num));
if (!orig_pt) {
ilogs(codec, LOG_DEBUG, "PT %i missing for offering " STR_FORMAT, pt_num,
STR_FMT(codec));
continue;
}
if (g_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num))) {
if (t_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num))) {
ilogs(codec, LOG_DEBUG, "PT %i (" STR_FORMAT ") already preset", pt_num,
STR_FMT(codec));
continue;
@ -5233,7 +5233,7 @@ void codec_store_accept(struct codec_store *cs, str_q *accept, struct codec_stor
// XXX duplicate code
for (__auto_type k = pts->head; k; k = k->next) {
struct rtp_payload_type *orig_pt = k->data;
if (g_hash_table_lookup(cs->codecs, GINT_TO_POINTER(orig_pt->payload_type))) {
if (t_hash_table_lookup(cs->codecs, GINT_TO_POINTER(orig_pt->payload_type))) {
ilogs(codec, LOG_DEBUG, "PT %i (" STR_FORMAT ") already preset",
orig_pt->payload_type,
STR_FMT(codec));
@ -5257,7 +5257,7 @@ void codec_store_accept(struct codec_store *cs, str_q *accept, struct codec_stor
for (__auto_type k = pts->head; k; k = k->next) {
struct rtp_payload_type *fpt = k->data;
int pt_num = fpt->payload_type;
struct rtp_payload_type *pt = g_hash_table_lookup(cs->codecs,
struct rtp_payload_type *pt = t_hash_table_lookup(cs->codecs,
GINT_TO_POINTER(pt_num));
if (!pt) {
ilogs(codec, LOG_DEBUG, "PT %i missing for accepting " STR_FORMAT, pt_num,
@ -5288,12 +5288,12 @@ int codec_store_accept_one(struct codec_store *cs, str_q *accept, bool accept_an
accept_any = true;
continue;
}
GQueue *pts = g_hash_table_lookup(cs->codec_names, codec);
GQueue *pts = t_hash_table_lookup(cs->codec_names, codec);
if (!pts)
continue;
for (GList *k = pts->head; k; k = k->next) {
int pt_num = GPOINTER_TO_INT(k->data);
struct rtp_payload_type *pt = g_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num));
struct rtp_payload_type *pt = t_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num));
if (!pt) {
ilogs(codec, LOG_DEBUG, "PT %i missing for accepting " STR_FORMAT, pt_num,
STR_FMT(codec));
@ -5348,12 +5348,12 @@ void codec_store_track(struct codec_store *cs, str_q *q) {
cs->tracker->all_touched = 1;
continue;
}
GQueue *pts = g_hash_table_lookup(cs->codec_names, codec);
GQueue *pts = t_hash_table_lookup(cs->codec_names, codec);
if (!pts)
continue;
for (GList *k = pts->head; k; k = k->next) {
int pt_num = GPOINTER_TO_INT(k->data);
struct rtp_payload_type *pt = g_hash_table_lookup(cs->codecs,
struct rtp_payload_type *pt = t_hash_table_lookup(cs->codecs,
GINT_TO_POINTER(pt_num));
codec_touched(cs, pt);
}
@ -5379,7 +5379,7 @@ void codec_store_transcode(struct codec_store *cs, str_q *offer, struct codec_st
STR_FMT(codec), pt_match->payload_type);
continue;
}
GQueue *orig_list = g_hash_table_lookup(orig->codec_names, codec);
GQueue *orig_list = t_hash_table_lookup(orig->codec_names, codec);
if (!orig_list || !orig_list->length || cs->strip_full) {
ilogs(codec, LOG_DEBUG, "Adding codec " STR_FORMAT
" for transcoding",
@ -5403,14 +5403,14 @@ void codec_store_transcode(struct codec_store *cs, str_q *offer, struct codec_st
// XXX duplicate code
for (GList *k = orig_list->head; k; k = k->next) {
int pt_num = GPOINTER_TO_INT(k->data);
struct rtp_payload_type *orig_pt = g_hash_table_lookup(orig->codecs,
struct rtp_payload_type *orig_pt = t_hash_table_lookup(orig->codecs,
GINT_TO_POINTER(pt_num));
if (!orig_pt) {
ilogs(codec, LOG_DEBUG, "PT %i missing for offering " STR_FORMAT, pt_num,
STR_FMT(codec));
continue;
}
if (g_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num))) {
if (t_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num))) {
ilogs(codec, LOG_DEBUG, "PT %i (" STR_FORMAT ") already preset", pt_num,
STR_FMT(codec));
continue;
@ -5525,7 +5525,7 @@ void codec_store_answer(struct codec_store *dst, struct codec_store *src, sdp_ng
STR_FMT(&h->dest_pt.encoding_with_params),
STR_FMT0(&h->dest_pt.format_parameters),
h->dest_pt.payload_type);
if (!g_hash_table_lookup(dst->codecs, GINT_TO_POINTER(h->dest_pt.payload_type))) {
if (!t_hash_table_lookup(dst->codecs, GINT_TO_POINTER(h->dest_pt.payload_type))) {
if (h->passthrough) {
struct rtp_payload_type copy = *pt;
copy.payload_type = pt->reverse_payload_type;
@ -5539,7 +5539,7 @@ void codec_store_answer(struct codec_store *dst, struct codec_store *src, sdp_ng
// handle associated supplemental codecs
if (h->cn_payload_type != -1) {
pt = g_hash_table_lookup(orig_dst.codecs, GINT_TO_POINTER(h->cn_payload_type));
pt = t_hash_table_lookup(orig_dst.codecs, GINT_TO_POINTER(h->cn_payload_type));
if (!pt)
ilogs(codec, LOG_DEBUG, "CN payload type %i is missing", h->cn_payload_type);
else
@ -5549,7 +5549,7 @@ void codec_store_answer(struct codec_store *dst, struct codec_store *src, sdp_ng
if (dtmf_payload_type == -1)
dtmf_payload_type = h->real_dtmf_payload_type;
if (dtmf_payload_type != -1) {
pt = g_hash_table_lookup(orig_dst.codecs, GINT_TO_POINTER(dtmf_payload_type));
pt = t_hash_table_lookup(orig_dst.codecs, GINT_TO_POINTER(dtmf_payload_type));
if (!pt)
ilogs(codec, LOG_DEBUG, "DTMF payload type %i is missing", dtmf_payload_type);
else
@ -5559,7 +5559,7 @@ void codec_store_answer(struct codec_store *dst, struct codec_store *src, sdp_ng
while (supp_codecs.length) {
struct rtp_payload_type *pt = g_queue_pop_head(&supp_codecs);
if (g_hash_table_lookup(dst->codecs, GINT_TO_POINTER(pt->payload_type))) {
if (t_hash_table_lookup(dst->codecs, GINT_TO_POINTER(pt->payload_type))) {
ilogs(codec, LOG_DEBUG, STR_FORMAT " payload type %i already present, skip",
STR_FMT(&pt->encoding_with_full_params), pt->payload_type);
payload_type_free(pt);
@ -5615,7 +5615,7 @@ void codec_store_synthesise(struct codec_store *dst, struct codec_store *opposit
bool codec_store_is_full_answer(const struct codec_store *src, const struct codec_store *dst) {
for (__auto_type l = src->codec_prefs.head; l; l = l->next) {
const struct rtp_payload_type *src_pt = l->data;
const struct rtp_payload_type *dst_pt = g_hash_table_lookup(dst->codecs,
const struct rtp_payload_type *dst_pt = t_hash_table_lookup(dst->codecs,
GINT_TO_POINTER(src_pt->payload_type));
if (!dst_pt || !rtp_payload_type_eq_compat(src_pt, dst_pt)) {
ilogs(codec, LOG_DEBUG, "Source codec " STR_FORMAT "/" STR_FORMAT

2
daemon/mqtt.c
Unescape View File

@ -214,7 +214,7 @@ static void mqtt_ssrc_stats(struct ssrc_ctx *ssrc, JsonBuilder *json, struct cal
mutex_unlock(&ssrc->tracker.lock);
unsigned int clockrate = 0;
struct rtp_payload_type *pt = g_hash_table_lookup(media->codecs.codecs, GUINT_TO_POINTER(prim_pt));
struct rtp_payload_type *pt = t_hash_table_lookup(media->codecs.codecs, GUINT_TO_POINTER(prim_pt));
if (pt) {
json_builder_set_member_name(json, "codec");
json_builder_add_string_value(json, pt->encoding.s);

9
daemon/recording.c
Unescape View File

@ -943,17 +943,16 @@ static void setup_media_proc(struct call_media *media) {
append_meta_chunk_null(recording, "MEDIA %u PTIME %i", media->unique_id, media->ptime);
GList *pltypes = g_hash_table_get_values(media->codecs.codecs);
codecs_ht_iter iter;
t_hash_table_iter_init(&iter, media->codecs.codecs);
for (GList *l = pltypes; l; l = l->next) {
struct rtp_payload_type *pt = l->data;
struct rtp_payload_type *pt;
while (t_hash_table_iter_next(&iter, NULL, &pt)) {
append_meta_chunk(recording, pt->encoding_with_params.s, pt->encoding_with_params.len,
"MEDIA %u PAYLOAD TYPE %u", media->unique_id, pt->payload_type);
append_meta_chunk(recording, pt->format_parameters.s, pt->format_parameters.len,
"MEDIA %u FMTP %u", media->unique_id, pt->payload_type);
}
g_list_free(pltypes);
}

2
daemon/rtp.c
Unescape View File

@ -317,7 +317,7 @@ const struct rtp_payload_type *rtp_payload_type(unsigned int type, struct codec_
if (!cs)
return rtp_get_rfc_payload_type(type);
rtp_pt = g_hash_table_lookup(cs->codecs, GINT_TO_POINTER(type));
rtp_pt = t_hash_table_lookup(cs->codecs, GINT_TO_POINTER(type));
if (rtp_pt)
return rtp_pt;

8
include/call.h
Unescape View File

@ -299,9 +299,13 @@ typedef bencode_buffer_t call_buffer_t;
TYPED_GHASHTABLE(codecs_ht, void, struct rtp_payload_type, g_direct_hash, g_direct_equal, NULL, NULL)
TYPED_GHASHTABLE(codec_names_ht, str, GQueue, str_case_hash, str_case_equal, str_free, g_queue_free)
TYPED_GHASHTABLE_LOOKUP_INSERT(codec_names_ht, str_free, g_queue_new)
struct codec_store {
GHashTable *codecs; // int payload type -> struct rtp_payload_type
GHashTable *codec_names; // codec name -> GQueue of int payload types; storage container
codecs_ht codecs; // int payload type -> struct rtp_payload_type
codec_names_ht codec_names; // codec name -> GQueue of int payload types; storage container
rtp_pt_q codec_prefs; // preference by order in SDP; storage container
rtp_pt_list *supp_link; // tracks location for codec_store_add_end
struct codec_tracker *tracker;

Write Preview
Loading…
Cancel
Save