rtp_engine.c File Reference

Pluggable RTP Architecture. More...

#include "asterisk.h"
#include <sched.h>
#include <sys/time.h>
#include <time.h>
#include "asterisk/_private.h"
#include "asterisk/astobj2.h"
#include "asterisk/channel.h"
#include "asterisk/codec.h"
#include "asterisk/format.h"
#include "asterisk/format_cache.h"
#include "asterisk/format_cap.h"
#include "asterisk/json.h"
#include "asterisk/linkedlists.h"
#include "asterisk/lock.h"
#include "asterisk/logger.h"
#include "asterisk/manager.h"
#include "asterisk/module.h"
#include "asterisk/netsock2.h"
#include "asterisk/options.h"
#include "asterisk/pbx.h"
#include "asterisk/res_srtp.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/strings.h"
#include "asterisk/translate.h"
#include "asterisk/utils.h"
#include "asterisk/vector.h"

Include dependency graph for rtp_engine.c:

Go to the source code of this file.

Data Structures
struct	ast_rtp_instance
struct	ast_rtp_mime_type
struct	engines
struct	glues
struct	rtcp_message_payload
struct	rtp_extmap

Macros
#define	MAX_RTP_MIME_TYPES   128
#define	SET_AST_JSON_OBJ(target, name, obj)
	Set given json object into target with name.
#define	SET_STATS_VAR_HELPER(var_prefix, field)

Functions
static void	add_static_payload (int payload, struct ast_format *format, int rtp_code)
uintmax_t	ast_debug_category_dtls_id (void)
uintmax_t	ast_debug_category_dtls_packet_id (void)
uintmax_t	ast_debug_category_ice_id (void)
uintmax_t	ast_debug_category_rtcp_id (void)
uintmax_t	ast_debug_category_rtcp_packet_id (void)
uintmax_t	ast_debug_category_rtp_id (void)
uintmax_t	ast_debug_category_rtp_packet_id (void)
int	ast_rtp_codecs_find_payload_code (struct ast_rtp_codecs *codecs, int payload)
	Search for the tx payload type in the ast_rtp_codecs structure.
unsigned int	ast_rtp_codecs_get_framing (struct ast_rtp_codecs *codecs)
	Get the framing used for a set of codecs.
struct ast_rtp_payload_type *	ast_rtp_codecs_get_payload (struct ast_rtp_codecs *codecs, int payload)
	Retrieve rx payload mapped information by payload type.
struct ast_format *	ast_rtp_codecs_get_payload_format (struct ast_rtp_codecs *codecs, int payload)
	Retrieve the actual ast_format stored on the codecs structure for a specific tx payload type.
int	ast_rtp_codecs_get_preferred_dtmf_format_pt (struct ast_rtp_codecs *codecs)
	Retrieve rx preferred dtmf format payload type.
int	ast_rtp_codecs_get_preferred_dtmf_format_rate (struct ast_rtp_codecs *codecs)
	Retrieve rx preferred dtmf format sample rate.
struct ast_format *	ast_rtp_codecs_get_preferred_format (struct ast_rtp_codecs *codecs)
	Retrieve rx preferred format.
enum ast_media_type	ast_rtp_codecs_get_stream_type (struct ast_rtp_codecs *codecs)
	Determine the type of RTP stream media from the codecs mapped.
int	ast_rtp_codecs_payload_code (struct ast_rtp_codecs *codecs, int asterisk_format, struct ast_format *format, int code)
	Retrieve a rx mapped payload type based on whether it is an Asterisk format and the code.
int	ast_rtp_codecs_payload_code_sample_rate (struct ast_rtp_codecs *codecs, int asterisk_format, struct ast_format *format, int code, unsigned int sample_rate)
	Retrieve a rx mapped payload type based on whether it is an Asterisk format, the code and the sample rate.
int	ast_rtp_codecs_payload_code_tx (struct ast_rtp_codecs *codecs, int asterisk_format, const struct ast_format *format, int code)
	Retrieve a tx mapped payload type based on whether it is an Asterisk format and the code.
int	ast_rtp_codecs_payload_code_tx_sample_rate (struct ast_rtp_codecs *codecs, int asterisk_format, const struct ast_format *format, int code, unsigned int sample_rate)
	Retrieve a tx mapped payload type based on whether it is an Asterisk format and the code.
void	ast_rtp_codecs_payload_formats (struct ast_rtp_codecs *codecs, struct ast_format_cap *astformats, int *nonastformats)
	Retrieve all formats that were found.
int	ast_rtp_codecs_payload_replace_format (struct ast_rtp_codecs *codecs, int payload, struct ast_format *format)
	Update the format associated with a tx payload type in a codecs structure.
int	ast_rtp_codecs_payload_set_rx (struct ast_rtp_codecs *codecs, int code, struct ast_format *format)
	Set a payload code for use with a specific Asterisk format.
int	ast_rtp_codecs_payload_set_rx_sample_rate (struct ast_rtp_codecs *codecs, int code, struct ast_format *format, unsigned int sample_rate)
	Set a payload code with sample rate for use with a specific Asterisk format.
void	ast_rtp_codecs_payloads_clear (struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance)
	Clear rx and tx payload mapping information from an RTP instance.
void	ast_rtp_codecs_payloads_copy (struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
	Copy payload information from one RTP instance to another.
void	ast_rtp_codecs_payloads_destroy (struct ast_rtp_codecs *codecs)
	Destroy the contents of an RTP codecs structure (but not the structure itself)
int	ast_rtp_codecs_payloads_initialize (struct ast_rtp_codecs *codecs)
	Initialize an RTP codecs structure.
void	ast_rtp_codecs_payloads_set_m_type (struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload)
	Record tx payload type information that was seen in an m= SDP line.
int	ast_rtp_codecs_payloads_set_rtpmap_type (struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload, char *mimetype, char *mimesubtype, enum ast_rtp_options options)
	Record tx payload type information that was seen in an a=rtpmap: SDP line.
int	ast_rtp_codecs_payloads_set_rtpmap_type_rate (struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int pt, char *mimetype, char *mimesubtype, enum ast_rtp_options options, unsigned int sample_rate)
	Set tx payload type to a known MIME media type for a codec with a specific sample rate.
void	ast_rtp_codecs_payloads_unset (struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload)
	Remove tx payload type mapped information.
void	ast_rtp_codecs_payloads_xover (struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
	Crossover copy the tx payload mapping of src to the rx payload mapping of dest.
void	ast_rtp_codecs_set_framing (struct ast_rtp_codecs *codecs, unsigned int framing)
	Set the framing used for a set of codecs.
int	ast_rtp_codecs_set_preferred_dtmf_format (struct ast_rtp_codecs *codecs, int pt, int rate)
	Set the preferred dtmf format pt and sample rate.
int	ast_rtp_codecs_set_preferred_format (struct ast_rtp_codecs *codecs, struct ast_format *format)
	Set the preferred format.
struct ast_json *	ast_rtp_convert_stats_json (const struct ast_rtp_instance_stats *stats)
	Convert given stat instance into json format.
void	ast_rtp_dtls_cfg_copy (const struct ast_rtp_dtls_cfg *src_cfg, struct ast_rtp_dtls_cfg *dst_cfg)
	Copy contents of a DTLS configuration structure.
void	ast_rtp_dtls_cfg_free (struct ast_rtp_dtls_cfg *dtls_cfg)
	Free contents of a DTLS configuration structure.
int	ast_rtp_dtls_cfg_parse (struct ast_rtp_dtls_cfg *dtls_cfg, const char *name, const char *value)
	Parse DTLS related configuration options.
int	ast_rtp_dtls_cfg_validate (struct ast_rtp_dtls_cfg *dtls_cfg)
	Validates DTLS related configuration options.
struct ast_rtp_payload_type *	ast_rtp_engine_alloc_payload_type (void)
	Allocation routine for ast_rtp_payload_type.
int	ast_rtp_engine_init (void)
	initializes the rtp engine arrays
int	ast_rtp_engine_load_format (struct ast_format *format)
	Custom formats declared in codecs.conf at startup must be communicated to the rtp_engine so their mime type can payload number can be initialized.
int	ast_rtp_engine_register2 (struct ast_rtp_engine *engine, struct ast_module *module)
	Register an RTP engine.
int	ast_rtp_engine_register_srtp (struct ast_srtp_res *srtp_res, struct ast_srtp_policy_res *policy_res)
int	ast_rtp_engine_srtp_is_registered (void)
int	ast_rtp_engine_unload_format (struct ast_format *format)
	Formats requiring the use of a format attribute interface must have that interface registered in 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_unregister (struct ast_rtp_engine *engine)
	Unregister an RTP engine.
void	ast_rtp_engine_unregister_srtp (void)
int	ast_rtp_get_rate (const struct ast_format *format)
	Retrieve the sample rate of a format according to RTP specifications.
int	ast_rtp_glue_register2 (struct ast_rtp_glue *glue, struct ast_module *module)
	Register RTP glue.
int	ast_rtp_glue_unregister (struct ast_rtp_glue *glue)
	Unregister RTP glue.
int	ast_rtp_instance_activate (struct ast_rtp_instance *instance)
	Indicate to the RTP engine that packets are now expected to be sent/received on the RTP instance.
int	ast_rtp_instance_add_srtp_policy (struct ast_rtp_instance *instance, struct ast_srtp_policy *remote_policy, struct ast_srtp_policy *local_policy, int rtcp)
	Add or replace the SRTP policies for the given RTP instance.
void	ast_rtp_instance_available_formats (struct ast_rtp_instance *instance, struct ast_format_cap *to_endpoint, struct ast_format_cap *to_asterisk, struct ast_format_cap *result)
	Request the formats that can be transcoded.
int	ast_rtp_instance_bundle (struct ast_rtp_instance *child, struct ast_rtp_instance *parent)
	Request that an RTP instance be bundled with another.
void	ast_rtp_instance_change_source (struct ast_rtp_instance *instance)
	Indicate a new source of audio has dropped in and the ssrc should change.
int	ast_rtp_instance_destroy (struct ast_rtp_instance *instance)
	Destroy an RTP instance.
int	ast_rtp_instance_dtmf_begin (struct ast_rtp_instance *instance, char digit)
	Begin sending a DTMF digit.
int	ast_rtp_instance_dtmf_end (struct ast_rtp_instance *instance, char digit)
	Stop sending a DTMF digit.
int	ast_rtp_instance_dtmf_end_with_duration (struct ast_rtp_instance *instance, char digit, unsigned int duration)
enum ast_rtp_dtmf_mode	ast_rtp_instance_dtmf_mode_get (struct ast_rtp_instance *instance)
	Get the DTMF mode of an RTP instance.
int	ast_rtp_instance_dtmf_mode_set (struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode)
	Set the DTMF mode that should be used.
int	ast_rtp_instance_early_bridge (struct ast_channel *c0, struct ast_channel *c1)
	Early bridge two channels that use RTP instances.
void	ast_rtp_instance_early_bridge_make_compatible (struct ast_channel *c_dst, struct ast_channel *c_src)
	Make two channels compatible for early bridging.
void	ast_rtp_instance_extmap_clear (struct ast_rtp_instance *instance)
	Clear negotiated RTP extension information.
size_t	ast_rtp_instance_extmap_count (struct ast_rtp_instance *instance)
	Get the number of known unique identifiers.
int	ast_rtp_instance_extmap_enable (struct ast_rtp_instance *instance, int id, enum ast_rtp_extension extension, enum ast_rtp_extension_direction direction)
	Enable support for an RTP extension on an instance.
enum ast_rtp_extension_direction	ast_rtp_instance_extmap_get_direction (struct ast_rtp_instance *instance, int id)
	Retrieve the negotiated direction for an RTP extension id.
enum ast_rtp_extension	ast_rtp_instance_extmap_get_extension (struct ast_rtp_instance *instance, int id)
	Retrieve the extension for an RTP extension id.
int	ast_rtp_instance_extmap_get_id (struct ast_rtp_instance *instance, enum ast_rtp_extension extension)
	Retrieve the id for an RTP extension.
const char *	ast_rtp_instance_extmap_get_uri (struct ast_rtp_instance *instance, int id)
	Retrieve the URI for an RTP extension id.
int	ast_rtp_instance_extmap_negotiate (struct ast_rtp_instance *instance, int id, enum ast_rtp_extension_direction direction, const char *uri, const char *attributes)
	Negotiate received RTP extension information.
int	ast_rtp_instance_fd (struct ast_rtp_instance *instance, int rtcp)
	Get the file descriptor for an RTP session (or RTCP)
struct ast_rtp_glue *	ast_rtp_instance_get_active_glue (struct ast_rtp_instance *instance)
	Get the RTP glue in use on an RTP instance.
int	ast_rtp_instance_get_and_cmp_local_address (struct ast_rtp_instance *instance, struct ast_sockaddr *address)
	Get the address of the local endpoint that we are sending RTP to, comparing its address to another.
int	ast_rtp_instance_get_and_cmp_requested_target_address (struct ast_rtp_instance *instance, struct ast_sockaddr *address)
	Get the requested target address of the remote endpoint and compare it to the given address.
struct ast_rtp_instance *	ast_rtp_instance_get_bridged (struct ast_rtp_instance *instance)
	Get the other RTP instance that an instance is bridged to.
const char *	ast_rtp_instance_get_channel_id (struct ast_rtp_instance *instance)
	Get the unique ID of the channel that owns this RTP instance.
const char *	ast_rtp_instance_get_cname (struct ast_rtp_instance *rtp)
	Retrieve the CNAME used in RTCP SDES items.
struct ast_rtp_codecs *	ast_rtp_instance_get_codecs (struct ast_rtp_instance *instance)
	Get the codecs structure of an RTP instance.
void *	ast_rtp_instance_get_data (struct ast_rtp_instance *instance)
	Get the data portion of an RTP instance.
struct ast_rtp_engine_dtls *	ast_rtp_instance_get_dtls (struct ast_rtp_instance *instance)
	Obtain a pointer to the DTLS support present on an RTP instance.
struct ast_rtp_engine *	ast_rtp_instance_get_engine (struct ast_rtp_instance *instance)
	Get the RTP engine in use on an RTP instance.
void *	ast_rtp_instance_get_extended_prop (struct ast_rtp_instance *instance, int property)
	Get the value of an RTP instance extended property.
struct ast_rtp_glue *	ast_rtp_instance_get_glue (const char *type)
	Get the RTP glue that binds a channel to the RTP engine.
int	ast_rtp_instance_get_hold_timeout (struct ast_rtp_instance *instance)
	Get the RTP timeout value for when an RTP instance is on hold.
struct ast_rtp_engine_ice *	ast_rtp_instance_get_ice (struct ast_rtp_instance *instance)
	Obtain a pointer to the ICE support present on an RTP instance.
void	ast_rtp_instance_get_incoming_source_address (struct ast_rtp_instance *instance, struct ast_sockaddr *address)
	Get the incoming source address of the remote endpoint.
int	ast_rtp_instance_get_keepalive (struct ast_rtp_instance *instance)
	Get the RTP keepalive interval.
time_t	ast_rtp_instance_get_last_rx (const struct ast_rtp_instance *rtp)
	Get the last RTP reception time.
time_t	ast_rtp_instance_get_last_tx (const struct ast_rtp_instance *rtp)
	Get the last RTP transmission time.
void	ast_rtp_instance_get_local_address (struct ast_rtp_instance *instance, struct ast_sockaddr *address)
	Get the local address that we are expecting RTP on.
unsigned int	ast_rtp_instance_get_port_end (struct ast_rtp_instance *instance)
	Get the per-instance RTP port range end.
unsigned int	ast_rtp_instance_get_port_start (struct ast_rtp_instance *instance)
	Get the per-instance RTP port range start.
int	ast_rtp_instance_get_prop (struct ast_rtp_instance *instance, enum ast_rtp_property property)
	Get the value of an RTP instance property.
char *	ast_rtp_instance_get_quality (struct ast_rtp_instance *instance, enum ast_rtp_instance_stat_field field, char *buf, size_t size)
	Retrieve quality statistics about an RTP instance.
void	ast_rtp_instance_get_requested_target_address (struct ast_rtp_instance *instance, struct ast_sockaddr *address)
	Get the requested target address of the remote endpoint.
struct ast_srtp *	ast_rtp_instance_get_srtp (struct ast_rtp_instance *instance, int rtcp)
	Obtain the SRTP instance associated with an RTP instance.
unsigned int	ast_rtp_instance_get_ssrc (struct ast_rtp_instance *rtp)
	Retrieve the local SSRC value that we will be using.
int	ast_rtp_instance_get_stats (struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
	Retrieve statistics about an RTP instance.
struct ast_json *	ast_rtp_instance_get_stats_all_json (struct ast_rtp_instance *instance)
	Retrieve statistics about an RTP instance in json format.
int	ast_rtp_instance_get_timeout (struct ast_rtp_instance *instance)
	Get the RTP timeout value.
int	ast_rtp_instance_make_compatible (struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_channel *peer)
	Request that the underlying RTP engine make two RTP instances compatible with eachother.
struct ast_rtp_instance *	ast_rtp_instance_new (const char *engine_name, struct ast_sched_context *sched, const struct ast_sockaddr *sa, void *data)
	Create a new RTP instance.
struct ast_rtp_instance *	ast_rtp_instance_new_with_options (const char *engine_name, struct ast_sched_context *sched, const struct ast_sockaddr *sa, void *data, const struct ast_rtp_instance_options *options)
	Create a new RTP instance with additional options.
struct ast_frame *	ast_rtp_instance_read (struct ast_rtp_instance *instance, int rtcp)
	Receive a frame over RTP.
int	ast_rtp_instance_sendcng (struct ast_rtp_instance *instance, int level)
	Send a comfort noise packet to the RTP instance.
void	ast_rtp_instance_set_bridged (struct ast_rtp_instance *instance, struct ast_rtp_instance *bridged)
	Set the other RTP instance that an instance is bridged to.
void	ast_rtp_instance_set_channel_id (struct ast_rtp_instance *instance, const char *uniqueid)
	Set the channel that owns this RTP instance.
void	ast_rtp_instance_set_data (struct ast_rtp_instance *instance, void *data)
	Set the data portion of an RTP instance.
void	ast_rtp_instance_set_extended_prop (struct ast_rtp_instance *instance, int property, void *value)
	Set the value of an RTP instance extended property.
void	ast_rtp_instance_set_hold_timeout (struct ast_rtp_instance *instance, int timeout)
	Set the RTP timeout value for when the instance is on hold.
int	ast_rtp_instance_set_incoming_source_address (struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
	Set the incoming source address of the remote endpoint that we are sending RTP to.
void	ast_rtp_instance_set_keepalive (struct ast_rtp_instance *instance, int interval)
	Set the RTP keepalive interval.
void	ast_rtp_instance_set_last_rx (struct ast_rtp_instance *rtp, time_t time)
	Set the last RTP reception time.
void	ast_rtp_instance_set_last_tx (struct ast_rtp_instance *rtp, time_t time)
	Set the last RTP transmission time.
int	ast_rtp_instance_set_local_address (struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
	Set the address that we are expecting to receive RTP on.
void	ast_rtp_instance_set_prop (struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
	Set the value of an RTP instance property.
int	ast_rtp_instance_set_qos (struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
	Set QoS parameters on an RTP session.
int	ast_rtp_instance_set_read_format (struct ast_rtp_instance *instance, struct ast_format *format)
	Request that the underlying RTP engine provide audio frames in a specific format.
void	ast_rtp_instance_set_remote_ssrc (struct ast_rtp_instance *rtp, unsigned int ssrc)
	Set the remote SSRC for an RTP instance.
int	ast_rtp_instance_set_requested_target_address (struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
	Set the requested target address of the remote endpoint.
void	ast_rtp_instance_set_stats_vars (struct ast_channel *chan, struct ast_rtp_instance *instance)
	Set standard statistics from an RTP instance on a channel.
void	ast_rtp_instance_set_stream_num (struct ast_rtp_instance *rtp, int stream_num)
	Set the stream number for an RTP instance.
void	ast_rtp_instance_set_timeout (struct ast_rtp_instance *instance, int timeout)
	Set the RTP timeout value.
int	ast_rtp_instance_set_write_format (struct ast_rtp_instance *instance, struct ast_format *format)
	Tell underlying RTP engine that audio frames will be provided in a specific format.
void	ast_rtp_instance_stop (struct ast_rtp_instance *instance)
	Stop an RTP instance.
void	ast_rtp_instance_stun_request (struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username)
	Request that the underlying RTP engine send a STUN BIND request.
void	ast_rtp_instance_update_source (struct ast_rtp_instance *instance)
	Indicate that the RTP marker bit should be set on an RTP stream.
int	ast_rtp_instance_write (struct ast_rtp_instance *instance, struct ast_frame *frame)
	Send a frame out over RTP.
char *	ast_rtp_lookup_mime_multiple2 (struct ast_str *buf, struct ast_format_cap *ast_format_capability, int rtp_capability, const int asterisk_format, enum ast_rtp_options options)
	Convert formats into a string and put them into a buffer.
const char *	ast_rtp_lookup_mime_subtype2 (const int asterisk_format, const struct ast_format *format, int code, enum ast_rtp_options options)
	Retrieve mime subtype information on a payload.
unsigned int	ast_rtp_lookup_sample_rate2 (int asterisk_format, const struct ast_format *format, int code)
	Get the sample rate associated with known RTP payload types.
int	ast_rtp_payload_mapping_tx_is_present (struct ast_rtp_codecs *codecs, const struct ast_rtp_payload_type *to_match)
	Determine if a type of payload is already present in mappings.
void	ast_rtp_publish_rtcp_message (struct ast_rtp_instance *rtp, struct stasis_message_type *message_type, struct ast_rtp_rtcp_report *report, struct ast_json *blob)
	Publish an RTCP message to Stasis Message Bus API.
int	ast_rtp_red_buffer (struct ast_rtp_instance *instance, struct ast_frame *frame)
	Buffer a frame in an RTP instance for RED.
int	ast_rtp_red_init (struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
	Initialize RED support on an RTP instance.
struct ast_rtp_rtcp_report *	ast_rtp_rtcp_report_alloc (unsigned int report_blocks)
	Allocate an ao2 ref counted instance of ast_rtp_rtcp_report.
struct stasis_topic *	ast_rtp_topic (void)
	Stasis Message Bus API topic for RTP and RTCP related messages
static int	find_static_payload_type (int asterisk_format, const struct ast_format *format, int code)
static int	find_unused_payload (const struct ast_rtp_codecs *codecs)
static int	find_unused_payload_in_range (const struct ast_rtp_codecs *codecs, int start, int end, struct ast_rtp_payload_type *ignore[])
static void	instance_destructor (void *obj)
static void	payload_mapping_rx_clear_primary (struct ast_rtp_codecs *codecs, struct ast_rtp_payload_type *to_match)
static int	payload_mapping_tx_is_present (const struct ast_rtp_codecs *codecs, const struct ast_rtp_payload_type *to_match)
static void	rtcp_message_payload_dtor (void *obj)
static struct ast_manager_event_blob *	rtcp_report_to_ami (struct stasis_message *msg)
static struct ast_json *	rtcp_report_to_json (struct stasis_message *msg, const struct stasis_message_sanitizer *sanitize)
static int	rtp_codecs_assign_payload_code_rx (struct ast_rtp_codecs *codecs, int asterisk_format, struct ast_format *format, int code, int explicit, unsigned int sample_rate)
static int	rtp_codecs_find_non_primary_dynamic_rx (struct ast_rtp_codecs *codecs)
static void	rtp_codecs_payload_replace_rx (struct ast_rtp_codecs *codecs, int payload, struct ast_rtp_payload_type *new_type)
static void	rtp_codecs_payload_set_rx (struct ast_rtp_codecs *codecs, int payload, struct ast_rtp_payload_type *new_type, int replace)
static void	rtp_codecs_payloads_copy_rx (struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
static void	rtp_codecs_payloads_copy_tx (struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
static int	rtp_dtls_wrap_active (struct ast_rtp_instance *instance)
static enum ast_rtp_dtls_connection	rtp_dtls_wrap_get_connection (struct ast_rtp_instance *instance)
static const char *	rtp_dtls_wrap_get_fingerprint (struct ast_rtp_instance *instance)
static enum ast_rtp_dtls_hash	rtp_dtls_wrap_get_fingerprint_hash (struct ast_rtp_instance *instance)
static enum ast_rtp_dtls_setup	rtp_dtls_wrap_get_setup (struct ast_rtp_instance *instance)
static void	rtp_dtls_wrap_reset (struct ast_rtp_instance *instance)
static int	rtp_dtls_wrap_set_configuration (struct ast_rtp_instance *instance, const struct ast_rtp_dtls_cfg *dtls_cfg)
static void	rtp_dtls_wrap_set_fingerprint (struct ast_rtp_instance *instance, enum ast_rtp_dtls_hash hash, const char *fingerprint)
static void	rtp_dtls_wrap_set_setup (struct ast_rtp_instance *instance, enum ast_rtp_dtls_setup setup)
static void	rtp_dtls_wrap_stop (struct ast_rtp_instance *instance)
static void	rtp_engine_atexit (void)
static void	rtp_engine_mime_type_cleanup (int i)
static void	rtp_engine_shutdown (void)
static enum ast_rtp_extension_direction	rtp_extmap_negotiate_direction (enum ast_rtp_extension_direction ours, enum ast_rtp_extension_direction theirs)
	Helper function which negotiates two RTP extension directions to get our current direction.
static void	rtp_ice_wrap_add_remote_candidate (struct ast_rtp_instance *instance, const struct ast_rtp_engine_ice_candidate *candidate)
static void	rtp_ice_wrap_change_components (struct ast_rtp_instance *instance, int num_components)
static struct ao2_container *	rtp_ice_wrap_get_local_candidates (struct ast_rtp_instance *instance)
static const char *	rtp_ice_wrap_get_password (struct ast_rtp_instance *instance)
static const char *	rtp_ice_wrap_get_ufrag (struct ast_rtp_instance *instance)
static void	rtp_ice_wrap_ice_lite (struct ast_rtp_instance *instance)
static void	rtp_ice_wrap_set_authentication (struct ast_rtp_instance *instance, const char *ufrag, const char *password)
static void	rtp_ice_wrap_set_role (struct ast_rtp_instance *instance, enum ast_rtp_ice_role role)
static void	rtp_ice_wrap_start (struct ast_rtp_instance *instance)
static void	rtp_ice_wrap_stop (struct ast_rtp_instance *instance)
static void	rtp_ice_wrap_turn_request (struct ast_rtp_instance *instance, enum ast_rtp_ice_component_type component, enum ast_transport transport, const char *server, unsigned int port, const char *username, const char *password)
static void	rtp_instance_set_incoming_source_address_nolock (struct ast_rtp_instance *instance, const struct ast_sockaddr *address)
static struct ast_rtp_payload_type *	rtp_payload_type_alloc (struct ast_format *format, int payload, int rtp_code, int primary_mapping, unsigned int sample_rate)
static void	rtp_payload_type_dtor (void *obj)
static void	rtp_rtcp_report_dtor (void *obj)
static void	set_next_mime_type (struct ast_format *format, int rtp_code, const char *type, const char *subtype, unsigned int sample_rate)
static void	unref_instance_cond (struct ast_rtp_instance **instance)
	Conditionally unref an rtp instance.
	STASIS_MESSAGE_TYPE_DEFN (ast_rtp_rtcp_received_type,.to_ami=rtcp_report_to_ami,.to_json=rtcp_report_to_json,)
	STASIS_MESSAGE_TYPE_DEFN (ast_rtp_rtcp_sent_type,.to_ami=rtcp_report_to_ami,.to_json=rtcp_report_to_json,)
	Define RTCP/RTP message types.

Variables
static struct ast_rtp_mime_type	ast_rtp_mime_types [128]
static uintmax_t	debug_category_dtls_id
static uintmax_t	debug_category_dtls_packet_id
static uintmax_t	debug_category_ice_id
static uintmax_t	debug_category_rtcp_id
static uintmax_t	debug_category_rtcp_packet_id
static uintmax_t	debug_category_rtp_id
static uintmax_t	debug_category_rtp_packet_id
static struct engines	engines = AST_RWLIST_HEAD_INIT_VALUE
static struct glues	glues = AST_RWLIST_HEAD_INIT_VALUE
static int	mime_types_len = 0
static ast_rwlock_t	mime_types_lock
struct ast_srtp_res *	res_srtp = NULL
struct ast_srtp_policy_res *	res_srtp_policy = NULL
static struct ast_rtp_engine_dtls	rtp_dtls_wrappers
static const char *const	rtp_extension_uris [AST_RTP_EXTENSION_MAX]
	URIs for known RTP extensions.
static struct ast_rtp_engine_ice	rtp_ice_wrappers
static struct stasis_topic *	rtp_topic
	Stasis Message Bus API topic for RTP related messages
static struct ast_rtp_payload_type *	static_RTP_PT [AST_RTP_MAX_PT]
	Mapping between Asterisk codecs and rtp payload types.
static ast_rwlock_t	static_RTP_PT_lock

Detailed Description

Pluggable RTP Architecture.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file rtp_engine.c.

Macro Definition Documentation

MAX_RTP_MIME_TYPES

#define MAX_RTP_MIME_TYPES   128

Definition at line 256 of file rtp_engine.c.

SET_AST_JSON_OBJ

#define SET_AST_JSON_OBJ	(		target,
			name,
			obj
	)

Set given json object into target with name.

Parameters

target	Target json.
name	key of given object.
obj	Json value will be set.

Definition at line 297 of file rtp_engine.c.

                                             {                  \
    struct ast_json *j_tmp = obj;                       \
    if (j_tmp) {                        \
        ast_json_object_set(target, name, j_tmp);                       \
    }                       \
})

SET_STATS_VAR_HELPER

#define SET_STATS_VAR_HELPER	(		var_prefix,
			field
	)

Definition at line 2730 of file rtp_engine.c.

 { \
    value = ast_rtp_instance_get_quality(instance, field, quality_buf, sizeof(quality_buf)); \
    if (value) { \
        if (!chanvars || ast_strlen_zero(ast_var_find(chanvars, var_prefix))) { \
            pbx_builtin_setvar_helper(chan, var_prefix, value); \
            chanchanges++; \
        } \
        if (bridge) { \
            if (!bridgevars || ast_strlen_zero(ast_var_find(bridgevars, var_prefix "BRIDGED"))) { \
                pbx_builtin_setvar_helper(bridge, var_prefix "BRIDGED", value); \
                bridgechanges++; \
            } \
        } \
    } \
})

Function Documentation

add_static_payload()

static void add_static_payload ( int  payload, struct ast_format *  format, int  rtp_code  )

static

Definition at line 3438 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type;
 
    /*
     * ARRAY_LEN's result is cast to an int so 'map' is not autocast to a size_t,
     * which if negative would cause an assertion.
     */
    ast_assert(payload < (int)ARRAY_LEN(static_RTP_PT));
 
    if (ast_option_rtpusedynamic && payload < 0) {
        /*
         * We're going to build dynamic payloads dynamically. An RTP code is
         * required otherwise one will be dynamically allocated per instance.
         */
        return;
    }
 
    /*
     * Either the given payload is truly a static type, or Asterisk is
     * globally storing the dynamic payloads in the static_RTP_PT object.
     */
    ast_rwlock_wrlock(&static_RTP_PT_lock);
 
    if (payload < 0) {
        /*
         * This is a dynamic payload that will be stored globally,
         * so find the next available empty slot.
         */
        payload = find_unused_payload(NULL);
        if (payload < 0) {
            ast_log(LOG_WARNING, "No dynamic RTP payload type values available "
                "for %s - %d!\n", format ? ast_format_get_name(format) : "", rtp_code);
            ast_rwlock_unlock(&static_RTP_PT_lock);
            return;
        }
    }
 
    type = rtp_payload_type_alloc(format, payload, rtp_code, 1, 0);
    if (type) {
        ao2_cleanup(static_RTP_PT[payload]);
        static_RTP_PT[payload] = type;
    }
    ast_rwlock_unlock(&static_RTP_PT_lock);
}

References ao2_cleanup, ARRAY_LEN, ast_assert, ast_format_get_name(), ast_log, ast_option_rtpusedynamic, ast_rwlock_unlock, ast_rwlock_wrlock, find_unused_payload(), ast_rtp_payload_type::format, LOG_WARNING, NULL, ast_rtp_payload_type::payload, ast_rtp_payload_type::rtp_code, rtp_payload_type_alloc(), static_RTP_PT, static_RTP_PT_lock, and type.

Referenced by ast_rtp_engine_init(), and ast_rtp_engine_load_format().

ast_debug_category_dtls_id()

uintmax_t ast_debug_category_dtls_id

(

void

)

Definition at line 3826 of file rtp_engine.c.

{
    return debug_category_dtls_id;
}

References debug_category_dtls_id.

ast_debug_category_dtls_packet_id()

uintmax_t ast_debug_category_dtls_packet_id

(

void

)

Definition at line 3833 of file rtp_engine.c.

{
    return debug_category_dtls_packet_id;
}

References debug_category_dtls_packet_id.

ast_debug_category_ice_id()

uintmax_t ast_debug_category_ice_id

(

void

)

Definition at line 3840 of file rtp_engine.c.

{
    return debug_category_ice_id;
}

References debug_category_ice_id.

ast_debug_category_rtcp_id()

uintmax_t ast_debug_category_rtcp_id

(

void

)

Definition at line 3812 of file rtp_engine.c.

{
    return debug_category_rtcp_id;
}

References debug_category_rtcp_id.

ast_debug_category_rtcp_packet_id()

uintmax_t ast_debug_category_rtcp_packet_id

(

void

)

Definition at line 3819 of file rtp_engine.c.

{
    return debug_category_rtcp_packet_id;
}

References debug_category_rtcp_packet_id.

ast_debug_category_rtp_id()

uintmax_t ast_debug_category_rtp_id

(

void

)

Definition at line 3798 of file rtp_engine.c.

{
    return debug_category_rtp_id;
}

References debug_category_rtp_id.

ast_debug_category_rtp_packet_id()

uintmax_t ast_debug_category_rtp_packet_id

(

void

)

Definition at line 3805 of file rtp_engine.c.

{
    return debug_category_rtp_packet_id;
}

References debug_category_rtp_packet_id.

ast_rtp_codecs_find_payload_code()

int ast_rtp_codecs_find_payload_code	(	struct ast_rtp_codecs *	codecs,
		int	payload
	)

Search for the tx payload type in the ast_rtp_codecs structure.

Parameters

codecs	Codecs structure to look in
payload	The payload type format to look for

Returns

Numerical payload type or -1 if unable to find payload in codecs

Example usage:

int payload = ast_rtp_codecs_find_payload_code(&codecs, 0);

This looks for the numerical payload for ULAW in the codecs structure.

Definition at line 2190 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type;
    int res = -1;
 
    ast_rwlock_rdlock(&codecs->codecs_lock);
    if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
        type = AST_VECTOR_GET(&codecs->payload_mapping_tx, payload);
        if (type) {
            res = payload;
        }
    }
    ast_rwlock_unlock(&codecs->codecs_lock);
 
    return res;
}

References ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, codecs, ast_rtp_payload_type::payload, and type.

Referenced by bridge_p2p_rtp_write().

ast_rtp_codecs_get_framing()

unsigned int ast_rtp_codecs_get_framing

(

struct ast_rtp_codecs *

codecs

)

Get the framing used for a set of codecs.

Parameters

codecs

Codecs structure to get the framing from

Returns

The framing to be used for the media stream associated with these codecs

Since

13.0.0

Definition at line 1711 of file rtp_engine.c.

{
    unsigned int framing;
 
    ast_rwlock_rdlock(&codecs->codecs_lock);
    framing = codecs->framing;
    ast_rwlock_unlock(&codecs->codecs_lock);
 
    return framing;
}

References ast_rwlock_rdlock, ast_rwlock_unlock, and codecs.

Referenced by ast_rtp_write(), create_outgoing_sdp_stream(), multicast_rtp_write(), and native_rtp_bridge_compatible_check().

ast_rtp_codecs_get_payload()

struct ast_rtp_payload_type * ast_rtp_codecs_get_payload	(	struct ast_rtp_codecs *	codecs,
		int	payload
	)

Retrieve rx payload mapped information by payload type.

Parameters

codecs	Codecs structure to look in
payload	Numerical payload to look up

Returns

Payload information.

Return values

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:

struct ast_rtp_payload_type *payload_type;
payload_type = ast_rtp_codecs_get_payload(&codecs, 0);

This looks up the information for payload '0' from the codecs structure.

Definition at line 1577 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type = NULL;
 
    if (payload < 0 || payload >= AST_RTP_MAX_PT) {
        return NULL;
    }
 
    ast_rwlock_rdlock(&codecs->codecs_lock);
    if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_rx)) {
        type = AST_VECTOR_GET(&codecs->payload_mapping_rx, payload);
        ao2_bump(type);
    }
    ast_rwlock_unlock(&codecs->codecs_lock);
 
    if (!type && payload <= AST_RTP_PT_LAST_STATIC) {
        ast_rwlock_rdlock(&static_RTP_PT_lock);
        type = ao2_bump(static_RTP_PT[payload]);
        ast_rwlock_unlock(&static_RTP_PT_lock);
    }
 
    return type;
}

References ao2_bump, AST_RTP_MAX_PT, AST_RTP_PT_LAST_STATIC, ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, codecs, NULL, ast_rtp_payload_type::payload, static_RTP_PT, static_RTP_PT_lock, and type.

Referenced by ast_rtp_dtmf_begin(), ast_rtp_interpret(), and bridge_p2p_rtp_write().

ast_rtp_codecs_get_payload_format()

struct ast_format * ast_rtp_codecs_get_payload_format	(	struct ast_rtp_codecs *	codecs,
		int	payload
	)

Retrieve the actual ast_format stored on the codecs structure for a specific tx payload type.

Parameters

codecs	Codecs structure to look in
payload	Numerical payload type to look up

Returns

pointer to format structure on success

Return values

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

Definition at line 1679 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type;
    struct ast_format *format = NULL;
 
    if (payload < 0 || payload >= AST_RTP_MAX_PT) {
        return NULL;
    }
 
    ast_rwlock_rdlock(&codecs->codecs_lock);
    if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
        type = AST_VECTOR_GET(&codecs->payload_mapping_tx, payload);
        if (type && type->asterisk_format) {
            format = ao2_bump(type->format);
        }
    }
    ast_rwlock_unlock(&codecs->codecs_lock);
 
    return format;
}

