Asterisk - The Open Source Telephony Project GIT-master-a63eec2
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Macros Modules Pages
rtp_engine.c
Go to the documentation of this file.
1/*
2 * Asterisk -- An open source telephony toolkit.
3 *
4 * Copyright (C) 1999 - 2008, Digium, Inc.
5 *
6 * Joshua Colp <jcolp@digium.com>
7 *
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
13 *
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
17 */
18
19/*! \file
20 *
21 * \brief Pluggable RTP Architecture
22 *
23 * \author Joshua Colp <jcolp@digium.com>
24 */
25
26/*** MODULEINFO
27 <support_level>core</support_level>
28***/
29
30/*** DOCUMENTATION
31 <managerEvent language="en_US" name="RTCPSent">
32 <managerEventInstance class="EVENT_FLAG_REPORTING">
33 <since>
34 <version>12.0.0</version>
35 </since>
36 <synopsis>Raised when an RTCP packet is sent.</synopsis>
37 <syntax>
38 <channel_snapshot/>
39 <parameter name="SSRC">
40 <para>The SSRC identifier for our stream</para>
41 </parameter>
42 <parameter name="PT">
43 <para>The type of packet for this RTCP report.</para>
44 <enumlist>
45 <enum name="200(SR)"/>
46 <enum name="201(RR)"/>
47 </enumlist>
48 </parameter>
49 <parameter name="To">
50 <para>The address the report is sent to.</para>
51 </parameter>
52 <parameter name="ReportCount">
53 <para>The number of reports that were sent.</para>
54 <para>The report count determines the number of ReportX headers in
55 the message. The X for each set of report headers will range from 0 to
56 <literal>ReportCount - 1</literal>.</para>
57 </parameter>
58 <parameter name="SentNTP" required="false">
59 <para>The time the sender generated the report. Only valid when
60 PT is <literal>200(SR)</literal>.</para>
61 </parameter>
62 <parameter name="SentRTP" required="false">
63 <para>The sender's last RTP timestamp. Only valid when PT is
64 <literal>200(SR)</literal>.</para>
65 </parameter>
66 <parameter name="SentPackets" required="false">
67 <para>The number of packets the sender has sent. Only valid when PT
68 is <literal>200(SR)</literal>.</para>
69 </parameter>
70 <parameter name="SentOctets" required="false">
71 <para>The number of bytes the sender has sent. Only valid when PT is
72 <literal>200(SR)</literal>.</para>
73 </parameter>
74 <parameter name="ReportXSourceSSRC">
75 <para>The SSRC for the source of this report block.</para>
76 </parameter>
77 <parameter name="ReportXFractionLost">
78 <para>The fraction of RTP data packets from <literal>ReportXSourceSSRC</literal>
79 lost since the previous SR or RR report was sent.</para>
80 </parameter>
81 <parameter name="ReportXCumulativeLost">
82 <para>The total number of RTP data packets from <literal>ReportXSourceSSRC</literal>
83 lost since the beginning of reception.</para>
84 </parameter>
85 <parameter name="ReportXHighestSequence">
86 <para>The highest sequence number received in an RTP data packet from
87 <literal>ReportXSourceSSRC</literal>.</para>
88 </parameter>
89 <parameter name="ReportXSequenceNumberCycles">
90 <para>The number of sequence number cycles seen for the RTP data
91 received from <literal>ReportXSourceSSRC</literal>.</para>
92 </parameter>
93 <parameter name="ReportXIAJitter">
94 <para>An estimate of the statistical variance of the RTP data packet
95 interarrival time, measured in timestamp units.</para>
96 </parameter>
97 <parameter name="ReportXLSR">
98 <para>The last SR timestamp received from <literal>ReportXSourceSSRC</literal>.
99 If no SR has been received from <literal>ReportXSourceSSRC</literal>,
100 then 0.</para>
101 </parameter>
102 <parameter name="ReportXDLSR">
103 <para>The delay, expressed in units of 1/65536 seconds, between
104 receiving the last SR packet from <literal>ReportXSourceSSRC</literal>
105 and sending this report.</para>
106 </parameter>
107 </syntax>
108 <see-also>
109 <ref type="managerEvent">RTCPReceived</ref>
110 </see-also>
111 </managerEventInstance>
112 </managerEvent>
113 <managerEvent language="en_US" name="RTCPReceived">
114 <managerEventInstance class="EVENT_FLAG_REPORTING">
115 <since>
116 <version>12.0.0</version>
117 </since>
118 <synopsis>Raised when an RTCP packet is received.</synopsis>
119 <syntax>
120 <channel_snapshot/>
121 <parameter name="SSRC">
122 <para>The SSRC identifier for the remote system</para>
123 </parameter>
124 <xi:include xpointer="xpointer(/docs/managerEvent[@name='RTCPSent']/managerEventInstance/syntax/parameter[@name='PT'])" />
125 <parameter name="From">
126 <para>The address the report was received from.</para>
127 </parameter>
128 <parameter name="RTT">
129 <para>Calculated Round-Trip Time in seconds</para>
130 </parameter>
131 <parameter name="ReportCount">
132 <para>The number of reports that were received.</para>
133 <para>The report count determines the number of ReportX headers in
134 the message. The X for each set of report headers will range from 0 to
135 <literal>ReportCount - 1</literal>.</para>
136 </parameter>
137 <xi:include xpointer="xpointer(/docs/managerEvent[@name='RTCPSent']/managerEventInstance/syntax/parameter[@name='SentNTP'])" />
138 <xi:include xpointer="xpointer(/docs/managerEvent[@name='RTCPSent']/managerEventInstance/syntax/parameter[@name='SentRTP'])" />
139 <xi:include xpointer="xpointer(/docs/managerEvent[@name='RTCPSent']/managerEventInstance/syntax/parameter[@name='SentPackets'])" />
140 <xi:include xpointer="xpointer(/docs/managerEvent[@name='RTCPSent']/managerEventInstance/syntax/parameter[@name='SentOctets'])" />
141 <xi:include xpointer="xpointer(/docs/managerEvent[@name='RTCPSent']/managerEventInstance/syntax/parameter[contains(@name, 'ReportX')])" />
142 </syntax>
143 <see-also>
144 <ref type="managerEvent">RTCPSent</ref>
145 </see-also>
146 </managerEventInstance>
147 </managerEvent>
148 ***/
149
150#include "asterisk.h"
151
152#include <sched.h> /* for sched_yield */
153#include <sys/time.h> /* for timeval */
154#include <time.h> /* for time_t */
155
156#include "asterisk/_private.h" /* for ast_rtp_engine_init prototype */
157#include "asterisk/astobj2.h" /* for ao2_cleanup, ao2_ref, etc */
158#include "asterisk/channel.h" /* for ast_channel_name, etc */
159#include "asterisk/codec.h" /* for ast_codec_media_type2str, etc */
160#include "asterisk/format.h" /* for ast_format_cmp, etc */
161#include "asterisk/format_cache.h" /* for ast_format_adpcm, etc */
162#include "asterisk/format_cap.h" /* for ast_format_cap_alloc, etc */
163#include "asterisk/json.h" /* for ast_json_ref, etc */
164#include "asterisk/linkedlists.h" /* for ast_rtp_engine::<anonymous>, etc */
165#include "asterisk/lock.h" /* for ast_rwlock_unlock, etc */
166#include "asterisk/logger.h" /* for ast_log, ast_debug, etc */
167#include "asterisk/manager.h"
168#include "asterisk/module.h" /* for ast_module_unref, etc */
169#include "asterisk/netsock2.h" /* for ast_sockaddr_copy, etc */
170#include "asterisk/options.h" /* for ast_option_rtpptdynamic */
171#include "asterisk/pbx.h" /* for pbx_builtin_setvar_helper */
172#include "asterisk/res_srtp.h" /* for ast_srtp_res */
173#include "asterisk/rtp_engine.h" /* for ast_rtp_codecs, etc */
174#include "asterisk/stasis.h" /* for stasis_message_data, etc */
175#include "asterisk/stasis_channels.h" /* for ast_channel_stage_snapshot, etc */
176#include "asterisk/strings.h" /* for ast_str_append, etc */
177#include "asterisk/time.h" /* for ast_tvdiff_ms, ast_tvnow */
178#include "asterisk/translate.h" /* for ast_translate_available_formats */
179#include "asterisk/utils.h" /* for ast_free, ast_strdup, etc */
180#include "asterisk/vector.h" /* for AST_VECTOR_GET, etc */
181
184
185/*! Structure that contains extmap negotiation information */
187 /*! The RTP extension */
189 /*! The current negotiated direction */
191};
192
193/*! Structure that represents an RTP session (instance) */
195 /*! Engine that is handling this RTP instance */
197 /*! Data unique to the RTP engine */
198 void *data;
199 /*! RTP properties that have been set and their value */
201 /*! Address that we are expecting RTP to come in to */
203 /*! The original source address */
205 /*! Address that we are sending RTP to */
207 /*! Instance that we are bridged to if doing remote or local bridging */
209 /*! Payload and packetization information */
211 /*! RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
213 /*! RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
215 /*! RTP keepalive interval */
217 /*! Glue currently in use */
219 /*! SRTP info associated with the instance */
220 struct ast_srtp *srtp;
221 /*! SRTP info dedicated for RTCP associated with the instance */
223 /*! Channel unique ID */
225 /*! Time of last packet sent */
226 time_t last_tx;
227 /*! Time of last packet received */
228 time_t last_rx;
229 /*! Enabled RTP extensions */
231 /*! Negotiated RTP extensions (using index based on extension) */
233 /*! Negotiated RTP extensions (using index based on unique id) */
235};
236
237/*!
238 * \brief URIs for known RTP extensions
239 */
240static const char * const rtp_extension_uris[AST_RTP_EXTENSION_MAX] = {
242 [AST_RTP_EXTENSION_ABS_SEND_TIME] = "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time",
243 [AST_RTP_EXTENSION_TRANSPORT_WIDE_CC] = "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01",
244};
245
246/*! List of RTP engines that are currently registered */
248
249/*! List of RTP glues */
251
252#define MAX_RTP_MIME_TYPES 128
253
254/*! The following array defines the MIME Media type (and subtype) for each
255 of our codecs, or RTP-specific data type. */
256static struct ast_rtp_mime_type {
257 /*! \brief A mapping object between the Asterisk codec and this RTP payload */
259 /*! \brief The media type */
260 char type[16];
261 /*! \brief The format type */
262 char subtype[64];
263 /*! \brief Expected sample rate of the /c subtype */
264 unsigned int sample_rate;
265} ast_rtp_mime_types[128]; /* This will Likely not need to grow any time soon. */
267static int mime_types_len = 0;
268
269/*!
270 * \brief Mapping between Asterisk codecs and rtp payload types
271 *
272 * Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
273 * also, our own choices for dynamic payload types. This is our master
274 * table for transmission
275 *
276 * See http://www.iana.org/assignments/rtp-parameters for a list of
277 * assigned values
278 */
281
282/*! \brief \ref stasis topic for RTP related messages */
283static struct stasis_topic *rtp_topic;
284
285
286/*!
287 * \brief Set given json object into target with name
288 *
289 * \param target Target json.
290 * \param name key of given object.
291 * \param obj Json value will be set.
292 */
293#define SET_AST_JSON_OBJ(target, name, obj) ({ \
294 struct ast_json *j_tmp = obj; \
295 if (j_tmp) { \
296 ast_json_object_set(target, name, j_tmp); \
297 } \
298})
299
300/*!
301 * \internal
302 * \brief Destructor for \c ast_rtp_payload_type
303 */
304static void rtp_payload_type_dtor(void *obj)
305{
306 struct ast_rtp_payload_type *payload = obj;
307
308 ao2_cleanup(payload->format);
309}
310
312 int payload, int rtp_code, int primary_mapping, unsigned int sample_rate)
313{
316
317 if (!type) {
318 return NULL;
319 }
320
321 type->format = ao2_bump(format);
322 type->asterisk_format = type->format != NULL;
323 type->payload = payload;
324 type->rtp_code = rtp_code;
325 type->primary_mapping = primary_mapping;
326 type->sample_rate = sample_rate;
327
328 return type;
329}
330
335
336int ast_rtp_engine_register2(struct ast_rtp_engine *engine, struct ast_module *module)
337{
338 struct ast_rtp_engine *current_engine;
339
340 /* Perform a sanity check on the engine structure to make sure it has the basics */
341 if (ast_strlen_zero(engine->name) || !engine->new || !engine->destroy || !engine->write || !engine->read) {
342 ast_log(LOG_WARNING, "RTP Engine '%s' failed sanity check so it was not registered.\n", !ast_strlen_zero(engine->name) ? engine->name : "Unknown");
343 return -1;
344 }
345
346 /* Link owner module to the RTP engine for reference counting purposes */
347 engine->mod = module;
348
350
351 /* Ensure that no two modules with the same name are registered at the same time */
352 AST_RWLIST_TRAVERSE(&engines, current_engine, entry) {
353 if (!strcmp(current_engine->name, engine->name)) {
354 ast_log(LOG_WARNING, "An RTP engine with the name '%s' has already been registered.\n", engine->name);
356 return -1;
357 }
358 }
359
360 /* The engine survived our critique. Off to the list it goes to be used */
362
364
365 ast_verb(5, "Registered RTP engine '%s'\n", engine->name);
366
367 return 0;
368}
369
371{
372 struct ast_rtp_engine *current_engine = NULL;
373
375
376 if ((current_engine = AST_RWLIST_REMOVE(&engines, engine, entry))) {
377 ast_verb(5, "Unregistered RTP engine '%s'\n", engine->name);
378 }
379
381
382 return current_engine ? 0 : -1;
383}
384
385int ast_rtp_glue_register2(struct ast_rtp_glue *glue, struct ast_module *module)
386{
387 struct ast_rtp_glue *current_glue = NULL;
388
389 if (ast_strlen_zero(glue->type)) {
390 return -1;
391 }
392
393 glue->mod = module;
394
396
397 AST_RWLIST_TRAVERSE(&glues, current_glue, entry) {
398 if (!strcasecmp(current_glue->type, glue->type)) {
399 ast_log(LOG_WARNING, "RTP glue with the name '%s' has already been registered.\n", glue->type);
401 return -1;
402 }
403 }
404
406
408
409 ast_verb(5, "Registered RTP glue '%s'\n", glue->type);
410
411 return 0;
412}
413
415{
416 struct ast_rtp_glue *current_glue = NULL;
417
419
420 if ((current_glue = AST_RWLIST_REMOVE(&glues, glue, entry))) {
421 ast_verb(5, "Unregistered RTP glue '%s'\n", glue->type);
422 }
423
425
426 return current_glue ? 0 : -1;
427}
428
429static void instance_destructor(void *obj)
430{
431 struct ast_rtp_instance *instance = obj;
432
433 /* Pass us off to the engine to destroy */
434 if (instance->data) {
435 /*
436 * Lock in case the RTP engine has other threads that
437 * need synchronization with the destruction.
438 */
439 ao2_lock(instance);
440 instance->engine->destroy(instance);
441 ao2_unlock(instance);
442 }
443
444 if (instance->srtp) {
445 res_srtp->destroy(instance->srtp);
446 }
447
448 if (instance->rtcp_srtp) {
449 res_srtp->destroy(instance->rtcp_srtp);
450 }
451
453
457
458 /* Drop our engine reference */
459 ast_module_unref(instance->engine->mod);
460
461 ast_debug(1, "Destroyed RTP instance '%p'\n", instance);
462}
463
465{
466 if (!instance) {
467 return 0;
468 }
470 char buffer[4][512];
471 ast_debug_rtp(1, "%s:\n"
472 " RTT: %s\n"
473 " Loss: %s\n"
474 " Jitter: %s\n"
475 " MES: %s\n",
476 instance->channel_uniqueid,
478 buffer[0], sizeof(buffer[0])),
480 buffer[1], sizeof(buffer[1])),
482 buffer[2], sizeof(buffer[2])),
484 buffer[3], sizeof(buffer[3]))
485 );
486 }
487
488 ao2_cleanup(instance);
489
490 return 0;
491}
492
493struct ast_rtp_instance *ast_rtp_instance_new(const char *engine_name,
494 struct ast_sched_context *sched, const struct ast_sockaddr *sa,
495 void *data)
496{
497 struct ast_sockaddr address = {{0,}};
498 struct ast_rtp_instance *instance = NULL;
499 struct ast_rtp_engine *engine = NULL;
500 struct ast_module *mod_ref;
501
503
504 /* If an engine name was specified try to use it or otherwise use the first one registered */
505 if (!ast_strlen_zero(engine_name)) {
507 if (!strcmp(engine->name, engine_name)) {
508 break;
509 }
510 }
511 } else {
512 engine = AST_RWLIST_FIRST(&engines);
513 }
514
515 /* If no engine was actually found bail out now */
516 if (!engine) {
517 ast_log(LOG_ERROR, "No RTP engine was found. Do you have one loaded?\n");
519 return NULL;
520 }
521
522 /* Bump up the reference count before we return so the module can not be unloaded */
523 mod_ref = ast_module_running_ref(engine->mod);
524
526
527 if (!mod_ref) {
528 /* BUGBUG: improve handling of this situation. */
529 return NULL;
530 }
531
532 /* Allocate a new RTP instance */
533 if (!(instance = ao2_alloc(sizeof(*instance), instance_destructor))) {
534 ast_module_unref(engine->mod);
535 return NULL;
536 }
537 instance->engine = engine;
538 ast_sockaddr_copy(&instance->local_address, sa);
540
542 ao2_ref(instance, -1);
543 return NULL;
544 }
545
546 /* Initialize RTP extension support */
547 if (AST_VECTOR_INIT(&instance->extmap_enabled, 0) ||
548 AST_VECTOR_INIT(&instance->extmap_negotiated, 0) ||
549 AST_VECTOR_INIT(&instance->extmap_unique_ids, 0)) {
550 ao2_ref(instance, -1);
551 return NULL;
552 }
553
554 ast_debug(1, "Using engine '%s' for RTP instance '%p'\n", engine->name, instance);
555
556 /*
557 * And pass it off to the engine to setup
558 *
559 * Lock in case the RTP engine has other threads that
560 * need synchronization with the construction.
561 */
562 ao2_lock(instance);
563 if (instance->engine->new(instance, sched, &address, data)) {
564 ast_debug(1, "Engine '%s' failed to setup RTP instance '%p'\n", engine->name, instance);
565 ao2_unlock(instance);
566 ao2_ref(instance, -1);
567 return NULL;
568 }
569 ao2_unlock(instance);
570
571 ast_debug(1, "RTP instance '%p' is setup and ready to go\n", instance);
572
573 return instance;
574}
575
577{
578 return instance->channel_uniqueid;
579}
580
581void ast_rtp_instance_set_channel_id(struct ast_rtp_instance *instance, const char *uniqueid)
582{
583 ast_copy_string(instance->channel_uniqueid, uniqueid, sizeof(instance->channel_uniqueid));
584}
585
586void ast_rtp_instance_set_data(struct ast_rtp_instance *instance, void *data)
587{
588 instance->data = data;
589}
590
592{
593 return instance->data;
594}
595
596int ast_rtp_instance_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
597{
598 int res;
599
600 ao2_lock(instance);
601 res = instance->engine->write(instance, frame);
602 ao2_unlock(instance);
603 return res;
604}
605
606struct ast_frame *ast_rtp_instance_read(struct ast_rtp_instance *instance, int rtcp)
607{
608 struct ast_frame *frame;
609
610 ao2_lock(instance);
611 frame = instance->engine->read(instance, rtcp);
612 ao2_unlock(instance);
613 return frame;
614}
615
617 const struct ast_sockaddr *address)
618{
619 ao2_lock(instance);
621 ao2_unlock(instance);
622 return 0;
623}
624
626 const struct ast_sockaddr *address)
627{
629 if (instance->engine->remote_address_set) {
630 instance->engine->remote_address_set(instance, &instance->incoming_source_address);
631 }
632}
633
635 const struct ast_sockaddr *address)
636{
637 ao2_lock(instance);
639 ao2_unlock(instance);
640
641 return 0;
642}
643
645 const struct ast_sockaddr *address)
646{
647 ao2_lock(instance);
648
651
652 ao2_unlock(instance);
653
654 return 0;
655}
656
658 struct ast_sockaddr *address)
659{
660 ao2_lock(instance);
661 if (ast_sockaddr_cmp(address, &instance->local_address) != 0) {
663 ao2_unlock(instance);
664 return 1;
665 }
666 ao2_unlock(instance);
667
668 return 0;
669}
670
672 struct ast_sockaddr *address)
673{
674 ao2_lock(instance);
676 ao2_unlock(instance);
677}
678
680 struct ast_sockaddr *address)
681{
682 ao2_lock(instance);
683 if (ast_sockaddr_cmp(address, &instance->requested_target_address) != 0) {
685 ao2_unlock(instance);
686 return 1;
687 }
688 ao2_unlock(instance);
689
690 return 0;
691}
692
694 struct ast_sockaddr *address)
695{
696 ao2_lock(instance);
698 ao2_unlock(instance);
699}
700
702 struct ast_sockaddr *address)
703{
704 ao2_lock(instance);
706 ao2_unlock(instance);
707}
708
709void ast_rtp_instance_set_extended_prop(struct ast_rtp_instance *instance, int property, void *value)
710{
711 if (instance->engine->extended_prop_set) {
712 ao2_lock(instance);
713 instance->engine->extended_prop_set(instance, property, value);
714 ao2_unlock(instance);
715 }
716}
717
718void *ast_rtp_instance_get_extended_prop(struct ast_rtp_instance *instance, int property)
719{
720 void *prop;
721
722 if (instance->engine->extended_prop_get) {
723 ao2_lock(instance);
724 prop = instance->engine->extended_prop_get(instance, property);
725 ao2_unlock(instance);
726 } else {
727 prop = NULL;
728 }
729
730 return prop;
731}
732
733void ast_rtp_instance_set_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
734{
735 ao2_lock(instance);
736 instance->properties[property] = value;
737
738 if (instance->engine->prop_set) {
739 instance->engine->prop_set(instance, property, value);
740 }
741 ao2_unlock(instance);
742}
743
745{
746 int prop;
747
748 ao2_lock(instance);
749 prop = instance->properties[property];
750 ao2_unlock(instance);
751
752 return prop;
753}
754
756{
757 return &instance->codecs;
758}
759
762{
763 struct rtp_extmap extmap = {
765 .direction = direction,
766 };
767
768 ao2_lock(instance);
769
770 if (!instance->engine->extension_enable || !instance->engine->extension_enable(instance, extension)) {
771 ao2_unlock(instance);
772 return 0;
773 }
774
775 /* We store enabled extensions separately so we can easily do negotiation */
777 ao2_unlock(instance);
778 return -1;
779 }
780
781 if (id <= 0) {
782 /* We find a free unique identifier for this extension by just appending it to the
783 * vector of unique ids. The size of the vector will become its unique identifier.
784 * As well when we are asking for information on the extensions it will be returned,
785 * allowing it to be added to the SDP offer.
786 */
787 if (AST_VECTOR_APPEND(&instance->extmap_unique_ids, extmap)) {
789 ao2_unlock(instance);
790 return -1;
791 }
792 id = AST_VECTOR_SIZE(&instance->extmap_unique_ids);
793 } else {
794 /* Otherwise we put it precisely where they want it */
795 if (AST_VECTOR_REPLACE(&instance->extmap_unique_ids, id - 1, extmap)) {
797 ao2_unlock(instance);
798 return -1;
799 }
800 }
801
802 /* Now that we have an id add the extension to here */
803 if (AST_VECTOR_REPLACE(&instance->extmap_negotiated, extension, id)) {
807 AST_VECTOR_REPLACE(&instance->extmap_unique_ids, id - 1, extmap);
808 ao2_unlock(instance);
809 return -1;
810 }
811
812 ao2_unlock(instance);
813
814 return 0;
815}
816
817/*! \brief Helper function which negotiates two RTP extension directions to get our current direction */
819 enum ast_rtp_extension_direction theirs)
820{
822 /* This should not occur but if it does tolerate either side not having this extension
823 * in use.
824 */
826 } else if (theirs == AST_RTP_EXTENSION_DIRECTION_INACTIVE) {
827 /* Inactive is always inactive on our side */
829 } else if (theirs == AST_RTP_EXTENSION_DIRECTION_SENDRECV) {
830 return ours;
831 } else if (theirs == AST_RTP_EXTENSION_DIRECTION_SENDONLY) {
832 /* If they are send only then we become recvonly if we are configured as sendrecv or recvonly */
835 }
836 } else if (theirs == AST_RTP_EXTENSION_DIRECTION_RECVONLY) {
837 /* If they are recv only then we become sendonly if we are configured as sendrecv or sendonly */
840 }
841 }
842
844}
845
847 const char *uri, const char *attributes)
848{
849 /* 'attributes' is currently unused but exists in the API to ensure it does not need to be altered
850 * in the future in case we need to use it.
851 */
852 int idx;
854
855 /* Per the RFC the identifier has to be 1 or above */
856 if (id < 1) {
857 return -1;
858 }
859
860 /* Convert the provided URI to the internal representation */
861 for (idx = 0; idx < ARRAY_LEN(rtp_extension_uris); ++idx) {
862 if (!strcasecmp(rtp_extension_uris[idx], uri)) {
863 extension = idx;
864 break;
865 }
866 }
867
868 ao2_lock(instance);
869 /* We only accept the extension if it is enabled */
870 if (extension < AST_VECTOR_SIZE(&instance->extmap_enabled) &&
872 struct rtp_extmap extmap = {
875 };
876
877 /* If the direction negotiation failed then don't accept or use this extension */
881 }
882 AST_VECTOR_REPLACE(&instance->extmap_unique_ids, id - 1, extmap);
883 }
884 }
885 ao2_unlock(instance);
886
887 return 0;
888}
889
891{
892 static const struct rtp_extmap extmap_none = {
895 };
896 int idx;
897
898 ao2_lock(instance);
899
900 /* Clear both the known unique ids and the negotiated extensions as we are about to have
901 * new results set on us.
902 */
903 for (idx = 0; idx < AST_VECTOR_SIZE(&instance->extmap_unique_ids); ++idx) {
904 AST_VECTOR_REPLACE(&instance->extmap_unique_ids, idx, extmap_none);
905 }
906
907 for (idx = 0; idx < AST_VECTOR_SIZE(&instance->extmap_negotiated); ++idx) {
908 AST_VECTOR_REPLACE(&instance->extmap_negotiated, idx, -1);
909 }
910
911 ao2_unlock(instance);
912}
913
915{
916 int id = -1;
917
918 ao2_lock(instance);
919 if (extension < AST_VECTOR_SIZE(&instance->extmap_negotiated)) {
921 }
922 ao2_unlock(instance);
923
924 return id;
925}
926
928{
929 size_t count;
930
931 ao2_lock(instance);
932 count = AST_VECTOR_SIZE(&instance->extmap_unique_ids);
933 ao2_unlock(instance);
934
935 return count;
936}
937
939{
941
942 ao2_lock(instance);
943
944 /* The local unique identifier starts at '1' so the highest unique identifier
945 * can be the actual size of the vector. We compensate (as it is 0 index based)
946 * by dropping it down to 1 to get the correct information.
947 */
948 if (0 < id && id <= AST_VECTOR_SIZE(&instance->extmap_unique_ids)) {
949 struct rtp_extmap *extmap = AST_VECTOR_GET_ADDR(&instance->extmap_unique_ids, id - 1);
950
951 extension = extmap->extension;
952 }
953 ao2_unlock(instance);
954
955 return extension;
956}
957
959{
961
962 ao2_lock(instance);
963
964 if (0 < id && id <= AST_VECTOR_SIZE(&instance->extmap_unique_ids)) {
965 struct rtp_extmap *extmap = AST_VECTOR_GET_ADDR(&instance->extmap_unique_ids, id - 1);
966
967 direction = extmap->direction;
968 }
969 ao2_unlock(instance);
970
971 return direction;
972}
973
974const char *ast_rtp_instance_extmap_get_uri(struct ast_rtp_instance *instance, int id)
975{
977
979 (unsigned int)extension >= ARRAY_LEN(rtp_extension_uris)) {
980 return NULL;
981 }
982
984}
985
987{
988 int res;
989
990 codecs->framing = 0;
991 ast_rwlock_init(&codecs->codecs_lock);
992 res = AST_VECTOR_INIT(&codecs->payload_mapping_rx, AST_RTP_MAX_PT);
993 res |= AST_VECTOR_INIT(&codecs->payload_mapping_tx, AST_RTP_MAX_PT);
994 if (res) {
995 AST_VECTOR_FREE(&codecs->payload_mapping_rx);
996 AST_VECTOR_FREE(&codecs->payload_mapping_tx);
997 }
998
999 return res;
1000}
1001
1003{
1004 int idx;
1005 struct ast_rtp_payload_type *type;
1006
1007 for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
1008 type = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
1009 ao2_t_cleanup(type, "destroying ast_rtp_codec rx mapping");
1010 }
1011 AST_VECTOR_FREE(&codecs->payload_mapping_rx);
1012
1013 for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
1014 type = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
1015 ao2_t_cleanup(type, "destroying ast_rtp_codec tx mapping");
1016 }
1017 AST_VECTOR_FREE(&codecs->payload_mapping_tx);
1018
1019 ao2_t_cleanup(codecs->preferred_format, "destroying ast_rtp_codec preferred format");
1020 codecs->preferred_format = NULL;
1021
1022 ast_rwlock_destroy(&codecs->codecs_lock);
1023}
1024
1026{
1029
1030 if (instance && instance->engine && instance->engine->payload_set) {
1031 int i;
1032
1033 ao2_lock(instance);
1034 for (i = 0; i < AST_RTP_MAX_PT; i++) {
1035 instance->engine->payload_set(instance, i, 0, NULL, 0);
1036 }
1037 ao2_unlock(instance);
1038 }
1039}
1040
1041/*!
1042 * \internal
1043 * \brief Clear the rx primary mapping flag on all other matching mappings.
1044 * \since 14.0.0
1045 *
1046 * \param codecs Codecs that need rx clearing.
1047 * \param to_match Payload type object to compare against.
1048 *
1049 * \note It is assumed that codecs is write locked before calling.
1050 */
1052{
1053 int idx;
1055 struct ast_rtp_payload_type *new_type;
1056 struct timeval now;
1057
1058 if (!to_match->primary_mapping) {
1059 return;
1060 }
1061
1062 now = ast_tvnow();
1063 for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
1064 current = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
1065
1066 if (!current || current == to_match || !current->primary_mapping) {
1067 continue;
1068 }
1069 if (current->asterisk_format && to_match->asterisk_format) {
1070 if (ast_format_cmp(current->format, to_match->format) == AST_FORMAT_CMP_NOT_EQUAL) {
1071 continue;
1072 }
1073 } else if (!current->asterisk_format && !to_match->asterisk_format) {
1074 if (current->rtp_code != to_match->rtp_code) {
1075 continue;
1076 }
1077 } else {
1078 continue;
1079 }
1080
1081 /* Replace current with non-primary marked version */
1083 if (!new_type) {
1084 continue;
1085 }
1086 *new_type = *current;
1087 new_type->primary_mapping = 0;
1088 new_type->when_retired = now;
1089 ao2_bump(new_type->format);
1090 AST_VECTOR_REPLACE(&codecs->payload_mapping_rx, idx, new_type);
1091 ao2_ref(current, -1);
1092 }
1093}
1094
1095/*!
1096 * \internal
1097 * \brief Put the new_type into the rx payload type mapping.
1098 * \since 21.0.0
1099 *
1100 * \param codecs Codecs structure to put new_type into
1101 * \param payload type position to replace.
1102 * \param new_type RTP payload mapping object to store.
1103 * \param replace Clear the primary flag
1104 *
1105 * \note It is assumed that codecs is write locked before calling.
1106 */
1107static void rtp_codecs_payload_set_rx(struct ast_rtp_codecs *codecs, int payload, struct ast_rtp_payload_type *new_type, int replace)
1108{
1109 ao2_ref(new_type, +1);
1110 if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_rx)) {
1111 ao2_t_cleanup(AST_VECTOR_GET(&codecs->payload_mapping_rx, payload),
1112 "cleaning up rx mapping vector element about to be replaced");
1113 }
1114 if (AST_VECTOR_REPLACE(&codecs->payload_mapping_rx, payload, new_type)) {
1115 ao2_ref(new_type, -1);
1116 return;
1117 }
1118
1119 if (replace) {
1121 }
1122}
1123
1124/*!
1125 * \internal
1126 * \brief Put the new_type into the rx payload type mapping.
1127 * \since 14.0.0
1128 *
1129 * \param codecs Codecs structure to put new_type into
1130 * \param payload type position to replace.
1131 * \param new_type RTP payload mapping object to store.
1132 *
1133 * \note It is assumed that codecs is write locked before calling.
1134 */
1135static void rtp_codecs_payload_replace_rx(struct ast_rtp_codecs *codecs, int payload, struct ast_rtp_payload_type *new_type) {
1136 rtp_codecs_payload_set_rx(codecs, payload, new_type, 1);
1137}
1138
1139
1140/*!
1141 * \internal
1142 * \brief Copy the rx payload type mapping to the destination.
1143 * \since 14.0.0
1144 *
1145 * \param src The source codecs structure
1146 * \param dest The destination codecs structure that the values from src will be copied to
1147 * \param instance Optionally the instance that the dst codecs structure belongs to
1148 *
1149 * \note It is assumed that src is at least read locked before calling.
1150 * \note It is assumed that dest is write locked before calling.
1151 */
1152static void rtp_codecs_payloads_copy_rx(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
1153{
1154 int idx;
1155 struct ast_rtp_payload_type *type;
1156
1157 for (idx = 0; idx < AST_VECTOR_SIZE(&src->payload_mapping_rx); ++idx) {
1159 if (!type) {
1160 continue;
1161 }
1162
1163 ast_debug(2, "Copying rx payload mapping %d (%p) from %p to %p\n",
1164 idx, type, src, dest);
1166
1167 if (instance && instance->engine && instance->engine->payload_set) {
1168 ao2_lock(instance);
1169 instance->engine->payload_set(instance, idx, type->asterisk_format, type->format, type->rtp_code);
1170 ao2_unlock(instance);
1171 }
1172 }
1173}
1174
1175/*!
1176 * \internal
1177 * \brief Determine if a type of payload is already present in mappings.
1178 * \since 14.0.0
1179 *
1180 * \param codecs Codecs to be checked for mappings.
1181 * \param to_match Payload type object to compare against.
1182 *
1183 * \note It is assumed that codecs is write locked before calling.
1184 *
1185 * \retval 0 not found
1186 * \retval 1 found
1187 */
1188static int payload_mapping_tx_is_present(const struct ast_rtp_codecs *codecs, const struct ast_rtp_payload_type *to_match)
1189{
1190 int idx;
1192
1193 for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
1194 current = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
1195
1196 if (!current) {
1197 continue;
1198 }
1199 if (current == to_match) {
1200 /* The exact object is already in the mapping. */
1201 return 1;
1202 }
1203 if (current->asterisk_format && to_match->asterisk_format) {
1205 continue;
1206 } else if (current->payload == to_match->payload) {
1207 return 0;
1208 }
1209 } else if (!current->asterisk_format && !to_match->asterisk_format) {
1210 if (current->rtp_code != to_match->rtp_code) {
1211 continue;
1212 } else if (to_match->rtp_code == AST_RTP_DTMF && current->sample_rate != to_match->sample_rate) {
1213 /* it is possible for multiple DTMF types to exist with different sample rates */
1214 continue;
1215 }
1216 } else {
1217 continue;
1218 }
1219
1220 return 1;
1221 }
1222
1223 return 0;
1224}
1225
1227 int ret = 0;
1228 if (codecs && to_match) {
1229 ast_rwlock_rdlock(&codecs->codecs_lock);
1230 ret = payload_mapping_tx_is_present(codecs, to_match);
1231 ast_rwlock_unlock(&codecs->codecs_lock);
1232 }
1233 return ret;
1234}
1235
1236/*!
1237 * \internal
1238 * \brief Copy the tx payload type mapping to the destination.
1239 * \since 14.0.0
1240 *
1241 * \param src The source codecs structure
1242 * \param dest The destination codecs structure that the values from src will be copied to
1243 * \param instance Optionally the instance that the dst codecs structure belongs to
1244 *
1245 * \note It is assumed that src is at least read locked before calling.
1246 * \note It is assumed that dest is write locked before calling.
1247 */
1248static void rtp_codecs_payloads_copy_tx(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
1249{
1250 int idx;
1251 struct ast_rtp_payload_type *type;
1252
1253 for (idx = 0; idx < AST_VECTOR_SIZE(&src->payload_mapping_tx); ++idx) {
1255 if (!type) {
1256 continue;
1257 }
1258
1259 ast_debug(2, "Copying tx payload mapping %d (%p) from %p to %p\n",
1260 idx, type, src, dest);
1261 ao2_ref(type, +1);
1262 if (idx < AST_VECTOR_SIZE(&dest->payload_mapping_tx)) {
1264 "cleaning up tx mapping vector element about to be replaced");
1265 }
1266 if (AST_VECTOR_REPLACE(&dest->payload_mapping_tx, idx, type)) {
1267 ao2_ref(type, -1);
1268 continue;
1269 }
1270
1271 if (instance && instance->engine && instance->engine->payload_set) {
1272 ao2_lock(instance);
1273 instance->engine->payload_set(instance, idx, type->asterisk_format, type->format, type->rtp_code);
1274 ao2_unlock(instance);
1275 }
1276 }
1277}
1278
1279void ast_rtp_codecs_payloads_copy(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
1280{
1281 int idx;
1282 struct ast_rtp_payload_type *type;
1283
1285
1286 /* Deadlock avoidance because of held write lock. */
1287 while (ast_rwlock_tryrdlock(&src->codecs_lock)) {
1289 sched_yield();
1291 }
1292
1293 /*
1294 * This represents a completely new mapping of what the remote party is
1295 * expecting for payloads, so we clear out the entire tx payload mapping
1296 * vector and replace it.
1297 */
1298 for (idx = 0; idx < AST_VECTOR_SIZE(&dest->payload_mapping_tx); ++idx) {
1299 type = AST_VECTOR_GET(&dest->payload_mapping_tx, idx);
1300 ao2_t_cleanup(type, "destroying ast_rtp_codec tx mapping");
1302 }
1303
1304 rtp_codecs_payloads_copy_rx(src, dest, instance);
1305 rtp_codecs_payloads_copy_tx(src, dest, instance);
1306 dest->framing = src->framing;
1310
1313}
1314
1315void ast_rtp_codecs_payloads_xover(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
1316{
1317 int idx;
1318 struct ast_rtp_payload_type *type;
1319
1321 if (src != dest) {
1322 /* Deadlock avoidance because of held write lock. */
1323 while (ast_rwlock_tryrdlock(&src->codecs_lock)) {
1325 sched_yield();
1327 }
1328 }
1329
1330 /* Crossover copy payload type tx mapping to rx mapping. */
1331 for (idx = 0; idx < AST_VECTOR_SIZE(&src->payload_mapping_tx); ++idx) {
1333 if (!type) {
1334 continue;
1335 }
1336
1337 /* All tx mapping elements should have the primary flag set. */
1338 ast_assert(type->primary_mapping);
1339
1340 ast_debug(2, "Crossover copying tx to rx payload mapping %d (%p) from %p to %p\n",
1341 idx, type, src, dest);
1343
1344 if (instance && instance->engine && instance->engine->payload_set) {
1345 ao2_lock(instance);
1346 instance->engine->payload_set(instance, idx, type->asterisk_format, type->format, type->rtp_code);
1347 ao2_unlock(instance);
1348 }
1349 }
1350
1351 dest->framing = src->framing;
1355
1356 if (src != dest) {
1358 }
1360}
1361
1363{
1364 struct ast_rtp_payload_type *new_type;
1365
1366 if (payload < 0 || payload >= AST_RTP_MAX_PT || payload > AST_RTP_PT_LAST_STATIC) {
1367 return;
1368 }
1369
1371 new_type = ao2_bump(static_RTP_PT[payload]);
1373 if (!new_type) {
1374 ast_debug(1, "Don't have a default tx payload type %d format for m type on %p\n",
1375 payload, codecs);
1376 return;
1377 }
1378
1379 ast_debug(1, "Setting tx payload type %d based on m type on %p\n",
1380 payload, codecs);
1381
1382 ast_rwlock_wrlock(&codecs->codecs_lock);
1383
1384 if (!payload_mapping_tx_is_present(codecs, new_type)) {
1385 if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
1386 ao2_t_cleanup(AST_VECTOR_GET(&codecs->payload_mapping_tx, payload),
1387 "cleaning up replaced tx payload type");
1388 }
1389
1390 if (AST_VECTOR_REPLACE(&codecs->payload_mapping_tx, payload, new_type)) {
1391 ao2_ref(new_type, -1);
1392 } else if (instance && instance->engine && instance->engine->payload_set) {
1393 ao2_lock(instance);
1394 instance->engine->payload_set(instance, payload, new_type->asterisk_format, new_type->format, new_type->rtp_code);
1395 ao2_unlock(instance);
1396 }
1397 } else {
1398 ao2_ref(new_type, -1);
1399 }
1400
1401 ast_rwlock_unlock(&codecs->codecs_lock);
1402}
1403
1405 char *mimetype, char *mimesubtype,
1407 unsigned int sample_rate)
1408{
1409 unsigned int idx;
1410 int found = 0;
1411
1412 if (pt < 0 || pt >= AST_RTP_MAX_PT) {
1413 return -1; /* bogus payload type */
1414 }
1415
1417 ast_rwlock_wrlock(&codecs->codecs_lock);
1418
1419 for (idx = 0; idx < mime_types_len; ++idx) {
1420 const struct ast_rtp_mime_type *t = &ast_rtp_mime_types[idx];
1421 struct ast_rtp_payload_type *new_type;
1422
1423 if (strcasecmp(mimesubtype, t->subtype)) {
1424 continue;
1425 }
1426
1427 if (strcasecmp(mimetype, t->type)) {
1428 continue;
1429 }
1430
1431 /* if both sample rates have been supplied, and they don't match,
1432 * then this not a match; if one has not been supplied, then the
1433 * rates are not compared */
1434 if (sample_rate && t->sample_rate &&
1435 (sample_rate != t->sample_rate)) {
1436 continue;
1437 }
1438
1439 found = 1;
1440
1442 if (!new_type) {
1443 continue;
1444 }
1445
1446 new_type->asterisk_format = t->payload_type.asterisk_format;
1447 new_type->rtp_code = t->payload_type.rtp_code;
1448 new_type->payload = pt;
1449 new_type->primary_mapping = 1;
1450 new_type->sample_rate = sample_rate;
1454 new_type->format = ast_format_g726_aal2;
1455 } else {
1456 new_type->format = t->payload_type.format;
1457 }
1458
1459 if (new_type->format) {
1460 /* SDP parsing automatically increases the reference count */
1461 new_type->format = ast_format_parse_sdp_fmtp(new_type->format, "");
1462 }
1463
1464 if (!payload_mapping_tx_is_present(codecs, new_type)) {
1465 if (pt < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
1466 ao2_t_cleanup(AST_VECTOR_GET(&codecs->payload_mapping_tx, pt),
1467 "cleaning up replaced tx payload type");
1468 }
1469
1470 if (AST_VECTOR_REPLACE(&codecs->payload_mapping_tx, pt, new_type)) {
1471 ao2_ref(new_type, -1);
1472 } else if (instance && instance->engine && instance->engine->payload_set) {
1473 ao2_lock(instance);
1474 instance->engine->payload_set(instance, pt, new_type->asterisk_format, new_type->format, new_type->rtp_code);
1475 ao2_unlock(instance);
1476 }
1477 } else {
1478 ao2_ref(new_type, -1);
1479 }
1480
1481 break;
1482 }
1483
1484 ast_rwlock_unlock(&codecs->codecs_lock);
1486
1487 return (found ? 0 : -2);
1488}
1489
1490int ast_rtp_codecs_payloads_set_rtpmap_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload, char *mimetype, char *mimesubtype, enum ast_rtp_options options)
1491{
1492 return ast_rtp_codecs_payloads_set_rtpmap_type_rate(codecs, instance, payload, mimetype, mimesubtype, options, 0);
1493}
1494
1496{
1497 struct ast_rtp_payload_type *type;
1498
1499 if (payload < 0 || payload >= AST_RTP_MAX_PT) {
1500 return;
1501 }
1502
1503 ast_debug(2, "Unsetting payload %d on %p\n", payload, codecs);
1504
1505 ast_rwlock_wrlock(&codecs->codecs_lock);
1506
1507 if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
1508 type = AST_VECTOR_GET(&codecs->payload_mapping_tx, payload);
1509 /*
1510 * Remove the preferred format if we are unsetting its container.
1511 *
1512 * There can be empty slots in payload_mapping_tx corresponding to
1513 * dynamic payload types that haven't been seen before so we need
1514 * to check for NULL before attempting to use 'type' in the call to
1515 * ast_format_cmp.
1516 */
1517 if (type) {
1518 if (ast_format_cmp(type->format, codecs->preferred_format) == AST_FORMAT_CMP_EQUAL) {
1519 ao2_replace(codecs->preferred_format, NULL);
1520 }
1521 ao2_ref(type, -1);
1522 AST_VECTOR_REPLACE(&codecs->payload_mapping_tx, payload, NULL);
1523 }
1524 }
1525
1526 if (instance && instance->engine && instance->engine->payload_set) {
1527 ao2_lock(instance);
1528 instance->engine->payload_set(instance, payload, 0, NULL, 0);
1529 ao2_unlock(instance);
1530 }
1531
1532 ast_rwlock_unlock(&codecs->codecs_lock);
1533}
1534
1536{
1537 enum ast_media_type stream_type = AST_MEDIA_TYPE_UNKNOWN;
1538 int payload;
1539 struct ast_rtp_payload_type *type;
1540
1541 ast_rwlock_rdlock(&codecs->codecs_lock);
1542 for (payload = 0; payload < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++payload) {
1543 type = AST_VECTOR_GET(&codecs->payload_mapping_rx, payload);
1544 if (type && type->asterisk_format) {
1545 stream_type = ast_format_get_type(type->format);
1546 break;
1547 }
1548 }
1549 ast_rwlock_unlock(&codecs->codecs_lock);
1550
1551 return stream_type;
1552}
1553
1555{
1556 struct ast_rtp_payload_type *type = NULL;
1557
1558 if (payload < 0 || payload >= AST_RTP_MAX_PT) {
1559 return NULL;
1560 }
1561
1562 ast_rwlock_rdlock(&codecs->codecs_lock);
1563 if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_rx)) {
1564 type = AST_VECTOR_GET(&codecs->payload_mapping_rx, payload);
1565 ao2_bump(type);
1566 }
1567 ast_rwlock_unlock(&codecs->codecs_lock);
1568
1569 if (!type && payload <= AST_RTP_PT_LAST_STATIC) {
1573 }
1574
1575 return type;
1576}
1577
1579{
1580 struct ast_format *format;
1581 ast_rwlock_rdlock(&codecs->codecs_lock);
1582 format = ao2_bump(codecs->preferred_format);
1583 ast_rwlock_unlock(&codecs->codecs_lock);
1584 return format;
1585}
1586
1588{
1589 ast_rwlock_wrlock(&codecs->codecs_lock);
1590 ao2_replace(codecs->preferred_format, format);
1591 ast_rwlock_unlock(&codecs->codecs_lock);
1592 return 0;
1593}
1594
1596{
1597 int pt = -1;
1598 ast_rwlock_rdlock(&codecs->codecs_lock);
1599 pt = codecs->preferred_dtmf_pt;
1600 ast_rwlock_unlock(&codecs->codecs_lock);
1601 return pt;
1602}
1603
1605{
1606 int rate = -1;
1607 ast_rwlock_rdlock(&codecs->codecs_lock);
1608 rate = codecs->preferred_dtmf_rate;
1609 ast_rwlock_unlock(&codecs->codecs_lock);
1610 return rate;
1611}
1612
1614{
1615 ast_rwlock_wrlock(&codecs->codecs_lock);
1616 codecs->preferred_dtmf_pt = pt;
1617 codecs->preferred_dtmf_rate = rate;
1618 ast_rwlock_unlock(&codecs->codecs_lock);
1619 return 0;
1620}
1621
1623{
1624 struct ast_rtp_payload_type *type;
1625
1626 if (payload < 0 || payload >= AST_RTP_MAX_PT || !format) {
1627 return -1;
1628 }
1629
1631 if (!type) {
1632 return -1;
1633 }
1634 ao2_ref(format, +1);
1635 type->format = format;
1636 type->asterisk_format = 1;
1637 type->payload = payload;
1638 type->primary_mapping = 1;
1639
1640 ast_rwlock_wrlock(&codecs->codecs_lock);
1642 if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
1643 ao2_cleanup(AST_VECTOR_GET(&codecs->payload_mapping_tx, payload));
1644 }
1645 if (AST_VECTOR_REPLACE(&codecs->payload_mapping_tx, payload, type)) {
1646 ao2_ref(type, -1);
1647 }
1648 } else {
1649 ao2_ref(type, -1);
1650 }
1651 ast_rwlock_unlock(&codecs->codecs_lock);
1652
1653 return 0;
1654}
1655
1657{
1658 struct ast_rtp_payload_type *type;
1659 struct ast_format *format = NULL;
1660
1661 if (payload < 0 || payload >= AST_RTP_MAX_PT) {
1662 return NULL;
1663 }
1664
1665 ast_rwlock_rdlock(&codecs->codecs_lock);
1666 if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
1667 type = AST_VECTOR_GET(&codecs->payload_mapping_tx, payload);
1668 if (type && type->asterisk_format) {
1669 format = ao2_bump(type->format);
1670 }
1671 }
1672 ast_rwlock_unlock(&codecs->codecs_lock);
1673
1674 return format;
1675}
1676
1677void ast_rtp_codecs_set_framing(struct ast_rtp_codecs *codecs, unsigned int framing)
1678{
1679 if (!framing) {
1680 return;
1681 }
1682
1683 ast_rwlock_wrlock(&codecs->codecs_lock);
1684 codecs->framing = framing;
1685 ast_rwlock_unlock(&codecs->codecs_lock);
1686}
1687
1689{
1690 unsigned int framing;
1691
1692 ast_rwlock_rdlock(&codecs->codecs_lock);
1693 framing = codecs->framing;
1694 ast_rwlock_unlock(&codecs->codecs_lock);
1695
1696 return framing;
1697}
1698
1699void ast_rtp_codecs_payload_formats(struct ast_rtp_codecs *codecs, struct ast_format_cap *astformats, int *nonastformats)
1700{
1701 int idx;
1702
1704 *nonastformats = 0;
1705
1706 ast_rwlock_rdlock(&codecs->codecs_lock);
1707
1708 for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
1709 struct ast_rtp_payload_type *type;
1710
1711 type = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
1712 if (!type) {
1713 continue;
1714 }
1715
1716 if (type->asterisk_format) {
1717 ast_format_cap_append(astformats, type->format, 0);
1718 } else {
1719 *nonastformats |= type->rtp_code;
1720 }
1721 }
1722 if (codecs->framing) {
1723 ast_format_cap_set_framing(astformats, codecs->framing);
1724 }
1725
1726 ast_rwlock_unlock(&codecs->codecs_lock);
1727}
1728
1729/*!
1730 * \internal
1731 * \brief Find the static payload type mapping for the format.
1732 * \since 14.0.0
1733 *
1734 * \param asterisk_format Non-zero if the given Asterisk format is present
1735 * \param format Asterisk format to look for
1736 * \param code The non-Asterisk format code to look for
1737 *
1738 * \note It is assumed that static_RTP_PT_lock is at least read locked before calling.
1739 *
1740 * \return Numerical payload type
1741 * \retval -1 if not found.
1742 */
1743static int find_static_payload_type(int asterisk_format, const struct ast_format *format, int code)
1744{
1745 int idx;
1746 int payload = -1;
1747
1748 if (!asterisk_format) {
1749 for (idx = 0; idx < AST_RTP_MAX_PT; ++idx) {
1750 if (static_RTP_PT[idx]
1752 && static_RTP_PT[idx]->rtp_code == code) {
1753 payload = idx;
1754 break;
1755 }
1756 }
1757 } else if (format) {
1758 for (idx = 0; idx < AST_RTP_MAX_PT; ++idx) {
1759 if (static_RTP_PT[idx]
1763 payload = idx;
1764 break;
1765 }
1766 }
1767 }
1768
1769 return payload;
1770}
1771
1772/*!
1773 * \internal
1774 * \brief Find the first unused payload type in a given range
1775 *
1776 * \param codecs The codec structure to look in
1777 * \param start Starting index
1778 * \param end Ending index
1779 * \param ignore Skip these payloads types
1780 *
1781 * \note The static_RTP_PT_lock object must be locked before calling
1782 *
1783 * \return Numerical payload type
1784 * \retval -1 if not found.
1785 */
1787 int start, int end, struct ast_rtp_payload_type *ignore[])
1788{
1789 int x;
1790
1791 for (x = start; x < end; ++x) {
1792 struct ast_rtp_payload_type *type;
1793
1794 if (ignore[x]) {
1795 continue;
1796 } else if (!codecs || x >= AST_VECTOR_SIZE(&codecs->payload_mapping_rx)) {
1797 return x;
1798 }
1799
1800 type = AST_VECTOR_GET(&codecs->payload_mapping_rx, x);
1801 if (!type) {
1802 return x;
1803 }
1804 }
1805 return -1;
1806}
1807
1808/*!
1809 * \internal
1810 * \brief Find an unused payload type
1811 *
1812 * \param codecs Codecs structure to look in
1813 *
1814 * \note Both static_RTP_PT_lock and codecs (if given) must be at least
1815 * read locked before calling.
1816 *
1817 * \return Numerical payload type
1818 * \retval -1 if not found.
1819 */
1821{
1822 int res;
1823
1824 /* find next available dynamic payload slot */
1827 if (res != -1) {
1828 return res;
1829 }
1830
1832 /*
1833 * We're using default values for some dynamic types. So if an unused
1834 * slot was not found try again, but this time ignore the default
1835 * values declared for dynamic types (except for 101 and 121) .
1836 */
1837 static struct ast_rtp_payload_type *ignore[AST_RTP_MAX_PT] = {0};
1838
1839 ignore[101] = static_RTP_PT[101];
1840 ignore[121] = static_RTP_PT[121];
1841
1844 if (res != -1) {
1845 return res;
1846 }
1847 }
1848
1849 /* http://www.iana.org/assignments/rtp-parameters
1850 * RFC 3551, Section 3: "[...] applications which need to define more
1851 * than 32 dynamic payload types MAY bind codes below 96, in which case
1852 * it is RECOMMENDED that unassigned payload type numbers be used
1853 * first". Updated by RFC 5761, Section 4: "[...] values in the range
1854 * 64-95 MUST NOT be used [to avoid conflicts with RTCP]". Summaries:
1855 * https://tools.ietf.org/html/draft-roach-mmusic-unified-plan#section-3.2.1.2
1856 * https://tools.ietf.org/html/draft-wu-avtcore-dynamic-pt-usage#section-3
1857 */
1861 if (res != -1) {
1862 return res;
1863 }
1864
1865 /* Yet, reusing mappings below AST_RTP_PT_LAST_STATIC (35) is not supported
1866 * in Asterisk because when Compact Headers are activated, no rtpmap is
1867 * send for those below 35. If you want to use 35 and below
1868 * A) do not use Compact Headers,
1869 * B) remove that code in res_pjsip, or
1870 * C) add a flag that this RTP Payload Type got reassigned dynamically
1871 * and requires a rtpmap even with Compact Headers enabled.
1872 */
1876 if (res != -1) {
1877 return res;
1878 }
1879
1882 20, static_RTP_PT);
1883}
1884
1885/*!
1886 * \internal
1887 * \brief Find the oldest non-primary dynamic rx payload type.
1888 * \since 14.0.0
1889 *
1890 * \param codecs Codecs structure to look in
1891 *
1892 * \note It is assumed that codecs is at least read locked before calling.
1893 *
1894 * \return Numerical payload type
1895 * \retval -1 if not found.
1896 */
1898{
1899 struct ast_rtp_payload_type *type;
1900 struct timeval oldest;
1901 int idx;
1902 int payload = -1;
1903
1905 for (; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
1906 type = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
1907 if (type
1908 && !type->primary_mapping
1909 && (payload == -1
1910 || ast_tvdiff_ms(type->when_retired, oldest) < 0)) {
1911 oldest = type->when_retired;
1912 payload = idx;
1913 }
1914 }
1915 return payload;
1916}
1917
1918/*!
1919 * \internal
1920 * \brief Assign a payload type for the rx mapping.
1921 * \since 14.0.0
1922 *
1923 * \param codecs Codecs structure to look in
1924 * \param asterisk_format Non-zero if the given Asterisk format is present
1925 * \param format Asterisk format to look for
1926 * \param code The format to look for
1927 * \param explicit Require the provided code to be explicitly used
1928 *
1929 * \note It is assumed that static_RTP_PT_lock is at least read locked before calling.
1930 *
1931 * \return Numerical payload type
1932 * \retval -1 if could not assign.
1933 */
1934static int rtp_codecs_assign_payload_code_rx(struct ast_rtp_codecs *codecs, int asterisk_format, struct ast_format *format, int code, int explicit, unsigned int sample_rate)
1935{
1936 int payload = code, i;
1937 struct ast_rtp_payload_type *new_type;
1938 static struct ast_rtp_payload_type *ignore[AST_RTP_MAX_PT] = {0};
1939
1940 if (!explicit) {
1942
1944 return payload;
1945 }
1946 }
1947
1948 new_type = rtp_payload_type_alloc(format, payload, code, 1, sample_rate);
1949 if (!new_type) {
1950 return -1;
1951 }
1952
1953 ast_rwlock_wrlock(&codecs->codecs_lock);
1954
1955 /* Go through the existing mapping to create an ignore list. */
1956 for (i = 0; i < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); i++) {
1957 if (AST_VECTOR_GET(&codecs->payload_mapping_rx, i)) {
1958 ignore[i] = static_RTP_PT[i];
1959 }
1960 }
1961
1962
1964 || AST_VECTOR_SIZE(&codecs->payload_mapping_rx) <= payload
1965 || !AST_VECTOR_GET(&codecs->payload_mapping_rx, payload))) {
1966
1967 /*
1968 * The payload type is a static assignment
1969 * or our default dynamic position is available.
1970 */
1972 } else if (payload > -1 && !explicit
1973 /* We can either call this with the full list or the current rx list. The former
1974 * (static_RTP_PT) results in payload types skipping statically 'used' slots so you
1975 * get 101, 113...
1976 * With the latter (the built ignore list) you get what's expected 101, 102, 103 under
1977 * most circumstances, but this results in static types being replaced. Probably fine
1978 * because we preclude the current list.
1979 */
1981 /*
1982 * Our dynamic position is currently in use.
1983 * Try for the numerically next free one before trying
1984 * across the full range. This keeps the payload id's
1985 * in the best numerical order we can through the free
1986 * types.
1987 */
1988 new_type->payload = payload;
1989 /*
1990 * In this case, consider this the primary mapping for
1991 * the payload type so don't clear it. Set not replace.
1992 */
1994 } else if (!explicit && (-1 < (payload = find_unused_payload(codecs))
1996 /*
1997 * We found the first available empty dynamic position
1998 * or we found a mapping that should no longer be
1999 * actively used.
2000 */
2001 new_type->payload = payload;
2003 } else if (explicit) {
2004 /*
2005 * They explicitly requested this payload number be used but it couldn't be
2006 */
2007 payload = -1;
2008 } else {
2009 /*
2010 * There are no empty or non-primary dynamic positions
2011 * left. Sadness.
2012 *
2013 * I don't think this is really possible.
2014 */
2015 ast_log(LOG_WARNING, "No dynamic RTP payload type values available "
2016 "for %s - %d!\n", format ? ast_format_get_name(format) : "", code);
2017 }
2018 ast_rwlock_unlock(&codecs->codecs_lock);
2019
2020 ao2_ref(new_type, -1);
2021
2022 return payload;
2023}
2024
2029
2031{
2032 struct ast_rtp_payload_type *type;
2033 int idx;
2034 int payload = -1;
2035
2037 if (!asterisk_format) {
2038 ast_rwlock_rdlock(&codecs->codecs_lock);
2039 for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
2040 type = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
2041 if (!type) {
2042 continue;
2043 }
2044
2045 if (!type->asterisk_format
2046 && type->primary_mapping
2047 && type->rtp_code == code
2048 && (sample_rate == 0 || type->sample_rate == sample_rate)) {
2049 payload = idx;
2050 break;
2051 }
2052 }
2053 ast_rwlock_unlock(&codecs->codecs_lock);
2054 } else if (format) {
2055 ast_rwlock_rdlock(&codecs->codecs_lock);
2056 for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
2057 type = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
2058 if (!type) {
2059 continue;
2060 }
2061
2062 if (type->asterisk_format
2063 && type->primary_mapping
2065 payload = idx;
2066 break;
2067 }
2068 }
2069 ast_rwlock_unlock(&codecs->codecs_lock);
2070 }
2071
2072 if (payload < 0) {
2074 code, 0, sample_rate);
2075 }
2077
2078 return payload;
2079}
2080
2082{
2083 return rtp_codecs_assign_payload_code_rx(codecs, 1, format, code, 1, 0);
2084}
2085
2090
2092{
2093 struct ast_rtp_payload_type *type;
2094 int idx;
2095 int payload = -1;
2096
2097 if (!asterisk_format) {
2098 ast_rwlock_rdlock(&codecs->codecs_lock);
2099 for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
2100 type = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
2101 if (!type) {
2102 continue;
2103 }
2104
2105 if (!type->asterisk_format
2106 && type->rtp_code == code
2107 /* Multiple DTMF types share an rtp code but have different sample rates. To ensure we have the right
2108 type we therefore need the sample rate as well as the format and code. Other types have a fixed
2109 sample rate so this is not needed. For those pass in a sample rate of 0 or use ast_rtp_codecs_payload_code_tx. */
2110 && (sample_rate == 0 || type->sample_rate == sample_rate)) {
2111 payload = idx;
2112 break;
2113 }
2114 }
2115 ast_rwlock_unlock(&codecs->codecs_lock);
2116 } else if (format) {
2117 ast_rwlock_rdlock(&codecs->codecs_lock);
2118 for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
2119 type = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
2120 if (!type) {
2121 continue;
2122 }
2123
2124 if (type->asterisk_format
2126 payload = idx;
2127 break;
2128 }
2129 }
2130 ast_rwlock_unlock(&codecs->codecs_lock);
2131 }
2132
2133 if (payload < 0) {
2137
2138 /*
2139 * Comfort noise is NOT used as an SDP negotiated format within Asterisk;
2140 * instead, it is used when it is not negotiated. This special case allows
2141 * its payload to be returned when not negotiated, allowing keep alive to
2142 * function as expected.
2143 */
2144 if (payload == 13 && code == AST_RTP_CN) {
2145 return payload;
2146 }
2147
2148 ast_rwlock_rdlock(&codecs->codecs_lock);
2149 if (payload >= 0 && payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)){
2150 type = AST_VECTOR_GET(&codecs->payload_mapping_tx, payload);
2151 if (!type || (sample_rate != 0 && type->sample_rate != sample_rate)) {
2152 /* Don't use the type if we can't find it or it doesn't match the supplied sample_rate */
2153 payload = -1;
2154 }
2155 }
2156 ast_rwlock_unlock(&codecs->codecs_lock);
2157 }
2158
2159 return payload;
2160}
2161
2166
2168{
2169 struct ast_rtp_payload_type *type;
2170 int res = -1;
2171
2172 ast_rwlock_rdlock(&codecs->codecs_lock);
2173 if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
2174 type = AST_VECTOR_GET(&codecs->payload_mapping_tx, payload);
2175 if (type) {
2176 res = payload;
2177 }
2178 }
2179 ast_rwlock_unlock(&codecs->codecs_lock);
2180
2181 return res;
2182}
2183
2185 const struct ast_format *format, int code, enum ast_rtp_options options)
2186{
2187 int i;
2188 const char *res = "";
2189
2191 for (i = 0; i < mime_types_len; i++) {
2192 if (ast_rtp_mime_types[i].payload_type.asterisk_format && asterisk_format && format &&
2193 (ast_format_cmp(format, ast_rtp_mime_types[i].payload_type.format) != AST_FORMAT_CMP_NOT_EQUAL)) {
2196 res = "G726-32";
2197 break;
2198 } else {
2199 res = ast_rtp_mime_types[i].subtype;
2200 break;
2201 }
2202 } else if (!ast_rtp_mime_types[i].payload_type.asterisk_format && !asterisk_format &&
2204
2205 res = ast_rtp_mime_types[i].subtype;
2206 break;
2207 }
2208 }
2210
2211 return res;
2212}
2213
2215 const struct ast_format *format, int code)
2216{
2217 unsigned int i;
2218 unsigned int res = 0;
2219
2221 for (i = 0; i < mime_types_len; ++i) {
2222 if (ast_rtp_mime_types[i].payload_type.asterisk_format && asterisk_format && format &&
2223 (ast_format_cmp(format, ast_rtp_mime_types[i].payload_type.format) != AST_FORMAT_CMP_NOT_EQUAL)) {
2225 break;
2226 } else if (!ast_rtp_mime_types[i].payload_type.asterisk_format && !asterisk_format &&
2229 break;
2230 }
2231 }
2233
2234 return res;
2235}
2236
2237char *ast_rtp_lookup_mime_multiple2(struct ast_str *buf, struct ast_format_cap *ast_format_capability, int rtp_capability, const int asterisk_format, enum ast_rtp_options options)
2238{
2239 int found = 0;
2240 const char *name;
2241 if (!buf) {
2242 return NULL;
2243 }
2244
2245
2246 if (asterisk_format) {
2247 int x;
2248 struct ast_format *tmp_fmt;
2249 for (x = 0; x < ast_format_cap_count(ast_format_capability); x++) {
2250 tmp_fmt = ast_format_cap_get_format(ast_format_capability, x);
2251 name = ast_rtp_lookup_mime_subtype2(asterisk_format, tmp_fmt, 0, options);
2252 ao2_ref(tmp_fmt, -1);
2253 ast_str_append(&buf, 0, "%s|", name);
2254 found = 1;
2255 }
2256 } else {
2257 int x;
2258 ast_str_append(&buf, 0, "0x%x (", (unsigned int) rtp_capability);
2259 for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
2260 if (rtp_capability & x) {
2261 name = ast_rtp_lookup_mime_subtype2(asterisk_format, NULL, x, options);
2262 ast_str_append(&buf, 0, "%s|", name);
2263 found = 1;
2264 }
2265 }
2266 }
2267
2268 ast_str_append(&buf, 0, "%s", found ? ")" : "nothing)");
2269
2270 return ast_str_buffer(buf);
2271}
2272
2274{
2275 int res;
2276
2277 if (instance->engine->dtmf_begin) {
2278 ao2_lock(instance);
2279 res = instance->engine->dtmf_begin(instance, digit);
2280 ao2_unlock(instance);
2281 } else {
2282 res = -1;
2283 }
2284 return res;
2285}
2286
2288{
2289 int res;
2290
2291 if (instance->engine->dtmf_end) {
2292 ao2_lock(instance);
2293 res = instance->engine->dtmf_end(instance, digit);
2294 ao2_unlock(instance);
2295 } else {
2296 res = -1;
2297 }
2298 return res;
2299}
2300
2301int ast_rtp_instance_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration)
2302{
2303 int res;
2304
2305 if (instance->engine->dtmf_end_with_duration) {
2306 ao2_lock(instance);
2307 res = instance->engine->dtmf_end_with_duration(instance, digit, duration);
2308 ao2_unlock(instance);
2309 } else {
2310 res = -1;
2311 }
2312 return res;
2313}
2314
2316{
2317 int res;
2318
2319 if (instance->engine->dtmf_mode_set) {
2320 ao2_lock(instance);
2321 res = instance->engine->dtmf_mode_set(instance, dtmf_mode);
2322 ao2_unlock(instance);
2323 } else {
2324 res = -1;
2325 }
2326 return res;
2327}
2328
2330{
2331 int res;
2332
2333 if (instance->engine->dtmf_mode_get) {
2334 ao2_lock(instance);
2335 res = instance->engine->dtmf_mode_get(instance);
2336 ao2_unlock(instance);
2337 } else {
2338 res = 0;
2339 }
2340 return res;
2341}
2342
2344{
2345 if (instance->engine->update_source) {
2346 ao2_lock(instance);
2347 instance->engine->update_source(instance);
2348 ao2_unlock(instance);
2349 }
2350}
2351
2353{
2354 if (instance->engine->change_source) {
2355 ao2_lock(instance);
2356 instance->engine->change_source(instance);
2357 ao2_unlock(instance);
2358 }
2359}
2360
2361int ast_rtp_instance_set_qos(struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
2362{
2363 int res;
2364
2365 if (instance->engine->qos) {
2366 ao2_lock(instance);
2367 res = instance->engine->qos(instance, tos, cos, desc);
2368 ao2_unlock(instance);
2369 } else {
2370 res = -1;
2371 }
2372 return res;
2373}
2374
2376{
2377 if (instance->engine->stop) {
2378 ao2_lock(instance);
2379 instance->engine->stop(instance);
2380 ao2_unlock(instance);
2381 }
2382}
2383
2384int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp)
2385{
2386 int res;
2387
2388 if (instance->engine->fd) {
2389 ao2_lock(instance);
2390 res = instance->engine->fd(instance, rtcp);
2391 ao2_unlock(instance);
2392 } else {
2393 res = -1;
2394 }
2395 return res;
2396}
2397
2399{
2400 struct ast_rtp_glue *glue = NULL;
2401
2403
2405 if (!strcasecmp(glue->type, type)) {
2406 break;
2407 }
2408 }
2409
2411
2412 return glue;
2413}
2414
2415/*!
2416 * \brief Conditionally unref an rtp instance
2417 */
2418static void unref_instance_cond(struct ast_rtp_instance **instance)
2419{
2420 if (*instance) {
2421 ao2_ref(*instance, -1);
2422 *instance = NULL;
2423 }
2424}
2425
2427{
2428 struct ast_rtp_instance *bridged;
2429
2430 ao2_lock(instance);
2431 bridged = instance->bridged;
2432 ao2_unlock(instance);
2433 return bridged;
2434}
2435
2437{
2438 ao2_lock(instance);
2439 instance->bridged = bridged;
2440 ao2_unlock(instance);
2441}
2442
2444{
2445 struct ast_rtp_instance *instance_dst = NULL, *instance_src = NULL,
2446 *vinstance_dst = NULL, *vinstance_src = NULL,
2447 *tinstance_dst = NULL, *tinstance_src = NULL;
2448 struct ast_rtp_glue *glue_dst, *glue_src;
2449 enum ast_rtp_glue_result audio_glue_dst_res = AST_RTP_GLUE_RESULT_FORBID, video_glue_dst_res = AST_RTP_GLUE_RESULT_FORBID;
2450 enum ast_rtp_glue_result audio_glue_src_res = AST_RTP_GLUE_RESULT_FORBID, video_glue_src_res = AST_RTP_GLUE_RESULT_FORBID;
2453
2454 /* Lock both channels so we can look for the glue that binds them together */
2455 ast_channel_lock_both(c_dst, c_src);
2456
2457 if (!cap_src || !cap_dst) {
2458 goto done;
2459 }
2460
2461 /* Grab glue that binds each channel to something using the RTP engine */
2462 if (!(glue_dst = ast_rtp_instance_get_glue(ast_channel_tech(c_dst)->type)) || !(glue_src = ast_rtp_instance_get_glue(ast_channel_tech(c_src)->type))) {
2463 ast_debug(1, "Can't find native functions for channel '%s'\n", glue_dst ? ast_channel_name(c_src) : ast_channel_name(c_dst));
2464 goto done;
2465 }
2466
2467 audio_glue_dst_res = glue_dst->get_rtp_info(c_dst, &instance_dst);
2468 video_glue_dst_res = glue_dst->get_vrtp_info ? glue_dst->get_vrtp_info(c_dst, &vinstance_dst) : AST_RTP_GLUE_RESULT_FORBID;
2469
2470 audio_glue_src_res = glue_src->get_rtp_info(c_src, &instance_src);
2471 video_glue_src_res = glue_src->get_vrtp_info ? glue_src->get_vrtp_info(c_src, &vinstance_src) : AST_RTP_GLUE_RESULT_FORBID;
2472
2473 /* If we are carrying video, and both sides are not going to remotely bridge... fail the native bridge */
2474 if (video_glue_dst_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue_dst_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue_dst_res != AST_RTP_GLUE_RESULT_REMOTE)) {
2475 audio_glue_dst_res = AST_RTP_GLUE_RESULT_FORBID;
2476 }
2477 if (video_glue_src_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue_src_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue_src_res != AST_RTP_GLUE_RESULT_REMOTE)) {
2478 audio_glue_src_res = AST_RTP_GLUE_RESULT_FORBID;
2479 }
2480 if (audio_glue_dst_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue_dst_res == AST_RTP_GLUE_RESULT_FORBID || video_glue_dst_res == AST_RTP_GLUE_RESULT_REMOTE) && glue_dst->get_codec) {
2481 glue_dst->get_codec(c_dst, cap_dst);
2482 }
2483 if (audio_glue_src_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue_src_res == AST_RTP_GLUE_RESULT_FORBID || video_glue_src_res == AST_RTP_GLUE_RESULT_REMOTE) && glue_src->get_codec) {
2484 glue_src->get_codec(c_src, cap_src);
2485 }
2486
2487 /* If any sort of bridge is forbidden just completely bail out and go back to generic bridging */
2488 if (audio_glue_dst_res != AST_RTP_GLUE_RESULT_REMOTE || audio_glue_src_res != AST_RTP_GLUE_RESULT_REMOTE) {
2489 goto done;
2490 }
2491
2492 /* Make sure we have matching codecs */
2493 if (!ast_format_cap_iscompatible(cap_dst, cap_src)) {
2494 goto done;
2495 }
2496
2497 ast_rtp_codecs_payloads_xover(&instance_src->codecs, &instance_dst->codecs, instance_dst);
2498
2499 if (vinstance_dst && vinstance_src) {
2500 ast_rtp_codecs_payloads_xover(&vinstance_src->codecs, &vinstance_dst->codecs, vinstance_dst);
2501 }
2502 if (tinstance_dst && tinstance_src) {
2503 ast_rtp_codecs_payloads_xover(&tinstance_src->codecs, &tinstance_dst->codecs, tinstance_dst);
2504 }
2505
2506 if (glue_dst->update_peer(c_dst, instance_src, vinstance_src, tinstance_src, cap_src, 0)) {
2507 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n",
2508 ast_channel_name(c_dst), ast_channel_name(c_src));
2509 } else {
2510 ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n",
2511 ast_channel_name(c_dst), ast_channel_name(c_src));
2512 }
2513
2514done:
2515 ast_channel_unlock(c_dst);
2516 ast_channel_unlock(c_src);
2517
2518 ao2_cleanup(cap_dst);
2519 ao2_cleanup(cap_src);
2520
2521 unref_instance_cond(&instance_dst);
2522 unref_instance_cond(&instance_src);
2523 unref_instance_cond(&vinstance_dst);
2524 unref_instance_cond(&vinstance_src);
2525 unref_instance_cond(&tinstance_dst);
2526 unref_instance_cond(&tinstance_src);
2527}
2528
2530{
2531 struct ast_rtp_instance *instance0 = NULL, *instance1 = NULL,
2532 *vinstance0 = NULL, *vinstance1 = NULL,
2533 *tinstance0 = NULL, *tinstance1 = NULL;
2534 struct ast_rtp_glue *glue0, *glue1;
2535 enum ast_rtp_glue_result audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID, video_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
2536 enum ast_rtp_glue_result audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID, video_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
2539
2540 /* If there is no second channel just immediately bail out, we are of no use in that scenario */
2541 if (!c1 || !cap1 || !cap0) {
2542 ao2_cleanup(cap0);
2543 ao2_cleanup(cap1);
2544 return -1;
2545 }
2546
2547 /* Lock both channels so we can look for the glue that binds them together */
2548 ast_channel_lock_both(c0, c1);
2549
2550 /* Grab glue that binds each channel to something using the RTP engine */
2552 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", glue0 ? ast_channel_name(c1) : ast_channel_name(c0));
2553 goto done;
2554 }
2555
2556 audio_glue0_res = glue0->get_rtp_info(c0, &instance0);
2557 video_glue0_res = glue0->get_vrtp_info ? glue0->get_vrtp_info(c0, &vinstance0) : AST_RTP_GLUE_RESULT_FORBID;
2558
2559 audio_glue1_res = glue1->get_rtp_info(c1, &instance1);
2560 video_glue1_res = glue1->get_vrtp_info ? glue1->get_vrtp_info(c1, &vinstance1) : AST_RTP_GLUE_RESULT_FORBID;
2561
2562 /* If we are carrying video, and both sides are not going to remotely bridge... fail the native bridge */
2563 if (video_glue0_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue0_res != AST_RTP_GLUE_RESULT_REMOTE)) {
2564 audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
2565 }
2566 if (video_glue1_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue1_res != AST_RTP_GLUE_RESULT_REMOTE)) {
2567 audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
2568 }
2569 if (audio_glue0_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue0_res == AST_RTP_GLUE_RESULT_FORBID || video_glue0_res == AST_RTP_GLUE_RESULT_REMOTE) && glue0->get_codec) {
2570 glue0->get_codec(c0, cap0);
2571 }
2572 if (audio_glue1_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue1_res == AST_RTP_GLUE_RESULT_FORBID || video_glue1_res == AST_RTP_GLUE_RESULT_REMOTE) && glue1->get_codec) {
2573 glue1->get_codec(c1, cap1);
2574 }
2575
2576 /* If any sort of bridge is forbidden just completely bail out and go back to generic bridging */
2577 if (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE) {
2578 goto done;
2579 }
2580
2581 /* Make sure we have matching codecs */
2582 if (!ast_format_cap_iscompatible(cap0, cap1)) {
2583 goto done;
2584 }
2585
2586 /* Bridge media early */
2587 if (glue0->update_peer(c0, instance1, vinstance1, tinstance1, cap1, 0)) {
2588 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", ast_channel_name(c0), c1 ? ast_channel_name(c1) : "<unspecified>");
2589 }
2590
2591done:
2594
2595 ao2_cleanup(cap0);
2596 ao2_cleanup(cap1);
2597
2598 unref_instance_cond(&instance0);
2599 unref_instance_cond(&instance1);
2600 unref_instance_cond(&vinstance0);
2601 unref_instance_cond(&vinstance1);
2602 unref_instance_cond(&tinstance0);
2603 unref_instance_cond(&tinstance1);
2604
2605 ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", ast_channel_name(c0), c1 ? ast_channel_name(c1) : "<unspecified>");
2606
2607 return 0;
2608}
2609
2610int ast_rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
2611{
2612 int res;
2613
2614 if (instance->engine->red_init) {
2615 ao2_lock(instance);
2616 res = instance->engine->red_init(instance, buffer_time, payloads, generations);
2617 ao2_unlock(instance);
2618 } else {
2619 res = -1;
2620 }
2621 return res;
2622}
2623
2624int ast_rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
2625{
2626 int res;
2627
2628 if (instance->engine->red_buffer) {
2629 ao2_lock(instance);
2630 res = instance->engine->red_buffer(instance, frame);
2631 ao2_unlock(instance);
2632 } else {
2633 res = -1;
2634 }
2635 return res;
2636}
2637
2639{
2640 int res;
2641
2642 if (!instance || !instance->engine || !stats) {
2643 return -1;
2644 }
2645
2646 if (instance->engine->get_stat) {
2647 ao2_lock(instance);
2648 res = instance->engine->get_stat(instance, stats, stat);
2649 ao2_unlock(instance);
2650 } else {
2651 res = -1;
2652 }
2653 return res;
2654}
2655
2656char *ast_rtp_instance_get_quality(struct ast_rtp_instance *instance, enum ast_rtp_instance_stat_field field, char *buf, size_t size)
2657{
2658 struct ast_rtp_instance_stats stats = { 0, };
2659 enum ast_rtp_instance_stat stat;
2660
2661 /* Determine what statistics we will need to retrieve based on field passed in */
2664 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER) {
2666 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS) {
2668 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT) {
2670 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES) {
2672 } else {
2673 return NULL;
2674 }
2675
2676 /* Attempt to actually retrieve the statistics we need to generate the quality string */
2677 if (ast_rtp_instance_get_stats(instance, &stats, stat)) {
2678 return NULL;
2679 }
2680
2681 /* Now actually fill the buffer with the good information */
2683 snprintf(buf, size, "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;"
2684 "txjitter=%f;txcount=%u;rlp=%u;rtt=%f;rxmes=%f;txmes=%f",
2685 stats.local_ssrc, stats.remote_ssrc, stats.rxploss, stats.rxjitter,
2686 stats.rxcount, stats.txjitter, stats.txcount, stats.txploss, stats.rtt,
2687 stats.rxmes, stats.txmes);
2688 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER) {
2689 snprintf(buf, size, "minrxjitter=%010.6f;maxrxjitter=%010.6f;avgrxjitter=%010.6f;stdevrxjitter=%010.6f;mintxjitter=%010.6f;maxtxjitter=%010.6f;avgtxjitter=%010.6f;stdevtxjitter=%010.6f;",
2691 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS) {
2692 snprintf(buf, size, " minrxlost=%010.6f; maxrxlost=%010.6f; avgrxlost=%010.6f; stdevrxlost=%010.6f; mintxlost=%010.6f; maxtxlost=%010.6f; avgtxlost=%010.6f; stdevtxlost=%010.6f;",
2694 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT) {
2695 snprintf(buf, size, " minrtt=%010.6f; maxrtt=%010.6f; avgrtt=%010.6f; stdevrtt=%010.6f;", stats.minrtt, stats.maxrtt, stats.normdevrtt, stats.stdevrtt);
2696 } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES) {
2697 snprintf(buf, size, " minrxmes=%010.6f; maxrxmes=%010.6f; avgrxmes=%010.6f; stdevrxmes=%010.6f; mintxmes=%010.6f; maxtxmes=%010.6f; avgtxmes=%010.6f; stdevtxmes=%010.6f;",
2698 stats.local_minmes, stats.local_maxmes,
2699 stats.local_normdevmes, stats.local_stdevmes,
2700 stats.remote_minmes, stats.remote_maxmes,
2701 stats.remote_normdevmes, stats.remote_stdevmes);
2702 }
2703
2704 return buf;
2705}
2706
2708{
2709 char quality_buf[AST_MAX_USER_FIELD];
2710 char *quality;
2711 struct ast_channel *bridge;
2712
2714 if (bridge) {
2717 } else {
2718 ast_channel_lock(chan);
2719 }
2721
2723 quality_buf, sizeof(quality_buf));
2724 if (quality) {
2725 pbx_builtin_setvar_helper(chan, "RTPAUDIOQOS", quality);
2726 if (bridge) {
2727 pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSBRIDGED", quality);
2728 }
2729 }
2730
2732 AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER, quality_buf, sizeof(quality_buf));
2733 if (quality) {
2734 pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSJITTER", quality);
2735 if (bridge) {
2736 pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSJITTERBRIDGED", quality);
2737 }
2738 }
2739
2741 AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS, quality_buf, sizeof(quality_buf));
2742 if (quality) {
2743 pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSLOSS", quality);
2744 if (bridge) {
2745 pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSLOSSBRIDGED", quality);
2746 }
2747 }
2748
2750 AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT, quality_buf, sizeof(quality_buf));
2751 if (quality) {
2752 pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSRTT", quality);
2753 if (bridge) {
2754 pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSRTTBRIDGED", quality);
2755 }
2756 }
2757
2759 AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES, quality_buf, sizeof(quality_buf));
2760 if (quality) {
2761 pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSMES", quality);
2762 if (bridge) {
2763 pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSMESBRIDGED", quality);
2764 }
2765 }
2766
2768 ast_channel_unlock(chan);
2769 if (bridge) {
2773 }
2774}
2775
2777{
2778 int res;
2779
2780 if (instance->engine->set_read_format) {
2781 ao2_lock(instance);
2782 res = instance->engine->set_read_format(instance, format);
2783 ao2_unlock(instance);
2784 } else {
2785 res = -1;
2786 }
2787 return res;
2788}
2789
2791{
2792 int res;
2793
2794 if (instance->engine->set_read_format) {
2795 ao2_lock(instance);
2796 res = instance->engine->set_write_format(instance, format);
2797 ao2_unlock(instance);
2798 } else {
2799 res = -1;
2800 }
2801 return res;
2802}
2803
2804/* XXX Nothing calls this */
2805int ast_rtp_instance_make_compatible(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_channel *peer)
2806{
2807 struct ast_rtp_glue *glue;
2808 struct ast_rtp_instance *peer_instance = NULL;
2809 int res = -1;
2810
2811 if (!instance->engine->make_compatible) {
2812 return -1;
2813 }
2814
2815 ast_channel_lock(peer);
2816
2818 ast_channel_unlock(peer);
2819 return -1;
2820 }
2821
2822 glue->get_rtp_info(peer, &peer_instance);
2823 if (!peer_instance) {
2824 ast_log(LOG_ERROR, "Unable to get_rtp_info for peer type %s\n", glue->type);
2825 ast_channel_unlock(peer);
2826 return -1;
2827 }
2828 if (peer_instance->engine != instance->engine) {
2829 ast_log(LOG_ERROR, "Peer engine mismatch for type %s\n", glue->type);
2830 ast_channel_unlock(peer);
2831 ao2_ref(peer_instance, -1);
2832 return -1;
2833 }
2834
2835 /*
2836 * XXX Good thing nothing calls this function because we would need
2837 * deadlock avoidance to get the two instance locks.
2838 */
2839 res = instance->engine->make_compatible(chan, instance, peer, peer_instance);
2840
2841 ast_channel_unlock(peer);
2842
2843 ao2_ref(peer_instance, -1);
2844 peer_instance = NULL;
2845
2846 return res;
2847}
2848
2849void ast_rtp_instance_available_formats(struct ast_rtp_instance *instance, struct ast_format_cap *to_endpoint, struct ast_format_cap *to_asterisk, struct ast_format_cap *result)
2850{
2851 if (instance->engine->available_formats) {
2852 ao2_lock(instance);
2853 instance->engine->available_formats(instance, to_endpoint, to_asterisk, result);
2854 ao2_unlock(instance);
2856 return;
2857 }
2858 }
2859
2860 ast_translate_available_formats(to_endpoint, to_asterisk, result);
2861}
2862
2864{
2865 int res;
2866
2867 if (instance->engine->activate) {
2868 ao2_lock(instance);
2869 res = instance->engine->activate(instance);
2870 ao2_unlock(instance);
2871 } else {
2872 res = 0;
2873 }
2874 return res;
2875}
2876
2878 struct ast_sockaddr *suggestion,
2879 const char *username)
2880{
2881 if (instance->engine->stun_request) {
2882 instance->engine->stun_request(instance, suggestion, username);
2883 }
2884}
2885
2887{
2888 instance->timeout = timeout;
2889}
2890
2892{
2893 instance->holdtimeout = timeout;
2894}
2895
2896void ast_rtp_instance_set_keepalive(struct ast_rtp_instance *instance, int interval)
2897{
2898 instance->keepalive = interval;
2899}
2900
2902{
2903 return instance->timeout;
2904}
2905
2907{
2908 return instance->holdtimeout;
2909}
2910
2912{
2913 return instance->keepalive;
2914}
2915
2917{
2918 return instance->engine;
2919}
2920
2922{
2923 return instance->glue;
2924}
2925
2927{
2928 if (res_srtp || res_srtp_policy) {
2929 return -1;
2930 }
2931 if (!srtp_res || !policy_res) {
2932 return -1;
2933 }
2934
2937
2938 return 0;
2939}
2940
2942{
2943 res_srtp = NULL;
2945}
2946
2948{
2949 return res_srtp && res_srtp_policy;
2950}
2951
2952int ast_rtp_instance_add_srtp_policy(struct ast_rtp_instance *instance, struct ast_srtp_policy *remote_policy, struct ast_srtp_policy *local_policy, int rtcp)
2953{
2954 int res = 0;
2955 struct ast_srtp **srtp;
2956
2957 if (!res_srtp) {
2958 return -1;
2959 }
2960
2961 ao2_lock(instance);
2962
2963 srtp = rtcp ? &instance->rtcp_srtp : &instance->srtp;
2964
2965 if (!*srtp) {
2966 res = res_srtp->create(srtp, instance, remote_policy);
2967 } else if (remote_policy) {
2968 res = res_srtp->replace(srtp, instance, remote_policy);
2969 }
2970 if (!res) {
2971 res = res_srtp->add_stream(*srtp, local_policy);
2972 }
2973
2974 ao2_unlock(instance);
2975
2976 return res;
2977}
2978
2979struct ast_srtp *ast_rtp_instance_get_srtp(struct ast_rtp_instance *instance, int rtcp)
2980{
2981 if (rtcp && instance->rtcp_srtp) {
2982 return instance->rtcp_srtp;
2983 } else {
2984 return instance->srtp;
2985 }
2986}
2987
2988int ast_rtp_instance_sendcng(struct ast_rtp_instance *instance, int level)
2989{
2990 int res;
2991
2992 if (instance->engine->sendcng) {
2993 ao2_lock(instance);
2994 res = instance->engine->sendcng(instance, level);
2995 ao2_unlock(instance);
2996 } else {
2997 res = -1;
2998 }
2999 return res;
3000}
3001
3002static void rtp_ice_wrap_set_authentication(struct ast_rtp_instance *instance, const char *ufrag, const char *password)
3003{
3004 ao2_lock(instance);
3005 instance->engine->ice->set_authentication(instance, ufrag, password);
3006 ao2_unlock(instance);
3007}
3008
3009static void rtp_ice_wrap_add_remote_candidate(struct ast_rtp_instance *instance, const struct ast_rtp_engine_ice_candidate *candidate)
3010{
3011 ao2_lock(instance);
3012 instance->engine->ice->add_remote_candidate(instance, candidate);
3013 ao2_unlock(instance);
3014}
3015
3016static void rtp_ice_wrap_start(struct ast_rtp_instance *instance)
3017{
3018 ao2_lock(instance);
3019 instance->engine->ice->start(instance);
3020 ao2_unlock(instance);
3021}
3022
3023static void rtp_ice_wrap_stop(struct ast_rtp_instance *instance)
3024{
3025 ao2_lock(instance);
3026 instance->engine->ice->stop(instance);
3027 ao2_unlock(instance);
3028}
3029
3030static const char *rtp_ice_wrap_get_ufrag(struct ast_rtp_instance *instance)
3031{
3032 const char *ufrag;
3033
3034 ao2_lock(instance);
3035 ufrag = instance->engine->ice->get_ufrag(instance);
3036 ao2_unlock(instance);
3037 return ufrag;
3038}
3039
3040static const char *rtp_ice_wrap_get_password(struct ast_rtp_instance *instance)
3041{
3042 const char *password;
3043
3044 ao2_lock(instance);
3045 password = instance->engine->ice->get_password(instance);
3046 ao2_unlock(instance);
3047 return password;
3048}
3049
3051{
3052 struct ao2_container *local_candidates;
3053
3054 ao2_lock(instance);
3055 local_candidates = instance->engine->ice->get_local_candidates(instance);
3056 ao2_unlock(instance);
3057 return local_candidates;
3058}
3059
3060static void rtp_ice_wrap_ice_lite(struct ast_rtp_instance *instance)
3061{
3062 ao2_lock(instance);
3063 instance->engine->ice->ice_lite(instance);
3064 ao2_unlock(instance);
3065}
3066
3067static void rtp_ice_wrap_set_role(struct ast_rtp_instance *instance,
3068 enum ast_rtp_ice_role role)
3069{
3070 ao2_lock(instance);
3071 instance->engine->ice->set_role(instance, role);
3072 ao2_unlock(instance);
3073}
3074
3075static void rtp_ice_wrap_turn_request(struct ast_rtp_instance *instance,
3076 enum ast_rtp_ice_component_type component, enum ast_transport transport,
3077 const char *server, unsigned int port, const char *username, const char *password)
3078{
3079 ao2_lock(instance);
3080 instance->engine->ice->turn_request(instance, component, transport, server, port,
3081 username, password);
3082 ao2_unlock(instance);
3083}
3084
3086 int num_components)
3087{
3088 ao2_lock(instance);
3089 instance->engine->ice->change_components(instance, num_components);
3090 ao2_unlock(instance);
3091}
3092
3095 .add_remote_candidate = rtp_ice_wrap_add_remote_candidate,
3096 .start = rtp_ice_wrap_start,
3097 .stop = rtp_ice_wrap_stop,
3098 .get_ufrag = rtp_ice_wrap_get_ufrag,
3099 .get_password = rtp_ice_wrap_get_password,
3100 .get_local_candidates = rtp_ice_wrap_get_local_candidates,
3101 .ice_lite = rtp_ice_wrap_ice_lite,
3102 .set_role = rtp_ice_wrap_set_role,
3103 .turn_request = rtp_ice_wrap_turn_request,
3104 .change_components = rtp_ice_wrap_change_components,
3105};
3106
3108{
3109 if (instance->engine->ice) {
3110 return &rtp_ice_wrappers;
3111 }
3112 /* ICE not available */
3113 return NULL;
3114}
3115
3116#ifdef TEST_FRAMEWORK
3117struct ast_rtp_engine_test *ast_rtp_instance_get_test(struct ast_rtp_instance *instance)
3118{
3119 return instance->engine->test;
3120}
3121#endif
3122
3124 const struct ast_rtp_dtls_cfg *dtls_cfg)
3125{
3126 int set_configuration;
3127
3128 ao2_lock(instance);
3129 set_configuration = instance->engine->dtls->set_configuration(instance, dtls_cfg);
3130 ao2_unlock(instance);
3131 return set_configuration;
3132}
3133
3134static int rtp_dtls_wrap_active(struct ast_rtp_instance *instance)
3135{
3136 int active;
3137
3138 ao2_lock(instance);
3139 active = instance->engine->dtls->active(instance);
3140 ao2_unlock(instance);
3141 return active;
3142}
3143
3144static void rtp_dtls_wrap_stop(struct ast_rtp_instance *instance)
3145{
3146 ao2_lock(instance);
3147 instance->engine->dtls->stop(instance);
3148 ao2_unlock(instance);
3149}
3150
3151static void rtp_dtls_wrap_reset(struct ast_rtp_instance *instance)
3152{
3153 ao2_lock(instance);
3154 instance->engine->dtls->reset(instance);
3155 ao2_unlock(instance);
3156}
3157
3159{
3160 enum ast_rtp_dtls_connection get_connection;
3161
3162 ao2_lock(instance);
3163 get_connection = instance->engine->dtls->get_connection(instance);
3164 ao2_unlock(instance);
3165 return get_connection;
3166}
3167
3169{
3170 enum ast_rtp_dtls_setup get_setup;
3171
3172 ao2_lock(instance);
3173 get_setup = instance->engine->dtls->get_setup(instance);
3174 ao2_unlock(instance);
3175 return get_setup;
3176}
3177
3178static void rtp_dtls_wrap_set_setup(struct ast_rtp_instance *instance,
3179 enum ast_rtp_dtls_setup setup)
3180{
3181 ao2_lock(instance);
3182 instance->engine->dtls->set_setup(instance, setup);
3183 ao2_unlock(instance);
3184}
3185
3187 enum ast_rtp_dtls_hash hash, const char *fingerprint)
3188{
3189 ao2_lock(instance);
3190 instance->engine->dtls->set_fingerprint(instance, hash, fingerprint);
3191 ao2_unlock(instance);
3192}
3193
3195{
3196 enum ast_rtp_dtls_hash get_fingerprint_hash;
3197
3198 ao2_lock(instance);
3199 get_fingerprint_hash = instance->engine->dtls->get_fingerprint_hash(instance);
3200 ao2_unlock(instance);
3201 return get_fingerprint_hash;
3202}
3203
3204static const char *rtp_dtls_wrap_get_fingerprint(struct ast_rtp_instance *instance)
3205{
3206 const char *get_fingerprint;
3207
3208 ao2_lock(instance);
3209 get_fingerprint = instance->engine->dtls->get_fingerprint(instance);
3210 ao2_unlock(instance);
3211 return get_fingerprint;
3212}
3213
3216 .active = rtp_dtls_wrap_active,
3217 .stop = rtp_dtls_wrap_stop,
3218 .reset = rtp_dtls_wrap_reset,
3219 .get_connection = rtp_dtls_wrap_get_connection,
3220 .get_setup = rtp_dtls_wrap_get_setup,
3221 .set_setup = rtp_dtls_wrap_set_setup,
3222 .set_fingerprint = rtp_dtls_wrap_set_fingerprint,
3223 .get_fingerprint_hash = rtp_dtls_wrap_get_fingerprint_hash,
3224 .get_fingerprint = rtp_dtls_wrap_get_fingerprint,
3225};
3226
3228{
3229 if (instance->engine->dtls) {
3230 return &rtp_dtls_wrappers;
3231 }
3232 /* DTLS not available */
3233 return NULL;
3234}
3235
3236int ast_rtp_dtls_cfg_parse(struct ast_rtp_dtls_cfg *dtls_cfg, const char *name, const char *value)
3237{
3238 if (!strcasecmp(name, "dtlsenable")) {
3239 dtls_cfg->enabled = ast_true(value) ? 1 : 0;
3240 } else if (!strcasecmp(name, "dtlsverify")) {
3241 if (!strcasecmp(value, "yes")) {
3243 } else if (!strcasecmp(value, "fingerprint")) {
3245 } else if (!strcasecmp(value, "certificate")) {
3247 } else if (!strcasecmp(value, "no")) {
3248 dtls_cfg->verify = AST_RTP_DTLS_VERIFY_NONE;
3249 } else {
3250 return -1;
3251 }
3252 } else if (!strcasecmp(name, "dtlsrekey")) {
3253 if (sscanf(value, "%30u", &dtls_cfg->rekey) != 1) {
3254 return -1;
3255 }
3256 } else if (!strcasecmp(name, "dtlsautogeneratecert")) {
3257 dtls_cfg->ephemeral_cert = ast_true(value) ? 1 : 0;
3258 } else if (!strcasecmp(name, "dtlscertfile")) {
3260 ast_log(LOG_ERROR, "%s file %s does not exist or is not readable\n", name, value);
3261 return -1;
3262 }
3263 ast_free(dtls_cfg->certfile);
3264 dtls_cfg->certfile = ast_strdup(value);
3265 } else if (!strcasecmp(name, "dtlsprivatekey")) {
3267 ast_log(LOG_ERROR, "%s file %s does not exist or is not readable\n", name, value);
3268 return -1;
3269 }
3270 ast_free(dtls_cfg->pvtfile);
3271 dtls_cfg->pvtfile = ast_strdup(value);
3272 } else if (!strcasecmp(name, "dtlscipher")) {
3273 ast_free(dtls_cfg->cipher);
3274 dtls_cfg->cipher = ast_strdup(value);
3275 } else if (!strcasecmp(name, "dtlscafile")) {
3277 ast_log(LOG_ERROR, "%s file %s does not exist or is not readable\n", name, value);
3278 return -1;
3279 }
3280 ast_free(dtls_cfg->cafile);
3281 dtls_cfg->cafile = ast_strdup(value);
3282 } else if (!strcasecmp(name, "dtlscapath") || !strcasecmp(name, "dtlscadir")) {
3284 ast_log(LOG_ERROR, "%s file %s does not exist or is not readable\n", name, value);
3285 return -1;
3286 }
3287 ast_free(dtls_cfg->capath);
3288 dtls_cfg->capath = ast_strdup(value);
3289 } else if (!strcasecmp(name, "dtlssetup")) {
3290 if (!strcasecmp(value, "active")) {
3292 } else if (!strcasecmp(value, "passive")) {
3294 } else if (!strcasecmp(value, "actpass")) {
3296 }
3297 } else if (!strcasecmp(name, "dtlsfingerprint")) {
3298 if (!strcasecmp(value, "sha-256")) {
3299 dtls_cfg->hash = AST_RTP_DTLS_HASH_SHA256;
3300 } else if (!strcasecmp(value, "sha-1")) {
3301 dtls_cfg->hash = AST_RTP_DTLS_HASH_SHA1;
3302 }
3303 } else {
3304 return -1;
3305 }
3306
3307 return 0;
3308}
3309
3311{
3312 if (dtls_cfg->ephemeral_cert) {
3313 if (!ast_strlen_zero(dtls_cfg->certfile)) {
3314 ast_log(LOG_ERROR, "You cannot request automatically generated certificates"
3315 " (dtls_auto_generate_cert) and also specify a certificate file"
3316 " (dtls_cert_file) at the same time\n");
3317 return -1;
3318 } else if (!ast_strlen_zero(dtls_cfg->pvtfile)
3319 || !ast_strlen_zero(dtls_cfg->cafile)
3320 || !ast_strlen_zero(dtls_cfg->capath)) {
3321 ast_log(LOG_NOTICE, "dtls_pvt_file, dtls_cafile, and dtls_ca_path are"
3322 " ignored when dtls_auto_generate_cert is enabled\n");
3323 }
3324 }
3325
3326 return 0;
3327}
3328
3329void ast_rtp_dtls_cfg_copy(const struct ast_rtp_dtls_cfg *src_cfg, struct ast_rtp_dtls_cfg *dst_cfg)
3330{
3331 ast_rtp_dtls_cfg_free(dst_cfg); /* Prevent a double-call leaking memory via ast_strdup */
3332
3333 dst_cfg->enabled = src_cfg->enabled;
3334 dst_cfg->verify = src_cfg->verify;
3335 dst_cfg->rekey = src_cfg->rekey;
3336 dst_cfg->suite = src_cfg->suite;
3337 dst_cfg->hash = src_cfg->hash;
3338 dst_cfg->ephemeral_cert = src_cfg->ephemeral_cert;
3339 dst_cfg->certfile = ast_strdup(src_cfg->certfile);
3340 dst_cfg->pvtfile = ast_strdup(src_cfg->pvtfile);
3341 dst_cfg->cipher = ast_strdup(src_cfg->cipher);
3342 dst_cfg->cafile = ast_strdup(src_cfg->cafile);
3343 dst_cfg->capath = ast_strdup(src_cfg->capath);
3344 dst_cfg->default_setup = src_cfg->default_setup;
3345}
3346
3348{
3349 ast_free(dtls_cfg->certfile);
3350 dtls_cfg->certfile = NULL;
3351 ast_free(dtls_cfg->pvtfile);
3352 dtls_cfg->pvtfile = NULL;
3353 ast_free(dtls_cfg->cipher);
3354 dtls_cfg->cipher = NULL;
3355 ast_free(dtls_cfg->cafile);
3356 dtls_cfg->cafile = NULL;
3357 ast_free(dtls_cfg->capath);
3358 dtls_cfg->capath = NULL;
3359}
3360
3361/*! \internal
3362 * \brief Small helper routine that cleans up entry i in
3363 * \c ast_rtp_mime_types.
3364 */
3366{
3367 ao2_cleanup(ast_rtp_mime_types[i].payload_type.format);
3368 memset(&ast_rtp_mime_types[i], 0, sizeof(struct ast_rtp_mime_type));
3369}
3370
3371static void set_next_mime_type(struct ast_format *format, int rtp_code, const char *type, const char *subtype, unsigned int sample_rate)
3372{
3373 int x;
3374
3376
3377 x = mime_types_len;
3378 if (ARRAY_LEN(ast_rtp_mime_types) <= x) {
3380 return;
3381 }
3382
3383 /* Make sure any previous value in ast_rtp_mime_types is cleaned up */
3384 memset(&ast_rtp_mime_types[x], 0, sizeof(struct ast_rtp_mime_type));
3385 if (format) {
3388 } else {
3390 }
3392 ast_copy_string(ast_rtp_mime_types[x].subtype, subtype, sizeof(ast_rtp_mime_types[x].subtype));
3393 ast_rtp_mime_types[x].sample_rate = sample_rate;
3395
3397}
3398
3399static void add_static_payload(int payload, struct ast_format *format, int rtp_code)
3400{
3401 struct ast_rtp_payload_type *type;
3402
3403 /*
3404 * ARRAY_LEN's result is cast to an int so 'map' is not autocast to a size_t,
3405 * which if negative would cause an assertion.
3406 */
3408
3409 if (ast_option_rtpusedynamic && payload < 0) {
3410 /*
3411 * We're going to build dynamic payloads dynamically. An RTP code is
3412 * required otherwise one will be dynamically allocated per instance.
3413 */
3414 return;
3415 }
3416
3417 /*
3418 * Either the given payload is truly a static type, or Asterisk is
3419 * globally storing the dynamic payloads in the static_RTP_PT object.
3420 */
3422
3423 if (payload < 0) {
3424 /*
3425 * This is a dynamic payload that will be stored globally,
3426 * so find the next available empty slot.
3427 */
3429 if (payload < 0) {
3430 ast_log(LOG_WARNING, "No dynamic RTP payload type values available "
3431 "for %s - %d!\n", format ? ast_format_get_name(format) : "", rtp_code);
3433 return;
3434 }
3435 }
3436
3438 if (type) {
3441 }
3443}
3444
3446{
3447 char *codec_name = ast_strdupa(ast_format_get_codec_name(format));
3448
3449 codec_name = ast_str_to_upper(codec_name);
3450
3452 0,
3454 codec_name,
3456 add_static_payload(-1, format, 0);
3457
3458 return 0;
3459}
3460
3462{
3463 int x;
3464 int y = 0;
3465
3467 /* remove everything pertaining to this format id from the lists */
3468 for (x = 0; x < AST_RTP_MAX_PT; x++) {
3469 if (static_RTP_PT[x]
3471 ao2_ref(static_RTP_PT[x], -1);
3472 static_RTP_PT[x] = NULL;
3473 }
3474 }
3476
3478 /* rebuild the list skipping the items matching this id */
3479 for (x = 0; x < mime_types_len; x++) {
3480 if (ast_format_cmp(ast_rtp_mime_types[x].payload_type.format, format) == AST_FORMAT_CMP_EQUAL) {
3482 continue;
3483 }
3484 if (x != y) {
3486 }
3487 y++;
3488 }
3489 mime_types_len = y;
3491 return 0;
3492}
3493
3494/*!
3495 * \internal
3496 * \brief \ref stasis message payload for RTCP messages
3497 */
3499 struct ast_channel_snapshot *snapshot; /*< The channel snapshot, if available */
3500 struct ast_rtp_rtcp_report *report; /*< The RTCP report */
3501 struct ast_json *blob; /*< Extra JSON data to publish */
3502};
3503
3504static void rtcp_message_payload_dtor(void *obj)
3505{
3506 struct rtcp_message_payload *payload = obj;
3507
3508 ao2_cleanup(payload->report);
3509 ao2_cleanup(payload->snapshot);
3510 ast_json_unref(payload->blob);
3511}
3512
3514{
3515 struct rtcp_message_payload *payload = stasis_message_data(msg);
3516 RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
3517 RAII_VAR(struct ast_str *, packet_string, ast_str_create(512), ast_free);
3518 unsigned int ssrc = payload->report->ssrc;
3519 unsigned int type = payload->report->type;
3520 unsigned int report_count = payload->report->reception_report_count;
3521 int i;
3522
3523 if (!packet_string) {
3524 return NULL;
3525 }
3526
3527 if (payload->snapshot) {
3528 channel_string = ast_manager_build_channel_state_string(payload->snapshot);
3529 if (!channel_string) {
3530 return NULL;
3531 }
3532 }
3533
3534 if (payload->blob) {
3535 /* Optional data */
3536 struct ast_json *to = ast_json_object_get(payload->blob, "to");
3537 struct ast_json *from = ast_json_object_get(payload->blob, "from");
3538 struct ast_json *rtt = ast_json_object_get(payload->blob, "rtt");
3539 struct ast_json *mes = ast_json_object_get(payload->blob, "mes");
3540 if (to) {
3541 ast_str_append(&packet_string, 0, "To: %s\r\n", ast_json_string_get(to));
3542 }
3543 if (from) {
3544 ast_str_append(&packet_string, 0, "From: %s\r\n", ast_json_string_get(from));
3545 }
3546 if (rtt) {
3547 ast_str_append(&packet_string, 0, "RTT: %4.4f\r\n", ast_json_real_get(rtt));
3548 }
3549 if (mes) {
3550 ast_str_append(&packet_string, 0, "MES: %4.1f\r\n", ast_json_real_get(mes));
3551 }
3552 }
3553
3554 ast_str_append(&packet_string, 0, "SSRC: 0x%.8x\r\n", ssrc);
3555 ast_str_append(&packet_string, 0, "PT: %u(%s)\r\n", type, type== AST_RTP_RTCP_SR ? "SR" : "RR");
3556 ast_str_append(&packet_string, 0, "ReportCount: %u\r\n", report_count);
3557 if (type == AST_RTP_RTCP_SR) {
3558 ast_str_append(&packet_string, 0, "SentNTP: %lu.%06lu\r\n",
3559 (unsigned long)payload->report->sender_information.ntp_timestamp.tv_sec,
3560 (unsigned long)payload->report->sender_information.ntp_timestamp.tv_usec);
3561 ast_str_append(&packet_string, 0, "SentRTP: %u\r\n",
3563 ast_str_append(&packet_string, 0, "SentPackets: %u\r\n",
3565 ast_str_append(&packet_string, 0, "SentOctets: %u\r\n",
3567 }
3568
3569 for (i = 0; i < report_count; i++) {
3570 RAII_VAR(struct ast_str *, report_string, NULL, ast_free);
3571
3572 if (!payload->report->report_block[i]) {
3573 break;
3574 }
3575
3576 report_string = ast_str_create(256);
3577 if (!report_string) {
3578 return NULL;
3579 }
3580
3581 ast_str_append(&report_string, 0, "Report%dSourceSSRC: 0x%.8x\r\n",
3582 i, payload->report->report_block[i]->source_ssrc);
3583 ast_str_append(&report_string, 0, "Report%dFractionLost: %d\r\n",
3584 i, payload->report->report_block[i]->lost_count.fraction);
3585 ast_str_append(&report_string, 0, "Report%dCumulativeLost: %u\r\n",
3586 i, payload->report->report_block[i]->lost_count.packets);
3587 ast_str_append(&report_string, 0, "Report%dHighestSequence: %u\r\n",
3588 i, payload->report->report_block[i]->highest_seq_no & 0xffff);
3589 ast_str_append(&report_string, 0, "Report%dSequenceNumberCycles: %u\r\n",
3590 i, payload->report->report_block[i]->highest_seq_no >> 16);
3591 ast_str_append(&report_string, 0, "Report%dIAJitter: %u\r\n",
3592 i, payload->report->report_block[i]->ia_jitter);
3593 ast_str_append(&report_string, 0, "Report%dLSR: %u\r\n",
3594 i, payload->report->report_block[i]->lsr);
3595 ast_str_append(&report_string, 0, "Report%dDLSR: %4.4f\r\n",
3596 i, ((double)payload->report->report_block[i]->dlsr) / 65536);
3597 ast_str_append(&packet_string, 0, "%s", ast_str_buffer(report_string));
3598 }
3599
3601 stasis_message_type(msg) == ast_rtp_rtcp_received_type() ? "RTCPReceived" : "RTCPSent",
3602 "%s%s",
3603 AS_OR(channel_string, ""),
3604 ast_str_buffer(packet_string));
3605}
3606
3608 const struct stasis_message_sanitizer *sanitize)
3609{
3610 struct rtcp_message_payload *payload = stasis_message_data(msg);
3611 struct ast_json *json_rtcp_report = NULL;
3612 struct ast_json *json_rtcp_report_blocks;
3613 struct ast_json *json_rtcp_sender_info = NULL;
3614 struct ast_json *json_channel = NULL;
3615 int i;
3616
3617 json_rtcp_report_blocks = ast_json_array_create();
3618 if (!json_rtcp_report_blocks) {
3619 return NULL;
3620 }
3621
3622 for (i = 0; i < payload->report->reception_report_count && payload->report->report_block[i]; i++) {
3623 struct ast_json *json_report_block;
3624 char str_lsr[32];
3625
3626 snprintf(str_lsr, sizeof(str_lsr), "%u", payload->report->report_block[i]->lsr);
3627 json_report_block = ast_json_pack("{s: I, s: I, s: I, s: I, s: I, s: s, s: I}",
3628 "source_ssrc", (ast_json_int_t)payload->report->report_block[i]->source_ssrc,
3629 "fraction_lost", (ast_json_int_t)payload->report->report_block[i]->lost_count.fraction,
3630 "packets_lost", (ast_json_int_t)payload->report->report_block[i]->lost_count.packets,
3631 "highest_seq_no", (ast_json_int_t)payload->report->report_block[i]->highest_seq_no,
3632 "ia_jitter", (ast_json_int_t)payload->report->report_block[i]->ia_jitter,
3633 "lsr", str_lsr,
3634 "dlsr", (ast_json_int_t)payload->report->report_block[i]->dlsr);
3635 if (!json_report_block
3636 || ast_json_array_append(json_rtcp_report_blocks, json_report_block)) {
3637 ast_json_unref(json_rtcp_report_blocks);
3638 return NULL;
3639 }
3640 }
3641
3642 if (payload->report->type == AST_RTP_RTCP_SR) {
3643 char sec[32];
3644 char usec[32];
3645
3646 snprintf(sec, sizeof(sec), "%lu", (unsigned long)payload->report->sender_information.ntp_timestamp.tv_sec);
3647 snprintf(usec, sizeof(usec), "%lu", (unsigned long)payload->report->sender_information.ntp_timestamp.tv_usec);
3648 json_rtcp_sender_info = ast_json_pack("{s: s, s: s, s: I, s: I, s: I}",
3649 "ntp_timestamp_sec", sec,
3650 "ntp_timestamp_usec", usec,
3651 "rtp_timestamp", (ast_json_int_t)payload->report->sender_information.rtp_timestamp,
3654 if (!json_rtcp_sender_info) {
3655 ast_json_unref(json_rtcp_report_blocks);
3656 return NULL;
3657 }
3658 }
3659
3660 json_rtcp_report = ast_json_pack("{s: I, s: I, s: i, s: o, s: o}",
3661 "ssrc", (ast_json_int_t)payload->report->ssrc,
3662 "type", (ast_json_int_t)payload->report->type,
3663 "report_count", payload->report->reception_report_count,
3664 "sender_information", json_rtcp_sender_info ?: ast_json_null(),
3665 "report_blocks", json_rtcp_report_blocks);
3666 if (!json_rtcp_report) {
3667 return NULL;
3668 }
3669
3670 if (payload->snapshot) {
3671 json_channel = ast_channel_snapshot_to_json(payload->snapshot, sanitize);
3672 if (!json_channel) {
3673 ast_json_unref(json_rtcp_report);
3674 return NULL;
3675 }
3676 }
3677
3678 return ast_json_pack("{s: s, s: o?, s: o, s: O?}",
3679 "type", stasis_message_type(msg) == ast_rtp_rtcp_received_type() ? "RTCPReceived" : "RTCPSent",
3680 "channel", json_channel,
3681 "rtcp_report", json_rtcp_report,
3682 "blob", payload->blob);
3683}
3684
3685static void rtp_rtcp_report_dtor(void *obj)
3686{
3687 int i;
3688 struct ast_rtp_rtcp_report *rtcp_report = obj;
3689
3690 for (i = 0; i < rtcp_report->reception_report_count; i++) {
3691 ast_free(rtcp_report->report_block[i]);
3692 }
3693}
3694
3695struct ast_rtp_rtcp_report *ast_rtp_rtcp_report_alloc(unsigned int report_blocks)
3696{
3697 struct ast_rtp_rtcp_report *rtcp_report;
3698
3699 /* Size of object is sizeof the report + the number of report_blocks * sizeof pointer */
3700 rtcp_report = ao2_alloc((sizeof(*rtcp_report) + report_blocks * sizeof(struct ast_rtp_rtcp_report_block *)),
3702
3703 return rtcp_report;
3704}
3705
3707 struct stasis_message_type *message_type,
3708 struct ast_rtp_rtcp_report *report,
3709 struct ast_json *blob)
3710{
3711 RAII_VAR(struct rtcp_message_payload *, payload, NULL, ao2_cleanup);
3713
3714 if (!message_type) {
3715 return;
3716 }
3717
3718 payload = ao2_alloc(sizeof(*payload), rtcp_message_payload_dtor);
3719 if (!payload || !report) {
3720 return;
3721 }
3722
3723 if (!ast_strlen_zero(rtp->channel_uniqueid)) {
3724 payload->snapshot = ast_channel_snapshot_get_latest(rtp->channel_uniqueid);
3725 }
3726 if (blob) {
3727 payload->blob = blob;
3728 ast_json_ref(blob);
3729 }
3730 ao2_ref(report, +1);
3731 payload->report = report;
3732
3733 message = stasis_message_create(message_type, payload);
3734 if (!message) {
3735 return;
3736 }
3737
3739}
3740
3741/*!
3742 * @{ \brief Define RTCP/RTP message types.
3743 */
3746 .to_json = rtcp_report_to_json,);
3749 .to_json = rtcp_report_to_json,);
3750/*! @} */
3751
3753{
3754 return rtp_topic;
3755}
3756
3757static uintmax_t debug_category_rtp_id;
3758
3760{
3761 return debug_category_rtp_id;
3762}
3763
3765
3770
3771static uintmax_t debug_category_rtcp_id;
3772
3774{
3776}
3777
3779
3784
3785static uintmax_t debug_category_dtls_id;
3786
3788{
3790}
3791
3793
3798
3799static uintmax_t debug_category_ice_id;
3800
3802{
3803 return debug_category_ice_id;
3804}
3805
3806/*!
3807 * \internal
3808 * \brief Shutdown the RTP engine
3809 * This function will not get called if any module fails to unload.
3810 */
3811static void rtp_engine_shutdown(void)
3812{
3813 int x;
3814
3816 rtp_topic = NULL;
3819
3821 for (x = 0; x < AST_RTP_MAX_PT; x++) {
3823 static_RTP_PT[x] = NULL;
3824 }
3826
3828 for (x = 0; x < mime_types_len; x++) {
3829 if (ast_rtp_mime_types[x].payload_type.format) {
3831 }
3832 }
3833 mime_types_len = 0;
3835}
3836
3837/*!
3838 * \internal
3839 * \brief Unregister the debug categories
3840 * This function will always get called even if any module fails to unload.
3841 */
3855
3857{
3860
3861 rtp_topic = stasis_topic_create("rtp:all");
3862 if (!rtp_topic) {
3863 return -1;
3864 }
3868
3869 /* Define all the RTP mime types available */
3870 set_next_mime_type(ast_format_g723, 0, "audio", "G723", 8000);
3871 set_next_mime_type(ast_format_gsm, 0, "audio", "GSM", 8000);
3872 set_next_mime_type(ast_format_ulaw, 0, "audio", "PCMU", 8000);
3873 set_next_mime_type(ast_format_ulaw, 0, "audio", "G711U", 8000);
3874 set_next_mime_type(ast_format_alaw, 0, "audio", "PCMA", 8000);
3875 set_next_mime_type(ast_format_alaw, 0, "audio", "G711A", 8000);
3876 set_next_mime_type(ast_format_g726, 0, "audio", "G726-32", 8000);
3877 set_next_mime_type(ast_format_adpcm, 0, "audio", "DVI4", 8000);
3878 set_next_mime_type(ast_format_slin, 0, "audio", "L16", 8000);
3879 set_next_mime_type(ast_format_slin16, 0, "audio", "L16", 16000);
3880 set_next_mime_type(ast_format_slin16, 0, "audio", "L16-256", 16000);
3881 set_next_mime_type(ast_format_slin12, 0, "audio", "L16", 12000);
3882 set_next_mime_type(ast_format_slin24, 0, "audio", "L16", 24000);
3883 set_next_mime_type(ast_format_slin32, 0, "audio", "L16", 32000);
3884 set_next_mime_type(ast_format_slin44, 0, "audio", "L16", 44100);
3885 set_next_mime_type(ast_format_slin48, 0, "audio", "L16", 48000);
3886 set_next_mime_type(ast_format_slin96, 0, "audio", "L16", 96000);
3887 set_next_mime_type(ast_format_slin192, 0, "audio", "L16", 192000);
3888 set_next_mime_type(ast_format_lpc10, 0, "audio", "LPC", 8000);
3889 set_next_mime_type(ast_format_g729, 0, "audio", "G729", 8000);
3890 set_next_mime_type(ast_format_g729, 0, "audio", "G729A", 8000);
3891 set_next_mime_type(ast_format_g729, 0, "audio", "G.729", 8000);
3892 set_next_mime_type(ast_format_speex, 0, "audio", "speex", 8000);
3893 set_next_mime_type(ast_format_speex16, 0, "audio", "speex", 16000);
3894 set_next_mime_type(ast_format_speex32, 0, "audio", "speex", 32000);
3895 set_next_mime_type(ast_format_ilbc, 0, "audio", "iLBC", 8000);
3896 /* this is the sample rate listed in the RTP profile for the G.722 codec, *NOT* the actual sample rate of the media stream */
3897 set_next_mime_type(ast_format_g722, 0, "audio", "G722", 8000);
3898 set_next_mime_type(ast_format_g726_aal2, 0, "audio", "AAL2-G726-32", 8000);
3899 /* we need all possible dtmf/bitrate combinations or ast_rtp_codecs_payloads_set_rtpmap_type_rate will not examine it */
3900 set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 8000);
3901 set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 16000);
3902 set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 24000);
3903 set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 32000);
3904 set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 48000);
3905 set_next_mime_type(NULL, AST_RTP_CISCO_DTMF, "audio", "cisco-telephone-event", 8000);
3906 set_next_mime_type(NULL, AST_RTP_CN, "audio", "CN", 8000);
3907 set_next_mime_type(ast_format_jpeg, 0, "video", "JPEG", 90000);
3908 set_next_mime_type(ast_format_png, 0, "video", "PNG", 90000);
3909 set_next_mime_type(ast_format_h261, 0, "video", "H261", 90000);
3910 set_next_mime_type(ast_format_h263, 0, "video", "H263", 90000);
3911 set_next_mime_type(ast_format_h263p, 0, "video", "h263-1998", 90000);
3912 set_next_mime_type(ast_format_h264, 0, "video", "H264", 90000);
3913 set_next_mime_type(ast_format_h265, 0, "video", "H265", 90000);
3914 set_next_mime_type(ast_format_mp4, 0, "video", "MP4V-ES", 90000);
3915 set_next_mime_type(ast_format_t140_red, 0, "text", "RED", 1000);
3916 set_next_mime_type(ast_format_t140, 0, "text", "T140", 1000);
3917 set_next_mime_type(ast_format_siren7, 0, "audio", "G7221", 16000);
3918 set_next_mime_type(ast_format_siren14, 0, "audio", "G7221", 32000);
3919 set_next_mime_type(ast_format_g719, 0, "audio", "G719", 48000);
3920 /* Opus, VP8, and VP9 */
3921 set_next_mime_type(ast_format_opus, 0, "audio", "opus", 48000);
3922 set_next_mime_type(ast_format_vp8, 0, "video", "VP8", 90000);
3923 set_next_mime_type(ast_format_vp9, 0, "video", "VP9", 90000);
3924
3925 /* Define the static rtp payload mappings */
3927 #ifdef USE_DEPRECATED_G726
3928 add_static_payload(2, ast_format_g726, 0);/* Technically this is G.721, but if Cisco can do it, so can we... */
3929 #endif
3932 add_static_payload(5, ast_format_adpcm, 0);/* 8 kHz */
3933 add_static_payload(6, ast_format_adpcm, 0); /* 16 kHz */
3937 add_static_payload(10, ast_format_slin, 0); /* 2 channels */
3938 add_static_payload(11, ast_format_slin, 0); /* 1 channel */
3940 add_static_payload(16, ast_format_adpcm, 0); /* 11.025 kHz */
3941 add_static_payload(17, ast_format_adpcm, 0); /* 22.050 kHz */
3943 add_static_payload(19, NULL, AST_RTP_CN); /* Also used for CN */
3947
3948 /*
3949 * Dynamic payload types - Even when dynamically assigning them we'll fall
3950 * back to using the statically declared values as the default number.
3951 */
3954
3961 add_static_payload(105, ast_format_t140_red, 0); /* Real time text chat (with redundancy encoding) */
3962 add_static_payload(106, ast_format_t140, 0); /* Real time text chat */
3966
3970
3974 add_static_payload(118, ast_format_slin16, 0); /* 16 Khz signed linear */
3976
3977 add_static_payload(121, NULL, AST_RTP_CISCO_DTMF); /* Must be type 121 */
3984 /* payload types above 127 are not valid */
3985
3993
3994 /*
3995 * Normnally a core module should call ast_register_cleanup,
3996 * which doesn't run if any module fails to unload. This
3997 * prevents resources being pulled out from under a running
3998 * module and possibly causing a segfault. In this case however,
3999 * the only thing we're cleaning up are the registrations of the
4000 * debug categories.
4001 */
4003
4004 return 0;
4005}
4006
4008{
4009 return rtp->last_tx;
4010}
4011
4013{
4014 rtp->last_tx = time;
4015}
4016
4018{
4019 return rtp->last_rx;
4020}
4021
4023{
4024 rtp->last_rx = time;
4025}
4026
4028{
4029 unsigned int ssrc = 0;
4030
4031 ao2_lock(rtp);
4032 if (rtp->engine->ssrc_get) {
4033 ssrc = rtp->engine->ssrc_get(rtp);
4034 }
4035 ao2_unlock(rtp);
4036
4037 return ssrc;
4038}
4039
4041{
4042 const char *cname = "";
4043
4044 ao2_lock(rtp);
4045 if (rtp->engine->cname_get) {
4046 cname = rtp->engine->cname_get(rtp);
4047 }
4048 ao2_unlock(rtp);
4049
4050 return cname;
4051}
4052
4054{
4055 int res = -1;
4056
4057 if (parent && (child->engine != parent->engine)) {
4058 return -1;
4059 }
4060
4061 ao2_lock(child);
4062 if (child->engine->bundle) {
4063 res = child->engine->bundle(child, parent);
4064 }
4065 ao2_unlock(child);
4066
4067 return res;
4068}
4069
4070void ast_rtp_instance_set_remote_ssrc(struct ast_rtp_instance *rtp, unsigned int ssrc)
4071{
4072 ao2_lock(rtp);
4073 if (rtp->engine->set_remote_ssrc) {
4074 rtp->engine->set_remote_ssrc(rtp, ssrc);
4075 }
4076 ao2_unlock(rtp);
4077}
4078
4079void ast_rtp_instance_set_stream_num(struct ast_rtp_instance *rtp, int stream_num)
4080{
4081 ao2_lock(rtp);
4082 if (rtp->engine->set_stream_num) {
4083 rtp->engine->set_stream_num(rtp, stream_num);
4084 }
4085 ao2_unlock(rtp);
4086}
4087
4088#ifdef TEST_FRAMEWORK
4089size_t ast_rtp_instance_get_recv_buffer_max(struct ast_rtp_instance *instance)
4090{
4091 size_t res;
4092 struct ast_rtp_engine_test *test = ast_rtp_instance_get_test(instance);
4093
4094 if (!test) {
4095 ast_log(LOG_ERROR, "There is no test engine set up!\n");
4096 return 0;
4097 }
4098
4099 ao2_lock(instance);
4100 res = test->recv_buffer_max(instance);
4101 ao2_unlock(instance);
4102
4103 return res;
4104}
4105
4106size_t ast_rtp_instance_get_recv_buffer_count(struct ast_rtp_instance *instance)
4107{
4108 size_t res;
4109 struct ast_rtp_engine_test *test = ast_rtp_instance_get_test(instance);
4110
4111 if (!test) {
4112 ast_log(LOG_ERROR, "There is no test engine set up!\n");
4113 return 0;
4114 }
4115
4116 ao2_lock(instance);
4117 res = test->recv_buffer_count(instance);
4118 ao2_unlock(instance);
4119
4120 return res;
4121}
4122
4123size_t ast_rtp_instance_get_send_buffer_count(struct ast_rtp_instance *instance)
4124{
4125 size_t res;
4126 struct ast_rtp_engine_test *test = ast_rtp_instance_get_test(instance);
4127
4128 if (!test) {
4129 ast_log(LOG_ERROR, "There is no test engine set up!\n");
4130 return 0;
4131 }
4132
4133 ao2_lock(instance);
4134 res = test->send_buffer_count(instance);
4135 ao2_unlock(instance);
4136
4137 return res;
4138}
4139
4140void ast_rtp_instance_set_schedid(struct ast_rtp_instance *instance, int id)
4141{
4142 struct ast_rtp_engine_test *test = ast_rtp_instance_get_test(instance);
4143
4144 if (!test) {
4145 ast_log(LOG_ERROR, "There is no test engine set up!\n");
4146 return;
4147 }
4148
4149 ao2_lock(instance);
4150 test->set_schedid(instance, id);
4151 ao2_unlock(instance);
4152}
4153
4154void ast_rtp_instance_drop_packets(struct ast_rtp_instance *instance, int num)
4155{
4156 struct ast_rtp_engine_test *test = ast_rtp_instance_get_test(instance);
4157
4158 if (!test) {
4159 ast_log(LOG_ERROR, "There is no test engine set up!\n");
4160 return;
4161 }
4162
4163 test->packets_to_drop = num;
4164}
4165
4166void ast_rtp_instance_queue_report(struct ast_rtp_instance *instance)
4167{
4168 struct ast_rtp_engine_test *test = ast_rtp_instance_get_test(instance);
4169
4170 if (!test) {
4171 ast_log(LOG_ERROR, "There is no test engine set up!\n");
4172 return;
4173 }
4174
4175 test->send_report = 1;
4176}
4177
4178int ast_rtp_instance_get_sdes_received(struct ast_rtp_instance *instance)
4179{
4180 struct ast_rtp_engine_test *test = ast_rtp_instance_get_test(instance);
4181
4182 if (!test) {
4183 ast_log(LOG_ERROR, "There is no test engine set up!\n");
4184 return 0;
4185 }
4186
4187 return test->sdes_received;
4188}
4189
4190void ast_rtp_instance_reset_test_engine(struct ast_rtp_instance *instance)
4191{
4192 struct ast_rtp_engine_test *test = ast_rtp_instance_get_test(instance);
4193
4194 if (!test) {
4195 ast_log(LOG_ERROR, "There is no test engine set up!\n");
4196 return;
4197 }
4198
4199 test->packets_to_drop = 0;
4200 test->send_report = 0;
4201 test->sdes_received = 0;
4202}
4203#endif
4204
4206{
4207 struct ast_json *j_res;
4208 int ret;
4209
4210 j_res = ast_json_object_create();
4211 if (!j_res) {
4212 return NULL;
4213 }
4214
4215 /* set mandatory items */
4216 ret = ast_json_object_set(j_res, "txcount", ast_json_integer_create(stats->txcount));
4217 ret |= ast_json_object_set(j_res, "rxcount", ast_json_integer_create(stats->rxcount));
4218
4219 ret |= ast_json_object_set(j_res, "txploss", ast_json_integer_create(stats->txploss));
4220 ret |= ast_json_object_set(j_res, "rxploss", ast_json_integer_create(stats->rxploss));
4221
4222 ret |= ast_json_object_set(j_res, "local_ssrc", ast_json_integer_create(stats->local_ssrc));
4223 ret |= ast_json_object_set(j_res, "remote_ssrc", ast_json_integer_create(stats->remote_ssrc));
4224
4225 ret |= ast_json_object_set(j_res, "txoctetcount", ast_json_integer_create(stats->txoctetcount));
4226 ret |= ast_json_object_set(j_res, "rxoctetcount", ast_json_integer_create(stats->rxoctetcount));
4227
4228 ret |= ast_json_object_set(j_res, "channel_uniqueid", ast_json_string_create(stats->channel_uniqueid));
4229 if (ret) {
4230 ast_log(LOG_WARNING, "Could not create rtp statistics info. channel: %s\n", stats->channel_uniqueid);
4231 ast_json_unref(j_res);
4232 return NULL;
4233 }
4234
4235 /* set other items */
4236 SET_AST_JSON_OBJ(j_res, "txjitter", ast_json_real_create(stats->txjitter));
4237 SET_AST_JSON_OBJ(j_res, "rxjitter", ast_json_real_create(stats->rxjitter));
4238
4239 SET_AST_JSON_OBJ(j_res, "remote_maxjitter", ast_json_real_create(stats->remote_maxjitter));
4240 SET_AST_JSON_OBJ(j_res, "remote_minjitter", ast_json_real_create(stats->remote_minjitter));
4241 SET_AST_JSON_OBJ(j_res, "remote_normdevjitter", ast_json_real_create(stats->remote_normdevjitter));
4242 SET_AST_JSON_OBJ(j_res, "remote_stdevjitter", ast_json_real_create(stats->remote_stdevjitter));
4243
4244 SET_AST_JSON_OBJ(j_res, "local_maxjitter", ast_json_real_create(stats->local_maxjitter));
4245 SET_AST_JSON_OBJ(j_res, "local_minjitter", ast_json_real_create(stats->local_minjitter));
4246 SET_AST_JSON_OBJ(j_res, "local_normdevjitter", ast_json_real_create(stats->local_normdevjitter));
4247 SET_AST_JSON_OBJ(j_res, "local_stdevjitter", ast_json_real_create(stats->local_stdevjitter));
4248
4249 SET_AST_JSON_OBJ(j_res, "remote_maxrxploss", ast_json_real_create(stats->remote_maxrxploss));
4250 SET_AST_JSON_OBJ(j_res, "remote_minrxploss", ast_json_real_create(stats->remote_minrxploss));
4251 SET_AST_JSON_OBJ(j_res, "remote_normdevrxploss", ast_json_real_create(stats->remote_normdevrxploss));
4252 SET_AST_JSON_OBJ(j_res, "remote_stdevrxploss", ast_json_real_create(stats->remote_stdevrxploss));
4253
4254 SET_AST_JSON_OBJ(j_res, "local_maxrxploss", ast_json_real_create(stats->local_maxrxploss));
4255 SET_AST_JSON_OBJ(j_res, "local_minrxploss", ast_json_real_create(stats->local_minrxploss));
4256 SET_AST_JSON_OBJ(j_res, "local_normdevrxploss", ast_json_real_create(stats->local_normdevrxploss));
4257 SET_AST_JSON_OBJ(j_res, "local_stdevrxploss", ast_json_real_create(stats->local_stdevrxploss));
4258
4259 SET_AST_JSON_OBJ(j_res, "rtt", ast_json_real_create(stats->rtt));
4260 SET_AST_JSON_OBJ(j_res, "maxrtt", ast_json_real_create(stats->maxrtt));
4261 SET_AST_JSON_OBJ(j_res, "minrtt", ast_json_real_create(stats->minrtt));
4262 SET_AST_JSON_OBJ(j_res, "normdevrtt", ast_json_real_create(stats->normdevrtt));
4263 SET_AST_JSON_OBJ(j_res, "stdevrtt", ast_json_real_create(stats->stdevrtt));
4264
4265 SET_AST_JSON_OBJ(j_res, "txmes", ast_json_integer_create(stats->txmes));
4266 SET_AST_JSON_OBJ(j_res, "rxmes", ast_json_integer_create(stats->rxmes));
4267
4268 SET_AST_JSON_OBJ(j_res, "remote_maxmes", ast_json_real_create(stats->remote_maxmes));
4269 SET_AST_JSON_OBJ(j_res, "remote_minmes", ast_json_real_create(stats->remote_minmes));
4270 SET_AST_JSON_OBJ(j_res, "remote_normdevmes", ast_json_real_create(stats->remote_normdevmes));
4271 SET_AST_JSON_OBJ(j_res, "remote_stdevmes", ast_json_real_create(stats->remote_stdevmes));
4272
4273 SET_AST_JSON_OBJ(j_res, "local_maxmes", ast_json_real_create(stats->local_maxmes));
4274 SET_AST_JSON_OBJ(j_res, "local_minmes", ast_json_real_create(stats->local_minmes));
4275 SET_AST_JSON_OBJ(j_res, "local_normdevmes", ast_json_real_create(stats->local_normdevmes));
4276 SET_AST_JSON_OBJ(j_res, "local_stdevmes", ast_json_real_create(stats->local_stdevmes));
4277
4278 return j_res;
4279}
4280
4282{
4283 struct ast_rtp_instance_stats stats = {0,};
4284
4286 return NULL;
4287 }
4288
4289 return ast_rtp_convert_stats_json(&stats);
4290}
4291
4292int ast_rtp_get_rate(const struct ast_format *format)
4293{
4294 /* For those wondering: due to a fluke in RFC publication, G.722 is advertised
4295 * as having a sample rate of 8kHz, while implementations must know that its
4296 * real rate is 16kHz. Seriously.
4297 */
4298 return (ast_format_cmp(format, ast_format_g722) == AST_FORMAT_CMP_EQUAL) ? 8000 : (int)ast_format_get_sample_rate(format);
4299}
Prototypes for public functions only of internal interest,.
char digit
enum queue_result id
Definition app_queue.c:1767
Asterisk main include file. File version handling, generic pbx functions.
int ast_register_cleanup(void(*func)(void))
Register a function to be executed before Asterisk gracefully exits.
Definition clicompat.c:19
int ast_register_atexit(void(*func)(void))
Register a function to be executed before Asterisk exits.
Definition clicompat.c:13
#define ast_free(a)
Definition astmm.h:180
#define ast_strdup(str)
A wrapper for strdup()
Definition astmm.h:241
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition astmm.h:298
#define ast_log
Definition astobj2.c:42
@ AO2_ALLOC_OPT_LOCK_NOLOCK
Definition astobj2.h:367
#define ao2_cleanup(obj)
Definition astobj2.h:1934
#define ao2_unlock(a)
Definition astobj2.h:729
#define ao2_replace(dst, src)
Replace one object reference with another cleaning up the original.
Definition astobj2.h:501
#define ao2_lock(a)
Definition astobj2.h:717
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition astobj2.h:459
#define ao2_alloc_options(data_size, destructor_fn, options)
Definition astobj2.h:404
#define ao2_t_cleanup(obj, tag)
Definition astobj2.h:1935
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition astobj2.h:480
#define ao2_alloc(data_size, destructor_fn)
Definition astobj2.h:409
static const char desc[]
Definition cdr_radius.c:84
static PGresult * result
Definition cel_pgsql.c:84
unsigned int tos
Definition chan_iax2.c:379
unsigned int cos
Definition chan_iax2.c:380
static const char type[]
General Asterisk PBX channel definitions.
const char * ast_channel_name(const struct ast_channel *chan)
struct ast_channel * ast_channel_bridge_peer(struct ast_channel *chan)
Get the channel's bridge peer only if the bridge is two-party.
Definition channel.c:10578
#define ast_channel_lock(chan)
Definition channel.h:2972
#define ast_channel_lock_both(chan1, chan2)
Lock two channels.
Definition channel.h:2979
#define ast_channel_unref(c)
Decrease channel reference count.
Definition channel.h:3008
#define AST_MAX_UNIQUEID
Definition channel.h:170
#define AST_MAX_USER_FIELD
Definition channel.h:176
#define ast_channel_unlock(chan)
Definition channel.h:2973
size_t current
static struct ao2_container * codecs
Registered codecs.
Definition codec.c:48
Codec API.
ast_media_type
Types of media.
Definition codec.h:30
@ AST_MEDIA_TYPE_UNKNOWN
Definition codec.h:31
const char * ast_codec_media_type2str(enum ast_media_type type)
Conversion function to take a media type and turn it into a string.
Definition codec.c:348
static int quality
Definition codec_speex.c:62
char * end
Definition eagi_proxy.c:73
char buf[BUFSIZE]
Definition eagi_proxy.c:66
char * address
Definition f2c.h:59
Media Format API.
enum ast_media_type ast_format_get_type(const struct ast_format *format)
Get the media type of a format.
Definition format.c:354
unsigned int ast_format_get_codec_id(const struct ast_format *format)
Get the codec identifier associated with a format.
Definition format.c:329
unsigned int ast_format_get_sample_rate(const struct ast_format *format)
Get the sample rate of a media format.
Definition format.c:379
enum ast_format_cmp_res ast_format_cmp(const struct ast_format *format1, const struct ast_format *format2)
Compare two formats.
Definition format.c:201
@ AST_FORMAT_CMP_EQUAL
Definition format.h:36
@ AST_FORMAT_CMP_NOT_EQUAL
Definition format.h:38
const char * ast_format_get_name(const struct ast_format *format)
Get the name associated with a format.
Definition format.c:334
const char * ast_format_get_codec_name(const struct ast_format *format)
Get the codec name associated with a format.
Definition format.c:339
struct ast_format * ast_format_parse_sdp_fmtp(const struct ast_format *format, const char *attributes)
This function is used to have a media format aware module parse and interpret SDP attribute informati...
Definition format.c:286
Media Format Cache API.
struct ast_format * ast_format_speex16
Built-in cached speex at 16kHz format.
struct ast_format * ast_format_h264
Built-in cached h264 format.
struct ast_format * ast_format_slin44
Built-in cached signed linear 44kHz format.
struct ast_format * ast_format_adpcm
Built-in cached adpcm format.
struct ast_format * ast_format_slin24
Built-in cached signed linear 24kHz format.
struct ast_format * ast_format_opus
Built-in cached opus format.
struct ast_format * ast_format_h265
Built-in cached h265 format.
struct ast_format * ast_format_gsm
Built-in cached gsm format.
struct ast_format * ast_format_slin32
Built-in cached signed linear 32kHz format.
struct ast_format * ast_format_siren14
Built-in cached siren14 format.
struct ast_format * ast_format_speex
Built-in cached speex format.
struct ast_format * ast_format_h263
Built-in cached h263 format.
struct ast_format * ast_format_mp4
Built-in cached mp4 format.
struct ast_format * ast_format_slin192
Built-in cached signed linear 192kHz format.
struct ast_format * ast_format_ilbc
Built-in cached ilbc format.
struct ast_format * ast_format_g726
Built-in cached g726 format.
struct ast_format * ast_format_ulaw
Built-in cached ulaw format.
struct ast_format * ast_format_lpc10
Built-in cached ilbc format.
struct ast_format * ast_format_slin16
Built-in cached signed linear 16kHz format.
struct ast_format * ast_format_slin96
Built-in cached signed linear 96kHz format.
struct ast_format * ast_format_slin48
Built-in cached signed linear 48kHz format.
struct ast_format * ast_format_g723
Built-in cached g723.1 format.
struct ast_format * ast_format_slin
Built-in cached signed linear 8kHz format.
struct ast_format * ast_format_siren7
Built-in cached siren7 format.
struct ast_format * ast_format_alaw
Built-in cached alaw format.
struct ast_format * ast_format_speex32
Built-in cached speex at 32kHz format.
struct ast_format * ast_format_h261
Built-in cached h261 format.
struct ast_format * ast_format_vp9
Built-in cached vp9 format.
struct ast_format * ast_format_t140_red
Built-in cached t140 red format.
struct ast_format * ast_format_slin12
Built-in cached signed linear 12kHz format.
struct ast_format * ast_format_h263p
Built-in cached h263 plus format.
struct ast_format * ast_format_png
Built-in cached png format.
struct ast_format * ast_format_g722
Built-in cached g722 format.
struct ast_format * ast_format_g726_aal2
Built-in cached g726 aal2 format.
struct ast_format * ast_format_t140
Built-in cached t140 format.
struct ast_format * ast_format_g729
Built-in cached g729 format.
struct ast_format * ast_format_jpeg
Built-in cached jpeg format.
struct ast_format * ast_format_vp8
Built-in cached vp8 format.
struct ast_format * ast_format_g719
Built-in cached g719 format.
Format Capabilities API.
struct ast_format * ast_format_cap_get_format(const struct ast_format_cap *cap, int position)
Get the format at a specific index.
Definition format_cap.c:400
void ast_format_cap_remove_by_type(struct ast_format_cap *cap, enum ast_media_type type)
Remove all formats matching a specific format type.
Definition format_cap.c:523
@ AST_FORMAT_CAP_FLAG_DEFAULT
Definition format_cap.h:38
int ast_format_cap_iscompatible(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2)
Determine if any joint capabilities exist between two capabilities structures.
Definition format_cap.c:653
#define ast_format_cap_append(cap, format, framing)
Add format capability to capabilities structure.
Definition format_cap.h:99
void ast_format_cap_set_framing(struct ast_format_cap *cap, unsigned int framing)
Set the global framing.
Definition format_cap.c:136
#define ast_format_cap_alloc(flags)
Allocate a new ast_format_cap structure.
Definition format_cap.h:49
size_t ast_format_cap_count(const struct ast_format_cap *cap)
Get the number of formats present within the capabilities structure.
Definition format_cap.c:395
static const char name[]
Definition format_mp3.c:68
direction
static int replace(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
struct stasis_message_type * ast_rtp_rtcp_sent_type(void)
Message type for an RTCP message sent from this Asterisk instance.
struct ast_channel_snapshot * ast_channel_snapshot_get_latest(const char *uniqueid)
Obtain the latest ast_channel_snapshot from the Stasis Message Bus API cache. This is an ao2 object,...
void ast_channel_stage_snapshot_done(struct ast_channel *chan)
Clear flag to indicate channel snapshot is being staged, and publish snapshot.
struct stasis_message_type * ast_rtp_rtcp_received_type(void)
Message type for an RTCP message received from some external source.
void ast_channel_stage_snapshot(struct ast_channel *chan)
Set flag to indicate channel snapshot is being staged.
int ast_option_rtpusedynamic
Definition options.c:89
unsigned int ast_option_rtpptdynamic
Definition options.c:90
Support for logging to various files, console and syslog Configuration in file logger....
#define ast_debug(level,...)
Log a DEBUG message.
#define LOG_ERROR
#define ast_verb(level,...)
#define LOG_NOTICE
#define LOG_WARNING
Asterisk JSON abstraction layer.
struct ast_json * ast_json_string_create(const char *value)
Construct a JSON string from value.
Definition json.c:278
struct ast_json * ast_json_null(void)
Get the JSON null value.
Definition json.c:248
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition json.c:73
int ast_json_array_append(struct ast_json *array, struct ast_json *value)
Append to an array.
Definition json.c:378
struct ast_json * ast_json_object_create(void)
Create a new JSON object.
Definition json.c:399
struct ast_json * ast_json_pack(char const *format,...)
Helper for creating complex JSON values.
Definition json.c:612
struct ast_json * ast_json_integer_create(intmax_t value)
Create a JSON integer.
Definition json.c:327
struct ast_json * ast_json_array_create(void)
Create a empty JSON array.
Definition json.c:362
struct ast_json * ast_json_ref(struct ast_json *value)
Increase refcount on value.
Definition json.c:67
int ast_json_object_set(struct ast_json *object, const char *key, struct ast_json *value)
Set a field in a JSON object.
Definition json.c:414
const char * ast_json_string_get(const struct ast_json *string)
Get the value of a JSON string.
Definition json.c:283
struct ast_json * ast_json_object_get(struct ast_json *object, const char *key)
Get a field from a JSON object.
Definition json.c:407
struct ast_json * ast_json_real_create(double value)
Create a JSON real number.
Definition json.c:342
AST_JSON_INT_T ast_json_int_t
Primarily used to cast when packing to an "I" type.
Definition json.h:87
double ast_json_real_get(const struct ast_json *real)
Get the value from a JSON real number.
Definition json.c:347
A set of macros to manage forward-linked lists.
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition linkedlists.h:78
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition linkedlists.h:52
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
#define AST_RWLIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a read/write list of specified type, statically initialized.
#define AST_RWLIST_REMOVE
#define AST_RWLIST_FIRST
#define AST_RWLIST_TRAVERSE
#define AST_RWLIST_INSERT_TAIL
Asterisk locking-related definitions:
#define ast_rwlock_wrlock(a)
Definition lock.h:243
#define ast_rwlock_rdlock(a)
Definition lock.h:242
#define ast_rwlock_init(rwlock)
wrapper for rwlock with tracking enabled
Definition lock.h:231
#define ast_rwlock_destroy(rwlock)
Definition lock.h:240
#define ast_rwlock_unlock(a)
Definition lock.h:241
#define ast_rwlock_tryrdlock(a)
Definition lock.h:244
uintmax_t ast_debug_category_register(const char *name)
Register a debug level logger category.
int ast_debug_category_unregister(const char *name)
Un-register a debug level logger category.
The AMI - Asterisk Manager Interface - is a TCP protocol created to manage Asterisk with third-party ...
#define EVENT_FLAG_REPORTING
Definition manager.h:84
struct ast_str * ast_manager_build_channel_state_string(const struct ast_channel_snapshot *snapshot)
Generate the AMI message body from a channel snapshot.
struct ast_manager_event_blob * ast_manager_event_blob_create(int event_flags, const char *manager_event, const char *extra_fields_fmt,...)
Construct a ast_manager_event_blob.
Definition manager.c:10144
Asterisk module definitions.
#define ast_module_unref(mod)
Release a reference to the module.
Definition module.h:483
#define ast_module_running_ref(mod)
Hold a reference to the module if it is running.
Definition module.h:469
Network socket handling.
static void ast_sockaddr_copy(struct ast_sockaddr *dst, const struct ast_sockaddr *src)
Copies the data from one ast_sockaddr to another.
Definition netsock2.h:167
ast_transport
Definition netsock2.h:59
int ast_sockaddr_cmp(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
Compares two ast_sockaddr structures.
Definition netsock2.c:388
Options provided by main asterisk program.
Core PBX routines and definitions.
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name.
static void to_ami(struct ast_sip_subscription *sub, struct ast_str **buf)
static struct ast_srtp_res srtp_res
Definition res_srtp.c:129
static struct ast_srtp_policy_res policy_res
Definition res_srtp.c:141
SRTP resource.
#define NULL
Definition resample.c:96
uintmax_t ast_debug_category_rtcp_packet_id(void)
void ast_rtp_instance_set_stats_vars(struct ast_channel *chan, struct ast_rtp_instance *instance)
Set standard statistics from an RTP instance on a channel.
unsigned int ast_rtp_lookup_sample_rate2(int asterisk_format, const struct ast_format *format, int code)
Get the sample rate associated with known RTP payload types.
struct stasis_topic * ast_rtp_topic(void)
Stasis Message Bus API topic for RTP and RTCP related messages
struct ast_format * ast_rtp_codecs_get_payload_format(struct ast_rtp_codecs *codecs, int payload)
Retrieve the actual ast_format stored on the codecs structure for a specific tx payload type.
void ast_rtp_instance_get_incoming_source_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address)
Get the incoming source address of the remote endpoint.
Definition rtp_engine.c:693
void ast_rtp_codecs_payloads_destroy(struct ast_rtp_codecs *codecs)
Destroy the contents of an RTP codecs structure (but not the structure itself)
int ast_rtp_instance_destroy(struct ast_rtp_instance *instance)
Destroy an RTP instance.
Definition rtp_engine.c:464
static enum ast_rtp_dtls_connection rtp_dtls_wrap_get_connection(struct ast_rtp_instance *instance)
enum ast_rtp_dtmf_mode ast_rtp_instance_dtmf_mode_get(struct ast_rtp_instance *instance)
Get the DTMF mode of an RTP instance.
int ast_rtp_codecs_payload_set_rx(struct ast_rtp_codecs *codecs, int code, struct ast_format *format)
Set a payload code for use with a specific Asterisk format.
struct ast_srtp_res * res_srtp
Definition rtp_engine.c:182
struct ast_format * ast_rtp_codecs_get_preferred_format(struct ast_rtp_codecs *codecs)
Retrieve rx preferred format.
struct ast_json * ast_rtp_convert_stats_json(const struct ast_rtp_instance_stats *stats)
Convert given stat instance into json format.
uintmax_t ast_debug_category_rtp_packet_id(void)
static void rtp_ice_wrap_turn_request(struct ast_rtp_instance *instance, enum ast_rtp_ice_component_type component, enum ast_transport transport, const char *server, unsigned int port, const char *username, const char *password)
static void rtp_payload_type_dtor(void *obj)
Definition rtp_engine.c:304
struct ast_rtp_glue * ast_rtp_instance_get_active_glue(struct ast_rtp_instance *instance)
Get the RTP glue in use on an RTP instance.
char * ast_rtp_lookup_mime_multiple2(struct ast_str *buf, struct ast_format_cap *ast_format_capability, int rtp_capability, const int asterisk_format, enum ast_rtp_options options)
Convert formats into a string and put them into a buffer.
struct ast_rtp_rtcp_report * ast_rtp_rtcp_report_alloc(unsigned int report_blocks)
Allocate an ao2 ref counted instance of ast_rtp_rtcp_report.
int ast_rtp_instance_get_and_cmp_local_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address)
Get the address of the local endpoint that we are sending RTP to, comparing its address to another.
Definition rtp_engine.c:657
void ast_rtp_instance_early_bridge_make_compatible(struct ast_channel *c_dst, struct ast_channel *c_src)
Make two channels compatible for early bridging.
static struct ast_rtp_engine_ice rtp_ice_wrappers
struct ast_rtp_instance * ast_rtp_instance_new(const char *engine_name, struct ast_sched_context *sched, const struct ast_sockaddr *sa, void *data)
Create a new RTP instance.
Definition rtp_engine.c:493
struct ast_rtp_payload_type * ast_rtp_codecs_get_payload(struct ast_rtp_codecs *codecs, int payload)
Retrieve rx payload mapped information by payload type.
void ast_rtp_instance_set_last_rx(struct ast_rtp_instance *rtp, time_t time)
Set the last RTP reception time.
int ast_rtp_instance_get_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property)
Get the value of an RTP instance property.
Definition rtp_engine.c:744
static uintmax_t debug_category_dtls_packet_id
static const char * rtp_dtls_wrap_get_fingerprint(struct ast_rtp_instance *instance)
int ast_rtp_engine_register_srtp(struct ast_srtp_res *srtp_res, struct ast_srtp_policy_res *policy_res)
int ast_rtp_instance_set_requested_target_address(struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
Set the requested target address of the remote endpoint.
Definition rtp_engine.c:644
uintmax_t ast_debug_category_ice_id(void)
static void rtp_ice_wrap_stop(struct ast_rtp_instance *instance)
int ast_rtp_engine_srtp_is_registered(void)
static void rtp_ice_wrap_add_remote_candidate(struct ast_rtp_instance *instance, const struct ast_rtp_engine_ice_candidate *candidate)
static struct ast_rtp_payload_type * static_RTP_PT[AST_RTP_MAX_PT]
Mapping between Asterisk codecs and rtp payload types.
Definition rtp_engine.c:279
static const char * rtp_ice_wrap_get_ufrag(struct ast_rtp_instance *instance)
int ast_rtp_instance_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode)
Set the DTMF mode that should be used.
void ast_rtp_instance_stop(struct ast_rtp_instance *instance)
Stop an RTP instance.
void ast_rtp_dtls_cfg_free(struct ast_rtp_dtls_cfg *dtls_cfg)
Free contents of a DTLS configuration structure.
static void rtcp_message_payload_dtor(void *obj)
int ast_rtp_instance_get_and_cmp_requested_target_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address)
Get the requested target address of the remote endpoint and compare it to the given address.
Definition rtp_engine.c:679
static struct ast_rtp_mime_type ast_rtp_mime_types[128]
static void rtp_ice_wrap_ice_lite(struct ast_rtp_instance *instance)
static void rtp_ice_wrap_set_role(struct ast_rtp_instance *instance, enum ast_rtp_ice_role role)
void ast_rtp_engine_unregister_srtp(void)
static int rtp_codecs_assign_payload_code_rx(struct ast_rtp_codecs *codecs, int asterisk_format, struct ast_format *format, int code, int explicit, unsigned int sample_rate)
static const char * rtp_ice_wrap_get_password(struct ast_rtp_instance *instance)
static void rtp_ice_wrap_start(struct ast_rtp_instance *instance)
uintmax_t ast_debug_category_rtp_id(void)
static uintmax_t debug_category_rtcp_id
void ast_rtp_codecs_payloads_copy(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
Copy payload information from one RTP instance to another.
void ast_rtp_publish_rtcp_message(struct ast_rtp_instance *rtp, struct stasis_message_type *message_type, struct ast_rtp_rtcp_report *report, struct ast_json *blob)
Publish an RTCP message to Stasis Message Bus API.
struct ast_srtp * ast_rtp_instance_get_srtp(struct ast_rtp_instance *instance, int rtcp)
Obtain the SRTP instance associated with an RTP instance.
static struct stasis_topic * rtp_topic
Stasis Message Bus API topic for RTP related messages
Definition rtp_engine.c:283
void ast_rtp_instance_set_keepalive(struct ast_rtp_instance *instance, int interval)
Set the RTP keepalive interval.
struct ast_rtp_instance * ast_rtp_instance_get_bridged(struct ast_rtp_instance *instance)
Get the other RTP instance that an instance is bridged to.
size_t ast_rtp_instance_extmap_count(struct ast_rtp_instance *instance)
Get the number of known unique identifiers.
Definition rtp_engine.c:927
static enum ast_rtp_extension_direction rtp_extmap_negotiate_direction(enum ast_rtp_extension_direction ours, enum ast_rtp_extension_direction theirs)
Helper function which negotiates two RTP extension directions to get our current direction.
Definition rtp_engine.c:818
int ast_rtp_instance_extmap_enable(struct ast_rtp_instance *instance, int id, enum ast_rtp_extension extension, enum ast_rtp_extension_direction direction)
Enable support for an RTP extension on an instance.
Definition rtp_engine.c:760
static void rtp_engine_shutdown(void)
#define SET_AST_JSON_OBJ(target, name, obj)
Set given json object into target with name.
Definition rtp_engine.c:293
int ast_rtp_instance_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
Early bridge two channels that use RTP instances.
void * ast_rtp_instance_get_data(struct ast_rtp_instance *instance)
Get the data portion of an RTP instance.
Definition rtp_engine.c:591
struct ast_srtp_policy_res * res_srtp_policy
Definition rtp_engine.c:183
enum ast_media_type ast_rtp_codecs_get_stream_type(struct ast_rtp_codecs *codecs)
Determine the type of RTP stream media from the codecs mapped.
char * ast_rtp_instance_get_quality(struct ast_rtp_instance *instance, enum ast_rtp_instance_stat_field field, char *buf, size_t size)
Retrieve quality statistics about an RTP instance.
int ast_rtp_instance_get_keepalive(struct ast_rtp_instance *instance)
Get the RTP keepalive interval.
struct ast_rtp_engine * ast_rtp_instance_get_engine(struct ast_rtp_instance *instance)
Get the RTP engine in use on an RTP instance.
static enum ast_rtp_dtls_setup rtp_dtls_wrap_get_setup(struct ast_rtp_instance *instance)
static void rtp_ice_wrap_change_components(struct ast_rtp_instance *instance, int num_components)
static void rtp_dtls_wrap_set_fingerprint(struct ast_rtp_instance *instance, enum ast_rtp_dtls_hash hash, const char *fingerprint)
const char * ast_rtp_instance_get_cname(struct ast_rtp_instance *rtp)
Retrieve the CNAME used in RTCP SDES items.
int ast_rtp_codecs_payload_set_rx_sample_rate(struct ast_rtp_codecs *codecs, int code, struct ast_format *format, unsigned int sample_rate)
Set a payload code with sample rate for use with a specific Asterisk format.
void ast_rtp_codecs_payload_formats(struct ast_rtp_codecs *codecs, struct ast_format_cap *astformats, int *nonastformats)
Retrieve all formats that were found.
int ast_rtp_instance_get_timeout(struct ast_rtp_instance *instance)
Get the RTP timeout value.
int ast_rtp_instance_dtmf_begin(struct ast_rtp_instance *instance, char digit)
Begin sending a DTMF digit.
struct ast_rtp_engine_dtls * ast_rtp_instance_get_dtls(struct ast_rtp_instance *instance)
Obtain a pointer to the DTLS support present on an RTP instance.
static void rtp_dtls_wrap_stop(struct ast_rtp_instance *instance)
void ast_rtp_instance_set_last_tx(struct ast_rtp_instance *rtp, time_t time)
Set the last RTP transmission time.
static void add_static_payload(int payload, struct ast_format *format, int rtp_code)
static ast_rwlock_t static_RTP_PT_lock
Definition rtp_engine.c:280
static void rtp_ice_wrap_set_authentication(struct ast_rtp_instance *instance, const char *ufrag, const char *password)
struct ast_frame * ast_rtp_instance_read(struct ast_rtp_instance *instance, int rtcp)
Receive a frame over RTP.
Definition rtp_engine.c:606
static int rtp_dtls_wrap_active(struct ast_rtp_instance *instance)
void ast_rtp_instance_set_data(struct ast_rtp_instance *instance, void *data)
Set the data portion of an RTP instance.
Definition rtp_engine.c:586
int ast_rtp_instance_set_write_format(struct ast_rtp_instance *instance, struct ast_format *format)
Tell underlying RTP engine that audio frames will be provided in a specific format.
int ast_rtp_instance_bundle(struct ast_rtp_instance *child, struct ast_rtp_instance *parent)
Request that an RTP instance be bundled with another.
void ast_rtp_instance_stun_request(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username)
Request that the underlying RTP engine send a STUN BIND request.
int ast_rtp_codecs_payload_code_tx_sample_rate(struct ast_rtp_codecs *codecs, int asterisk_format, const struct ast_format *format, int code, unsigned int sample_rate)
Retrieve a tx mapped payload type based on whether it is an Asterisk format and the code.
static void rtp_dtls_wrap_set_setup(struct ast_rtp_instance *instance, enum ast_rtp_dtls_setup setup)
void ast_rtp_codecs_set_framing(struct ast_rtp_codecs *codecs, unsigned int framing)
Set the framing used for a set of codecs.
static void rtp_dtls_wrap_reset(struct ast_rtp_instance *instance)
static uintmax_t debug_category_rtcp_packet_id
time_t ast_rtp_instance_get_last_tx(const struct ast_rtp_instance *rtp)
Get the last RTP transmission time.
void ast_rtp_codecs_payloads_set_m_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload)
Record tx payload type information that was seen in an m= SDP line.
static void rtp_codecs_payloads_copy_tx(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
static int rtp_codecs_find_non_primary_dynamic_rx(struct ast_rtp_codecs *codecs)
int ast_rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
Initialize RED support on an RTP instance.
struct ast_json * ast_rtp_instance_get_stats_all_json(struct ast_rtp_instance *instance)
Retrieve statistics about an RTP instance in json format.
void ast_rtp_instance_set_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
Set the value of an RTP instance property.
Definition rtp_engine.c:733
static uintmax_t debug_category_ice_id
void ast_rtp_instance_set_hold_timeout(struct ast_rtp_instance *instance, int timeout)
Set the RTP timeout value for when the instance is on hold.
static void rtp_codecs_payloads_copy_rx(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
int ast_rtp_codecs_find_payload_code(struct ast_rtp_codecs *codecs, int payload)
Search for the tx payload type in the ast_rtp_codecs structure.
int ast_rtp_instance_make_compatible(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_channel *peer)
Request that the underlying RTP engine make two RTP instances compatible with eachother.
int ast_rtp_codecs_get_preferred_dtmf_format_rate(struct ast_rtp_codecs *codecs)
Retrieve rx preferred dtmf format sample rate.
void ast_rtp_instance_set_extended_prop(struct ast_rtp_instance *instance, int property, void *value)
Set the value of an RTP instance extended property.
Definition rtp_engine.c:709
static int mime_types_len
Definition rtp_engine.c:267
void ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address)
Get the local address that we are expecting RTP on.
Definition rtp_engine.c:671
int ast_rtp_instance_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration)
int ast_rtp_instance_get_stats(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
Retrieve statistics about an RTP instance.
int ast_rtp_codecs_payload_code_sample_rate(struct ast_rtp_codecs *codecs, int asterisk_format, struct ast_format *format, int code, unsigned int sample_rate)
Retrieve a rx mapped payload type based on whether it is an Asterisk format, the code and the sample ...
int ast_rtp_instance_set_local_address(struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
Set the address that we are expecting to receive RTP on.
Definition rtp_engine.c:616
int ast_rtp_get_rate(const struct ast_format *format)
Retrieve the sample rate of a format according to RTP specifications.
int ast_rtp_codecs_payload_code_tx(struct ast_rtp_codecs *codecs, int asterisk_format, const struct ast_format *format, int code)
Retrieve a tx mapped payload type based on whether it is an Asterisk format and the code.
enum ast_rtp_extension ast_rtp_instance_extmap_get_extension(struct ast_rtp_instance *instance, int id)
Retrieve the extension for an RTP extension id.
Definition rtp_engine.c:938
int ast_rtp_instance_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
Send a frame out over RTP.
Definition rtp_engine.c:596
int ast_rtp_engine_init(void)
initializes the rtp engine arrays
int ast_rtp_glue_register2(struct ast_rtp_glue *glue, struct ast_module *module)
Register RTP glue.
Definition rtp_engine.c:385
static void rtp_codecs_payload_set_rx(struct ast_rtp_codecs *codecs, int payload, struct ast_rtp_payload_type *new_type, int replace)
static struct ast_rtp_engine_dtls rtp_dtls_wrappers
uintmax_t ast_debug_category_dtls_packet_id(void)
static void rtp_engine_atexit(void)
static void rtp_rtcp_report_dtor(void *obj)
int ast_rtp_payload_mapping_tx_is_present(struct ast_rtp_codecs *codecs, const struct ast_rtp_payload_type *to_match)
Determine if a type of payload is already present in mappings.
static uintmax_t debug_category_rtp_id
void ast_rtp_codecs_payloads_unset(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload)
Remove tx payload type mapped information.
int ast_rtp_instance_sendcng(struct ast_rtp_instance *instance, int level)
Send a comfort noise packet to the RTP instance.
static struct ao2_container * rtp_ice_wrap_get_local_candidates(struct ast_rtp_instance *instance)
static void rtp_engine_mime_type_cleanup(int i)
void ast_rtp_codecs_payloads_clear(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance)
Clear rx and tx payload mapping information from an RTP instance.
void ast_rtp_instance_set_remote_ssrc(struct ast_rtp_instance *rtp, unsigned int ssrc)
Set the remote SSRC for an RTP instance.
struct ast_rtp_engine_ice * ast_rtp_instance_get_ice(struct ast_rtp_instance *instance)
Obtain a pointer to the ICE support present on an RTP instance.
int ast_rtp_instance_get_hold_timeout(struct ast_rtp_instance *instance)
Get the RTP timeout value for when an RTP instance is on hold.
int ast_rtp_codecs_payloads_initialize(struct ast_rtp_codecs *codecs)
Initialize an RTP codecs structure.
Definition rtp_engine.c:986
static uintmax_t debug_category_rtp_packet_id
static struct ast_rtp_payload_type * rtp_payload_type_alloc(struct ast_format *format, int payload, int rtp_code, int primary_mapping, unsigned int sample_rate)
Definition rtp_engine.c:311
int ast_rtp_dtls_cfg_parse(struct ast_rtp_dtls_cfg *dtls_cfg, const char *name, const char *value)
Parse DTLS related configuration options.
void * ast_rtp_instance_get_extended_prop(struct ast_rtp_instance *instance, int property)
Get the value of an RTP instance extended property.
Definition rtp_engine.c:718
static uintmax_t debug_category_dtls_id
int ast_rtp_engine_unload_format(struct ast_format *format)
Formats requiring the use of a format attribute interface must have that interface registered in orde...
static void payload_mapping_rx_clear_primary(struct ast_rtp_codecs *codecs, struct ast_rtp_payload_type *to_match)
static int find_unused_payload_in_range(const struct ast_rtp_codecs *codecs, int start, int end, struct ast_rtp_payload_type *ignore[])
static void set_next_mime_type(struct ast_format *format, int rtp_code, const char *type, const char *subtype, unsigned int sample_rate)
int ast_rtp_instance_activate(struct ast_rtp_instance *instance)
Indicate to the RTP engine that packets are now expected to be sent/received on the RTP instance.
const char * ast_rtp_lookup_mime_subtype2(const int asterisk_format, const struct ast_format *format, int code, enum ast_rtp_options options)
Retrieve mime subtype information on a payload.
static void unref_instance_cond(struct ast_rtp_instance **instance)
Conditionally unref an rtp instance.
void ast_rtp_instance_get_requested_target_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address)
Get the requested target address of the remote endpoint.
Definition rtp_engine.c:701
time_t ast_rtp_instance_get_last_rx(const struct ast_rtp_instance *rtp)
Get the last RTP reception time.
static struct ast_json * rtcp_report_to_json(struct stasis_message *msg, const struct stasis_message_sanitizer *sanitize)
int ast_rtp_engine_register2(struct ast_rtp_engine *engine, struct ast_module *module)
Register an RTP engine.
Definition rtp_engine.c:336
static void rtp_codecs_payload_replace_rx(struct ast_rtp_codecs *codecs, int payload, struct ast_rtp_payload_type *new_type)
int ast_rtp_codecs_payloads_set_rtpmap_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload, char *mimetype, char *mimesubtype, enum ast_rtp_options options)
Record tx payload type information that was seen in an a=rtpmap: SDP line.
int ast_rtp_instance_set_qos(struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
Set QoS parameters on an RTP session.
static enum ast_rtp_dtls_hash rtp_dtls_wrap_get_fingerprint_hash(struct ast_rtp_instance *instance)
void ast_rtp_instance_set_channel_id(struct ast_rtp_instance *instance, const char *uniqueid)
Set the channel that owns this RTP instance.
Definition rtp_engine.c:581
void ast_rtp_dtls_cfg_copy(const struct ast_rtp_dtls_cfg *src_cfg, struct ast_rtp_dtls_cfg *dst_cfg)
Copy contents of a DTLS configuration structure.
int ast_rtp_instance_set_incoming_source_address(struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
Set the incoming source address of the remote endpoint that we are sending RTP to.
Definition rtp_engine.c:634
void ast_rtp_instance_available_formats(struct ast_rtp_instance *instance, struct ast_format_cap *to_endpoint, struct ast_format_cap *to_asterisk, struct ast_format_cap *result)
Request the formats that can be transcoded.
int ast_rtp_codecs_payload_replace_format(struct ast_rtp_codecs *codecs, int payload, struct ast_format *format)
Update the format associated with a tx payload type in a codecs structure.
static int find_static_payload_type(int asterisk_format, const struct ast_format *format, int code)
uintmax_t ast_debug_category_rtcp_id(void)
struct ast_rtp_glue * ast_rtp_instance_get_glue(const char *type)
Get the RTP glue that binds a channel to the RTP engine.
const char * ast_rtp_instance_extmap_get_uri(struct ast_rtp_instance *instance, int id)
Retrieve the URI for an RTP extension id.
Definition rtp_engine.c:974
int ast_rtp_codecs_payloads_set_rtpmap_type_rate(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int pt, char *mimetype, char *mimesubtype, enum ast_rtp_options options, unsigned int sample_rate)
Set tx payload type to a known MIME media type for a codec with a specific sample rate.
int ast_rtp_codecs_set_preferred_dtmf_format(struct ast_rtp_codecs *codecs, int pt, int rate)
Set the preferred dtmf format pt and sample rate.
int ast_rtp_instance_dtmf_end(struct ast_rtp_instance *instance, char digit)
Stop sending a DTMF digit.
int ast_rtp_instance_extmap_get_id(struct ast_rtp_instance *instance, enum ast_rtp_extension extension)
Retrieve the id for an RTP extension.
Definition rtp_engine.c:914
int ast_rtp_dtls_cfg_validate(struct ast_rtp_dtls_cfg *dtls_cfg)
Validates DTLS related configuration options.
static struct ast_manager_event_blob * rtcp_report_to_ami(struct stasis_message *msg)
void ast_rtp_instance_set_stream_num(struct ast_rtp_instance *rtp, int stream_num)
Set the stream number for an RTP instance.
int ast_rtp_codecs_get_preferred_dtmf_format_pt(struct ast_rtp_codecs *codecs)
Retrieve rx preferred dtmf format payload type.
static const char *const rtp_extension_uris[AST_RTP_EXTENSION_MAX]
URIs for known RTP extensions.
Definition rtp_engine.c:240
void ast_rtp_instance_change_source(struct ast_rtp_instance *instance)
Indicate a new source of audio has dropped in and the ssrc should change.
int ast_rtp_engine_unregister(struct ast_rtp_engine *engine)
Unregister an RTP engine.
Definition rtp_engine.c:370
uintmax_t ast_debug_category_dtls_id(void)
int ast_rtp_instance_extmap_negotiate(struct ast_rtp_instance *instance, int id, enum ast_rtp_extension_direction direction, const char *uri, const char *attributes)
Negotiate received RTP extension information.
Definition rtp_engine.c:846
static int find_unused_payload(const struct ast_rtp_codecs *codecs)
static int rtp_dtls_wrap_set_configuration(struct ast_rtp_instance *instance, const struct ast_rtp_dtls_cfg *dtls_cfg)
int ast_rtp_engine_load_format(struct ast_format *format)
Custom formats declared in codecs.conf at startup must be communicated to the rtp_engine so their mim...
void ast_rtp_instance_extmap_clear(struct ast_rtp_instance *instance)
Clear negotiated RTP extension information.
Definition rtp_engine.c:890
struct ast_rtp_payload_type * ast_rtp_engine_alloc_payload_type(void)
Allocation routine for ast_rtp_payload_type.
Definition rtp_engine.c:331
struct ast_rtp_codecs * ast_rtp_instance_get_codecs(struct ast_rtp_instance *instance)
Get the codecs structure of an RTP instance.
Definition rtp_engine.c:755
int ast_rtp_instance_set_read_format(struct ast_rtp_instance *instance, struct ast_format *format)
Request that the underlying RTP engine provide audio frames in a specific format.
static void rtp_instance_set_incoming_source_address_nolock(struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
Definition rtp_engine.c:625
const char * ast_rtp_instance_get_channel_id(struct ast_rtp_instance *instance)
Get the unique ID of the channel that owns this RTP instance.
Definition rtp_engine.c:576
int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp)
Get the file descriptor for an RTP session (or RTCP)
void ast_rtp_instance_update_source(struct ast_rtp_instance *instance)
Indicate that the RTP marker bit should be set on an RTP stream.
unsigned int ast_rtp_codecs_get_framing(struct ast_rtp_codecs *codecs)
Get the framing used for a set of codecs.
unsigned int ast_rtp_instance_get_ssrc(struct ast_rtp_instance *rtp)
Retrieve the local SSRC value that we will be using.
int ast_rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
Buffer a frame in an RTP instance for RED.
static void instance_destructor(void *obj)
Definition rtp_engine.c:429
int ast_rtp_instance_add_srtp_policy(struct ast_rtp_instance *instance, struct ast_srtp_policy *remote_policy, struct ast_srtp_policy *local_policy, int rtcp)
Add or replace the SRTP policies for the given RTP instance.
int ast_rtp_codecs_payload_code(struct ast_rtp_codecs *codecs, int asterisk_format, struct ast_format *format, int code)
Retrieve a rx mapped payload type based on whether it is an Asterisk format and the code.
static int payload_mapping_tx_is_present(const struct ast_rtp_codecs *codecs, const struct ast_rtp_payload_type *to_match)
enum ast_rtp_extension_direction ast_rtp_instance_extmap_get_direction(struct ast_rtp_instance *instance, int id)
Retrieve the negotiated direction for an RTP extension id.
Definition rtp_engine.c:958
void ast_rtp_codecs_payloads_xover(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
Crossover copy the tx payload mapping of src to the rx payload mapping of dest.
void ast_rtp_instance_set_bridged(struct ast_rtp_instance *instance, struct ast_rtp_instance *bridged)
Set the other RTP instance that an instance is bridged to.
void ast_rtp_instance_set_timeout(struct ast_rtp_instance *instance, int timeout)
Set the RTP timeout value.
int ast_rtp_glue_unregister(struct ast_rtp_glue *glue)
Unregister RTP glue.
Definition rtp_engine.c:414
int ast_rtp_codecs_set_preferred_format(struct ast_rtp_codecs *codecs, struct ast_format *format)
Set the preferred format.
static ast_rwlock_t mime_types_lock
Definition rtp_engine.c:266
Pluggable RTP Architecture.
ast_rtp_dtls_setup
DTLS setup types.
Definition rtp_engine.h:564
@ AST_RTP_DTLS_SETUP_PASSIVE
Definition rtp_engine.h:566
@ AST_RTP_DTLS_SETUP_ACTPASS
Definition rtp_engine.h:567
@ AST_RTP_DTLS_SETUP_ACTIVE
Definition rtp_engine.h:565
ast_rtp_ice_role
ICE role during negotiation.
Definition rtp_engine.h:519
#define AST_RTP_PT_LAST_REASSIGN
Definition rtp_engine.h:95
ast_rtp_ice_component_type
ICE component types.
Definition rtp_engine.h:513
ast_rtp_dtls_hash
DTLS fingerprint hashes.
Definition rtp_engine.h:578
@ AST_RTP_DTLS_HASH_SHA1
Definition rtp_engine.h:580
@ AST_RTP_DTLS_HASH_SHA256
Definition rtp_engine.h:579
ast_rtp_dtmf_mode
Definition rtp_engine.h:151
#define AST_LOG_CATEGORY_ICE
#define AST_RTP_DTMF
Definition rtp_engine.h:294
#define AST_RTP_RTCP_SR
Definition rtp_engine.h:323
ast_rtp_instance_stat_field
Definition rtp_engine.h:171
@ AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS
Definition rtp_engine.h:177
@ AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT
Definition rtp_engine.h:179
@ AST_RTP_INSTANCE_STAT_FIELD_QUALITY
Definition rtp_engine.h:173
@ AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER
Definition rtp_engine.h:175
@ AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES
Definition rtp_engine.h:181
@ AST_RTP_DTLS_VERIFY_NONE
Definition rtp_engine.h:585
@ AST_RTP_DTLS_VERIFY_FINGERPRINT
Definition rtp_engine.h:586
@ AST_RTP_DTLS_VERIFY_CERTIFICATE
Definition rtp_engine.h:587
ast_rtp_glue_result
Definition rtp_engine.h:161
@ AST_RTP_GLUE_RESULT_REMOTE
Definition rtp_engine.h:165
@ AST_RTP_GLUE_RESULT_FORBID
Definition rtp_engine.h:163
#define AST_LOG_CATEGORY_RTCP_PACKET
ast_rtp_instance_stat
Definition rtp_engine.h:185
@ AST_RTP_INSTANCE_STAT_COMBINED_MES
Definition rtp_engine.h:260
@ AST_RTP_INSTANCE_STAT_COMBINED_JITTER
Definition rtp_engine.h:215
@ AST_RTP_INSTANCE_STAT_COMBINED_LOSS
Definition rtp_engine.h:193
@ AST_RTP_INSTANCE_STAT_COMBINED_RTT
Definition rtp_engine.h:237
@ AST_RTP_INSTANCE_STAT_ALL
Definition rtp_engine.h:187
#define AST_LOG_CATEGORY_DTLS
#define AST_RTP_MAX_PT
Definition rtp_engine.h:83
#define AST_LOG_CATEGORY_RTCP
#define ast_debug_rtp(sublevel,...)
Log debug level RTP information.
#define AST_LOG_CATEGORY_RTP
#define ast_debug_rtp_is_allowed
ast_rtp_extension
Known RTP extensions.
Definition rtp_engine.h:593
@ AST_RTP_EXTENSION_MAX
Definition rtp_engine.h:601
@ AST_RTP_EXTENSION_TRANSPORT_WIDE_CC
Definition rtp_engine.h:599
@ AST_RTP_EXTENSION_ABS_SEND_TIME
Definition rtp_engine.h:597
@ AST_RTP_EXTENSION_UNSUPPORTED
Definition rtp_engine.h:595
#define AST_RTP_PT_FIRST_DYNAMIC
Definition rtp_engine.h:92
ast_rtp_options
Definition rtp_engine.h:145
@ AST_RTP_OPT_G726_NONSTANDARD
Definition rtp_engine.h:147
ast_rtp_dtls_connection
DTLS connection states.
Definition rtp_engine.h:572
ast_rtp_property
Definition rtp_engine.h:116
@ AST_RTP_PROPERTY_MAX
Maximum number of RTP properties supported.
Definition rtp_engine.h:141
#define AST_LOG_CATEGORY_RTP_PACKET
#define AST_RTP_PT_LAST_STATIC
Definition rtp_engine.h:89
ast_rtp_extension_direction
Directions for RTP extensions.
Definition rtp_engine.h:827
@ AST_RTP_EXTENSION_DIRECTION_SENDRECV
Definition rtp_engine.h:831
@ AST_RTP_EXTENSION_DIRECTION_NONE
Definition rtp_engine.h:829
@ AST_RTP_EXTENSION_DIRECTION_INACTIVE
Definition rtp_engine.h:837
@ AST_RTP_EXTENSION_DIRECTION_RECVONLY
Definition rtp_engine.h:835
@ AST_RTP_EXTENSION_DIRECTION_SENDONLY
Definition rtp_engine.h:833
#define AST_LOG_CATEGORY_DTLS_PACKET
#define AST_RTP_CN
Definition rtp_engine.h:296
#define AST_RTP_MAX
Definition rtp_engine.h:300
#define AST_RTP_CISCO_DTMF
Definition rtp_engine.h:298
Scheduler Routines (derived from cheops)
Stasis Message Bus API. See Stasis Message Bus API for detailed documentation.
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
Definition stasis.h:1515
struct stasis_topic * stasis_topic_create(const char *name)
Create a new topic.
Definition stasis.c:684
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
Definition stasis.h:1493
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
#define STASIS_MESSAGE_TYPE_DEFN(name,...)
Boiler-plate messaging macro for defining public message types.
Definition stasis.h:1440
struct stasis_message * stasis_message_create(struct stasis_message_type *type, void *data)
Create a new message.
void stasis_publish(struct stasis_topic *topic, struct stasis_message *message)
Publish a message to a topic's subscribers.
Definition stasis.c:1578
struct ast_json * ast_channel_snapshot_to_json(const struct ast_channel_snapshot *snapshot, const struct stasis_message_sanitizer *sanitize)
Build a JSON object from a ast_channel_snapshot.
String manipulation functions.
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition strings.h:1139
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
Definition utils.c:2235
static force_inline char * ast_str_to_upper(char *str)
Convert a string to all upper-case.
Definition strings.h:1342
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition strings.h:65
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
Definition strings.h:659
char *attribute_pure ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition strings.h:761
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition strings.h:425
#define AS_OR(a, b)
Definition strings.h:49
Generic container type.
Structure representing a snapshot of channel state.
Structure to describe a channel "technology", ie a channel driver See for examples:
Definition channel.h:648
Main Channel structure associated with a channel.
struct ast_bridge * bridge
Format capabilities structure, holds formats + preference order + etc.
Definition format_cap.c:54
Definition of a media format.
Definition format.c:43
Data structure associated with a single frame of data.
Abstract JSON element (object, array, string, int, ...).
Struct containing info for an AMI event to send out.
Definition manager.h:503
struct ast_module::@390 entry
struct ast_rtp_codecs::@296 payload_mapping_rx
ast_rwlock_t codecs_lock
Definition rtp_engine.h:758
struct ast_rtp_codecs::@297 payload_mapping_tx
int preferred_dtmf_rate
Definition rtp_engine.h:768
struct ast_format * preferred_format
Definition rtp_engine.h:766
unsigned int framing
Definition rtp_engine.h:764
DTLS configuration structure.
Definition rtp_engine.h:605
enum ast_rtp_dtls_setup default_setup
Definition rtp_engine.h:608
enum ast_rtp_dtls_verify verify
Definition rtp_engine.h:611
unsigned int rekey
Definition rtp_engine.h:607
enum ast_rtp_dtls_hash hash
Definition rtp_engine.h:610
unsigned int enabled
Definition rtp_engine.h:606
unsigned int ephemeral_cert
Definition rtp_engine.h:617
enum ast_srtp_suite suite
Definition rtp_engine.h:609
Structure that represents the optional DTLS SRTP support within an RTP engine.
Definition rtp_engine.h:621
int(* set_configuration)(struct ast_rtp_instance *instance, const struct ast_rtp_dtls_cfg *dtls_cfg)
Definition rtp_engine.h:623
int(* active)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:625
enum ast_rtp_dtls_setup(* get_setup)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:633
void(* stop)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:627
enum ast_rtp_dtls_hash(* get_fingerprint_hash)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:639
const char *(* get_fingerprint)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:641
void(* reset)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:629
void(* set_fingerprint)(struct ast_rtp_instance *instance, enum ast_rtp_dtls_hash hash, const char *fingerprint)
Definition rtp_engine.h:637
enum ast_rtp_dtls_connection(* get_connection)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:631
void(* set_setup)(struct ast_rtp_instance *instance, enum ast_rtp_dtls_setup setup)
Definition rtp_engine.h:635
Structure for an ICE candidate.
Definition rtp_engine.h:525
Structure that represents the optional ICE support within an RTP engine.
Definition rtp_engine.h:536
void(* ice_lite)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:552
void(* stop)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:544
void(* change_components)(struct ast_rtp_instance *instance, int num_components)
Definition rtp_engine.h:560
void(* set_authentication)(struct ast_rtp_instance *instance, const char *ufrag, const char *password)
Definition rtp_engine.h:538
void(* start)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:542
const char *(* get_ufrag)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:546
void(* turn_request)(struct ast_rtp_instance *instance, enum ast_rtp_ice_component_type component, enum ast_transport transport, const char *server, unsigned int port, const char *username, const char *password)
Definition rtp_engine.h:556
void(* add_remote_candidate)(struct ast_rtp_instance *instance, const struct ast_rtp_engine_ice_candidate *candidate)
Definition rtp_engine.h:540
const char *(* get_password)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:548
void(* set_role)(struct ast_rtp_instance *instance, enum ast_rtp_ice_role role)
Definition rtp_engine.h:554
struct ao2_container *(* get_local_candidates)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:550
struct ast_rtp_engine::@295 entry
int(* get_stat)(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
Definition rtp_engine.h:702
int(* write)(struct ast_rtp_instance *instance, struct ast_frame *frame)
Definition rtp_engine.h:675
int(* qos)(struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
Definition rtp_engine.h:704
void(* stop)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:677
enum ast_rtp_dtmf_mode(* dtmf_mode_get)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:700
int(* activate)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:724
void(* change_source)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:686
int(* dtmf_end)(struct ast_rtp_instance *instance, char digit)
Definition rtp_engine.h:681
void(* payload_set)(struct ast_rtp_instance *instance, int payload, int asterisk_format, struct ast_format *format, int code)
Definition rtp_engine.h:694
int(* destroy)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:673
int(* fd)(struct ast_rtp_instance *instance, int rtcp)
Definition rtp_engine.h:706
int(* dtmf_mode_set)(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode)
Definition rtp_engine.h:698
void(* set_remote_ssrc)(struct ast_rtp_instance *instance, unsigned int ssrc)
Definition rtp_engine.h:738
void *(* extended_prop_get)(struct ast_rtp_instance *instance, int property)
Definition rtp_engine.h:690
int(* make_compatible)(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1)
Definition rtp_engine.h:720
struct ast_module * mod
Definition rtp_engine.h:669
int(* red_buffer)(struct ast_rtp_instance *instance, struct ast_frame *frame)
Definition rtp_engine.h:710
int(* set_read_format)(struct ast_rtp_instance *instance, struct ast_format *format)
Definition rtp_engine.h:716
int(* new)(struct ast_rtp_instance *instance, struct ast_sched_context *sched, struct ast_sockaddr *sa, void *data)
Definition rtp_engine.h:671
int(* red_init)(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
Definition rtp_engine.h:708
void(* prop_set)(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
Definition rtp_engine.h:692
const char * name
Definition rtp_engine.h:667
int(* dtmf_end_with_duration)(struct ast_rtp_instance *instance, char digit, unsigned int duration)
Definition rtp_engine.h:682
int(* set_write_format)(struct ast_rtp_instance *instance, struct ast_format *format)
Definition rtp_engine.h:718
void(* remote_address_set)(struct ast_rtp_instance *instance, struct ast_sockaddr *sa)
Definition rtp_engine.h:696
void(* available_formats)(struct ast_rtp_instance *instance, struct ast_format_cap *to_endpoint, struct ast_format_cap *to_asterisk, struct ast_format_cap *result)
Definition rtp_engine.h:728
int(* sendcng)(struct ast_rtp_instance *instance, int level)
Definition rtp_engine.h:730
void(* update_source)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:684
void(* stun_request)(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username)
Definition rtp_engine.h:726
int(* dtmf_begin)(struct ast_rtp_instance *instance, char digit)
Definition rtp_engine.h:679
const char *(* cname_get)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:734
struct ast_rtp_engine_ice * ice
Definition rtp_engine.h:742
unsigned int(* ssrc_get)(struct ast_rtp_instance *instance)
Definition rtp_engine.h:732
struct ast_rtp_engine_dtls * dtls
Definition rtp_engine.h:744
void(* set_stream_num)(struct ast_rtp_instance *instance, int stream_num)
Definition rtp_engine.h:740
struct ast_frame *(* read)(struct ast_rtp_instance *instance, int rtcp)
Definition rtp_engine.h:712
int(* bundle)(struct ast_rtp_instance *child, struct ast_rtp_instance *parent)
Definition rtp_engine.h:736
int(* extension_enable)(struct ast_rtp_instance *instance, enum ast_rtp_extension extension)
Definition rtp_engine.h:750
int(* extended_prop_set)(struct ast_rtp_instance *instance, int property, void *value)
Definition rtp_engine.h:688
enum ast_rtp_glue_result(* get_rtp_info)(struct ast_channel *chan, struct ast_rtp_instance **instance)
Callback for retrieving the RTP instance carrying audio.
Definition rtp_engine.h:787
void(* get_codec)(struct ast_channel *chan, struct ast_format_cap *result_cap)
Callback for retrieving codecs that the channel can do. Result returned in result_cap.
Definition rtp_engine.h:819
int(* update_peer)(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_rtp_instance *vinstance, struct ast_rtp_instance *tinstance, const struct ast_format_cap *cap, int nat_active)
Definition rtp_engine.h:814
const char * type
Definition rtp_engine.h:780
struct ast_module * mod
Definition rtp_engine.h:782
struct ast_rtp_glue::@298 entry
enum ast_rtp_glue_result(* get_vrtp_info)(struct ast_channel *chan, struct ast_rtp_instance **instance)
Callback for retrieving the RTP instance carrying video.
Definition rtp_engine.h:799
unsigned int remote_ssrc
Definition rtp_engine.h:454
unsigned int local_ssrc
Definition rtp_engine.h:452
unsigned int rxoctetcount
Definition rtp_engine.h:460
unsigned int txoctetcount
Definition rtp_engine.h:458
char channel_uniqueid[MAX_CHANNEL_ID]
Definition rtp_engine.h:456
struct ast_rtp_instance::@416 extmap_negotiated
struct ast_rtp_codecs codecs
Definition rtp_engine.c:210
struct ast_srtp * rtcp_srtp
Definition rtp_engine.c:222
struct ast_rtp_instance::@417 extmap_unique_ids
int properties[AST_RTP_PROPERTY_MAX]
Definition rtp_engine.c:200
struct ast_sockaddr incoming_source_address
Definition rtp_engine.c:206
struct ast_rtp_glue * glue
Definition rtp_engine.c:218
struct ast_sockaddr requested_target_address
Definition rtp_engine.c:204
struct ast_sockaddr local_address
Definition rtp_engine.c:202
struct ast_rtp_instance * bridged
Definition rtp_engine.c:208
struct ast_rtp_engine * engine
Definition rtp_engine.c:196
struct ast_rtp_instance::@415 extmap_enabled
char channel_uniqueid[AST_MAX_UNIQUEID]
Definition rtp_engine.c:224
struct ast_srtp * srtp
Definition rtp_engine.c:220
unsigned int sample_rate
Expected sample rate of the /c subtype.
Definition rtp_engine.c:264
char subtype[64]
The format type.
Definition rtp_engine.c:262
char type[16]
The media type.
Definition rtp_engine.c:260
struct ast_rtp_payload_type payload_type
A mapping object between the Asterisk codec and this RTP payload.
Definition rtp_engine.c:258
unsigned int sample_rate
Definition rtp_engine.h:318
unsigned int primary_mapping
Definition rtp_engine.h:314
struct ast_format * format
Definition rtp_engine.h:306
A report block within a SR/RR report.
Definition rtp_engine.h:346
unsigned int highest_seq_no
Definition rtp_engine.h:352
struct ast_rtp_rtcp_report_block::@291 lost_count
unsigned short fraction
Definition rtp_engine.h:349
An object that represents data sent during a SR/RR RTCP report.
Definition rtp_engine.h:361
struct ast_rtp_rtcp_report::@292 sender_information
unsigned int type
Definition rtp_engine.h:364
unsigned short reception_report_count
Definition rtp_engine.h:362
unsigned int rtp_timestamp
Definition rtp_engine.h:367
struct ast_rtp_rtcp_report_block * report_block[0]
Definition rtp_engine.h:374
struct timeval ntp_timestamp
Definition rtp_engine.h:366
unsigned int octet_count
Definition rtp_engine.h:369
unsigned int ssrc
Definition rtp_engine.h:363
unsigned int packet_count
Definition rtp_engine.h:368
Structure for rwlock and tracking information.
Definition lock.h:164
Socket address structure.
Definition netsock2.h:97
void(* destroy)(struct ast_srtp *srtp)
Definition res_srtp.h:40
int(* replace)(struct ast_srtp **srtp, struct ast_rtp_instance *rtp, struct ast_srtp_policy *policy)
Definition res_srtp.h:38
int(* add_stream)(struct ast_srtp *srtp, struct ast_srtp_policy *policy)
Definition res_srtp.h:42
int(* create)(struct ast_srtp **srtp, struct ast_rtp_instance *rtp, struct ast_srtp_policy *policy)
Definition res_srtp.h:36
Support for dynamic strings.
Definition strings.h:623
structure to hold extensions
struct ast_rtp_rtcp_report * report
struct ast_channel_snapshot * snapshot
struct ast_json * blob
enum ast_rtp_extension extension
Definition rtp_engine.c:188
enum ast_rtp_extension_direction direction
Definition rtp_engine.c:190
Definition sched.c:76
Structure containing callbacks for Stasis message sanitization.
Definition stasis.h:200
int value
Definition syslog.c:37
int done
static struct test_options options
Time-related functions and macros.
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
Definition time.h:107
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition time.h:159
Support for translation of data formats. translate.c.
void ast_translate_available_formats(struct ast_format_cap *dest, struct ast_format_cap *src, struct ast_format_cap *result)
Find available formats.
Definition translate.c:1616
Utility functions.
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition utils.h:978
#define ast_assert(a)
Definition utils.h:776
int ast_file_is_readable(const char *filename)
Test that a file exists and is readable by the effective user.
Definition utils.c:3143
#define ARRAY_LEN(a)
Definition utils.h:703
#define MAX(a, b)
Definition utils.h:251
Vector container support.
#define AST_VECTOR_REPLACE(vec, idx, elem)
Replace an element at a specific position in a vector, growing the vector if needed.
Definition vector.h:295
#define AST_VECTOR_SIZE(vec)
Get the number of elements in a vector.
Definition vector.h:620
#define AST_VECTOR_FREE(vec)
Deallocates this vector.
Definition vector.h:185
#define AST_VECTOR_INIT(vec, size)
Initialize a vector.
Definition vector.h:124
#define AST_VECTOR_APPEND(vec, elem)
Append an element to a vector, growing the vector if needed.
Definition vector.h:267
#define AST_VECTOR(name, type)
Define a vector structure.
Definition vector.h:44
#define AST_VECTOR_GET(vec, idx)
Get an element from a vector.
Definition vector.h:691
#define AST_VECTOR_GET_ADDR(vec, idx)
Get an address of element in a vector.
Definition vector.h:679