From e4fb02bedb96f9d7c56148d047872e03e48d0523 Mon Sep 17 00:00:00 2001 From: Richard Fuchs Date: Mon, 4 Dec 2023 15:01:15 -0500 Subject: [PATCH] MT#55283 use typed GHashTables for codec_store Change-Id: I746b7a39897343b9fa7a2b382ced0403601b8025 --- daemon/call.c | 11 ++--- daemon/codec.c | 120 ++++++++++++++++++++++----------------------- daemon/mqtt.c | 2 +- daemon/recording.c | 9 ++-- daemon/rtp.c | 2 +- include/call.h | 8 ++- 6 files changed, 76 insertions(+), 76 deletions(-) diff --git a/daemon/call.c b/daemon/call.c index 5d04d0964..330d4d151 100644 --- a/daemon/call.c +++ b/daemon/call.c @@ -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 */ } diff --git a/daemon/codec.c b/daemon/codec.c index c4f3640a6..eca5cc392 100644 --- a/daemon/codec.c +++ b/daemon/codec.c @@ -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 diff --git a/daemon/mqtt.c b/daemon/mqtt.c index 6d929bd92..f8d158afa 100644 --- a/daemon/mqtt.c +++ b/daemon/mqtt.c @@ -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); diff --git a/daemon/recording.c b/daemon/recording.c index 54199543f..61e73bb4d 100644 --- a/daemon/recording.c +++ b/daemon/recording.c @@ -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); } diff --git a/daemon/rtp.c b/daemon/rtp.c index 9a7bb49b6..2525c2791 100644 --- a/daemon/rtp.c +++ b/daemon/rtp.c @@ -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; diff --git a/include/call.h b/include/call.h index 9778bbd59..2e27e4727 100644 --- a/include/call.h +++ b/include/call.h @@ -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;