References ao2_bump, AST_RTP_MAX_PT, ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, codecs, NULL, and type.

Referenced by get_codecs().

ast_rtp_codecs_get_preferred_dtmf_format_pt()

int ast_rtp_codecs_get_preferred_dtmf_format_pt

(

struct ast_rtp_codecs *

codecs

)

Retrieve rx preferred dtmf format payload type.

Parameters

codecs

Codecs structure to look in

Returns

Payload type of preferred dtmf format.

Return values

-1	if not set.

Example usage:

int payload;
payload = ast_rtp_codecs_get_preferred_dtmf_format_pt(codec);

This looks up the preferred dtmf format pt on the codec

Definition at line 1618 of file rtp_engine.c.

{
    int pt = -1;
    ast_rwlock_rdlock(&codecs->codecs_lock);
    pt = codecs->preferred_dtmf_pt;
    ast_rwlock_unlock(&codecs->codecs_lock);
    return pt;
}

References ast_rwlock_rdlock, ast_rwlock_unlock, and codecs.

Referenced by ast_rtp_dtmf_begin().

ast_rtp_codecs_get_preferred_dtmf_format_rate()

int ast_rtp_codecs_get_preferred_dtmf_format_rate

(

struct ast_rtp_codecs *

codecs

)

Retrieve rx preferred dtmf format sample rate.

Parameters

codecs

Codecs structure to look in

Returns

Sample rate of preferred dtmf format.

Return values

-1	if not set.

Example usage:

int sample_rate;
sample_rate = ast_rtp_codecs_get_preferred_dtmf_format_rate(codec);

This looks up the preferred dtmf format sample rate on the codec

Definition at line 1627 of file rtp_engine.c.

{
    int rate = -1;
    ast_rwlock_rdlock(&codecs->codecs_lock);
    rate = codecs->preferred_dtmf_rate;
    ast_rwlock_unlock(&codecs->codecs_lock);
    return rate;
}

References ast_rwlock_rdlock, ast_rwlock_unlock, and codecs.

Referenced by ast_rtp_dtmf_begin().

ast_rtp_codecs_get_preferred_format()

struct ast_format * ast_rtp_codecs_get_preferred_format

(

struct ast_rtp_codecs *

codecs

)

Retrieve rx preferred format.

Parameters

codecs

Codecs structure to look in

Returns

format information.

Return values

NULL	if format does not exist.

Note

The format returned by this function has its reference count increased. Callers are responsible for decrementing the reference count.

Example usage:

struct ast_format *payload_format;
payload_format = ast_rtp_codecs_get_preferred_format(&codecs);

This looks up the preferred format on the codec

Definition at line 1601 of file rtp_engine.c.

{
    struct ast_format *format;
    ast_rwlock_rdlock(&codecs->codecs_lock);
    format = ao2_bump(codecs->preferred_format);
    ast_rwlock_unlock(&codecs->codecs_lock);
    return format;
}

References ao2_bump, ast_rwlock_rdlock, ast_rwlock_unlock, and codecs.

Referenced by ast_rtp_dtmf_begin().

ast_rtp_codecs_get_stream_type()

enum ast_media_type ast_rtp_codecs_get_stream_type

(

struct ast_rtp_codecs *

codecs

)

Determine the type of RTP stream media from the codecs mapped.

Since

13.19.0

Parameters

codecs

Codecs structure to look in

Returns

Media type or AST_MEDIA_TYPE_UNKNOWN if no codecs mapped.

Definition at line 1558 of file rtp_engine.c.

{
    enum ast_media_type stream_type = AST_MEDIA_TYPE_UNKNOWN;
    int payload;
    struct ast_rtp_payload_type *type;
 
    ast_rwlock_rdlock(&codecs->codecs_lock);
    for (payload = 0; payload < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++payload) {
        type = AST_VECTOR_GET(&codecs->payload_mapping_rx, payload);
        if (type && type->asterisk_format) {
            stream_type = ast_format_get_type(type->format);
            break;
        }
    }
    ast_rwlock_unlock(&codecs->codecs_lock);
 
    return stream_type;
}

References ast_format_get_type(), AST_MEDIA_TYPE_UNKNOWN, ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, codecs, ast_rtp_payload_type::payload, and type.

Referenced by ast_rtp_read().

ast_rtp_codecs_payload_code()

int ast_rtp_codecs_payload_code	(	struct ast_rtp_codecs *	codecs,
		int	asterisk_format,
		struct ast_format *	format,
		int	code
	)

Retrieve a rx mapped payload type based on whether it is an Asterisk format and the code.

Parameters

codecs	Codecs structure to look in
asterisk_format	Non-zero if the given Asterisk format is present
format	Asterisk format to look for
code	The format to look for

Find the currently assigned rx mapped payload type based on whether it is an Asterisk format or non-format code. If one is currently not assigned then create a rx payload type mapping.

Returns

Numerical payload type

Return values

-1	if could not assign.

Example usage:

int payload = ast_rtp_codecs_payload_code(&codecs, 1, ast_format_ulaw, 0);

This looks for the numerical payload for ULAW in the codecs structure.

Since

1.8

Definition at line 2048 of file rtp_engine.c.

{
    return ast_rtp_codecs_payload_code_sample_rate(codecs, asterisk_format, format, code, 0);
}

References ast_rtp_codecs_payload_code_sample_rate(), ast_rtp_payload_type::asterisk_format, codecs, and ast_rtp_payload_type::format.

Referenced by apply_cap_to_bundled(), create_outgoing_sdp_stream(), and jingle_add_payloads_to_description().

ast_rtp_codecs_payload_code_sample_rate()

int ast_rtp_codecs_payload_code_sample_rate	(	struct ast_rtp_codecs *	codecs,
		int	asterisk_format,
		struct ast_format *	format,
		int	code,
		unsigned int	sample_rate
	)

Retrieve a rx mapped payload type based on whether it is an Asterisk format, the code and the sample rate.

Parameters

codecs	Codecs structure to look in
asterisk_format	Non-zero if the given Asterisk format is present
format	Asterisk format to look for
code	The format to look for
sample_rate	Non-zero if we want to also match on sample rate.

Find the currently assigned rx mapped payload type based on whether it is an Asterisk format or non-format code. If one is currently not assigned then create a rx payload type mapping.

Returns

Numerical payload type

Return values

-1	if could not assign.

Example usage:

int payload = ast_rtp_codecs_payload_code_sample_rate(&codecs, 0, NULL, AST_RTP_DTMF, 8000);

This looks for the numerical payload for a DTMF type with a sample rate of 8kHz in the codecs structure.

Since

22.0.0

Definition at line 2053 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type;
    int idx;
    int payload = -1;
 
    ast_rwlock_rdlock(&static_RTP_PT_lock);
    if (!asterisk_format) {
        ast_rwlock_rdlock(&codecs->codecs_lock);
        for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
            type = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
            if (!type) {
                continue;
            }
 
            if (!type->asterisk_format
                && type->primary_mapping
                && type->rtp_code == code
                && (sample_rate == 0 || type->sample_rate == sample_rate)) {
                payload = idx;
                break;
            }
        }
        ast_rwlock_unlock(&codecs->codecs_lock);
    } else if (format) {
        ast_rwlock_rdlock(&codecs->codecs_lock);
        for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
            type = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
            if (!type) {
                continue;
            }
 
            if (type->asterisk_format
                && type->primary_mapping
                && ast_format_cmp(format, type->format) == AST_FORMAT_CMP_EQUAL) {
                payload = idx;
                break;
            }
        }
        ast_rwlock_unlock(&codecs->codecs_lock);
    }
 
    if (payload < 0) {
        payload = rtp_codecs_assign_payload_code_rx(codecs, asterisk_format, format,
            code, 0, sample_rate);
    }
    ast_rwlock_unlock(&static_RTP_PT_lock);
 
    return payload;
}

References ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_rtp_payload_type::asterisk_format, codecs, ast_rtp_payload_type::format, ast_rtp_payload_type::payload, rtp_codecs_assign_payload_code_rx(), ast_rtp_payload_type::sample_rate, static_RTP_PT_lock, and type.

Referenced by ast_rtp_codecs_payload_code(), and create_outgoing_sdp_stream().

ast_rtp_codecs_payload_code_tx()

int ast_rtp_codecs_payload_code_tx	(	struct ast_rtp_codecs *	codecs,
		int	asterisk_format,
		const struct ast_format *	format,
		int	code
	)

Retrieve a tx mapped payload type based on whether it is an Asterisk format and the code.

Since

14.0.0

Parameters

codecs	Codecs structure to look in
asterisk_format	Non-zero if the given Asterisk format is present
format	Asterisk format to look for
code	The format to look for

Returns

Numerical payload type

Return values

-1	if not found.

Definition at line 2185 of file rtp_engine.c.

{
    return ast_rtp_codecs_payload_code_tx_sample_rate(codecs, asterisk_format, format, code, 0);
}

References ast_rtp_codecs_payload_code_tx_sample_rate(), ast_rtp_payload_type::asterisk_format, codecs, and ast_rtp_payload_type::format.

Referenced by ast_rtp_dtmf_begin(), ast_rtp_sendcng(), ast_rtp_write(), multicast_rtp_write(), and send_start_rtp().

ast_rtp_codecs_payload_code_tx_sample_rate()

int ast_rtp_codecs_payload_code_tx_sample_rate	(	struct ast_rtp_codecs *	codecs,
		int	asterisk_format,
		const struct ast_format *	format,
		int	code,
		unsigned int	sample_rate
	)

Retrieve a tx mapped payload type based on whether it is an Asterisk format and the code.

Since

22.0.0

Parameters

codecs	Codecs structure to look in
asterisk_format	Non-zero if the given Asterisk format is present
format	Asterisk format to look for
code	The format to look for
sample_rate	The sample rate to look for, zero if we don't care

Returns

Numerical payload type

Return values

-1	if not found.

Definition at line 2114 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type;
    int idx;
    int payload = -1;
 
    if (!asterisk_format) {
        ast_rwlock_rdlock(&codecs->codecs_lock);
        for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
            type = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
            if (!type) {
                continue;
            }
 
            if (!type->asterisk_format
                && type->rtp_code == code
                /* Multiple DTMF types share an rtp code but have different sample rates.  To ensure we have the right
                   type we therefore need the sample rate as well as the format and code.  Other types have a fixed
                   sample rate so this is not needed. For those pass in a sample rate of 0 or use ast_rtp_codecs_payload_code_tx. */
                && (sample_rate == 0 || type->sample_rate == sample_rate)) {
                payload = idx;
                break;
            }
        }
        ast_rwlock_unlock(&codecs->codecs_lock);
    } else if (format) {
        ast_rwlock_rdlock(&codecs->codecs_lock);
        for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
            type = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
            if (!type) {
                continue;
            }
 
            if (type->asterisk_format
                && ast_format_cmp(format, type->format) == AST_FORMAT_CMP_EQUAL) {
                payload = idx;
                break;
            }
        }
        ast_rwlock_unlock(&codecs->codecs_lock);
    }
 
    if (payload < 0) {
        ast_rwlock_rdlock(&static_RTP_PT_lock);
        payload = find_static_payload_type(asterisk_format, format, code);
        ast_rwlock_unlock(&static_RTP_PT_lock);
 
        /*
         * Comfort noise is NOT used as an SDP negotiated format within Asterisk;
         * instead, it is used when it is not negotiated. This special case allows
         * its payload to be returned when not negotiated, allowing keep alive to
         * function as expected.
         */
        if (payload == 13 && code == AST_RTP_CN) {
            return payload;
        }
 
        ast_rwlock_rdlock(&codecs->codecs_lock);
        if (payload >= 0 && payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)){
            type = AST_VECTOR_GET(&codecs->payload_mapping_tx, payload);
            if (!type || (sample_rate != 0 && type->sample_rate != sample_rate)) {
                /* Don't use the type if we can't find it or it doesn't match the supplied sample_rate */
                payload = -1;
            }
        }
        ast_rwlock_unlock(&codecs->codecs_lock);
    }
 
    return payload;
}

References ast_format_cmp(), AST_FORMAT_CMP_EQUAL, AST_RTP_CN, ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_rtp_payload_type::asterisk_format, codecs, find_static_payload_type(), ast_rtp_payload_type::format, ast_rtp_payload_type::payload, ast_rtp_payload_type::sample_rate, static_RTP_PT_lock, and type.

Referenced by ast_rtp_codecs_payload_code_tx(), ast_rtp_dtmf_begin(), and bridge_p2p_rtp_write().

ast_rtp_codecs_payload_formats()

void ast_rtp_codecs_payload_formats	(	struct ast_rtp_codecs *	codecs,
		struct ast_format_cap *	astformats,
		int *	nonastformats
	)

Retrieve all formats that were found.

Parameters

codecs	Codecs structure to look in
astformats	A capabilities structure to put the Asterisk formats in.
nonastformats	An integer to put the non-Asterisk formats in

Example usage:

struct ast_format_cap *astformats = ast_format_cap_alloc_nolock()
int nonastformats;
ast_rtp_codecs_payload_formats(&codecs, astformats, &nonastformats);

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.8

Definition at line 1722 of file rtp_engine.c.

{
    int idx;
 
    ast_format_cap_remove_by_type(astformats, AST_MEDIA_TYPE_UNKNOWN);
    *nonastformats = 0;
 
    ast_rwlock_rdlock(&codecs->codecs_lock);
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
        struct ast_rtp_payload_type *type;
 
        type = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
        if (!type) {
            continue;
        }
 
        if (type->asterisk_format) {
            ast_format_cap_append(astformats, type->format, 0);
        } else {
            *nonastformats |= type->rtp_code;
        }
    }
    if (codecs->framing) {
        ast_format_cap_set_framing(astformats, codecs->framing);
    }
 
    ast_rwlock_unlock(&codecs->codecs_lock);
}

References ast_format_cap_append, ast_format_cap_remove_by_type(), ast_format_cap_set_framing(), AST_MEDIA_TYPE_UNKNOWN, ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, codecs, and type.

Referenced by jingle_interpret_description().

ast_rtp_codecs_payload_replace_format()

int ast_rtp_codecs_payload_replace_format	(	struct ast_rtp_codecs *	codecs,
		int	payload,
		struct ast_format *	format
	)

Update the format associated with a tx payload type in a codecs structure.

Parameters

codecs	Codecs structure to operate on
payload	Numerical payload type to look up
format	The format to replace the existing one

Return values

0	success
-1	failure

Since

13

Definition at line 1645 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type;
 
    if (payload < 0 || payload >= AST_RTP_MAX_PT || !format) {
        return -1;
    }
 
    type = ast_rtp_engine_alloc_payload_type();
    if (!type) {
        return -1;
    }
    ao2_ref(format, +1);
    type->format = format;
    type->asterisk_format = 1;
    type->payload = payload;
    type->primary_mapping = 1;
 
    ast_rwlock_wrlock(&codecs->codecs_lock);
    if (!payload_mapping_tx_is_present(codecs, type)) {
        if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
            ao2_cleanup(AST_VECTOR_GET(&codecs->payload_mapping_tx, payload));
        }
        if (AST_VECTOR_REPLACE(&codecs->payload_mapping_tx, payload, type)) {
            ao2_ref(type, -1);
        }
    } else {
        ao2_ref(type, -1);
    }
    ast_rwlock_unlock(&codecs->codecs_lock);
 
    return 0;
}

References ao2_cleanup, ao2_ref, ast_rtp_engine_alloc_payload_type(), AST_RTP_MAX_PT, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, codecs, ast_rtp_payload_type::format, ast_rtp_payload_type::payload, payload_mapping_tx_is_present(), and type.

Referenced by get_codecs().

ast_rtp_codecs_payload_set_rx()

int ast_rtp_codecs_payload_set_rx	(	struct ast_rtp_codecs *	codecs,
		int	code,
		struct ast_format *	format
	)

Set a payload code for use with a specific Asterisk format.

Parameters

codecs	Codecs structure to manipulate
code	The payload code
format	Asterisk format

Return values

0	Payload was set to the given format
-1	Payload was in use or could not be set

Since

15.0.0

Definition at line 2104 of file rtp_engine.c.

{
    return rtp_codecs_assign_payload_code_rx(codecs, 1, format, code, 1, 0);
}

References codecs, ast_rtp_payload_type::format, and rtp_codecs_assign_payload_code_rx().

Referenced by apply_cap_to_bundled(), and create_outgoing_sdp_stream().

ast_rtp_codecs_payload_set_rx_sample_rate()

int ast_rtp_codecs_payload_set_rx_sample_rate	(	struct ast_rtp_codecs *	codecs,
		int	code,
		struct ast_format *	format,
		unsigned int	sample_rate
	)

Set a payload code with sample rate for use with a specific Asterisk format.

Parameters

codecs	Codecs structure to manipulate
code	The payload code
format	Asterisk format
sample_rate	Sample rate of the format, 0 to use the format's default

Return values

0	Payload was set to the given format
-1	Payload was in use or could not be set

Since

22.0.0

Definition at line 2109 of file rtp_engine.c.

{
    return rtp_codecs_assign_payload_code_rx(codecs, 1, format, code, 0, sample_rate);
}

References codecs, ast_rtp_payload_type::format, rtp_codecs_assign_payload_code_rx(), and ast_rtp_payload_type::sample_rate.

ast_rtp_codecs_payloads_clear()

void ast_rtp_codecs_payloads_clear	(	struct ast_rtp_codecs *	codecs,
		struct ast_rtp_instance *	instance
	)

Clear rx and tx payload mapping information from an RTP instance.

Parameters

codecs	The codecs structure that payloads will be cleared from
instance	Optionally the instance that the codecs structure belongs to

Example usage:

struct ast_rtp_codecs codecs;
ast_rtp_codecs_payloads_clear(&codecs, NULL);

This clears the codecs structure and puts it into a pristine state.

Since

1.8

Definition at line 1048 of file rtp_engine.c.

{
    ast_rtp_codecs_payloads_destroy(codecs);
    ast_rtp_codecs_payloads_initialize(codecs);
 
    if (instance && instance->engine && instance->engine->payload_set) {
        int i;
 
        ao2_lock(instance);
        for (i = 0; i < AST_RTP_MAX_PT; i++) {
            instance->engine->payload_set(instance, i, 0, NULL, 0);
        }
        ao2_unlock(instance);
    }
}

References ao2_lock, ao2_unlock, ast_rtp_codecs_payloads_destroy(), ast_rtp_codecs_payloads_initialize(), AST_RTP_MAX_PT, codecs, ast_rtp_instance::engine, NULL, and ast_rtp_engine::payload_set.

ast_rtp_codecs_payloads_copy()

void ast_rtp_codecs_payloads_copy	(	struct ast_rtp_codecs *	src,
		struct ast_rtp_codecs *	dest,
		struct ast_rtp_instance *	instance
	)

Copy payload information from one RTP instance to another.

Parameters

src	The source codecs structure
dest	The destination codecs structure that the values from src will be copied to
instance	Optionally the instance that the dst codecs structure belongs to

Example usage:

ast_rtp_codecs_payloads_copy(&codecs0, &codecs1, NULL);

This copies the payloads from the codecs0 structure to the codecs1 structure, overwriting any current values.

Since

1.8

Definition at line 1302 of file rtp_engine.c.

{
    int idx;
    struct ast_rtp_payload_type *type;
 
    ast_rwlock_wrlock(&dest->codecs_lock);
 
    /* Deadlock avoidance because of held write lock. */
    while (ast_rwlock_tryrdlock(&src->codecs_lock)) {
        ast_rwlock_unlock(&dest->codecs_lock);
        sched_yield();
        ast_rwlock_wrlock(&dest->codecs_lock);
    }
 
    /*
     * This represents a completely new mapping of what the remote party is
     * expecting for payloads, so we clear out the entire tx payload mapping
     * vector and replace it.
     */
    for (idx = 0; idx < AST_VECTOR_SIZE(&dest->payload_mapping_tx); ++idx) {
        type = AST_VECTOR_GET(&dest->payload_mapping_tx, idx);
        ao2_t_cleanup(type, "destroying ast_rtp_codec tx mapping");
        AST_VECTOR_REPLACE(&dest->payload_mapping_tx, idx, NULL);
    }
 
    rtp_codecs_payloads_copy_rx(src, dest, instance);
    rtp_codecs_payloads_copy_tx(src, dest, instance);
    dest->framing = src->framing;
    ao2_replace(dest->preferred_format, src->preferred_format);
    dest->preferred_dtmf_rate = src->preferred_dtmf_rate;
    dest->preferred_dtmf_pt = src->preferred_dtmf_pt;
 
    ast_rwlock_unlock(&src->codecs_lock);
    ast_rwlock_unlock(&dest->codecs_lock);
}

References ao2_replace, ao2_t_cleanup, ast_rwlock_tryrdlock, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, ast_rtp_codecs::codecs_lock, ast_rtp_codecs::framing, NULL, ast_rtp_codecs::payload_mapping_tx, ast_rtp_codecs::preferred_dtmf_pt, ast_rtp_codecs::preferred_dtmf_rate, ast_rtp_codecs::preferred_format, rtp_codecs_payloads_copy_rx(), rtp_codecs_payloads_copy_tx(), and type.

Referenced by jingle_interpret_description(), set_caps(), and set_incoming_call_offer_cap().

ast_rtp_codecs_payloads_destroy()

void ast_rtp_codecs_payloads_destroy

(

struct ast_rtp_codecs *

codecs

)

Destroy the contents of an RTP codecs structure (but not the structure itself)

Parameters

codecs

The codecs structure to destroy the contents of

Example usage:

struct ast_rtp_codecs codecs;
ast_rtp_codecs_payloads_destroy(&codecs);

Since

11

Definition at line 1025 of file rtp_engine.c.

{
    int idx;
    struct ast_rtp_payload_type *type;
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
        type = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
        ao2_t_cleanup(type, "destroying ast_rtp_codec rx mapping");
    }
    AST_VECTOR_FREE(&codecs->payload_mapping_rx);
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
        type = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
        ao2_t_cleanup(type, "destroying ast_rtp_codec tx mapping");
    }
    AST_VECTOR_FREE(&codecs->payload_mapping_tx);
 
    ao2_t_cleanup(codecs->preferred_format, "destroying ast_rtp_codec preferred format");
    codecs->preferred_format = NULL;
 
    ast_rwlock_destroy(&codecs->codecs_lock);
}

References ao2_t_cleanup, ast_rwlock_destroy, AST_VECTOR_FREE, AST_VECTOR_GET, AST_VECTOR_SIZE, codecs, NULL, and type.

Referenced by ast_rtp_codecs_payloads_clear(), ast_stream_free(), ast_stream_set_rtp_codecs(), instance_destructor(), jingle_interpret_description(), set_caps(), and set_incoming_call_offer_cap().

ast_rtp_codecs_payloads_initialize()

int ast_rtp_codecs_payloads_initialize

(

struct ast_rtp_codecs *

codecs

)

Initialize an RTP codecs structure.

Parameters

codecs

The codecs structure to initialize

Return values

0	success
-1	failure

Example usage:

struct ast_rtp_codecs codecs;
ast_rtp_codecs_payloads_initialize(&codecs);

Since

11

Definition at line 1009 of file rtp_engine.c.

{
    int res;
 
    codecs->framing = 0;
    ast_rwlock_init(&codecs->codecs_lock);
    res = AST_VECTOR_INIT(&codecs->payload_mapping_rx, AST_RTP_MAX_PT);
    res |= AST_VECTOR_INIT(&codecs->payload_mapping_tx, AST_RTP_MAX_PT);
    if (res) {
        AST_VECTOR_FREE(&codecs->payload_mapping_rx);
        AST_VECTOR_FREE(&codecs->payload_mapping_tx);
    }
 
    return res;
}

References AST_RTP_MAX_PT, ast_rwlock_init, AST_VECTOR_FREE, AST_VECTOR_INIT, and codecs.

Referenced by ast_rtp_codecs_payloads_clear(), ast_rtp_instance_new_with_options(), get_codecs(), and jingle_interpret_description().

ast_rtp_codecs_payloads_set_m_type()

void ast_rtp_codecs_payloads_set_m_type	(	struct ast_rtp_codecs *	codecs,
		struct ast_rtp_instance *	instance,
		int	payload
	)

Record tx payload type information that was seen in an m= SDP line.

Parameters

codecs	The codecs structure to muck with
instance	Optionally the instance that the codecs structure belongs to
payload	Numerical payload that was seen in the m= SDP line

Example usage:

ast_rtp_codecs_payloads_set_m_type(&codecs, NULL, 0);

This records that the numerical payload '0' was seen in the codecs structure.

Since

1.8

Definition at line 1385 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *new_type;
 
    if (payload < 0 || payload >= AST_RTP_MAX_PT || payload > AST_RTP_PT_LAST_STATIC) {
        return;
    }
 
    ast_rwlock_rdlock(&static_RTP_PT_lock);
    new_type = ao2_bump(static_RTP_PT[payload]);
    ast_rwlock_unlock(&static_RTP_PT_lock);
    if (!new_type) {
        ast_debug(1, "Don't have a default tx payload type %d format for m type on %p\n",
            payload, codecs);
        return;
    }
 
    ast_debug(1, "Setting tx payload type %d based on m type on %p\n",
        payload, codecs);
 
    ast_rwlock_wrlock(&codecs->codecs_lock);
 
    if (!payload_mapping_tx_is_present(codecs, new_type)) {
        if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
            ao2_t_cleanup(AST_VECTOR_GET(&codecs->payload_mapping_tx, payload),
                "cleaning up replaced tx payload type");
        }
 
        if (AST_VECTOR_REPLACE(&codecs->payload_mapping_tx, payload, new_type)) {
            ao2_ref(new_type, -1);
        } else if (instance && instance->engine && instance->engine->payload_set) {
            ao2_lock(instance);
            instance->engine->payload_set(instance, payload, new_type->asterisk_format, new_type->format, new_type->rtp_code);
            ao2_unlock(instance);
        }
    } else {
        ao2_ref(new_type, -1);
    }
 
    ast_rwlock_unlock(&codecs->codecs_lock);
}

References ao2_bump, ao2_lock, ao2_ref, ao2_t_cleanup, ao2_unlock, ast_debug, AST_RTP_MAX_PT, AST_RTP_PT_LAST_STATIC, ast_rwlock_rdlock, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, codecs, ast_rtp_instance::engine, ast_rtp_payload_type::payload, payload_mapping_tx_is_present(), ast_rtp_engine::payload_set, static_RTP_PT, and static_RTP_PT_lock.

Referenced by get_codecs().

ast_rtp_codecs_payloads_set_rtpmap_type()

int ast_rtp_codecs_payloads_set_rtpmap_type	(	struct ast_rtp_codecs *	codecs,
		struct ast_rtp_instance *	instance,
		int	payload,
		char *	mimetype,
		char *	mimesubtype,
		enum ast_rtp_options	options
	)

Record tx payload type information that was seen in an a=rtpmap: SDP line.

Parameters

codecs	The codecs structure to muck with
instance	Optionally the instance that the codecs structure belongs to
payload	Numerical payload that was seen in the a=rtpmap: SDP line
mimetype	The string mime type that was seen
mimesubtype	The string mime sub type that was seen
options	Optional options that may change the behavior of this specific payload

Return values

0	success
-1	failure, invalid payload numbe
-2	failure, unknown mimetype

Example usage:

ast_rtp_codecs_payloads_set_rtpmap_type(&codecs, NULL, 0, "audio", "PCMU", 0);

This records that the numerical payload '0' was seen with mime type 'audio' and sub mime type 'PCMU' in the codecs structure.

Since

1.8

Definition at line 1513 of file rtp_engine.c.

{
    return ast_rtp_codecs_payloads_set_rtpmap_type_rate(codecs, instance, payload, mimetype, mimesubtype, options, 0);
}

References ast_rtp_codecs_payloads_set_rtpmap_type_rate(), codecs, options, and ast_rtp_payload_type::payload.

Referenced by configure_local_rtp(), jingle_interpret_description(), ooh323_set_write_format(), and setup_rtp_connection().

ast_rtp_codecs_payloads_set_rtpmap_type_rate()

int ast_rtp_codecs_payloads_set_rtpmap_type_rate	(	struct ast_rtp_codecs *	codecs,
		struct ast_rtp_instance *	instance,
		int	pt,
		char *	mimetype,
		char *	mimesubtype,
		enum ast_rtp_options	options,
		unsigned int	sample_rate
	)

Set tx payload type to a known MIME media type for a codec with a specific sample rate.

Parameters

codecs	RTP structure to modify
instance	Optionally the instance that the codecs structure belongs to
pt	Payload type entry to modify
mimetype	top-level MIME type of media stream (typically "audio", "video", "text", etc.)
mimesubtype	MIME subtype of media stream (typically a codec name)
options	Zero or more flags from the ast_rtp_options enum
sample_rate	The sample rate of the media stream

This function 'fills in' an entry in the list of possible formats for a media stream associated with an RTP structure.

Return values

0	on success
-1	if the payload type is out of range
-2	if the mimeType/mimeSubtype combination was not found

Since

1.8

Definition at line 1427 of file rtp_engine.c.

{
    unsigned int idx;
    int found = 0;
 
    if (pt < 0 || pt >= AST_RTP_MAX_PT) {
        return -1; /* bogus payload type */
    }
 
    ast_rwlock_rdlock(&mime_types_lock);
    ast_rwlock_wrlock(&codecs->codecs_lock);
 
    for (idx = 0; idx < mime_types_len; ++idx) {
        const struct ast_rtp_mime_type *t = &ast_rtp_mime_types[idx];
        struct ast_rtp_payload_type *new_type;
 
        if (strcasecmp(mimesubtype, t->subtype)) {
            continue;
        }
 
        if (strcasecmp(mimetype, t->type)) {
            continue;
        }
 
        /* if both sample rates have been supplied, and they don't match,
         * then this not a match; if one has not been supplied, then the
         * rates are not compared */
        if (sample_rate && t->sample_rate &&
            (sample_rate != t->sample_rate)) {
            continue;
        }
 
        found = 1;
 
        new_type = ast_rtp_engine_alloc_payload_type();
        if (!new_type) {
            continue;
        }
 
        new_type->asterisk_format = t->payload_type.asterisk_format;
        new_type->rtp_code = t->payload_type.rtp_code;
        new_type->payload = pt;
        new_type->primary_mapping = 1;
        new_type->sample_rate = sample_rate;
        if (t->payload_type.asterisk_format
            && ast_format_cmp(t->payload_type.format, ast_format_g726) == AST_FORMAT_CMP_EQUAL
            && (options & AST_RTP_OPT_G726_NONSTANDARD)) {
            new_type->format = ast_format_g726_aal2;
        } else {
            new_type->format = t->payload_type.format;
        }
 
        if (new_type->format) {
            /* SDP parsing automatically increases the reference count */
            new_type->format = ast_format_parse_sdp_fmtp(new_type->format, "");
        }
 
        if (!payload_mapping_tx_is_present(codecs, new_type)) {
            if (pt < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
                ao2_t_cleanup(AST_VECTOR_GET(&codecs->payload_mapping_tx, pt),
                    "cleaning up replaced tx payload type");
            }
 
            if (AST_VECTOR_REPLACE(&codecs->payload_mapping_tx, pt, new_type)) {
                ao2_ref(new_type, -1);
            } else if (instance && instance->engine && instance->engine->payload_set) {
                ao2_lock(instance);
                instance->engine->payload_set(instance, pt, new_type->asterisk_format, new_type->format, new_type->rtp_code);
                ao2_unlock(instance);
            }
        } else {
            ao2_ref(new_type, -1);
        }
 
        break;
    }
 
    ast_rwlock_unlock(&codecs->codecs_lock);
    ast_rwlock_unlock(&mime_types_lock);
 
    return (found ? 0 : -2);
}

