rtp_engine.h: No sense allowing payload types larger than RFC allows.
[asterisk/asterisk.git] / include / asterisk / rtp_engine.h
index 605cc17..d6a9be5 100644 (file)
@@ -70,13 +70,32 @@ extern "C" {
 #endif
 
 #include "asterisk/astobj2.h"
+#include "asterisk/frame.h"
+#include "asterisk/format_cap.h"
+#include "asterisk/netsock2.h"
+#include "asterisk/sched.h"
+#include "asterisk/res_srtp.h"
+#include "asterisk/stasis.h"
+#include "asterisk/vector.h"
 
-/* Maximum number of payloads supported */
-#define AST_RTP_MAX_PT 256
+/*! Maximum number of payload types RTP can support. */
+#define AST_RTP_MAX_PT 128
 
-/* Maximum number of generations */
+/*! First dynamic RTP payload type */
+#define AST_RTP_PT_FIRST_DYNAMIC 96
+
+/*! Maximum number of generations */
 #define AST_RED_MAX_GENERATION 5
 
+/*!
+ * Maximum size of an internal Asterisk channel unique ID.
+ *
+ * \note Must match the AST_MAX_UNIQUEID(AST_MAX_PUBLIC_UNIQUEID) value.
+ * We don't use that defined value directly here to avoid a hard
+ * dependency on channel.h.
+ */
+#define MAX_CHANNEL_ID 152
+
 struct ast_rtp_instance;
 struct ast_rtp_glue;
 
@@ -92,7 +111,12 @@ enum ast_rtp_property {
        AST_RTP_PROPERTY_STUN,
        /*! Enable RTCP support */
        AST_RTP_PROPERTY_RTCP,
-       /*! Maximum number of RTP properties supported */
+
+       /*!
+        * \brief Maximum number of RTP properties supported
+        *
+        * \note THIS MUST BE THE LAST ENTRY IN THIS ENUM.
+        */
        AST_RTP_PROPERTY_MAX,
 };
 
@@ -202,6 +226,8 @@ enum ast_rtp_instance_stat {
        AST_RTP_INSTANCE_STAT_LOCAL_SSRC,
        /*! Retrieve remote SSRC */
        AST_RTP_INSTANCE_STAT_REMOTE_SSRC,
+       /*! Retrieve channel unique ID */
+       AST_RTP_INSTANCE_STAT_CHANNEL_UNIQUEID,
 };
 
 /* Codes for RTP-specific data - not defined by our AST_FORMAT codes */
@@ -218,8 +244,53 @@ enum ast_rtp_instance_stat {
 struct ast_rtp_payload_type {
        /*! Is this an Asterisk value */
        int asterisk_format;
-       /*! Actual internal value of the payload */
-       int code;
+       /*! If asterisk_format is set, this is the internal
+        * asterisk format represented by the payload */
+       struct ast_format *format;
+       /*! Actual internal RTP specific value of the payload */
+       int rtp_code;
+       /*! Actual payload number */
+       int payload;
+};
+
+/* Common RTCP report types */
+/*! Sender Report */
+#define AST_RTP_RTCP_SR 200
+/*! Receiver Report */
+#define AST_RTP_RTCP_RR 201
+
+/*!
+ * \since 12
+ * \brief A report block within a SR/RR report */
+struct ast_rtp_rtcp_report_block {
+       unsigned int source_ssrc;         /*< The SSRC of the source for this report block */
+       struct {
+               unsigned short fraction;      /*< The fraction of packets lost since last SR/RR */
+               unsigned int packets;         /*< The cumulative packets since the beginning */
+       } lost_count;                     /*< Statistics regarding missed packets */
+       unsigned int highest_seq_no;      /*< Extended highest sequence number received */
+       unsigned int ia_jitter;           /*< Calculated interarrival jitter */
+       unsigned int lsr;                 /*< The time the last SR report was received */
+       unsigned int dlsr;                /*< Delay in sending this report */
+};
+
+/*!
+ * \since 12
+ * \brief An object that represents data sent during a SR/RR RTCP report */
+struct ast_rtp_rtcp_report {
+       unsigned short reception_report_count;     /*< The number of report blocks */
+       unsigned int ssrc;                         /*< Our SSRC */
+       unsigned int type;                         /*< The type of report. 200=SR; 201=RR */
+       struct {
+               struct timeval ntp_timestamp;          /*< Our NTP timestamp */
+               unsigned int rtp_timestamp;            /*< Our last RTP timestamp */
+               unsigned int packet_count;             /*< Number of packets sent */
+               unsigned int octet_count;              /*< Number of bytes sent */
+       } sender_information;                      /*< Sender information for SR */
+       /*! A dynamic array of report blocks. The number of elements is given by
+        * \c reception_report_count.
+        */
+       struct ast_rtp_rtcp_report_block *report_block[0];
 };
 
 /*! Structure that represents statistics from an RTP instance */
@@ -229,9 +300,9 @@ struct ast_rtp_instance_stats {
        /*! Number of packets received */
        unsigned int rxcount;
        /*! Jitter on transmitted packets */
-       unsigned int txjitter;
+       double txjitter;
        /*! Jitter on received packets */
-       unsigned int rxjitter;
+       double rxjitter;
        /*! Maximum jitter on remote side */
        double remote_maxjitter;
        /*! Minimum jitter on remote side */
@@ -269,7 +340,7 @@ struct ast_rtp_instance_stats {
        /*! Standard deviation packets lost on local side */
        double local_stdevrxploss;
        /*! Total round trip time */
-       unsigned int rtt;
+       double rtt;
        /*! Maximum round trip time */
        double maxrtt;
        /*! Minimum round trip time */
@@ -282,6 +353,8 @@ struct ast_rtp_instance_stats {
        unsigned int local_ssrc;
        /*! Their SSRC */
        unsigned int remote_ssrc;
+       /*! The Asterisk channel's unique ID that owns this instance */
+       char channel_uniqueid[MAX_CHANNEL_ID];
 };
 
 #define AST_RTP_STAT_SET(current_stat, combined, placement, value) \
@@ -292,11 +365,141 @@ return 0; \
 } \
 }
 
+#define AST_RTP_STAT_STRCPY(current_stat, combined, placement, value) \
+if (stat == current_stat || stat == AST_RTP_INSTANCE_STAT_ALL || (combined >= 0 && combined == current_stat)) { \
+       ast_copy_string(placement, value, sizeof(placement)); \
+       if (stat == current_stat) { \
+               return 0; \
+       } \
+}
+
 #define AST_RTP_STAT_TERMINATOR(combined) \
 if (stat == combined) { \
 return 0; \
 }
 
+/*! \brief ICE candidate types */
+enum ast_rtp_ice_candidate_type {
+       AST_RTP_ICE_CANDIDATE_TYPE_HOST,    /*!< ICE host candidate. A host candidate represents the actual local transport address in the host. */
+       AST_RTP_ICE_CANDIDATE_TYPE_SRFLX,   /*!< ICE server reflexive candidate, which represents the public mapped address of the local address. */
+       AST_RTP_ICE_CANDIDATE_TYPE_RELAYED, /*!< ICE relayed candidate, which represents the address allocated in TURN server. */
+};
+
+/*! \brief ICE component types */
+enum ast_rtp_ice_component_type {
+       AST_RTP_ICE_COMPONENT_RTP = 1,
+       AST_RTP_ICE_COMPONENT_RTCP = 2,
+};
+
+/*! \brief ICE role during negotiation */
+enum ast_rtp_ice_role {
+       AST_RTP_ICE_ROLE_CONTROLLED,
+       AST_RTP_ICE_ROLE_CONTROLLING,
+};
+
+/*! \brief Structure for an ICE candidate */
+struct ast_rtp_engine_ice_candidate {
+       char *foundation;                     /*!< Foundation identifier */
+       enum ast_rtp_ice_component_type id;   /*!< Component identifier */
+       char *transport;                      /*!< Transport for the media */
+       int priority;                         /*!< Priority which is used if multiple candidates can be used */
+       struct ast_sockaddr address;          /*!< Address of the candidate */
+       struct ast_sockaddr relay_address;    /*!< Relay address for the candidate */
+       enum ast_rtp_ice_candidate_type type; /*!< Type of candidate */
+};
+
+/*! \brief Structure that represents the optional ICE support within an RTP engine */
+struct ast_rtp_engine_ice {
+       /*! Callback for setting received authentication information */
+       void (*set_authentication)(struct ast_rtp_instance *instance, const char *ufrag, const char *password);
+       /*! Callback for adding a remote candidate */
+       void (*add_remote_candidate)(struct ast_rtp_instance *instance, const struct ast_rtp_engine_ice_candidate *candidate);
+       /*! Callback for starting ICE negotiation */
+       void (*start)(struct ast_rtp_instance *instance);
+       /*! Callback for stopping ICE support */
+       void (*stop)(struct ast_rtp_instance *instance);
+       /*! Callback for getting local username */
+       const char *(*get_ufrag)(struct ast_rtp_instance *instance);
+       /*! Callback for getting local password */
+       const char *(*get_password)(struct ast_rtp_instance *instance);
+       /*! Callback for getting local candidates */
+       struct ao2_container *(*get_local_candidates)(struct ast_rtp_instance *instance);
+       /*! Callback for telling the ICE support that it is talking to an ice-lite implementation */
+       void (*ice_lite)(struct ast_rtp_instance *instance);
+       /*! Callback for changing our role in negotiation */
+       void (*set_role)(struct ast_rtp_instance *instance, enum ast_rtp_ice_role role);
+       /*! Callback for requesting a TURN session */
+       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);
+};
+
+/*! \brief DTLS setup types */
+enum ast_rtp_dtls_setup {
+       AST_RTP_DTLS_SETUP_ACTIVE,   /*!< Endpoint is willing to inititate connections */
+       AST_RTP_DTLS_SETUP_PASSIVE,  /*!< Endpoint is willing to accept connections */
+       AST_RTP_DTLS_SETUP_ACTPASS,  /*!< Endpoint is willing to both accept and initiate connections */
+       AST_RTP_DTLS_SETUP_HOLDCONN, /*!< Endpoint does not want the connection to be established right now */
+};
+
+/*! \brief DTLS connection states */
+enum ast_rtp_dtls_connection {
+       AST_RTP_DTLS_CONNECTION_NEW,      /*!< Endpoint wants to use a new connection */
+       AST_RTP_DTLS_CONNECTION_EXISTING, /*!< Endpoint wishes to use existing connection */
+};
+
+/*! \brief DTLS fingerprint hashes */
+enum ast_rtp_dtls_hash {
+       AST_RTP_DTLS_HASH_SHA256, /*!< SHA-256 fingerprint hash */
+       AST_RTP_DTLS_HASH_SHA1,   /*!< SHA-1 fingerprint hash */
+};
+
+/*! \brief DTLS verification settings */
+enum ast_rtp_dtls_verify {
+       AST_RTP_DTLS_VERIFY_NONE = 0,               /*!< Don't verify anything */
+       AST_RTP_DTLS_VERIFY_FINGERPRINT = (1 << 0), /*!< Verify the fingerprint */
+       AST_RTP_DTLS_VERIFY_CERTIFICATE = (1 << 1), /*!< Verify the certificate */
+};
+
+/*! \brief DTLS configuration structure */
+struct ast_rtp_dtls_cfg {
+       unsigned int enabled:1;                /*!< Whether DTLS support is enabled or not */
+       unsigned int rekey;                    /*!< Interval at which to renegotiate and rekey - defaults to 0 (off) */
+       enum ast_rtp_dtls_setup default_setup; /*!< Default setup type to use for outgoing */
+       enum ast_srtp_suite suite;             /*!< Crypto suite in use */
+       enum ast_rtp_dtls_hash hash;               /*!< Hash to use for fingerprint */
+       enum ast_rtp_dtls_verify verify;           /*!< What should be verified */
+       char *certfile;                        /*!< Certificate file */
+       char *pvtfile;                         /*!< Private key file */
+       char *cipher;                          /*!< Cipher to use */
+       char *cafile;                          /*!< Certificate authority file */
+       char *capath;                          /*!< Path to certificate authority */
+};
+
+/*! \brief Structure that represents the optional DTLS SRTP support within an RTP engine */
+struct ast_rtp_engine_dtls {
+       /*! Set the configuration of the DTLS support on the instance */
+       int (*set_configuration)(struct ast_rtp_instance *instance, const struct ast_rtp_dtls_cfg *dtls_cfg);
+       /*! Get if the DTLS SRTP support is active or not */
+       int (*active)(struct ast_rtp_instance *instance);
+       /*! Stop and terminate DTLS SRTP support */
+       void (*stop)(struct ast_rtp_instance *instance);
+       /*! Reset the connection and start fresh */
+       void (*reset)(struct ast_rtp_instance *instance);
+       /*! Get the current connection state */
+       enum ast_rtp_dtls_connection (*get_connection)(struct ast_rtp_instance *instance);
+       /*! Get the current setup state */
+       enum ast_rtp_dtls_setup (*get_setup)(struct ast_rtp_instance *instance);
+       /*! Set the remote setup state */
+       void (*set_setup)(struct ast_rtp_instance *instance, enum ast_rtp_dtls_setup setup);
+       /*! Set the remote fingerprint */
+       void (*set_fingerprint)(struct ast_rtp_instance *instance, enum ast_rtp_dtls_hash hash, const char *fingerprint);
+       /*! Get the local fingerprint hash type */
+       enum ast_rtp_dtls_hash (*get_fingerprint_hash)(struct ast_rtp_instance *instance);
+       /*! Get the local fingerprint */
+       const char *(*get_fingerprint)(struct ast_rtp_instance *instance);
+};
+
 /*! Structure that represents an RTP stack (engine) */
 struct ast_rtp_engine {
        /*! Name of the RTP engine, used when explicitly requested */
@@ -304,7 +507,7 @@ struct ast_rtp_engine {
        /*! Module this RTP engine came from, used for reference counting */
        struct ast_module *mod;
        /*! Callback for setting up a new RTP instance */
-       int (*new)(struct ast_rtp_instance *instance, struct sched_context *sched, struct sockaddr_in *sin, void *data);
+       int (*new)(struct ast_rtp_instance *instance, struct ast_sched_context *sched, struct ast_sockaddr *sa, void *data);
        /*! Callback for destroying an RTP instance */
        int (*destroy)(struct ast_rtp_instance *instance);
        /*! Callback for writing out a frame */
@@ -315,24 +518,25 @@ struct ast_rtp_engine {
        int (*dtmf_begin)(struct ast_rtp_instance *instance, char digit);
        /*! Callback for stopping RFC2833 DTMF transmission */
        int (*dtmf_end)(struct ast_rtp_instance *instance, char digit);
-       /*! Callback to indicate that a new source of media has come in */
-       void (*new_source)(struct ast_rtp_instance *instance);
+       int (*dtmf_end_with_duration)(struct ast_rtp_instance *instance, char digit, unsigned int duration);
+       /*! Callback to indicate that we should update the marker bit */
+       void (*update_source)(struct ast_rtp_instance *instance);
+       /*! Callback to indicate that we should update the marker bit and ssrc */
+       void (*change_source)(struct ast_rtp_instance *instance);
        /*! Callback for setting an extended RTP property */
        int (*extended_prop_set)(struct ast_rtp_instance *instance, int property, void *value);
        /*! Callback for getting an extended RTP property */
        void *(*extended_prop_get)(struct ast_rtp_instance *instance, int property);
        /*! Callback for setting an RTP property */
        void (*prop_set)(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value);
-       /*! Callback for setting a payload */
-       void (*payload_set)(struct ast_rtp_instance *instance, int payload, int astformat, int format);
-       /*! Callback for setting packetization preferences */
-       void (*packetization_set)(struct ast_rtp_instance *instance, struct ast_codec_pref *pref);
+       /*! Callback for setting a payload.  If asterisk  is to be used, asterisk_format will be set, otherwise value in code is used. */
+       void (*payload_set)(struct ast_rtp_instance *instance, int payload, int asterisk_format, struct ast_format *format, int code);
        /*! Callback for setting the remote address that RTP is to be sent to */
-       void (*remote_address_set)(struct ast_rtp_instance *instance, struct sockaddr_in *sin);
-       /*! Callback for setting an alternate remote address */
-       void (*alt_remote_address_set)(struct ast_rtp_instance *instance, struct sockaddr_in *sin);
+       void (*remote_address_set)(struct ast_rtp_instance *instance, struct ast_sockaddr *sa);
        /*! Callback for changing DTMF mode */
        int (*dtmf_mode_set)(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode);
+       /*! Callback for getting DTMF mode */
+       enum ast_rtp_dtmf_mode (*dtmf_mode_get)(struct ast_rtp_instance *instance);
        /*! Callback for retrieving statistics */
        int (*get_stat)(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat);
        /*! Callback for setting QoS values */
@@ -348,9 +552,9 @@ struct ast_rtp_engine {
        /*! Callback to locally bridge two RTP instances */
        int (*local_bridge)(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1);
        /*! Callback to set the read format */
-       int (*set_read_format)(struct ast_rtp_instance *instance, int format);
+       int (*set_read_format)(struct ast_rtp_instance *instance, struct ast_format *format);
        /*! Callback to set the write format */
-       int (*set_write_format)(struct ast_rtp_instance *instance, int format);
+       int (*set_write_format)(struct ast_rtp_instance *instance, struct ast_format *format);
        /*! Callback to make two instances compatible */
        int (*make_compatible)(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1);
        /*! Callback to see if two instances are compatible with DTMF */
@@ -358,21 +562,32 @@ struct ast_rtp_engine {
        /*! Callback to indicate that packets will now flow */
        int (*activate)(struct ast_rtp_instance *instance);
        /*! Callback to request that the RTP engine send a STUN BIND request */
-       void (*stun_request)(struct ast_rtp_instance *instance, struct sockaddr_in *suggestion, const char *username);
-       /*! Callback to get the transcodeable formats supported */
-       int (*available_formats)(struct ast_rtp_instance *instance, int to_endpoint, int to_asterisk);
+       void (*stun_request)(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username);
+       /*! Callback to get the transcodeable formats supported. result returned in ast_format_cap *result */
+       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);
+       /*! Callback to send CNG */
+       int (*sendcng)(struct ast_rtp_instance *instance, int level);
+       /*! Callback to pointer for optional ICE support */
+       struct ast_rtp_engine_ice *ice;
+       /*! Callback to pointer for optional DTLS SRTP support */
+       struct ast_rtp_engine_dtls *dtls;
        /*! Linked list information */
        AST_RWLIST_ENTRY(ast_rtp_engine) entry;
 };
 
 /*! Structure that represents codec and packetization information */
 struct ast_rtp_codecs {
-       /*! Codec packetization preferences */
-       struct ast_codec_pref pref;
        /*! Payloads present */
-       struct ast_rtp_payload_type payloads[AST_RTP_MAX_PT];
+       AST_VECTOR(, struct ast_rtp_payload_type *) payloads;
+       /*! The framing for this media session */
+       unsigned int framing;
+       /*! RW lock that protects elements in this structure */
+       ast_rwlock_t codecs_lock;
 };
 
+#define AST_RTP_CODECS_NULL_INIT \
+    { .payloads = { 0, }, .framing = 0, .codecs_lock = AST_RWLOCK_INIT_VALUE, }
+
 /*! Structure that represents the glue that binds an RTP instance to a channel */
 struct ast_rtp_glue {
        /*! Name of the channel driver that this glue is responsible for */
@@ -385,24 +600,49 @@ struct ast_rtp_glue {
         */
        enum ast_rtp_glue_result (*get_rtp_info)(struct ast_channel *chan, struct ast_rtp_instance **instance);
        /*!
+        * \brief Used to prevent two channels from remotely bridging audio rtp if the channel tech has a
+        *        reason for prohibiting it based on qualities that need to be compared from both channels.
+        * \note This function may be NULL for a given channel driver. This should be accounted for and if that is the case, function this is not used.
+        */
+       int (*allow_rtp_remote)(struct ast_channel *chan1, struct ast_rtp_instance *instance);
+       /*!
         * \brief Callback for retrieving the RTP instance carrying video
         * \note This function increases the reference count on the returned RTP instance.
         */
        enum ast_rtp_glue_result (*get_vrtp_info)(struct ast_channel *chan, struct ast_rtp_instance **instance);
        /*!
+        * \brief Used to prevent two channels from remotely bridging video rtp if the channel tech has a
+        *        reason for prohibiting it based on qualities that need to be compared from both channels.
+        * \note This function may be NULL for a given channel driver. This should be accounted for and if that is the case, this function is not used.
+        */
+       int (*allow_vrtp_remote)(struct ast_channel *chan1, struct ast_rtp_instance *instance);
+
+       /*!
         * \brief Callback for retrieving the RTP instance carrying text
         * \note This function increases the reference count on the returned RTP instance.
         */
        enum ast_rtp_glue_result (*get_trtp_info)(struct ast_channel *chan, struct ast_rtp_instance **instance);
        /*! Callback for updating the destination that the remote side should send RTP to */
-       int (*update_peer)(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_rtp_instance *vinstance, struct ast_rtp_instance *tinstance, int codecs, int nat_active);
-       /*! Callback for retrieving codecs that the channel can do */
-       int (*get_codec)(struct ast_channel *chan);
+       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);
+       /*! Callback for retrieving codecs that the channel can do.  Result returned in result_cap. */
+       void (*get_codec)(struct ast_channel *chan, struct ast_format_cap *result_cap);
        /*! Linked list information */
        AST_RWLIST_ENTRY(ast_rtp_glue) entry;
 };
 
-#define ast_rtp_engine_register(engine) ast_rtp_engine_register2(engine, ast_module_info->self)
+/*!
+ * \brief Allocation routine for \ref ast_rtp_payload_type
+ *
+ * \retval NULL on error
+ * \retval An ao2 ref counted \c ast_rtp_payload_type on success.
+ *
+ * \note The \c ast_rtp_payload_type returned by this function is an
+ *       ao2 ref counted object.
+ *
+ */
+struct ast_rtp_payload_type *ast_rtp_engine_alloc_payload_type(void);
+
+#define ast_rtp_engine_register(engine) ast_rtp_engine_register2(engine, AST_MODULE_SELF)
 
 /*!
  * \brief Register an RTP engine
@@ -425,7 +665,7 @@ struct ast_rtp_glue {
  * \note It is recommended that you use the ast_rtp_engine_register macro so that the module is
  *       associated with the RTP engine and use counting is performed.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_engine_register2(struct ast_rtp_engine *engine, struct ast_module *module);
 
@@ -446,11 +686,16 @@ int ast_rtp_engine_register2(struct ast_rtp_engine *engine, struct ast_module *m
  * This unregisters the RTP engine declared as example_rtp_engine from the RTP engine core. If a module
  * reference was provided when it was registered then this will only be called once the RTP engine is no longer in use.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_engine_unregister(struct ast_rtp_engine *engine);
 
-#define ast_rtp_glue_register(glue) ast_rtp_glue_register2(glue, ast_module_info->self)
+int ast_rtp_engine_register_srtp(struct ast_srtp_res *srtp_res, struct ast_srtp_policy_res *policy_res);
+
+void ast_rtp_engine_unregister_srtp(void);
+int ast_rtp_engine_srtp_is_registered(void);
+
+#define ast_rtp_glue_register(glue) ast_rtp_glue_register2(glue, AST_MODULE_SELF)
 
 /*!
  * \brief Register RTP glue
@@ -473,7 +718,7 @@ int ast_rtp_engine_unregister(struct ast_rtp_engine *engine);
  * \note It is recommended that you use the ast_rtp_glue_register macro so that the module is
  *       associated with the RTP glue and use counting is performed.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_glue_register2(struct ast_rtp_glue *glue, struct ast_module *module);
 
@@ -494,7 +739,7 @@ int ast_rtp_glue_register2(struct ast_rtp_glue *glue, struct ast_module *module)
  * This unregisters the RTP glue declared as example_rtp_gkue from the RTP engine core. If a module
  * reference was provided when it was registered then this will only be called once the RTP engine is no longer in use.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_glue_unregister(struct ast_rtp_glue *glue);
 
@@ -503,7 +748,7 @@ int ast_rtp_glue_unregister(struct ast_rtp_glue *glue);
  *
  * \param engine_name Name of the engine to use for the RTP instance
  * \param sched Scheduler context that the RTP engine may want to use
- * \param sin Address we want to bind to
+ * \param sa Address we want to bind to
  * \param data Unique data for the engine
  *
  * \retval non-NULL success
@@ -517,14 +762,16 @@ int ast_rtp_glue_unregister(struct ast_rtp_glue *glue);
  * \endcode
  *
  * This creates a new RTP instance using the default engine and asks the RTP engine to bind to the address given
- * in the sin structure.
+ * in the address structure.
  *
  * \note The RTP engine does not have to use the address provided when creating an RTP instance. It may choose to use
  *       another depending on it's own configuration.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-struct ast_rtp_instance *ast_rtp_instance_new(const char *engine_name, struct sched_context *sched, struct sockaddr_in *sin, void *data);
+struct ast_rtp_instance *ast_rtp_instance_new(const char *engine_name,
+                struct ast_sched_context *sched, const struct ast_sockaddr *sa,
+                void *data);
 
 /*!
  * \brief Destroy an RTP instance
@@ -543,7 +790,7 @@ struct ast_rtp_instance *ast_rtp_instance_new(const char *engine_name, struct sc
  * This destroys the RTP instance pointed to by instance. Once this function returns instance no longer points to valid
  * memory and may not be used again.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_destroy(struct ast_rtp_instance *instance);
 
@@ -562,7 +809,7 @@ int ast_rtp_instance_destroy(struct ast_rtp_instance *instance);
  * This sets the data pointer on the RTP instance pointed to by 'instance' to
  * blob.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_instance_set_data(struct ast_rtp_instance *instance, void *data);
 
@@ -579,7 +826,7 @@ void ast_rtp_instance_set_data(struct ast_rtp_instance *instance, void *data);
  *
  * This gets the data pointer on the RTP instance pointed to by 'instance'.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void *ast_rtp_instance_get_data(struct ast_rtp_instance *instance);
 
@@ -587,6 +834,7 @@ void *ast_rtp_instance_get_data(struct ast_rtp_instance *instance);
  * \brief Send a frame out over RTP
  *
  * \param instance The RTP instance to send frame out on
+ * \param frame the frame to send out
  *
  * \retval 0 success
  * \retval -1 failure
@@ -600,7 +848,7 @@ void *ast_rtp_instance_get_data(struct ast_rtp_instance *instance);
  * This gives the frame pointed to by frame to the RTP engine being used for the instance
  * and asks that it be transmitted to the current remote address set on the RTP instance.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_write(struct ast_rtp_instance *instance, struct ast_frame *frame);
 
@@ -622,34 +870,46 @@ int ast_rtp_instance_write(struct ast_rtp_instance *instance, struct ast_frame *
  *
  * This asks the RTP engine to read in RTP from the instance and return it as an Asterisk frame.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 struct ast_frame *ast_rtp_instance_read(struct ast_rtp_instance *instance, int rtcp);
 
 /*!
- * \brief Set the address of the remote endpoint that we are sending RTP to
+ * \brief Set the incoming source address of the remote endpoint that we are sending RTP to
+ *
+ * This sets the incoming source address the engine is sending RTP to. Usually this
+ * will be the same as the requested target address, however in the case where
+ * the engine "learns" the address (for instance, symmetric RTP enabled) this
+ * will then contain the learned address.
  *
  * \param instance The RTP instance to change the address on
  * \param address Address to set it to
  *
  * \retval 0 success
  * \retval -1 failure
+ */
+int ast_rtp_instance_set_incoming_source_address(struct ast_rtp_instance *instance,
+                                                const struct ast_sockaddr *address);
+
+/*!
+ * \brief Set the requested target address of the remote endpoint
  *
- * Example usage:
+ * This should always be the address of the remote endpoint. Consequently, this can differ
+ * from the address the engine is sending RTP to.  However, usually they will be the same
+ * except in some circumstances (for instance when the engine "learns" the address if
+ * symmetric RTP is enabled).
  *
- * \code
- * ast_rtp_instance_set_remote_address(instance, &sin);
- * \endcode
- *
- * This changes the remote address that RTP will be sent to on instance to the address given in the sin
- * structure.
+ * \param instance The RTP instance to change the address on
+ * \param address Address to set it to
  *
- * \since 1.6.3
+ * \retval 0 success
+ * \retval -1 failure
  */
-int ast_rtp_instance_set_remote_address(struct ast_rtp_instance *instance, struct sockaddr_in *address);
+int ast_rtp_instance_set_requested_target_address(struct ast_rtp_instance *instance,
+                                                 const struct ast_sockaddr *address);
 
 /*!
- * \brief Set the address of an an alternate RTP address to receive from
+ * \brief Set the address of the remote endpoint that we are sending RTP to
  *
  * \param instance The RTP instance to change the address on
  * \param address Address to set it to
@@ -660,15 +920,16 @@ int ast_rtp_instance_set_remote_address(struct ast_rtp_instance *instance, struc
  * Example usage:
  *
  * \code
- * ast_rtp_instance_set_alt_remote_address(instance, &sin);
+ * ast_rtp_instance_set_remote_address(instance, &sin);
  * \endcode
  *
- * This changes the alternate remote address that RTP will be sent to on instance to the address given in the sin
+ * This changes the remote address that RTP will be sent to on instance to the address given in the sin
  * structure.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-int ast_rtp_instance_set_alt_remote_address(struct ast_rtp_instance *instance, struct sockaddr_in *address);
+#define ast_rtp_instance_set_remote_address(instance, address) \
+       ast_rtp_instance_set_requested_target_address((instance), (address));
 
 /*!
  * \brief Set the address that we are expecting to receive RTP on
@@ -688,9 +949,10 @@ int ast_rtp_instance_set_alt_remote_address(struct ast_rtp_instance *instance, s
  * This changes the local address that RTP is expected on to the address given in the sin
  * structure.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-int ast_rtp_instance_set_local_address(struct ast_rtp_instance *instance, struct sockaddr_in *address);
+int ast_rtp_instance_set_local_address(struct ast_rtp_instance *instance,
+                const struct ast_sockaddr *address);
 
 /*!
  * \brief Get the local address that we are expecting RTP on
@@ -698,21 +960,67 @@ int ast_rtp_instance_set_local_address(struct ast_rtp_instance *instance, struct
  * \param instance The RTP instance to get the address from
  * \param address The variable to store the address in
  *
- * \retval 0 success
- * \retval -1 failure
+ * Example usage:
+ *
+ * \code
+ * struct ast_sockaddr address;
+ * ast_rtp_instance_get_local_address(instance, &address);
+ * \endcode
+ *
+ * This gets the local address that we are expecting RTP on and stores it in the 'address' structure.
+ *
+ * \since 1.8
+ */
+void ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address);
+
+/*!
+ * \brief Get the address of the local endpoint that we are sending RTP to, comparing its address to another
  *
+ * \param instance The instance that we want to get the local address for
+ * \param address An initialized address that may be overwritten if the local address is different
+ *
+ * \retval 0 address was not changed
+ * \retval 1 address was changed
  * Example usage:
  *
  * \code
- * struct sockaddr_in sin;
- * ast_rtp_instance_get_local_address(instance, &sin);
+ * struct ast_sockaddr address;
+ * int ret;
+ * ret = ast_rtp_instance_get_and_cmp_local_address(instance, &address);
  * \endcode
  *
- * This gets the local address that we are expecting RTP on and stores it in the 'sin' structure.
+ * This retrieves the current local address set on the instance pointed to by instance and puts the value
+ * into the address structure.
+ *
+ * \since 1.8
+ */
+int ast_rtp_instance_get_and_cmp_local_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address);
+
+/*!
+ * \brief Get the incoming source address of the remote endpoint
+ *
+ * This returns the remote address the engine is sending RTP to. Usually this
+ * will be the same as the requested target address, however in the case where
+ * the engine "learns" the address (for instance, symmetric RTP enabled) this
+ * will then contain the learned address.
+ *
+ * \param instance The instance that we want to get the incoming source address for
+ * \param address A structure to put the address into
+ */
+void ast_rtp_instance_get_incoming_source_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address);
+
+/*!
+ * \brief Get the requested target address of the remote endpoint
+ *
+ * This returns the explicitly set address of a remote endpoint. Meaning this won't change unless
+ * specifically told to change. In most cases this should be the same as the incoming source
+ * address, except in cases where the engine "learns" the address in which case this and the
+ * incoming source address might differ.
  *
- * \since 1.6.3
+ * \param instance The instance that we want to get the requested target address for
+ * \param address A structure to put the address into
  */
-int ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance, struct sockaddr_in *address);
+void ast_rtp_instance_get_requested_target_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address);
 
 /*!
  * \brief Get the address of the remote endpoint that we are sending RTP to
@@ -720,22 +1028,56 @@ int ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance, struct
  * \param instance The instance that we want to get the remote address for
  * \param address A structure to put the address into
  *
- * \retval 0 success
- * \retval -1 failure
+ * Example usage:
+ *
+ * \code
+ * struct ast_sockaddr address;
+ * ast_rtp_instance_get_remote_address(instance, &address);
+ * \endcode
+ *
+ * This retrieves the current remote address set on the instance pointed to by instance and puts the value
+ * into the address structure.
+ *
+ * \since 1.8
+ */
+#define ast_rtp_instance_get_remote_address(instance, address) \
+       ast_rtp_instance_get_incoming_source_address((instance), (address));
+
+/*!
+ * \brief Get the requested target address of the remote endpoint and
+ *        compare it to the given address
+ *
+ * \param instance The instance that we want to get the remote address for
+ * \param address An initialized address that may be overwritten addresses differ
+ *
+ * \retval 0 address was not changed
+ * \retval 1 address was changed
+ */
+int ast_rtp_instance_get_and_cmp_requested_target_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address);
+
+/*!
+ * \brief Get the address of the remote endpoint that we are sending RTP to, comparing its address to another
+ *
+ * \param instance The instance that we want to get the remote address for
+ * \param address An initialized address that may be overwritten if the remote address is different
  *
+ * \retval 0 address was not changed
+ * \retval 1 address was changed
  * Example usage:
  *
  * \code
- * struct sockaddr_in sin;
- * ast_rtp_instance_get_remote_address(instance, &sin);
+ * struct ast_sockaddr address;
+ * int ret;
+ * ret = ast_rtp_instance_get_and_cmp_remote_address(instance, &address);
  * \endcode
  *
  * This retrieves the current remote address set on the instance pointed to by instance and puts the value
- * into the sin structure.
+ * into the address structure.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-int ast_rtp_instance_get_remote_address(struct ast_rtp_instance *instance, struct sockaddr_in *address);
+#define ast_rtp_instance_get_and_cmp_remote_address(instance, address) \
+       ast_rtp_instance_get_and_cmp_requested_target_address((instance), (address));
 
 /*!
  * \brief Set the value of an RTP instance extended property
@@ -744,7 +1086,7 @@ int ast_rtp_instance_get_remote_address(struct ast_rtp_instance *instance, struc
  * \param property The extended property to set
  * \param value The value to set the extended property to
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_instance_set_extended_prop(struct ast_rtp_instance *instance, int property, void *value);
 
@@ -754,7 +1096,7 @@ void ast_rtp_instance_set_extended_prop(struct ast_rtp_instance *instance, int p
  * \param instance The RTP instance to get the extended property on
  * \param property The extended property to get
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void *ast_rtp_instance_get_extended_prop(struct ast_rtp_instance *instance, int property);
 
@@ -773,7 +1115,7 @@ void *ast_rtp_instance_get_extended_prop(struct ast_rtp_instance *instance, int
  *
  * This enables the AST_RTP_PROPERTY_NAT property on the instance pointed to by instance.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_instance_set_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value);
 
@@ -793,7 +1135,7 @@ void ast_rtp_instance_set_prop(struct ast_rtp_instance *instance, enum ast_rtp_p
  *
  * This returns the current value of the NAT property on the instance pointed to by instance.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_get_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property);
 
@@ -810,53 +1152,69 @@ int ast_rtp_instance_get_prop(struct ast_rtp_instance *instance, enum ast_rtp_pr
  *
  * This gets the codecs structure on the RTP instance pointed to by 'instance'.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 struct ast_rtp_codecs *ast_rtp_instance_get_codecs(struct ast_rtp_instance *instance);
 
 /*!
- * \brief Clear payload information from an RTP instance
+ * \brief Initialize an RTP codecs structure
  *
- * \param codecs The codecs structure that payloads will be cleared from
- * \param instance Optionally the instance that the codecs structure belongs to
+ * \param codecs The codecs structure to initialize
+ *
+ * \retval 0 success
+ * \retval -1 failure
  *
  * Example usage:
  *
  * \code
  * struct ast_rtp_codecs codecs;
- * ast_rtp_codecs_payloads_clear(&codecs, NULL);
+ * ast_rtp_codecs_payloads_initialize(&codecs);
  * \endcode
  *
- * This clears the codecs structure and puts it into a pristine state.
+ * \since 11
+ */
+int ast_rtp_codecs_payloads_initialize(struct ast_rtp_codecs *codecs);
+
+/*!
+ * \brief Destroy the contents of an RTP codecs structure (but not the structure itself)
  *
- * \since 1.6.3
+ * \param codecs The codecs structure to destroy the contents of
+ *
+ * Example usage:
+ *
+ * \code
+ * struct ast_rtp_codecs codecs;
+ * ast_rtp_codecs_payloads_destroy(&codecs);
+ * \endcode
+ *
+ * \since 11
  */
