From c9ac6ecc739b0c05ea8e981026f930260e699ef6 Mon Sep 17 00:00:00 2001 From: Richard Fuchs Date: Sat, 9 Dec 2023 13:24:04 -0500 Subject: [PATCH] MT#55283 convert struct rtp_payload_time to typedef Change-Id: Idb415f448a920b73582f9d5f64cca9b53b81a8ac --- daemon/audio_player.c | 6 +- daemon/call.c | 10 +- daemon/call_interfaces.c | 2 +- daemon/cdr.c | 2 +- daemon/cli.c | 2 +- daemon/codec.c | 230 +++++++++++++++++++-------------------- daemon/janus.c | 2 +- daemon/jitter_buffer.c | 10 +- daemon/media_player.c | 40 +++---- daemon/mqtt.c | 2 +- daemon/recording.c | 2 +- daemon/redis.c | 6 +- daemon/rtp.c | 4 +- daemon/sdp.c | 14 +-- daemon/ssrc.c | 4 +- include/audio_player.h | 6 +- include/call.h | 7 +- include/codec.h | 32 +++--- include/media_player.h | 9 +- include/rtp.h | 3 +- include/ssrc.h | 1 - include/t38.h | 3 +- include/types.h | 1 + t/test-transcode.c | 4 +- 24 files changed, 201 insertions(+), 201 deletions(-) diff --git a/daemon/audio_player.c b/daemon/audio_player.c index 39227ad65..2fc02ad46 100644 --- a/daemon/audio_player.c +++ b/daemon/audio_player.c @@ -50,7 +50,7 @@ static bool audio_player_run(struct media_player *mp) { } // call locked in W -bool audio_player_setup(struct call_media *m, const struct rtp_payload_type *dst_pt, +bool audio_player_setup(struct call_media *m, const rtp_payload_type *dst_pt, unsigned int size_ms, unsigned int delay_ms) { if (!dst_pt) @@ -70,7 +70,7 @@ bool audio_player_setup(struct call_media *m, const struct rtp_payload_type *dst unsigned int ptime_smp = ptime_ms * clockrate / 1000; // in samples // TODO: shortcut this to avoid the detour of avframe -> avpacket -> avframe (all in s16) - struct rtp_payload_type src_pt = { + rtp_payload_type src_pt = { .payload_type = -1, .encoding = STR_CONST_INIT("PCM-S16LE"), // XXX support flp .channels = dst_pt->channels, @@ -203,7 +203,7 @@ bool audio_player_is_active(struct call_media *m) { } -bool audio_player_pt_match(struct call_media *m, const struct rtp_payload_type *pt) { +bool audio_player_pt_match(struct call_media *m, const rtp_payload_type *pt) { return rtp_payload_type_eq_exact(&m->audio_player->mp->coder.handler->dest_pt, pt); } diff --git a/daemon/call.c b/daemon/call.c index 484debad1..f8758604e 100644 --- a/daemon/call.c +++ b/daemon/call.c @@ -1138,7 +1138,7 @@ 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; + rtp_payload_type *pt; codecs_ht src = cs->codecs; /* "src" is a call_media->codecs table, while "dst" is a @@ -3490,11 +3490,11 @@ static int __rtp_stats_sort(const void *ap, const void *bp) { return 0; } -const struct rtp_payload_type *__rtp_stats_codec(struct call_media *m) { +const rtp_payload_type *__rtp_stats_codec(struct call_media *m) { struct packet_stream *ps; GList *values; struct rtp_stats *rtp_s; - const struct rtp_payload_type *rtp_pt = NULL; + const rtp_payload_type *rtp_pt = NULL; /* we only use the primary packet stream for the time being */ if (!m->streams.head) @@ -3513,7 +3513,7 @@ const struct rtp_payload_type *__rtp_stats_codec(struct call_media *m) { if (atomic64_get(&rtp_s->packets) == 0) goto out; - rtp_pt = rtp_payload_type(rtp_s->payload_type, &m->codecs); + rtp_pt = get_rtp_payload_type(rtp_s->payload_type, &m->codecs); out: g_list_free(values); @@ -3602,7 +3602,7 @@ void call_destroy(call_t *c) { struct call_monologue *ml; struct call_media *md; GList *k; - const struct rtp_payload_type *rtp_pt; + const rtp_payload_type *rtp_pt; if (!c) { return; diff --git a/daemon/call_interfaces.c b/daemon/call_interfaces.c index f52170be9..6fc555cab 100644 --- a/daemon/call_interfaces.c +++ b/daemon/call_interfaces.c @@ -2260,7 +2260,7 @@ static void ng_stats_media(bencode_item_t *list, const struct call_media *m, { bencode_item_t *dict, *streams = NULL, *flags; struct packet_stream *ps; - const struct rtp_payload_type *rtp_pt = NULL; + const rtp_payload_type *rtp_pt = NULL; if (!list) goto stats; diff --git a/daemon/cdr.c b/daemon/cdr.c index a67cb8e77..4da44a8cf 100644 --- a/daemon/cdr.c +++ b/daemon/cdr.c @@ -42,7 +42,7 @@ void cdr_update_entry(call_t * c) { int cdrlinecnt = 0; g_autoptr(GString) cdr = g_string_new(""); struct call_media *md; - const struct rtp_payload_type *rtp_pt; + const rtp_payload_type *rtp_pt; struct packet_stream *ps=0; if (!IS_OWN_CALL(c)) diff --git a/daemon/cli.c b/daemon/cli.c index f51282893..a2a1abe8b 100644 --- a/daemon/cli.c +++ b/daemon/cli.c @@ -681,7 +681,7 @@ static void cli_list_tag_info(struct cli_writer *cw, struct call_monologue *ml) if (!md) continue; - const struct rtp_payload_type *rtp_pt = __rtp_stats_codec(md); + const rtp_payload_type *rtp_pt = __rtp_stats_codec(md); cw->cw_printf(cw, "------ Media #%u (" STR_FORMAT " over %s) using ", md->index, diff --git a/daemon/codec.c b/daemon/codec.c index e09e43f18..2afc3ee4b 100644 --- a/daemon/codec.c +++ b/daemon/codec.c @@ -52,11 +52,11 @@ static void __buffer_delay_raw(struct delay_buffer *dbuf, struct codec_handler * static codec_handler_func handler_func_passthrough; static struct timerthread codec_timers_thread; -static void rtp_payload_type_copy(struct rtp_payload_type *dst, const struct rtp_payload_type *src); -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(codec_names_ht, struct rtp_payload_type *pt); +static void rtp_payload_type_copy(rtp_payload_type *dst, const rtp_payload_type *src); +static void codec_store_add_raw_order(struct codec_store *cs, rtp_payload_type *pt); +static rtp_payload_type *codec_store_find_compatible(struct codec_store *cs, + const rtp_payload_type *pt); +static void __rtp_payload_type_add_name(codec_names_ht, rtp_payload_type *pt); static void codec_calc_lost(struct ssrc_ctx *ssrc, uint16_t seq); @@ -78,7 +78,7 @@ static void __ht_queue_del(codec_names_ht ht, const str *key, int pt) { } static rtp_pt_list *__codec_store_delete_link(rtp_pt_list *link, struct codec_store *cs) { - struct rtp_payload_type *pt = link->data; + rtp_payload_type *pt = link->data; t_hash_table_remove(cs->codecs, GINT_TO_POINTER(pt->payload_type)); __ht_queue_del(cs->codec_names, &pt->encoding, pt->payload_type); @@ -261,7 +261,7 @@ static int packet_decoded_fifo(decoder_t *decoder, AVFrame *frame, void *u1, voi static int packet_decoded_direct(decoder_t *decoder, AVFrame *frame, void *u1, void *u2); static int packet_decoded_audio_player(decoder_t *decoder, AVFrame *frame, void *u1, void *u2); -static void codec_touched(struct codec_store *cs, struct rtp_payload_type *pt); +static void codec_touched(struct codec_store *cs, rtp_payload_type *pt); static int __buffer_dtx(struct dtx_buffer *dtxb, struct codec_ssrc_handler *ch, struct codec_ssrc_handler *input_handler, @@ -342,7 +342,7 @@ void codec_handler_free(struct codec_handler **handler) { *handler = NULL; } -static struct codec_handler *__handler_new(const struct rtp_payload_type *pt, struct call_media *media, +static struct codec_handler *__handler_new(const rtp_payload_type *pt, struct call_media *media, struct call_media *sink) { struct codec_handler *handler = g_slice_alloc0(sizeof(*handler)); @@ -407,7 +407,7 @@ static void __reset_sequencer(void *p, void *dummy) { g_hash_table_destroy(s->sequencers); s->sequencers = NULL; } -static void __make_transcoder_full(struct codec_handler *handler, struct rtp_payload_type *dest, +static void __make_transcoder_full(struct codec_handler *handler, rtp_payload_type *dest, GHashTable *output_transcoders, int dtmf_payload_type, bool pcm_dtmf_detect, int cn_payload_type, int (*packet_decoded)(decoder_t *, AVFrame *, void *, void *), struct ssrc_entry *(*ssrc_handler_new_func)(void *p)) @@ -513,14 +513,14 @@ no_handler_reset: handler->output_handler = handler; // make sure we don't have a stale pointer } } -static void __make_transcoder(struct codec_handler *handler, struct rtp_payload_type *dest, +static void __make_transcoder(struct codec_handler *handler, rtp_payload_type *dest, GHashTable *output_transcoders, int dtmf_payload_type, bool pcm_dtmf_detect, int cn_payload_type) { __make_transcoder_full(handler, dest, output_transcoders, dtmf_payload_type, pcm_dtmf_detect, cn_payload_type, packet_decoded_fifo, __ssrc_handler_transcode_new); } -static void __make_audio_player_decoder(struct codec_handler *handler, struct rtp_payload_type *dest, +static void __make_audio_player_decoder(struct codec_handler *handler, rtp_payload_type *dest, bool pcm_dtmf_detect) { __make_transcoder_full(handler, dest, NULL, -1, pcm_dtmf_detect, -1, packet_decoded_audio_player, @@ -528,8 +528,8 @@ static void __make_audio_player_decoder(struct codec_handler *handler, struct rt } // used for generic playback (audio_player, t38_gateway) -struct codec_handler *codec_handler_make_playback(const struct rtp_payload_type *src_pt, - const struct rtp_payload_type *dst_pt, unsigned long last_ts, struct call_media *media, +struct codec_handler *codec_handler_make_playback(const rtp_payload_type *src_pt, + const rtp_payload_type *dst_pt, unsigned long last_ts, struct call_media *media, uint32_t ssrc) { struct codec_handler *handler = __handler_new(src_pt, media, NULL); @@ -556,8 +556,8 @@ struct codec_handler *codec_handler_make_playback(const struct rtp_payload_type return handler; } // used for "play media" player -struct codec_handler *codec_handler_make_media_player(const struct rtp_payload_type *src_pt, - const struct rtp_payload_type *dst_pt, unsigned long last_ts, struct call_media *media, +struct codec_handler *codec_handler_make_media_player(const rtp_payload_type *src_pt, + const rtp_payload_type *dst_pt, unsigned long last_ts, struct call_media *media, uint32_t ssrc) { struct codec_handler *h = codec_handler_make_playback(src_pt, dst_pt, last_ts, media, ssrc); @@ -573,7 +573,7 @@ struct codec_handler *codec_handler_make_media_player(const struct rtp_payload_t } return h; } -struct codec_handler *codec_handler_make_dummy(const struct rtp_payload_type *dst_pt, struct call_media *media) +struct codec_handler *codec_handler_make_dummy(const rtp_payload_type *dst_pt, struct call_media *media) { struct codec_handler *handler = __handler_new(NULL, media, NULL); rtp_payload_type_copy(&handler->dest_pt, dst_pt); @@ -582,7 +582,7 @@ struct codec_handler *codec_handler_make_dummy(const struct rtp_payload_type *ds // does not init/parse a=fmtp -static void ensure_codec_def_type(struct rtp_payload_type *pt, enum media_type type) { +static void ensure_codec_def_type(rtp_payload_type *pt, enum media_type type) { if (pt->codec_def) return; @@ -593,7 +593,7 @@ static void ensure_codec_def_type(struct rtp_payload_type *pt, enum media_type t pt->codec_def = NULL; } // does init/parse a=fmtp -void ensure_codec_def(struct rtp_payload_type *pt, struct call_media *media) { +void ensure_codec_def(rtp_payload_type *pt, struct call_media *media) { if (!media) return; ensure_codec_def_type(pt, media->type_id); @@ -603,7 +603,7 @@ void ensure_codec_def(struct rtp_payload_type *pt, struct call_media *media) { // only called from codec_handlers_update() static void __make_passthrough_gsl(struct codec_handler *handler, GSList **handlers, - struct rtp_payload_type *dtmf_pt, struct rtp_payload_type *cn_pt, + rtp_payload_type *dtmf_pt, rtp_payload_type *cn_pt, bool use_ssrc_passthrough) { __make_passthrough(handler, dtmf_pt ? dtmf_pt->payload_type : -1, @@ -614,7 +614,7 @@ static void __make_passthrough_gsl(struct codec_handler *handler, GSList **handl } -static void __track_supp_codec(GHashTable *supplemental_sinks, struct rtp_payload_type *pt) { +static void __track_supp_codec(GHashTable *supplemental_sinks, rtp_payload_type *pt) { if (!pt->codec_def || !pt->codec_def->supplemental) return; @@ -625,7 +625,7 @@ static void __track_supp_codec(GHashTable *supplemental_sinks, struct rtp_payloa g_hash_table_insert(supp_sinks, GUINT_TO_POINTER(pt->clock_rate), pt); } -static void __check_codec_list(GHashTable **supplemental_sinks, struct rtp_payload_type **pref_dest_codec, +static void __check_codec_list(GHashTable **supplemental_sinks, rtp_payload_type **pref_dest_codec, struct call_media *sink, rtp_pt_q *sink_list) { // first initialise and populate the list of supp sinks @@ -637,11 +637,11 @@ static void __check_codec_list(GHashTable **supplemental_sinks, struct rtp_paylo g_hash_table_new(g_direct_hash, g_direct_equal)); } - struct rtp_payload_type *pdc = NULL; - struct rtp_payload_type *first_tc_codec = NULL; + rtp_payload_type *pdc = NULL; + rtp_payload_type *first_tc_codec = NULL; for (__auto_type l = sink->codecs.codec_prefs.head; l; l = l->next) { - struct rtp_payload_type *pt = l->data; + rtp_payload_type *pt = l->data; ensure_codec_def(pt, sink); if (!pt->codec_def) // not supported, next continue; @@ -674,7 +674,7 @@ static void __check_codec_list(GHashTable **supplemental_sinks, struct rtp_paylo } } -static struct rtp_payload_type *__supp_payload_type(GHashTable *supplemental_sinks, int clockrate, +static rtp_payload_type *__supp_payload_type(GHashTable *supplemental_sinks, int clockrate, const char *codec) { GHashTable *supp_sinks = g_hash_table_lookup(supplemental_sinks, codec); @@ -684,17 +684,17 @@ static struct rtp_payload_type *__supp_payload_type(GHashTable *supplemental_sin return NULL; // find the codec entry with a matching clock rate - struct rtp_payload_type *pt = g_hash_table_lookup(supp_sinks, + rtp_payload_type *pt = g_hash_table_lookup(supp_sinks, GUINT_TO_POINTER(clockrate)); return pt; } static int __unused_pt_number(struct call_media *media, struct call_media *other_media, struct codec_store *extra_cs, - struct rtp_payload_type *pt) + rtp_payload_type *pt) { int num = pt ? pt->payload_type : -1; - struct rtp_payload_type *pt_match; + rtp_payload_type *pt_match; if (num < 0) num = 96; // default first dynamic payload type number @@ -741,7 +741,7 @@ static void __check_dtmf_injector(struct call_media *receiver, struct call_media return; // synthesise input rtp payload type - struct rtp_payload_type src_pt = { + rtp_payload_type src_pt = { .payload_type = -1, .clock_rate = parent->source_pt.clock_rate, .channels = parent->source_pt.channels, @@ -764,7 +764,7 @@ static void __check_dtmf_injector(struct call_media *receiver, struct call_media -static struct codec_handler *__get_pt_handler(struct call_media *receiver, struct rtp_payload_type *pt, +static struct codec_handler *__get_pt_handler(struct call_media *receiver, rtp_payload_type *pt, struct call_media *sink) { ensure_codec_def(pt, receiver); @@ -869,7 +869,7 @@ static void __check_t38_gateway(struct call_media *pcm_media, struct call_media // for each codec type supported by the pcm_media, we create a codec handler that // links to the T.38 encoder for (__auto_type l = pcm_media->codecs.codec_prefs.head; l; l = l->next) { - struct rtp_payload_type *pt = l->data; + rtp_payload_type *pt = l->data; struct codec_handler *handler = __get_pt_handler(pcm_media, pt, t38_media); if (!pt->codec_def) { // should not happen @@ -1113,7 +1113,7 @@ void __codec_handlers_update(struct call_media *receiver, struct call_media *sin // first gather info about what we can send g_autoptr(GHashTable) supplemental_sinks = NULL; - struct rtp_payload_type *pref_dest_codec = NULL; + rtp_payload_type *pref_dest_codec = NULL; __check_codec_list(&supplemental_sinks, &pref_dest_codec, sink, &sink->codecs.codec_prefs); // then do the same with what we can receive @@ -1145,8 +1145,8 @@ void __codec_handlers_update(struct call_media *receiver, struct call_media *sin bool force_transcoding = do_pcm_dtmf_blocking || do_dtmf_blocking || use_audio_player; for (__auto_type l = receiver->codecs.codec_prefs.head; l; ) { - struct rtp_payload_type *pt = l->data; - struct rtp_payload_type *sink_pt = NULL; + rtp_payload_type *pt = l->data; + rtp_payload_type *sink_pt = NULL; ilogs(codec, LOG_DEBUG, "Checking receiver codec " STR_FORMAT "/" STR_FORMAT " (%i)", STR_FMT(&pt->encoding_with_full_params), @@ -1166,9 +1166,9 @@ void __codec_handlers_update(struct call_media *receiver, struct call_media *sin } // fill matching supp codecs - struct rtp_payload_type *recv_dtmf_pt = __supp_payload_type(supplemental_recvs, pt->clock_rate, + rtp_payload_type *recv_dtmf_pt = __supp_payload_type(supplemental_recvs, pt->clock_rate, "telephone-event"); - struct rtp_payload_type *recv_cn_pt = __supp_payload_type(supplemental_recvs, pt->clock_rate, + rtp_payload_type *recv_cn_pt = __supp_payload_type(supplemental_recvs, pt->clock_rate, "CN"); bool pcm_dtmf_detect = false; @@ -1227,11 +1227,11 @@ void __codec_handlers_update(struct call_media *receiver, struct call_media *sin sink_pt_fixed:; // we have found a usable output codec. gather matching output supp codecs - struct rtp_payload_type *sink_dtmf_pt = __supp_payload_type(supplemental_sinks, + rtp_payload_type *sink_dtmf_pt = __supp_payload_type(supplemental_sinks, sink_pt->clock_rate, "telephone-event"); - struct rtp_payload_type *sink_cn_pt = __supp_payload_type(supplemental_sinks, + rtp_payload_type *sink_cn_pt = __supp_payload_type(supplemental_sinks, sink_pt->clock_rate, "CN"); - struct rtp_payload_type *real_sink_dtmf_pt = NULL; // for DTMF delay + rtp_payload_type *real_sink_dtmf_pt = NULL; // for DTMF delay // XXX synthesise missing supp codecs according to codec tracker XXX needed? @@ -1400,7 +1400,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 = t_hash_table_lookup(sink->codecs.codecs, + 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) @@ -1444,7 +1444,7 @@ next: receiver->rtcp_handler = rtcp_transcode_handler; for (__auto_type l = receiver->codecs.codec_prefs.head; l; ) { - struct rtp_payload_type *pt = l->data; + rtp_payload_type *pt = l->data; if (pt->codec_def) { // supported @@ -2423,7 +2423,7 @@ struct codec_packet *codec_packet_dup(struct codec_packet *p) { -struct rtp_payload_type *codec_make_payload_type(const str *codec_str, enum media_type type) { +rtp_payload_type *codec_make_payload_type(const str *codec_str, enum media_type type) { str codec_fmt = *codec_str; str codec, parms, chans, opts, extra_opts, fmt_params, codec_opts; @@ -2444,7 +2444,7 @@ struct rtp_payload_type *codec_make_payload_type(const str *codec_str, enum medi if (clockrate && !channels) channels = 1; - struct rtp_payload_type *pt = g_slice_alloc0(sizeof(*pt)); + rtp_payload_type *pt = g_slice_alloc0(sizeof(*pt)); pt->payload_type = -1; pt->encoding = codec; @@ -2460,7 +2460,7 @@ struct rtp_payload_type *codec_make_payload_type(const str *codec_str, enum medi return pt; } -void codec_init_payload_type(struct rtp_payload_type *pt, enum media_type type) { +void codec_init_payload_type(rtp_payload_type *pt, enum media_type type) { #ifdef WITH_TRANSCODING ensure_codec_def_type(pt, type); codec_def_t *def = pt->codec_def; @@ -2481,7 +2481,7 @@ void codec_init_payload_type(struct rtp_payload_type *pt, enum media_type type) def->init(pt); if (pt->payload_type == -1 && def->rfc_payload_type >= 0) { - const struct rtp_payload_type *rfc_pt = rtp_get_rfc_payload_type(def->rfc_payload_type); + const rtp_payload_type *rfc_pt = rtp_get_rfc_payload_type(def->rfc_payload_type); // only use the RFC payload type if all parameters match if (rfc_pt && (pt->clock_rate == 0 || pt->clock_rate == rfc_pt->clock_rate) @@ -3390,7 +3390,7 @@ 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 = t_hash_table_lookup(ps->media->codecs.codecs, + 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; @@ -4433,8 +4433,8 @@ static int handler_func_inject_dtmf(struct codec_handler *h, struct media_packet -static struct rtp_payload_type *codec_make_payload_type_sup(const str *codec_str, struct call_media *media) { - struct rtp_payload_type *ret = codec_make_payload_type(codec_str, media ? media->type_id : MT_UNKNOWN); +static rtp_payload_type *codec_make_payload_type_sup(const str *codec_str, struct call_media *media) { + rtp_payload_type *ret = codec_make_payload_type(codec_str, media ? media->type_id : MT_UNKNOWN); if (!ret) goto err2; @@ -4475,7 +4475,7 @@ err2: #ifdef WITH_TRANSCODING -static struct rtp_payload_type *codec_add_payload_type_pt(struct rtp_payload_type *pt, struct call_media *media, +static rtp_payload_type *codec_add_payload_type_pt(rtp_payload_type *pt, struct call_media *media, struct call_media *other_media, struct codec_store *extra_cs) { if (!pt) @@ -4492,10 +4492,10 @@ static struct rtp_payload_type *codec_add_payload_type_pt(struct rtp_payload_typ return pt; } -static struct rtp_payload_type *codec_add_payload_type(const str *codec, struct call_media *media, +static rtp_payload_type *codec_add_payload_type(const str *codec, struct call_media *media, struct call_media *other_media, struct codec_store *extra_cs) { - struct rtp_payload_type *pt = codec_make_payload_type_sup(codec, media); + rtp_payload_type *pt = codec_make_payload_type_sup(codec, media); return codec_add_payload_type_pt(pt, media, other_media, extra_cs); } @@ -4507,7 +4507,7 @@ static struct rtp_payload_type *codec_add_payload_type(const str *codec, struct -void payload_type_clear(struct rtp_payload_type *p) { +void payload_type_clear(rtp_payload_type *p) { g_queue_clear_full(&p->rtcp_fb, free); str_free_dup(&p->encoding); str_free_dup(&p->encoding_parameters); @@ -4518,11 +4518,11 @@ void payload_type_clear(struct rtp_payload_type *p) { ZERO(*p); p->payload_type = -1; } -void payload_type_free(struct rtp_payload_type *p) { +void payload_type_free(rtp_payload_type *p) { payload_type_clear(p); g_slice_free1(sizeof(*p), p); } -void payload_type_destroy(struct rtp_payload_type **p) { +void payload_type_destroy(rtp_payload_type **p) { if (*p) payload_type_free(*p); *p = NULL; @@ -4530,7 +4530,7 @@ void payload_type_destroy(struct rtp_payload_type **p) { // dst must be pre-initialised (zeroed) -static void rtp_payload_type_copy(struct rtp_payload_type *dst, const struct rtp_payload_type *src) { +static void rtp_payload_type_copy(rtp_payload_type *dst, const rtp_payload_type *src) { payload_type_clear(dst); *dst = *src; @@ -4543,12 +4543,12 @@ static void rtp_payload_type_copy(struct rtp_payload_type *dst, const struct rtp codec_init_payload_type(dst, MT_UNKNOWN); } -struct rtp_payload_type *rtp_payload_type_dup(const struct rtp_payload_type *pt) { - struct rtp_payload_type *pt_copy = g_slice_alloc0(sizeof(*pt)); +rtp_payload_type *rtp_payload_type_dup(const rtp_payload_type *pt) { + rtp_payload_type *pt_copy = g_slice_alloc0(sizeof(*pt)); rtp_payload_type_copy(pt_copy, pt); return pt_copy; } -static void __rtp_payload_type_add_name(codec_names_ht ht, struct rtp_payload_type *pt) { +static void __rtp_payload_type_add_name(codec_names_ht ht, 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 = codec_names_ht_lookup_insert(ht, str_dup(&pt->encoding_with_params)); @@ -4560,7 +4560,7 @@ static void __rtp_payload_type_add_name(codec_names_ht ht, struct rtp_payload_ty static void __insert_codec_tracker(GHashTable *all_clockrates, GHashTable *all_supp_codecs, struct codec_tracker *sct, rtp_pt_list *link) { - struct rtp_payload_type *pt = link->data; + rtp_payload_type *pt = link->data; if (!pt->codec_def || !pt->codec_def->supplemental) g_hash_table_replace(all_clockrates, GUINT_TO_POINTER(pt->clock_rate), @@ -4580,13 +4580,13 @@ static void __insert_codec_tracker(GHashTable *all_clockrates, GHashTable *all_s } } #endif -static int __codec_options_set1(call_t *call, struct rtp_payload_type *pt, const str *enc, +static int __codec_options_set1(call_t *call, rtp_payload_type *pt, const str *enc, str_case_value_ht codec_set) { str *pt_str = t_hash_table_lookup(codec_set, enc); if (!pt_str) return 0; - struct rtp_payload_type *pt_parsed = codec_make_payload_type(pt_str, MT_UNKNOWN); + rtp_payload_type *pt_parsed = codec_make_payload_type(pt_str, MT_UNKNOWN); if (!pt_parsed) return 0; // match parameters @@ -4605,7 +4605,7 @@ static int __codec_options_set1(call_t *call, struct rtp_payload_type *pt, const payload_type_free(pt_parsed); return 1; } -static void __codec_options_set(call_t *call, struct rtp_payload_type *pt, str_case_value_ht codec_set) { +static void __codec_options_set(call_t *call, rtp_payload_type *pt, str_case_value_ht codec_set) { if (!call) return; if (!t_hash_table_is_set(codec_set)) @@ -4642,14 +4642,14 @@ static void codec_tracker_move(struct codec_tracker **dst, struct codec_tracker *src = NULL; #endif } -static void codec_touched_real(struct codec_store *cs, struct rtp_payload_type *pt) { +static void codec_touched_real(struct codec_store *cs, rtp_payload_type *pt) { #ifdef WITH_TRANSCODING if (pt->codec_def && pt->codec_def->supplemental) return; g_hash_table_replace(cs->tracker->touched, GUINT_TO_POINTER(pt->clock_rate), (void *) 0x1); #endif } -static void codec_touched(struct codec_store *cs, struct rtp_payload_type *pt) { +static void codec_touched(struct codec_store *cs, rtp_payload_type *pt) { #ifdef WITH_TRANSCODING if (pt->codec_def && pt->codec_def->supplemental) { cs->tracker->all_touched = 1; @@ -4669,7 +4669,7 @@ static bool is_codec_touched_rate(struct codec_tracker *tracker, unsigned int cl return false; #endif } -static bool is_codec_touched(struct codec_store *cs, struct rtp_payload_type *pt) { +static bool is_codec_touched(struct codec_store *cs, rtp_payload_type *pt) { if (!cs) return false; return is_codec_touched_rate(cs->tracker, pt->clock_rate); @@ -4737,7 +4737,7 @@ void codec_tracker_update(struct codec_store *cs, struct codec_store *orig_cs) { str pt_str = STR_INIT(pt_s); // see if we have a matching PT from before - struct rtp_payload_type *pt = NULL; + rtp_payload_type *pt = NULL; if (orig_cs) { GQueue *ptq = t_hash_table_lookup(orig_cs->codec_names, &pt_str); if (ptq) { @@ -4777,7 +4777,7 @@ void codec_tracker_update(struct codec_store *cs, struct codec_store *orig_cs) { GQueue *entries = g_hash_table_lookup(supp_clockrates, GUINT_TO_POINTER(clockrate)); for (GList *j = entries->head; j; j = j->next) { rtp_pt_list *link = j->data; - struct rtp_payload_type *pt = link->data; + rtp_payload_type *pt = link->data; ilogs(codec, LOG_DEBUG, "Eliminating supplemental codec " STR_FORMAT "/" STR_FORMAT " (%i) with " "stray clock rate %u", @@ -4827,12 +4827,12 @@ static void codec_store_move(struct codec_store *dst, struct codec_store *src) { // `out_compat` must be initialised already, or NULL // either `codec` or `pt_parsed` must be given (or both) -static void codec_store_find_matching_codecs(rtp_pt_q *out_compat, struct rtp_payload_type **out_exact, +static void codec_store_find_matching_codecs(rtp_pt_q *out_compat, rtp_payload_type **out_exact, struct codec_store *cs, const str *codec, - struct rtp_payload_type *pt_parsed) + rtp_payload_type *pt_parsed) { - AUTO_CLEANUP_NULL(struct rtp_payload_type *pt_store, payload_type_destroy); - struct rtp_payload_type *pt = NULL; + AUTO_CLEANUP_NULL(rtp_payload_type *pt_store, payload_type_destroy); + rtp_payload_type *pt = NULL; if (pt_parsed) pt = pt_parsed; @@ -4853,7 +4853,7 @@ static void codec_store_find_matching_codecs(rtp_pt_q *out_compat, struct rtp_pa return; // no matches // see if given format parameters match for (GList *k = pts->head; k; k = k->next) { - struct rtp_payload_type *pt2 = t_hash_table_lookup(cs->codecs, k->data); + rtp_payload_type *pt2 = t_hash_table_lookup(cs->codecs, k->data); if (!pt2) continue; ensure_codec_def(pt2, cs->media); @@ -4874,7 +4874,7 @@ static void codec_store_find_matching_codecs(rtp_pt_q *out_compat, struct rtp_pa } __attribute__((nonnull(1, 2))) -static void codec_store_add_raw_link(struct codec_store *cs, struct rtp_payload_type *pt, rtp_pt_list *link) { +static void codec_store_add_raw_link(struct codec_store *cs, rtp_payload_type *pt, rtp_pt_list *link) { // cs->media may be NULL ensure_codec_def(pt, cs->media); if (cs->media && cs->media->ptime > 0) @@ -4901,18 +4901,18 @@ static void codec_store_add_raw_link(struct codec_store *cs, struct rtp_payload_ // appends to the end, but before supplemental codecs __attribute__((nonnull(1, 2))) -static void codec_store_add_raw_order(struct codec_store *cs, struct rtp_payload_type *pt) { +static void codec_store_add_raw_order(struct codec_store *cs, rtp_payload_type *pt) { codec_store_add_raw_link(cs, pt, cs->supp_link); } // appends to the end __attribute__((nonnull(1, 2))) -void codec_store_add_raw(struct codec_store *cs, struct rtp_payload_type *pt) { +void codec_store_add_raw(struct codec_store *cs, rtp_payload_type *pt) { codec_store_add_raw_link(cs, pt, NULL); } __attribute__((nonnull(1, 2))) -static struct rtp_payload_type *codec_store_add_link(struct codec_store *cs, - struct rtp_payload_type *pt, rtp_pt_list *link) +static rtp_payload_type *codec_store_add_link(struct codec_store *cs, + rtp_payload_type *pt, rtp_pt_list *link) { if (!cs->media) return NULL; @@ -4921,38 +4921,38 @@ static struct rtp_payload_type *codec_store_add_link(struct codec_store *cs, if (proto_is_not_rtp(cs->media->protocol)) return NULL; - struct rtp_payload_type *copy = rtp_payload_type_dup(pt); + rtp_payload_type *copy = rtp_payload_type_dup(pt); codec_store_add_raw_link(cs, copy, link); return copy; } // appends to the end, but before supplemental codecs __attribute__((nonnull(1, 2))) -static struct rtp_payload_type *codec_store_add_order(struct codec_store *cs, struct rtp_payload_type *pt) { +static rtp_payload_type *codec_store_add_order(struct codec_store *cs, rtp_payload_type *pt) { return codec_store_add_link(cs, pt, cs->supp_link); } // always add to end __attribute__((nonnull(1, 2))) -static void codec_store_add_end(struct codec_store *cs, struct rtp_payload_type *pt) { +static void codec_store_add_end(struct codec_store *cs, rtp_payload_type *pt) { codec_store_add_link(cs, pt, NULL); } -static struct rtp_payload_type *codec_store_find_compatible_q(struct codec_store *cs, GQueue *q, - const struct rtp_payload_type *pt) +static rtp_payload_type *codec_store_find_compatible_q(struct codec_store *cs, GQueue *q, + const rtp_payload_type *pt) { if (!q) return NULL; for (GList *l = q->head; l; l = l->next) { - struct rtp_payload_type *ret = t_hash_table_lookup(cs->codecs, l->data); + rtp_payload_type *ret = t_hash_table_lookup(cs->codecs, l->data); if (rtp_payload_type_fmt_eq_compat(ret, pt)) return ret; } return NULL; } -static struct rtp_payload_type *codec_store_find_compatible(struct codec_store *cs, - const struct rtp_payload_type *pt) +static rtp_payload_type *codec_store_find_compatible(struct codec_store *cs, + const rtp_payload_type *pt) { - struct rtp_payload_type *ret; + rtp_payload_type *ret; ret = codec_store_find_compatible_q(cs, t_hash_table_lookup(cs->codec_names, &pt->encoding_with_full_params), pt); @@ -4977,8 +4977,8 @@ void __codec_store_populate_reuse(struct codec_store *dst, struct codec_store *s call_t *call = media ? media->call : NULL; 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 = t_hash_table_lookup(dst->codecs, + rtp_payload_type *pt = l->data; + rtp_payload_type *orig_pt = t_hash_table_lookup(dst->codecs, GINT_TO_POINTER(pt->payload_type)); pt->reverse_payload_type = pt->payload_type; @@ -5007,8 +5007,8 @@ 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 = t_hash_table_lookup(src->codecs, + rtp_payload_type *pt = l->data; + rtp_payload_type *orig_pt = t_hash_table_lookup(src->codecs, GINT_TO_POINTER(pt->payload_type)); if(!orig_pt){ if (a.merge_cs) @@ -5033,12 +5033,12 @@ void codec_store_check_empty(struct codec_store *dst, struct codec_store *src) { static void codec_store_merge(struct codec_store *dst, struct codec_store *src) { while (src->codec_prefs.length) { - struct rtp_payload_type *pt = t_queue_pop_tail(&src->codec_prefs); + rtp_payload_type *pt = t_queue_pop_tail(&src->codec_prefs); // 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 = t_hash_table_lookup(dst->codecs, + 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); @@ -5058,8 +5058,8 @@ void __codec_store_populate(struct codec_store *dst, struct codec_store *src, st call_t *call = media ? media->call : NULL; 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 = t_hash_table_lookup(orig_dst.codecs, + rtp_payload_type *pt = l->data; + 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) @@ -5116,7 +5116,7 @@ void codec_store_strip(struct codec_store *cs, str_q *strip, str_case_ht except) __auto_type link = cs->codec_prefs.head; while (link) { __auto_type next = link->next; - struct rtp_payload_type *pt = link->data; + rtp_payload_type *pt = link->data; if (t_hash_table_is_set(except) && t_hash_table_lookup(except, &pt->encoding)) ; else if (t_hash_table_is_set(except) && t_hash_table_lookup(except, &pt->encoding_with_params)) @@ -5146,7 +5146,7 @@ void codec_store_strip(struct codec_store *cs, str_q *strip, str_case_ht except) } while (pts->length) { int pt_num = GPOINTER_TO_INT(pts->head->data); - struct rtp_payload_type *pt = t_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num)); + 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), @@ -5186,7 +5186,7 @@ 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 = t_hash_table_lookup(orig->codecs, + 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, @@ -5235,7 +5235,7 @@ void codec_store_accept(struct codec_store *cs, str_q *accept, struct codec_stor rtp_pt_q pt_readded = TYPED_GQUEUE_INIT; // XXX duplicate code for (__auto_type k = pts->head; k; k = k->next) { - struct rtp_payload_type *orig_pt = k->data; + rtp_payload_type *orig_pt = k->data; 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, @@ -5248,7 +5248,7 @@ void codec_store_accept(struct codec_store *cs, str_q *accept, struct codec_stor STR_FMT0(&orig_pt->format_parameters), orig_pt->payload_type); codec_touched(cs, orig_pt); - struct rtp_payload_type *added = codec_store_add_order(cs, orig_pt); + rtp_payload_type *added = codec_store_add_order(cs, orig_pt); if (added) t_queue_push_tail(&pt_readded, added); } @@ -5258,9 +5258,9 @@ void codec_store_accept(struct codec_store *cs, str_q *accept, struct codec_stor continue; } for (__auto_type k = pts->head; k; k = k->next) { - struct rtp_payload_type *fpt = k->data; + rtp_payload_type *fpt = k->data; int pt_num = fpt->payload_type; - struct rtp_payload_type *pt = t_hash_table_lookup(cs->codecs, + 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, @@ -5282,7 +5282,7 @@ int codec_store_accept_one(struct codec_store *cs, str_q *accept, bool accept_an // local codec-accept routine: accept first supported codec, or first from "accept" list // if given - struct rtp_payload_type *accept_pt = NULL; + rtp_payload_type *accept_pt = NULL; for (__auto_type l = accept->head; l; l = l->next) { // iterate through list and look for the first supported codec @@ -5296,7 +5296,7 @@ int codec_store_accept_one(struct codec_store *cs, str_q *accept, bool accept_an continue; for (GList *k = pts->head; k; k = k->next) { int pt_num = GPOINTER_TO_INT(k->data); - struct rtp_payload_type *pt = t_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num)); + 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)); @@ -5312,7 +5312,7 @@ int codec_store_accept_one(struct codec_store *cs, str_q *accept, bool accept_an if (!accept_pt) { // none found yet - pick the first one for (__auto_type l = cs->codec_prefs.head; l; l = l->next) { - struct rtp_payload_type *pt = l->data; + rtp_payload_type *pt = l->data; if (!accept_any) { ensure_codec_def(pt, cs->media); if (!pt->codec_def) @@ -5331,7 +5331,7 @@ int codec_store_accept_one(struct codec_store *cs, str_q *accept, bool accept_an // delete all codecs except the accepted one __auto_type link = cs->codec_prefs.head; while (link) { - struct rtp_payload_type *pt = link->data; + rtp_payload_type *pt = link->data; if (pt == accept_pt) { link = link->next; continue; @@ -5356,7 +5356,7 @@ void codec_store_track(struct codec_store *cs, str_q *q) { continue; for (GList *k = pts->head; k; k = k->next) { int pt_num = GPOINTER_TO_INT(k->data); - struct rtp_payload_type *pt = t_hash_table_lookup(cs->codecs, + rtp_payload_type *pt = t_hash_table_lookup(cs->codecs, GINT_TO_POINTER(pt_num)); codec_touched(cs, pt); } @@ -5370,11 +5370,11 @@ void codec_store_transcode(struct codec_store *cs, str_q *offer, struct codec_st for (__auto_type l = offer->head; l; l = l->next) { str *codec = l->data; // parse out given codec string - AUTO_CLEANUP(struct rtp_payload_type *pt, payload_type_destroy) + AUTO_CLEANUP(rtp_payload_type *pt, payload_type_destroy) = codec_make_payload_type_sup(codec, cs->media); // find matching existing PT if one exists - struct rtp_payload_type *pt_match = NULL; + rtp_payload_type *pt_match = NULL; codec_store_find_matching_codecs(NULL, &pt_match, cs, codec, pt); if (pt_match) { ilogs(codec, LOG_DEBUG, "Codec " STR_FORMAT @@ -5406,7 +5406,7 @@ 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 = t_hash_table_lookup(orig->codecs, + 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, @@ -5460,7 +5460,7 @@ void codec_store_answer(struct codec_store *dst, struct codec_store *src, sdp_ng if (flags->single_codec && num_codecs >= 1) add_codec = false; - struct rtp_payload_type *pt = l->data; + rtp_payload_type *pt = l->data; struct codec_handler *h = codec_handler_get(src_media, pt->payload_type, dst_media, NULL); bool is_supp = false; @@ -5530,7 +5530,7 @@ void codec_store_answer(struct codec_store *dst, struct codec_store *src, sdp_ng 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; + rtp_payload_type copy = *pt; copy.payload_type = pt->reverse_payload_type; codec_store_add_end(dst, ©); } @@ -5561,7 +5561,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); + rtp_payload_type *pt = g_queue_pop_head(&supp_codecs); 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); @@ -5598,7 +5598,7 @@ void codec_store_synthesise(struct codec_store *dst, struct codec_store *opposit else { // we already have a list of codecs - make sure they're all supported by us for (__auto_type l = dst->codec_prefs.head; l;) { - struct rtp_payload_type *pt = l->data; + rtp_payload_type *pt = l->data; if (pt->codec_def) { l = l->next; continue; @@ -5617,8 +5617,8 @@ void codec_store_synthesise(struct codec_store *dst, struct codec_store *opposit // check all codecs listed in the source are also be present in the answer (dst) 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 = t_hash_table_lookup(dst->codecs, + const rtp_payload_type *src_pt = l->data; + const 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/janus.c b/daemon/janus.c index d106bcdfd..ffe5c03c2 100644 --- a/daemon/janus.c +++ b/daemon/janus.c @@ -341,7 +341,7 @@ static void janus_add_publisher_details(JsonBuilder *builder, struct call_monolo const char *codec = NULL; for (__auto_type k = media->codecs.codec_prefs.head; k; k = k->next) { - struct rtp_payload_type *pt = k->data; + rtp_payload_type *pt = k->data; codec = pt->encoding.s; // XXX check codec support? break; diff --git a/daemon/jitter_buffer.c b/daemon/jitter_buffer.c index c025789c0..58866c495 100644 --- a/daemon/jitter_buffer.c +++ b/daemon/jitter_buffer.c @@ -64,8 +64,8 @@ static void reset_jitter_buffer(struct jitter_buffer *jb) { jb->disabled = 1; } -static struct rtp_payload_type *get_rtp_payload_type(struct media_packet *mp, int payload_type) { - struct rtp_payload_type *rtp_pt = NULL; +static rtp_payload_type *codec_rtp_pt(struct media_packet *mp, int payload_type) { + rtp_payload_type *rtp_pt = NULL; struct codec_handler *transcoder = codec_handler_get(mp->media, payload_type, mp->media_out, NULL); if(transcoder) { if(transcoder->source_pt.payload_type == payload_type) @@ -83,7 +83,7 @@ static int get_clock_rate(struct media_packet *mp, int payload_type) { if(jb->clock_rate && jb->payload_type == payload_type) return jb->clock_rate; - const struct rtp_payload_type *rtp_pt = get_rtp_payload_type(mp, payload_type); + const rtp_payload_type *rtp_pt = codec_rtp_pt(mp, payload_type); if(rtp_pt) { if(rtp_pt->codec_def && !rtp_pt->codec_def->dtmf) { clock_rate = jb->clock_rate = rtp_pt->clock_rate; @@ -261,7 +261,7 @@ int buffer_packet(struct media_packet *mp, const str *s) { int seq = ntohs(mp->rtp->seq_num); int marker = (mp->rtp->m_pt & 0x80) ? 1 : 0; int dtmf = 0; - const struct rtp_payload_type *rtp_pt = get_rtp_payload_type(mp, payload_type); + const rtp_payload_type *rtp_pt = codec_rtp_pt(mp, payload_type); if(rtp_pt) { if(rtp_pt->codec_def && rtp_pt->codec_def->dtmf) dtmf = 1; @@ -346,7 +346,7 @@ static void set_jitter_values(struct media_packet *mp) { int curr_seq = ntohs(mp->rtp->seq_num); int payload_type = (mp->rtp->m_pt & 0x7f); int dtmf = 0; - const struct rtp_payload_type *rtp_pt = get_rtp_payload_type(mp, payload_type); + const rtp_payload_type *rtp_pt = codec_rtp_pt(mp, payload_type); if(rtp_pt) { if(rtp_pt->codec_def && rtp_pt->codec_def->dtmf) dtmf = 1; diff --git a/daemon/media_player.c b/daemon/media_player.c index ccc849a9f..2b3d68a0e 100644 --- a/daemon/media_player.c +++ b/daemon/media_player.c @@ -39,7 +39,7 @@ TYPED_GPTRARRAY_FULL(cache_packet_arr, struct media_player_cache_packet, cache_p struct media_player_cache_index { struct media_player_content_index index; - struct rtp_payload_type dst_pt; + rtp_payload_type dst_pt; }; struct media_player_cache_entry { bool finished; @@ -470,7 +470,7 @@ retry:; return false; } -static void media_player_cached_reader_start(struct media_player *mp, const struct rtp_payload_type *dst_pt, +static void media_player_cached_reader_start(struct media_player *mp, const rtp_payload_type *dst_pt, long long repeat) { struct media_player_cache_entry *entry = mp->cache_entry; @@ -506,7 +506,7 @@ static void cache_packet_free(struct media_player_cache_packet *p) { // returns: true = entry exists, decoding handled separately, use entry for playback // false = no entry exists, OR entry is a new one, proceed to open decoder, then call _play_start static bool media_player_cache_get_entry(struct media_player *mp, - const struct rtp_payload_type *dst_pt, long long repeat) + const rtp_payload_type *dst_pt, long long repeat) { if (!rtpe_config.player_cache) return false; @@ -650,7 +650,7 @@ static int media_player_packet_cache(encoder_t *enc, void *u1, void *u2) { // do have a cache entry, initialise it, set up the thread, take over decoding, and then proceed as a // media player consuming the data from the decoder thread. // returns: false = continue normally decode in-thread, true = take data from other thread -static bool media_player_cache_entry_init(struct media_player *mp, const struct rtp_payload_type *dst_pt, +static bool media_player_cache_entry_init(struct media_player *mp, const rtp_payload_type *dst_pt, long long repeat) { struct media_player_cache_entry *entry = mp->cache_entry; @@ -675,8 +675,8 @@ static bool media_player_cache_entry_init(struct media_player *mp, const struct // find suitable output payload type -static struct rtp_payload_type *media_player_get_dst_pt(struct media_player *mp) { - struct rtp_payload_type *dst_pt = NULL; +static rtp_payload_type *media_player_get_dst_pt(struct media_player *mp) { + rtp_payload_type *dst_pt = NULL; for (__auto_type l = mp->media->codecs.codec_prefs.head; l; l = l->next) { dst_pt = l->data; ensure_codec_def(dst_pt, mp->media); @@ -694,8 +694,8 @@ found: } -bool media_player_pt_match(const struct media_player *mp, const struct rtp_payload_type *src_pt, - const struct rtp_payload_type *dst_pt) +bool media_player_pt_match(const struct media_player *mp, const rtp_payload_type *src_pt, + const rtp_payload_type *dst_pt) { if (!mp->coder.handler) return true; // not initialised yet -> doesn't need a reset @@ -707,8 +707,8 @@ bool media_player_pt_match(const struct media_player *mp, const struct rtp_paylo } -static int media_player_setup_common(struct media_player *mp, const struct rtp_payload_type *src_pt, - const struct rtp_payload_type **dst_pt) +static int media_player_setup_common(struct media_player *mp, const rtp_payload_type *src_pt, + const rtp_payload_type **dst_pt) { if (!*dst_pt) *dst_pt = media_player_get_dst_pt(mp); @@ -732,8 +732,8 @@ static int media_player_setup_common(struct media_player *mp, const struct rtp_p } // used for generic playback (audio_player, t38_gateway) -int media_player_setup(struct media_player *mp, const struct rtp_payload_type *src_pt, - const struct rtp_payload_type *dst_pt) +int media_player_setup(struct media_player *mp, const rtp_payload_type *src_pt, + const rtp_payload_type *dst_pt) { int ret = media_player_setup_common(mp, src_pt, &dst_pt); if (ret) @@ -748,8 +748,8 @@ int media_player_setup(struct media_player *mp, const struct rtp_payload_type *s return 0; } // used for "play media" player -static int __media_player_setup_internal(struct media_player *mp, const struct rtp_payload_type *src_pt, - const struct rtp_payload_type *dst_pt) +static int __media_player_setup_internal(struct media_player *mp, const rtp_payload_type *src_pt, + const rtp_payload_type *dst_pt) { int ret = media_player_setup_common(mp, src_pt, &dst_pt); if (ret) @@ -764,12 +764,12 @@ static int __media_player_setup_internal(struct media_player *mp, const struct r return 0; } -static int __ensure_codec_handler(struct media_player *mp, const struct rtp_payload_type *dst_pt) { +static int __ensure_codec_handler(struct media_player *mp, const rtp_payload_type *dst_pt) { if (mp->coder.handler) return 0; // synthesise rtp payload type - struct rtp_payload_type src_pt = { .payload_type = -1 }; + rtp_payload_type src_pt = { .payload_type = -1 }; src_pt.codec_def = codec_find_by_av(mp->coder.avstream->CODECPAR->codec_id); if (!src_pt.codec_def) { ilog(LOG_ERR, "Attempting to play media from an unsupported file format/codec"); @@ -894,7 +894,7 @@ void media_player_set_media(struct media_player *mp, struct call_media *media) { // call->master_lock held in W // returns destination payload type, or NULL on failure -static const struct rtp_payload_type *media_player_play_init(struct media_player *mp) { +static const rtp_payload_type *media_player_play_init(struct media_player *mp) { media_player_shutdown(mp); // find call media suitable for playback @@ -921,7 +921,7 @@ found: // call->master_lock held in W -static void media_player_play_start(struct media_player *mp, const struct rtp_payload_type *dst_pt, +static void media_player_play_start(struct media_player *mp, const rtp_payload_type *dst_pt, long long repeat, long long start_pos) { // needed to have usable duration for some formats. ignore errors. @@ -956,7 +956,7 @@ static void media_player_play_start(struct media_player *mp, const struct rtp_pa // call->master_lock held in W int media_player_play_file(struct media_player *mp, const str *file, long long repeat, long long start_pos) { #ifdef WITH_TRANSCODING - const struct rtp_payload_type *dst_pt = media_player_play_init(mp); + const rtp_payload_type *dst_pt = media_player_play_init(mp); if (!dst_pt) return -1; @@ -1038,7 +1038,7 @@ static int media_player_play_blob_id(struct media_player *mp, const str *blob, l const char *err; int av_ret = 0; - const struct rtp_payload_type *dst_pt = media_player_play_init(mp); + const rtp_payload_type *dst_pt = media_player_play_init(mp); if (!dst_pt) return -1; diff --git a/daemon/mqtt.c b/daemon/mqtt.c index fa05fbd37..d1506a188 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 = t_hash_table_lookup(media->codecs.codecs, GUINT_TO_POINTER(prim_pt)); + 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 dbb18c8fe..5f102ff6d 100644 --- a/daemon/recording.c +++ b/daemon/recording.c @@ -945,7 +945,7 @@ static void setup_media_proc(struct call_media *media) { codecs_ht_iter iter; t_hash_table_iter_init(&iter, media->codecs.codecs); - struct rtp_payload_type *pt; + 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); diff --git a/daemon/redis.c b/daemon/redis.c index bd2ea977e..dc8a8e970 100644 --- a/daemon/redis.c +++ b/daemon/redis.c @@ -1529,14 +1529,14 @@ static int redis_tags(call_t *c, struct redis_list *tags, JsonReader *root_reade return 0; } -static struct rtp_payload_type *rbl_cb_plts_g(str *s, struct redis_list *list, void *ptr) { +static rtp_payload_type *rbl_cb_plts_g(str *s, struct redis_list *list, void *ptr) { str ptype; struct call_media *med = ptr; if (str_token(&ptype, s, '/')) return NULL; - struct rtp_payload_type *pt = codec_make_payload_type(s, med->type_id); + rtp_payload_type *pt = codec_make_payload_type(s, med->type_id); if (!pt) return NULL; @@ -2627,7 +2627,7 @@ char* redis_encode_json(call_t *c) { json_builder_set_member_name(builder, tmp); json_builder_begin_array(builder); for (__auto_type m = media->codecs.codec_prefs.head; m; m = m->next) { - struct rtp_payload_type *pt = m->data; + rtp_payload_type *pt = m->data; JSON_ADD_STRING("%u/" STR_FORMAT "/%u/" STR_FORMAT "/" STR_FORMAT "/%i/%i", pt->payload_type, STR_FMT(&pt->encoding), pt->clock_rate, STR_FMT(&pt->encoding_parameters), diff --git a/daemon/rtp.c b/daemon/rtp.c index 2525c2791..95cd5b2ee 100644 --- a/daemon/rtp.c +++ b/daemon/rtp.c @@ -311,8 +311,8 @@ error: return -1; } -const struct rtp_payload_type *rtp_payload_type(unsigned int type, struct codec_store *cs) { - const struct rtp_payload_type *rtp_pt; +const rtp_payload_type *get_rtp_payload_type(unsigned int type, struct codec_store *cs) { + const rtp_payload_type *rtp_pt; if (!cs) return rtp_get_rfc_payload_type(type); diff --git a/daemon/sdp.c b/daemon/sdp.c index 14b6d4c86..781df3d6f 100644 --- a/daemon/sdp.c +++ b/daemon/sdp.c @@ -230,7 +230,7 @@ struct attribute_rtpmap { str encoding_str; str clock_rate_str; - struct rtp_payload_type rtp_pt; + rtp_payload_type rtp_pt; }; struct attribute_rtcp_fb { @@ -925,7 +925,7 @@ static int parse_attribute_rtpmap(struct sdp_attribute *output) { PARSE_DECL; char *ep; struct attribute_rtpmap *a; - struct rtp_payload_type *pt; + rtp_payload_type *pt; output->attr = ATTR_RTPMAP; @@ -1466,7 +1466,7 @@ static int __rtp_payload_types(struct stream_params *sp, struct sdp_media *media ht_rtpmap = g_hash_table_new(g_int_hash, g_int_equal); attributes_q *q = attr_list_get_by_id(&media->attributes, ATTR_RTPMAP); for (__auto_type ql = q ? q->head : NULL; ql; ql = ql->next) { - struct rtp_payload_type *pt; + rtp_payload_type *pt; attr = ql->data; pt = &attr->rtpmap.rtp_pt; g_hash_table_insert(ht_rtpmap, &pt->payload_type, pt); @@ -1494,8 +1494,8 @@ static int __rtp_payload_types(struct stream_params *sp, struct sdp_media *media char *ep; str *s; unsigned int i; - struct rtp_payload_type *pt; - const struct rtp_payload_type *ptl, *ptrfc; + rtp_payload_type *pt; + const rtp_payload_type *ptl, *ptrfc; s = ql->data; i = (unsigned int) strtoul(s->s, &ep, 10); @@ -2091,7 +2091,7 @@ static int print_codec_list(GString *s, struct call_media *media) { return 0; // legacy protocol or usage error for (__auto_type l = media->codecs.codec_prefs.head; l; l = l->next) { - struct rtp_payload_type *pt = l->data; + rtp_payload_type *pt = l->data; if (l != media->codecs.codec_prefs.head) g_string_append_c(s, ' '); g_string_append_printf(s, "%u", pt->payload_type); @@ -2115,7 +2115,7 @@ static void insert_codec_parameters(GString *s, struct call_media *cm, { for (__auto_type l = cm->codecs.codec_prefs.head; l; l = l->next) { - struct rtp_payload_type *pt = l->data; + rtp_payload_type *pt = l->data; if (!pt->encoding_with_params.len) continue; diff --git a/daemon/ssrc.c b/daemon/ssrc.c index 337146121..d790b3af5 100644 --- a/daemon/ssrc.c +++ b/daemon/ssrc.c @@ -389,7 +389,7 @@ void ssrc_receiver_report(struct call_media *m, stream_fd *sfd, const struct ssr goto out_nl_put; } - const struct rtp_payload_type *rpt = rtp_payload_type(pt, &m->codecs); + const rtp_payload_type *rpt = get_rtp_payload_type(pt, &m->codecs); if (!rpt) { ilog(LOG_INFO, "Invalid RTP payload type %i, discarding RTCP RR", pt); goto out_nl_put; @@ -639,7 +639,7 @@ void ssrc_collect_metrics(struct call_media *media) { continue; if (e->input_ctx.tracker.most_len > 0 && e->input_ctx.tracker.most[0] != 255) { - const struct rtp_payload_type *rpt = rtp_payload_type(e->input_ctx.tracker.most[0], + const rtp_payload_type *rpt = get_rtp_payload_type(e->input_ctx.tracker.most[0], &ps->media->codecs); if (rpt && rpt->clock_rate) e->jitter = e->jitter * 1000 / rpt->clock_rate; diff --git a/include/audio_player.h b/include/audio_player.h index 7bf2176ec..7a9201911 100644 --- a/include/audio_player.h +++ b/include/audio_player.h @@ -6,6 +6,7 @@ #include #include #include +#include "types.h" /* @@ -18,9 +19,8 @@ struct audio_player; struct call_media; -struct rtp_payload_type; -bool audio_player_setup(struct call_media *, const struct rtp_payload_type *, +bool audio_player_setup(struct call_media *, const rtp_payload_type *, unsigned int size_ms, unsigned int delay_ms); void audio_player_activate(struct call_media *); void audio_player_free(struct call_media *); @@ -28,7 +28,7 @@ void audio_player_free(struct call_media *); void audio_player_start(struct call_media *); void audio_player_stop(struct call_media *); bool audio_player_is_active(struct call_media *); -bool audio_player_pt_match(struct call_media *, const struct rtp_payload_type *); +bool audio_player_pt_match(struct call_media *, const rtp_payload_type *); void audio_player_add_frame(struct audio_player *, uint32_t ssrc, AVFrame *); diff --git a/include/call.h b/include/call.h index c20b87c9e..d4b248c26 100644 --- a/include/call.h +++ b/include/call.h @@ -278,7 +278,6 @@ struct call_monologue; struct ice_agent; struct ssrc_hash; struct codec_handler; -struct rtp_payload_type; struct media_player; struct send_timer; struct transport_protocol; @@ -298,12 +297,12 @@ 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(codecs_ht, void, 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 { - codecs_ht codecs; // int payload type -> struct rtp_payload_type + codecs_ht codecs; // int payload type -> 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 @@ -786,7 +785,7 @@ void __rtp_stats_update(GHashTable *dst, struct codec_store *); int __init_stream(struct packet_stream *ps); void call_stream_crypto_reset(struct packet_stream *ps); -const struct rtp_payload_type *__rtp_stats_codec(struct call_media *m); +const rtp_payload_type *__rtp_stats_codec(struct call_media *m); #include "str.h" #include "rtp.h" diff --git a/include/codec.h b/include/codec.h index 2164efcb6..7d73b88d1 100644 --- a/include/codec.h +++ b/include/codec.h @@ -33,8 +33,8 @@ typedef int codec_handler_func(struct codec_handler *, struct media_packet *); struct codec_handler { - struct rtp_payload_type source_pt; // source_pt.payload_type = hashtable index - struct rtp_payload_type dest_pt; + rtp_payload_type source_pt; // source_pt.payload_type = hashtable index + rtp_payload_type dest_pt; int dtmf_payload_type; int real_dtmf_payload_type; int cn_payload_type; @@ -101,11 +101,11 @@ void mqtt_timer_start(struct mqtt_timer **mqtp, call_t *call, struct call_media struct codec_handler *codec_handler_get(struct call_media *, int payload_type, struct call_media *sink, struct sink_handler *); void codec_handlers_free(struct call_media *); -struct codec_handler *codec_handler_make_playback(const struct rtp_payload_type *src_pt, - const struct rtp_payload_type *dst_pt, unsigned long ts, struct call_media *, uint32_t ssrc); -struct codec_handler *codec_handler_make_media_player(const struct rtp_payload_type *src_pt, - const struct rtp_payload_type *dst_pt, unsigned long ts, struct call_media *, uint32_t ssrc); -struct codec_handler *codec_handler_make_dummy(const struct rtp_payload_type *dst_pt, struct call_media *media); +struct codec_handler *codec_handler_make_playback(const rtp_payload_type *src_pt, + const rtp_payload_type *dst_pt, unsigned long ts, struct call_media *, uint32_t ssrc); +struct codec_handler *codec_handler_make_media_player(const rtp_payload_type *src_pt, + const rtp_payload_type *dst_pt, unsigned long ts, struct call_media *, uint32_t ssrc); +struct codec_handler *codec_handler_make_dummy(const rtp_payload_type *dst_pt, struct call_media *media); void codec_calc_jitter(struct ssrc_ctx *, unsigned long ts, unsigned int clockrate, const struct timeval *); void codec_update_all_handlers(struct call_monologue *ml); void codec_update_all_source_handlers(struct call_monologue *ml, const sdp_ng_flags *flags); @@ -130,7 +130,7 @@ void __codec_store_populate_reuse(struct codec_store *, struct codec_store *, st #define codec_store_populate_reuse(dst, src, ...) \ __codec_store_populate_reuse(dst, src, (struct codec_store_args) {__VA_ARGS__}) __attribute__((nonnull(1, 2))) -void codec_store_add_raw(struct codec_store *cs, struct rtp_payload_type *pt); +void codec_store_add_raw(struct codec_store *cs, rtp_payload_type *pt); __attribute__((nonnull(1, 2))) void codec_store_strip(struct codec_store *, str_q *strip, str_case_ht except); __attribute__((nonnull(1, 2, 3))) @@ -157,16 +157,16 @@ void codec_packet_free(void *); struct codec_packet *codec_packet_dup(struct codec_packet *p); bool codec_packet_copy(struct codec_packet *p); -void payload_type_free(struct rtp_payload_type *p); -void payload_type_destroy(struct rtp_payload_type **p); -struct rtp_payload_type *rtp_payload_type_dup(const struct rtp_payload_type *pt); +void payload_type_free(rtp_payload_type *p); +void payload_type_destroy(rtp_payload_type **p); +rtp_payload_type *rtp_payload_type_dup(const rtp_payload_type *pt); // special return value `(void *) 0x1` to signal type mismatch -struct rtp_payload_type *codec_make_payload_type(const str *codec_str, enum media_type); +rtp_payload_type *codec_make_payload_type(const str *codec_str, enum media_type); // handle string allocation -void codec_init_payload_type(struct rtp_payload_type *, enum media_type); -void payload_type_clear(struct rtp_payload_type *p); +void codec_init_payload_type(rtp_payload_type *, enum media_type); +void payload_type_clear(rtp_payload_type *p); struct chu_args { @@ -180,7 +180,7 @@ struct chu_args { #ifdef WITH_TRANSCODING -void ensure_codec_def(struct rtp_payload_type *pt, struct call_media *media); +void ensure_codec_def(rtp_payload_type *pt, struct call_media *media); void codec_handler_free(struct codec_handler **handler); __attribute__((nonnull(1, 2))) void __codec_handlers_update(struct call_media *receiver, struct call_media *sink, struct chu_args); @@ -230,7 +230,7 @@ INLINE void __codec_handlers_update(struct call_media *receiver, struct call_med INLINE void codec_handler_free(struct codec_handler **handler) { } INLINE void codec_tracker_update(struct codec_store *cs, struct codec_store *ocs) { } INLINE void codec_handlers_stop(codec_handlers_q *q, struct call_media *sink) { } -INLINE void ensure_codec_def(struct rtp_payload_type *pt, struct call_media *media) { } +INLINE void ensure_codec_def(rtp_payload_type *pt, struct call_media *media) { } #endif diff --git a/include/media_player.h b/include/media_player.h index 8e74e4a7c..822726d0c 100644 --- a/include/media_player.h +++ b/include/media_player.h @@ -17,7 +17,6 @@ struct ssrc_ctx; struct packet_stream; struct codec_packet; struct media_player; -struct rtp_payload_type; #ifdef WITH_TRANSCODING @@ -113,11 +112,11 @@ int media_player_play_db(struct media_player *, long long, long long, long long) long long media_player_stop(struct media_player *); bool media_player_is_active(struct call_monologue *); -int media_player_setup(struct media_player *mp, const struct rtp_payload_type *src_pt, - const struct rtp_payload_type *dst_pt); +int media_player_setup(struct media_player *mp, const rtp_payload_type *src_pt, + const rtp_payload_type *dst_pt); void media_player_set_media(struct media_player *mp, struct call_media *media); -bool media_player_pt_match(const struct media_player *mp, const struct rtp_payload_type *src_pt, - const struct rtp_payload_type *dst_pt); +bool media_player_pt_match(const struct media_player *mp, const rtp_payload_type *src_pt, + const rtp_payload_type *dst_pt); void media_player_add_packet(struct media_player *mp, char *buf, size_t len, long long us_dur, unsigned long long pts); diff --git a/include/rtp.h b/include/rtp.h index 90ce76555..62e4a4465 100644 --- a/include/rtp.h +++ b/include/rtp.h @@ -4,6 +4,7 @@ #include "str.h" +#include "types.h" #include @@ -19,7 +20,7 @@ struct codec_store; -const struct rtp_payload_type *rtp_payload_type(unsigned int, struct codec_store *); +const rtp_payload_type *get_rtp_payload_type(unsigned int, struct codec_store *); int rtp_avp2savp(str *, struct crypto_context *, struct ssrc_ctx *); int rtp_savp2avp(str *, struct crypto_context *, struct ssrc_ctx *); diff --git a/include/ssrc.h b/include/ssrc.h index 38dbc7caf..0b28c3a82 100644 --- a/include/ssrc.h +++ b/include/ssrc.h @@ -15,7 +15,6 @@ struct call_media; struct timeval; -struct rtp_payload_type; struct ssrc_entry; struct ssrc_entry_call; enum ssrc_dir; diff --git a/include/t38.h b/include/t38.h index 23008d857..5bdcafbef 100644 --- a/include/t38.h +++ b/include/t38.h @@ -43,6 +43,7 @@ struct t38_options { #include "helpers.h" #include "obj.h" #include "codeclib.h" +#include "types.h" @@ -56,7 +57,7 @@ struct t38_gateway { mutex_t lock; struct call_media *t38_media; struct call_media *pcm_media; - struct rtp_payload_type pcm_pt; // PCM input for spandsp + rtp_payload_type pcm_pt; // PCM input for spandsp t38_gateway_state_t *gw; struct t38_options options; diff --git a/include/types.h b/include/types.h index d277d0a43..cf8ee389b 100644 --- a/include/types.h +++ b/include/types.h @@ -8,6 +8,7 @@ typedef struct stats_metric stats_metric; typedef struct ng_buffer ng_buffer; typedef struct call call_t; typedef struct stream_fd stream_fd; +typedef struct rtp_payload_type rtp_payload_type; #include "containers.h" diff --git a/t/test-transcode.c b/t/test-transcode.c index 65bb40d9d..67d4c2146 100644 --- a/t/test-transcode.c +++ b/t/test-transcode.c @@ -24,7 +24,7 @@ static void queue_dump(GString *s, rtp_pt_q *q) { for (__auto_type l = q->head; l; l = l->next) { if (s->len) g_string_append(s, " "); - struct rtp_payload_type *pt = l->data; + rtp_payload_type *pt = l->data; g_string_append_printf(s, "%i/%s", pt->payload_type, pt->encoding_with_params.s); if (pt->format_parameters.len) g_string_append_printf(s, "/%s", pt->format_parameters.s); @@ -141,7 +141,7 @@ static void codec_set(char *c) { static void __sdp_pt_fmt(int num, str codec, int clockrate, int channels, str full_codec, str full_full, str fmt) { str *fmtdup = str_dup(&fmt); - struct rtp_payload_type pt = (struct rtp_payload_type) { + rtp_payload_type pt = (rtp_payload_type) { .payload_type = num, .encoding_with_params = full_codec, .encoding_with_full_params = full_full,