References ao2_lock, ao2_ref, ao2_t_cleanup, ao2_unlock, ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_g726, ast_format_g726_aal2, ast_format_parse_sdp_fmtp(), ast_rtp_engine_alloc_payload_type(), AST_RTP_MAX_PT, ast_rtp_mime_types, AST_RTP_OPT_G726_NONSTANDARD, ast_rwlock_rdlock, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, ast_rtp_payload_type::asterisk_format, codecs, ast_rtp_instance::engine, ast_rtp_payload_type::format, mime_types_len, mime_types_lock, options, payload_mapping_tx_is_present(), ast_rtp_engine::payload_set, ast_rtp_mime_type::payload_type, ast_rtp_payload_type::rtp_code, ast_rtp_payload_type::sample_rate, ast_rtp_mime_type::sample_rate, ast_rtp_mime_type::subtype, and ast_rtp_mime_type::type.

Referenced by ast_rtp_codecs_payloads_set_rtpmap_type(), get_codecs(), and jingle_interpret_description().

ast_rtp_codecs_payloads_unset()

void ast_rtp_codecs_payloads_unset	(	struct ast_rtp_codecs *	codecs,
		struct ast_rtp_instance *	instance,
		int	payload
	)

Remove tx payload type mapped information.

Parameters

codecs	The codecs structure to muck with
instance	Optionally the instance that the codecs structure belongs to
payload	Numerical payload to unset

Example usage:

ast_rtp_codecs_payloads_unset(&codecs, NULL, 0);

This clears the payload '0' from the codecs structure. It will be as if it was never set.

Since

1.8

Definition at line 1518 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type;
 
    if (payload < 0 || payload >= AST_RTP_MAX_PT) {
        return;
    }
 
    ast_debug(2, "Unsetting payload %d on %p\n", payload, codecs);
 
    ast_rwlock_wrlock(&codecs->codecs_lock);
 
    if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_tx)) {
        type = AST_VECTOR_GET(&codecs->payload_mapping_tx, payload);
        /*
         * Remove the preferred format if we are unsetting its container.
         *
         * There can be empty slots in payload_mapping_tx corresponding to
         * dynamic payload types that haven't been seen before so we need
         * to check for NULL before attempting to use 'type' in the call to
         * ast_format_cmp.
         */
        if (type) {
            if (ast_format_cmp(type->format, codecs->preferred_format) == AST_FORMAT_CMP_EQUAL) {
                ao2_replace(codecs->preferred_format, NULL);
            }
            ao2_ref(type, -1);
            AST_VECTOR_REPLACE(&codecs->payload_mapping_tx, payload, NULL);
        }
    }
 
    if (instance && instance->engine && instance->engine->payload_set) {
        ao2_lock(instance);
        instance->engine->payload_set(instance, payload, 0, NULL, 0);
        ao2_unlock(instance);
    }
 
    ast_rwlock_unlock(&codecs->codecs_lock);
}

References ao2_lock, ao2_ref, ao2_replace, ao2_unlock, ast_debug, ast_format_cmp(), AST_FORMAT_CMP_EQUAL, AST_RTP_MAX_PT, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, codecs, ast_rtp_instance::engine, NULL, ast_rtp_payload_type::payload, ast_rtp_engine::payload_set, and type.

ast_rtp_codecs_payloads_xover()

void ast_rtp_codecs_payloads_xover	(	struct ast_rtp_codecs *	src,
		struct ast_rtp_codecs *	dest,
		struct ast_rtp_instance *	instance
	)

Crossover copy the tx payload mapping of src to the rx payload mapping of dest.

Since

14.0.0

Parameters

src	The source codecs structure
dest	The destination codecs structure that the values from src will be copied to
instance	Optionally the instance that the dst codecs structure belongs to

Definition at line 1338 of file rtp_engine.c.

{
    int idx;
    struct ast_rtp_payload_type *type;
 
    ast_rwlock_wrlock(&dest->codecs_lock);
    if (src != dest) {
        /* Deadlock avoidance because of held write lock. */
        while (ast_rwlock_tryrdlock(&src->codecs_lock)) {
            ast_rwlock_unlock(&dest->codecs_lock);
            sched_yield();
            ast_rwlock_wrlock(&dest->codecs_lock);
        }
    }
 
    /* Crossover copy payload type tx mapping to rx mapping. */
    for (idx = 0; idx < AST_VECTOR_SIZE(&src->payload_mapping_tx); ++idx) {
        type = AST_VECTOR_GET(&src->payload_mapping_tx, idx);
        if (!type) {
            continue;
        }
 
        /* All tx mapping elements should have the primary flag set. */
        ast_assert(type->primary_mapping);
 
        ast_debug(2, "Crossover copying tx to rx payload mapping %d (%p) from %p to %p\n",
            idx, type, src, dest);
        rtp_codecs_payload_replace_rx(dest, idx, type);
 
        if (instance && instance->engine && instance->engine->payload_set) {
            ao2_lock(instance);
            instance->engine->payload_set(instance, idx, type->asterisk_format, type->format, type->rtp_code);
            ao2_unlock(instance);
        }
    }
 
    dest->framing = src->framing;
    ao2_replace(dest->preferred_format, src->preferred_format);
    dest->preferred_dtmf_rate = src->preferred_dtmf_rate;
    dest->preferred_dtmf_pt = src->preferred_dtmf_pt;
 
    if (src != dest) {
        ast_rwlock_unlock(&src->codecs_lock);
    }
    ast_rwlock_unlock(&dest->codecs_lock);
}

References ao2_lock, ao2_replace, ao2_unlock, ast_assert, ast_debug, ast_rwlock_tryrdlock, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_rtp_codecs::codecs_lock, ast_rtp_instance::engine, ast_rtp_codecs::framing, ast_rtp_codecs::payload_mapping_tx, ast_rtp_engine::payload_set, ast_rtp_codecs::preferred_dtmf_pt, ast_rtp_codecs::preferred_dtmf_rate, ast_rtp_codecs::preferred_format, rtp_codecs_payload_replace_rx(), and type.

Referenced by ast_rtp_instance_early_bridge_make_compatible(), set_caps(), and set_incoming_call_offer_cap().

ast_rtp_codecs_set_framing()

void ast_rtp_codecs_set_framing	(	struct ast_rtp_codecs *	codecs,
		unsigned int	framing
	)

Set the framing used for a set of codecs.

Parameters

codecs	Codecs structure to set framing on
framing	The framing value to set on the codecs

Since

13.0.0

Definition at line 1700 of file rtp_engine.c.

{
    if (!framing) {
        return;
    }
 
    ast_rwlock_wrlock(&codecs->codecs_lock);
    codecs->framing = framing;
    ast_rwlock_unlock(&codecs->codecs_lock);
}

References ast_rwlock_unlock, ast_rwlock_wrlock, and codecs.

Referenced by configure_local_rtp(), get_codecs(), jingle_enable_video(), and jingle_new().

ast_rtp_codecs_set_preferred_dtmf_format()

int ast_rtp_codecs_set_preferred_dtmf_format	(	struct ast_rtp_codecs *	codecs,
		int	pt,
		int	rate
	)

Set the preferred dtmf format pt and sample rate.

Parameters

codecs	Codecs structure to set the preferred format in
pt	Preferred dtmf payload type to set.
rate	Preferred dtmf payload rate to set.

Returns

0

Note

The format passed this function has its reference count increased. If an existing format is set, that format is replaced.

Example usage:

int dtmf_code = atoi(dtmf_pt);
int dtmf_rate = clock_rate;
ast_rtp_codecs_set_preferred_dtmf_format(codecs, dtmf_code, dtmf_rate);

This sets the preferred dtmf_code and dtmf_rate on the codec.

Definition at line 1636 of file rtp_engine.c.

{
    ast_rwlock_wrlock(&codecs->codecs_lock);
    codecs->preferred_dtmf_pt = pt;
    codecs->preferred_dtmf_rate = rate;
    ast_rwlock_unlock(&codecs->codecs_lock);
    return 0;
}

References ast_rwlock_unlock, ast_rwlock_wrlock, and codecs.

Referenced by get_codecs().

ast_rtp_codecs_set_preferred_format()

int ast_rtp_codecs_set_preferred_format	(	struct ast_rtp_codecs *	codecs,
		struct ast_format *	format
	)

Set the preferred format.

Parameters

codecs	Codecs structure to set the preferred format in
format	Preferred format to set.

Returns

0

Note

The format passed this function has its reference count increased. If an existing format is set, that format is replaced.

Example usage:

struct ast_format *preferred_format = ast_format_cap_get_format(joint, 0);
ast_rtp_codecs_set_preferred_format(&codecs, preferred_format));

This sets the first joint format as the preferred format.

Definition at line 1610 of file rtp_engine.c.

{
    ast_rwlock_wrlock(&codecs->codecs_lock);
    ao2_replace(codecs->preferred_format, format);
    ast_rwlock_unlock(&codecs->codecs_lock);
    return 0;
}

References ao2_replace, ast_rwlock_unlock, ast_rwlock_wrlock, and codecs.

Referenced by set_caps().

ast_rtp_convert_stats_json()

struct ast_json * ast_rtp_convert_stats_json

(

const struct ast_rtp_instance_stats *

stats

)

Convert given stat instance into json format.

Parameters

stats

Returns

A json format stat

Definition at line 4244 of file rtp_engine.c.

{
    struct ast_json *j_res;
    int ret;
 
    j_res = ast_json_object_create();
    if (!j_res) {
        return NULL;
    }
 
    /* set mandatory items */
    ret = ast_json_object_set(j_res, "txcount", ast_json_integer_create(stats->txcount));
    ret |= ast_json_object_set(j_res, "rxcount", ast_json_integer_create(stats->rxcount));
 
    ret |= ast_json_object_set(j_res, "txploss", ast_json_integer_create(stats->txploss));
    ret |= ast_json_object_set(j_res, "rxploss", ast_json_integer_create(stats->rxploss));
 
    ret |= ast_json_object_set(j_res, "local_ssrc", ast_json_integer_create(stats->local_ssrc));
    ret |= ast_json_object_set(j_res, "remote_ssrc", ast_json_integer_create(stats->remote_ssrc));
 
    ret |= ast_json_object_set(j_res, "txoctetcount", ast_json_integer_create(stats->txoctetcount));
    ret |= ast_json_object_set(j_res, "rxoctetcount", ast_json_integer_create(stats->rxoctetcount));
 
    ret |= ast_json_object_set(j_res, "channel_uniqueid", ast_json_string_create(stats->channel_uniqueid));
    if (ret) {
        ast_log(LOG_WARNING, "Could not create rtp statistics info. channel: %s\n", stats->channel_uniqueid);
        ast_json_unref(j_res);
        return NULL;
    }
 
    /* set other items */
    SET_AST_JSON_OBJ(j_res, "txjitter", ast_json_real_create(stats->txjitter));
    SET_AST_JSON_OBJ(j_res, "rxjitter", ast_json_real_create(stats->rxjitter));
 
    SET_AST_JSON_OBJ(j_res, "remote_maxjitter", ast_json_real_create(stats->remote_maxjitter));
    SET_AST_JSON_OBJ(j_res, "remote_minjitter", ast_json_real_create(stats->remote_minjitter));
    SET_AST_JSON_OBJ(j_res, "remote_normdevjitter", ast_json_real_create(stats->remote_normdevjitter));
    SET_AST_JSON_OBJ(j_res, "remote_stdevjitter", ast_json_real_create(stats->remote_stdevjitter));
 
    SET_AST_JSON_OBJ(j_res, "local_maxjitter", ast_json_real_create(stats->local_maxjitter));
    SET_AST_JSON_OBJ(j_res, "local_minjitter", ast_json_real_create(stats->local_minjitter));
    SET_AST_JSON_OBJ(j_res, "local_normdevjitter", ast_json_real_create(stats->local_normdevjitter));
    SET_AST_JSON_OBJ(j_res, "local_stdevjitter", ast_json_real_create(stats->local_stdevjitter));
 
    SET_AST_JSON_OBJ(j_res, "remote_maxrxploss", ast_json_real_create(stats->remote_maxrxploss));
    SET_AST_JSON_OBJ(j_res, "remote_minrxploss", ast_json_real_create(stats->remote_minrxploss));
    SET_AST_JSON_OBJ(j_res, "remote_normdevrxploss", ast_json_real_create(stats->remote_normdevrxploss));
    SET_AST_JSON_OBJ(j_res, "remote_stdevrxploss", ast_json_real_create(stats->remote_stdevrxploss));
 
    SET_AST_JSON_OBJ(j_res, "local_maxrxploss", ast_json_real_create(stats->local_maxrxploss));
    SET_AST_JSON_OBJ(j_res, "local_minrxploss", ast_json_real_create(stats->local_minrxploss));
    SET_AST_JSON_OBJ(j_res, "local_normdevrxploss", ast_json_real_create(stats->local_normdevrxploss));
    SET_AST_JSON_OBJ(j_res, "local_stdevrxploss", ast_json_real_create(stats->local_stdevrxploss));
 
    SET_AST_JSON_OBJ(j_res, "rtt", ast_json_real_create(stats->rtt));
    SET_AST_JSON_OBJ(j_res, "maxrtt", ast_json_real_create(stats->maxrtt));
    SET_AST_JSON_OBJ(j_res, "minrtt", ast_json_real_create(stats->minrtt));
    SET_AST_JSON_OBJ(j_res, "normdevrtt", ast_json_real_create(stats->normdevrtt));
    SET_AST_JSON_OBJ(j_res, "stdevrtt", ast_json_real_create(stats->stdevrtt));
 
    SET_AST_JSON_OBJ(j_res, "txmes", ast_json_integer_create(stats->txmes));
    SET_AST_JSON_OBJ(j_res, "rxmes", ast_json_integer_create(stats->rxmes));
 
    SET_AST_JSON_OBJ(j_res, "remote_maxmes", ast_json_real_create(stats->remote_maxmes));
    SET_AST_JSON_OBJ(j_res, "remote_minmes", ast_json_real_create(stats->remote_minmes));
    SET_AST_JSON_OBJ(j_res, "remote_normdevmes", ast_json_real_create(stats->remote_normdevmes));
    SET_AST_JSON_OBJ(j_res, "remote_stdevmes", ast_json_real_create(stats->remote_stdevmes));
 
    SET_AST_JSON_OBJ(j_res, "local_maxmes", ast_json_real_create(stats->local_maxmes));
    SET_AST_JSON_OBJ(j_res, "local_minmes", ast_json_real_create(stats->local_minmes));
    SET_AST_JSON_OBJ(j_res, "local_normdevmes", ast_json_real_create(stats->local_normdevmes));
    SET_AST_JSON_OBJ(j_res, "local_stdevmes", ast_json_real_create(stats->local_stdevmes));
 
    return j_res;
}

References ast_json_integer_create(), ast_json_object_create(), ast_json_object_set(), ast_json_real_create(), ast_json_string_create(), ast_json_unref(), ast_log, ast_rtp_instance_stats::channel_uniqueid, ast_rtp_instance_stats::local_maxjitter, ast_rtp_instance_stats::local_maxmes, ast_rtp_instance_stats::local_maxrxploss, ast_rtp_instance_stats::local_minjitter, ast_rtp_instance_stats::local_minmes, ast_rtp_instance_stats::local_minrxploss, ast_rtp_instance_stats::local_normdevjitter, ast_rtp_instance_stats::local_normdevmes, ast_rtp_instance_stats::local_normdevrxploss, ast_rtp_instance_stats::local_ssrc, ast_rtp_instance_stats::local_stdevjitter, ast_rtp_instance_stats::local_stdevmes, ast_rtp_instance_stats::local_stdevrxploss, LOG_WARNING, ast_rtp_instance_stats::maxrtt, ast_rtp_instance_stats::minrtt, ast_rtp_instance_stats::normdevrtt, NULL, ast_rtp_instance_stats::remote_maxjitter, ast_rtp_instance_stats::remote_maxmes, ast_rtp_instance_stats::remote_maxrxploss, ast_rtp_instance_stats::remote_minjitter, ast_rtp_instance_stats::remote_minmes, ast_rtp_instance_stats::remote_minrxploss, ast_rtp_instance_stats::remote_normdevjitter, ast_rtp_instance_stats::remote_normdevmes, ast_rtp_instance_stats::remote_normdevrxploss, ast_rtp_instance_stats::remote_ssrc, ast_rtp_instance_stats::remote_stdevjitter, ast_rtp_instance_stats::remote_stdevmes, ast_rtp_instance_stats::remote_stdevrxploss, ast_rtp_instance_stats::rtt, ast_rtp_instance_stats::rxcount, ast_rtp_instance_stats::rxjitter, ast_rtp_instance_stats::rxmes, ast_rtp_instance_stats::rxoctetcount, ast_rtp_instance_stats::rxploss, SET_AST_JSON_OBJ, ast_rtp_instance_stats::stdevrtt, ast_rtp_instance_stats::txcount, ast_rtp_instance_stats::txjitter, ast_rtp_instance_stats::txmes, ast_rtp_instance_stats::txoctetcount, and ast_rtp_instance_stats::txploss.

Referenced by ast_rtp_instance_get_stats_all_json().

ast_rtp_dtls_cfg_copy()

void ast_rtp_dtls_cfg_copy	(	const struct ast_rtp_dtls_cfg *	src_cfg,
		struct ast_rtp_dtls_cfg *	dst_cfg
	)

Copy contents of a DTLS configuration structure.

Parameters

src_cfg	source DTLS configuration structure
dst_cfg	destination DTLS configuration structure

Definition at line 3368 of file rtp_engine.c.

{
    ast_rtp_dtls_cfg_free(dst_cfg);         /* Prevent a double-call leaking memory via ast_strdup */
 
    dst_cfg->enabled = src_cfg->enabled;
    dst_cfg->verify = src_cfg->verify;
    dst_cfg->rekey = src_cfg->rekey;
    dst_cfg->suite = src_cfg->suite;
    dst_cfg->hash = src_cfg->hash;
    dst_cfg->ephemeral_cert = src_cfg->ephemeral_cert;
    dst_cfg->certfile = ast_strdup(src_cfg->certfile);
    dst_cfg->pvtfile = ast_strdup(src_cfg->pvtfile);
    dst_cfg->cipher = ast_strdup(src_cfg->cipher);
    dst_cfg->cafile = ast_strdup(src_cfg->cafile);
    dst_cfg->capath = ast_strdup(src_cfg->capath);
    dst_cfg->default_setup = src_cfg->default_setup;
}

References ast_rtp_dtls_cfg_free(), ast_strdup, ast_rtp_dtls_cfg::cafile, ast_rtp_dtls_cfg::capath, ast_rtp_dtls_cfg::certfile, ast_rtp_dtls_cfg::cipher, ast_rtp_dtls_cfg::default_setup, ast_rtp_dtls_cfg::enabled, ast_rtp_dtls_cfg::ephemeral_cert, ast_rtp_dtls_cfg::hash, ast_rtp_dtls_cfg::pvtfile, ast_rtp_dtls_cfg::rekey, ast_rtp_dtls_cfg::suite, and ast_rtp_dtls_cfg::verify.

ast_rtp_dtls_cfg_free()

void ast_rtp_dtls_cfg_free

(

struct ast_rtp_dtls_cfg *

dtls_cfg

)

Free contents of a DTLS configuration structure.

Parameters

dtls_cfg

a DTLS configuration structure

Definition at line 3386 of file rtp_engine.c.

{
    ast_free(dtls_cfg->certfile);
    dtls_cfg->certfile = NULL;
    ast_free(dtls_cfg->pvtfile);
    dtls_cfg->pvtfile = NULL;
    ast_free(dtls_cfg->cipher);
    dtls_cfg->cipher = NULL;
    ast_free(dtls_cfg->cafile);
    dtls_cfg->cafile = NULL;
    ast_free(dtls_cfg->capath);
    dtls_cfg->capath = NULL;
}

References ast_free, ast_rtp_dtls_cfg::cafile, ast_rtp_dtls_cfg::capath, ast_rtp_dtls_cfg::certfile, ast_rtp_dtls_cfg::cipher, NULL, and ast_rtp_dtls_cfg::pvtfile.

Referenced by ast_rtp_dtls_cfg_copy(), and media_configuration_destroy().

ast_rtp_dtls_cfg_parse()

int ast_rtp_dtls_cfg_parse	(	struct ast_rtp_dtls_cfg *	dtls_cfg,
		const char *	name,
		const char *	value
	)

Parse DTLS related configuration options.

Parameters

dtls_cfg	a DTLS configuration structure
name	name of the configuration option
value	value of the configuration option

Return values

0	if handled
-1	if not handled

Definition at line 3275 of file rtp_engine.c.

{
    if (!strcasecmp(name, "dtlsenable")) {
        dtls_cfg->enabled = ast_true(value) ? 1 : 0;
    } else if (!strcasecmp(name, "dtlsverify")) {
        if (!strcasecmp(value, "yes")) {
            dtls_cfg->verify = AST_RTP_DTLS_VERIFY_FINGERPRINT | AST_RTP_DTLS_VERIFY_CERTIFICATE;
        } else if (!strcasecmp(value, "fingerprint")) {
            dtls_cfg->verify = AST_RTP_DTLS_VERIFY_FINGERPRINT;
        } else if (!strcasecmp(value, "certificate")) {
            dtls_cfg->verify = AST_RTP_DTLS_VERIFY_CERTIFICATE;
        } else if (!strcasecmp(value, "no")) {
            dtls_cfg->verify = AST_RTP_DTLS_VERIFY_NONE;
        } else {
            return -1;
        }
    } else if (!strcasecmp(name, "dtlsrekey")) {
        if (sscanf(value, "%30u", &dtls_cfg->rekey) != 1) {
            return -1;
        }
    } else if (!strcasecmp(name, "dtlsautogeneratecert")) {
        dtls_cfg->ephemeral_cert = ast_true(value) ? 1 : 0;
    } else if (!strcasecmp(name, "dtlscertfile")) {
        if (!ast_strlen_zero(value) && !ast_file_is_readable(value)) {
            ast_log(LOG_ERROR, "%s file %s does not exist or is not readable\n", name, value);
            return -1;
        }
        ast_free(dtls_cfg->certfile);
        dtls_cfg->certfile = ast_strdup(value);
    } else if (!strcasecmp(name, "dtlsprivatekey")) {
        if (!ast_strlen_zero(value) && !ast_file_is_readable(value)) {
            ast_log(LOG_ERROR, "%s file %s does not exist or is not readable\n", name, value);
            return -1;
        }
        ast_free(dtls_cfg->pvtfile);
        dtls_cfg->pvtfile = ast_strdup(value);
    } else if (!strcasecmp(name, "dtlscipher")) {
        ast_free(dtls_cfg->cipher);
        dtls_cfg->cipher = ast_strdup(value);
    } else if (!strcasecmp(name, "dtlscafile")) {
        if (!ast_strlen_zero(value) && !ast_file_is_readable(value)) {
            ast_log(LOG_ERROR, "%s file %s does not exist or is not readable\n", name, value);
            return -1;
        }
        ast_free(dtls_cfg->cafile);
        dtls_cfg->cafile = ast_strdup(value);
    } else if (!strcasecmp(name, "dtlscapath") || !strcasecmp(name, "dtlscadir")) {
        if (!ast_strlen_zero(value) && !ast_file_is_readable(value)) {
            ast_log(LOG_ERROR, "%s file %s does not exist or is not readable\n", name, value);
            return -1;
        }
        ast_free(dtls_cfg->capath);
        dtls_cfg->capath = ast_strdup(value);
    } else if (!strcasecmp(name, "dtlssetup")) {
        if (!strcasecmp(value, "active")) {
            dtls_cfg->default_setup = AST_RTP_DTLS_SETUP_ACTIVE;
        } else if (!strcasecmp(value, "passive")) {
            dtls_cfg->default_setup = AST_RTP_DTLS_SETUP_PASSIVE;
        } else if (!strcasecmp(value, "actpass")) {
            dtls_cfg->default_setup = AST_RTP_DTLS_SETUP_ACTPASS;
        }
    } else if (!strcasecmp(name, "dtlsfingerprint")) {
        if (!strcasecmp(value, "sha-256")) {
            dtls_cfg->hash = AST_RTP_DTLS_HASH_SHA256;
        } else if (!strcasecmp(value, "sha-1")) {
            dtls_cfg->hash = AST_RTP_DTLS_HASH_SHA1;
        }
    } else {
        return -1;
    }
 
    return 0;
}

References ast_file_is_readable(), ast_free, ast_log, AST_RTP_DTLS_HASH_SHA1, AST_RTP_DTLS_HASH_SHA256, AST_RTP_DTLS_SETUP_ACTIVE, AST_RTP_DTLS_SETUP_ACTPASS, AST_RTP_DTLS_SETUP_PASSIVE, AST_RTP_DTLS_VERIFY_CERTIFICATE, AST_RTP_DTLS_VERIFY_FINGERPRINT, AST_RTP_DTLS_VERIFY_NONE, ast_strdup, ast_strlen_zero(), ast_true(), ast_rtp_dtls_cfg::cafile, ast_rtp_dtls_cfg::capath, ast_rtp_dtls_cfg::certfile, ast_rtp_dtls_cfg::cipher, ast_rtp_dtls_cfg::default_setup, ast_rtp_dtls_cfg::enabled, ast_rtp_dtls_cfg::ephemeral_cert, ast_rtp_dtls_cfg::hash, LOG_ERROR, name, ast_rtp_dtls_cfg::pvtfile, ast_rtp_dtls_cfg::rekey, value, and ast_rtp_dtls_cfg::verify.

Referenced by dtls_handler(), and media_encryption_handler().

ast_rtp_dtls_cfg_validate()

int ast_rtp_dtls_cfg_validate

(

struct ast_rtp_dtls_cfg *

dtls_cfg

)

Validates DTLS related configuration options.

Parameters

dtls_cfg

a DTLS configuration structure

Return values

0	if valid
-1	if invalid

Definition at line 3349 of file rtp_engine.c.

{
    if (dtls_cfg->ephemeral_cert) {
        if (!ast_strlen_zero(dtls_cfg->certfile)) {
            ast_log(LOG_ERROR, "You cannot request automatically generated certificates"
                " (dtls_auto_generate_cert) and also specify a certificate file"
                " (dtls_cert_file) at the same time\n");
            return -1;
        } else if (!ast_strlen_zero(dtls_cfg->pvtfile)
                  || !ast_strlen_zero(dtls_cfg->cafile)
                  || !ast_strlen_zero(dtls_cfg->capath)) {
            ast_log(LOG_NOTICE, "dtls_pvt_file, dtls_cafile, and dtls_ca_path are"
                " ignored when dtls_auto_generate_cert is enabled\n");
        }
    }
 
    return 0;
}

References ast_log, ast_strlen_zero(), ast_rtp_dtls_cfg::cafile, ast_rtp_dtls_cfg::capath, ast_rtp_dtls_cfg::certfile, ast_rtp_dtls_cfg::ephemeral_cert, LOG_ERROR, LOG_NOTICE, and ast_rtp_dtls_cfg::pvtfile.

Referenced by sip_endpoint_apply_handler().

ast_rtp_engine_alloc_payload_type()

struct ast_rtp_payload_type * ast_rtp_engine_alloc_payload_type

(

void

)

Allocation routine for ast_rtp_payload_type.

Return values

NULL

on error

Returns

An ao2 ref counted ast_rtp_payload_type on success.

Note

The ast_rtp_payload_type returned by this function is an ao2 ref counted object.

Definition at line 335 of file rtp_engine.c.

{
    return rtp_payload_type_alloc(NULL, 0, 0, 0, 0);
}

References NULL, and rtp_payload_type_alloc().

Referenced by ast_rtp_codecs_payload_replace_format(), ast_rtp_codecs_payloads_set_rtpmap_type_rate(), and payload_mapping_rx_clear_primary().

ast_rtp_engine_init()

int ast_rtp_engine_init

(

void

)

initializes the rtp engine arrays

Definition at line 3895 of file rtp_engine.c.

{
    ast_rwlock_init(&mime_types_lock);
    ast_rwlock_init(&static_RTP_PT_lock);
 
    rtp_topic = stasis_topic_create("rtp:all");
    if (!rtp_topic) {
        return -1;
    }
    STASIS_MESSAGE_TYPE_INIT(ast_rtp_rtcp_sent_type);
    STASIS_MESSAGE_TYPE_INIT(ast_rtp_rtcp_received_type);
    ast_register_cleanup(rtp_engine_shutdown);
 
    /* Define all the RTP mime types available */
    set_next_mime_type(ast_format_g723, 0, "audio", "G723", 8000);
    set_next_mime_type(ast_format_gsm, 0, "audio", "GSM", 8000);
    set_next_mime_type(ast_format_ulaw, 0, "audio", "PCMU", 8000);
    set_next_mime_type(ast_format_ulaw, 0, "audio", "G711U", 8000);
    set_next_mime_type(ast_format_alaw, 0, "audio", "PCMA", 8000);
    set_next_mime_type(ast_format_alaw, 0, "audio", "G711A", 8000);
    set_next_mime_type(ast_format_g726, 0, "audio", "G726-32", 8000);
    set_next_mime_type(ast_format_adpcm, 0, "audio", "DVI4", 8000);
    set_next_mime_type(ast_format_slin, 0, "audio", "L16", 8000);
    set_next_mime_type(ast_format_slin16, 0, "audio", "L16", 16000);
    set_next_mime_type(ast_format_slin16, 0, "audio", "L16-256", 16000);
    set_next_mime_type(ast_format_slin12, 0, "audio", "L16", 12000);
    set_next_mime_type(ast_format_slin24, 0, "audio", "L16", 24000);
    set_next_mime_type(ast_format_slin32, 0, "audio", "L16", 32000);
    set_next_mime_type(ast_format_slin44, 0, "audio", "L16", 44100);
    set_next_mime_type(ast_format_slin48, 0, "audio", "L16", 48000);
    set_next_mime_type(ast_format_slin96, 0, "audio", "L16", 96000);
    set_next_mime_type(ast_format_slin192, 0, "audio", "L16", 192000);
    set_next_mime_type(ast_format_lpc10, 0, "audio", "LPC", 8000);
    set_next_mime_type(ast_format_g729, 0, "audio", "G729", 8000);
    set_next_mime_type(ast_format_g729, 0, "audio", "G729A", 8000);
    set_next_mime_type(ast_format_g729, 0, "audio", "G.729", 8000);
    set_next_mime_type(ast_format_speex, 0, "audio", "speex", 8000);
    set_next_mime_type(ast_format_speex16, 0,  "audio", "speex", 16000);
    set_next_mime_type(ast_format_speex32, 0,  "audio", "speex", 32000);
    set_next_mime_type(ast_format_ilbc, 0, "audio", "iLBC", 8000);
    /* this is the sample rate listed in the RTP profile for the G.722 codec, *NOT* the actual sample rate of the media stream */
    set_next_mime_type(ast_format_g722, 0, "audio", "G722", 8000);
    set_next_mime_type(ast_format_g726_aal2, 0, "audio", "AAL2-G726-32", 8000);
    /* we need all possible dtmf/bitrate combinations or ast_rtp_codecs_payloads_set_rtpmap_type_rate will not examine it */
    set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 8000);
    set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 16000);
    set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 24000);
    set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 32000);
    set_next_mime_type(NULL, AST_RTP_DTMF, "audio", "telephone-event", 48000);
    set_next_mime_type(NULL, AST_RTP_CISCO_DTMF, "audio", "cisco-telephone-event", 8000);
    set_next_mime_type(NULL, AST_RTP_CN, "audio", "CN", 8000);
    set_next_mime_type(ast_format_jpeg, 0, "video", "JPEG", 90000);
    set_next_mime_type(ast_format_png, 0, "video", "PNG", 90000);
    set_next_mime_type(ast_format_h261, 0, "video", "H261", 90000);
    set_next_mime_type(ast_format_h263, 0, "video", "H263", 90000);
    set_next_mime_type(ast_format_h263p, 0, "video", "h263-1998", 90000);
    set_next_mime_type(ast_format_h264, 0, "video", "H264", 90000);
    set_next_mime_type(ast_format_h265, 0, "video", "H265", 90000);
    set_next_mime_type(ast_format_mp4, 0, "video", "MP4V-ES", 90000);
    set_next_mime_type(ast_format_t140_red, 0, "text", "RED", 1000);
    set_next_mime_type(ast_format_t140, 0, "text", "T140", 1000);
    set_next_mime_type(ast_format_siren7, 0, "audio", "G7221", 16000);
    set_next_mime_type(ast_format_siren14, 0, "audio", "G7221", 32000);
    set_next_mime_type(ast_format_g719, 0, "audio", "G719", 48000);
    /* Opus, VP8, and VP9 */
    set_next_mime_type(ast_format_opus, 0,  "audio", "opus", 48000);
    set_next_mime_type(ast_format_vp8, 0,  "video", "VP8", 90000);
    set_next_mime_type(ast_format_vp9, 0, "video", "VP9", 90000);
 
    /* Define the static rtp payload mappings */
    add_static_payload(0, ast_format_ulaw, 0);
    #ifdef USE_DEPRECATED_G726
    add_static_payload(2, ast_format_g726, 0);/* Technically this is G.721, but if Cisco can do it, so can we... */
    #endif
    add_static_payload(3, ast_format_gsm, 0);
    add_static_payload(4, ast_format_g723, 0);
    add_static_payload(5, ast_format_adpcm, 0);/* 8 kHz */
    add_static_payload(6, ast_format_adpcm, 0); /* 16 kHz */
    add_static_payload(7, ast_format_lpc10, 0);
    add_static_payload(8, ast_format_alaw, 0);
    add_static_payload(9, ast_format_g722, 0);
    add_static_payload(10, ast_format_slin, 0); /* 2 channels */
    add_static_payload(11, ast_format_slin, 0); /* 1 channel */
    add_static_payload(13, NULL, AST_RTP_CN);
    add_static_payload(16, ast_format_adpcm, 0); /* 11.025 kHz */
    add_static_payload(17, ast_format_adpcm, 0); /* 22.050 kHz */
    add_static_payload(18, ast_format_g729, 0);
    add_static_payload(19, NULL, AST_RTP_CN);         /* Also used for CN */
    add_static_payload(26, ast_format_jpeg, 0);
    add_static_payload(31, ast_format_h261, 0);
    add_static_payload(34, ast_format_h263, 0);
 
    /*
     * Dynamic payload types - Even when dynamically assigning them we'll fall
     * back to using the statically declared values as the default number.
     */
    add_static_payload(96, ast_format_slin192, 0);
    add_static_payload(97, ast_format_ilbc, 0);
 
    add_static_payload(99, ast_format_h264, 0);
    add_static_payload(100, ast_format_vp8, 0);
    add_static_payload(101, NULL, AST_RTP_DTMF);
    add_static_payload(102, ast_format_siren7, 0);
    add_static_payload(103, ast_format_h263p, 0);
    add_static_payload(104, ast_format_mp4, 0);
    add_static_payload(105, ast_format_t140_red, 0);   /* Real time text chat (with redundancy encoding) */
    add_static_payload(106, ast_format_t140, 0);     /* Real time text chat */
    add_static_payload(107, ast_format_opus, 0);
    add_static_payload(108, ast_format_vp9, 0);
    add_static_payload(109, ast_format_h265, 0);
 
    add_static_payload(110, ast_format_speex, 0);
    add_static_payload(111, ast_format_g726, 0);
    add_static_payload(112, ast_format_g726_aal2, 0);
 
    add_static_payload(115, ast_format_siren14, 0);
    add_static_payload(116, ast_format_g719, 0);
    add_static_payload(117, ast_format_speex16, 0);
    add_static_payload(118, ast_format_slin16, 0); /* 16 Khz signed linear */
    add_static_payload(119, ast_format_speex32, 0);
 
    add_static_payload(121, NULL, AST_RTP_CISCO_DTMF);   /* Must be type 121 */
    add_static_payload(122, ast_format_slin12, 0);
    add_static_payload(123, ast_format_slin24, 0);
    add_static_payload(124, ast_format_slin32, 0);
    add_static_payload(125, ast_format_slin44, 0);
    add_static_payload(126, ast_format_slin48, 0);
    add_static_payload(127, ast_format_slin96, 0);
    /* payload types above 127 are not valid */
 
    debug_category_rtp_id = ast_debug_category_register(AST_LOG_CATEGORY_RTP);
    debug_category_rtp_packet_id = ast_debug_category_register(AST_LOG_CATEGORY_RTP_PACKET);
    debug_category_rtcp_id = ast_debug_category_register(AST_LOG_CATEGORY_RTCP);
    debug_category_rtcp_packet_id = ast_debug_category_register(AST_LOG_CATEGORY_RTCP_PACKET);
    debug_category_dtls_id = ast_debug_category_register(AST_LOG_CATEGORY_DTLS);
    debug_category_dtls_packet_id = ast_debug_category_register(AST_LOG_CATEGORY_DTLS_PACKET);
    debug_category_ice_id = ast_debug_category_register(AST_LOG_CATEGORY_ICE);
 
    /*
     * Normnally a core module should call ast_register_cleanup,
     * which doesn't run if any module fails to unload.  This
     * prevents resources being pulled out from under a running
     * module and possibly causing a segfault.  In this case however,
     * the only thing we're cleaning up are the registrations of the
     * debug categories.
     */
    ast_register_atexit(rtp_engine_atexit);
 
    return 0;
}