-void ast_rtp_codecs_payloads_clear(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance);
+void ast_rtp_codecs_payloads_destroy(struct ast_rtp_codecs *codecs);
 
 /*!
- * \brief Set payload information on an RTP instance to the default
+ * \brief Clear payload information from an RTP instance
  *
- * \param codecs The codecs structure to set defaults on
+ * \param codecs The codecs structure that payloads will be cleared from
  * \param instance Optionally the instance that the codecs structure belongs to
  *
  * Example usage:
  *
  * \code
  * struct ast_rtp_codecs codecs;
- * ast_rtp_codecs_payloads_default(&codecs, NULL);
+ * ast_rtp_codecs_payloads_clear(&codecs, NULL);
  * \endcode
  *
- * This sets the default payloads on the codecs structure.
+ * This clears the codecs structure and puts it into a pristine state.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-void ast_rtp_codecs_payloads_default(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance);
+void ast_rtp_codecs_payloads_clear(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance);
 
 /*!
  * \brief Copy payload information from one RTP instance to another
  *
  * \param src The source codecs structure
- * \param dst The destination codecs structure that the values from src will be copied to
+ * \param dest The destination codecs structure that the values from src will be copied to
  * \param instance Optionally the instance that the dst codecs structure belongs to
  *
  * Example usage:
@@ -867,7 +1225,7 @@ void ast_rtp_codecs_payloads_default(struct ast_rtp_codecs *codecs, struct ast_r
  *
  * This copies the payloads from the codecs0 structure to the codecs1 structure, overwriting any current values.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_codecs_payloads_copy(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance);
 
@@ -886,7 +1244,7 @@ void ast_rtp_codecs_payloads_copy(struct ast_rtp_codecs *src, struct ast_rtp_cod
  *
  * This records that the numerical payload '0' was seen in the codecs structure.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_codecs_payloads_set_m_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload);
 
@@ -901,7 +1259,8 @@ void ast_rtp_codecs_payloads_set_m_type(struct ast_rtp_codecs *codecs, struct as
  * \param options Optional options that may change the behavior of this specific payload
  *
  * \retval 0 success
- * \retval -1 failure
+ * \retval -1 failure, invalid payload numbe
+ * \retval -2 failure, unknown mimetype
  *
  * Example usage:
  *
@@ -911,14 +1270,14 @@ void ast_rtp_codecs_payloads_set_m_type(struct ast_rtp_codecs *codecs, struct as
  *
  * This records that the numerical payload '0' was seen with mime type 'audio' and sub mime type 'PCMU' in the codecs structure.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 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);
 
 /*!
  * \brief Set payload type to a known MIME media type for a codec with a specific sample rate
  *
- * \param rtp RTP structure to modify
+ * \param codecs RTP structure to modify
  * \param instance Optionally the instance that the codecs structure belongs to
  * \param pt Payload type entry to modify
  * \param mimetype top-level MIME type of media stream (typically "audio", "video", "text", etc.)
@@ -933,7 +1292,7 @@ int ast_rtp_codecs_payloads_set_rtpmap_type(struct ast_rtp_codecs *codecs, struc
  * \retval -1 if the payload type is out of range
  * \retval -2 if the mimeType/mimeSubtype combination was not found
  *
- * \since 1.6.3
+ * \since 1.8
  */
 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,
