rtp_engine.h: No sense allowing payload types larger than RFC allows.
[asterisk/asterisk.git] / include / asterisk / rtp_engine.h
index 39633c8..d6a9be5 100644 (file)
@@ -71,16 +71,31 @@ extern "C" {
 
 #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;
 
@@ -211,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 */
@@ -227,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 */
-       format_t 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 */
@@ -291,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) \
@@ -301,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 */
@@ -313,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 ast_sockaddr *sa, 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 */
@@ -335,16 +529,14 @@ struct ast_rtp_engine {
        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, format_t 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 ast_sockaddr *sa);
-       /*! Callback for setting an alternate remote address */
-       void (*alt_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 */
@@ -360,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, format_t 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, format_t 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 */
@@ -371,20 +563,31 @@ struct ast_rtp_engine {
        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 ast_sockaddr *suggestion, const char *username);
-       /*! Callback to get the transcodeable formats supported */
-       int (*available_formats)(struct ast_rtp_instance *instance, format_t to_endpoint, format_t to_asterisk);
+       /*! 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 */
@@ -397,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, format_t codecs, int nat_active);
-       /*! Callback for retrieving codecs that the channel can do */
-       format_t (*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
@@ -467,7 +695,7 @@ int ast_rtp_engine_register_srtp(struct ast_srtp_res *srtp_res, struct ast_srtp_
 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_info->self)
+#define ast_rtp_glue_register(glue) ast_rtp_glue_register2(glue, AST_MODULE_SELF)
 
 /*!
  * \brief Register RTP glue
@@ -542,7 +770,7 @@ int ast_rtp_glue_unregister(struct ast_rtp_glue *glue);
  * \since 1.8
  */
 struct ast_rtp_instance *ast_rtp_instance_new(const char *engine_name,
-                struct sched_context *sched, const struct ast_sockaddr *sa,
+                struct ast_sched_context *sched, const struct ast_sockaddr *sa,
                 void *data);
 
 /*!
@@ -647,30 +875,41 @@ int ast_rtp_instance_write(struct ast_rtp_instance *instance, struct ast_frame *
 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:
- *
- * \code
- * ast_rtp_instance_set_remote_address(instance, &sin);
- * \endcode
+ * 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).
  *
- * 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.8
+ * \retval 0 success
+ * \retval -1 failure
  */
-int ast_rtp_instance_set_remote_address(struct ast_rtp_instance *instance, const struct ast_sockaddr *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
@@ -681,15 +920,16 @@ int ast_rtp_instance_set_remote_address(struct ast_rtp_instance *instance, const
  * Example usage:
  *
  * \code
- * ast_rtp_instance_set_alt_remote_address(instance, &address);
+ * 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.8
  */
-int ast_rtp_instance_set_alt_remote_address(struct ast_rtp_instance *instance, const struct ast_sockaddr *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
@@ -757,6 +997,32 @@ void ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance, struc
 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.
+ *
+ * \param instance The instance that we want to get the requested target address for
+ * \param address A structure to put the address into
+ */
+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
  *
  * \param instance The instance that we want to get the remote address for
@@ -774,7 +1040,20 @@ int ast_rtp_instance_get_and_cmp_local_address(struct ast_rtp_instance *instance
  *
  * \since 1.8
  */
-void ast_rtp_instance_get_remote_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address);
+#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
@@ -797,8 +1076,8 @@ void ast_rtp_instance_get_remote_address(struct ast_rtp_instance *instance, stru
  *
  * \since 1.8
  */
-
-int ast_rtp_instance_get_and_cmp_remote_address(struct ast_rtp_instance *instance, struct ast_sockaddr *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
@@ -878,42 +1157,58 @@ int ast_rtp_instance_get_prop(struct ast_rtp_instance *instance, enum ast_rtp_pr
 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.8
+ * \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.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
@@ -964,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:
  *
@@ -1028,45 +1324,100 @@ 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
  *
- * \since 1.8
+ * \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 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.8
  */
-unsigned int ast_rtp_lookup_sample_rate2(int asterisk_format, format_t 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
@@ -1074,13 +1425,14 @@ unsigned int ast_rtp_lookup_sample_rate2(int asterisk_format, format_t code);
  *
  * \since 1.8
  */
-void ast_rtp_codecs_payload_formats(struct ast_rtp_codecs *codecs, format_t *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
@@ -1088,79 +1440,86 @@ void ast_rtp_codecs_payload_formats(struct ast_rtp_codecs *codecs, format_t *ast
  * 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.8
  */
-int ast_rtp_codecs_payload_code(struct ast_rtp_codecs *codecs, const int asterisk_format, const format_t 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.8
  */
-const char *ast_rtp_lookup_mime_subtype2(const int asterisk_format, const format_t 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.8
  */
-char *ast_rtp_lookup_mime_multiple2(struct ast_str *buf, const format_t 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.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
@@ -1366,22 +1725,28 @@ int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp);
 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.8
+ * \since 12
+ */
+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
  */
-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);
+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
@@ -1404,14 +1769,24 @@ enum ast_bridge_result ast_rtp_instance_bridge(struct ast_channel *c0, struct as
 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.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
@@ -1486,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
@@ -1535,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.8
  */
-int ast_rtp_instance_set_read_format(struct ast_rtp_instance *instance, format_t 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
@@ -1556,14 +1934,15 @@ int ast_rtp_instance_set_read_format(struct ast_rtp_instance *instance, format_t
  * 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.8
  */
-int ast_rtp_instance_set_write_format(struct ast_rtp_instance *instance, format_t 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
@@ -1592,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.8
  */
-format_t ast_rtp_instance_available_formats(struct ast_rtp_instance *instance, format_t to_endpoint, format_t 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
@@ -1684,6 +2062,24 @@ void ast_rtp_instance_set_timeout(struct ast_rtp_instance *instance, int timeout
 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
@@ -1722,6 +2118,25 @@ int ast_rtp_instance_get_timeout(struct ast_rtp_instance *instance);
 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
@@ -1760,28 +2175,180 @@ struct ast_rtp_engine *ast_rtp_instance_get_engine(struct ast_rtp_instance *inst
 struct ast_rtp_glue *ast_rtp_instance_get_active_glue(struct ast_rtp_instance *instance);
 
 /*!
- * \brief Get the channel that is associated with an RTP instance while in a bridge
+ * \brief Send a comfort noise packet to the RTP instance
  *
  * \param instance The RTP instance
+ * \param level Magnitude of the noise level
  *
- * \retval pointer to the channel
+ * \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
  *
- * Example:
+ * \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
  *
- * \code
- * struct ast_channel *chan = ast_rtp_instance_get_chan(instance);
- * \endcode
+ * \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
  *
- * This gets the channel associated with the RTP instance pointed to by '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
  *
- * \note This will only return a channel while in a local or remote bridge.
+ * \param instance the RTP instance
  *
- * \since 1.8
+ * \retval ICE support if present
+ * \retval NULL if no ICE support available
  */
-struct ast_channel *ast_rtp_instance_get_chan(struct ast_rtp_instance *instance);
+struct ast_rtp_engine_ice *ast_rtp_instance_get_ice(struct ast_rtp_instance *instance);
 
-int ast_rtp_instance_add_srtp_policy(struct ast_rtp_instance *instance, struct ast_srtp_policy *policy);
-struct ast_srtp *ast_rtp_instance_get_srtp(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)
 }