References add_static_payload(), ast_debug_category_register(), ast_format_adpcm, ast_format_alaw, ast_format_g719, ast_format_g722, ast_format_g723, ast_format_g726, ast_format_g726_aal2, ast_format_g729, ast_format_gsm, ast_format_h261, ast_format_h263, ast_format_h263p, ast_format_h264, ast_format_h265, ast_format_ilbc, ast_format_jpeg, ast_format_lpc10, ast_format_mp4, ast_format_opus, ast_format_png, ast_format_siren14, ast_format_siren7, ast_format_slin, ast_format_slin12, ast_format_slin16, ast_format_slin192, ast_format_slin24, ast_format_slin32, ast_format_slin44, ast_format_slin48, ast_format_slin96, ast_format_speex, ast_format_speex16, ast_format_speex32, ast_format_t140, ast_format_t140_red, ast_format_ulaw, ast_format_vp8, ast_format_vp9, AST_LOG_CATEGORY_DTLS, AST_LOG_CATEGORY_DTLS_PACKET, AST_LOG_CATEGORY_ICE, AST_LOG_CATEGORY_RTCP, AST_LOG_CATEGORY_RTCP_PACKET, AST_LOG_CATEGORY_RTP, AST_LOG_CATEGORY_RTP_PACKET, ast_register_atexit(), ast_register_cleanup(), AST_RTP_CISCO_DTMF, AST_RTP_CN, AST_RTP_DTMF, ast_rtp_rtcp_received_type(), ast_rtp_rtcp_sent_type(), ast_rwlock_init, debug_category_dtls_id, debug_category_dtls_packet_id, debug_category_ice_id, debug_category_rtcp_id, debug_category_rtcp_packet_id, debug_category_rtp_id, debug_category_rtp_packet_id, mime_types_lock, NULL, rtp_engine_atexit(), rtp_engine_shutdown(), rtp_topic, set_next_mime_type(), STASIS_MESSAGE_TYPE_INIT, stasis_topic_create(), and static_RTP_PT_lock.

Referenced by asterisk_daemon().

ast_rtp_engine_load_format()

int ast_rtp_engine_load_format

(

struct ast_format *

format

)

Custom formats declared in codecs.conf at startup must be communicated to the rtp_engine so their mime type can payload number can be initialized.

Definition at line 3484 of file rtp_engine.c.

{
    char *codec_name = ast_strdupa(ast_format_get_codec_name(format));
 
    codec_name = ast_str_to_upper(codec_name);
 
    set_next_mime_type(format,
        0,
        ast_codec_media_type2str(ast_format_get_type(format)),
        codec_name,
        ast_format_get_sample_rate(format));
    add_static_payload(-1, format, 0);
 
    return 0;
}

References add_static_payload(), ast_codec_media_type2str(), ast_format_get_codec_name(), ast_format_get_sample_rate(), ast_format_get_type(), ast_str_to_upper(), ast_strdupa, ast_rtp_payload_type::format, and set_next_mime_type().

Referenced by load_module().

ast_rtp_engine_register2()

int ast_rtp_engine_register2	(	struct ast_rtp_engine *	engine,
		struct ast_module *	module
	)

Register an RTP engine.

Parameters

engine	Structure of the RTP engine to register
module	Module that the RTP engine is part of

Return values

0	success
-1	failure

Example usage:

ast_rtp_engine_register2(&example_rtp_engine, NULL);

This registers the RTP engine declared as example_rtp_engine with the RTP engine core, but does not associate a module with it.

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.8

Definition at line 340 of file rtp_engine.c.

{
    struct ast_rtp_engine *current_engine;
 
    /* Perform a sanity check on the engine structure to make sure it has the basics */
    if (ast_strlen_zero(engine->name) || !engine->new || !engine->destroy || !engine->write || !engine->read) {
        ast_log(LOG_WARNING, "RTP Engine '%s' failed sanity check so it was not registered.\n", !ast_strlen_zero(engine->name) ? engine->name : "Unknown");
        return -1;
    }
 
    /* Link owner module to the RTP engine for reference counting purposes */
    engine->mod = module;
 
    AST_RWLIST_WRLOCK(&engines);
 
    /* Ensure that no two modules with the same name are registered at the same time */
    AST_RWLIST_TRAVERSE(&engines, current_engine, entry) {
        if (!strcmp(current_engine->name, engine->name)) {
            ast_log(LOG_WARNING, "An RTP engine with the name '%s' has already been registered.\n", engine->name);
            AST_RWLIST_UNLOCK(&engines);
            return -1;
        }
    }
 
    /* The engine survived our critique. Off to the list it goes to be used */
    AST_RWLIST_INSERT_TAIL(&engines, engine, entry);
 
    AST_RWLIST_UNLOCK(&engines);
 
    ast_verb(5, "Registered RTP engine '%s'\n", engine->name);
 
    return 0;
}

References ast_log, AST_RWLIST_INSERT_TAIL, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero(), ast_verb, ast_rtp_engine::destroy, ast_rtp_engine::entry, LOG_WARNING, ast_rtp_engine::mod, ast_rtp_engine::name, ast_rtp_engine::new, ast_rtp_engine::read, and ast_rtp_engine::write.

ast_rtp_engine_register_srtp()

int ast_rtp_engine_register_srtp	(	struct ast_srtp_res *	srtp_res,
		struct ast_srtp_policy_res *	policy_res
	)

Definition at line 2965 of file rtp_engine.c.

{
    if (res_srtp || res_srtp_policy) {
        return -1;
    }
    if (!srtp_res || !policy_res) {
        return -1;
    }
 
    res_srtp = srtp_res;
    res_srtp_policy = policy_res;
 
    return 0;
}

References policy_res, res_srtp, res_srtp_policy, and srtp_res.

Referenced by res_srtp_init().

ast_rtp_engine_srtp_is_registered()

int ast_rtp_engine_srtp_is_registered

(

void

)

Definition at line 2986 of file rtp_engine.c.

{
    return res_srtp && res_srtp_policy;
}

References res_srtp, and res_srtp_policy.

Referenced by ast_sdp_srtp_alloc().

ast_rtp_engine_unload_format()

int ast_rtp_engine_unload_format

(

struct ast_format *

format

)

Formats requiring the use of a format attribute interface must have that interface registered in 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.

Definition at line 3500 of file rtp_engine.c.

{
    int x;
    int y = 0;
 
    ast_rwlock_wrlock(&static_RTP_PT_lock);
    /* remove everything pertaining to this format id from the lists */
    for (x = 0; x < AST_RTP_MAX_PT; x++) {
        if (static_RTP_PT[x]
            && ast_format_cmp(static_RTP_PT[x]->format, format) == AST_FORMAT_CMP_EQUAL) {
            ao2_ref(static_RTP_PT[x], -1);
            static_RTP_PT[x] = NULL;
        }
    }
    ast_rwlock_unlock(&static_RTP_PT_lock);
 
    ast_rwlock_wrlock(&mime_types_lock);
    /* rebuild the list skipping the items matching this id */
    for (x = 0; x < mime_types_len; x++) {
        if (ast_format_cmp(ast_rtp_mime_types[x].payload_type.format, format) == AST_FORMAT_CMP_EQUAL) {
            rtp_engine_mime_type_cleanup(x);
            continue;
        }
        if (x != y) {
            ast_rtp_mime_types[y] = ast_rtp_mime_types[x];
        }
        y++;
    }
    mime_types_len = y;
    ast_rwlock_unlock(&mime_types_lock);
    return 0;
}

References ao2_ref, ast_format_cmp(), AST_FORMAT_CMP_EQUAL, AST_RTP_MAX_PT, ast_rtp_mime_types, ast_rwlock_unlock, ast_rwlock_wrlock, ast_rtp_payload_type::format, mime_types_len, mime_types_lock, NULL, rtp_engine_mime_type_cleanup(), static_RTP_PT, and static_RTP_PT_lock.

Referenced by unload_module().

ast_rtp_engine_unregister()

int ast_rtp_engine_unregister

(

struct ast_rtp_engine *

engine

)

Unregister an RTP engine.

Parameters

engine

Structure of the RTP engine to unregister

Return values

0	success
-1	failure

Example usage:

ast_rtp_engine_unregister(&example_rtp_engine);

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.8

Definition at line 374 of file rtp_engine.c.

{
    struct ast_rtp_engine *current_engine = NULL;
 
    AST_RWLIST_WRLOCK(&engines);
 
    if ((current_engine = AST_RWLIST_REMOVE(&engines, engine, entry))) {
        ast_verb(5, "Unregistered RTP engine '%s'\n", engine->name);
    }
 
    AST_RWLIST_UNLOCK(&engines);
 
    return current_engine ? 0 : -1;
}

References AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, ast_rtp_engine::entry, ast_rtp_engine::name, and NULL.

Referenced by load_module(), unload_module(), and unload_module().

ast_rtp_engine_unregister_srtp()

void ast_rtp_engine_unregister_srtp

(

void

)

Definition at line 2980 of file rtp_engine.c.

{
    res_srtp = NULL;
    res_srtp_policy = NULL;
}

References NULL, res_srtp, and res_srtp_policy.

Referenced by res_srtp_shutdown().

ast_rtp_get_rate()

int ast_rtp_get_rate

(

const struct ast_format *

format

)

Retrieve the sample rate of a format according to RTP specifications.

Since

16.7.0

17.1.0

Parameters

format

The media format

Returns

The sample rate

Definition at line 4331 of file rtp_engine.c.

{
    /* For those wondering: due to a fluke in RFC publication, G.722 is advertised
     * as having a sample rate of 8kHz, while implementations must know that its
     * real rate is 16kHz. Seriously.
     */
        return (ast_format_cmp(format, ast_format_g722) == AST_FORMAT_CMP_EQUAL) ? 8000 : (int)ast_format_get_sample_rate(format);
}

References ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_g722, and ast_format_get_sample_rate().

Referenced by ast_rtcp_calculate_sr_rr_statistics(), ast_rtcp_interpret(), ast_rtp_dtmf_begin(), ast_rtp_dtmf_end_with_duration(), ast_rtp_interpret(), calc_rxstamp_and_jitter(), jitterbuffer_frame_get_ntp_timestamp(), process_dtmf_cisco(), process_dtmf_rfc2833(), rtp_raw_write(), and update_jitter_stats().

ast_rtp_glue_register2()

int ast_rtp_glue_register2	(	struct ast_rtp_glue *	glue,
		struct ast_module *	module
	)

Register RTP glue.

Parameters

glue	The glue to register
module	Module that the RTP glue is part of

Return values

0	success
-1	failure

Example usage:

ast_rtp_glue_register2(&example_rtp_glue, NULL);

This registers the RTP glue declared as example_rtp_glue with the RTP engine core, but does not associate a module with it.

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.8

Definition at line 389 of file rtp_engine.c.

{
    struct ast_rtp_glue *current_glue = NULL;
 
    if (ast_strlen_zero(glue->type)) {
        return -1;
    }
 
    glue->mod = module;
 
    AST_RWLIST_WRLOCK(&glues);
 
    AST_RWLIST_TRAVERSE(&glues, current_glue, entry) {
        if (!strcasecmp(current_glue->type, glue->type)) {
            ast_log(LOG_WARNING, "RTP glue with the name '%s' has already been registered.\n", glue->type);
            AST_RWLIST_UNLOCK(&glues);
            return -1;
        }
    }
 
    AST_RWLIST_INSERT_TAIL(&glues, glue, entry);
 
    AST_RWLIST_UNLOCK(&glues);
 
    ast_verb(5, "Registered RTP glue '%s'\n", glue->type);
 
    return 0;
}

References ast_log, AST_RWLIST_INSERT_TAIL, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero(), ast_verb, ast_rtp_glue::entry, LOG_WARNING, ast_rtp_glue::mod, NULL, and ast_rtp_glue::type.

ast_rtp_glue_unregister()

int ast_rtp_glue_unregister

(

struct ast_rtp_glue *

glue

)

Unregister RTP glue.

Parameters

glue	The glue to unregister

Return values

0	success
-1	failure

Example usage:

ast_rtp_glue_unregister(&example_rtp_glue);

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.8

Definition at line 418 of file rtp_engine.c.

{
    struct ast_rtp_glue *current_glue = NULL;
 
    AST_RWLIST_WRLOCK(&glues);
 
    if ((current_glue = AST_RWLIST_REMOVE(&glues, glue, entry))) {
        ast_verb(5, "Unregistered RTP glue '%s'\n", glue->type);
    }
 
    AST_RWLIST_UNLOCK(&glues);
 
    return current_glue ? 0 : -1;
}

References AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, ast_rtp_glue::entry, NULL, and ast_rtp_glue::type.

Referenced by load_module(), load_module(), unload_module(), unload_module(), unload_module(), unload_module(), and unload_module().

ast_rtp_instance_activate()

int ast_rtp_instance_activate

(

struct ast_rtp_instance *

instance

)

Indicate to the RTP engine that packets are now expected to be sent/received on the RTP instance.

Parameters

instance

The RTP instance

Return values

0	success
-1	failure

Example usage:

ast_rtp_instance_activate(instance);

This tells the underlying RTP engine of instance that packets will now flow.

Since

1.8

Definition at line 2892 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->activate) {
        ao2_lock(instance);
        res = instance->engine->activate(instance);
        ao2_unlock(instance);
    } else {
        res = 0;
    }
    return res;
}

References ast_rtp_engine::activate, ao2_lock, ao2_unlock, and ast_rtp_instance::engine.

Referenced by apply_negotiated_sdp_stream(), rtp_call(), and test_init_rtp_instances().

ast_rtp_instance_add_srtp_policy()

int ast_rtp_instance_add_srtp_policy	(	struct ast_rtp_instance *	instance,
		struct ast_srtp_policy *	remote_policy,
		struct ast_srtp_policy *	local_policy,
		int	rtcp
	)

Add or replace the SRTP policies for the given RTP instance.

Parameters

instance	the RTP instance
remote_policy	the remote endpoint's policy
local_policy	our policy for this RTP instance's remote endpoint
rtcp	1 for dedicated RTCP policies

Return values

0	Success
non-zero	Failure

Note

If no remote policy is provided any existing SRTP policies are left and the new local policy is added

Definition at line 2991 of file rtp_engine.c.

{
    int res = 0;
    struct ast_srtp **srtp;
 
    if (!res_srtp) {
        return -1;
    }
 
    ao2_lock(instance);
 
    srtp = rtcp ? &instance->rtcp_srtp : &instance->srtp;
 
    if (!*srtp) {
        res = res_srtp->create(srtp, instance, remote_policy);
    } else if (remote_policy) {
        res = res_srtp->replace(srtp, instance, remote_policy);
    }
    if (!res) {
        res = res_srtp->add_stream(*srtp, local_policy);
    }
 
    ao2_unlock(instance);
 
    return res;
}

References ast_srtp_res::add_stream, ao2_lock, ao2_unlock, ast_srtp_res::create, ast_srtp_res::replace, res_srtp, ast_rtp_instance::rtcp_srtp, and ast_rtp_instance::srtp.

Referenced by crypto_activate().

ast_rtp_instance_available_formats()

void ast_rtp_instance_available_formats	(	struct ast_rtp_instance *	instance,
		struct ast_format_cap *	to_endpoint,
		struct ast_format_cap *	to_asterisk,
		struct ast_format_cap *	result
	)

Request the formats that can be transcoded.

Parameters

instance	The RTP instance
to_endpoint	Formats being sent/received towards the endpoint
to_asterisk	Formats being sent/received towards Asterisk
result	capabilities structure to store and return supported formats in.

Example usage:

ast_rtp_instance_available_formats(instance, to_capabilities, from_capabilities, result_capabilities);

This sees if it is possible to have ulaw communicated to the endpoint but signed linear received into Asterisk.

Since

1.8

Definition at line 2878 of file rtp_engine.c.

{
    if (instance->engine->available_formats) {
        ao2_lock(instance);
        instance->engine->available_formats(instance, to_endpoint, to_asterisk, result);
        ao2_unlock(instance);
        if (ast_format_cap_count(result)) {
            return;
        }
    }
 
    ast_translate_available_formats(to_endpoint, to_asterisk, result);
}

References ao2_lock, ao2_unlock, ast_format_cap_count(), ast_translate_available_formats(), ast_rtp_engine::available_formats, ast_rtp_instance::engine, and result.

ast_rtp_instance_bundle()

int ast_rtp_instance_bundle	(	struct ast_rtp_instance *	child,
		struct ast_rtp_instance *	parent
	)

Request that an RTP instance be bundled with another.

Since

15.0.0

Parameters

child	The child RTP instance
parent	The parent RTP instance the child should be bundled with

Return values

0	success
-1	failure

Definition at line 4092 of file rtp_engine.c.

{
    int res = -1;
 
    if (parent && (child->engine != parent->engine)) {
        return -1;
    }
 
    ao2_lock(child);
    if (child->engine->bundle) {
        res = child->engine->bundle(child, parent);
    }
    ao2_unlock(child);
 
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_engine::bundle, and ast_rtp_instance::engine.

Referenced by apply_negotiated_sdp_stream(), and negotiate_incoming_sdp_stream().

ast_rtp_instance_change_source()

void ast_rtp_instance_change_source

(

struct ast_rtp_instance *

instance

)

Indicate a new source of audio has dropped in and the ssrc should change.

Parameters

instance

Instance that the new media source is feeding into

Example usage:

ast_rtp_instance_change_source(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.8

Definition at line 2375 of file rtp_engine.c.

{
    if (instance->engine->change_source) {
        ao2_lock(instance);
        instance->engine->change_source(instance);
        ao2_unlock(instance);
    }
}

References ao2_lock, ao2_unlock, ast_rtp_engine::change_source, and ast_rtp_instance::engine.

Referenced by chan_pjsip_indicate(), create_outgoing_sdp_stream(), jingle_indicate(), ooh323_indicate(), and unistim_indicate().

ast_rtp_instance_destroy()

int ast_rtp_instance_destroy

(

struct ast_rtp_instance *

instance

)

Destroy an RTP instance.

Parameters

instance

The RTP instance to destroy

Return values

0	success
-1	failure

Example usage:

ast_rtp_instance_destroy(instance);

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.8

Definition at line 468 of file rtp_engine.c.

{
    if (!instance) {
        return 0;
    }
    if (ast_debug_rtp_is_allowed) {
        char buffer[4][512];
        ast_debug_rtp(1, "%s:\n"
            "  RTT:    %s\n"
            "  Loss:   %s\n"
            "  Jitter: %s\n"
            "  MES:    %s\n",
            instance->channel_uniqueid,
            ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT,
                buffer[0], sizeof(buffer[0])),
            ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS,
                buffer[1], sizeof(buffer[1])),
            ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER,
                buffer[2], sizeof(buffer[2])),
            ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES,
                buffer[3], sizeof(buffer[3]))
        );
    }
 
    ao2_cleanup(instance);
 
    return 0;
}

References ao2_cleanup, ast_debug_rtp, ast_debug_rtp_is_allowed, ast_rtp_instance_get_quality(), AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT, and ast_rtp_instance::channel_uniqueid.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), jingle_session_destructor(), multicast_rtp_request(), ooh323_destroy(), rtp_hangup(), stream_destroy(), unicast_rtp_request(), and unistim_hangup_clean().

ast_rtp_instance_dtmf_begin()

int ast_rtp_instance_dtmf_begin	(	struct ast_rtp_instance *	instance,
		char	digit
	)

Begin sending a DTMF digit.

Parameters

instance	The RTP instance to send the DTMF on
digit	What DTMF digit to send

Return values

0	success
-1	failure

Example usage:

ast_rtp_instance_dtmf_begin(instance, '1');

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.8

Definition at line 2296 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->dtmf_begin) {
        ao2_lock(instance);
        res = instance->engine->dtmf_begin(instance, digit);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, digit, ast_rtp_engine::dtmf_begin, and ast_rtp_instance::engine.

Referenced by chan_pjsip_digit_begin(), jingle_digit_begin(), and ooh323_digit_begin().

ast_rtp_instance_dtmf_end()

int ast_rtp_instance_dtmf_end	(	struct ast_rtp_instance *	instance,
		char	digit
	)

Stop sending a DTMF digit.

Parameters

instance	The RTP instance to stop the DTMF on
digit	What DTMF digit to stop

Return values

0	success
-1	failure

Example usage:

ast_rtp_instance_dtmf_end(instance, '1');

This stops sending the DTMF '1' on the RTP instance pointed to by instance.

Since

1.8

Definition at line 2310 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->dtmf_end) {
        ao2_lock(instance);
        res = instance->engine->dtmf_end(instance, digit);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, digit, ast_rtp_engine::dtmf_end, and ast_rtp_instance::engine.

Referenced by ooh323_digit_end().

ast_rtp_instance_dtmf_end_with_duration()

int ast_rtp_instance_dtmf_end_with_duration	(	struct ast_rtp_instance *	instance,
		char	digit,
		unsigned int	duration
	)

Definition at line 2324 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->dtmf_end_with_duration) {
        ao2_lock(instance);
        res = instance->engine->dtmf_end_with_duration(instance, digit, duration);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, digit, ast_rtp_engine::dtmf_end_with_duration, and ast_rtp_instance::engine.

Referenced by chan_pjsip_digit_end(), and jingle_digit_end().

ast_rtp_instance_dtmf_mode_get()

enum ast_rtp_dtmf_mode ast_rtp_instance_dtmf_mode_get

(

struct ast_rtp_instance *

instance

)

Get the DTMF mode of an RTP instance.

Parameters

instance

The RTP instance to get the DTMF mode of

Returns

DTMF mode

Example usage:

enum ast_rtp_dtmf_mode dtmf_mode = ast_rtp_instance_dtmf_mode_get(instance);

This gets the DTMF mode set on the RTP instance pointed to by 'instance'.

Since

1.8

Definition at line 2352 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->dtmf_mode_get) {
        ao2_lock(instance);
        res = instance->engine->dtmf_mode_get(instance);
        ao2_unlock(instance);
    } else {
        res = 0;
    }
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtmf_mode_get, and ast_rtp_instance::engine.

Referenced by chan_pjsip_digit_begin(), chan_pjsip_digit_end(), native_rtp_bridge_compatible_check(), pjsip_acf_dtmf_mode_write(), and set_caps().

ast_rtp_instance_dtmf_mode_set()

int ast_rtp_instance_dtmf_mode_set	(	struct ast_rtp_instance *	instance,
		enum ast_rtp_dtmf_mode	dtmf_mode
	)

Set the DTMF mode that should be used.

Parameters

instance	the RTP instance to set DTMF mode on
dtmf_mode	The DTMF mode that is in use

Return values

0	success
-1	failure

Example usage:

ast_rtp_instance_dtmf_mode_set(instance, AST_RTP_DTMF_MODE_RFC2833);

This sets the RTP instance to use RFC2833 for DTMF transmission and receiving.

Since

1.8

Definition at line 2338 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->dtmf_mode_set) {
        ao2_lock(instance);
        res = instance->engine->dtmf_mode_set(instance, dtmf_mode);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtmf_mode_set, and ast_rtp_instance::engine.

Referenced by create_rtp(), get_codecs(), and pjsip_acf_dtmf_mode_write().

ast_rtp_instance_early_bridge()

int ast_rtp_instance_early_bridge	(	struct ast_channel *	c0,
		struct ast_channel *	c1
	)

Early bridge two channels that use RTP instances.

Parameters

c0	First channel part of the bridge
c1	Second channel part of the bridge

Return values

0	success
-1	failure

Note

This should only be used by channel drivers in their technology declaration.

Since

1.8

Definition at line 2552 of file rtp_engine.c.

{
    struct ast_rtp_instance *instance0 = NULL, *instance1 = NULL,
            *vinstance0 = NULL, *vinstance1 = NULL,
            *tinstance0 = NULL, *tinstance1 = NULL;
    struct ast_rtp_glue *glue0, *glue1;
    enum ast_rtp_glue_result audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID, video_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
    enum ast_rtp_glue_result audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID, video_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
    struct ast_format_cap *cap0 = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    struct ast_format_cap *cap1 = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
 
    /* If there is no second channel just immediately bail out, we are of no use in that scenario */
    if (!c1 || !cap1 || !cap0) {
        ao2_cleanup(cap0);
        ao2_cleanup(cap1);
        return -1;
    }
 
    /* Lock both channels so we can look for the glue that binds them together */
    ast_channel_lock_both(c0, c1);
 
    /* Grab glue that binds each channel to something using the RTP engine */
    if (!(glue0 = ast_rtp_instance_get_glue(ast_channel_tech(c0)->type)) || !(glue1 = ast_rtp_instance_get_glue(ast_channel_tech(c1)->type))) {
        ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", glue0 ? ast_channel_name(c1) : ast_channel_name(c0));
        goto done;
    }
 
    audio_glue0_res = glue0->get_rtp_info(c0, &instance0);
    video_glue0_res = glue0->get_vrtp_info ? glue0->get_vrtp_info(c0, &vinstance0) : AST_RTP_GLUE_RESULT_FORBID;
 
    audio_glue1_res = glue1->get_rtp_info(c1, &instance1);
    video_glue1_res = glue1->get_vrtp_info ? glue1->get_vrtp_info(c1, &vinstance1) : AST_RTP_GLUE_RESULT_FORBID;
 
    /* If we are carrying video, and both sides are not going to remotely bridge... fail the native bridge */
    if (video_glue0_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue0_res != AST_RTP_GLUE_RESULT_REMOTE)) {
        audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
    }
    if (video_glue1_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue1_res != AST_RTP_GLUE_RESULT_REMOTE)) {
        audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
    }
    if (audio_glue0_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue0_res == AST_RTP_GLUE_RESULT_FORBID || video_glue0_res == AST_RTP_GLUE_RESULT_REMOTE) && glue0->get_codec) {
        glue0->get_codec(c0, cap0);
    }
    if (audio_glue1_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue1_res == AST_RTP_GLUE_RESULT_FORBID || video_glue1_res == AST_RTP_GLUE_RESULT_REMOTE) && glue1->get_codec) {
        glue1->get_codec(c1, cap1);
    }
 
    /* If any sort of bridge is forbidden just completely bail out and go back to generic bridging */
    if (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE) {
        goto done;
    }
 
    /* Make sure we have matching codecs */
    if (!ast_format_cap_iscompatible(cap0, cap1)) {
        goto done;
    }
 
    /* Bridge media early */
    if (glue0->update_peer(c0, instance1, vinstance1, tinstance1, cap1, 0)) {
        ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", ast_channel_name(c0), c1 ? ast_channel_name(c1) : "<unspecified>");
    }
 
done:
    ast_channel_unlock(c0);
    ast_channel_unlock(c1);
 
    ao2_cleanup(cap0);
    ao2_cleanup(cap1);
 
    unref_instance_cond(&instance0);
    unref_instance_cond(&instance1);
    unref_instance_cond(&vinstance0);
    unref_instance_cond(&vinstance1);
    unref_instance_cond(&tinstance0);
    unref_instance_cond(&tinstance1);
 
    ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", ast_channel_name(c0), c1 ? ast_channel_name(c1) : "<unspecified>");
 
    return 0;
}

References ao2_cleanup, ast_channel_lock_both, ast_channel_name(), ast_channel_unlock, ast_debug, ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_iscompatible(), ast_log, AST_RTP_GLUE_RESULT_FORBID, AST_RTP_GLUE_RESULT_REMOTE, ast_rtp_instance_get_glue(), done, ast_rtp_glue::get_codec, ast_rtp_glue::get_rtp_info, ast_rtp_glue::get_vrtp_info, LOG_WARNING, NULL, type, unref_instance_cond(), and ast_rtp_glue::update_peer.

ast_rtp_instance_early_bridge_make_compatible()

void ast_rtp_instance_early_bridge_make_compatible	(	struct ast_channel *	c_dst,
		struct ast_channel *	c_src
	)

Make two channels compatible for early bridging.

Parameters

c_dst	Destination channel to copy to
c_src	Source channel to copy from

Since

1.8

Definition at line 2466 of file rtp_engine.c.

{
    struct ast_rtp_instance *instance_dst = NULL, *instance_src = NULL,
        *vinstance_dst = NULL, *vinstance_src = NULL,
        *tinstance_dst = NULL, *tinstance_src = NULL;
    struct ast_rtp_glue *glue_dst, *glue_src;
    enum ast_rtp_glue_result audio_glue_dst_res = AST_RTP_GLUE_RESULT_FORBID, video_glue_dst_res = AST_RTP_GLUE_RESULT_FORBID;
    enum ast_rtp_glue_result audio_glue_src_res = AST_RTP_GLUE_RESULT_FORBID, video_glue_src_res = AST_RTP_GLUE_RESULT_FORBID;
    struct ast_format_cap *cap_dst = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    struct ast_format_cap *cap_src = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
 
    /* Lock both channels so we can look for the glue that binds them together */
    ast_channel_lock_both(c_dst, c_src);
 
    if (!cap_src || !cap_dst) {
        goto done;
    }
 
    /* Grab glue that binds each channel to something using the RTP engine */
    if (!(glue_dst = ast_rtp_instance_get_glue(ast_channel_tech(c_dst)->type)) || !(glue_src = ast_rtp_instance_get_glue(ast_channel_tech(c_src)->type))) {
        ast_debug(1, "Can't find native functions for channel '%s'\n", glue_dst ? ast_channel_name(c_src) : ast_channel_name(c_dst));
        goto done;
    }
 
    audio_glue_dst_res = glue_dst->get_rtp_info(c_dst, &instance_dst);
    video_glue_dst_res = glue_dst->get_vrtp_info ? glue_dst->get_vrtp_info(c_dst, &vinstance_dst) : AST_RTP_GLUE_RESULT_FORBID;
 
    audio_glue_src_res = glue_src->get_rtp_info(c_src, &instance_src);
    video_glue_src_res = glue_src->get_vrtp_info ? glue_src->get_vrtp_info(c_src, &vinstance_src) : AST_RTP_GLUE_RESULT_FORBID;
 
    /* If we are carrying video, and both sides are not going to remotely bridge... fail the native bridge */
    if (video_glue_dst_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue_dst_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue_dst_res != AST_RTP_GLUE_RESULT_REMOTE)) {
        audio_glue_dst_res = AST_RTP_GLUE_RESULT_FORBID;
    }
    if (video_glue_src_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue_src_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue_src_res != AST_RTP_GLUE_RESULT_REMOTE)) {
        audio_glue_src_res = AST_RTP_GLUE_RESULT_FORBID;
    }
    if (audio_glue_dst_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue_dst_res == AST_RTP_GLUE_RESULT_FORBID || video_glue_dst_res == AST_RTP_GLUE_RESULT_REMOTE) && glue_dst->get_codec) {
        glue_dst->get_codec(c_dst, cap_dst);
    }
    if (audio_glue_src_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue_src_res == AST_RTP_GLUE_RESULT_FORBID || video_glue_src_res == AST_RTP_GLUE_RESULT_REMOTE) && glue_src->get_codec) {
        glue_src->get_codec(c_src, cap_src);
    }
 
    /* If any sort of bridge is forbidden just completely bail out and go back to generic bridging */
    if (audio_glue_dst_res != AST_RTP_GLUE_RESULT_REMOTE || audio_glue_src_res != AST_RTP_GLUE_RESULT_REMOTE) {
        goto done;
    }
 
    /* Make sure we have matching codecs */
    if (!ast_format_cap_iscompatible(cap_dst, cap_src)) {
        goto done;
    }
 
    ast_rtp_codecs_payloads_xover(&instance_src->codecs, &instance_dst->codecs, instance_dst);
 
    if (vinstance_dst && vinstance_src) {
        ast_rtp_codecs_payloads_xover(&vinstance_src->codecs, &vinstance_dst->codecs, vinstance_dst);
    }
    if (tinstance_dst && tinstance_src) {
        ast_rtp_codecs_payloads_xover(&tinstance_src->codecs, &tinstance_dst->codecs, tinstance_dst);
    }
 
    if (glue_dst->update_peer(c_dst, instance_src, vinstance_src, tinstance_src, cap_src, 0)) {
        ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n",
            ast_channel_name(c_dst), ast_channel_name(c_src));
    } else {
        ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n",
            ast_channel_name(c_dst), ast_channel_name(c_src));
    }
 
done:
    ast_channel_unlock(c_dst);
    ast_channel_unlock(c_src);
 
    ao2_cleanup(cap_dst);
    ao2_cleanup(cap_src);
 
    unref_instance_cond(&instance_dst);
    unref_instance_cond(&instance_src);
    unref_instance_cond(&vinstance_dst);
    unref_instance_cond(&vinstance_src);
    unref_instance_cond(&tinstance_dst);
    unref_instance_cond(&tinstance_src);
}

References ao2_cleanup, ast_channel_lock_both, ast_channel_name(), ast_channel_unlock, ast_debug, ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_iscompatible(), ast_log, ast_rtp_codecs_payloads_xover(), AST_RTP_GLUE_RESULT_FORBID, AST_RTP_GLUE_RESULT_REMOTE, ast_rtp_instance_get_glue(), ast_rtp_instance::codecs, done, ast_rtp_glue::get_codec, ast_rtp_glue::get_rtp_info, ast_rtp_glue::get_vrtp_info, LOG_WARNING, NULL, type, unref_instance_cond(), and ast_rtp_glue::update_peer.

Referenced by dial_exec_full(), and do_forward().

ast_rtp_instance_extmap_clear()

void ast_rtp_instance_extmap_clear

(

struct ast_rtp_instance *

instance

)

Clear negotiated RTP extension information.

Parameters

instance

The RTP instance to clear negotiated extension information on

Definition at line 913 of file rtp_engine.c.