@@ -955,7 +1314,7 @@ int ast_rtp_codecs_payloads_set_rtpmap_type_rate(struct ast_rtp_codecs *codecs,
  *
  * This clears the payload '0' from the codecs structure. It will be as if it was never set.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_codecs_payloads_unset(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload);
 
@@ -965,59 +1324,115 @@ void ast_rtp_codecs_payloads_unset(struct ast_rtp_codecs *codecs, struct ast_rtp
  * \param codecs Codecs structure to look in
  * \param payload Numerical payload to look up
  *
- * \retval Payload information
+ * \retval Payload information.
+ * \retval NULL if payload does not exist.
+ *
+ * \note The payload returned by this function has its reference count increased.
+ *       Callers are responsible for decrementing the reference count.
  *
  * Example usage:
  *
  * \code
- * struct ast_rtp_payload_type payload_type;
- * payload_type = ast_rtp_codecs_payload_lookup(&codecs, 0);
+ * struct ast_rtp_payload_type *payload_type;
+ * payload_type = ast_rtp_codecs_get_payload(&codecs, 0);
  * \endcode
  *
  * This looks up the information for payload '0' from the codecs structure.
+ */
+struct ast_rtp_payload_type *ast_rtp_codecs_get_payload(struct ast_rtp_codecs *codecs, int payload);
+
+/*!
+ * \brief Update the format associated with a payload in a codecs structure
+ *
+ * \param codecs Codecs structure to operate on
+ * \param payload Numerical payload to look up
+ * \param format The format to replace the existing one
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ *
+ * \since 13
+ */
+int ast_rtp_codecs_payload_replace_format(struct ast_rtp_codecs *codecs, int payload, struct ast_format *format);
+
+/*!
+ * \brief Retrieve the actual ast_format stored on the codecs structure for a specific payload
+ *
+ * \param codecs Codecs structure to look in
+ * \param payload Numerical payload to look up
+ *
+ * \retval pointer to format structure on success
+ * \retval NULL on failure
+ *
+ * \note The format returned by this function has its reference count increased.
+ *       Callers are responsible for decrementing the reference count.
+ *
+ * \since 10.0
+ */
+struct ast_format *ast_rtp_codecs_get_payload_format(struct ast_rtp_codecs *codecs, int payload);
+
+/*!
+ * \brief Set the framing used for a set of codecs
+ *
+ * \param codecs Codecs structure to set framing on
+ * \param framing The framing value to set on the codecs
+ *
+ * \since 13.0.0
+ */
+void ast_rtp_codecs_set_framing(struct ast_rtp_codecs *codecs, unsigned int framing);
+
+/*!
+ * \brief Get the framing used for a set of codecs
+ *
+ * \param codecs Codecs structure to get the framing from
+ *
+ * \retval The framing to be used for the media stream associated with these codecs
  *
- * \since 1.6.3
+ * \since 13.0.0
  */
-struct ast_rtp_payload_type ast_rtp_codecs_payload_lookup(struct ast_rtp_codecs *codecs, int payload);
+unsigned int ast_rtp_codecs_get_framing(struct ast_rtp_codecs *codecs);
 
 /*!
  * \brief Get the sample rate associated with known RTP payload types
  *
- * \param asterisk_format True if the value in the 'code' parameter is an AST_FORMAT value
- * \param code Format code, either from AST_FORMAT list or from AST_RTP list
+ * \param asterisk_format True if the value in format is to be used.
+ * \param format An asterisk format
+ * \param code from AST_RTP list
  *
  * \return the sample rate if the format was found, zero if it was not found
  *
- * \since 1.6.3
+ * \since 1.8
  */
-unsigned int ast_rtp_lookup_sample_rate2(int asterisk_format, int code);
+unsigned int ast_rtp_lookup_sample_rate2(int asterisk_format, struct ast_format *format, int code);
 
 /*!
  * \brief Retrieve all formats that were found
  *
  * \param codecs Codecs structure to look in
- * \param astFormats An integer to put the Asterisk formats in
+ * \param astformats A capabilities structure to put the Asterisk formats in.
  * \param nonastformats An integer to put the non-Asterisk formats in
  *
  * Example usage:
  *
  * \code
- * int astformats, nonastformats;
- * ast_rtp_codecs_payload_Formats(&codecs, &astformats, &nonastformats);
+ * struct ast_format_cap *astformats = ast_format_cap_alloc_nolock()
+ * int nonastformats;
+ * ast_rtp_codecs_payload_formats(&codecs, astformats, &nonastformats);
  * \endcode
  *
  * This retrieves all the formats known about in the codecs structure and puts the Asterisk ones in the integer
  * pointed to by astformats and the non-Asterisk ones in the integer pointed to by nonastformats.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-void ast_rtp_codecs_payload_formats(struct ast_rtp_codecs *codecs, int *astformats, int *nonastformats);
+void ast_rtp_codecs_payload_formats(struct ast_rtp_codecs *codecs, struct ast_format_cap *astformats, int *nonastformats);
 
 /*!
  * \brief Retrieve a payload based on whether it is an Asterisk format and the code
  *
  * \param codecs Codecs structure to look in
- * \param asterisk_format Non-zero if the given code is an Asterisk format value
+ * \param asterisk_format Non-zero if the given Asterisk format is present
+ * \param format Asterisk format to look for
  * \param code The format to look for
  *
  * \retval Numerical payload
@@ -1025,79 +1440,86 @@ void ast_rtp_codecs_payload_formats(struct ast_rtp_codecs *codecs, int *astforma
  * Example usage:
  *
  * \code
- * int payload = ast_rtp_codecs_payload_code(&codecs, 1, AST_FORMAT_ULAW);
+ * int payload = ast_rtp_codecs_payload_code(&codecs, 1, ast_format_set(&tmp_fmt, AST_FORMAT_ULAW, 0), 0);
  * \endcode
  *
  * This looks for the numerical payload for ULAW in the codecs structure.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-int ast_rtp_codecs_payload_code(struct ast_rtp_codecs *codecs, const int asterisk_format, const int code);
+int ast_rtp_codecs_payload_code(struct ast_rtp_codecs *codecs, int asterisk_format, const struct ast_format *format, int code);
 
 /*!
- * \brief Retrieve mime subtype information on a payload
+ * \brief Search for a payload code in the ast_rtp_codecs structure
  *
- * \param asterisk_format Non-zero if the given code is an Asterisk format value
- * \param code Format to look up
- * \param options Additional options that may change the result
+ * \param codecs Codecs structure to look in
+ * \param code The format to look for
  *
- * \retval Mime subtype success
- * \retval NULL failure
+ * \retval Numerical payload or -1 if unable to find payload in codecs
  *
  * Example usage:
  *
  * \code
- * const char *subtype = ast_rtp_lookup_mime_subtype2(1, AST_FORMAT_ULAW, 0);
+ * int payload = ast_rtp_codecs_payload_code(&codecs, 0);
  * \endcode
  *
- * This looks up the mime subtype for the ULAW format.
+ * This looks for the numerical payload for ULAW in the codecs structure.
  *
- * \since 1.6.3
  */
-const char *ast_rtp_lookup_mime_subtype2(const int asterisk_format, const int code, enum ast_rtp_options options);
+int ast_rtp_codecs_find_payload_code(struct ast_rtp_codecs *codecs, int code);
 
 /*!
- * \brief Convert formats into a string and put them into a buffer
+ * \brief Retrieve mime subtype information on a payload
  *
- * \param buf Buffer to put the mime output into
- * \param capability Formats that we are looking up
- * \param asterisk_format Non-zero if the given capability are Asterisk format capabilities
+ * \param asterisk_format Non-zero to look up using Asterisk format
+ * \param format Asterisk format to look up
+ * \param code RTP code to look up
  * \param options Additional options that may change the result
  *
- * \retval non-NULL success
+ * \retval Mime subtype success
  * \retval NULL failure
  *
  * Example usage:
  *
  * \code
- * char buf[256] = "";
- * char *mime = ast_rtp_lookup_mime_multiple2(&buf, sizeof(buf), AST_FORMAT_ULAW | AST_FORMAT_ALAW, 1, 0);
+ * const char *subtype = ast_rtp_lookup_mime_subtype2(1, ast_format_set(&tmp_fmt, AST_FORMAT_ULAW, 0), 0, 0);
  * \endcode
  *
- * This returns the mime values for ULAW and ALAW in the buffer pointed to by buf.
+ * This looks up the mime subtype for the ULAW format.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-char *ast_rtp_lookup_mime_multiple2(struct ast_str *buf, const int capability, const int asterisk_format, enum ast_rtp_options options);
+const char *ast_rtp_lookup_mime_subtype2(const int asterisk_format, struct ast_format *format, int code, enum ast_rtp_options options);
 
 /*!
- * \brief Set codec packetization preferences
+ * \brief Convert formats into a string and put them into a buffer
  *
- * \param codecs Codecs structure to muck with
- * \param instance Optionally the instance that the codecs structure belongs to
- * \param prefs Codec packetization preferences
+ * \param buf Buffer to put the mime output into
+ * \param ast_format_capability Asterisk Formats we are looking up.
+ * \param rtp_capability RTP codes that we are looking up
+ * \param asterisk_format Non-zero if the ast_format_capability structure is to be used, 0 if rtp_capability is to be used
+ * \param options Additional options that may change the result
+ *
+ * \retval non-NULL success
+ * \retval NULL failure
  *
  * Example usage:
  *
  * \code
- * ast_rtp_codecs_packetization_set(&codecs, NULL, &prefs);
+ * char buf[256] = "";
+ * struct ast_format tmp_fmt;
+ * struct ast_format_cap *cap = ast_format_cap_alloc_nolock();
+ * ast_format_cap_append(cap, ast_format_set(&tmp_fmt, AST_FORMAT_ULAW, 0));
+ * ast_format_cap_append(cap, ast_format_set(&tmp_fmt, AST_FORMAT_GSM, 0));
+ * char *mime = ast_rtp_lookup_mime_multiple2(&buf, sizeof(buf), cap, 0, 1, 0);
+ * ast_format_cap_destroy(cap);
  * \endcode
  *
- * This sets the packetization preferences pointed to by prefs on the codecs structure pointed to by codecs.
+ * This returns the mime values for ULAW and ALAW in the buffer pointed to by buf.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-void ast_rtp_codecs_packetization_set(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, struct ast_codec_pref *prefs);
+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);
 
 /*!
  * \brief Begin sending a DTMF digit
@@ -1117,7 +1539,7 @@ void ast_rtp_codecs_packetization_set(struct ast_rtp_codecs *codecs, struct ast_
  * This starts sending the DTMF '1' on the RTP instance pointed to by instance. It will
  * continue being sent until it is ended.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_dtmf_begin(struct ast_rtp_instance *instance, char digit);
 
@@ -1138,9 +1560,10 @@ int ast_rtp_instance_dtmf_begin(struct ast_rtp_instance *instance, char digit);
  *
  * This stops sending the DTMF '1' on the RTP instance pointed to by instance.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_dtmf_end(struct ast_rtp_instance *instance, char digit);
+int ast_rtp_instance_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration);
 
 /*!
  * \brief Set the DTMF mode that should be used
@@ -1159,7 +1582,7 @@ int ast_rtp_instance_dtmf_end(struct ast_rtp_instance *instance, char digit);
  *
  * This sets the RTP instance to use RFC2833 for DTMF transmission and receiving.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode);
 
@@ -1178,27 +1601,45 @@ int ast_rtp_instance_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_r
  *
  * This gets the DTMF mode set on the RTP instance pointed to by 'instance'.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 enum ast_rtp_dtmf_mode ast_rtp_instance_dtmf_mode_get(struct ast_rtp_instance *instance);
 
 /*!
- * \brief Indicate a new source of audio has dropped in
+ * \brief Indicate that the RTP marker bit should be set on an RTP stream
+ *
+ * \param instance Instance that the new media source is feeding into
+ *
+ * Example usage:
+ *
+ * \code
+ * ast_rtp_instance_update_source(instance);
+ * \endcode
+ *
+ * This indicates that the source of media that is feeding the instance pointed to by
+ * instance has been updated and that the marker bit should be set.
+ *
+ * \since 1.8
+ */
+void ast_rtp_instance_update_source(struct ast_rtp_instance *instance);
+
+/*!
+ * \brief Indicate a new source of audio has dropped in and the ssrc should change
  *
  * \param instance Instance that the new media source is feeding into
  *
  * Example usage:
  *
  * \code
- * ast_rtp_instance_new_source(instance);
+ * ast_rtp_instance_change_source(instance);
  * \endcode
  *
- * This indicates that a new source of media is feeding the instance pointed to by
- * instance.
+ * This indicates that the source of media that is feeding the instance pointed to by
+ * instance has changed and that the marker bit should be set and the SSRC updated.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-void ast_rtp_instance_new_source(struct ast_rtp_instance *instance);
+void ast_rtp_instance_change_source(struct ast_rtp_instance *instance);
 
 /*!
  * \brief Set QoS parameters on an RTP session
@@ -1219,7 +1660,7 @@ void ast_rtp_instance_new_source(struct ast_rtp_instance *instance);
  *
  * This sets the TOS and COS values to 0 on the instance pointed to by instance.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_set_qos(struct ast_rtp_instance *instance, int tos, int cos, const char *desc);
 
@@ -1237,7 +1678,7 @@ int ast_rtp_instance_set_qos(struct ast_rtp_instance *instance, int tos, int cos
  * This tells the RTP engine being used for the instance pointed to by instance
  * that media is no longer going to it at this time, but may in the future.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_instance_stop(struct ast_rtp_instance *instance);
 
@@ -1259,7 +1700,7 @@ void ast_rtp_instance_stop(struct ast_rtp_instance *instance);
  * This retrieves the file descriptor for the socket carrying media on the instance
  * pointed to by instance.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp);
 
@@ -1279,27 +1720,33 @@ int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp);
  *
  * This retrieves the RTP glue that has the name 'Example'.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 struct ast_rtp_glue *ast_rtp_instance_get_glue(const char *type);
 
 /*!
- * \brief Bridge two channels that use RTP instances
+ * \brief Get the unique ID of the channel that owns this RTP instance
  *
- * \param c0 First channel part of the bridge
- * \param c1 Second channel part of the bridge
- * \param flags Bridging flags
- * \param fo If a frame needs to be passed up it is stored here
- * \param rc Channel that passed the above frame up
- * \param timeoutms How long the channels should be bridged for
+ * Note that this should remain valid for the lifetime of the RTP instance.
  *
- * \retval Bridge result
+ * \param instance The RTP instance
  *
- * \note This should only be used by channel drivers in their technology declaration.
+ * \retval The unique ID of the channel
+ * \retval Empty string if no channel owns this RTP instance
  *
- * \since 1.6.3
+ * \since 12
  */
-enum ast_bridge_result ast_rtp_instance_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms);
+const char *ast_rtp_instance_get_channel_id(struct ast_rtp_instance *instance);
+
+/*!
+ * \brief Set the channel that owns this RTP instance
+ *
+ * \param instance The RTP instance
+ * \param uniqueid The uniqueid of the channel
+ *
+ * \since 12
+ */
+void ast_rtp_instance_set_channel_id(struct ast_rtp_instance *instance, const char *uniqueid);
 
 /*!
  * \brief Get the other RTP instance that an instance is bridged to
@@ -1317,19 +1764,29 @@ enum ast_bridge_result ast_rtp_instance_bridge(struct ast_channel *c0, struct as
  *
  * This gets the RTP instance that instance0 is bridged to.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 struct ast_rtp_instance *ast_rtp_instance_get_bridged(struct ast_rtp_instance *instance);
 
 /*!
+ * \brief Set the other RTP instance that an instance is bridged to
+ *
+ * \param instance The RTP instance that we want to set the bridged value on
+ * \param bridged The RTP instance they are bridged to
+ *
+ * \since 12
+ */
+void ast_rtp_instance_set_bridged(struct ast_rtp_instance *instance, struct ast_rtp_instance *bridged);
+
+/*!
  * \brief Make two channels compatible for early bridging
  *
- * \param c0 First channel part of the bridge
- * \param c1 Second channel part of the bridge
+ * \param c_dst Destination channel to copy to
+ * \param c_src Source channel to copy from
  *
- * \since 1.6.3
+ * \since 1.8
  */
-void ast_rtp_instance_early_bridge_make_compatible(struct ast_channel *c0, struct ast_channel *c1);
+void ast_rtp_instance_early_bridge_make_compatible(struct ast_channel *c_dst, struct ast_channel *c_src);
 
 /*!
  * \brief Early bridge two channels that use RTP instances
@@ -1342,7 +1799,7 @@ void ast_rtp_instance_early_bridge_make_compatible(struct ast_channel *c0, struc
  *
  * \note This should only be used by channel drivers in their technology declaration.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_early_bridge(struct ast_channel *c0, struct ast_channel *c1);
 
@@ -1357,7 +1814,7 @@ int ast_rtp_instance_early_bridge(struct ast_channel *c0, struct ast_channel *c1
  * \retval 0 success
  * \retval -1 failure
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations);
 
@@ -1370,7 +1827,7 @@ int ast_rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *pa
  * \retval 0 success
  * \retval -1 failure
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame);
 
@@ -1394,7 +1851,7 @@ int ast_rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *fram
  * This retrieves all statistics the underlying RTP engine supports and puts the values into the
  * stats structure.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_get_stats(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat);
 
@@ -1404,6 +1861,8 @@ int ast_rtp_instance_get_stats(struct ast_rtp_instance *instance, struct ast_rtp
  * \param chan Channel to set the statistics on
  * \param instance The RTP instance that statistics will be retrieved from
  *
+ * \note Absolutely _NO_ channel locks should be held before calling this function.
+ *
  * Example usage:
  *
  * \code
@@ -1413,7 +1872,7 @@ int ast_rtp_instance_get_stats(struct ast_rtp_instance *instance, struct ast_rtp
  * This retrieves standard statistics from the RTP instance rtp and sets it on the channel pointed to
  * by chan.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_instance_set_stats_vars(struct ast_channel *chan, struct ast_rtp_instance *instance);
 
@@ -1437,7 +1896,7 @@ void ast_rtp_instance_set_stats_vars(struct ast_channel *chan, struct ast_rtp_in
  *
  * This retrieves general quality statistics and places a text representation into the buf pointed to by buf.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 char *ast_rtp_instance_get_quality(struct ast_rtp_instance *instance, enum ast_rtp_instance_stat_field field, char *buf, size_t size);
 
@@ -1453,14 +1912,15 @@ char *ast_rtp_instance_get_quality(struct ast_rtp_instance *instance, enum ast_r
  * Example usage:
  *
  * \code
- * ast_rtp_instance_set_read_format(instance, AST_FORMAT_ULAW);
+ * struct ast_format tmp_fmt;
+ * ast_rtp_instance_set_read_format(instance, ast_format_set(&tmp_fmt, AST_FORMAT_ULAW, 0));
  * \endcode
  *
  * This requests that the RTP engine provide audio frames in the ULAW format.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-int ast_rtp_instance_set_read_format(struct ast_rtp_instance *instance, int format);
+int ast_rtp_instance_set_read_format(struct ast_rtp_instance *instance, struct ast_format *format);
 
 /*!
  * \brief Tell underlying RTP engine that audio frames will be provided in a specific format
@@ -1474,14 +1934,15 @@ int ast_rtp_instance_set_read_format(struct ast_rtp_instance *instance, int form
  * Example usage:
  *
  * \code
- * ast_rtp_instance_set_write_format(instance, AST_FORMAT_ULAW);
+ * struct ast_format tmp_fmt;
+ * ast_rtp_instance_set_write_format(instance, ast_format_set(&tmp_fmt, AST_FORMAT_ULAW, 0));
  * \endcode
  *
  * This tells the underlying RTP engine that audio frames will be provided to it in ULAW format.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-int ast_rtp_instance_set_write_format(struct ast_rtp_instance *instance, int format);
+int ast_rtp_instance_set_write_format(struct ast_rtp_instance *instance, struct ast_format *format);
 
 /*!
  * \brief Request that the underlying RTP engine make two RTP instances compatible with eachother
@@ -1501,7 +1962,7 @@ int ast_rtp_instance_set_write_format(struct ast_rtp_instance *instance, int for
  *
  * This makes the RTP instance for 'peer' compatible with 'instance' and vice versa.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_make_compatible(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_channel *peer);
 
@@ -1510,20 +1971,19 @@ int ast_rtp_instance_make_compatible(struct ast_channel *chan, struct ast_rtp_in
  * \param instance The RTP instance
  * \param to_endpoint Formats being sent/received towards the endpoint
  * \param to_asterisk Formats being sent/received towards Asterisk
- *
- * \retval supported formats
+ * \param result capabilities structure to store and return supported formats in.
  *
  * Example usage:
  *
  * \code
- * ast_rtp_instance_available_formats(instance, AST_FORMAT_ULAW, AST_FORMAT_SLINEAR);
+ * ast_rtp_instance_available_formats(instance, to_capabilities, from_capabilities, result_capabilities);
  * \endcode
  *
  * This sees if it is possible to have ulaw communicated to the endpoint but signed linear received into Asterisk.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-int ast_rtp_instance_available_formats(struct ast_rtp_instance *instance, int to_endpoint, int to_asterisk);
+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);
 
 /*!
  * \brief Indicate to the RTP engine that packets are now expected to be sent/received on the RTP instance
@@ -1541,7 +2001,7 @@ int ast_rtp_instance_available_formats(struct ast_rtp_instance *instance, int to
  *
  * This tells the underlying RTP engine of instance that packets will now flow.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_activate(struct ast_rtp_instance *instance);
 
@@ -1561,9 +2021,9 @@ int ast_rtp_instance_activate(struct ast_rtp_instance *instance);
  * This requests that the RTP engine send a STUN BIND request on the session pointed to by
  * 'instance'.
  *
- * \since 1.6.3
+ * \since 1.8
  */
-void ast_rtp_instance_stun_request(struct ast_rtp_instance *instance, struct sockaddr_in *suggestion, const char *username);
+void ast_rtp_instance_stun_request(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username);
 
 /*!
  * \brief Set the RTP timeout value
@@ -1579,7 +2039,7 @@ void ast_rtp_instance_stun_request(struct ast_rtp_instance *instance, struct soc
  *
  * This sets the RTP timeout value on 'instance' to be 5000.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_instance_set_timeout(struct ast_rtp_instance *instance, int timeout);
 
@@ -1597,11 +2057,29 @@ void ast_rtp_instance_set_timeout(struct ast_rtp_instance *instance, int timeout
  *
  * This sets the RTP hold timeout value on 'instance' to be 5000.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 void ast_rtp_instance_set_hold_timeout(struct ast_rtp_instance *instance, int timeout);
 
 /*!
+ * \brief Set the RTP keepalive interval
+ *
+ * \param instance The RTP instance
+ * \param timeout Value to set the keepalive interval to
+ *
+ * Example usage:
+ *
+ * \code
+ * ast_rtp_instance_set_keepalive(instance, 5000);
+ * \endcode
+ *
+ * This sets the RTP keepalive interval on 'instance' to be 5000.
+ *
+ * \since 1.8
+ */
+void ast_rtp_instance_set_keepalive(struct ast_rtp_instance *instance, int timeout);
+
+/*!
  * \brief Get the RTP timeout value
  *
  * \param instance The RTP instance
@@ -1616,7 +2094,7 @@ void ast_rtp_instance_set_hold_timeout(struct ast_rtp_instance *instance, int ti
  *
  * This gets the RTP timeout value for the RTP instance pointed to by 'instance'.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_get_timeout(struct ast_rtp_instance *instance);
 
@@ -1635,11 +2113,30 @@ int ast_rtp_instance_get_timeout(struct ast_rtp_instance *instance);
  *
  * This gets the RTP hold timeout value for the RTP instance pointed to by 'instance'.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 int ast_rtp_instance_get_hold_timeout(struct ast_rtp_instance *instance);
 
 /*!
+ * \brief Get the RTP keepalive interval
+ *
+ * \param instance The RTP instance
+ *
+ * \retval period Keepalive interval value
+ *
+ * Example usage:
+ *
+ * \code
+ * int interval = ast_rtp_instance_get_keepalive(instance);
+ * \endcode
+ *
+ * This gets the RTP keepalive interval value for the RTP instance pointed to by 'instance'.
+ *
+ * \since 1.8
+ */
+int ast_rtp_instance_get_keepalive(struct ast_rtp_instance *instance);
+
+/*!
  * \brief Get the RTP engine in use on an RTP instance
  *
  * \param instance The RTP instance
@@ -1654,10 +2151,205 @@ int ast_rtp_instance_get_hold_timeout(struct ast_rtp_instance *instance);
  *
  * This gets the RTP engine currently in use on the RTP instance pointed to by 'instance'.
  *
- * \since 1.6.3
+ * \since 1.8
  */
 struct ast_rtp_engine *ast_rtp_instance_get_engine(struct ast_rtp_instance *instance);
 
+/*!
+ * \brief Get the RTP glue in use on an RTP instance
+ *
+ * \param instance The RTP instance
+ *
+ * \retval pointer to the glue
+ *
+ * Example:
+ *
+ * \code
+ * struct ast_rtp_glue *glue = ast_rtp_instance_get_active_glue(instance);
+ * \endcode
+ *
+ * This gets the RTP glue currently in use on the RTP instance pointed to by 'instance'.
+ *
+ * \since 1.8
+ */
+struct ast_rtp_glue *ast_rtp_instance_get_active_glue(struct ast_rtp_instance *instance);
+
+/*!
+ * \brief Send a comfort noise packet to the RTP instance
+ *
+ * \param instance The RTP instance
+ * \param level Magnitude of the noise level
+ *
+ * \retval 0 Success
+ * \retval non-zero Failure
+ */
+int ast_rtp_instance_sendcng(struct ast_rtp_instance *instance, int level);
+
+/*!
+ * \brief Add or replace the SRTP policies for the given RTP instance
+ *
+ * \param instance the RTP instance
+ * \param remote_policy the remote endpoint's policy
+ * \param local_policy our policy for this RTP instance's remote endpoint
+ *
+ * \retval 0 Success
+ * \retval non-zero Failure
+ */
+int ast_rtp_instance_add_srtp_policy(struct ast_rtp_instance *instance, struct ast_srtp_policy* remote_policy, struct ast_srtp_policy *local_policy);
+
+/*!
+ * \brief Obtain the SRTP instance associated with an RTP instance
+ *
+ * \param instance the RTP instance
+ * \retval the SRTP instance on success
+ * \retval NULL if no SRTP instance exists
+ */
+struct ast_srtp *ast_rtp_instance_get_srtp(struct ast_rtp_instance *instance);
+
+/*! \brief Custom formats declared in codecs.conf at startup must be communicated to the rtp_engine
+ * so their mime type can payload number can be initialized. */
+int ast_rtp_engine_load_format(struct ast_format *format);
+
+/*! \brief Formats requiring the use of a format attribute interface must have that
+ * interface registered in order for the rtp engine to handle it correctly.  If an
+ * attribute interface is unloaded, this function must be called to notify the rtp_engine. */
+int ast_rtp_engine_unload_format(struct ast_format *format);
+
+/*!
+ * \brief Obtain a pointer to the ICE support present on an RTP instance
+ *
+ * \param instance the RTP instance
+ *
+ * \retval ICE support if present
+ * \retval NULL if no ICE support available
+ */
+struct ast_rtp_engine_ice *ast_rtp_instance_get_ice(struct ast_rtp_instance *instance);
+
+/*!
+ * \brief Obtain a pointer to the DTLS support present on an RTP instance
+ *
+ * \param instance the RTP instance
+ *
+ * \retval DTLS support if present
+ * \retval NULL if no DTLS support available
+ */
+struct ast_rtp_engine_dtls *ast_rtp_instance_get_dtls(struct ast_rtp_instance *instance);
+
+/*!
+ * \brief Parse DTLS related configuration options
+ *
+ * \param dtls_cfg a DTLS configuration structure
+ * \param name name of the configuration option
+ * \param value value of the configuration option
+ *
+ * \retval 0 if handled
+ * \retval -1 if not handled
+ */
+int ast_rtp_dtls_cfg_parse(struct ast_rtp_dtls_cfg *dtls_cfg, const char *name, const char *value);
+
+/*!
+ * \brief Copy contents of a DTLS configuration structure
+ *
+ * \param src_cfg source DTLS configuration structure
+ * \param dst_cfg destination DTLS configuration structure
+ */
+void ast_rtp_dtls_cfg_copy(const struct ast_rtp_dtls_cfg *src_cfg, struct ast_rtp_dtls_cfg *dst_cfg);
+
+/*!
+ * \brief Free contents of a DTLS configuration structure
+ *
+ * \param dtls_cfg a DTLS configuration structure
+ */
+void ast_rtp_dtls_cfg_free(struct ast_rtp_dtls_cfg *dtls_cfg);
+
+struct ast_json;
+
+/*!
+ * \brief Allocate an ao2 ref counted instance of \ref ast_rtp_rtcp_report
+ *
+ * \param report_blocks The number of report blocks to allocate
+ * \retval An ao2 ref counted \ref ast_rtp_rtcp_report object on success
+ * \retval NULL on error
+ */
+struct ast_rtp_rtcp_report *ast_rtp_rtcp_report_alloc(unsigned int report_blocks);
+
+/*!
+ * \since 12
+ * \brief Publish an RTCP message to \ref stasis
+ *
+ * \param rtp The rtp instance object
+ * \param message_type The RTP message type to publish
+ * \param report The RTCP report object to publish. This should be an ao2 ref counted
+ *  object. This routine will increase the reference count of the object.
+ * \param blob Additional JSON objects to publish along with the RTCP information
+ */
+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);
+
+/*!
+ * \brief Get the last RTP transmission time
+ *
+ * \param rtp The instance from which to get the last transmission time
+ * \return The last RTP transmission time
+ */
+time_t ast_rtp_instance_get_last_tx(const struct ast_rtp_instance *rtp);
+
+/*!
+ * \brief Set the last RTP transmission time
+ *
+ * \param rtp The instance on which to set the last transmission time
+ * \param time The last transmission time
+ */
+void ast_rtp_instance_set_last_tx(struct ast_rtp_instance *rtp, time_t time);
+
+/*
+ * \brief Get the last RTP reception time
+ *
+ * \param rtp The instance from which to get the last reception time
+ * \return The last RTP reception time
+ */
+time_t ast_rtp_instance_get_last_rx(const struct ast_rtp_instance *rtp);
+
+/*!
+ * \brief Set the last RTP reception time
+ *
+ * \param rtp The instance on which to set the last reception time
+ * \param time The last reception time
+ */
+void ast_rtp_instance_set_last_rx(struct ast_rtp_instance *rtp, time_t time);
+
+/*! \addtogroup StasisTopicsAndMessages
+ * @{
+ */
+
+/*!
+ * \since 12
+ * \brief Message type for an RTCP message sent from this Asterisk instance
+ *
+ * \retval A stasis message type
+ */
+struct stasis_message_type *ast_rtp_rtcp_sent_type(void);
+
+/*!
+ * \since 12
+ * \brief Message type for an RTCP message received from some external source
+ *
+ * \retval A stasis message type
+ */
+struct stasis_message_type *ast_rtp_rtcp_received_type(void);
+
+/*!
+ * \since 12
+ * \brief \ref stasis topic for RTP and RTCP related messages
+ *
+ * \retval A \ref stasis topic
+ */
+struct stasis_topic *ast_rtp_topic(void);
+
+/* @} */
+
 #if defined(__cplusplus) || defined(c_plusplus)
 }
 #endif