{
    static const struct rtp_extmap extmap_none = {
        .extension = AST_RTP_EXTENSION_UNSUPPORTED,
        .direction = AST_RTP_EXTENSION_DIRECTION_NONE,
    };
    int idx;
 
    ao2_lock(instance);
 
    /* Clear both the known unique ids and the negotiated extensions as we are about to have
     * new results set on us.
     */
    for (idx = 0; idx < AST_VECTOR_SIZE(&instance->extmap_unique_ids); ++idx) {
        AST_VECTOR_REPLACE(&instance->extmap_unique_ids, idx, extmap_none);
    }
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&instance->extmap_negotiated); ++idx) {
        AST_VECTOR_REPLACE(&instance->extmap_negotiated, idx, -1);
    }
 
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, AST_RTP_EXTENSION_DIRECTION_NONE, AST_RTP_EXTENSION_UNSUPPORTED, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, rtp_extmap::extension, ast_rtp_instance::extmap_negotiated, and ast_rtp_instance::extmap_unique_ids.

Referenced by process_extmap_attributes().

ast_rtp_instance_extmap_count()

size_t ast_rtp_instance_extmap_count

(

struct ast_rtp_instance *

instance

)

Get the number of known unique identifiers.

Parameters

instance

The RTP instance to retrieve the count from

Returns

the number of known unique identifiers

Since

15.5.0

Definition at line 950 of file rtp_engine.c.

{
    size_t count;
 
    ao2_lock(instance);
    count = AST_VECTOR_SIZE(&instance->extmap_unique_ids);
    ao2_unlock(instance);
 
    return count;
}

References ao2_lock, ao2_unlock, AST_VECTOR_SIZE, and ast_rtp_instance::extmap_unique_ids.

Referenced by add_extmap_to_stream(), and enable_rtp_extension().

ast_rtp_instance_extmap_enable()

int ast_rtp_instance_extmap_enable	(	struct ast_rtp_instance *	instance,
		int	id,
		enum ast_rtp_extension	extension,
		enum ast_rtp_extension_direction	direction
	)

Enable support for an RTP extension on an instance.

Parameters

instance	The RTP instance to enable the extension on
id	The unique local identifier to use for this extension (-1 to have one auto selected)
extension	The RTP extension
direction	The initial direction that the RTP extension should be used in

Return values

0	success
-1	failure

Since

15.5.0

Definition at line 783 of file rtp_engine.c.

{
    struct rtp_extmap extmap = {
        .extension = extension,
        .direction = direction,
    };
 
    ao2_lock(instance);
 
    if (!instance->engine->extension_enable || !instance->engine->extension_enable(instance, extension)) {
        ao2_unlock(instance);
        return 0;
    }
 
    /* We store enabled extensions separately so we can easily do negotiation */
    if (AST_VECTOR_REPLACE(&instance->extmap_enabled, extension, direction)) {
        ao2_unlock(instance);
        return -1;
    }
 
    if (id <= 0) {
        /* We find a free unique identifier for this extension by just appending it to the
         * vector of unique ids. The size of the vector will become its unique identifier.
         * As well when we are asking for information on the extensions it will be returned,
         * allowing it to be added to the SDP offer.
         */
        if (AST_VECTOR_APPEND(&instance->extmap_unique_ids, extmap)) {
            AST_VECTOR_REPLACE(&instance->extmap_enabled, extension, AST_RTP_EXTENSION_DIRECTION_NONE);
            ao2_unlock(instance);
            return -1;
        }
        id = AST_VECTOR_SIZE(&instance->extmap_unique_ids);
    } else {
        /* Otherwise we put it precisely where they want it */
        if (AST_VECTOR_REPLACE(&instance->extmap_unique_ids, id - 1, extmap)) {
            AST_VECTOR_REPLACE(&instance->extmap_enabled, extension, AST_RTP_EXTENSION_DIRECTION_NONE);
            ao2_unlock(instance);
            return -1;
        }
    }
 
    /* Now that we have an id add the extension to here */
    if (AST_VECTOR_REPLACE(&instance->extmap_negotiated, extension, id)) {
        extmap.extension = AST_RTP_EXTENSION_UNSUPPORTED;
        extmap.direction = AST_RTP_EXTENSION_DIRECTION_NONE;
        AST_VECTOR_REPLACE(&instance->extmap_enabled, extension, AST_RTP_EXTENSION_DIRECTION_NONE);
        AST_VECTOR_REPLACE(&instance->extmap_unique_ids, id - 1, extmap);
        ao2_unlock(instance);
        return -1;
    }
 
    ao2_unlock(instance);
 
    return 0;
}

References ao2_lock, ao2_unlock, AST_RTP_EXTENSION_DIRECTION_NONE, AST_RTP_EXTENSION_UNSUPPORTED, AST_VECTOR_APPEND, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, rtp_extmap::direction, ast_rtp_instance::engine, rtp_extmap::extension, ast_rtp_engine::extension_enable, ast_rtp_instance::extmap_enabled, ast_rtp_instance::extmap_negotiated, and ast_rtp_instance::extmap_unique_ids.

Referenced by enable_rtp_extension().

ast_rtp_instance_extmap_get_direction()

enum ast_rtp_extension_direction ast_rtp_instance_extmap_get_direction	(	struct ast_rtp_instance *	instance,
		int	id
	)

Retrieve the negotiated direction for an RTP extension id.

Parameters

instance	The RTP instance to retrieve the direction from
id	The negotiated RTP extension id

Returns

direction the direction that has been negotiated

Since

15.5.0

Definition at line 981 of file rtp_engine.c.

{
    enum ast_rtp_extension_direction direction = AST_RTP_EXTENSION_DIRECTION_NONE;
 
    ao2_lock(instance);
 
    if (0 < id && id <= AST_VECTOR_SIZE(&instance->extmap_unique_ids)) {
        struct rtp_extmap *extmap = AST_VECTOR_GET_ADDR(&instance->extmap_unique_ids, id - 1);
 
        direction = extmap->direction;
    }
    ao2_unlock(instance);
 
    return direction;
}

References ao2_lock, ao2_unlock, AST_RTP_EXTENSION_DIRECTION_NONE, AST_VECTOR_GET_ADDR, AST_VECTOR_SIZE, rtp_extmap::direction, and ast_rtp_instance::extmap_unique_ids.

Referenced by add_extmap_to_stream().

ast_rtp_instance_extmap_get_extension()

enum ast_rtp_extension ast_rtp_instance_extmap_get_extension	(	struct ast_rtp_instance *	instance,
		int	id
	)

Retrieve the extension for an RTP extension id.

Parameters

instance	The RTP instance to retrieve the extension from
id	The negotiated RTP extension id

Returns

extension the extension that maps to the id

Since

15.5.0

Note

This will return AST_RTP_EXTENSION_UNSUPPORTED if an extension was proposed for this unique identifier but it is not supported or if the unique identifier is unused.

Definition at line 961 of file rtp_engine.c.

{
    enum ast_rtp_extension extension = AST_RTP_EXTENSION_UNSUPPORTED;
 
    ao2_lock(instance);
 
    /* The local unique identifier starts at '1' so the highest unique identifier
     * can be the actual size of the vector. We compensate (as it is 0 index based)
     * by dropping it down to 1 to get the correct information.
     */
    if (0 < id && id <= AST_VECTOR_SIZE(&instance->extmap_unique_ids)) {
        struct rtp_extmap *extmap = AST_VECTOR_GET_ADDR(&instance->extmap_unique_ids, id - 1);
 
        extension = extmap->extension;
    }
    ao2_unlock(instance);
 
    return extension;
}

References ao2_lock, ao2_unlock, AST_RTP_EXTENSION_UNSUPPORTED, AST_VECTOR_GET_ADDR, AST_VECTOR_SIZE, rtp_extmap::extension, and ast_rtp_instance::extmap_unique_ids.

Referenced by add_extmap_to_stream(), and ast_rtp_instance_extmap_get_uri().

ast_rtp_instance_extmap_get_id()

int ast_rtp_instance_extmap_get_id	(	struct ast_rtp_instance *	instance,
		enum ast_rtp_extension	extension
	)

Retrieve the id for an RTP extension.

Parameters

instance	The RTP instance to retrieve the id from
extension	The RTP extension

Return values

-1	not negotiated
id	if negotiated

Since

15.5.0

Definition at line 937 of file rtp_engine.c.

{
    int id = -1;
 
    ao2_lock(instance);
    if (extension < AST_VECTOR_SIZE(&instance->extmap_negotiated)) {
        id = AST_VECTOR_GET(&instance->extmap_negotiated, extension);
    }
    ao2_unlock(instance);
 
    return id;
}

References ao2_lock, ao2_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_rtp_instance::extmap_negotiated, and id.

Referenced by ast_rtp_rtcp_handle_nack(), enable_rtp_extension(), rtp_instance_parse_extmap_extensions(), and rtp_raw_write().

ast_rtp_instance_extmap_get_uri()

const char * ast_rtp_instance_extmap_get_uri	(	struct ast_rtp_instance *	instance,
		int	id
	)

Retrieve the URI for an RTP extension id.

Parameters

instance	The RTP instance to retrieve the direction from
id	The negotiated RTP extension id

Returns

The URI for the RTP extension

Since

15.5.0

Definition at line 997 of file rtp_engine.c.

{
    enum ast_rtp_extension extension = ast_rtp_instance_extmap_get_extension(instance, id);
 
    if (extension == AST_RTP_EXTENSION_UNSUPPORTED ||
        (unsigned int)extension >= ARRAY_LEN(rtp_extension_uris)) {
        return NULL;
    }
 
    return rtp_extension_uris[extension];
}

References ARRAY_LEN, AST_RTP_EXTENSION_UNSUPPORTED, ast_rtp_instance_extmap_get_extension(), rtp_extmap::extension, NULL, and rtp_extension_uris.

Referenced by add_extmap_to_stream().

ast_rtp_instance_extmap_negotiate()

int ast_rtp_instance_extmap_negotiate	(	struct ast_rtp_instance *	instance,
		int	id,
		enum ast_rtp_extension_direction	direction,
		const char *	uri,
		const char *	attributes
	)

Negotiate received RTP extension information.

Parameters

instance	The RTP instance to set the extension on
id	The local identifier for the extension
direction	The direction that the extension should be used in
uri	The unique URI for the extension
attributes	Attributes specific to this extension (if NULL or empty then no attributes)

Return values

0	success
-1	failure

Since

15.5.0

Definition at line 869 of file rtp_engine.c.

{
    /* 'attributes' is currently unused but exists in the API to ensure it does not need to be altered
     * in the future in case we need to use it.
     */
    int idx;
    enum ast_rtp_extension extension = AST_RTP_EXTENSION_UNSUPPORTED;
 
    /* Per the RFC the identifier has to be 1 or above */
    if (id < 1) {
        return -1;
    }
 
    /* Convert the provided URI to the internal representation */
    for (idx = 0; idx < ARRAY_LEN(rtp_extension_uris); ++idx) {
        if (!strcasecmp(rtp_extension_uris[idx], uri)) {
            extension = idx;
            break;
        }
    }
 
    ao2_lock(instance);
    /* We only accept the extension if it is enabled */
    if (extension < AST_VECTOR_SIZE(&instance->extmap_enabled) &&
        AST_VECTOR_GET(&instance->extmap_enabled, extension) != AST_RTP_EXTENSION_DIRECTION_NONE) {
        struct rtp_extmap extmap = {
            .extension = extension,
            .direction = rtp_extmap_negotiate_direction(AST_VECTOR_GET(&instance->extmap_enabled, extension), direction),
        };
 
        /* If the direction negotiation failed then don't accept or use this extension */
        if (extmap.direction != AST_RTP_EXTENSION_DIRECTION_NONE) {
            if (extension != AST_RTP_EXTENSION_UNSUPPORTED) {
                AST_VECTOR_REPLACE(&instance->extmap_negotiated, extension, id);
            }
            AST_VECTOR_REPLACE(&instance->extmap_unique_ids, id - 1, extmap);
        }
    }
    ao2_unlock(instance);
 
    return 0;
}

References ao2_lock, ao2_unlock, ARRAY_LEN, AST_RTP_EXTENSION_DIRECTION_NONE, AST_RTP_EXTENSION_UNSUPPORTED, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, rtp_extmap::direction, rtp_extmap::extension, ast_rtp_instance::extmap_enabled, ast_rtp_instance::extmap_negotiated, ast_rtp_instance::extmap_unique_ids, rtp_extension_uris, and rtp_extmap_negotiate_direction().

Referenced by process_extmap_attributes().

ast_rtp_instance_fd()

int ast_rtp_instance_fd	(	struct ast_rtp_instance *	instance,
		int	rtcp
	)

Get the file descriptor for an RTP session (or RTCP)

Parameters

instance	Instance to get the file descriptor for
rtcp	Whether to retrieve the file descriptor for RTCP or not

Return values

fd	success
-1	failure

Example usage:

int rtp_fd = ast_rtp_instance_fd(instance, 0);

This retrieves the file descriptor for the socket carrying media on the instance pointed to by instance.

Since

1.8

Definition at line 2407 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->fd) {
        ao2_lock(instance);
        res = instance->engine->fd(instance, rtcp);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::fd.

Referenced by apply_negotiated_sdp_stream(), check_for_rtp_changes(), configure_local_rtp(), jingle_enable_video(), jingle_new(), rtp_find_rtcp_fd_position(), start_rtp(), unicast_rtp_request(), and unistim_new().

ast_rtp_instance_get_active_glue()

struct ast_rtp_glue * ast_rtp_instance_get_active_glue

(

struct ast_rtp_instance *

instance

)

Get the RTP glue in use on an RTP instance.

Parameters

instance

The RTP instance

Returns

pointer to the glue

Example:

struct ast_rtp_glue *glue = ast_rtp_instance_get_active_glue(instance);

This gets the RTP glue currently in use on the RTP instance pointed to by 'instance'.

Since

1.8

Definition at line 2960 of file rtp_engine.c.

{
    return instance->glue;
}

References ast_rtp_instance::glue.

ast_rtp_instance_get_and_cmp_local_address()

int ast_rtp_instance_get_and_cmp_local_address	(	struct ast_rtp_instance *	instance,
		struct ast_sockaddr *	address
	)

Get the address of the local endpoint that we are sending RTP to, comparing its address to another.

Parameters

instance	The instance that we want to get the local address for
address	An initialized address that may be overwritten if the local address is different

Return values

0	address was not changed
1	address was changed Example usage:

struct ast_sockaddr address;
int ret;
ret = ast_rtp_instance_get_and_cmp_local_address(instance, &address);

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

Definition at line 680 of file rtp_engine.c.

{
    ao2_lock(instance);
    if (ast_sockaddr_cmp(address, &instance->local_address) != 0) {
        ast_sockaddr_copy(address, &instance->local_address);
        ao2_unlock(instance);
        return 1;
    }
    ao2_unlock(instance);
 
    return 0;
}

References ao2_lock, ao2_unlock, ast_sockaddr_cmp(), ast_sockaddr_copy(), and ast_rtp_instance::local_address.

ast_rtp_instance_get_and_cmp_requested_target_address()

int ast_rtp_instance_get_and_cmp_requested_target_address	(	struct ast_rtp_instance *	instance,
		struct ast_sockaddr *	address
	)

Get the requested target address of the remote endpoint and compare it to the given address.

Parameters

instance	The instance that we want to get the remote address for
address	An initialized address that may be overwritten addresses differ

Return values

0	address was not changed
1	address was changed

Definition at line 702 of file rtp_engine.c.

{
    ao2_lock(instance);
    if (ast_sockaddr_cmp(address, &instance->requested_target_address) != 0) {
        ast_sockaddr_copy(address, &instance->requested_target_address);
        ao2_unlock(instance);
        return 1;
    }
    ao2_unlock(instance);
 
    return 0;
}

References ao2_lock, ao2_unlock, ast_sockaddr_cmp(), ast_sockaddr_copy(), and ast_rtp_instance::requested_target_address.

ast_rtp_instance_get_bridged()

struct ast_rtp_instance * ast_rtp_instance_get_bridged

(

struct ast_rtp_instance *

instance

)

Get the other RTP instance that an instance is bridged to.

Parameters

instance

The RTP instance that we want

Return values

non-NULL	success
NULL	failure

Example usage:

struct ast_rtp_instance *bridged = ast_rtp_instance_get_bridged(instance0);

This gets the RTP instance that instance0 is bridged to.

Since

1.8

Definition at line 2449 of file rtp_engine.c.

{
    struct ast_rtp_instance *bridged;
 
    ao2_lock(instance);
    bridged = instance->bridged;
    ao2_unlock(instance);
    return bridged;
}

References ao2_lock, ao2_unlock, and ast_rtp_instance::bridged.

Referenced by ast_rtp_interpret().

ast_rtp_instance_get_channel_id()

const char * ast_rtp_instance_get_channel_id

(

struct ast_rtp_instance *

instance

)

Get the unique ID of the channel that owns this RTP instance.

Note that this should remain valid for the lifetime of the RTP instance.

Parameters

instance

The RTP instance

Returns

The unique ID of the channel

Return values

Empty

string if no channel owns this RTP instance

Since

12

Definition at line 599 of file rtp_engine.c.

{
    return instance->channel_uniqueid;
}

References ast_rtp_instance::channel_uniqueid.

Referenced by __rtp_recvfrom(), ast_rtcp_interpret(), ast_rtp_get_stat(), ast_rtp_prop_set(), ast_rtp_stop(), ast_rtp_write(), calc_rxstamp_and_jitter(), rtp_check_timeout(), rtp_raw_write(), rtp_transport_wide_cc_feedback_produce(), update_local_mes_stats(), and update_reported_mes_stats().

ast_rtp_instance_get_cname()

const char * ast_rtp_instance_get_cname

(

struct ast_rtp_instance *

rtp

)

Retrieve the CNAME used in RTCP SDES items.

This is a pointer directly into the RTP struct, not a copy.

Parameters

rtp	The RTP instance

Returns

the CNAME

Definition at line 4079 of file rtp_engine.c.

{
    const char *cname = "";
 
    ao2_lock(rtp);
    if (rtp->engine->cname_get) {
        cname = rtp->engine->cname_get(rtp);
    }
    ao2_unlock(rtp);
 
    return cname;
}

References ao2_lock, ao2_unlock, ast_rtp_engine::cname_get, and ast_rtp_instance::engine.

Referenced by add_ssrc_to_stream().

ast_rtp_instance_get_codecs()

struct ast_rtp_codecs * ast_rtp_instance_get_codecs

(

struct ast_rtp_instance *

instance

)

Get the codecs structure of an RTP instance.

Parameters

instance

The RTP instance to get the codecs structure from

Example usage:

struct ast_rtp_codecs *codecs = ast_rtp_instance_get_codecs(instance);

This gets the codecs structure on the RTP instance pointed to by 'instance'.

Since

1.8

Definition at line 778 of file rtp_engine.c.

{
    return &instance->codecs;
}

References ast_rtp_instance::codecs.

Referenced by apply_cap_to_bundled(), ast_rtp_dtmf_begin(), ast_rtp_interpret(), ast_rtp_read(), ast_rtp_sendcng(), ast_rtp_write(), bridge_p2p_rtp_write(), configure_local_rtp(), create_outgoing_sdp_stream(), jingle_add_payloads_to_description(), jingle_enable_video(), jingle_interpret_description(), jingle_new(), multicast_rtp_write(), native_rtp_bridge_compatible_check(), ooh323_set_write_format(), send_start_rtp(), set_caps(), set_incoming_call_offer_cap(), and setup_rtp_connection().

ast_rtp_instance_get_data()

void * ast_rtp_instance_get_data

(

struct ast_rtp_instance *

instance

)

Get the data portion of an RTP instance.

Parameters

instance

The RTP instance we want the data portion from

Example usage:

  struct *blob = ast_rtp_instance_get_data(instance);
( 

This gets the data pointer on the RTP instance pointed to by 'instance'.

Since

1.8

Definition at line 614 of file rtp_engine.c.

{
    return instance->data;
}

References ast_rtp_instance::data.

Referenced by __rtp_recvfrom(), __rtp_sendto(), ast_rtcp_calculate_sr_rr_statistics(), ast_rtcp_generate_nack(), ast_rtcp_generate_report(), ast_rtcp_generate_sdes(), ast_rtcp_interpret(), ast_rtcp_read(), ast_rtcp_write(), ast_rtp_bundle(), ast_rtp_change_source(), ast_rtp_destroy(), ast_rtp_dtmf_begin(), ast_rtp_dtmf_continuation(), ast_rtp_dtmf_end_with_duration(), ast_rtp_dtmf_mode_get(), ast_rtp_dtmf_mode_set(), ast_rtp_fd(), ast_rtp_get_cname(), ast_rtp_get_ssrc(), ast_rtp_get_stat(), ast_rtp_interpret(), ast_rtp_local_bridge(), ast_rtp_prop_set(), ast_rtp_qos_set(), ast_rtp_read(), ast_rtp_remote_address_set(), ast_rtp_rtcp_handle_nack(), ast_rtp_sendcng(), ast_rtp_set_remote_ssrc(), ast_rtp_set_stream_num(), ast_rtp_stop(), ast_rtp_stun_request(), ast_rtp_update_source(), ast_rtp_write(), bridge_p2p_rtp_write(), create_dtmf_frame(), multicast_rtp_activate(), multicast_rtp_destroy(), multicast_rtp_write(), process_cn_rfc3389(), process_dtmf_cisco(), process_dtmf_rfc2833(), red_write(), rtp_instance_parse_transport_wide_cc(), rtp_raw_write(), rtp_raw_write(), rtp_red_buffer(), rtp_red_init(), rtp_sendto(), and rtp_transport_wide_cc_feedback_produce().

ast_rtp_instance_get_dtls()

struct ast_rtp_engine_dtls * ast_rtp_instance_get_dtls

(

struct ast_rtp_instance *

instance

)

Obtain a pointer to the DTLS support present on an RTP instance.

Parameters

instance

the RTP instance

Returns

DTLS support if present

Return values

NULL	if no DTLS support available

Definition at line 3266 of file rtp_engine.c.

{
    if (instance->engine->dtls) {
        return &rtp_dtls_wrappers;
    }
    /* DTLS not available */
    return NULL;
}

References ast_rtp_engine::dtls, ast_rtp_instance::engine, NULL, and rtp_dtls_wrappers.

Referenced by add_crypto_to_stream(), add_fingerprints_if_present(), apply_dtls_attrib(), ast_sdp_get_rtp_profile(), and setup_dtls_srtp().

ast_rtp_instance_get_engine()

struct ast_rtp_engine * ast_rtp_instance_get_engine

(

struct ast_rtp_instance *

instance

)

Get the RTP engine in use on an RTP instance.

Parameters

instance

The RTP instance

Returns

pointer to the engine

Example usage:

struct ast_rtp_engine *engine = ast_rtp_instance_get_engine(instance);

This gets the RTP engine currently in use on the RTP instance pointed to by 'instance'.

Since

1.8

Definition at line 2955 of file rtp_engine.c.

{
    return instance->engine;
}

References ast_rtp_instance::engine.

Referenced by native_rtp_bridge_compatible_check(), native_rtp_bridge_start(), and native_rtp_bridge_stop().

ast_rtp_instance_get_extended_prop()

void * ast_rtp_instance_get_extended_prop	(	struct ast_rtp_instance *	instance,
		int	property
	)

Get the value of an RTP instance extended property.

Parameters

instance	The RTP instance to get the extended property on
property	The extended property to get

Since

1.8

Definition at line 741 of file rtp_engine.c.

{
    void *prop;
 
    if (instance->engine->extended_prop_get) {
        ao2_lock(instance);
        prop = instance->engine->extended_prop_get(instance, property);
        ao2_unlock(instance);
    } else {
        prop = NULL;
    }
 
    return prop;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::extended_prop_get, and NULL.

ast_rtp_instance_get_glue()

struct ast_rtp_glue * ast_rtp_instance_get_glue

(

const char *

type

)

Get the RTP glue that binds a channel to the RTP engine.

Parameters

type	Name of the glue we want

Return values

non-NULL	success
NULL	failure

Example usage:

struct ast_rtp_glue *glue = ast_rtp_instance_get_glue("Example");

This retrieves the RTP glue that has the name 'Example'.

Since

1.8

Definition at line 2421 of file rtp_engine.c.

{
    struct ast_rtp_glue *glue = NULL;
 
    AST_RWLIST_RDLOCK(&glues);
 
    AST_RWLIST_TRAVERSE(&glues, glue, entry) {
        if (!strcasecmp(glue->type, type)) {
            break;
        }
    }
 
    AST_RWLIST_UNLOCK(&glues);
 
    return glue;
}

References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_rtp_glue::entry, NULL, type, and ast_rtp_glue::type.

Referenced by ast_ari_channels_rtpstatistics(), ast_rtp_instance_early_bridge(), ast_rtp_instance_early_bridge_make_compatible(), ast_rtp_instance_make_compatible(), ast_softhangup(), and rtp_glue_data_get().

ast_rtp_instance_get_hold_timeout()

int ast_rtp_instance_get_hold_timeout

(

struct ast_rtp_instance *

instance

)

Get the RTP timeout value for when an RTP instance is on hold.

Parameters

instance

The RTP instance

Returns

timeout value

Example usage:

int timeout = ast_rtp_instance_get_hold_timeout(instance);

This gets the RTP hold timeout value for the RTP instance pointed to by 'instance'.

Since

1.8

Definition at line 2935 of file rtp_engine.c.

{
    return instance->holdtimeout;
}

References ast_rtp_instance::holdtimeout.

ast_rtp_instance_get_ice()

struct ast_rtp_engine_ice * ast_rtp_instance_get_ice

(

struct ast_rtp_instance *

instance

)

Obtain a pointer to the ICE support present on an RTP instance.

Parameters

instance

the RTP instance

Returns

ICE support if present

Return values

NULL	if no ICE support available

Definition at line 3146 of file rtp_engine.c.

{
    if (instance->engine->ice) {
        return &rtp_ice_wrappers;
    }
    /* ICE not available */
    return NULL;
}

References ast_rtp_instance::engine, ast_rtp_engine::ice, NULL, and rtp_ice_wrappers.

Referenced by add_ice_to_stream(), check_ice_support(), create_rtp(), jingle_add_google_candidates_to_transport(), jingle_add_ice_udp_candidates_to_transport(), jingle_enable_video(), jingle_interpret_google_transport(), jingle_interpret_ice_udp_transport(), jingle_new(), jingle_outgoing_hook(), jingle_request(), process_ice_attributes(), process_ice_auth_attrb(), and set_ice_components().

ast_rtp_instance_get_incoming_source_address()

void ast_rtp_instance_get_incoming_source_address	(	struct ast_rtp_instance *	instance,
		struct ast_sockaddr *	address
	)

Get the incoming source address of the remote endpoint.

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.

Parameters

instance	The instance that we want to get the incoming source address for
address	A structure to put the address into

Definition at line 716 of file rtp_engine.c.

{
    ao2_lock(instance);
    ast_sockaddr_copy(address, &instance->incoming_source_address);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_sockaddr_copy(), and ast_rtp_instance::incoming_source_address.

ast_rtp_instance_get_keepalive()

int ast_rtp_instance_get_keepalive

(

struct ast_rtp_instance *

instance

)

Get the RTP keepalive interval.

Parameters

instance

The RTP instance

Returns

period Keepalive interval value

Example usage:

int interval = ast_rtp_instance_get_keepalive(instance);

This gets the RTP keepalive interval value for the RTP instance pointed to by 'instance'.

Since

1.8

Definition at line 2940 of file rtp_engine.c.

{
    return instance->keepalive;
}

References ast_rtp_instance::keepalive.

Referenced by send_keepalive().

ast_rtp_instance_get_last_rx()

time_t ast_rtp_instance_get_last_rx

(

const struct ast_rtp_instance *

rtp

)

Get the last RTP reception time.

Parameters

rtp	The instance from which to get the last reception time

Returns

The last RTP reception time

Definition at line 4056 of file rtp_engine.c.

{
    return rtp->last_rx;
}

References ast_rtp_instance::last_rx.

Referenced by rtp_check_timeout().

ast_rtp_instance_get_last_tx()

time_t ast_rtp_instance_get_last_tx

(

const struct ast_rtp_instance *

rtp

)

Get the last RTP transmission time.

Parameters

rtp	The instance from which to get the last transmission time

Returns

The last RTP transmission time

Definition at line 4046 of file rtp_engine.c.

{
    return rtp->last_tx;
}

References ast_rtp_instance::last_tx.

Referenced by send_keepalive().

ast_rtp_instance_get_local_address()

void ast_rtp_instance_get_local_address	(	struct ast_rtp_instance *	instance,
		struct ast_sockaddr *	address
	)

Get the local address that we are expecting RTP on.

Parameters

instance	The RTP instance to get the address from
address	The variable to store the address in

Example usage:

struct ast_sockaddr address;
ast_rtp_instance_get_local_address(instance, &address);

This gets the local address that we are expecting RTP on and stores it in the 'address' structure.

Since

1.8

Definition at line 694 of file rtp_engine.c.

{
    ao2_lock(instance);
    ast_sockaddr_copy(address, &instance->local_address);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_sockaddr_copy(), and ast_rtp_instance::local_address.

Referenced by ast_rtp_prop_set(), ast_rtp_remote_address_set(), channel_read_rtp(), configure_local_rtp(), create_outgoing_sdp_stream(), multicast_send_control_packet(), send_start_rtp(), test_init_rtp_instances(), unicast_rtp_request(), and unistim_set_rtp_peer().

ast_rtp_instance_get_port_end()

unsigned int ast_rtp_instance_get_port_end

(

struct ast_rtp_instance *

instance

)

Get the per-instance RTP port range end.

Parameters

instance

The RTP instance

Returns

port end value (0 means use global setting)

Since

20.20.0

22.10.0

23.4.0

Definition at line 2950 of file rtp_engine.c.

{
    return instance->rtp_port_end;
}

References ast_rtp_instance::rtp_port_end.

Referenced by rtp_allocate_transport().

ast_rtp_instance_get_port_start()

unsigned int ast_rtp_instance_get_port_start

(

struct ast_rtp_instance *

instance

)

Get the per-instance RTP port range start.

Parameters

instance

The RTP instance

Returns

port start value (0 means use global setting)

Since

20.20.0

22.10.0

23.4.0

Definition at line 2945 of file rtp_engine.c.

{
    return instance->rtp_port_start;
}

References ast_rtp_instance::rtp_port_start.

Referenced by rtp_allocate_transport().

ast_rtp_instance_get_prop()

int ast_rtp_instance_get_prop	(	struct ast_rtp_instance *	instance,
		enum ast_rtp_property	property
	)

Get the value of an RTP instance property.

Parameters

instance	The RTP instance to get the property from
property	The property to get

Returns

Current value of the property

Example usage:

ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT);

This returns the current value of the NAT property on the instance pointed to by instance.

Since

1.8

Definition at line 767 of file rtp_engine.c.

{
    int prop;
 
    ao2_lock(instance);
    prop = instance->properties[property];
    ao2_unlock(instance);
 
    return prop;
}

References ao2_lock, ao2_unlock, and ast_rtp_instance::properties.

Referenced by ast_rtcp_interpret(), ast_rtp_dtmf_compatible(), ast_rtp_read(), bridge_p2p_rtp_write(), process_dtmf_cisco(), process_dtmf_rfc2833(), rtp_raw_write(), and rtp_write_rtcp_psfb().

ast_rtp_instance_get_quality()

char * ast_rtp_instance_get_quality	(	struct ast_rtp_instance *	instance,
		enum ast_rtp_instance_stat_field	field,
		char *	buf,
		size_t	size
	)

Retrieve quality statistics about an RTP instance.

Parameters

instance	Instance to get statistics on
field	What quality statistic to retrieve
buf	What buffer to put the result into
size	Size of the above buffer

Return values

non-NULL	success
NULL	failure

Example usage:

char quality[AST_MAX_USER_FIELD];
ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, &buf, sizeof(buf));

This retrieves general quality statistics and places a text representation into the buf pointed to by buf.

Since

1.8

Definition at line 2679 of file rtp_engine.c.

{
    struct ast_rtp_instance_stats stats = { 0, };
    enum ast_rtp_instance_stat stat;
 
    /* Determine what statistics we will need to retrieve based on field passed in */
    if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY) {
        stat = AST_RTP_INSTANCE_STAT_ALL;
    } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER) {
        stat = AST_RTP_INSTANCE_STAT_COMBINED_JITTER;
    } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS) {
        stat = AST_RTP_INSTANCE_STAT_COMBINED_LOSS;
    } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT) {
        stat = AST_RTP_INSTANCE_STAT_COMBINED_RTT;
    } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES) {
        stat = AST_RTP_INSTANCE_STAT_COMBINED_MES;
    } else {
        return NULL;
    }
 
    /* Attempt to actually retrieve the statistics we need to generate the quality string */
    if (ast_rtp_instance_get_stats(instance, &stats, stat)) {
        return NULL;
    }
 
    /* Now actually fill the buffer with the good information */
    if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY) {
        snprintf(buf, size, "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;"
            "txjitter=%f;txcount=%u;rlp=%u;rtt=%f;rxmes=%f;txmes=%f",
             stats.local_ssrc, stats.remote_ssrc, stats.rxploss, stats.rxjitter,
             stats.rxcount, stats.txjitter, stats.txcount, stats.txploss, stats.rtt,
             stats.rxmes, stats.txmes);
    } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER) {
        snprintf(buf, size, "minrxjitter=%010.6f;maxrxjitter=%010.6f;avgrxjitter=%010.6f;stdevrxjitter=%010.6f;mintxjitter=%010.6f;maxtxjitter=%010.6f;avgtxjitter=%010.6f;stdevtxjitter=%010.6f;",
             stats.local_minjitter, stats.local_maxjitter, stats.local_normdevjitter, stats.local_stdevjitter, stats.remote_minjitter, stats.remote_maxjitter, stats.remote_normdevjitter, stats.remote_stdevjitter);
    } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS) {
        snprintf(buf, size, "  minrxlost=%010.6f;  maxrxlost=%010.6f;  avgrxlost=%010.6f;  stdevrxlost=%010.6f;  mintxlost=%010.6f;  maxtxlost=%010.6f;  avgtxlost=%010.6f;  stdevtxlost=%010.6f;",
             stats.local_minrxploss, stats.local_maxrxploss, stats.local_normdevrxploss, stats.local_stdevrxploss, stats.remote_minrxploss, stats.remote_maxrxploss, stats.remote_normdevrxploss, stats.remote_stdevrxploss);
    } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT) {
        snprintf(buf, size, "     minrtt=%010.6f;     maxrtt=%010.6f;     avgrtt=%010.6f;     stdevrtt=%010.6f;", stats.minrtt, stats.maxrtt, stats.normdevrtt, stats.stdevrtt);
    } else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES) {
        snprintf(buf, size, "   minrxmes=%010.6f;   maxrxmes=%010.6f;   avgrxmes=%010.6f;   stdevrxmes=%010.6f;   mintxmes=%010.6f;   maxtxmes=%010.6f;   avgtxmes=%010.6f;   stdevtxmes=%010.6f;",
             stats.local_minmes, stats.local_maxmes,
             stats.local_normdevmes, stats.local_stdevmes,
             stats.remote_minmes, stats.remote_maxmes,
             stats.remote_normdevmes, stats.remote_stdevmes);
    }
 
    return buf;
}

References ast_rtp_instance_get_stats(), AST_RTP_INSTANCE_STAT_ALL, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, AST_RTP_INSTANCE_STAT_COMBINED_MES, AST_RTP_INSTANCE_STAT_COMBINED_RTT, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT, buf, ast_rtp_instance_stats::local_maxjitter, ast_rtp_instance_stats::local_maxmes, ast_rtp_instance_stats::local_maxrxploss, ast_rtp_instance_stats::local_minjitter, ast_rtp_instance_stats::local_minmes, ast_rtp_instance_stats::local_minrxploss, ast_rtp_instance_stats::local_normdevjitter, ast_rtp_instance_stats::local_normdevmes, ast_rtp_instance_stats::local_normdevrxploss, ast_rtp_instance_stats::local_ssrc, ast_rtp_instance_stats::local_stdevjitter, ast_rtp_instance_stats::local_stdevmes, ast_rtp_instance_stats::local_stdevrxploss, ast_rtp_instance_stats::maxrtt, ast_rtp_instance_stats::minrtt, ast_rtp_instance_stats::normdevrtt, NULL, ast_rtp_instance_stats::remote_maxjitter, ast_rtp_instance_stats::remote_maxmes, ast_rtp_instance_stats::remote_maxrxploss, ast_rtp_instance_stats::remote_minjitter, ast_rtp_instance_stats::remote_minmes, ast_rtp_instance_stats::remote_minrxploss, ast_rtp_instance_stats::remote_normdevjitter, ast_rtp_instance_stats::remote_normdevmes, ast_rtp_instance_stats::remote_normdevrxploss, ast_rtp_instance_stats::remote_ssrc, ast_rtp_instance_stats::remote_stdevjitter, ast_rtp_instance_stats::remote_stdevmes, ast_rtp_instance_stats::remote_stdevrxploss, ast_rtp_instance_stats::rtt, ast_rtp_instance_stats::rxcount, ast_rtp_instance_stats::rxjitter, ast_rtp_instance_stats::rxmes, ast_rtp_instance_stats::rxploss, ast_rtp_instance_stats::stdevrtt, ast_rtp_instance_stats::txcount, ast_rtp_instance_stats::txjitter, ast_rtp_instance_stats::txmes, and ast_rtp_instance_stats::txploss.

Referenced by ast_rtp_instance_destroy(), and channel_read_rtcp().

ast_rtp_instance_get_requested_target_address()

void ast_rtp_instance_get_requested_target_address	(	struct ast_rtp_instance *	instance,
		struct ast_sockaddr *	address
	)

Get the requested target address of the remote endpoint.

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.

Parameters

instance	The instance that we want to get the requested target address for
address	A structure to put the address into

Definition at line 724 of file rtp_engine.c.

{
    ao2_lock(instance);
    ast_sockaddr_copy(address, &instance->requested_target_address);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_sockaddr_copy(), and ast_rtp_instance::requested_target_address.

Referenced by ast_rtp_read().

ast_rtp_instance_get_srtp()

struct ast_srtp * ast_rtp_instance_get_srtp	(	struct ast_rtp_instance *	instance,
		int	rtcp
	)

Obtain the SRTP instance associated with an RTP instance.

Parameters

instance	the RTP instance
rtcp	1 to request instance for RTCP

Returns

the SRTP instance on success

Return values

NULL	if no SRTP instance exists

Definition at line 3018 of file rtp_engine.c.

{
    if (rtcp && instance->rtcp_srtp) {
        return instance->rtcp_srtp;
    } else {
        return instance->srtp;
    }
}

References ast_rtp_instance::rtcp_srtp, and ast_rtp_instance::srtp.

Referenced by __rtp_sendto(), ast_rtcp_read(), ast_rtp_change_source(), and ast_rtp_read().

ast_rtp_instance_get_ssrc()

unsigned int ast_rtp_instance_get_ssrc

(

struct ast_rtp_instance *

rtp

)

Retrieve the local SSRC value that we will be using.

Parameters

rtp	The RTP instance

Returns

The SSRC value

Definition at line 4066 of file rtp_engine.c.

{
    unsigned int ssrc = 0;
 
    ao2_lock(rtp);
    if (rtp->engine->ssrc_get) {
        ssrc = rtp->engine->ssrc_get(rtp);
    }
    ao2_unlock(rtp);
 
    return ssrc;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::ssrc_get.

Referenced by add_ssrc_to_stream(), ast_srtp_unprotect(), and create_outgoing_sdp_stream().

ast_rtp_instance_get_stats()

int ast_rtp_instance_get_stats	(	struct ast_rtp_instance *	instance,
		struct ast_rtp_instance_stats *	stats,
		enum ast_rtp_instance_stat	stat
	)

Retrieve statistics about an RTP instance.

Parameters

instance	Instance to get statistics on
stats	Structure to put results into
stat	What statistic(s) to retrieve

Return values

0	success
-1	failure

Example usage:

struct ast_rtp_instance_stats stats;
ast_rtp_instance_get_stats(instance, &stats, AST_RTP_INSTANCE_STAT_ALL);

This retrieves all statistics the underlying RTP engine supports and puts the values into the stats structure.

Since

1.8

Definition at line 2661 of file rtp_engine.c.

{
    int res;
 
    if (!instance || !instance->engine || !stats) {
        return -1;
    }
 
    if (instance->engine->get_stat) {
        ao2_lock(instance);
        res = instance->engine->get_stat(instance, stats, stat);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::get_stat.

Referenced by ast_rtp_instance_get_quality(), ast_rtp_instance_get_stats_all_json(), ast_sip_session_media_stats_save(), ast_srtp_unprotect(), AST_TEST_DEFINE(), channel_read_rtcp(), cli_channelstats_print_body(), crypto_activate(), and process_ssrc_attributes().

ast_rtp_instance_get_stats_all_json()

struct ast_json * ast_rtp_instance_get_stats_all_json

(

struct ast_rtp_instance *

instance

)

Retrieve statistics about an RTP instance in json format.

Parameters

instance

Returns

json object of stats

Definition at line 4320 of file rtp_engine.c.

{
    struct ast_rtp_instance_stats stats = {0,};
 
    if(ast_rtp_instance_get_stats(instance, &stats, AST_RTP_INSTANCE_STAT_ALL)) {
        return NULL;
    }
 
    return ast_rtp_convert_stats_json(&stats);
}

References ast_rtp_convert_stats_json(), ast_rtp_instance_get_stats(), AST_RTP_INSTANCE_STAT_ALL, and NULL.

Referenced by ast_ari_channels_rtpstatistics().

ast_rtp_instance_get_timeout()

int ast_rtp_instance_get_timeout

(

struct ast_rtp_instance *

instance

)

Get the RTP timeout value.

Parameters

instance

The RTP instance

Returns

timeout value

Example usage:

int timeout = ast_rtp_instance_get_timeout(instance);

This gets the RTP timeout value for the RTP instance pointed to by 'instance'.

Since

1.8

Definition at line 2930 of file rtp_engine.c.

{
    return instance->timeout;
}

References ast_rtp_instance::timeout.

Referenced by apply_negotiated_sdp_stream(), and rtp_check_timeout().

ast_rtp_instance_make_compatible()

int ast_rtp_instance_make_compatible	(	struct ast_channel *	chan,
		struct ast_rtp_instance *	instance,
		struct ast_channel *	peer
	)

Request that the underlying RTP engine make two RTP instances compatible with eachother.

Parameters

chan	Our own Asterisk channel
instance	The first RTP instance
peer	The peer Asterisk channel

Return values

0	success
-1	failure

Example usage:

ast_rtp_instance_make_compatible(instance, peer);

This makes the RTP instance for 'peer' compatible with 'instance' and vice versa.

Since

1.8

Definition at line 2834 of file rtp_engine.c.

{
    struct ast_rtp_glue *glue;
    struct ast_rtp_instance *peer_instance = NULL;
    int res = -1;
 
    if (!instance->engine->make_compatible) {
        return -1;
    }
 
    ast_channel_lock(peer);
 
    if (!(glue = ast_rtp_instance_get_glue(ast_channel_tech(peer)->type))) {
        ast_channel_unlock(peer);
        return -1;
    }
 
    glue->get_rtp_info(peer, &peer_instance);
    if (!peer_instance) {
        ast_log(LOG_ERROR, "Unable to get_rtp_info for peer type %s\n", glue->type);
        ast_channel_unlock(peer);
        return -1;
    }
    if (peer_instance->engine != instance->engine) {
        ast_log(LOG_ERROR, "Peer engine mismatch for type %s\n", glue->type);
        ast_channel_unlock(peer);
        ao2_ref(peer_instance, -1);
        return -1;
    }
 
    /*
     * XXX Good thing nothing calls this function because we would need
     * deadlock avoidance to get the two instance locks.
     */
    res = instance->engine->make_compatible(chan, instance, peer, peer_instance);
 
    ast_channel_unlock(peer);
 
    ao2_ref(peer_instance, -1);
    peer_instance = NULL;
 
    return res;
}

References ao2_ref, ast_channel_lock, ast_channel_unlock, ast_log, ast_rtp_instance_get_glue(), ast_rtp_instance::engine, ast_rtp_glue::get_rtp_info, ast_rtp_instance::glue, LOG_ERROR, ast_rtp_engine::make_compatible, NULL, type, and ast_rtp_glue::type.

ast_rtp_instance_new()

struct ast_rtp_instance * ast_rtp_instance_new	(	const char *	engine_name,
		struct ast_sched_context *	sched,
		const struct ast_sockaddr *	sa,
		void *	data
	)

Create a new RTP instance.

Parameters

engine_name	Name of the engine to use for the RTP instance
sched	Scheduler context that the RTP engine may want to use
sa	Address we want to bind to
data	Unique data for the engine

Return values

non-NULL	success
NULL	failure

Example usage:

struct ast_rtp_instance *instance = NULL;
instance = ast_rtp_instance_new(NULL, sched, &sin, NULL);

This creates a new RTP instance using the default engine and asks the RTP engine to bind to the address given 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.8

Definition at line 497 of file rtp_engine.c.

{
    return ast_rtp_instance_new_with_options(
        engine_name, sched, sa, data, NULL);
}

References ast_rtp_instance_new_with_options(), ast_rtp_instance::data, and NULL.

Referenced by configure_local_rtp(), create_rtp(), jingle_alloc(), jingle_enable_video(), multicast_rtp_request(), start_rtp(), test_init_rtp_instances(), and unicast_rtp_request().

ast_rtp_instance_new_with_options()

struct ast_rtp_instance * ast_rtp_instance_new_with_options	(	const char *	engine_name,
		struct ast_sched_context *	sched,
		const struct ast_sockaddr *	sa,
		void *	data,
		const struct ast_rtp_instance_options *	options
	)

Create a new RTP instance with additional options.

Parameters

engine_name	Name of the engine to use for the RTP instance
sched	Scheduler context that the RTP engine may want to use
sa	Address we want to bind to
data	Unique data for the engine
options	Pointer to options struct, or NULL to use defaults

Return values

non-NULL	success
NULL	failure

Example usage:

struct ast_rtp_instance_options options = { .port_start = 15000, .port_end = 15010 };
struct ast_rtp_instance *instance = NULL;
instance = ast_rtp_instance_new_with_options(NULL, sched, &sin, NULL, &options);

This creates a new RTP instance using the specified options. When a per-instance port range is provided the global rtp.conf range is ignored. If options is NULL or port values are both 0 the global range is used.

Note

The per-instance port range overrides the global rtp.conf settings for this specific RTP instance only. It does not need to be a subset of the global range.

Since

20.20.0

22.10.0

23.4.0

Definition at line 505 of file rtp_engine.c.

{
    struct ast_sockaddr address = {{0,}};
    struct ast_rtp_instance *instance = NULL;
    struct ast_rtp_engine *engine = NULL;
    struct ast_module *mod_ref;
    unsigned int port_start = options ? options->port_start : 0;
    unsigned int port_end = options ? options->port_end : 0;
 
    AST_RWLIST_RDLOCK(&engines);
 
    /* If an engine name was specified try to use it or otherwise use the first one registered */
    if (!ast_strlen_zero(engine_name)) {
        AST_RWLIST_TRAVERSE(&engines, engine, entry) {
            if (!strcmp(engine->name, engine_name)) {
                break;
            }
        }
    } else {
        engine = AST_RWLIST_FIRST(&engines);
    }
 
    /* If no engine was actually found bail out now */
    if (!engine) {
        ast_log(LOG_ERROR, "No RTP engine was found. Do you have one loaded?\n");
        AST_RWLIST_UNLOCK(&engines);
        return NULL;
    }
 
    /* Bump up the reference count before we return so the module can not be unloaded */
    mod_ref = ast_module_running_ref(engine->mod);
 
    AST_RWLIST_UNLOCK(&engines);
 
    if (!mod_ref) {
        /* BUGBUG: improve handling of this situation. */
        return NULL;
    }
 
    /* Allocate a new RTP instance */
    if (!(instance = ao2_alloc(sizeof(*instance), instance_destructor))) {
        ast_module_unref(engine->mod);
        return NULL;
    }
    instance->engine = engine;
    ast_sockaddr_copy(&instance->local_address, sa);
    ast_sockaddr_copy(&address, sa);
 
    /* Set the per-instance port range before the engine allocates the transport */
    instance->rtp_port_start = port_start;
    instance->rtp_port_end = port_end;
 
    if (ast_rtp_codecs_payloads_initialize(&instance->codecs)) {
        ao2_ref(instance, -1);
        return NULL;
    }
 
    /* Initialize RTP extension support */
    if (AST_VECTOR_INIT(&instance->extmap_enabled, 0) ||
        AST_VECTOR_INIT(&instance->extmap_negotiated, 0) ||
        AST_VECTOR_INIT(&instance->extmap_unique_ids, 0)) {
        ao2_ref(instance, -1);
        return NULL;
    }
 
    if (port_start && port_end) {
        ast_debug(1, "Using engine '%s' for RTP instance '%p' with port range %d-%d\n",
            engine->name, instance, port_start, port_end);
    } else {
        ast_debug(1, "Using engine '%s' for RTP instance '%p'\n", engine->name, instance);
    }
 
    /*
     * And pass it off to the engine to setup
     *
     * Lock in case the RTP engine has other threads that
     * need synchronization with the construction.
     */
    ao2_lock(instance);
    if (instance->engine->new(instance, sched, &address, data)) {
        ast_debug(1, "Engine '%s' failed to setup RTP instance '%p'\n", engine->name, instance);
        ao2_unlock(instance);
        ao2_ref(instance, -1);
        return NULL;
    }
    ao2_unlock(instance);
 
    ast_debug(1, "RTP instance '%p' is setup and ready to go\n", instance);
 
    return instance;
}

References ao2_alloc, ao2_lock, ao2_ref, ao2_unlock, ast_debug, ast_log, ast_module_running_ref, ast_module_unref, ast_rtp_codecs_payloads_initialize(), AST_RWLIST_FIRST, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_sockaddr_copy(), ast_strlen_zero(), AST_VECTOR_INIT, ast_rtp_instance::codecs, ast_rtp_instance::engine, ast_module::entry, ast_rtp_instance::extmap_enabled, ast_rtp_instance::extmap_negotiated, ast_rtp_instance::extmap_unique_ids, instance_destructor(), ast_rtp_instance::local_address, LOG_ERROR, ast_rtp_engine::mod, ast_rtp_engine::name, ast_rtp_engine::new, NULL, options, ast_rtp_instance::rtp_port_end, and ast_rtp_instance::rtp_port_start.

Referenced by ast_rtp_instance_new(), and create_rtp().

ast_rtp_instance_read()

struct ast_frame * ast_rtp_instance_read	(	struct ast_rtp_instance *	instance,
		int	rtcp
	)

Receive a frame over RTP.

Parameters

instance	The RTP instance to receive frame on
rtcp	Whether to read in RTCP or not

Return values

non-NULL	success
NULL	failure

Example usage:

struct ast_frame *frame;
frame = ast_rtp_instance_read(instance, 0);

This asks the RTP engine to read in RTP from the instance and return it as an Asterisk frame.

Since

1.8

Definition at line 629 of file rtp_engine.c.

{
    struct ast_frame *frame;
 
    ao2_lock(instance);
    frame = instance->engine->read(instance, rtcp);
    ao2_unlock(instance);
    return frame;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::read.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), jingle_read(), media_session_rtcp_read_callback(), media_session_rtp_read_callback(), ooh323_rtp_read(), rtp_read(), test_read_frames(), test_write_and_read_interleaved_frames(), and unistim_rtp_read().

ast_rtp_instance_sendcng()

int ast_rtp_instance_sendcng	(	struct ast_rtp_instance *	instance,
		int	level
	)

Send a comfort noise packet to the RTP instance.

Parameters

instance	The RTP instance
level	Magnitude of the noise level

Return values

0	Success
non-zero	Failure

Definition at line 3027 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->sendcng) {
        ao2_lock(instance);
        res = instance->engine->sendcng(instance, level);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::sendcng.

Referenced by do_monitor(), and send_keepalive().

ast_rtp_instance_set_bridged()

void ast_rtp_instance_set_bridged	(	struct ast_rtp_instance *	instance,
		struct ast_rtp_instance *	bridged
	)

Set the other RTP instance that an instance is bridged to.

Parameters

instance	The RTP instance that we want to set the bridged value on
bridged	The RTP instance they are bridged to

Since

12

Definition at line 2459 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->bridged = bridged;
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, and ast_rtp_instance::bridged.

Referenced by native_rtp_bridge_start(), and native_rtp_bridge_stop().

ast_rtp_instance_set_channel_id()

void ast_rtp_instance_set_channel_id	(	struct ast_rtp_instance *	instance,
		const char *	uniqueid
	)

Set the channel that owns this RTP instance.

Parameters

instance	The RTP instance
uniqueid	The uniqueid of the channel

Since

12

Definition at line 604 of file rtp_engine.c.

{
    ast_copy_string(instance->channel_uniqueid, uniqueid, sizeof(instance->channel_uniqueid));
}

References ast_copy_string(), and ast_rtp_instance::channel_uniqueid.

Referenced by apply_negotiated_sdp_stream(), jingle_enable_video(), jingle_set_owner(), multicast_rtp_request(), set_channel_on_rtp_instance(), start_rtp(), test_init_rtp_instances(), unicast_rtp_request(), and unistim_set_owner().

ast_rtp_instance_set_data()

void ast_rtp_instance_set_data	(	struct ast_rtp_instance *	instance,
		void *	data
	)

Set the data portion of an RTP instance.

Parameters

instance	The RTP instance to manipulate
data	Pointer to data

Example usage:

ast_rtp_instance_set_data(instance, blob);

This sets the data pointer on the RTP instance pointed to by 'instance' to blob.

Since

1.8

Definition at line 609 of file rtp_engine.c.

{
    instance->data = data;
}

References ast_rtp_instance::data.

Referenced by ast_rtp_new(), and multicast_rtp_new().

ast_rtp_instance_set_extended_prop()

void ast_rtp_instance_set_extended_prop	(	struct ast_rtp_instance *	instance,
		int	property,
		void *	value
	)

Set the value of an RTP instance extended property.

Parameters

instance	The RTP instance to set the extended property on
property	The extended property to set
value	The value to set the extended property to

Since

1.8

Definition at line 732 of file rtp_engine.c.

{
    if (instance->engine->extended_prop_set) {
        ao2_lock(instance);
        instance->engine->extended_prop_set(instance, property, value);
        ao2_unlock(instance);
    }
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::extended_prop_set, and value.

ast_rtp_instance_set_hold_timeout()

void ast_rtp_instance_set_hold_timeout	(	struct ast_rtp_instance *	instance,
		int	timeout
	)

Set the RTP timeout value for when the instance is on hold.

Parameters

instance	The RTP instance
timeout	Value to set the timeout to

Example usage:

ast_rtp_instance_set_hold_timeout(instance, 5000);

This sets the RTP hold timeout value on 'instance' to be 5000.

Since

1.8

Definition at line 2920 of file rtp_engine.c.

{
    instance->holdtimeout = timeout;
}

References ast_rtp_instance::holdtimeout, and ast_rtp_instance::timeout.

ast_rtp_instance_set_incoming_source_address()

int ast_rtp_instance_set_incoming_source_address	(	struct ast_rtp_instance *	instance,
		const struct ast_sockaddr *	address
	)

Set the incoming source address of the remote endpoint that we are sending RTP to.

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.

Parameters

instance	The RTP instance to change the address on
address	Address to set it to

Return values

0	success
-1	failure

Definition at line 657 of file rtp_engine.c.

{
    ao2_lock(instance);
    rtp_instance_set_incoming_source_address_nolock(instance, address);
    ao2_unlock(instance);
 
    return 0;
}

References ao2_lock, ao2_unlock, and rtp_instance_set_incoming_source_address_nolock().

Referenced by ast_rtp_read().

ast_rtp_instance_set_keepalive()

void ast_rtp_instance_set_keepalive	(	struct ast_rtp_instance *	instance,
		int	timeout
	)

Set the RTP keepalive interval.

Parameters

instance	The RTP instance
timeout	Value to set the keepalive interval to

Example usage:

ast_rtp_instance_set_keepalive(instance, 5000);

This sets the RTP keepalive interval on 'instance' to be 5000.

Since

1.8

Definition at line 2925 of file rtp_engine.c.

{
    instance->keepalive = interval;
}

References ast_rtp_instance::keepalive.

Referenced by apply_negotiated_sdp_stream().

ast_rtp_instance_set_last_rx()

void ast_rtp_instance_set_last_rx	(	struct ast_rtp_instance *	rtp,
		time_t	time
	)

Set the last RTP reception time.

Parameters

rtp	The instance on which to set the last reception time
time	The last reception time

Definition at line 4061 of file rtp_engine.c.

{
    rtp->last_rx = time;
}

References ast_rtp_instance::last_rx.

Referenced by create_rtp(), media_session_rtcp_read_callback(), media_session_rtp_read_callback(), and rtp_check_timeout().

ast_rtp_instance_set_last_tx()

void ast_rtp_instance_set_last_tx	(	struct ast_rtp_instance *	rtp,
		time_t	time
	)

Set the last RTP transmission time.

Parameters

rtp	The instance on which to set the last transmission time
time	The last transmission time

Definition at line 4051 of file rtp_engine.c.

{
    rtp->last_tx = time;
}

References ast_rtp_instance::last_tx.

Referenced by __rtp_sendto().

ast_rtp_instance_set_local_address()

int ast_rtp_instance_set_local_address	(	struct ast_rtp_instance *	instance,
		const struct ast_sockaddr *	address
	)

Set the address that we are expecting to receive RTP on.

Parameters

instance	The RTP instance to change the address on
address	Address to set it to

Return values

0	success
-1	failure

Example usage:

ast_rtp_instance_set_local_address(instance, &sin);

This changes the local address that RTP is expected on to the address given in the sin structure.

Since

1.8

Definition at line 639 of file rtp_engine.c.

{
    ao2_lock(instance);
    ast_sockaddr_copy(&instance->local_address, address);
    ao2_unlock(instance);
    return 0;
}

References ao2_lock, ao2_unlock, ast_sockaddr_copy(), and ast_rtp_instance::local_address.

Referenced by ast_rtp_remote_address_set(), and rtp_allocate_transport().

ast_rtp_instance_set_prop()

void ast_rtp_instance_set_prop	(	struct ast_rtp_instance *	instance,
		enum ast_rtp_property	property,
		int	value
	)

Set the value of an RTP instance property.

Parameters

instance	The RTP instance to set the property on
property	The property to modify
value	The value to set the property to

Example usage:

ast_rtp_instance_set_prop(instance, AST_RTP_PROPERTY_NAT, 1);

This enables the AST_RTP_PROPERTY_NAT property on the instance pointed to by instance.

Since

1.8

Definition at line 756 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->properties[property] = value;
 
    if (instance->engine->prop_set) {
        instance->engine->prop_set(instance, property, value);
    }
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::prop_set, ast_rtp_instance::properties, and value.

Referenced by check_for_rtp_changes(), configure_local_rtp(), create_rtp(), enable_rtcp(), get_codecs(), jingle_alloc(), jingle_enable_video(), pjsip_acf_dtmf_mode_write(), start_rtp(), and test_init_rtp_instances().

ast_rtp_instance_set_qos()

int ast_rtp_instance_set_qos	(	struct ast_rtp_instance *	instance,
		int	tos,
		int	cos,
		const char *	desc
	)

Set QoS parameters on an RTP session.

Parameters

instance	Instance to set the QoS parameters on
tos	Terms of service value
cos	Class of service value
desc	What is setting the QoS values

Return values

0	success
-1	failure

Example usage:

ast_rtp_instance_set_qos(instance, 0, 0, "Example");

This sets the TOS and COS values to 0 on the instance pointed to by instance.

Since

1.8

Definition at line 2384 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->qos) {
        ao2_lock(instance);
        res = instance->engine->qos(instance, tos, cos, desc);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, cos, desc, ast_rtp_instance::engine, ast_rtp_engine::qos, and tos.

Referenced by configure_local_rtp(), create_rtp(), and start_rtp().

ast_rtp_instance_set_read_format()

int ast_rtp_instance_set_read_format	(	struct ast_rtp_instance *	instance,
		struct ast_format *	format
	)

Request that the underlying RTP engine provide audio frames in a specific format.

Parameters

instance	The RTP instance to change read format on
format	Format that frames are wanted in

Return values

0	success
-1	failure

Example usage:

struct ast_format tmp_fmt;
ast_rtp_instance_set_read_format(instance, ast_format_ulaw);

This requests that the RTP engine provide audio frames in the ULAW format.

Since

1.8

Definition at line 2805 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->set_read_format) {
        ao2_lock(instance);
        res = instance->engine->set_read_format(instance, format);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::set_read_format.

ast_rtp_instance_set_remote_ssrc()

void ast_rtp_instance_set_remote_ssrc	(	struct ast_rtp_instance *	rtp,
		unsigned int	ssrc
	)

Set the remote SSRC for an RTP instance.

Since

15.0.0

Parameters

rtp	The RTP instance
ssrc	The remote SSRC

Definition at line 4109 of file rtp_engine.c.

{
    ao2_lock(rtp);
    if (rtp->engine->set_remote_ssrc) {
        rtp->engine->set_remote_ssrc(rtp, ssrc);
    }
    ao2_unlock(rtp);
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::set_remote_ssrc.

Referenced by process_ssrc_attributes().

ast_rtp_instance_set_requested_target_address()

int ast_rtp_instance_set_requested_target_address	(	struct ast_rtp_instance *	instance,
		const struct ast_sockaddr *	address
	)

Set the requested target address of the remote endpoint.

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).

Parameters

instance	The RTP instance to change the address on
address	Address to set it to

Return values

0	success
-1	failure

Definition at line 667 of file rtp_engine.c.

{
    ao2_lock(instance);
 
    ast_sockaddr_copy(&instance->requested_target_address, address);
    rtp_instance_set_incoming_source_address_nolock(instance, address);
 
    ao2_unlock(instance);
 
    return 0;
}

References ao2_lock, ao2_unlock, ast_sockaddr_copy(), ast_rtp_instance::requested_target_address, and rtp_instance_set_incoming_source_address_nolock().

ast_rtp_instance_set_stats_vars()

void ast_rtp_instance_set_stats_vars	(	struct ast_channel *	chan,
		struct ast_rtp_instance *	instance
	)

Set standard statistics from an RTP instance on a channel.

Parameters

chan	Channel to set the statistics on
instance	The RTP instance that statistics will be retrieved from

Warning

Absolutely NO channel locks should be held before calling this function. If this channel is in a bridge, ast_rtp_instance_set_stats_vars() will attempt to lock the bridge peer as well as this channel. This can cause a lock inversion if we already have this channel locked and another thread tries to set bridge variables on the peer because it will have locked the peer first, then this channel. For this reason, we must NOT have the channel locked when we call ast_rtp_instance_set_stats_vars().

Example usage:

ast_rtp_instance_set_stats_vars(chan, rtp);

This retrieves standard statistics from the RTP instance rtp and sets it on the channel pointed to by chan.

Since

1.8

Definition at line 2758 of file rtp_engine.c.

{
    char quality_buf[AST_MAX_USER_FIELD];
    char *value;
    struct ast_channel *bridge;
    struct varshead *chanvars = ast_channel_varshead(chan);
    struct varshead *bridgevars = NULL;
    int chanchanges = 0;
    int bridgechanges = 0;
 
    bridge = ast_channel_bridge_peer(chan);
    if (bridge) {
        bridgevars = ast_channel_varshead(bridge);
        ast_channel_lock_both(chan, bridge);
        ast_channel_stage_snapshot(bridge);
    } else {
        ast_channel_lock(chan);
    }
    ast_channel_stage_snapshot(chan);
 
    SET_STATS_VAR_HELPER("RTPAUDIOQOS", AST_RTP_INSTANCE_STAT_FIELD_QUALITY);
 
    SET_STATS_VAR_HELPER("RTPAUDIOQOSJITTER", AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER);
 
    SET_STATS_VAR_HELPER("RTPAUDIOQOSLOSS", AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS);
 
    SET_STATS_VAR_HELPER("RTPAUDIOQOSRTT", AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT);
 
    SET_STATS_VAR_HELPER("RTPAUDIOQOSMES", AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES);
 
    if (chanchanges) {
        ast_channel_stage_snapshot_done(chan);
    } else {
        ast_clear_flag(ast_channel_flags(chan), AST_FLAG_SNAPSHOT_STAGE);
    }
    ast_channel_unlock(chan);
    if (bridge) {
        if (bridgechanges) {
            ast_channel_stage_snapshot_done(bridge);
        } else {
            ast_clear_flag(ast_channel_flags(bridge), AST_FLAG_SNAPSHOT_STAGE);
        }
        ast_channel_unlock(bridge);
        ast_channel_unref(bridge);
    }
}

References ast_channel_bridge_peer(), ast_channel_flags(), ast_channel_lock, ast_channel_lock_both, ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_channel_unlock, ast_channel_unref, ast_channel_varshead(), ast_clear_flag, AST_FLAG_SNAPSHOT_STAGE, AST_MAX_USER_FIELD, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_MES, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT, ast_channel::bridge, NULL, SET_STATS_VAR_HELPER, and value.

Referenced by ast_softhangup(), chan_pjsip_session_end(), and hangup().

ast_rtp_instance_set_stream_num()

void ast_rtp_instance_set_stream_num	(	struct ast_rtp_instance *	instance,
		int	stream_num
	)

Set the stream number for an RTP instance.

Since

15.0.0

Parameters

instance	The RTP instance
stream_num	The stream identifier number

Definition at line 4118 of file rtp_engine.c.

{
    ao2_lock(rtp);
    if (rtp->engine->set_stream_num) {
        rtp->engine->set_stream_num(rtp, stream_num);
    }
    ao2_unlock(rtp);
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::set_stream_num.

Referenced by apply_negotiated_sdp_stream().

ast_rtp_instance_set_timeout()

void ast_rtp_instance_set_timeout	(	struct ast_rtp_instance *	instance,
		int	timeout
	)

Set the RTP timeout value.

Parameters

instance	The RTP instance
timeout	Value to set the timeout to

Example usage:

ast_rtp_instance_set_timeout(instance, 5000);

This sets the RTP timeout value on 'instance' to be 5000.

Since

1.8

Definition at line 2915 of file rtp_engine.c.

{
    instance->timeout = timeout;
}

References ast_rtp_instance::timeout.

Referenced by apply_negotiated_sdp_stream(), and configure_local_rtp().

ast_rtp_instance_set_write_format()

int ast_rtp_instance_set_write_format	(	struct ast_rtp_instance *	instance,
		struct ast_format *	format
	)

Tell underlying RTP engine that audio frames will be provided in a specific format.

Parameters

instance	The RTP instance to change write format on
format	Format that frames will be provided in

Return values

0	success
-1	failure

Example usage:

struct ast_format tmp_fmt;
ast_rtp_instance_set_write_format(instance, ast_format_ulaw);

This tells the underlying RTP engine that audio frames will be provided to it in ULAW format.

Since

1.8

Definition at line 2819 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->set_read_format) {
        ao2_lock(instance);
        res = instance->engine->set_write_format(instance, format);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::set_read_format, and ast_rtp_engine::set_write_format.

ast_rtp_instance_stop()

void ast_rtp_instance_stop

(

struct ast_rtp_instance *

instance

)

Stop an RTP instance.

Parameters

instance

Instance that media is no longer going to at this time

Example usage:

ast_rtp_instance_stop(instance);

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.8

Definition at line 2398 of file rtp_engine.c.

{
    if (instance->engine->stop) {
        ao2_lock(instance);
        instance->engine->stop(instance);
        ao2_unlock(instance);
    }
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::stop.

Referenced by apply_negotiated_sdp_stream(), close_rtp_connection(), jingle_session_destructor(), ooh323_destroy(), stream_stop(), and unistim_hangup_clean().

ast_rtp_instance_stun_request()

void ast_rtp_instance_stun_request	(	struct ast_rtp_instance *	instance,
		struct ast_sockaddr *	suggestion,
		const char *	username
	)

Request that the underlying RTP engine send a STUN BIND request.

Parameters

instance	The RTP instance
suggestion	The suggested destination
username	Optionally a username for the request

Example usage:

ast_rtp_instance_stun_request(instance, NULL, NULL);

This requests that the RTP engine send a STUN BIND request on the session pointed to by 'instance'.

Since

1.8

Definition at line 2906 of file rtp_engine.c.

{
    if (instance->engine->stun_request) {
        instance->engine->stun_request(instance, suggestion, username);
    }
}

References ast_rtp_instance::engine, and ast_rtp_engine::stun_request.

Referenced by jingle_interpret_google_transport().

ast_rtp_instance_update_source()

void ast_rtp_instance_update_source

(

struct ast_rtp_instance *

instance

)

Indicate that the RTP marker bit should be set on an RTP stream.

Parameters

instance

Instance that the new media source is feeding into

Example usage:

ast_rtp_instance_update_source(instance);

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

Definition at line 2366 of file rtp_engine.c.

{
    if (instance->engine->update_source) {
        ao2_lock(instance);
        instance->engine->update_source(instance);
        ao2_unlock(instance);
    }
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::update_source.

Referenced by jingle_indicate(), and ooh323_indicate().

ast_rtp_instance_write()

int ast_rtp_instance_write	(	struct ast_rtp_instance *	instance,
		struct ast_frame *	frame
	)

Send a frame out over RTP.

Parameters

instance	The RTP instance to send frame out on
frame	the frame to send out

Return values

0	success
-1	failure

Example usage:

ast_rtp_instance_write(instance, frame);

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.8

Definition at line 619 of file rtp_engine.c.

{
    int res;
 
    ao2_lock(instance);
    res = instance->engine->write(instance, frame);
    ao2_unlock(instance);
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::write.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), chan_pjsip_indicate(), jingle_write(), media_session_rtp_write_callback(), ooh323_write(), rtp_write(), test_write_and_read_interleaved_frames(), test_write_frames(), and unistim_write().

ast_rtp_lookup_mime_multiple2()

char * ast_rtp_lookup_mime_multiple2	(	struct ast_str *	buf,
		struct ast_format_cap *	ast_format_capability,
		int	rtp_capability,
		const int	asterisk_format,
		enum ast_rtp_options	options
	)

Convert formats into a string and put them into a buffer.

Parameters

buf	Buffer to put the mime output into
ast_format_capability	Asterisk Formats we are looking up.
rtp_capability	RTP codes that we are looking up
asterisk_format	Non-zero if the ast_format_capability structure is to be used, 0 if rtp_capability is to be used
options	Additional options that may change the result

Return values

non-NULL	success
NULL	failure

Example usage:

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_ulaw, 0);
ast_format_cap_append(cap, ast_format_ulaw, 0);
char *mime = ast_rtp_lookup_mime_multiple2(&buf, sizeof(buf), cap, 0, 1, 0);
ast_format_cap_destroy(cap);

This returns the mime values for ULAW and ALAW in the buffer pointed to by buf.

Since

1.8

Definition at line 2260 of file rtp_engine.c.

{
    int found = 0;
    const char *name;
    if (!buf) {
        return NULL;
    }
 
 
    if (asterisk_format) {
        int x;
        struct ast_format *tmp_fmt;
        for (x = 0; x < ast_format_cap_count(ast_format_capability); x++) {
            tmp_fmt = ast_format_cap_get_format(ast_format_capability, x);
            name = ast_rtp_lookup_mime_subtype2(asterisk_format, tmp_fmt, 0, options);
            ao2_ref(tmp_fmt, -1);
            ast_str_append(&buf, 0, "%s|", name);
            found = 1;
        }
    } else {
        int x;
        ast_str_append(&buf, 0, "0x%x (", (unsigned int) rtp_capability);
        for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
            if (rtp_capability & x) {
                name = ast_rtp_lookup_mime_subtype2(asterisk_format, NULL, x, options);
                ast_str_append(&buf, 0, "%s|", name);
                found = 1;
            }
        }
    }
 
    ast_str_append(&buf, 0, "%s", found ? ")" : "nothing)");
 
    return ast_str_buffer(buf);
}

References ao2_ref, ast_format_cap_count(), ast_format_cap_get_format(), ast_rtp_lookup_mime_subtype2(), AST_RTP_MAX, ast_str_append(), ast_str_buffer(), ast_rtp_payload_type::asterisk_format, buf, name, NULL, and options.

ast_rtp_lookup_mime_subtype2()

const char * ast_rtp_lookup_mime_subtype2	(	const int	asterisk_format,
		const struct ast_format *	format,
		int	code,
		enum ast_rtp_options	options
	)

Retrieve mime subtype information on a payload.

Parameters

asterisk_format	Non-zero to look up using Asterisk format
format	Asterisk format to look up
code	RTP code to look up
options	Additional options that may change the result

Returns

Mime subtype success

Return values

NULL

failure

Example usage:

const char *subtype = ast_rtp_lookup_mime_subtype2(1, ast_format_ulaw, 0, 0);

This looks up the mime subtype for the ULAW format.

Since

1.8

Definition at line 2207 of file rtp_engine.c.

{
    int i;
    const char *res = "";
 
    ast_rwlock_rdlock(&mime_types_lock);
    for (i = 0; i < mime_types_len; i++) {
        if (ast_rtp_mime_types[i].payload_type.asterisk_format && asterisk_format && format &&
            (ast_format_cmp(format, ast_rtp_mime_types[i].payload_type.format) != AST_FORMAT_CMP_NOT_EQUAL)) {
            if ((ast_format_cmp(format, ast_format_g726_aal2) == AST_FORMAT_CMP_EQUAL) &&
                    (options & AST_RTP_OPT_G726_NONSTANDARD)) {
                res = "G726-32";
                break;
            } else {
                res = ast_rtp_mime_types[i].subtype;
                break;
            }
        } else if (!ast_rtp_mime_types[i].payload_type.asterisk_format && !asterisk_format &&
            ast_rtp_mime_types[i].payload_type.rtp_code == code) {
 
            res = ast_rtp_mime_types[i].subtype;
            break;
        }
    }
    ast_rwlock_unlock(&mime_types_lock);
 
    return res;
}

References ast_format_cmp(), AST_FORMAT_CMP_EQUAL, AST_FORMAT_CMP_NOT_EQUAL, ast_format_g726_aal2, ast_rtp_mime_types, AST_RTP_OPT_G726_NONSTANDARD, ast_rwlock_rdlock, ast_rwlock_unlock, ast_rtp_payload_type::asterisk_format, ast_rtp_payload_type::format, mime_types_len, mime_types_lock, options, ast_rtp_mime_type::payload_type, ast_rtp_payload_type::rtp_code, and ast_rtp_mime_type::subtype.

Referenced by ast_rtp_lookup_mime_multiple2(), generate_rtpmap_attr(), generate_rtpmap_attr2(), and jingle_add_payloads_to_description().

ast_rtp_lookup_sample_rate2()

unsigned int ast_rtp_lookup_sample_rate2	(	int	asterisk_format,
		const struct ast_format *	format,
		int	code
	)

Get the sample rate associated with known RTP payload types.

Parameters

asterisk_format	True if the value in format is to be used.
format	An asterisk format
code	from AST_RTP list

Returns

the sample rate if the format was found, zero if it was not found

Since

1.8

Definition at line 2237 of file rtp_engine.c.

{
    unsigned int i;
    unsigned int res = 0;
 
    ast_rwlock_rdlock(&mime_types_lock);
    for (i = 0; i < mime_types_len; ++i) {
        if (ast_rtp_mime_types[i].payload_type.asterisk_format && asterisk_format && format &&
            (ast_format_cmp(format, ast_rtp_mime_types[i].payload_type.format) != AST_FORMAT_CMP_NOT_EQUAL)) {
            res = ast_rtp_mime_types[i].sample_rate;
            break;
        } else if (!ast_rtp_mime_types[i].payload_type.asterisk_format && !asterisk_format &&
            ast_rtp_mime_types[i].payload_type.rtp_code == code) {
            res = ast_rtp_mime_types[i].sample_rate;
            break;
        }
    }
    ast_rwlock_unlock(&mime_types_lock);
 
    return res;
}

References ast_format_cmp(), AST_FORMAT_CMP_NOT_EQUAL, ast_rtp_mime_types, ast_rwlock_rdlock, ast_rwlock_unlock, ast_rtp_payload_type::asterisk_format, ast_rtp_payload_type::format, mime_types_len, mime_types_lock, ast_rtp_mime_type::payload_type, ast_rtp_payload_type::rtp_code, and ast_rtp_mime_type::sample_rate.

Referenced by create_outgoing_sdp_stream(), generate_rtpmap_attr(), and jingle_add_payloads_to_description().

ast_rtp_payload_mapping_tx_is_present()

int ast_rtp_payload_mapping_tx_is_present	(	struct ast_rtp_codecs *	codecs,
		const struct ast_rtp_payload_type *	to_match
	)

Determine if a type of payload is already present in mappings.

Since

18

Parameters

codecs	Codecs to be checked for mappings.
to_match	Payload type object to compare against.

Note

It is assumed that codecs is not locked before calling.

Return values

0	not found
1	found

Definition at line 1249 of file rtp_engine.c.

                                                                                                                      {
    int ret = 0;
    if (codecs && to_match) {
        ast_rwlock_rdlock(&codecs->codecs_lock);
        ret = payload_mapping_tx_is_present(codecs, to_match);
        ast_rwlock_unlock(&codecs->codecs_lock);
    }
    return ret;
}

References ast_rwlock_rdlock, ast_rwlock_unlock, codecs, and payload_mapping_tx_is_present().

Referenced by ast_rtp_dtmf_begin().

ast_rtp_publish_rtcp_message()

void ast_rtp_publish_rtcp_message	(	struct ast_rtp_instance *	rtp,
		struct stasis_message_type *	message_type,
		struct ast_rtp_rtcp_report *	report,
		struct ast_json *	blob
	)

Publish an RTCP message to Stasis Message Bus API.

Since

12

Parameters

rtp	The rtp instance object
message_type	The RTP message type to publish
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.
blob	Additional JSON objects to publish along with the RTCP information

Definition at line 3745 of file rtp_engine.c.

{
    RAII_VAR(struct rtcp_message_payload *, payload, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
 
    if (!message_type) {
        return;
    }
 
    payload = ao2_alloc(sizeof(*payload), rtcp_message_payload_dtor);
    if (!payload || !report) {
        return;
    }
 
    if (!ast_strlen_zero(rtp->channel_uniqueid)) {
        payload->snapshot = ast_channel_snapshot_get_latest(rtp->channel_uniqueid);
    }
    if (blob) {
        payload->blob = blob;
        ast_json_ref(blob);
    }
    ao2_ref(report, +1);
    payload->report = report;
 
    message = stasis_message_create(message_type, payload);
    if (!message) {
        return;
    }
 
    stasis_publish(ast_rtp_topic(), message);
}

References ao2_alloc, ao2_cleanup, ao2_ref, ast_channel_snapshot_get_latest(), ast_json_ref(), ast_rtp_topic(), ast_strlen_zero(), ast_rtp_instance::channel_uniqueid, NULL, RAII_VAR, rtcp_message_payload_dtor(), stasis_message_create(), and stasis_publish().

Referenced by ast_rtcp_calculate_sr_rr_statistics(), and ast_rtcp_interpret().

ast_rtp_red_buffer()

int ast_rtp_red_buffer	(	struct ast_rtp_instance *	instance,
		struct ast_frame *	frame
	)

Buffer a frame in an RTP instance for RED.

Parameters

instance	The instance to buffer the frame on
frame	Frame that we want to buffer

Return values

0	success
-1	failure

Since

1.8

Definition at line 2647 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->red_buffer) {
        ao2_lock(instance);
        res = instance->engine->red_buffer(instance, frame);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::red_buffer.

ast_rtp_red_init()

int ast_rtp_red_init	(	struct ast_rtp_instance *	instance,
		int	buffer_time,
		int *	payloads,
		int	generations
	)

Initialize RED support on an RTP instance.

Parameters

instance	The instance to initialize RED support on
buffer_time	How long to buffer before sending
payloads	Payload values
generations	Number of generations

Return values

0	success
-1	failure

Since

1.8

Definition at line 2633 of file rtp_engine.c.

{
    int res;
 
    if (instance->engine->red_init) {
        ao2_lock(instance);
        res = instance->engine->red_init(instance, buffer_time, payloads, generations);
        ao2_unlock(instance);
    } else {
        res = -1;
    }
    return res;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::red_init.

ast_rtp_rtcp_report_alloc()

struct ast_rtp_rtcp_report * ast_rtp_rtcp_report_alloc

(

unsigned int

report_blocks

)

Allocate an ao2 ref counted instance of ast_rtp_rtcp_report.

Parameters

report_blocks

The number of report blocks to allocate

Returns

An ao2 ref counted ast_rtp_rtcp_report object on success

Return values

NULL

on error

Definition at line 3734 of file rtp_engine.c.

{
    struct ast_rtp_rtcp_report *rtcp_report;
 
    /* Size of object is sizeof the report + the number of report_blocks * sizeof pointer */
    rtcp_report = ao2_alloc((sizeof(*rtcp_report) + report_blocks * sizeof(struct ast_rtp_rtcp_report_block *)),
        rtp_rtcp_report_dtor);
 
    return rtcp_report;
}

References ao2_alloc, and rtp_rtcp_report_dtor().

Referenced by ast_rtcp_interpret(), ast_rtcp_write(), ast_rtp_read(), rtp_write_rtcp_fir(), and rtp_write_rtcp_psfb().

ast_rtp_topic()

struct stasis_topic * ast_rtp_topic

(

void

)

Stasis Message Bus API topic for RTP and RTCP related messages

Since

12

Returns

A Stasis Message Bus API topic

Definition at line 3791 of file rtp_engine.c.

{
    return rtp_topic;
}

References rtp_topic.

Referenced by ast_rtp_publish_rtcp_message(), load_module(), and manager_subscriptions_init().

find_static_payload_type()

static int find_static_payload_type ( int  asterisk_format, const struct ast_format *  format, int  code  )

static

Definition at line 1766 of file rtp_engine.c.

{
    int idx;
    int payload = -1;
 
    if (!asterisk_format) {
        for (idx = 0; idx < AST_RTP_MAX_PT; ++idx) {
            if (static_RTP_PT[idx]
                && !static_RTP_PT[idx]->asterisk_format
                && static_RTP_PT[idx]->rtp_code == code) {
                payload = idx;
                break;
            }
        }
    } else if (format) {
        for (idx = 0; idx < AST_RTP_MAX_PT; ++idx) {
            if (static_RTP_PT[idx]
                && static_RTP_PT[idx]->asterisk_format
                && ast_format_cmp(format, static_RTP_PT[idx]->format)
                    != AST_FORMAT_CMP_NOT_EQUAL) {
                payload = idx;
                break;
            }
        }
    }
 
    return payload;
}

References ast_format_cmp(), AST_FORMAT_CMP_NOT_EQUAL, AST_RTP_MAX_PT, ast_rtp_payload_type::asterisk_format, ast_rtp_payload_type::format, ast_rtp_payload_type::payload, ast_rtp_payload_type::rtp_code, and static_RTP_PT.

Referenced by ast_rtp_codecs_payload_code_tx_sample_rate(), and rtp_codecs_assign_payload_code_rx().

find_unused_payload()

static int find_unused_payload ( const struct ast_rtp_codecs *  codecs )

static

Definition at line 1843 of file rtp_engine.c.

{
    int res;
 
    /* find next available dynamic payload slot */
    res = find_unused_payload_in_range(
        codecs, AST_RTP_PT_FIRST_DYNAMIC, AST_RTP_MAX_PT, static_RTP_PT);
    if (res != -1) {
        return res;
    }
 
    if (ast_option_rtpusedynamic) {
        /*
         * We're using default values for some dynamic types. So if an unused
         * slot was not found try again, but this time ignore the default
         * values declared for dynamic types (except for 101 and 121) .
         */
        static struct ast_rtp_payload_type *ignore[AST_RTP_MAX_PT] = {0};
 
        ignore[101] = static_RTP_PT[101];
        ignore[121] = static_RTP_PT[121];
 
        res = find_unused_payload_in_range(
            codecs, AST_RTP_PT_FIRST_DYNAMIC, AST_RTP_MAX_PT, ignore);
        if (res != -1) {
            return res;
        }
    }
 
    /* http://www.iana.org/assignments/rtp-parameters
     * RFC 3551, Section 3: "[...] applications which need to define more
     * than 32 dynamic payload types MAY bind codes below 96, in which case
     * it is RECOMMENDED that unassigned payload type numbers be used
     * first". Updated by RFC 5761, Section 4: "[...] values in the range
     * 64-95 MUST NOT be used [to avoid conflicts with RTCP]". Summaries:
     * https://tools.ietf.org/html/draft-roach-mmusic-unified-plan#section-3.2.1.2
     * https://tools.ietf.org/html/draft-wu-avtcore-dynamic-pt-usage#section-3
     */
    res = find_unused_payload_in_range(
        codecs, MAX(ast_option_rtpptdynamic, AST_RTP_PT_LAST_STATIC + 1),
        AST_RTP_PT_LAST_REASSIGN, static_RTP_PT);
    if (res != -1) {
        return res;
    }
 
    /* Yet, reusing mappings below AST_RTP_PT_LAST_STATIC (35) is not supported
     * in Asterisk because when Compact Headers are activated, no rtpmap is
     * send for those below 35. If you want to use 35 and below
     * A) do not use Compact Headers,
     * B) remove that code in res_pjsip, or
     * C) add a flag that this RTP Payload Type got reassigned dynamically
     *    and requires a rtpmap even with Compact Headers enabled.
     */
    res = find_unused_payload_in_range(
        codecs, MAX(ast_option_rtpptdynamic, 20),
        AST_RTP_PT_LAST_STATIC + 1, static_RTP_PT);
    if (res != -1) {
        return res;
    }
 
    return find_unused_payload_in_range(
        codecs, MAX(ast_option_rtpptdynamic, 0),
        20, static_RTP_PT);
}

References ast_option_rtpptdynamic, ast_option_rtpusedynamic, AST_RTP_MAX_PT, AST_RTP_PT_FIRST_DYNAMIC, AST_RTP_PT_LAST_REASSIGN, AST_RTP_PT_LAST_STATIC, codecs, find_unused_payload_in_range(), MAX, and static_RTP_PT.

Referenced by add_static_payload(), and rtp_codecs_assign_payload_code_rx().

find_unused_payload_in_range()

static int find_unused_payload_in_range ( const struct ast_rtp_codecs *  codecs, int  start, int  end, struct ast_rtp_payload_type *  ignore[]  )

static

Definition at line 1809 of file rtp_engine.c.

{
    int x;
 
    for (x = start; x < end; ++x) {
        struct ast_rtp_payload_type *type;
 
        if (ignore[x]) {
            continue;
        } else if (!codecs || x >= AST_VECTOR_SIZE(&codecs->payload_mapping_rx)) {
            return x;
        }
 
        type = AST_VECTOR_GET(&codecs->payload_mapping_rx, x);
        if (!type) {
            return x;
        }
    }
    return -1;
}

References AST_VECTOR_GET, AST_VECTOR_SIZE, codecs, end, and type.

Referenced by find_unused_payload(), and rtp_codecs_assign_payload_code_rx().

instance_destructor()

static void instance_destructor ( void *  obj )

static

Definition at line 433 of file rtp_engine.c.

{
    struct ast_rtp_instance *instance = obj;
 
    /* Pass us off to the engine to destroy */
    if (instance->data) {
        /*
         * Lock in case the RTP engine has other threads that
         * need synchronization with the destruction.
         */
        ao2_lock(instance);
        instance->engine->destroy(instance);
        ao2_unlock(instance);
    }
 
    if (instance->srtp) {
        res_srtp->destroy(instance->srtp);
    }
 
    if (instance->rtcp_srtp) {
        res_srtp->destroy(instance->rtcp_srtp);
    }
 
    ast_rtp_codecs_payloads_destroy(&instance->codecs);
 
    AST_VECTOR_FREE(&instance->extmap_enabled);
    AST_VECTOR_FREE(&instance->extmap_negotiated);
    AST_VECTOR_FREE(&instance->extmap_unique_ids);
 
    /* Drop our engine reference */
    ast_module_unref(instance->engine->mod);
 
    ast_debug(1, "Destroyed RTP instance '%p'\n", instance);
}

References ao2_lock, ao2_unlock, ast_debug, ast_module_unref, ast_rtp_codecs_payloads_destroy(), AST_VECTOR_FREE, ast_rtp_instance::codecs, ast_rtp_instance::data, ast_rtp_engine::destroy, ast_srtp_res::destroy, ast_rtp_instance::engine, ast_rtp_instance::extmap_enabled, ast_rtp_instance::extmap_negotiated, ast_rtp_instance::extmap_unique_ids, ast_rtp_engine::mod, res_srtp, ast_rtp_instance::rtcp_srtp, and ast_rtp_instance::srtp.

Referenced by ast_rtp_instance_new_with_options().

payload_mapping_rx_clear_primary()

static void payload_mapping_rx_clear_primary ( struct ast_rtp_codecs *  codecs, struct ast_rtp_payload_type *  to_match  )

static

Definition at line 1074 of file rtp_engine.c.

{
    int idx;
    struct ast_rtp_payload_type *current;
    struct ast_rtp_payload_type *new_type;
    struct timeval now;
 
    if (!to_match->primary_mapping) {
        return;
    }
 
    now = ast_tvnow();
    for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
        current = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
 
        if (!current || current == to_match || !current->primary_mapping) {
            continue;
        }
        if (current->asterisk_format && to_match->asterisk_format) {
            if (ast_format_cmp(current->format, to_match->format) == AST_FORMAT_CMP_NOT_EQUAL) {
                continue;
            }
        } else if (!current->asterisk_format && !to_match->asterisk_format) {
            if (current->rtp_code != to_match->rtp_code) {
                continue;
            }
        } else {
            continue;
        }
 
        /* Replace current with non-primary marked version */
        new_type = ast_rtp_engine_alloc_payload_type();
        if (!new_type) {
            continue;
        }
        *new_type = *current;
        new_type->primary_mapping = 0;
        new_type->when_retired = now;
        ao2_bump(new_type->format);
        AST_VECTOR_REPLACE(&codecs->payload_mapping_rx, idx, new_type);
        ao2_ref(current, -1);
    }
}

References ao2_bump, ao2_ref, ast_format_cmp(), AST_FORMAT_CMP_NOT_EQUAL, ast_rtp_engine_alloc_payload_type(), ast_tvnow(), AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, ast_rtp_payload_type::asterisk_format, codecs, current, ast_rtp_payload_type::format, ast_rtp_payload_type::primary_mapping, and ast_rtp_payload_type::rtp_code.

Referenced by rtp_codecs_payload_set_rx().

payload_mapping_tx_is_present()

static int payload_mapping_tx_is_present ( const struct ast_rtp_codecs *  codecs, const struct ast_rtp_payload_type *  to_match  )

static

Definition at line 1211 of file rtp_engine.c.

{
    int idx;
    struct ast_rtp_payload_type *current;
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_tx); ++idx) {
        current = AST_VECTOR_GET(&codecs->payload_mapping_tx, idx);
 
        if (!current) {
            continue;
        }
        if (current == to_match) {
            /* The exact object is already in the mapping. */
            return 1;
        }
        if (current->asterisk_format && to_match->asterisk_format) {
            if (ast_format_get_codec_id(current->format) != ast_format_get_codec_id(to_match->format)) {
                continue;
            } else if (current->payload == to_match->payload) {
                return 0;
            }
        } else if (!current->asterisk_format && !to_match->asterisk_format) {
            if (current->rtp_code != to_match->rtp_code) {
                continue;
            } else if (to_match->rtp_code == AST_RTP_DTMF && current->sample_rate != to_match->sample_rate) {
                /* it is possible for multiple DTMF types to exist with different sample rates */
                continue;
            }
        } else {
            continue;
        }
 
        return 1;
    }
 
    return 0;
}

References ast_format_get_codec_id(), AST_RTP_DTMF, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_rtp_payload_type::asterisk_format, codecs, current, ast_rtp_payload_type::format, ast_rtp_payload_type::payload, ast_rtp_payload_type::rtp_code, and ast_rtp_payload_type::sample_rate.

Referenced by ast_rtp_codecs_payload_replace_format(), ast_rtp_codecs_payloads_set_m_type(), ast_rtp_codecs_payloads_set_rtpmap_type_rate(), and ast_rtp_payload_mapping_tx_is_present().

rtcp_message_payload_dtor()

static void rtcp_message_payload_dtor ( void *  obj )

static

Definition at line 3543 of file rtp_engine.c.

{
    struct rtcp_message_payload *payload = obj;
 
    ao2_cleanup(payload->report);
    ao2_cleanup(payload->snapshot);
    ast_json_unref(payload->blob);
}

References ao2_cleanup, ast_json_unref(), rtcp_message_payload::blob, rtcp_message_payload::report, and rtcp_message_payload::snapshot.

Referenced by ast_rtp_publish_rtcp_message().

rtcp_report_to_ami()

static struct ast_manager_event_blob * rtcp_report_to_ami ( struct stasis_message *  msg )

static

Definition at line 3552 of file rtp_engine.c.

{
    struct rtcp_message_payload *payload = stasis_message_data(msg);
    RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
    RAII_VAR(struct ast_str *, packet_string, ast_str_create(512), ast_free);
    unsigned int ssrc = payload->report->ssrc;
    unsigned int type = payload->report->type;
    unsigned int report_count = payload->report->reception_report_count;
    int i;
 
    if (!packet_string) {
        return NULL;
    }
 
    if (payload->snapshot) {
        channel_string = ast_manager_build_channel_state_string(payload->snapshot);
        if (!channel_string) {
            return NULL;
        }
    }
 
    if (payload->blob) {
        /* Optional data */
        struct ast_json *to = ast_json_object_get(payload->blob, "to");
        struct ast_json *from = ast_json_object_get(payload->blob, "from");
        struct ast_json *rtt = ast_json_object_get(payload->blob, "rtt");
        struct ast_json *mes = ast_json_object_get(payload->blob, "mes");
        if (to) {
            ast_str_append(&packet_string, 0, "To: %s\r\n", ast_json_string_get(to));
        }
        if (from) {
            ast_str_append(&packet_string, 0, "From: %s\r\n", ast_json_string_get(from));
        }
        if (rtt) {
            ast_str_append(&packet_string, 0, "RTT: %4.4f\r\n", ast_json_real_get(rtt));
        }
        if (mes) {
            ast_str_append(&packet_string, 0, "MES: %4.1f\r\n", ast_json_real_get(mes));
        }
    }
 
    ast_str_append(&packet_string, 0, "SSRC: 0x%.8x\r\n", ssrc);
    ast_str_append(&packet_string, 0, "PT: %u(%s)\r\n", type, type== AST_RTP_RTCP_SR ? "SR" : "RR");
    ast_str_append(&packet_string, 0, "ReportCount: %u\r\n", report_count);
    if (type == AST_RTP_RTCP_SR) {
        ast_str_append(&packet_string, 0, "SentNTP: %lu.%06lu\r\n",
            (unsigned long)payload->report->sender_information.ntp_timestamp.tv_sec,
            (unsigned long)payload->report->sender_information.ntp_timestamp.tv_usec);
        ast_str_append(&packet_string, 0, "SentRTP: %u\r\n",
                payload->report->sender_information.rtp_timestamp);
        ast_str_append(&packet_string, 0, "SentPackets: %u\r\n",
                payload->report->sender_information.packet_count);
        ast_str_append(&packet_string, 0, "SentOctets: %u\r\n",
                payload->report->sender_information.octet_count);
    }
 
    for (i = 0; i < report_count; i++) {
        RAII_VAR(struct ast_str *, report_string, NULL, ast_free);
 
        if (!payload->report->report_block[i]) {
            break;
        }
 
        report_string = ast_str_create(256);
        if (!report_string) {
            return NULL;
        }
 
        ast_str_append(&report_string, 0, "Report%dSourceSSRC: 0x%.8x\r\n",
                i, payload->report->report_block[i]->source_ssrc);
        ast_str_append(&report_string, 0, "Report%dFractionLost: %d\r\n",
                i, payload->report->report_block[i]->lost_count.fraction);
        ast_str_append(&report_string, 0, "Report%dCumulativeLost: %u\r\n",
                i, payload->report->report_block[i]->lost_count.packets);
        ast_str_append(&report_string, 0, "Report%dHighestSequence: %u\r\n",
                i, payload->report->report_block[i]->highest_seq_no & 0xffff);
        ast_str_append(&report_string, 0, "Report%dSequenceNumberCycles: %u\r\n",
                i, payload->report->report_block[i]->highest_seq_no >> 16);
        ast_str_append(&report_string, 0, "Report%dIAJitter: %u\r\n",
                i, payload->report->report_block[i]->ia_jitter);
        ast_str_append(&report_string, 0, "Report%dLSR: %u\r\n",
                i, payload->report->report_block[i]->lsr);
        ast_str_append(&report_string, 0, "Report%dDLSR: %4.4f\r\n",
                i, ((double)payload->report->report_block[i]->dlsr) / 65536);
        ast_str_append(&packet_string, 0, "%s", ast_str_buffer(report_string));
    }
 
    return ast_manager_event_blob_create(EVENT_FLAG_REPORTING,
        stasis_message_type(msg) == ast_rtp_rtcp_received_type() ? "RTCPReceived" : "RTCPSent",
        "%s%s",
        AS_OR(channel_string, ""),
        ast_str_buffer(packet_string));
}

References AS_OR, ast_free, ast_json_object_get(), ast_json_real_get(), ast_json_string_get(), ast_manager_build_channel_state_string(), ast_manager_event_blob_create(), ast_rtp_rtcp_received_type(), AST_RTP_RTCP_SR, ast_str_append(), ast_str_buffer(), ast_str_create, rtcp_message_payload::blob, ast_rtp_rtcp_report_block::dlsr, EVENT_FLAG_REPORTING, ast_rtp_rtcp_report_block::fraction, ast_rtp_rtcp_report_block::highest_seq_no, ast_rtp_rtcp_report_block::ia_jitter, ast_rtp_rtcp_report_block::lost_count, ast_rtp_rtcp_report_block::lsr, ast_rtp_rtcp_report::ntp_timestamp, NULL, ast_rtp_rtcp_report::octet_count, ast_rtp_rtcp_report::packet_count, ast_rtp_rtcp_report_block::packets, RAII_VAR, ast_rtp_rtcp_report::reception_report_count, rtcp_message_payload::report, ast_rtp_rtcp_report::report_block, ast_rtp_rtcp_report::rtp_timestamp, ast_rtp_rtcp_report::sender_information, rtcp_message_payload::snapshot, ast_rtp_rtcp_report_block::source_ssrc, ast_rtp_rtcp_report::ssrc, stasis_message_data(), type, and ast_rtp_rtcp_report::type.

rtcp_report_to_json()

static struct ast_json * rtcp_report_to_json ( struct stasis_message *  msg, const struct stasis_message_sanitizer *  sanitize  )

static

Definition at line 3646 of file rtp_engine.c.

{
    struct rtcp_message_payload *payload = stasis_message_data(msg);
    struct ast_json *json_rtcp_report = NULL;
    struct ast_json *json_rtcp_report_blocks;
    struct ast_json *json_rtcp_sender_info = NULL;
    struct ast_json *json_channel = NULL;
    int i;
 
    json_rtcp_report_blocks = ast_json_array_create();
    if (!json_rtcp_report_blocks) {
        return NULL;
    }
 
    for (i = 0; i < payload->report->reception_report_count && payload->report->report_block[i]; i++) {
        struct ast_json *json_report_block;
        char str_lsr[32];
 
        snprintf(str_lsr, sizeof(str_lsr), "%u", payload->report->report_block[i]->lsr);
        json_report_block = ast_json_pack("{s: I, s: I, s: I, s: I, s: I, s: s, s: I}",
            "source_ssrc", (ast_json_int_t)payload->report->report_block[i]->source_ssrc,
            "fraction_lost", (ast_json_int_t)payload->report->report_block[i]->lost_count.fraction,
            "packets_lost", (ast_json_int_t)payload->report->report_block[i]->lost_count.packets,
            "highest_seq_no", (ast_json_int_t)payload->report->report_block[i]->highest_seq_no,
            "ia_jitter", (ast_json_int_t)payload->report->report_block[i]->ia_jitter,
            "lsr", str_lsr,
            "dlsr", (ast_json_int_t)payload->report->report_block[i]->dlsr);
        if (!json_report_block
            || ast_json_array_append(json_rtcp_report_blocks, json_report_block)) {
            ast_json_unref(json_rtcp_report_blocks);
            return NULL;
        }
    }
 
    if (payload->report->type == AST_RTP_RTCP_SR) {
        char sec[32];
        char usec[32];
 
        snprintf(sec, sizeof(sec), "%lu", (unsigned long)payload->report->sender_information.ntp_timestamp.tv_sec);
        snprintf(usec, sizeof(usec), "%lu", (unsigned long)payload->report->sender_information.ntp_timestamp.tv_usec);
        json_rtcp_sender_info = ast_json_pack("{s: s, s: s, s: I, s: I, s: I}",
            "ntp_timestamp_sec", sec,
            "ntp_timestamp_usec", usec,
            "rtp_timestamp", (ast_json_int_t)payload->report->sender_information.rtp_timestamp,
            "packets", (ast_json_int_t)payload->report->sender_information.packet_count,
            "octets", (ast_json_int_t)payload->report->sender_information.octet_count);
        if (!json_rtcp_sender_info) {
            ast_json_unref(json_rtcp_report_blocks);
            return NULL;
        }
    }
 
    json_rtcp_report = ast_json_pack("{s: I, s: I, s: i, s: o, s: o}",
        "ssrc", (ast_json_int_t)payload->report->ssrc,
        "type", (ast_json_int_t)payload->report->type,
        "report_count", payload->report->reception_report_count,
        "sender_information", json_rtcp_sender_info ?: ast_json_null(),
        "report_blocks", json_rtcp_report_blocks);
    if (!json_rtcp_report) {
        return NULL;
    }
 
    if (payload->snapshot) {
        json_channel = ast_channel_snapshot_to_json(payload->snapshot, sanitize);
        if (!json_channel) {
            ast_json_unref(json_rtcp_report);
            return NULL;
        }
    }
 
    return ast_json_pack("{s: s, s: o?, s: o, s: O?}",
        "type", stasis_message_type(msg) == ast_rtp_rtcp_received_type() ? "RTCPReceived" : "RTCPSent",
        "channel", json_channel,
        "rtcp_report", json_rtcp_report,
        "blob", payload->blob);
}

References ast_channel_snapshot_to_json(), ast_json_array_append(), ast_json_array_create(), ast_json_null(), ast_json_pack(), ast_json_unref(), ast_rtp_rtcp_received_type(), AST_RTP_RTCP_SR, rtcp_message_payload::blob, ast_rtp_rtcp_report_block::dlsr, ast_rtp_rtcp_report_block::fraction, ast_rtp_rtcp_report_block::highest_seq_no, ast_rtp_rtcp_report_block::ia_jitter, ast_rtp_rtcp_report_block::lost_count, ast_rtp_rtcp_report_block::lsr, ast_rtp_rtcp_report::ntp_timestamp, NULL, ast_rtp_rtcp_report::octet_count, ast_rtp_rtcp_report::packet_count, ast_rtp_rtcp_report_block::packets, ast_rtp_rtcp_report::reception_report_count, rtcp_message_payload::report, ast_rtp_rtcp_report::report_block, ast_rtp_rtcp_report::rtp_timestamp, ast_rtp_rtcp_report::sender_information, rtcp_message_payload::snapshot, ast_rtp_rtcp_report_block::source_ssrc, ast_rtp_rtcp_report::ssrc, stasis_message_data(), and ast_rtp_rtcp_report::type.

rtp_codecs_assign_payload_code_rx()

static int rtp_codecs_assign_payload_code_rx ( struct ast_rtp_codecs *  codecs, int  asterisk_format, struct ast_format *  format, int  code, int  explicit, unsigned int  sample_rate  )

static

Definition at line 1957 of file rtp_engine.c.

{
    int payload = code, i;
    struct ast_rtp_payload_type *new_type;
    static struct ast_rtp_payload_type *ignore[AST_RTP_MAX_PT] = {0};
 
    if (!explicit) {
        payload = find_static_payload_type(asterisk_format, format, code);
 
        if (payload < 0 && (!asterisk_format || !ast_option_rtpusedynamic)) {
            return payload;
        }
    }
 
    new_type = rtp_payload_type_alloc(format, payload, code, 1, sample_rate);
    if (!new_type) {
        return -1;
    }
 
    ast_rwlock_wrlock(&codecs->codecs_lock);
 
    /* Go through the existing mapping to create an ignore list. */
    for (i = 0; i < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); i++) {
        if (AST_VECTOR_GET(&codecs->payload_mapping_rx, i)) {
            ignore[i] = static_RTP_PT[i];
        }
    }
 
 
    if (payload > -1 && (payload < AST_RTP_PT_FIRST_DYNAMIC
        || AST_VECTOR_SIZE(&codecs->payload_mapping_rx) <= payload
        || !AST_VECTOR_GET(&codecs->payload_mapping_rx, payload))) {
 
        /*
         * The payload type is a static assignment
         * or our default dynamic position is available.
         */
        rtp_codecs_payload_replace_rx(codecs, payload, new_type);
    } else if (payload > -1 && !explicit
                /* We can either call this with the full list or the current rx list. The former
                 * (static_RTP_PT) results in payload types skipping statically 'used' slots so you
                 * get 101, 113...
                 * With the latter (the built ignore list) you get what's expected 101, 102, 103 under
                 * most circumstances, but this results in static types being replaced.  Probably fine
                 * because we preclude the current list.
                 */
                && (-1 < (payload = find_unused_payload_in_range(codecs, payload, AST_RTP_MAX_PT, ignore)))) {
        /*
         * Our dynamic position is currently in use.
         * Try for the numerically next free one before trying
         * across the full range. This keeps the payload id's
         * in the best numerical order we can through the free
         * types.
         */
        new_type->payload = payload;
        /*
         * In this case, consider this the primary mapping for
         * the payload type so don't clear it. Set not replace.
         */
        rtp_codecs_payload_set_rx(codecs, payload, new_type, 0);
    } else if (!explicit && (-1 < (payload = find_unused_payload(codecs))
            || -1 < (payload = rtp_codecs_find_non_primary_dynamic_rx(codecs)))) {
        /*
         * We found the first available empty dynamic position
         * or we found a mapping that should no longer be
         * actively used.
         */
        new_type->payload = payload;
        rtp_codecs_payload_replace_rx(codecs, payload, new_type);
    } else if (explicit) {
        /*
        * They explicitly requested this payload number be used but it couldn't be
        */
        payload = -1;
    } else {
        /*
         * There are no empty or non-primary dynamic positions
         * left.  Sadness.
         *
         * I don't think this is really possible.
         */
        ast_log(LOG_WARNING, "No dynamic RTP payload type values available "
            "for %s - %d!\n", format ? ast_format_get_name(format) : "", code);
    }
    ast_rwlock_unlock(&codecs->codecs_lock);
 
    ao2_ref(new_type, -1);
 
    return payload;
}

References ao2_ref, ast_format_get_name(), ast_log, ast_option_rtpusedynamic, AST_RTP_MAX_PT, AST_RTP_PT_FIRST_DYNAMIC, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_rtp_payload_type::asterisk_format, codecs, find_static_payload_type(), find_unused_payload(), find_unused_payload_in_range(), ast_rtp_payload_type::format, LOG_WARNING, ast_rtp_payload_type::payload, rtp_codecs_find_non_primary_dynamic_rx(), rtp_codecs_payload_replace_rx(), rtp_codecs_payload_set_rx(), rtp_payload_type_alloc(), ast_rtp_payload_type::sample_rate, and static_RTP_PT.

Referenced by ast_rtp_codecs_payload_code_sample_rate(), ast_rtp_codecs_payload_set_rx(), and ast_rtp_codecs_payload_set_rx_sample_rate().

rtp_codecs_find_non_primary_dynamic_rx()

static int rtp_codecs_find_non_primary_dynamic_rx ( struct ast_rtp_codecs *  codecs )

static

Definition at line 1920 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type;
    struct timeval oldest;
    int idx;
    int payload = -1;
 
    idx = AST_RTP_PT_FIRST_DYNAMIC;
    for (; idx < AST_VECTOR_SIZE(&codecs->payload_mapping_rx); ++idx) {
        type = AST_VECTOR_GET(&codecs->payload_mapping_rx, idx);
        if (type
            && !type->primary_mapping
            && (payload == -1
                || ast_tvdiff_ms(type->when_retired, oldest) < 0)) {
            oldest = type->when_retired;
            payload = idx;
        }
    }
    return payload;
}

References AST_RTP_PT_FIRST_DYNAMIC, ast_tvdiff_ms(), AST_VECTOR_GET, AST_VECTOR_SIZE, codecs, and type.

Referenced by rtp_codecs_assign_payload_code_rx().

rtp_codecs_payload_replace_rx()

static void rtp_codecs_payload_replace_rx ( struct ast_rtp_codecs *  codecs, int  payload, struct ast_rtp_payload_type *  new_type  )

static

Definition at line 1158 of file rtp_engine.c.

                                                                                                                             {
    rtp_codecs_payload_set_rx(codecs, payload, new_type, 1);
}

References codecs, and rtp_codecs_payload_set_rx().

Referenced by ast_rtp_codecs_payloads_xover(), rtp_codecs_assign_payload_code_rx(), and rtp_codecs_payloads_copy_rx().

rtp_codecs_payload_set_rx()

static void rtp_codecs_payload_set_rx ( struct ast_rtp_codecs *  codecs, int  payload, struct ast_rtp_payload_type *  new_type, int  replace  )

static

Definition at line 1130 of file rtp_engine.c.

{
    ao2_ref(new_type, +1);
    if (payload < AST_VECTOR_SIZE(&codecs->payload_mapping_rx)) {
        ao2_t_cleanup(AST_VECTOR_GET(&codecs->payload_mapping_rx, payload),
            "cleaning up rx mapping vector element about to be replaced");
    }
    if (AST_VECTOR_REPLACE(&codecs->payload_mapping_rx, payload, new_type)) {
        ao2_ref(new_type, -1);
        return;
    }
 
    if (replace)    {
        payload_mapping_rx_clear_primary(codecs, new_type);
    }
}

References ao2_ref, ao2_t_cleanup, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, codecs, payload_mapping_rx_clear_primary(), and replace().

Referenced by rtp_codecs_assign_payload_code_rx(), and rtp_codecs_payload_replace_rx().

rtp_codecs_payloads_copy_rx()

static void rtp_codecs_payloads_copy_rx ( struct ast_rtp_codecs *  src, struct ast_rtp_codecs *  dest, struct ast_rtp_instance *  instance  )

static

Definition at line 1175 of file rtp_engine.c.

{
    int idx;
    struct ast_rtp_payload_type *type;
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&src->payload_mapping_rx); ++idx) {
        type = AST_VECTOR_GET(&src->payload_mapping_rx, idx);
        if (!type) {
            continue;
        }
 
        ast_debug(2, "Copying rx payload mapping %d (%p) from %p to %p\n",
            idx, type, src, dest);
        rtp_codecs_payload_replace_rx(dest, idx, type);
 
        if (instance && instance->engine && instance->engine->payload_set) {
            ao2_lock(instance);
            instance->engine->payload_set(instance, idx, type->asterisk_format, type->format, type->rtp_code);
            ao2_unlock(instance);
        }
    }
}

References ao2_lock, ao2_unlock, ast_debug, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_rtp_instance::engine, ast_rtp_codecs::payload_mapping_rx, ast_rtp_engine::payload_set, rtp_codecs_payload_replace_rx(), and type.

Referenced by ast_rtp_codecs_payloads_copy().

rtp_codecs_payloads_copy_tx()

static void rtp_codecs_payloads_copy_tx ( struct ast_rtp_codecs *  src, struct ast_rtp_codecs *  dest, struct ast_rtp_instance *  instance  )

static

Definition at line 1271 of file rtp_engine.c.

{
    int idx;
    struct ast_rtp_payload_type *type;
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&src->payload_mapping_tx); ++idx) {
        type = AST_VECTOR_GET(&src->payload_mapping_tx, idx);
        if (!type) {
            continue;
        }
 
        ast_debug(2, "Copying tx payload mapping %d (%p) from %p to %p\n",
            idx, type, src, dest);
        ao2_ref(type, +1);
        if (idx < AST_VECTOR_SIZE(&dest->payload_mapping_tx)) {
            ao2_t_cleanup(AST_VECTOR_GET(&dest->payload_mapping_tx, idx),
                "cleaning up tx mapping vector element about to be replaced");
        }
        if (AST_VECTOR_REPLACE(&dest->payload_mapping_tx, idx, type)) {
            ao2_ref(type, -1);
            continue;
        }
 
        if (instance && instance->engine && instance->engine->payload_set) {
            ao2_lock(instance);
            instance->engine->payload_set(instance, idx, type->asterisk_format, type->format, type->rtp_code);
            ao2_unlock(instance);
        }
    }
}

References ao2_lock, ao2_ref, ao2_t_cleanup, ao2_unlock, ast_debug, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, ast_rtp_instance::engine, ast_rtp_codecs::payload_mapping_tx, ast_rtp_engine::payload_set, and type.

Referenced by ast_rtp_codecs_payloads_copy().

rtp_dtls_wrap_active()

static int rtp_dtls_wrap_active ( struct ast_rtp_instance *  instance )

static

Definition at line 3173 of file rtp_engine.c.

{
    int active;
 
    ao2_lock(instance);
    active = instance->engine->dtls->active(instance);
    ao2_unlock(instance);
    return active;
}

References ast_rtp_engine_dtls::active, ao2_lock, ao2_unlock, ast_rtp_engine::dtls, and ast_rtp_instance::engine.

rtp_dtls_wrap_get_connection()

static enum ast_rtp_dtls_connection rtp_dtls_wrap_get_connection ( struct ast_rtp_instance *  instance )

static

Definition at line 3197 of file rtp_engine.c.

{
    enum ast_rtp_dtls_connection get_connection;
 
    ao2_lock(instance);
    get_connection = instance->engine->dtls->get_connection(instance);
    ao2_unlock(instance);
    return get_connection;
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtls, ast_rtp_instance::engine, and ast_rtp_engine_dtls::get_connection.

rtp_dtls_wrap_get_fingerprint()

static const char * rtp_dtls_wrap_get_fingerprint ( struct ast_rtp_instance *  instance )

static

Definition at line 3243 of file rtp_engine.c.

{
    const char *get_fingerprint;
 
    ao2_lock(instance);
    get_fingerprint = instance->engine->dtls->get_fingerprint(instance);
    ao2_unlock(instance);
    return get_fingerprint;
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtls, ast_rtp_instance::engine, and ast_rtp_engine_dtls::get_fingerprint.

rtp_dtls_wrap_get_fingerprint_hash()

static enum ast_rtp_dtls_hash rtp_dtls_wrap_get_fingerprint_hash ( struct ast_rtp_instance *  instance )

static

Definition at line 3233 of file rtp_engine.c.

{
    enum ast_rtp_dtls_hash get_fingerprint_hash;
 
    ao2_lock(instance);
    get_fingerprint_hash = instance->engine->dtls->get_fingerprint_hash(instance);
    ao2_unlock(instance);
    return get_fingerprint_hash;
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtls, ast_rtp_instance::engine, and ast_rtp_engine_dtls::get_fingerprint_hash.

rtp_dtls_wrap_get_setup()

static enum ast_rtp_dtls_setup rtp_dtls_wrap_get_setup ( struct ast_rtp_instance *  instance )

static

Definition at line 3207 of file rtp_engine.c.

{
    enum ast_rtp_dtls_setup get_setup;
 
    ao2_lock(instance);
    get_setup = instance->engine->dtls->get_setup(instance);
    ao2_unlock(instance);
    return get_setup;
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtls, ast_rtp_instance::engine, and ast_rtp_engine_dtls::get_setup.

rtp_dtls_wrap_reset()

static void rtp_dtls_wrap_reset ( struct ast_rtp_instance *  instance )

static

Definition at line 3190 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->dtls->reset(instance);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtls, ast_rtp_instance::engine, and ast_rtp_engine_dtls::reset.

rtp_dtls_wrap_set_configuration()

static int rtp_dtls_wrap_set_configuration ( struct ast_rtp_instance *  instance, const struct ast_rtp_dtls_cfg *  dtls_cfg  )

static

Definition at line 3162 of file rtp_engine.c.

{
    int set_configuration;
 
    ao2_lock(instance);
    set_configuration = instance->engine->dtls->set_configuration(instance, dtls_cfg);
    ao2_unlock(instance);
    return set_configuration;
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtls, ast_rtp_instance::engine, and ast_rtp_engine_dtls::set_configuration.

rtp_dtls_wrap_set_fingerprint()

static void rtp_dtls_wrap_set_fingerprint ( struct ast_rtp_instance *  instance, enum ast_rtp_dtls_hash  hash, const char *  fingerprint  )

static

Definition at line 3225 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->dtls->set_fingerprint(instance, hash, fingerprint);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtls, ast_rtp_instance::engine, and ast_rtp_engine_dtls::set_fingerprint.

rtp_dtls_wrap_set_setup()

static void rtp_dtls_wrap_set_setup ( struct ast_rtp_instance *  instance, enum ast_rtp_dtls_setup  setup  )

static

Definition at line 3217 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->dtls->set_setup(instance, setup);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtls, ast_rtp_instance::engine, and ast_rtp_engine_dtls::set_setup.

rtp_dtls_wrap_stop()

static void rtp_dtls_wrap_stop ( struct ast_rtp_instance *  instance )

static

Definition at line 3183 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->dtls->stop(instance);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_engine::dtls, ast_rtp_instance::engine, and ast_rtp_engine_dtls::stop.

rtp_engine_atexit()

static void rtp_engine_atexit ( void  )

static

Definition at line 3881 of file rtp_engine.c.

{
    ast_debug_category_unregister(AST_LOG_CATEGORY_ICE);
 
    ast_debug_category_unregister(AST_LOG_CATEGORY_DTLS_PACKET);
    ast_debug_category_unregister(AST_LOG_CATEGORY_DTLS);
 
    ast_debug_category_unregister(AST_LOG_CATEGORY_RTCP_PACKET);
    ast_debug_category_unregister(AST_LOG_CATEGORY_RTCP);
 
    ast_debug_category_unregister(AST_LOG_CATEGORY_RTP_PACKET);
    ast_debug_category_unregister(AST_LOG_CATEGORY_RTP);
}

References ast_debug_category_unregister(), AST_LOG_CATEGORY_DTLS, AST_LOG_CATEGORY_DTLS_PACKET, AST_LOG_CATEGORY_ICE, AST_LOG_CATEGORY_RTCP, AST_LOG_CATEGORY_RTCP_PACKET, AST_LOG_CATEGORY_RTP, and AST_LOG_CATEGORY_RTP_PACKET.

Referenced by ast_rtp_engine_init().

rtp_engine_mime_type_cleanup()

static void rtp_engine_mime_type_cleanup ( int  i )

static

Definition at line 3404 of file rtp_engine.c.

{
    ao2_cleanup(ast_rtp_mime_types[i].payload_type.format);
    memset(&ast_rtp_mime_types[i], 0, sizeof(struct ast_rtp_mime_type));
}

References ao2_cleanup, and ast_rtp_mime_types.

Referenced by ast_rtp_engine_unload_format(), and rtp_engine_shutdown().

rtp_engine_shutdown()

static void rtp_engine_shutdown ( void  )

static

Definition at line 3850 of file rtp_engine.c.

{
    int x;
 
    ao2_cleanup(rtp_topic);
    rtp_topic = NULL;
    STASIS_MESSAGE_TYPE_CLEANUP(ast_rtp_rtcp_received_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_rtp_rtcp_sent_type);
 
    ast_rwlock_wrlock(&static_RTP_PT_lock);
    for (x = 0; x < AST_RTP_MAX_PT; x++) {
        ao2_cleanup(static_RTP_PT[x]);
        static_RTP_PT[x] = NULL;
    }
    ast_rwlock_unlock(&static_RTP_PT_lock);
 
    ast_rwlock_wrlock(&mime_types_lock);
    for (x = 0; x < mime_types_len; x++) {
        if (ast_rtp_mime_types[x].payload_type.format) {
            rtp_engine_mime_type_cleanup(x);
        }
    }
    mime_types_len = 0;
    ast_rwlock_unlock(&mime_types_lock);
}

References ao2_cleanup, AST_RTP_MAX_PT, ast_rtp_mime_types, ast_rtp_rtcp_received_type(), ast_rtp_rtcp_sent_type(), ast_rwlock_unlock, ast_rwlock_wrlock, mime_types_len, mime_types_lock, NULL, rtp_engine_mime_type_cleanup(), rtp_topic, STASIS_MESSAGE_TYPE_CLEANUP, static_RTP_PT, and static_RTP_PT_lock.

Referenced by ast_rtp_engine_init().

rtp_extmap_negotiate_direction()

static enum ast_rtp_extension_direction rtp_extmap_negotiate_direction ( enum ast_rtp_extension_direction  ours, enum ast_rtp_extension_direction  theirs  )

static

Helper function which negotiates two RTP extension directions to get our current direction.

Definition at line 841 of file rtp_engine.c.

{
    if (theirs == AST_RTP_EXTENSION_DIRECTION_NONE || ours == AST_RTP_EXTENSION_DIRECTION_NONE) {
        /* This should not occur but if it does tolerate either side not having this extension
         * in use.
         */
        return AST_RTP_EXTENSION_DIRECTION_NONE;
    } else if (theirs == AST_RTP_EXTENSION_DIRECTION_INACTIVE) {
        /* Inactive is always inactive on our side */
        return AST_RTP_EXTENSION_DIRECTION_INACTIVE;
    } else if (theirs == AST_RTP_EXTENSION_DIRECTION_SENDRECV) {
        return ours;
    } else if (theirs == AST_RTP_EXTENSION_DIRECTION_SENDONLY) {
        /* If they are send only then we become recvonly if we are configured as sendrecv or recvonly */
        if (ours == AST_RTP_EXTENSION_DIRECTION_SENDRECV || ours == AST_RTP_EXTENSION_DIRECTION_RECVONLY) {
            return AST_RTP_EXTENSION_DIRECTION_RECVONLY;
        }
    } else if (theirs == AST_RTP_EXTENSION_DIRECTION_RECVONLY) {
        /* If they are recv only then we become sendonly if we are configured as sendrecv or sendonly */
        if (ours == AST_RTP_EXTENSION_DIRECTION_SENDRECV || ours == AST_RTP_EXTENSION_DIRECTION_SENDONLY) {
            return AST_RTP_EXTENSION_DIRECTION_SENDONLY;
        }
    }
 
    return AST_RTP_EXTENSION_DIRECTION_NONE;
}

References AST_RTP_EXTENSION_DIRECTION_INACTIVE, AST_RTP_EXTENSION_DIRECTION_NONE, AST_RTP_EXTENSION_DIRECTION_RECVONLY, AST_RTP_EXTENSION_DIRECTION_SENDONLY, and AST_RTP_EXTENSION_DIRECTION_SENDRECV.

Referenced by ast_rtp_instance_extmap_negotiate().

rtp_ice_wrap_add_remote_candidate()

static void rtp_ice_wrap_add_remote_candidate ( struct ast_rtp_instance *  instance, const struct ast_rtp_engine_ice_candidate *  candidate  )

static

Definition at line 3048 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->ice->add_remote_candidate(instance, candidate);
    ao2_unlock(instance);
}

References ast_rtp_engine_ice::add_remote_candidate, ao2_lock, ao2_unlock, ast_rtp_instance::engine, and ast_rtp_engine::ice.

rtp_ice_wrap_change_components()

static void rtp_ice_wrap_change_components ( struct ast_rtp_instance *  instance, int  num_components  )

static

Definition at line 3124 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->ice->change_components(instance, num_components);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_engine_ice::change_components, ast_rtp_instance::engine, and ast_rtp_engine::ice.

rtp_ice_wrap_get_local_candidates()

static struct ao2_container * rtp_ice_wrap_get_local_candidates ( struct ast_rtp_instance *  instance )

static

Definition at line 3089 of file rtp_engine.c.

{
    struct ao2_container *local_candidates;
 
    ao2_lock(instance);
    local_candidates = instance->engine->ice->get_local_candidates(instance);
    ao2_unlock(instance);
    return local_candidates;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine_ice::get_local_candidates, and ast_rtp_engine::ice.

rtp_ice_wrap_get_password()

static const char * rtp_ice_wrap_get_password ( struct ast_rtp_instance *  instance )

static

Definition at line 3079 of file rtp_engine.c.

{
    const char *password;
 
    ao2_lock(instance);
    password = instance->engine->ice->get_password(instance);
    ao2_unlock(instance);
    return password;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine_ice::get_password, and ast_rtp_engine::ice.

rtp_ice_wrap_get_ufrag()

static const char * rtp_ice_wrap_get_ufrag ( struct ast_rtp_instance *  instance )

static

Definition at line 3069 of file rtp_engine.c.

{
    const char *ufrag;
 
    ao2_lock(instance);
    ufrag = instance->engine->ice->get_ufrag(instance);
    ao2_unlock(instance);
    return ufrag;
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine_ice::get_ufrag, and ast_rtp_engine::ice.

rtp_ice_wrap_ice_lite()

static void rtp_ice_wrap_ice_lite ( struct ast_rtp_instance *  instance )

static

Definition at line 3099 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->ice->ice_lite(instance);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::ice, and ast_rtp_engine_ice::ice_lite.

rtp_ice_wrap_set_authentication()

static void rtp_ice_wrap_set_authentication ( struct ast_rtp_instance *  instance, const char *  ufrag, const char *  password  )

static

Definition at line 3041 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->ice->set_authentication(instance, ufrag, password);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::ice, and ast_rtp_engine_ice::set_authentication.

rtp_ice_wrap_set_role()

static void rtp_ice_wrap_set_role ( struct ast_rtp_instance *  instance, enum ast_rtp_ice_role  role  )

static

Definition at line 3106 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->ice->set_role(instance, role);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::ice, and ast_rtp_engine_ice::set_role.

rtp_ice_wrap_start()

static void rtp_ice_wrap_start ( struct ast_rtp_instance *  instance )

static

Definition at line 3055 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->ice->start(instance);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::ice, and ast_rtp_engine_ice::start.

rtp_ice_wrap_stop()

static void rtp_ice_wrap_stop ( struct ast_rtp_instance *  instance )

static

Definition at line 3062 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->ice->stop(instance);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::ice, and ast_rtp_engine_ice::stop.

rtp_ice_wrap_turn_request()

static void rtp_ice_wrap_turn_request ( struct ast_rtp_instance *  instance, enum ast_rtp_ice_component_type  component, enum ast_transport  transport, const char *  server, unsigned int  port, const char *  username, const char *  password  )

static

Definition at line 3114 of file rtp_engine.c.

{
    ao2_lock(instance);
    instance->engine->ice->turn_request(instance, component, transport, server, port,
        username, password);
    ao2_unlock(instance);
}

References ao2_lock, ao2_unlock, ast_rtp_instance::engine, ast_rtp_engine::ice, and ast_rtp_engine_ice::turn_request.

rtp_instance_set_incoming_source_address_nolock()

static void rtp_instance_set_incoming_source_address_nolock ( struct ast_rtp_instance *  instance, const struct ast_sockaddr *  address  )

static

Definition at line 648 of file rtp_engine.c.

{
    ast_sockaddr_copy(&instance->incoming_source_address, address);
    if (instance->engine->remote_address_set) {
        instance->engine->remote_address_set(instance, &instance->incoming_source_address);
    }
}

References ast_sockaddr_copy(), ast_rtp_instance::engine, ast_rtp_instance::incoming_source_address, and ast_rtp_engine::remote_address_set.

Referenced by ast_rtp_instance_set_incoming_source_address(), and ast_rtp_instance_set_requested_target_address().

rtp_payload_type_alloc()

static struct ast_rtp_payload_type * rtp_payload_type_alloc ( struct ast_format *  format, int  payload, int  rtp_code, int  primary_mapping, unsigned int  sample_rate  )

static

Definition at line 315 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *type = ao2_alloc_options(
        sizeof(*type), rtp_payload_type_dtor, AO2_ALLOC_OPT_LOCK_NOLOCK);
 
    if (!type) {
        return NULL;
    }
 
    type->format = ao2_bump(format);
    type->asterisk_format = type->format != NULL;
    type->payload = payload;
    type->rtp_code = rtp_code;
    type->primary_mapping = primary_mapping;
    type->sample_rate = sample_rate;
 
    return type;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ast_rtp_payload_type::format, NULL, ast_rtp_payload_type::payload, ast_rtp_payload_type::primary_mapping, ast_rtp_payload_type::rtp_code, rtp_payload_type_dtor(), ast_rtp_payload_type::sample_rate, and type.

Referenced by add_static_payload(), ast_rtp_engine_alloc_payload_type(), and rtp_codecs_assign_payload_code_rx().

rtp_payload_type_dtor()

static void rtp_payload_type_dtor ( void *  obj )

static

Definition at line 308 of file rtp_engine.c.

{
    struct ast_rtp_payload_type *payload = obj;
 
    ao2_cleanup(payload->format);
}

References ao2_cleanup, and ast_rtp_payload_type::payload.

Referenced by rtp_payload_type_alloc().

rtp_rtcp_report_dtor()

static void rtp_rtcp_report_dtor ( void *  obj )

static

Definition at line 3724 of file rtp_engine.c.

{
    int i;
    struct ast_rtp_rtcp_report *rtcp_report = obj;
 
    for (i = 0; i < rtcp_report->reception_report_count; i++) {
        ast_free(rtcp_report->report_block[i]);
    }
}

References ast_free, ast_rtp_rtcp_report::reception_report_count, and ast_rtp_rtcp_report::report_block.

Referenced by ast_rtp_rtcp_report_alloc().

set_next_mime_type()

static void set_next_mime_type ( struct ast_format *  format, int  rtp_code, const char *  type, const char *  subtype, unsigned int  sample_rate  )

static

Definition at line 3410 of file rtp_engine.c.

{
    int x;
 
    ast_rwlock_wrlock(&mime_types_lock);
 
    x = mime_types_len;
    if (ARRAY_LEN(ast_rtp_mime_types) <= x) {
        ast_rwlock_unlock(&mime_types_lock);
        return;
    }
 
    /* Make sure any previous value in ast_rtp_mime_types is cleaned up */
    memset(&ast_rtp_mime_types[x], 0, sizeof(struct ast_rtp_mime_type));
    if (format) {
        ast_rtp_mime_types[x].payload_type.asterisk_format = 1;
        ast_rtp_mime_types[x].payload_type.format = ao2_bump(format);
    } else {
        ast_rtp_mime_types[x].payload_type.rtp_code = rtp_code;
    }
    ast_copy_string(ast_rtp_mime_types[x].type, type, sizeof(ast_rtp_mime_types[x].type));
    ast_copy_string(ast_rtp_mime_types[x].subtype, subtype, sizeof(ast_rtp_mime_types[x].subtype));
    ast_rtp_mime_types[x].sample_rate = sample_rate;
    mime_types_len++;
 
    ast_rwlock_unlock(&mime_types_lock);
}

References ao2_bump, ARRAY_LEN, ast_copy_string(), ast_rtp_mime_types, ast_rwlock_unlock, ast_rwlock_wrlock, ast_rtp_payload_type::asterisk_format, ast_rtp_payload_type::format, mime_types_len, mime_types_lock, ast_rtp_mime_type::payload_type, ast_rtp_payload_type::rtp_code, ast_rtp_mime_type::sample_rate, and type.

Referenced by ast_rtp_engine_init(), and ast_rtp_engine_load_format().

STASIS_MESSAGE_TYPE_DEFN() [1/2]

STASIS_MESSAGE_TYPE_DEFN	(	ast_rtp_rtcp_received_type	,
		.	to_ami = rtcp_report_to_ami,
		.	to_json = rtcp_report_to_json
	)

STASIS_MESSAGE_TYPE_DEFN() [2/2]

STASIS_MESSAGE_TYPE_DEFN	(	ast_rtp_rtcp_sent_type	,
		.	to_ami = rtcp_report_to_ami,
		.	to_json = rtcp_report_to_json
	)

Define RTCP/RTP message types.

unref_instance_cond()

static void unref_instance_cond ( struct ast_rtp_instance **  instance )

static

Conditionally unref an rtp instance.

Definition at line 2441 of file rtp_engine.c.

{
    if (*instance) {
        ao2_ref(*instance, -1);
        *instance = NULL;
    }
}

References ao2_ref, and NULL.

Referenced by ast_rtp_instance_early_bridge(), and ast_rtp_instance_early_bridge_make_compatible().

Variable Documentation

ast_rtp_mime_types

struct ast_rtp_mime_type ast_rtp_mime_types[128]

static

Referenced by ast_rtp_codecs_payloads_set_rtpmap_type_rate(), ast_rtp_engine_unload_format(), ast_rtp_lookup_mime_subtype2(), ast_rtp_lookup_sample_rate2(), rtp_engine_mime_type_cleanup(), rtp_engine_shutdown(), and set_next_mime_type().

debug_category_dtls_id

uintmax_t debug_category_dtls_id

static

Definition at line 3824 of file rtp_engine.c.

Referenced by ast_debug_category_dtls_id(), and ast_rtp_engine_init().

debug_category_dtls_packet_id

uintmax_t debug_category_dtls_packet_id

static

Definition at line 3831 of file rtp_engine.c.

Referenced by ast_debug_category_dtls_packet_id(), and ast_rtp_engine_init().

debug_category_ice_id

uintmax_t debug_category_ice_id

static

Definition at line 3838 of file rtp_engine.c.

Referenced by ast_debug_category_ice_id(), and ast_rtp_engine_init().

debug_category_rtcp_id

uintmax_t debug_category_rtcp_id

static

Definition at line 3810 of file rtp_engine.c.

Referenced by ast_debug_category_rtcp_id(), and ast_rtp_engine_init().

debug_category_rtcp_packet_id

uintmax_t debug_category_rtcp_packet_id

static

Definition at line 3817 of file rtp_engine.c.

Referenced by ast_debug_category_rtcp_packet_id(), and ast_rtp_engine_init().

debug_category_rtp_id

uintmax_t debug_category_rtp_id

static

Definition at line 3796 of file rtp_engine.c.

Referenced by ast_debug_category_rtp_id(), and ast_rtp_engine_init().

debug_category_rtp_packet_id

uintmax_t debug_category_rtp_packet_id

static

Definition at line 3803 of file rtp_engine.c.

Referenced by ast_debug_category_rtp_packet_id(), and ast_rtp_engine_init().

engines

struct engines engines = AST_RWLIST_HEAD_INIT_VALUE

static

glues

struct glues glues = AST_RWLIST_HEAD_INIT_VALUE

static

mime_types_len

int mime_types_len = 0

static

Definition at line 271 of file rtp_engine.c.

Referenced by ast_rtp_codecs_payloads_set_rtpmap_type_rate(), ast_rtp_engine_unload_format(), ast_rtp_lookup_mime_subtype2(), ast_rtp_lookup_sample_rate2(), rtp_engine_shutdown(), and set_next_mime_type().

mime_types_lock

ast_rwlock_t mime_types_lock

static

Definition at line 270 of file rtp_engine.c.

Referenced by ast_rtp_codecs_payloads_set_rtpmap_type_rate(), ast_rtp_engine_init(), ast_rtp_engine_unload_format(), ast_rtp_lookup_mime_subtype2(), ast_rtp_lookup_sample_rate2(), rtp_engine_shutdown(), and set_next_mime_type().

res_srtp

struct ast_srtp_res* res_srtp = NULL

Definition at line 182 of file rtp_engine.c.

Referenced by __rtp_sendto(), ast_rtcp_interpret(), ast_rtp_change_source(), ast_rtp_engine_register_srtp(), ast_rtp_engine_srtp_is_registered(), ast_rtp_engine_unregister_srtp(), ast_rtp_instance_add_srtp_policy(), ast_rtp_interpret(), and instance_destructor().

res_srtp_policy

struct ast_srtp_policy_res* res_srtp_policy = NULL

Definition at line 183 of file rtp_engine.c.

Referenced by ast_rtp_engine_register_srtp(), ast_rtp_engine_srtp_is_registered(), and ast_rtp_engine_unregister_srtp().

rtp_dtls_wrappers

struct ast_rtp_engine_dtls rtp_dtls_wrappers

static

Definition at line 3253 of file rtp_engine.c.

                                                      {
    .set_configuration = rtp_dtls_wrap_set_configuration,
    .active = rtp_dtls_wrap_active,
    .stop = rtp_dtls_wrap_stop,
    .reset = rtp_dtls_wrap_reset,
    .get_connection = rtp_dtls_wrap_get_connection,
    .get_setup = rtp_dtls_wrap_get_setup,
    .set_setup = rtp_dtls_wrap_set_setup,
    .set_fingerprint = rtp_dtls_wrap_set_fingerprint,
    .get_fingerprint_hash = rtp_dtls_wrap_get_fingerprint_hash,
    .get_fingerprint = rtp_dtls_wrap_get_fingerprint,
};

Referenced by ast_rtp_instance_get_dtls().

rtp_extension_uris

const char* const rtp_extension_uris[AST_RTP_EXTENSION_MAX]

static

Initial value:

= {
    [AST_RTP_EXTENSION_UNSUPPORTED]     = "",
    [AST_RTP_EXTENSION_ABS_SEND_TIME]   = "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time",
    [AST_RTP_EXTENSION_TRANSPORT_WIDE_CC]   = "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01",
}

URIs for known RTP extensions.

Definition at line 244 of file rtp_engine.c.

                                                                      {
    [AST_RTP_EXTENSION_UNSUPPORTED]     = "",
    [AST_RTP_EXTENSION_ABS_SEND_TIME]   = "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time",
    [AST_RTP_EXTENSION_TRANSPORT_WIDE_CC]   = "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01",
};

Referenced by ast_rtp_instance_extmap_get_uri(), and ast_rtp_instance_extmap_negotiate().

rtp_ice_wrappers

struct ast_rtp_engine_ice rtp_ice_wrappers

static

Definition at line 3132 of file rtp_engine.c.

                                                    {
    .set_authentication = rtp_ice_wrap_set_authentication,
    .add_remote_candidate = rtp_ice_wrap_add_remote_candidate,
    .start = rtp_ice_wrap_start,
    .stop = rtp_ice_wrap_stop,
    .get_ufrag = rtp_ice_wrap_get_ufrag,
    .get_password = rtp_ice_wrap_get_password,
    .get_local_candidates = rtp_ice_wrap_get_local_candidates,
    .ice_lite = rtp_ice_wrap_ice_lite,
    .set_role = rtp_ice_wrap_set_role,
    .turn_request = rtp_ice_wrap_turn_request,
    .change_components = rtp_ice_wrap_change_components,
};

Referenced by ast_rtp_instance_get_ice().

rtp_topic

struct stasis_topic* rtp_topic

static

Stasis Message Bus API topic for RTP related messages

Definition at line 287 of file rtp_engine.c.

Referenced by ast_rtp_engine_init(), ast_rtp_topic(), and rtp_engine_shutdown().

static_RTP_PT

struct ast_rtp_payload_type* static_RTP_PT[AST_RTP_MAX_PT]

static

Mapping between Asterisk codecs and rtp payload types.

Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s: also, our own choices for dynamic payload types. This is our master table for transmission

See http://www.iana.org/assignments/rtp-parameters for a list of assigned values

Definition at line 283 of file rtp_engine.c.

Referenced by add_static_payload(), ast_rtp_codecs_get_payload(), ast_rtp_codecs_payloads_set_m_type(), ast_rtp_engine_unload_format(), find_static_payload_type(), find_unused_payload(), rtp_codecs_assign_payload_code_rx(), and rtp_engine_shutdown().

static_RTP_PT_lock

ast_rwlock_t static_RTP_PT_lock

static

Definition at line 284 of file rtp_engine.c.

Referenced by add_static_payload(), ast_rtp_codecs_get_payload(), ast_rtp_codecs_payload_code_sample_rate(), ast_rtp_codecs_payload_code_tx_sample_rate(), ast_rtp_codecs_payloads_set_m_type(), ast_rtp_engine_init(), ast_rtp_engine_unload_format(), and rtp_engine_shutdown().