#include <switch.h>
#include <switch_ssl.h>
#include <switch_stun.h>
#include <switch_nat.h>
#include "private/switch_core_pvt.h"
#include <switch_curl.h>
#include <errno.h>
#include <sofia-sip/sdp.h>
#include <sofia-sip/su.h>

Include dependency graph for switch_core_media.c:

Data Structures
struct	secure_settings_s

struct	core_video_globals_s

struct	media_helper

struct	switch_rtp_engine_s

struct	switch_media_handle_s

struct	matches

Macros
#define	RTCP_MUX

#define	MAX_CODEC_CHECK_FRAMES 50

#define	MAX_MISMATCH_FRAMES 5

#define	type2str(type) type == SWITCH_MEDIA_TYPE_VIDEO ? "video" : "audio"

#define	VIDEO_REFRESH_FREQ 1000000

#define	add_stat(_i, _s)

#define	add_stat_double(_i, _s)

#define	MAX_MATCHES 30

#define	RA_PTR_LEN 512

#define	SDPBUFLEN 65536

Typedefs
typedef struct secure_settings_s	switch_secure_settings_t

typedef struct core_video_globals_s	core_video_globals_t

typedef struct switch_rtp_engine_s	switch_rtp_engine_t

Enumerations
enum	smh_flag_t { SMF_INIT = (1 << 0), SMF_READY = (1 << 1), SMF_JB_PAUSED = (1 << 2) }

enum	switch_rtp_crypto_mode_t { CRYPTO_MODE_OPTIONAL, CRYPTO_MODE_MANDATORY, CRYPTO_MODE_FORBIDDEN }

Functions
static switch_t38_options_t *	switch_core_media_process_udptl (switch_core_session_t session, sdp_session_t sdp, sdp_media_t *m)

static void	switch_core_media_find_zrtp_hash (switch_core_session_t session, sdp_session_t sdp)

static void	switch_core_media_set_r_sdp_codec_string (switch_core_session_t session, const char codec_string, sdp_session_t *sdp, switch_sdp_type_t sdp_type)

static void	gen_ice (switch_core_session_t session, switch_media_type_t type, const char ip, switch_port_t port)

switch_rtp_crypto_key_type_t	switch_core_media_crypto_str2type (const char *str)

const char *	switch_core_media_crypto_type2str (switch_rtp_crypto_key_type_t type)

int	switch_core_media_crypto_keylen (switch_rtp_crypto_key_type_t type)

static switch_media_flow_t	sdp_media_flow (unsigned in)

static int	get_channels (const char *name, int dft)

static void	_switch_core_media_pass_zrtp_hash2 (switch_core_session_t aleg_session, switch_core_session_t bleg_session, switch_media_type_t type)

uint32_t	switch_core_media_get_video_fps (switch_core_session_t *session)

void	switch_core_media_pass_zrtp_hash2 (switch_core_session_t aleg_session, switch_core_session_t bleg_session)

void	switch_core_media_pass_zrtp_hash (switch_core_session_t *session)

const char *	switch_core_media_get_zrtp_hash (switch_core_session_t *session, switch_media_type_t type, switch_bool_t local)

switch_status_t	switch_core_media_check_autoadj (switch_core_session_t *session)

switch_status_t	switch_core_media_get_vid_params (switch_core_session_t session, switch_vid_params_t vid_params)

switch_t38_options_t *	switch_core_media_extract_t38_options (switch_core_session_t session, const char r_sdp)

switch_status_t	switch_core_media_process_t38_passthru (switch_core_session_t session, switch_core_session_t other_session, switch_t38_options_t *t38_options)

switch_status_t	switch_core_session_get_payload_code (switch_core_session_t session, switch_media_type_t type, const char iananame, uint32_t rate, switch_payload_t ptP, switch_payload_t recv_ptP, char **fmtpP)

payload_map_t *	switch_core_media_add_payload_map (switch_core_session_t session, switch_media_type_t type, const char name, const char modname, const char fmtp, switch_sdp_type_t sdp_type, uint32_t pt, uint32_t rate, uint32_t ptime, uint32_t channels, uint8_t negotiated)

const char *	switch_core_media_get_codec_string (switch_core_session_t *session)

void	switch_core_session_clear_crypto (switch_core_session_t *session)

const char *	switch_core_session_local_crypto_key (switch_core_session_t *session, switch_media_type_t type)

void	switch_core_media_parse_rtp_bugs (switch_rtp_bug_flag_t flag_pole, const char str)

static switch_status_t	switch_core_media_build_crypto (switch_media_handle_t *smh, switch_media_type_t type, int index, switch_rtp_crypto_key_type_t ctype, switch_rtp_crypto_direction_t direction, int force)

switch_status_t	switch_core_media_add_crypto (switch_secure_settings_t ssec, const char key_str, switch_rtp_crypto_direction_t direction)

void	switch_core_media_set_rtp_session (switch_core_session_t session, switch_media_type_t type, switch_rtp_t rtp_session)

static void	switch_core_session_get_recovery_crypto_key (switch_core_session_t *session, switch_media_type_t type)

static void	switch_core_session_apply_crypto (switch_core_session_t *session, switch_media_type_t type)

static void	switch_core_session_parse_crypto_prefs (switch_core_session_t *session)

int	switch_core_session_check_incoming_crypto (switch_core_session_t session, const char varname, switch_media_type_t type, const char *crypto, int crypto_tag, switch_sdp_type_t sdp_type)

void	switch_core_session_check_outgoing_crypto (switch_core_session_t *session)

static void	set_stats (switch_core_session_t session, switch_media_type_t type, const char prefix)

void	switch_core_media_sync_stats (switch_core_session_t *session)

void	switch_core_media_set_stats (switch_core_session_t *session)

void	switch_media_handle_destroy (switch_core_session_t *session)

switch_status_t	switch_media_handle_create (switch_media_handle_t *smhp, switch_core_session_t session, switch_core_media_params_t *params)

void	switch_media_handle_set_media_flag (switch_media_handle_t *smh, switch_core_media_flag_t flag)

void	switch_media_handle_set_media_flags (switch_media_handle_t *smh, switch_core_media_flag_t flags[SCMF_MAX])

void	switch_media_handle_clear_media_flag (switch_media_handle_t *smh, switch_core_media_flag_t flag)

int32_t	switch_media_handle_test_media_flag (switch_media_handle_t *smh, switch_core_media_flag_t flag)

switch_media_flow_t	switch_core_session_media_flow (switch_core_session_t *session, switch_media_type_t type)

switch_status_t	switch_core_session_media_handle_ready (switch_core_session_t *session)

switch_media_handle_t *	switch_core_session_get_media_handle (switch_core_session_t *session)

switch_status_t	switch_core_session_clear_media_handle (switch_core_session_t *session)

switch_core_media_params_t *	switch_core_media_get_mparams (switch_media_handle_t *smh)

void	switch_core_media_prepare_codecs (switch_core_session_t *session, switch_bool_t force)

static void	check_jb (switch_core_session_t session, const char input, int32_t jb_msec, int32_t maxlen, switch_bool_t silent)

static void	check_jb_sync (switch_core_session_t *session)

switch_status_t	switch_core_media_read_lock_unlock (switch_core_session_t *session, switch_media_type_t type, switch_bool_t lock)

switch_status_t	switch_core_media_read_frame (switch_core_session_t session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id, switch_media_type_t type)

switch_status_t	switch_core_media_write_frame (switch_core_session_t session, switch_frame_t frame, switch_io_flag_t flags, int stream_id, switch_media_type_t type)

void	switch_core_media_copy_t38_options (switch_t38_options_t t38_options, switch_core_session_t session)

switch_status_t	switch_core_media_get_offered_pt (switch_core_session_t session, const switch_codec_implementation_t mimp, switch_payload_t *pt)

static void	switch_core_session_parse_codec_settings (switch_core_session_t *session, switch_media_type_t type)

switch_status_t	switch_core_media_set_video_codec (switch_core_session_t *session, int force)

switch_status_t	switch_core_media_set_codec (switch_core_session_t *session, int force, uint32_t codec_flags)

static void	clear_ice (switch_core_session_t *session, switch_media_type_t type)

void	switch_core_media_clear_ice (switch_core_session_t *session)

void	switch_core_media_pause (switch_core_session_t *session)

void	switch_core_media_resume (switch_core_session_t *session)

switch_status_t	switch_core_media_add_ice_acl (switch_core_session_t session, switch_media_type_t type, const char acl_name)

void	switch_core_media_check_video_codecs (switch_core_session_t *session)

static void	generate_local_fingerprint (switch_media_handle_t *smh, switch_media_type_t type)

static int	dtls_ok (switch_core_session_t *session)

switch_call_direction_t	switch_ice_direction (switch_core_session_t *session)

static switch_status_t	ip_choose_family (switch_media_handle_t smh, const char ip)

static switch_bool_t	ip_possible (switch_media_handle_t smh, const char ip)

static switch_status_t	check_ice (switch_media_handle_t smh, switch_media_type_t type, sdp_session_t sdp, sdp_media_t *m)

void	switch_core_session_set_ice (switch_core_session_t *session)

static void	greedy_sort (switch_media_handle_t smh, struct matches matches, int m_idx, const switch_codec_implementation_t **codec_array, int total_codecs)

static void	clear_pmaps (switch_rtp_engine_t *engine)

uint8_t	switch_core_media_negotiate_sdp (switch_core_session_t session, const char r_sdp, uint8_t *proceed, switch_sdp_type_t sdp_type)

int	switch_core_media_toggle_hold (switch_core_session_t *session, int sendonly)

switch_file_handle_t *	switch_core_media_get_video_file (switch_core_session_t *session, switch_rw_t rw)

static void *SWITCH_THREAD_FUNC	video_write_thread (switch_thread_t thread, void obj)

switch_status_t	switch_core_media_lock_video_file (switch_core_session_t *session, switch_rw_t rw)

switch_status_t	switch_core_media_unlock_video_file (switch_core_session_t *session, switch_rw_t rw)

switch_status_t	switch_core_media_set_video_file (switch_core_session_t session, switch_file_handle_t fh, switch_rw_t rw)

int	next_cpu (void)

void	switch_core_autobind_cpu (void)

static void *SWITCH_THREAD_FUNC	video_helper_thread (switch_thread_t thread, void obj)

switch_status_t	switch_core_session_start_video_thread (switch_core_session_t *session)

void	switch_core_media_start_video_function (switch_core_session_t session, switch_video_function_t video_function, void user_data)

int	switch_core_media_check_video_function (switch_core_session_t *session)

void	switch_core_media_end_video_function (switch_core_session_t *session)

switch_bool_t	switch_core_session_in_video_thread (switch_core_session_t *session)

switch_status_t	switch_core_media_proxy_remote_addr (switch_core_session_t session, const char sdp_str)

int	switch_core_media_check_nat (switch_media_handle_t smh, const char network_ip)

switch_status_t	switch_core_media_ext_address_lookup (switch_core_session_t session, char ip, switch_port_t port, const char *sourceip)

void	switch_core_media_reset_autofix (switch_core_session_t *session, switch_media_type_t type)

switch_status_t	switch_core_media_choose_port (switch_core_session_t *session, switch_media_type_t type, int force)

switch_status_t	switch_core_media_choose_ports (switch_core_session_t *session, switch_bool_t audio, switch_bool_t video)

void	switch_core_media_deactivate_rtp (switch_core_session_t *session)

void	switch_core_session_wake_video_thread (switch_core_session_t *session)

static void	check_dtls_reinvite (switch_core_session_t session, switch_rtp_engine_t engine)

switch_status_t	switch_core_media_activate_rtp (switch_core_session_t *session)

static const char *	get_media_profile_name (switch_core_session_t *session, int secure)

static char *	get_setup (switch_rtp_engine_t engine, switch_core_session_t session, switch_sdp_type_t sdp_type)

static void	generate_m (switch_core_session_t session, char buf, size_t buflen, switch_port_t port, const char family, const char ip, int cur_ptime, const char append_audio, const char sr, int use_cng, int cng_type, switch_event_t *map, int secure, switch_sdp_type_t sdp_type)

void	switch_core_media_check_dtmf_type (switch_core_session_t *session)

switch_status_t	switch_core_media_sdp_map (const char r_sdp, switch_event_t fmtp, switch_event_t *pt)

void	switch_core_media_set_local_sdp (switch_core_session_t session, const char sdp_str, switch_bool_t dup)

static void	add_fb (char *buf, uint32_t buflen, int pt, int fir, int nack, int pli, int tmmbr)

void	switch_core_media_gen_local_sdp (switch_core_session_t session, switch_sdp_type_t sdp_type, const char ip, switch_port_t port, const char *sr, int force)

void	switch_core_media_absorb_sdp (switch_core_session_t *session)

void	switch_core_media_set_udptl_image_sdp (switch_core_session_t session, switch_t38_options_t t38_options, int insist)

void	switch_core_media_patch_sdp (switch_core_session_t *session)

void	switch_core_media_start_udptl (switch_core_session_t session, switch_t38_options_t t38_options)

void	switch_core_media_hard_mute (switch_core_session_t *session, switch_bool_t on)

static int	check_engine (switch_rtp_engine_t *engine)

switch_bool_t	switch_core_media_check_dtls (switch_core_session_t *session, switch_media_type_t type)

switch_status_t	switch_core_media_set_outgoing_bitrate (switch_core_session_t *session, switch_media_type_t type, uint32_t bitrate)

switch_status_t	switch_core_media_reset_jb (switch_core_session_t *session, switch_media_type_t type)

switch_status_t	switch_core_media_receive_message (switch_core_session_t session, switch_core_session_message_t msg)

void	switch_core_media_break (switch_core_session_t *session, switch_media_type_t type)

void	switch_core_media_kill_socket (switch_core_session_t *session, switch_media_type_t type)

switch_status_t	switch_core_media_queue_rfc2833 (switch_core_session_t session, switch_media_type_t type, const switch_dtmf_t dtmf)

switch_status_t	switch_core_media_queue_rfc2833_in (switch_core_session_t session, switch_media_type_t type, const switch_dtmf_t dtmf)

uint8_t	switch_core_media_ready (switch_core_session_t *session, switch_media_type_t type)

void	switch_core_media_set_rtp_flag (switch_core_session_t *session, switch_media_type_t type, switch_rtp_flag_t flag)

void	switch_core_media_clear_rtp_flag (switch_core_session_t *session, switch_media_type_t type, switch_rtp_flag_t flag)

void	switch_core_media_set_telephony_event (switch_core_session_t *session, switch_media_type_t type, switch_payload_t te)

void	switch_core_media_set_telephony_recv_event (switch_core_session_t *session, switch_media_type_t type, switch_payload_t te)

switch_rtp_stats_t *	switch_core_media_get_stats (switch_core_session_t session, switch_media_type_t type, switch_memory_pool_t pool)

switch_bool_t	switch_core_media_check_udptl_mode (switch_core_session_t *session, switch_media_type_t type)

switch_status_t	switch_core_media_udptl_mode (switch_core_session_t *session, switch_media_type_t type)

switch_jb_t *	switch_core_media_get_jb (switch_core_session_t *session, switch_media_type_t type)

void	switch_core_media_set_sdp_codec_string (switch_core_session_t session, const char r_sdp, switch_sdp_type_t sdp_type)

static void	add_audio_codec (sdp_rtpmap_t map, const switch_codec_implementation_t imp, int ptime, char *buf, switch_size_t buflen)

switch_status_t	switch_core_media_codec_chosen (switch_core_session_t *session, switch_media_type_t type)

void	switch_core_session_stop_media (switch_core_session_t *session)

void	switch_core_media_check_outgoing_proxy (switch_core_session_t session, switch_core_session_t o_session)

void	switch_core_media_recover_session (switch_core_session_t *session)

void	switch_core_media_init (void)

void	switch_core_media_deinit (void)

static int	payload_number (const char *name)

static int	find_pt (const char sdp, const char name)

char *	switch_core_media_filter_sdp (const char sdp_str, const char cmd, const char *arg)

char *	switch_core_media_process_sdp_filter (const char sdp, const char cmd_buf, switch_core_session_t *session)

switch_timer_t *	switch_core_media_get_timer (switch_core_session_t *session, switch_media_type_t mtype)

switch_status_t	switch_core_session_request_video_refresh (switch_core_session_t *session)

switch_status_t	switch_core_session_send_and_request_video_refresh (switch_core_session_t *session)

switch_status_t	switch_core_media_codec_control (switch_core_session_t session, switch_media_type_t mtype, switch_io_type_t iotype, switch_codec_control_command_t cmd, switch_codec_control_type_t ctype, void cmd_data, switch_codec_control_type_t atype, void cmd_arg, switch_codec_control_type_t rtype, void **ret_data)

switch_status_t	switch_core_session_write_encoded_video_frame (switch_core_session_t session, switch_frame_t frame, switch_io_flag_t flags, int stream_id)

void	switch_core_session_video_reinit (switch_core_session_t *session)

switch_status_t	switch_core_session_write_video_frame (switch_core_session_t session, switch_frame_t frame, switch_io_flag_t flags, int stream_id)

switch_status_t	switch_core_session_wait_for_video_input_params (switch_core_session_t *session, uint32_t timeout_ms)

switch_status_t	switch_core_session_read_video_frame (switch_core_session_t session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)

switch_status_t	switch_core_session_set_video_read_callback (switch_core_session_t session, switch_core_video_thread_callback_func_t func, void user_data)

switch_status_t	switch_core_session_video_read_callback (switch_core_session_t session, switch_frame_t frame)

Variables
static core_video_globals_t	video_globals = { 0 }

static switch_srtp_crypto_suite_t	SUITES [CRYPTO_INVALID]

Macro Definition Documentation

#define add_stat	(	_i,
		_s
	)

Value:

switch_snprintf(var_name, sizeof(var_name), "rtp_%s_%s", switch_str_nil(prefix), _s) ; \
	switch_snprintf(var_val, sizeof(var_val), "%" SWITCH_SIZE_T_FMT, _i); \
	switch_channel_set_variable(channel, var_name, var_val)

Definition at line 1484 of file switch_core_media.c.

Referenced by set_stats().

#define add_stat_double	(	_i,
		_s
	)

Value:

switch_snprintf(var_name, sizeof(var_name), "rtp_%s_%s", switch_str_nil(prefix), _s) ; \
	switch_snprintf(var_val, sizeof(var_val), "%0.2f", _i); \
	switch_channel_set_variable(channel, var_name, var_val)

Definition at line 1489 of file switch_core_media.c.

Referenced by set_stats().

#define MAX_CODEC_CHECK_FRAMES 50

Definition at line 48 of file switch_core_media.c.

Referenced by switch_core_media_read_frame().

#define MAX_MATCHES 30

Definition at line 3610 of file switch_core_media.c.

#define MAX_MISMATCH_FRAMES 5

Definition at line 49 of file switch_core_media.c.

Referenced by switch_core_media_read_frame().

#define RA_PTR_LEN 512

Definition at line 5612 of file switch_core_media.c.

Referenced by switch_core_media_proxy_remote_addr().

#define RTCP_MUX

Definition at line 47 of file switch_core_media.c.

#define SDPBUFLEN 65536

Definition at line 7522 of file switch_core_media.c.

Referenced by switch_core_media_gen_local_sdp().

#define type2str ( type ) type == SWITCH_MEDIA_TYPE_VIDEO ? "video" : "audio"

Definition at line 50 of file switch_core_media.c.

Referenced by check_dtls_reinvite(), check_ice(), switch_core_media_build_crypto(), switch_core_media_read_frame(), switch_core_media_read_lock_unlock(), and switch_core_session_write_video_frame().

#define VIDEO_REFRESH_FREQ 1000000

Definition at line 51 of file switch_core_media.c.

Referenced by switch_core_media_codec_control(), and switch_core_session_request_video_refresh().

Typedef Documentation

typedef struct core_video_globals_s core_video_globals_t

typedef struct switch_rtp_engine_s switch_rtp_engine_t

typedef struct secure_settings_s switch_secure_settings_t

Enumeration Type Documentation

enum smh_flag_t

Enumerator
SMF_INIT
SMF_READY
SMF_JB_PAUSED

Definition at line 53 of file switch_core_media.c.

              {
         SMF_INIT = (1 << 0),
         SMF_READY = (1 << 1),
         SMF_JB_PAUSED = (1 << 2)
 } smh_flag_t;

enum switch_rtp_crypto_mode_t

Enumerator
CRYPTO_MODE_OPTIONAL
CRYPTO_MODE_MANDATORY
CRYPTO_MODE_FORBIDDEN

Definition at line 89 of file switch_core_media.c.

              {
         CRYPTO_MODE_OPTIONAL,
         CRYPTO_MODE_MANDATORY,
         CRYPTO_MODE_FORBIDDEN
 } switch_rtp_crypto_mode_t;

Function Documentation

static void _switch_core_media_pass_zrtp_hash2	(	switch_core_session_t *	aleg_session,
		switch_core_session_t *	bleg_session,
		switch_media_type_t	type
	)

static

Definition at line 306 of file switch_core_media.c.

References CF_ZRTP_PASSTHRU_REQ, switch_core_session::channel, switch_media_handle_s::engines, switch_rtp_engine_s::local_sdp_zrtp_hash, switch_core_session::media_handle, switch_rtp_engine_s::remote_sdp_zrtp_hash, SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_set_variable, switch_channel_test_flag(), switch_core_session_strdup, SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG1, and switch_log_printf().

Referenced by switch_core_media_pass_zrtp_hash2().

 {
         switch_rtp_engine_t *aleg_engine;
         switch_rtp_engine_t *bleg_engine;
 
         if (!aleg_session->media_handle || !bleg_session->media_handle) return;
         aleg_engine = &aleg_session->media_handle->engines[type];
         bleg_engine = &bleg_session->media_handle->engines[type];
 
 
 
         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(aleg_session->channel), SWITCH_LOG_DEBUG1, 
                                           "Deciding whether to pass zrtp-hash between a-leg and b-leg\n");
 
         if (!(switch_channel_test_flag(aleg_session->channel, CF_ZRTP_PASSTHRU_REQ))) {
                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(aleg_session->channel), SWITCH_LOG_DEBUG1, 
                                                   "CF_ZRTP_PASSTHRU_REQ not set on a-leg, so not propagating zrtp-hash\n");
                 return;
         }
 
         if (aleg_engine->remote_sdp_zrtp_hash) {
                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(aleg_session->channel), SWITCH_LOG_DEBUG, "Passing a-leg remote zrtp-hash (audio) to b-leg\n");
                 bleg_engine->local_sdp_zrtp_hash = switch_core_session_strdup(bleg_session, aleg_engine->remote_sdp_zrtp_hash);
                 switch_channel_set_variable(bleg_session->channel, "l_sdp_audio_zrtp_hash", bleg_engine->local_sdp_zrtp_hash);
         }
         
         if (bleg_engine->remote_sdp_zrtp_hash) {
                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(aleg_session->channel), SWITCH_LOG_DEBUG, "Passing b-leg remote zrtp-hash (audio) to a-leg\n");
                 aleg_engine->local_sdp_zrtp_hash = switch_core_session_strdup(aleg_session, bleg_engine->remote_sdp_zrtp_hash);
                 switch_channel_set_variable(aleg_session->channel, "l_sdp_audio_zrtp_hash", aleg_engine->local_sdp_zrtp_hash);
         }
 }

static void add_audio_codec	(	sdp_rtpmap_t *	map,
		const switch_codec_implementation_t *	imp,
		int	ptime,
		char *	buf,
		switch_size_t	buflen
	)

static

Definition at line 9993 of file switch_core_media.c.

References switch_codec_fmtp::bits_per_second, switch_codec_fmtp::microseconds_per_packet, switch_codec_implementation::modname, switch_core_codec_parse_fmtp(), switch_default_ptime(), switch_known_bitrate(), switch_snprintf(), SWITCH_STATUS_SUCCESS, and zstr.

Referenced by switch_core_media_set_r_sdp_codec_string().

 {
         int codec_ms = ptime;
         uint32_t map_bit_rate = 0, map_channels = 1;
         char ptstr[20] = "";
         char ratestr[20] = "";
         char bitstr[20] = "";
         switch_codec_fmtp_t codec_fmtp = { 0 };
                                                 
         if (!codec_ms) {
                 codec_ms = switch_default_ptime(map->rm_encoding, map->rm_pt);
         }
 
         map_channels = map->rm_params ? atoi(map->rm_params) : 1;
         map_bit_rate = switch_known_bitrate((switch_payload_t)map->rm_pt);
                                 
         if (!ptime && !strcasecmp(map->rm_encoding, "g723")) {
                 ptime = codec_ms = 30;
         }
                                 
         if (zstr(map->rm_fmtp)) {
                 if (!strcasecmp(map->rm_encoding, "ilbc")) {
                         ptime = codec_ms = 30;
                         map_bit_rate = 13330;
                 } else if (!strcasecmp(map->rm_encoding, "isac")) {
                         ptime = codec_ms = 30;
                         map_bit_rate = 32000;
                 }
         } else {
                 if ((switch_core_codec_parse_fmtp(map->rm_encoding, map->rm_fmtp, map->rm_rate, &codec_fmtp)) == SWITCH_STATUS_SUCCESS) {
                         if (codec_fmtp.bits_per_second) {
                                 map_bit_rate = codec_fmtp.bits_per_second;
                         }
                         if (codec_fmtp.microseconds_per_packet) {
                                 codec_ms = (codec_fmtp.microseconds_per_packet / 1000);
                         }
                 }
         }
 
         if (map->rm_rate) {
                 switch_snprintf(ratestr, sizeof(ratestr), "@%uh", (unsigned int) map->rm_rate);
         }
 
         if (codec_ms) {
                 switch_snprintf(ptstr, sizeof(ptstr), "@%di", codec_ms);
         }
 
         if (map_bit_rate) {
                 switch_snprintf(bitstr, sizeof(bitstr), "@%db", map_bit_rate);
         }
 
         if (map_channels > 1) {
                 switch_snprintf(bitstr, sizeof(bitstr), "@%dc", map_channels);
         }
 
         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), ",%s.%s%s%s%s", imp->modname, map->rm_encoding, ratestr, ptstr, bitstr);
 
 }

static void add_fb	(	char *	buf,
		uint32_t	buflen,
		int	pt,
		int	fir,
		int	nack,
		int	pli,
		int	tmmbr
	)

static

Definition at line 7501 of file switch_core_media.c.

References switch_snprintf().

Referenced by switch_core_media_gen_local_sdp().

 {
         if (fir) {
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-fb:%d ccm fir\r\n", pt);
         }
 
         if (tmmbr) {
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-fb:%d ccm tmmbr\r\n", pt);
         }
 
         if (nack) {
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-fb:%d nack\r\n", pt);
         }
 
         if (pli) {
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-fb:%d nack pli\r\n", pt);
         }
 
 }

static void check_dtls_reinvite	(	switch_core_session_t *	session,
		switch_rtp_engine_t *	engine
	)

static

Definition at line 6193 of file switch_core_media.c.

References CF_REINVITE, switch_core_session::channel, switch_rtp_engine_s::dtls_controller, dtls_ok(), DTLS_TYPE_CLIENT, DTLS_TYPE_RTCP, DTLS_TYPE_RTP, DTLS_TYPE_SERVER, switch_rtp_engine_s::local_dtls_fingerprint, switch_rtp_engine_s::new_dtls, switch_rtp_engine_s::remote_dtls_fingerprint, switch_rtp_engine_s::rtcp_mux, switch_rtp_engine_s::rtp_session, dtls_fp_s::str, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), SWITCH_LOG_INFO, switch_log_printf(), switch_rtp_add_dtls(), switch_rtp_has_dtls(), switch_rtp_engine_s::type, type2str, and zstr.

Referenced by switch_core_media_activate_rtp().

 {
         if (switch_channel_test_flag(session->channel, CF_REINVITE) && engine->new_dtls) {
 
                 if (!zstr(engine->local_dtls_fingerprint.str) && switch_rtp_has_dtls() && dtls_ok(session)) {
                         dtls_type_t xtype, dtype = engine->dtls_controller ? DTLS_TYPE_CLIENT : DTLS_TYPE_SERVER;
                         
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "RE-SETTING %s DTLS\n", type2str(engine->type));
                 
                         xtype = DTLS_TYPE_RTP;
                         if (engine->rtcp_mux > 0) xtype |= DTLS_TYPE_RTCP;
                         
                         switch_rtp_add_dtls(engine->rtp_session, &engine->local_dtls_fingerprint, &engine->remote_dtls_fingerprint, dtype | xtype);
                 
                         if (engine->rtcp_mux < 1) {
                                 xtype = DTLS_TYPE_RTCP;
                                 switch_rtp_add_dtls(engine->rtp_session, &engine->local_dtls_fingerprint, &engine->remote_dtls_fingerprint, dtype | xtype);
                         }
                 
                 }
                 engine->new_dtls = 0;
         }
 }

static int check_engine ( switch_rtp_engine_t * engine )

static

Definition at line 9176 of file switch_core_media.c.

References DS_FAIL, DS_READY, DTLS_TYPE_RTP, switch_rtp_engine_s::read_frame, switch_rtp_engine_s::rtp_session, SWITCH_READ_ACCEPTABLE, switch_rtp_dtls_state(), and switch_rtp_zerocopy_read_frame().

Referenced by switch_core_media_check_dtls().

 {
         dtls_state_t dtls_state = switch_rtp_dtls_state(engine->rtp_session, DTLS_TYPE_RTP);
         int flags = 0;
         switch_status_t status;
         
         if (dtls_state == DS_READY || dtls_state >= DS_FAIL) return 0;
 
         status = switch_rtp_zerocopy_read_frame(engine->rtp_session, &engine->read_frame, flags);
         
         if (!SWITCH_READ_ACCEPTABLE(status)) {
                 return 0;
         }
 
         return 1;
 }

static switch_status_t check_ice	(	switch_media_handle_t *	smh,
		switch_media_type_t	type,
		sdp_session_t *	sdp,
		sdp_media_t *	m
	)

static

Definition at line 3229 of file switch_core_media.c.

Referenced by switch_core_media_negotiate_sdp().

 {
         switch_rtp_engine_t *engine = &smh->engines[type];
         sdp_attribute_t *attr;
         int i = 0, got_rtcp_mux = 0;
         const char *val;
         int ice_seen = 0, cid = 0, ai = 0;
 
         //if (engine->ice_in.is_chosen[0] && engine->ice_in.is_chosen[1]) {
                 //return SWITCH_STATUS_SUCCESS;
         //}
 
         engine->ice_in.chosen[0] = 0;
         engine->ice_in.chosen[1] = 0;
         engine->ice_in.is_chosen[0] = 0;
         engine->ice_in.is_chosen[1] = 0;
         engine->ice_in.cand_idx[0] = 0;
         engine->ice_in.cand_idx[1] = 0;
         engine->remote_ssrc = 0;
 
         if (m) {
                 attr = m->m_attributes;
         } else {
                 attr = sdp->sdp_attributes;
         }
 
         for (; attr; attr = attr->a_next) {
                 char *data;
                 char *fields[15];
                 int argc = 0, j = 0;
 
                 if (zstr(attr->a_name)) {
                         continue;
                 }
                 
                 if (!strcasecmp(attr->a_name, "ice-ufrag")) {
                         if (engine->ice_in.ufrag && !strcmp(engine->ice_in.ufrag, attr->a_value)) {
                                 engine->new_ice = 0;
                         } else {
                                 engine->ice_in.ufrag = switch_core_session_strdup(smh->session, attr->a_value);
                                 engine->new_ice = 1;
                         }
                         ice_seen++;
                 } else if (!strcasecmp(attr->a_name, "ice-pwd")) {
                         if (!engine->ice_in.pwd || strcmp(engine->ice_in.pwd, attr->a_value)) {
                                 engine->ice_in.pwd = switch_core_session_strdup(smh->session, attr->a_value);
                         }
                 } else if (!strcasecmp(attr->a_name, "ice-options")) {
                         engine->ice_in.options = switch_core_session_strdup(smh->session, attr->a_value);
                 } else if (!strcasecmp(attr->a_name, "setup")) {
                         if (!strcasecmp(attr->a_value, "passive") || !strcasecmp(attr->a_value, "actpass")) {
                                 if (!engine->dtls_controller) {
                                         engine->new_dtls = 1;
                                         engine->new_ice = 1;
                                 }
                                 engine->dtls_controller = 1;
                         } else if (!strcasecmp(attr->a_value, "active")) {
                                 if (engine->dtls_controller) {
                                         engine->new_dtls = 1;
                                         engine->new_ice = 1;
                                 }
                                 engine->dtls_controller = 0;
                         }
                 } else if (switch_rtp_has_dtls() && dtls_ok(smh->session) && !strcasecmp(attr->a_name, "fingerprint") && !zstr(attr->a_value)) {
                         char *p;
 
                         engine->remote_dtls_fingerprint.type = switch_core_session_strdup(smh->session, attr->a_value);
                         
                         if ((p = strchr(engine->remote_dtls_fingerprint.type, ' '))) {
                                 *p++ = '\0';
 
                                 if (switch_channel_test_flag(smh->session->channel, CF_REINVITE) && !switch_channel_test_flag(smh->session->channel, CF_RECOVERING) &&
                                         !zstr(engine->remote_dtls_fingerprint.str) && !strcmp(engine->remote_dtls_fingerprint.str, p)) {
                                                 engine->new_dtls = 0;
                                 } else {
                                         switch_set_string(engine->remote_dtls_fingerprint.str, p);
                                         engine->new_dtls = 1;
                                         engine->new_ice = 1;
                                 }
                         }
                         
 
                         //if (strcasecmp(engine->remote_dtls_fingerprint.type, "sha-256")) {
                         //      switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_WARNING, "Unsupported fingerprint type.\n");
                                 //engine->local_dtls_fingerprint.type = NULL;
                                 //engine->remote_dtls_fingerprint.type = NULL;
                         //}
 
 
                         generate_local_fingerprint(smh, type);
                         switch_channel_set_flag(smh->session->channel, CF_DTLS);
                         
                 } else if (!engine->remote_ssrc && !strcasecmp(attr->a_name, "ssrc") && attr->a_value) {
                         engine->remote_ssrc = (uint32_t) atol(attr->a_value);
 
                         if (engine->rtp_session && engine->remote_ssrc) {
                                 switch_rtp_set_remote_ssrc(engine->rtp_session, engine->remote_ssrc);
                         }
         
 
 #ifdef RTCP_MUX
                 } else if (!strcasecmp(attr->a_name, "rtcp-mux")) {
                         engine->rtcp_mux = SWITCH_TRUE;
                         engine->remote_rtcp_port = engine->cur_payload_map->remote_sdp_port;
                         got_rtcp_mux++;
 #endif
                 } else if (!strcasecmp(attr->a_name, "candidate")) {
                         switch_channel_set_flag(smh->session->channel, CF_ICE);
 
                         if (!engine->cand_acl_count) {
                                 engine->cand_acl[engine->cand_acl_count++] = "wan.auto";
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_WARNING, "NO candidate ACL defined, Defaulting to wan.auto\n");
                         }
 
 
                         if (!switch_stristr(" udp ", attr->a_value)) {
                                 continue;
                         }
 
                         data = switch_core_session_strdup(smh->session, attr->a_value);
                         
                         argc = switch_split(data, ' ', fields);
                         
                         cid = fields[1] ? atoi(fields[1]) - 1 : 0;
 
                         if (argc < 5 || engine->ice_in.cand_idx[cid] >= MAX_CAND - 1) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_WARNING, "Invalid data\n");
                                 continue;
                         }
 
                         for (i = 0; i < argc; i++) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG1, "CAND %d [%s]\n", i, fields[i]);
                         }
 
                         if (!ip_possible(smh, fields[4])) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, 
                                                                   "Drop %s Candidate cid: %d proto: %s type: %s addr: %s:%s (no network path)\n", 
                                                                   type == SWITCH_MEDIA_TYPE_VIDEO ? "video" : "audio",
                                                                   cid+1, fields[2], fields[7], fields[4], fields[5]);
                                 continue;
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, 
                                                                   "Save %s Candidate cid: %d proto: %s type: %s addr: %s:%s\n", 
                                                                   type == SWITCH_MEDIA_TYPE_VIDEO ? "video" : "audio",
                                                                   cid+1, fields[2], fields[7], fields[4], fields[5]);
                         }
                 
                         
                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].foundation = switch_core_session_strdup(smh->session, fields[0]);
                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].component_id = atoi(fields[1]);
                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].transport = switch_core_session_strdup(smh->session, fields[2]);
                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].priority = atol(fields[3]);
                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].con_addr = switch_core_session_strdup(smh->session, fields[4]);
                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].con_port = (switch_port_t)atoi(fields[5]);
                                 
                         j = 6;
 
                         while(j < argc && fields[j+1]) {
                                 if (!strcasecmp(fields[j], "typ")) {
                                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].cand_type = switch_core_session_strdup(smh->session, fields[j+1]);                                                      
                                 } else if (!strcasecmp(fields[j], "raddr")) {
                                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].raddr = switch_core_session_strdup(smh->session, fields[j+1]);
                                 } else if (!strcasecmp(fields[j], "rport")) {
                                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].rport = (switch_port_t)atoi(fields[j+1]);
                                 } else if (!strcasecmp(fields[j], "generation")) {
                                         engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].generation = switch_core_session_strdup(smh->session, fields[j+1]);
                                 }
                                 
                                 j += 2;
                         }
                         
                         engine->ice_in.cand_idx[cid]++;
                 }
         }
 
         if (!ice_seen) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
 
         for (cid = 0; cid < 2; cid++) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "Searching for %s candidate.\n", cid ? "rtcp" : "rtp");
 
                 for (ai = 0; ai < engine->cand_acl_count; ai++) {
                         for (i = 0; i < engine->ice_in.cand_idx[cid]; i++) {
                                 if (switch_check_network_list_ip(engine->ice_in.cands[i][cid].con_addr, engine->cand_acl[ai])) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, 
                                                                           "Choose %s candidate, index %d, %s:%d\n", cid ? "rtcp" : "rtp", i,
                                                                           engine->ice_in.cands[i][cid].con_addr, engine->ice_in.cands[i][cid].con_port);
 
                                         engine->ice_in.chosen[cid] = i;
                                         engine->ice_in.is_chosen[cid] = 1;
                                         engine->ice_in.cands[i][cid].ready++;
                                         ip_choose_family(smh, engine->ice_in.cands[i][cid].con_addr);
                                         
                                         if (cid == 0 && got_rtcp_mux && engine->ice_in.cand_idx[1] < MAX_CAND) {
                                                 
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG,
                                                                                   "Choose same candidate, index %d, for rtcp based on rtcp-mux attribute %s:%d\n", engine->ice_in.cand_idx[1],
                                                                                   engine->ice_in.cands[i][cid].con_addr, engine->ice_in.cands[i][cid].con_port);
 
 
                                                 engine->ice_in.cands[engine->ice_in.cand_idx[1]][1] = engine->ice_in.cands[i][0];
                                                 engine->ice_in.chosen[1] = engine->ice_in.cand_idx[1];
                                                 engine->ice_in.is_chosen[1] = 1;
                                                 engine->ice_in.cand_idx[1]++;
                                                 
                                                 goto done_choosing;
                                         }
                                         
                                         goto next_cid;
                                 }
                         }
                 }
 
         next_cid:
 
                 continue;
         }
 
  done_choosing:
 
 
         if (!engine->ice_in.is_chosen[0] || !engine->ice_in.is_chosen[1]) {
                 /* PUNT */
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "%s no suitable candidates found.\n", 
                                                   switch_channel_get_name(smh->session->channel));
                 return SWITCH_STATUS_FALSE;
         }
 
         for (i = 0; i < 2; i++) {
                 if (engine->ice_in.cands[engine->ice_in.chosen[i]][i].ready) {
                         if (zstr(engine->ice_in.ufrag) || zstr(engine->ice_in.pwd)) {
                                 engine->ice_in.cands[engine->ice_in.chosen[i]][i].ready = 0;
                         }
                 }
         }
 
 
         if (engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr && engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port) {
                 char tmp[80] = "";
                 engine->cur_payload_map->remote_sdp_ip = switch_core_session_strdup(smh->session, (char *) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr);
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, 
                                                   "setting remote %s ice addr to index %d %s:%d based on candidate\n", type2str(type), engine->ice_in.chosen[0],
                                                   engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr, engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port);
                 engine->ice_in.cands[engine->ice_in.chosen[0]][0].ready++;
 
                 engine->remote_rtp_ice_port = (switch_port_t) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port;
                 engine->remote_rtp_ice_addr = switch_core_session_strdup(smh->session, engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr);
 
                 engine->cur_payload_map->remote_sdp_ip = switch_core_session_strdup(smh->session, (char *) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr);
                 engine->cur_payload_map->remote_sdp_port = (switch_port_t) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port;
                 
                 if (!smh->mparams->remote_ip) {
                         smh->mparams->remote_ip = engine->cur_payload_map->remote_sdp_ip;
                 }
                 
                 switch_snprintf(tmp, sizeof(tmp), "%d", engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port);
                 switch_channel_set_variable(smh->session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr);
                 switch_channel_set_variable(smh->session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE, tmp);                                     
         }
 
         if (engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG,
                                                   "Setting remote rtcp %s addr to %s:%d based on candidate\n", type2str(type),
                                                   engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_addr, engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port);
                 engine->remote_rtcp_ice_port = engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port;
                 engine->remote_rtcp_ice_addr = switch_core_session_strdup(smh->session, engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_addr);
                 
                 engine->remote_rtcp_port = engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port;
         }
 
 
         if (m && !got_rtcp_mux) {
                 engine->rtcp_mux = -1;
         }
 
         if (switch_channel_test_flag(smh->session->channel, CF_REINVITE)) {
                 if (switch_rtp_ready(engine->rtp_session) && engine->ice_in.cands[engine->ice_in.chosen[0]][0].ready && engine->new_ice) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "RE-Activating %s ICE\n", type2str(type));
 
                         switch_rtp_activate_ice(engine->rtp_session, 
                                                                         engine->ice_in.ufrag,
                                                                         engine->ice_out.ufrag,
                                                                         engine->ice_out.pwd,
                                                                         engine->ice_in.pwd,
                                                                         IPR_RTP,
 #ifdef GOOGLE_ICE
                                                                         ICE_GOOGLE_JINGLE,
                                                                         NULL
 #else
                                                                         switch_ice_direction(smh->session) == 
                                                                         SWITCH_CALL_DIRECTION_OUTBOUND ? ICE_VANILLA : (ICE_VANILLA | ICE_CONTROLLED),
                                                                         &engine->ice_in
 #endif
                                                                         );
 
                 
                         engine->new_ice = 0;
                 }
                 
 
                 if (engine->rtp_session && ((val = switch_channel_get_variable(smh->session->channel,
                                                                                                                                            type == SWITCH_MEDIA_TYPE_VIDEO ? 
                                                                                                                                            "rtcp_video_interval_msec" : "rtcp_audio_interval_msec")) 
                                                                         || (val = type == SWITCH_MEDIA_TYPE_VIDEO ? 
                                                                                 smh->mparams->rtcp_video_interval_msec : smh->mparams->rtcp_audio_interval_msec))) {
                         
                         switch_port_t remote_rtcp_port = engine->remote_rtcp_port;
 
                         if (remote_rtcp_port) {
                                 if (!strcasecmp(val, "passthru")) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "Activating %s RTCP PASSTHRU PORT %d\n", 
                                                                           type2str(type), remote_rtcp_port);
                                         switch_rtp_activate_rtcp(engine->rtp_session, -1, remote_rtcp_port, engine->rtcp_mux > 0);
                                 } else {
                                         int interval = atoi(val);
                                         if (interval < 100 || interval > 500000) {
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_ERROR,
                                                                                   "Invalid rtcp interval spec [%d] must be between 100 and 500000\n", interval);
                                                 interval = 5000;
                                         }
 
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "Activating %s RTCP PORT %d\n", type2str(type), remote_rtcp_port);
                                         switch_rtp_activate_rtcp(engine->rtp_session, interval, remote_rtcp_port, engine->rtcp_mux > 0);
                                 }
                         }
                 }
                         
                 if (engine->rtp_session && engine->ice_in.cands[engine->ice_in.chosen[1]][1].ready) {
                         if (engine->rtcp_mux > 0 && !strcmp(engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_addr, engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr)
                                 && engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port == engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "Skipping %s RTCP ICE (Same as RTP)\n", type2str(type));
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "Activating %s RTCP ICE\n", type2str(type));
                                 
                                 switch_rtp_activate_ice(engine->rtp_session, 
                                                                                 engine->ice_in.ufrag,
                                                                                 engine->ice_out.ufrag,
                                                                                 engine->ice_out.pwd,
                                                                                 engine->ice_in.pwd,
                                                                                 IPR_RTCP,
 #ifdef GOOGLE_ICE
                                                                                 ICE_GOOGLE_JINGLE,
                                                                                 NULL
 #else
                                                                                 switch_ice_direction(smh->session) == 
                                                                                 SWITCH_CALL_DIRECTION_OUTBOUND ? ICE_VANILLA : (ICE_VANILLA | ICE_CONTROLLED),
                                                                                 &engine->ice_in
 #endif
                                                                                 );
                         }
                         
                 }
                 
         }
 
         return ice_seen ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_BREAK;
 }

static void check_jb	(	switch_core_session_t *	session,
		const char *	input,
		int32_t	jb_msec,
		int32_t	maxlen,
		switch_bool_t	silent
	)

static

Definition at line 1875 of file switch_core_media.c.

References CF_JITTERBUFFER, CF_JITTERBUFFER_PLC, switch_core_session::channel, switch_media_handle_s::engines, switch_codec::implementation, switch_core_media_params_s::jb_msec, switch_core_session::media_handle, switch_codec_implementation::microseconds_per_packet, switch_media_handle_s::mparams, switch_rtp_engine_s::read_codec, switch_rtp_engine_s::read_impl, switch_rtp_engine_s::rtp_session, switch_codec_implementation::samples_per_packet, switch_codec_implementation::samples_per_second, switch_assert, switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_variable, SWITCH_FALSE, switch_false(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_TYPE_VIDEO, switch_rtp_activate_jitter_buffer(), switch_rtp_deactivate_jitter_buffer(), switch_rtp_debug_jitter_buffer(), switch_rtp_pause_jitter_buffer(), switch_rtp_set_video_buffer_size(), SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and zstr.

Referenced by check_jb_sync(), switch_core_media_activate_rtp(), switch_core_media_read_frame(), and switch_core_media_receive_message().

 {
         const char *val;
         switch_media_handle_t *smh;
         switch_rtp_engine_t *a_engine = NULL, *v_engine = NULL;
 
         switch_assert(session);
 
         if (!(smh = session->media_handle)) {
                 return;
         }
 
         a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
         v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
 
 
         if (!zstr(input)) {
                 const char *s;
                 if (a_engine->rtp_session) {
                         if (!strcasecmp(input, "pause")) {
                                 switch_rtp_pause_jitter_buffer(a_engine->rtp_session, SWITCH_TRUE);
                                 return;
                         } else if (!strcasecmp(input, "resume")) {
                                 switch_rtp_pause_jitter_buffer(a_engine->rtp_session, SWITCH_FALSE);
                                 return;
                         } else if (!strcasecmp(input, "stop")) {
                                 switch_rtp_deactivate_jitter_buffer(a_engine->rtp_session);
                                 return;
                         } else if (!strncasecmp(input, "debug:", 6)) {
                                 s = input + 6;
                                 if (s && !strcmp(s, "off")) {
                                         s = NULL;
                                 }
                                 switch_rtp_debug_jitter_buffer(a_engine->rtp_session, s);
                                 return;
                         }
 
                         switch_channel_set_variable(session->channel, "jitterbuffer_msec", input);
                 }
                 
                 if (v_engine->rtp_session) {
                         if (!strncasecmp(input, "vbsize:", 7)) {
                                 int frames = 0, max_frames = 0;
                                 s = input + 7;
                                 
                                 frames = atoi(s);
 
                                 if ((s = strchr(s, ':')) && *(s+1) != '\0') {
                                         max_frames = atoi(s+1);
                                 }
                                 
                                 if (frames > 0) {
                                         switch_rtp_set_video_buffer_size(v_engine->rtp_session, frames, max_frames);
                                 }
                                 return;
                         } else if (!strncasecmp(input, "vdebug:", 7)) {
                                 s = input + 7;
                                 
                                 if (s && !strcmp(s, "off")) {
                                         s = NULL;
                                 }
                                 switch_rtp_debug_jitter_buffer(v_engine->rtp_session, s);
                                 return;
                         }
                 }
         }
         
 
         if (jb_msec || (val = switch_channel_get_variable(session->channel, "jitterbuffer_msec")) || (val = smh->mparams->jb_msec)) {
                 char *p;
 
                 if (!jb_msec) {
                         jb_msec = atoi(val);
 
                         if (strchr(val, 'p') && jb_msec > 0) {
                                 jb_msec *= -1;
                         }
                                         
                         if ((p = strchr(val, ':'))) {
                                 p++;
                                 maxlen = atoi(p);
 
                                 if (strchr(p, 'p') && maxlen > 0) {
                                         maxlen *= -1;
                                 }
                         }
                 }
 
                 if (jb_msec < 0 && jb_msec > -1000) {
                         jb_msec = (a_engine->read_codec.implementation->microseconds_per_packet / 1000) * abs(jb_msec);
                 }
 
                 if (maxlen < 0 && maxlen > -1000) {
                         maxlen = (a_engine->read_codec.implementation->microseconds_per_packet / 1000) * abs(maxlen);
                 }
 
                 if (jb_msec < 10 || jb_msec > 10000) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                                                           "Invalid Jitterbuffer spec [%d] must be between 10 and 10000\n", jb_msec);
                 } else {
                         int qlen, maxqlen = 50;
                         
                         qlen = jb_msec / (a_engine->read_impl.microseconds_per_packet / 1000);
 
                         if (maxlen) {
                                 maxqlen = maxlen / (a_engine->read_impl.microseconds_per_packet / 1000);
                         }
 
                         if (maxqlen < qlen) {
                                 maxqlen = qlen * 5;
                         }
                         if (switch_rtp_activate_jitter_buffer(a_engine->rtp_session, qlen, maxqlen,
                                                                                                   a_engine->read_impl.samples_per_packet, 
                                                                                                   a_engine->read_impl.samples_per_second) == SWITCH_STATUS_SUCCESS) {
                                 if (!silent) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), 
                                                                           SWITCH_LOG_DEBUG, "Setting Jitterbuffer to %dms (%d frames) (%d max frames)\n", 
                                                                           jb_msec, qlen, maxqlen);
                                 }
                                 switch_channel_set_flag(session->channel, CF_JITTERBUFFER);
                                 if (!switch_false(switch_channel_get_variable(session->channel, "rtp_jitter_buffer_plc"))) {
                                         switch_channel_set_flag(session->channel, CF_JITTERBUFFER_PLC);
                                 }
                         } else if (!silent) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), 
                                                                   SWITCH_LOG_WARNING, "Error Setting Jitterbuffer to %dms (%d frames)\n", jb_msec, qlen);
                         }
                                 
                 }
         }
 
 }

static void check_jb_sync ( switch_core_session_t * session )

static

Definition at line 2008 of file switch_core_media.c.

References CF_VIDEO, switch_core_session::channel, check_jb(), switch_media_handle_s::engines, core_video_globals_s::fps, switch_core_session::media_handle, switch_rtp_engine_s::rtp_session, switch_assert, switch_channel_get_name(), switch_channel_get_variable_dup(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_core_media_get_video_fps(), switch_core_session_get_uuid(), SWITCH_FALSE, SWITCH_LOG_DEBUG1, switch_log_printf(), SWITCH_MEDIA_TYPE_VIDEO, switch_rtp_get_video_buffer_size(), switch_rtp_set_video_buffer_size(), SWITCH_TRUE, and core_video_globals_s::synced.

Referenced by switch_core_media_read_frame().

 {
         int32_t jb_sync_msec = 0;
         uint32_t fps = 0, frames = 0;
         uint32_t min_frames = 0;
         uint32_t max_frames = 0;
         uint32_t cur_frames = 0;
         switch_media_handle_t *smh;
         switch_rtp_engine_t *v_engine = NULL;
         int sync_audio = 0, sync_video = 0;
 
         const char *var;
 
         switch_assert(session);
 
         if (!switch_channel_test_flag(session->channel, CF_VIDEO)) {
                 return;
         }
 
         if (!(smh = session->media_handle)) {
                 return;
         }
 
         v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
         
         if ((var = switch_channel_get_variable_dup(session->channel, "jb_av_sync_msec", SWITCH_FALSE, -1))) {
                 int tmp;
                 char *p;
                 
                 if (!strcasecmp(var, "disabled")) {
                         return;
                 }
 
                 tmp = atol(var);
 
                 if (tmp && tmp > -50 && tmp < 10000) {
                         jb_sync_msec = tmp;
                 }
 
                 if ((p = strchr(var, ':'))) {
                         p++;
                         frames = atoi(p);
                 }
         }
         
         fps = switch_core_media_get_video_fps(session);
         
         switch_rtp_get_video_buffer_size(v_engine->rtp_session, &min_frames, &max_frames, &cur_frames, NULL);
 
         if (!frames) {
                 if (cur_frames != min_frames) {
                         frames = cur_frames;
                 } else {
                         frames = fps / 7.5;
                         if (frames < 1) frames = 1;
                         sync_audio = 1;
                 }
         }
         
         if (!jb_sync_msec) {
                 jb_sync_msec = frames * 75;
         }
         
 
         if (frames != cur_frames) {
                 switch_rtp_set_video_buffer_size(v_engine->rtp_session, frames, 0);
                 sync_audio = 1;
                 sync_video = 1;
         }
 
         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session),
                                           SWITCH_LOG_DEBUG1, "%s %s \"%s\" Sync A/V JB to %dms %u VFrames FPS %u a:%s v:%s\n", 
                                           switch_core_session_get_uuid(session),
                                           switch_channel_get_name(session->channel),
                                           switch_channel_get_variable_dup(session->channel, "caller_id_name", SWITCH_FALSE, -1),
                                           jb_sync_msec, frames, video_globals.fps, sync_audio ? "yes" : "no", sync_video ? "yes" : "no");
         
         if (sync_audio) {
                 check_jb(session, NULL, jb_sync_msec, 0, SWITCH_TRUE);
         }
 
         video_globals.synced++;
 }

static void clear_ice	(	switch_core_session_t *	session,
		switch_media_type_t	type
	)

static

Definition at line 3001 of file switch_core_media.c.

References ice_s::cand_idx, ice_s::chosen, switch_media_handle_s::engines, switch_rtp_engine_s::ice_in, ice_s::is_chosen, switch_core_session::media_handle, memset(), switch_rtp_engine_s::remote_rtcp_port, switch_rtp_engine_s::rtp_session, switch_assert, and switch_rtp_reset().

Referenced by switch_core_media_clear_ice().

 {
         switch_media_handle_t *smh;
         switch_rtp_engine_t *engine;
 
         switch_assert(session);
 
         if (!(smh = session->media_handle)) {
                 return;
         }
 
         engine = &smh->engines[type];
 
         engine->ice_in.chosen[0] = 0;
         engine->ice_in.chosen[1] = 0;
         engine->ice_in.is_chosen[0] = 0;
         engine->ice_in.is_chosen[1] = 0;
         engine->ice_in.cand_idx[0] = 0;
         engine->ice_in.cand_idx[1] = 0;
         memset(&engine->ice_in, 0, sizeof(engine->ice_in));
         engine->remote_rtcp_port = 0;
 
         if (engine->rtp_session) {
                 switch_rtp_reset(engine->rtp_session);
         }
 
 }

static void clear_pmaps ( switch_rtp_engine_t * engine )

static

Definition at line 3636 of file switch_core_media.c.

References payload_map_s::allocated, payload_map_s::current, payload_map_s::negotiated, payload_map_s::next, and switch_rtp_engine_s::payload_map.

Referenced by switch_core_media_check_outgoing_proxy(), switch_core_media_negotiate_sdp(), switch_core_media_patch_sdp(), and switch_core_media_receive_message().

 {
         payload_map_t *pmap;
 
         for (pmap = engine->payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                 pmap->negotiated = 0;
                 pmap->current = 0;
         }
 }

static int dtls_ok ( switch_core_session_t * session )

static

Definition at line 3152 of file switch_core_media.c.

References CF_DTLS_OK, switch_core_session::channel, and switch_channel_test_flag().

Referenced by check_dtls_reinvite(), check_ice(), switch_core_media_activate_rtp(), switch_core_media_gen_local_sdp(), and switch_core_media_negotiate_sdp().

 {
         return switch_channel_test_flag(session->channel, CF_DTLS_OK);
 }

static int find_pt	(	const char *	sdp,
		const char *	name
	)

static

Definition at line 10665 of file switch_core_media.c.

References end_of_p, and switch_stristr().

Referenced by switch_core_media_filter_sdp().

 {
         const char *p;
         
         if ((p = switch_stristr(name, sdp))) {
                 if (p < end_of_p(sdp) && *(p+strlen(name)) == '/' && *(p-1) == ' ') {
                         p -= 2;
 
                         while(*p > 47 && *p < 58) {
                                 p--;
                         }
                         p++;
 
                         if (p) {
                                 return atoi(p);
                         }
                 }
         }
 
         return -1;
 }

static void gen_ice	(	switch_core_session_t *	session,
		switch_media_type_t	type,
		const char *	ip,
		switch_port_t	port
	)

static

Definition at line 6089 of file switch_core_media.c.

References ice_s::cands, switch_media_handle_s::cname, icand_s::component_id, icand_s::con_addr, icand_s::con_port, switch_media_handle_s::engines, icand_s::foundation, icand_s::generation, switch_rtp_engine_s::ice_out, switch_core_session::media_handle, switch_media_handle_s::msid, icand_s::priority, ice_s::pwd, icand_s::ready, switch_rtp_engine_s::rtcp_mux, switch_assert, switch_core_session_strdup, switch_stun_random_string(), SWITCH_TRUE, icand_s::transport, ice_s::ufrag, and zstr.

Referenced by generate_m(), switch_core_media_activate_rtp(), switch_core_media_gen_local_sdp(), and switch_core_session_stop_media().

 {
         switch_media_handle_t *smh;
         switch_rtp_engine_t *engine;
         char tmp[33] = "";
 
         switch_assert(session);
 
         if (!(smh = session->media_handle)) {
                 return;
         }
 
         engine = &smh->engines[type];
 
 #ifdef RTCP_MUX
         if (!engine->rtcp_mux) {//  && type == SWITCH_MEDIA_TYPE_AUDIO) {
                 engine->rtcp_mux = SWITCH_TRUE;
         }
 #endif
 
         if (!smh->msid) {
                 switch_stun_random_string(tmp, 32, NULL);
                 tmp[32] = '\0';
                 smh->msid = switch_core_session_strdup(session, tmp);
         }
 
         if (!smh->cname) {
                 switch_stun_random_string(tmp, 16, NULL);
                 tmp[16] = '\0';
                 smh->cname = switch_core_session_strdup(session, tmp);
         }
         
         if (!engine->ice_out.ufrag) {
                 switch_stun_random_string(tmp, 16, NULL);
                 tmp[16] = '\0';
                 engine->ice_out.ufrag = switch_core_session_strdup(session, tmp);
         }
 
         if (!engine->ice_out.pwd) {
                 switch_stun_random_string(tmp, 24, NULL);
                 tmp[24] = '\0';
                 engine->ice_out.pwd = switch_core_session_strdup(session, tmp); 
         }
 
         if (!engine->ice_out.cands[0][0].foundation) {
                 switch_stun_random_string(tmp, 10, "0123456789");
                 tmp[10] = '\0';
                 engine->ice_out.cands[0][0].foundation = switch_core_session_strdup(session, tmp);
         }
 
         engine->ice_out.cands[0][0].transport = "udp";
 
         if (!engine->ice_out.cands[0][0].component_id) {
                 engine->ice_out.cands[0][0].component_id = 1;
                 engine->ice_out.cands[0][0].priority = (2^24)*126 + (2^8)*65535 + (2^0)*(256 - engine->ice_out.cands[0][0].component_id);
         }
 
         if (!zstr(ip)) {
                 engine->ice_out.cands[0][0].con_addr = switch_core_session_strdup(session, ip);
         }
 
         if (port) {
                 engine->ice_out.cands[0][0].con_port = port;
         }
 
         engine->ice_out.cands[0][0].generation = "0";
         //add rport stuff later
         
         engine->ice_out.cands[0][0].ready = 1;
 
 
 }

static void generate_local_fingerprint	(	switch_media_handle_t *	smh,
		switch_media_type_t	type
	)

static

Definition at line 3137 of file switch_core_media.c.

References DTLS_SRTP_FNAME, switch_media_handle_s::engines, dtls_fp_s::len, switch_rtp_engine_s::local_dtls_fingerprint, switch_rtp_engine_s::remote_dtls_fingerprint, switch_core_cert_gen_fingerprint(), and dtls_fp_s::type.

Referenced by check_ice(), and switch_core_media_gen_local_sdp().

 {
         switch_rtp_engine_t *engine = &smh->engines[type];
 
         if (!engine->local_dtls_fingerprint.len) {
                 if (engine->remote_dtls_fingerprint.type) {
                         engine->local_dtls_fingerprint.type = engine->remote_dtls_fingerprint.type;
                 } else {
                         engine->local_dtls_fingerprint.type = "sha-256";
                 }
                 switch_core_cert_gen_fingerprint(DTLS_SRTP_FNAME, &engine->local_dtls_fingerprint);
         }
 }

static void generate_m	(	switch_core_session_t *	session,
		char *	buf,
		size_t	buflen,
		switch_port_t	port,
		const char *	family,
		const char *	ip,
		int	cur_ptime,
		const char *	append_audio,
		const char *	sr,
		int	use_cng,
		int	cng_type,
		switch_event_t *	map,
		int	secure,
		switch_sdp_type_t	sdp_type
	)

static

Definition at line 7096 of file switch_core_media.c.

Referenced by switch_core_media_gen_local_sdp().

 {
         int i = 0;
         int rate;
         int already_did[128] = { 0 };
         int ptime = 0, noptime = 0;
         const char *local_sdp_audio_zrtp_hash;
         switch_media_handle_t *smh;
         switch_rtp_engine_t *a_engine;
 
         switch_assert(session);
 
         if (!(smh = session->media_handle)) {
                 return;
         }
 
         a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
 
         //switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "m=audio %d RTP/%sAVP%s", 
         //port, secure ? "S" : "", switch_channel_test_flag(session->channel, CF_AVPF) ? "F" : "");
 
         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "m=audio %d %s", port, 
                                         get_media_profile_name(session, secure || a_engine->crypto_type != CRYPTO_INVALID));
 
         for (i = 0; i < smh->mparams->num_codecs; i++) {
                 const switch_codec_implementation_t *imp = smh->codecs[i];
                 int this_ptime = (imp->microseconds_per_packet / 1000);
 
                 if (!strcasecmp(imp->iananame, "ilbc") || !strcasecmp(imp->iananame, "isac") ) {
                         this_ptime = 20;
                 }
 
                 if (imp->codec_type != SWITCH_CODEC_TYPE_AUDIO) {
                         continue;
                 }
 
                 if (!noptime) {
                         if (!cur_ptime) {
                                 if (!ptime) {
                                         ptime = this_ptime;
                                 }
                         } else {
                                 if (this_ptime != cur_ptime) {
                                         continue;
                                 }
                         }
                 }
 
                 if (smh->ianacodes[i] < 128) {
                         if (already_did[smh->ianacodes[i]]) {
                                 continue;
                         }
 
                         already_did[smh->ianacodes[i]] = 1;
                 }
 
                 
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), " %d", smh->ianacodes[i]);
         }
 
         if (smh->mparams->dtmf_type == DTMF_2833 && smh->mparams->te > 95) {
                 int i;
                 for (i = 0; i < smh->num_rates; i++) {
                         if (smh->dtmf_ianacodes[i]) {
                                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), " %d", smh->dtmf_ianacodes[i]);
                         }
                         if (smh->cng_ianacodes[i] && !switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) && cng_type && use_cng) {
                                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), " %d", smh->cng_ianacodes[i]);
                         }
                 }
         }
                 
         //if (!switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) && cng_type && use_cng) {
                 //switch_snprintf(buf + strlen(buf), buflen - strlen(buf), " %d", cng_type);
         //}
                 
         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "\r\n");
 
 
         memset(already_did, 0, sizeof(already_did));
 
                 
         for (i = 0; i < smh->mparams->num_codecs; i++) {
                 const switch_codec_implementation_t *imp = smh->codecs[i];
                 char *fmtp = imp->fmtp;
                 int this_ptime = imp->microseconds_per_packet / 1000;
 
                 if (imp->codec_type != SWITCH_CODEC_TYPE_AUDIO) {
                         continue;
                 }
 
                 if (!strcasecmp(imp->iananame, "ilbc") || !strcasecmp(imp->iananame, "isac")) {
                         this_ptime = 20;
                 }
 
                 if (!noptime) {
                         if (!cur_ptime) {
                                 if (!ptime) {
                                         ptime = this_ptime;
                                 }
                         } else {
                                 if (this_ptime != cur_ptime) {
                                         continue;
                                 }
                         }
                 }
                 
                 if (smh->ianacodes[i] < 128) {
                         if (already_did[smh->ianacodes[i]]) {
                                 continue;
                         }
                         
                         already_did[smh->ianacodes[i]] = 1;
                 }
 
                 rate = imp->samples_per_second;
 
                 if (map) {
                         char key[128] = "";
                         char *check = NULL;
                         switch_snprintf(key, sizeof(key), "%s:%u", imp->iananame, imp->bits_per_second);
 
                         if ((check = switch_event_get_header(map, key)) || (check = switch_event_get_header(map, imp->iananame))) {
                                 fmtp = check;
                         }
                 }
 
                 if (smh->fmtps[i]) {
                         fmtp = smh->fmtps[i];
                 }
 
                 if (smh->ianacodes[i] > 95 || switch_channel_test_flag(session->channel, CF_VERBOSE_SDP)) {
                         int channels = get_channels(imp->iananame, imp->number_of_channels);
 
                         if (channels > 1) {
                                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d %s/%d/%d\r\n", smh->ianacodes[i], imp->iananame, rate, channels);
                                                                 
                         } else {
                                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d %s/%d\r\n", smh->ianacodes[i], imp->iananame, rate);
                         }
                 }
 
                 if (fmtp) {
                         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=fmtp:%d %s\r\n", smh->ianacodes[i], fmtp);
                 }
         }
 
 
         if ((smh->mparams->dtmf_type == DTMF_2833 || switch_media_handle_test_media_flag(smh, SCMF_LIBERAL_DTMF) || 
                  switch_channel_test_flag(session->channel, CF_LIBERAL_DTMF)) && smh->mparams->te > 95) {
 
                 for (i = 0; i < smh->num_rates; i++) {
                         if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d telephone-event/%d\r\n", 
                                                                 smh->dtmf_ianacodes[i], smh->rates[i]);
                         } else {
                                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d telephone-event/%d\r\na=fmtp:%d 0-16\r\n", 
                                                                 smh->dtmf_ianacodes[i], smh->rates[i], smh->dtmf_ianacodes[i]);
                         }
                 }
         }
 
         if (!zstr(a_engine->local_dtls_fingerprint.type) && secure) {
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=fingerprint:%s %s\na=setup:%s\r\n", a_engine->local_dtls_fingerprint.type, 
                                                 a_engine->local_dtls_fingerprint.str, get_setup(a_engine, session, sdp_type));
         }
         
         if (smh->mparams->rtcp_audio_interval_msec) {
                 if (a_engine->rtcp_mux > 0) {
                         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-mux\r\n");
                         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp:%d IN %s %s\r\n", port, family, ip);
                 } else {
                         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp:%d IN %s %s\r\n", port + 1, family, ip);
                 }
         }
 
         //switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u\r\n", a_engine->ssrc);
 
         if (a_engine->ice_out.cands[0][0].ready) {
                 char tmp1[11] = "";
                 char tmp2[11] = "";
                 uint32_t c1 = (2^24)*126 + (2^8)*65535 + (2^0)*(256 - 1);
                 uint32_t c2 = c1 - 1;
 
                 //uint32_t c2 = (2^24)*126 + (2^8)*65535 + (2^0)*(256 - 2);
                 //uint32_t c3 = (2^24)*126 + (2^8)*65534 + (2^0)*(256 - 1);
                 //uint32_t c4 = (2^24)*126 + (2^8)*65534 + (2^0)*(256 - 2);
                 ice_t *ice_out;
 
                 tmp1[10] = '\0';
                 tmp2[10] = '\0';
                 switch_stun_random_string(tmp1, 10, "0123456789");
                 switch_stun_random_string(tmp2, 10, "0123456789");
 
                 gen_ice(session, SWITCH_MEDIA_TYPE_AUDIO, NULL, 0);
 
                 ice_out = &a_engine->ice_out;
 
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ssrc:%u cname:%s\r\n", a_engine->ssrc, smh->cname);
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ssrc:%u msid:%s a0\r\n", a_engine->ssrc, smh->msid);
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ssrc:%u mslabel:%s\r\n", a_engine->ssrc, smh->msid);
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ssrc:%u label:%sa0\r\n", a_engine->ssrc, smh->msid);
 
 
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ice-ufrag:%s\r\n", ice_out->ufrag);
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ice-pwd:%s\r\n", ice_out->pwd);
 
 
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ host generation 0\r\n", 
                                                 tmp1, ice_out->cands[0][0].transport, c1,
                                                 ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port
                                                 );
 
                 if (!zstr(a_engine->local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) && 
                         strcmp(a_engine->local_sdp_ip, ice_out->cands[0][0].con_addr)
                         && a_engine->local_sdp_port != ice_out->cands[0][0].con_port) {
 
                         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ srflx raddr %s rport %d generation 0\r\n", 
                                                         tmp2, ice_out->cands[0][0].transport, c2,
                                                         ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port,
                                                         a_engine->local_sdp_ip, a_engine->local_sdp_port
                                                         );
                 }
 
                 if (a_engine->rtcp_mux < 1 || switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND || switch_channel_test_flag(session->channel, CF_RECOVERING)) {
                         
 
                         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ host generation 0\r\n", 
                                                         tmp1, ice_out->cands[0][0].transport, c1,
                                                         ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (a_engine->rtcp_mux > 0 ? 0 : 1)
                                                         );
                         
                         if (!zstr(a_engine->local_sdp_ip) && !zstr(ice_out->cands[0][1].con_addr) && 
                                 strcmp(a_engine->local_sdp_ip, ice_out->cands[0][1].con_addr)
                                 && a_engine->local_sdp_port != ice_out->cands[0][1].con_port) {
                                 
                                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ srflx raddr %s rport %d generation 0\r\n", 
                                                                 tmp2, ice_out->cands[0][0].transport, c2,
                                                                 ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (a_engine->rtcp_mux > 0 ? 0 : 1),
                                                                 a_engine->local_sdp_ip, a_engine->local_sdp_port + (a_engine->rtcp_mux > 0 ? 0 : 1)
                                                                 );
                         }
                 }
 
                         
                                 
 #ifdef GOOGLE_ICE
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ice-options:google-ice\r\n");
 #endif
         }
 
 
         if (secure && !switch_channel_test_flag(session->channel, CF_DTLS)) {
                 int i;
 
                 for (i = 0; smh->crypto_suite_order[i] != CRYPTO_INVALID; i++) {
                         switch_rtp_crypto_key_type_t j = SUITES[smh->crypto_suite_order[i]].type;
 
                         if ((a_engine->crypto_type == j || a_engine->crypto_type == CRYPTO_INVALID) && !zstr(a_engine->ssec[j].local_crypto_key)) {
                                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=crypto:%s\r\n", a_engine->ssec[j].local_crypto_key);
                         }
                 }
                 //switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "a=encryption:optional\r\n");
         }
 
         if (cng_type) {
                 for (i = 0; i < smh->num_rates; i++) {
                         //if (smh->rates[i] == 8000) {
                         //      switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d CN/%d\r\n", cng_type, smh->rates[i]);
                         //} else {
                                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d CN/%d\r\n", smh->cng_ianacodes[i], smh->rates[i]);
                                 //}
                 }
         } else {
                 if (switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG)) { 
                         switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=silenceSupp:off - - - -\r\n");
                 }
         }
 
         if (append_audio) {
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "%s%s", append_audio, end_of(append_audio) == '\n' ? "" : "\r\n");
         }
 
         if (!cur_ptime) {
                 cur_ptime = ptime;
         }
         
         if (!noptime && cur_ptime) {
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ptime:%d\r\n", cur_ptime);
         }
 
         local_sdp_audio_zrtp_hash = switch_core_media_get_zrtp_hash(session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_TRUE);
 
         if (local_sdp_audio_zrtp_hash) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Adding audio a=zrtp-hash:%s\n", local_sdp_audio_zrtp_hash);
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=zrtp-hash:%s\r\n", local_sdp_audio_zrtp_hash);
         }
 
         if (!zstr(sr)) {
                 switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=%s\r\n", sr);
         }
 }

static int get_channels	(	const char *	name,
		int	dft
	)

static

Definition at line 296 of file switch_core_media.c.

References switch_core_get_variable(), switch_true(), and zstr.

Referenced by generate_m(), and switch_core_media_gen_local_sdp().

 {
 
         if (!zstr(name) && !switch_true(switch_core_get_variable("NDLB_broken_opus_sdp")) && !strcasecmp(name, "opus")) {
                 return 2; /* IKR???*/
         }
 
         return dft ? dft : 1;
 }

static const char* get_media_profile_name	(	switch_core_session_t *	session,
		int	secure
	)

static

Definition at line 7053 of file switch_core_media.c.

References CF_AVPF, CF_AVPF_MOZ, CF_DTLS, switch_core_session::channel, switch_assert, and switch_channel_test_flag().

Referenced by generate_m(), and switch_core_media_gen_local_sdp().

 {
         switch_assert(session);
 
         if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                 if (switch_channel_test_flag(session->channel, CF_DTLS) || secure) {
                         if (switch_channel_test_flag(session->channel, CF_AVPF_MOZ)) {
                                 return "UDP/TLS/RTP/SAVPF";
                         } else {
                                 return "RTP/SAVPF";
                         }
                 } else {
                         if (switch_channel_test_flag(session->channel, CF_AVPF_MOZ)) {
                                 return "UDP/AVPF";
                         } else {
                                 return "RTP/AVPF";
                         }
                 }
         }
 
         if (secure) {
                 return "RTP/SAVP";
         }
 
         return "RTP/AVP";
         
 }

static char* get_setup	(	switch_rtp_engine_t *	engine,
		switch_core_session_t *	session,
		switch_sdp_type_t	sdp_type
	)

static

Definition at line 7081 of file switch_core_media.c.

References switch_rtp_engine_s::dtls_controller, switch_rtp_engine_s::new_dtls, switch_rtp_engine_s::new_ice, and SDP_TYPE_REQUEST.

Referenced by generate_m(), and switch_core_media_gen_local_sdp().

 {
 
         if (sdp_type == SDP_TYPE_REQUEST) {
                 engine->dtls_controller = 0;
                 engine->new_dtls = 1;
                 engine->new_ice = 1;
                 return "actpass";
         } else {
                 return engine->dtls_controller ? "active" : "passive";
         }
 }

static void greedy_sort	(	switch_media_handle_t *	smh,
		struct matches *	matches,
		int	m_idx,
		const switch_codec_implementation_t **	codec_array,
		int	total_codecs
	)

static

Definition at line 3618 of file switch_core_media.c.

References matches::imp, switch_media_handle_s::mparams, and switch_core_media_params_s::num_codecs.

Referenced by switch_core_media_negotiate_sdp().

 {
         int j = 0, f = 0, g;
         struct matches mtmp[MAX_MATCHES] = { { 0 } };
         for(j = 0; j < m_idx; j++) {
                 *&mtmp[j] = *&matches[j];
                                         }
         for (g = 0; g < smh->mparams->num_codecs && g < total_codecs; g++) {
                 const switch_codec_implementation_t *imp = codec_array[g];
                 
                 for(j = 0; j < m_idx; j++) {
                         if (mtmp[j].imp == imp) {
                                 *&matches[f++] = *&mtmp[j];
                         }
                 }
         }
 }

static switch_status_t ip_choose_family	(	switch_media_handle_t *	smh,
		const char *	ip
	)

static

Definition at line 3183 of file switch_core_media.c.

References switch_core_session::channel, switch_media_handle_s::mparams, switch_core_media_params_s::rtpip, switch_core_media_params_s::rtpip4, switch_core_media_params_s::rtpip6, switch_media_handle_s::session, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by check_ice().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         if (zstr(ip)) {
                 return status;
         }
 
         if (strchr(ip, ':')) {
                 if (!zstr(smh->mparams->rtpip6)) {
                         smh->mparams->rtpip = smh->mparams->rtpip6;
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "%s choosing family v6\n", 
                                                           switch_channel_get_name(smh->session->channel));
                         status = SWITCH_STATUS_SUCCESS;
                 }
         } else {
                 if (!zstr(smh->mparams->rtpip4)) {
                         smh->mparams->rtpip = smh->mparams->rtpip4;
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "%s choosing family v4\n", 
                                                           switch_channel_get_name(smh->session->channel));
                         status = SWITCH_STATUS_SUCCESS;
                 }
         }
 
         return status;
 }

static switch_bool_t ip_possible	(	switch_media_handle_t *	smh,
		const char *	ip
	)

static

Definition at line 3211 of file switch_core_media.c.

References switch_media_handle_s::mparams, switch_core_media_params_s::rtpip4, switch_core_media_params_s::rtpip6, SWITCH_FALSE, and zstr.

Referenced by check_ice().

 {
         switch_bool_t r = SWITCH_FALSE;
 
         if (zstr(ip)) {
                 return r;
         }
 
         if (strchr(ip, ':')) {
                 r = (switch_bool_t) !zstr(smh->mparams->rtpip6);
         } else {
                 r = (switch_bool_t) !zstr(smh->mparams->rtpip4);
         }
 
         return r;
 }

int next_cpu ( void )

Definition at line 5315 of file switch_core_media.c.

References core_video_globals_s::cpu_count, core_video_globals_s::cur_cpu, core_video_globals_s::mutex, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, switch_log_printf(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_autobind_cpu().

 {
         int x = 0;
 
         switch_mutex_lock(video_globals.mutex);
         x = video_globals.cur_cpu++;
         if (video_globals.cur_cpu == video_globals.cpu_count) {
                 video_globals.cur_cpu = 0;
         }
         switch_mutex_unlock(video_globals.mutex);
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Binding to CPU %d\n", x);
 
         return x;
 }

static int payload_number ( const char * name )

static

Definition at line 10628 of file switch_core_media.c.

Referenced by switch_core_media_filter_sdp().

 {
         if (!strcasecmp(name, "pcmu")) {
                 return 0;
         }
 
         if (!strcasecmp(name, "pcma")) {
                 return 8;
         }
 
         if (!strcasecmp(name, "gsm")) {
                 return 3;
         }
 
         if (!strcasecmp(name, "g722")) {
                 return 9;
         }
 
         if (!strcasecmp(name, "g729")) {
                 return 18;
         }
 
         if (!strcasecmp(name, "dvi4")) {
                 return 5;
         }
 
         if (!strcasecmp(name, "h261")) {
                 return 31;
         }
 
         if (!strcasecmp(name, "h263")) {
                 return 34;
         }
 
         return -1;
 }

static switch_media_flow_t sdp_media_flow ( unsigned in )

inlinestatic

Definition at line 280 of file switch_core_media.c.

References SWITCH_MEDIA_FLOW_INACTIVE, SWITCH_MEDIA_FLOW_RECVONLY, SWITCH_MEDIA_FLOW_SENDONLY, and SWITCH_MEDIA_FLOW_SENDRECV.

Referenced by switch_core_media_negotiate_sdp().

 {
         switch(in) {
         case sdp_sendonly:
                 return SWITCH_MEDIA_FLOW_SENDONLY;
         case sdp_recvonly:
                 return SWITCH_MEDIA_FLOW_RECVONLY;
         case sdp_sendrecv:
                 return SWITCH_MEDIA_FLOW_SENDRECV;
         case sdp_inactive:
                 return SWITCH_MEDIA_FLOW_INACTIVE;
         }
         
         return SWITCH_MEDIA_FLOW_SENDRECV;
 }

static void set_stats	(	switch_core_session_t *	session,
		switch_media_type_t	type,
		const char *	prefix
	)

static

Definition at line 1494 of file switch_core_media.c.

Referenced by switch_core_media_set_stats().

 {
         switch_rtp_stats_t *stats = switch_core_media_get_stats(session, type, NULL);
         switch_channel_t *channel = switch_core_session_get_channel(session);
 
         char var_name[256] = "", var_val[35] = "";
 
         if (stats) {
                 stats->inbound.std_deviation = sqrt(stats->inbound.variance);
 
                 add_stat(stats->inbound.raw_bytes, "in_raw_bytes");
                 add_stat(stats->inbound.media_bytes, "in_media_bytes");
                 add_stat(stats->inbound.packet_count, "in_packet_count");
                 add_stat(stats->inbound.media_packet_count, "in_media_packet_count");
                 add_stat(stats->inbound.skip_packet_count, "in_skip_packet_count");
                 add_stat(stats->inbound.jb_packet_count, "in_jitter_packet_count");
                 add_stat(stats->inbound.dtmf_packet_count, "in_dtmf_packet_count");
                 add_stat(stats->inbound.cng_packet_count, "in_cng_packet_count");
                 add_stat(stats->inbound.flush_packet_count, "in_flush_packet_count");
                 add_stat(stats->inbound.largest_jb_size, "in_largest_jb_size");
                 add_stat_double(stats->inbound.min_variance, "in_jitter_min_variance");
                 add_stat_double(stats->inbound.max_variance, "in_jitter_max_variance");
                 add_stat_double(stats->inbound.lossrate, "in_jitter_loss_rate");
                 add_stat_double(stats->inbound.burstrate, "in_jitter_burst_rate");
                 add_stat_double(stats->inbound.mean_interval, "in_mean_interval");
                 add_stat(stats->inbound.flaws, "in_flaw_total");
                 add_stat_double(stats->inbound.R, "in_quality_percentage");
                 add_stat_double(stats->inbound.mos, "in_mos");
 
 
                 add_stat(stats->outbound.raw_bytes, "out_raw_bytes");
                 add_stat(stats->outbound.media_bytes, "out_media_bytes");
                 add_stat(stats->outbound.packet_count, "out_packet_count");
                 add_stat(stats->outbound.media_packet_count, "out_media_packet_count");
                 add_stat(stats->outbound.skip_packet_count, "out_skip_packet_count");
                 add_stat(stats->outbound.dtmf_packet_count, "out_dtmf_packet_count");
                 add_stat(stats->outbound.cng_packet_count, "out_cng_packet_count");
 
                 add_stat(stats->rtcp.packet_count, "rtcp_packet_count");
                 add_stat(stats->rtcp.octet_count, "rtcp_octet_count");
 
         }
 }

void switch_core_autobind_cpu ( void )

Definition at line 5330 of file switch_core_media.c.

References core_video_globals_s::cpu_count, next_cpu(), and switch_core_thread_set_cpu_affinity().

Referenced by video_helper_thread().

 {
         if (video_globals.cpu_count > 1) {
                 switch_core_thread_set_cpu_affinity(next_cpu());
         }
 }

void switch_core_media_absorb_sdp ( switch_core_session_t * session )

Definition at line 8594 of file switch_core_media.c.

References switch_media_handle_s::engines, if(), switch_rtp_engine_s::proxy_sdp_ip, switch_rtp_engine_s::proxy_sdp_port, switch_assert, SWITCH_B_SDP_VARIABLE, switch_channel_get_variable, switch_core_media_set_local_sdp(), switch_core_session_strdup, SWITCH_MEDIA_TYPE_AUDIO, and SWITCH_TRUE.

Referenced by switch_core_media_receive_message().

 {
         const char *sdp_str;
         switch_rtp_engine_t *a_engine;
         switch_media_handle_t *smh;
 
         switch_assert(session);
 
         if (!(smh = session->media_handle)) {
                 return;
         }
 
         a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
 
         if ((sdp_str = switch_channel_get_variable(session->channel, SWITCH_B_SDP_VARIABLE))) {
                 sdp_parser_t *parser;
                 sdp_session_t *sdp;
                 sdp_media_t *m;
                 sdp_connection_t *connection;
 
                 if ((parser = sdp_parse(NULL, sdp_str, (int) strlen(sdp_str), 0))) {
                         if ((sdp = sdp_session(parser))) {
                                 for (m = sdp->sdp_media; m; m = m->m_next) {
                                         if (m->m_type != sdp_media_audio || !m->m_port) {
                                                 continue;
                                         }
 
                                         connection = sdp->sdp_connection;
                                         if (m->m_connections) {
                                                 connection = m->m_connections;
                                         }
 
                                         if (connection) {
                                                 a_engine->proxy_sdp_ip = switch_core_session_strdup(session, connection->c_address);
                                         }
                                         a_engine->proxy_sdp_port = (switch_port_t) m->m_port;
                                         if (a_engine->proxy_sdp_ip && a_engine->proxy_sdp_port) {
                                                 break;
                                         }
                                 }
                         }
                         sdp_parser_free(parser);
                 }
                 switch_core_media_set_local_sdp(session, sdp_str, SWITCH_TRUE);
         }
 }

switch_status_t switch_core_media_activate_rtp ( switch_core_session_t * session )

Definition at line 6218 of file switch_core_media.c.

Referenced by switch_core_media_patch_sdp(), and switch_core_media_recover_session().

 {
         const char *err = NULL;
         const char *val = NULL;
         switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID] = {0};
         switch_status_t status = SWITCH_STATUS_SUCCESS;
         char tmp[50];
         char *timer_name = NULL;
         const char *var;
         switch_rtp_engine_t *a_engine, *v_engine;
         switch_media_handle_t *smh;
 
         switch_assert(session);
         
         if (!(smh = session->media_handle)) {
                 return SWITCH_STATUS_FALSE;
         }
 
         a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
         v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
 
 
         if (switch_channel_down(session->channel)) {
                 return SWITCH_STATUS_FALSE;
         }
 
 
         if (switch_rtp_ready(a_engine->rtp_session)) {
                 switch_rtp_reset_media_timer(a_engine->rtp_session);
         }
 
         if (a_engine->crypto_type != CRYPTO_INVALID) {
                 switch_channel_set_flag(session->channel, CF_SECURE);
         }
 
         if (switch_channel_test_flag(session->channel, CF_PROXY_MODE)) {
                 status = SWITCH_STATUS_SUCCESS;
                 goto end;
         }
 
         if (!switch_channel_test_flag(session->channel, CF_REINVITE)) {
                 if (switch_rtp_ready(a_engine->rtp_session)) {
                         if (switch_channel_test_flag(session->channel, CF_VIDEO_POSSIBLE) && !switch_rtp_ready(v_engine->rtp_session)) {
                                 goto video;
                         }
 
                         status = SWITCH_STATUS_SUCCESS;
                         goto end;
                 } 
         }
 
         if ((status = switch_core_media_set_codec(session, 0, smh->mparams->codec_flags)) != SWITCH_STATUS_SUCCESS) {
                 goto end;
         }
 
         switch_core_media_set_video_codec(session, 0);
 
 
         memset(flags, 0, sizeof(flags));
         flags[SWITCH_RTP_FLAG_DATAWAIT]++;
 
         if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                 !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                 flags[SWITCH_RTP_FLAG_AUTOADJ]++;
         }
 
         if (switch_media_handle_test_media_flag(smh, SCMF_PASS_RFC2833)
                 || ((val = switch_channel_get_variable(session->channel, "pass_rfc2833")) && switch_true(val))) {
                 switch_channel_set_flag(session->channel, CF_PASS_RFC2833);
         }
 
 
         if (switch_media_handle_test_media_flag(smh, SCMF_AUTOFLUSH)
                 || ((val = switch_channel_get_variable(session->channel, "rtp_autoflush")) && switch_true(val))) {
                 flags[SWITCH_RTP_FLAG_AUTOFLUSH]++;
         }
 
         if (!(switch_media_handle_test_media_flag(smh, SCMF_REWRITE_TIMESTAMPS) ||
                   ((val = switch_channel_get_variable(session->channel, "rtp_rewrite_timestamps")) && switch_true(val)))) {
                 flags[SWITCH_RTP_FLAG_RAW_WRITE]++;
         }
 
         if (switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG)) {
                 smh->mparams->cng_pt = 0;
         } else if (smh->mparams->cng_pt) {
                 flags[SWITCH_RTP_FLAG_AUTO_CNG]++;
         }
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
         if (!strcasecmp(a_engine->read_impl.iananame, "L16")) {
                 flags[SWITCH_RTP_FLAG_BYTESWAP]++;
         }
 #endif
         
         if ((flags[SWITCH_RTP_FLAG_BYTESWAP]) && (val = switch_channel_get_variable(session->channel, "rtp_disable_byteswap")) && switch_true(val)) {
                 flags[SWITCH_RTP_FLAG_BYTESWAP] = 0;
         }
 
         if ((val = switch_channel_get_variable(session->channel, "rtp_gen_ts_delta")) && switch_true(val)) {
                 flags[SWITCH_RTP_FLAG_GEN_TS_DELTA] = 1;
         }
 
         if (a_engine->rtp_session && switch_channel_test_flag(session->channel, CF_REINVITE)) {
                 //const char *ip = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE);
                 //const char *port = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE);
                 char *remote_host = switch_rtp_get_remote_host(a_engine->rtp_session);
                 switch_port_t remote_port = switch_rtp_get_remote_port(a_engine->rtp_session);
 
                 if (remote_host && remote_port && !strcmp(remote_host, a_engine->cur_payload_map->remote_sdp_ip) && 
                         remote_port == a_engine->cur_payload_map->remote_sdp_port) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Audio params are unchanged for %s.\n",
                                                           switch_channel_get_name(session->channel));
                         a_engine->cur_payload_map->negotiated = 1;
                         //XX
                         goto video;
                 } else {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Audio params changed for %s from %s:%d to %s:%d\n",
                                                           switch_channel_get_name(session->channel),
                                                           remote_host, remote_port, a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);
 
                         switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->cur_payload_map->remote_sdp_port);
                         switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->cur_payload_map->remote_sdp_ip);
                         switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE, tmp);
                 }
         }
 
         if (!switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "AUDIO RTP [%s] %s port %d -> %s port %d codec: %u ms: %d\n",
                                                   switch_channel_get_name(session->channel),
                                                   a_engine->local_sdp_ip,
                                                   a_engine->local_sdp_port,
                                                   a_engine->cur_payload_map->remote_sdp_ip,
                                                   a_engine->cur_payload_map->remote_sdp_port, a_engine->cur_payload_map->agreed_pt, a_engine->read_impl.microseconds_per_packet / 1000);
 
                 //XX
         }
 
         switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->local_sdp_port);
         switch_channel_set_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE, a_engine->local_sdp_ip);
         switch_channel_set_variable(session->channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE, tmp);
         switch_channel_set_variable(session->channel, SWITCH_ADVERTISED_MEDIA_IP_VARIABLE, a_engine->adv_sdp_ip);
 
         if (a_engine->rtp_session && switch_channel_test_flag(session->channel, CF_REINVITE)) {
                 const char *rport = NULL;
                 switch_port_t remote_rtcp_port = a_engine->remote_rtcp_port;
                                 
                 if (!remote_rtcp_port) {
                         if ((rport = switch_channel_get_variable(session->channel, "rtp_remote_audio_rtcp_port"))) {
                                 remote_rtcp_port = (switch_port_t)atoi(rport);
                         }
                 }
 
                 if (switch_rtp_set_remote_address(a_engine->rtp_session, a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port,
                                                                                   remote_rtcp_port, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "AUDIO RTP REPORTS ERROR: [%s]\n", err);
                 } else {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "AUDIO RTP CHANGING DEST TO: [%s:%d]\n",
                                                           a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);
 
                         if (switch_channel_test_flag(session->channel, CF_PROTO_HOLD) && strcmp(a_engine->cur_payload_map->remote_sdp_ip, "0.0.0.0")) {
                                 switch_core_media_toggle_hold(session, 0);
                         }
 
 
                         if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) &&
                                 !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) &&
                                 !switch_channel_test_flag(session->channel, CF_AVPF)) {
                                 /* Reactivate the NAT buster flag. */
                                 switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                         }
                 }
 
                 if (session && a_engine) {
                         check_dtls_reinvite(session, a_engine);
                 }
 
                 goto video;
         }
 
         if (switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                 switch_core_media_proxy_remote_addr(session, NULL);
 
                 memset(flags, 0, sizeof(flags));
                 flags[SWITCH_RTP_FLAG_DATAWAIT]++;
                 flags[SWITCH_RTP_FLAG_PROXY_MEDIA]++;
 
                 if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                         !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                         flags[SWITCH_RTP_FLAG_AUTOADJ]++;
                 }
                 timer_name = NULL;
 
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                   "PROXY AUDIO RTP [%s] %s:%d->%s:%d codec: %u ms: %d\n",
                                                   switch_channel_get_name(session->channel),
                                                   a_engine->cur_payload_map->remote_sdp_ip,
                                                   a_engine->cur_payload_map->remote_sdp_port,
                                                   a_engine->cur_payload_map->remote_sdp_ip,
                                                   a_engine->cur_payload_map->remote_sdp_port, a_engine->cur_payload_map->agreed_pt, a_engine->read_impl.microseconds_per_packet / 1000);
 
                 if (switch_rtp_ready(a_engine->rtp_session)) {
                         switch_rtp_set_default_payload(a_engine->rtp_session, a_engine->cur_payload_map->agreed_pt);
                 }
 
         } else {
                 timer_name = smh->mparams->timer_name;
 
                 if ((var = switch_channel_get_variable(session->channel, "rtp_timer_name"))) {
                         timer_name = (char *) var;
                 }
         }
 
         if (switch_channel_up(session->channel)) {
                 switch_channel_set_variable(session->channel, "rtp_use_timer_name", timer_name);
                 
                 a_engine->rtp_session = switch_rtp_new(a_engine->local_sdp_ip,
                                                                                            a_engine->local_sdp_port,
                                                                                            a_engine->cur_payload_map->remote_sdp_ip,
                                                                                            a_engine->cur_payload_map->remote_sdp_port,
                                                                                            a_engine->cur_payload_map->agreed_pt,
                                                                                            a_engine->read_impl.samples_per_packet,
                                                                                            a_engine->cur_payload_map->codec_ms * 1000,
                                                                                            flags, timer_name, &err, switch_core_session_get_pool(session));
 
                 if (switch_rtp_ready(a_engine->rtp_session)) {
                         switch_rtp_set_payload_map(a_engine->rtp_session, &a_engine->payload_map);
                 }
         }
 
         if (switch_rtp_ready(a_engine->rtp_session)) {
                 uint8_t vad_in = (smh->mparams->vflags & VAD_IN);
                 uint8_t vad_out = (smh->mparams->vflags & VAD_OUT);
                 uint8_t inb = switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND;
                 const char *ssrc;
 
                 switch_mutex_init(&smh->read_mutex[SWITCH_MEDIA_TYPE_AUDIO], SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
                 switch_mutex_init(&smh->write_mutex[SWITCH_MEDIA_TYPE_AUDIO], SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
 
                 //switch_core_media_set_rtp_session(session, SWITCH_MEDIA_TYPE_AUDIO, a_engine->rtp_session);
 
                 if ((ssrc = switch_channel_get_variable(session->channel, "rtp_use_ssrc"))) {
                         uint32_t ssrc_ul = (uint32_t) strtoul(ssrc, NULL, 10);
                         switch_rtp_set_ssrc(a_engine->rtp_session, ssrc_ul);
                         a_engine->ssrc = ssrc_ul;
                 } else {
                         switch_rtp_set_ssrc(a_engine->rtp_session, a_engine->ssrc);
                 }
 
                 if (a_engine->remote_ssrc) {
                         switch_rtp_set_remote_ssrc(a_engine->rtp_session, a_engine->remote_ssrc);
                 }
 
                 switch_channel_set_flag(session->channel, CF_FS_RTP);
 
                 switch_channel_set_variable_printf(session->channel, "rtp_use_pt", "%d", a_engine->cur_payload_map->agreed_pt);
 
                 if ((val = switch_channel_get_variable(session->channel, "rtp_enable_vad_in")) && switch_true(val)) {
                         vad_in = 1;
                 }
                 if ((val = switch_channel_get_variable(session->channel, "rtp_enable_vad_out")) && switch_true(val)) {
                         vad_out = 1;
                 }
 
                 if ((val = switch_channel_get_variable(session->channel, "rtp_disable_vad_in")) && switch_true(val)) {
                         vad_in = 0;
                 }
                 if ((val = switch_channel_get_variable(session->channel, "rtp_disable_vad_out")) && switch_true(val)) {
                         vad_out = 0;
                 }
 
 
                 a_engine->ssrc = switch_rtp_get_ssrc(a_engine->rtp_session);
                 switch_channel_set_variable_printf(session->channel, "rtp_use_ssrc", "%u", a_engine->ssrc);
 
 
 
                 if (smh->mparams->auto_rtp_bugs & RTP_BUG_IGNORE_MARK_BIT) {
                         a_engine->rtp_bugs |= RTP_BUG_IGNORE_MARK_BIT;
                 }
 
                 if ((val = switch_channel_get_variable(session->channel, "rtp_manual_rtp_bugs"))) {
                         switch_core_media_parse_rtp_bugs(&a_engine->rtp_bugs, val);
                 }
                 
                 //if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                 //      smh->mparams->manual_rtp_bugs = RTP_BUG_SEND_LINEAR_TIMESTAMPS;
                 //}
 
                 switch_rtp_intentional_bugs(a_engine->rtp_session, a_engine->rtp_bugs | smh->mparams->manual_rtp_bugs);
 
                 if ((vad_in && inb) || (vad_out && !inb)) {
                         switch_rtp_enable_vad(a_engine->rtp_session, session, &a_engine->read_codec, SWITCH_VAD_FLAG_TALKING | SWITCH_VAD_FLAG_EVENTS_TALK | SWITCH_VAD_FLAG_EVENTS_NOTALK);
 
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "AUDIO RTP Engage VAD for %s ( %s %s )\n",
                                                           switch_channel_get_name(switch_core_session_get_channel(session)), vad_in ? "in" : "", vad_out ? "out" : "");
                 }
 
                 
                 if (a_engine->ice_in.cands[a_engine->ice_in.chosen[0]][0].ready) {
                         
                         gen_ice(session, SWITCH_MEDIA_TYPE_AUDIO, NULL, 0);
 
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating Audio ICE\n");
 
                         switch_rtp_activate_ice(a_engine->rtp_session, 
                                                                         a_engine->ice_in.ufrag,
                                                                         a_engine->ice_out.ufrag,
                                                                         a_engine->ice_out.pwd,
                                                                         a_engine->ice_in.pwd,
                                                                         IPR_RTP,
 #ifdef GOOGLE_ICE
                                                                         ICE_GOOGLE_JINGLE,
                                                                         NULL
 #else
                                                                         switch_ice_direction(session) == 
                                                                         SWITCH_CALL_DIRECTION_OUTBOUND ? ICE_VANILLA : (ICE_VANILLA | ICE_CONTROLLED),
                                                                         &a_engine->ice_in
 #endif
                                                                         );
 
                 
                         
                 }
 
 
 
                 if ((val = switch_channel_get_variable(session->channel, "rtcp_audio_interval_msec")) || (val = smh->mparams->rtcp_audio_interval_msec)) {
                         const char *rport = switch_channel_get_variable(session->channel, "rtp_remote_audio_rtcp_port");
                         switch_port_t remote_rtcp_port = a_engine->remote_rtcp_port;
 
                         if (!remote_rtcp_port && rport) {
                                 remote_rtcp_port = (switch_port_t)atoi(rport);
                         }
                         
                         if (!strcasecmp(val, "passthru")) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating RTCP PASSTHRU PORT %d\n", remote_rtcp_port);
                                 switch_rtp_activate_rtcp(a_engine->rtp_session, -1, remote_rtcp_port, a_engine->rtcp_mux > 0);
                         } else if (remote_rtcp_port) {
                                 int interval = atoi(val);
                                 if (interval < 100 || interval > 500000) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                                                                           "Invalid rtcp interval spec [%d] must be between 100 and 500000\n", interval);
                                         interval = 5000;
                                 }
 
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Activating RTCP PORT %d\n", remote_rtcp_port);
                                 switch_rtp_activate_rtcp(a_engine->rtp_session, interval, remote_rtcp_port, a_engine->rtcp_mux > 0);
                                 
                         }
 
                         if (a_engine->ice_in.cands[a_engine->ice_in.chosen[1]][1].ready) {
                                 if (a_engine->rtcp_mux > 0 && !strcmp(a_engine->ice_in.cands[a_engine->ice_in.chosen[1]][1].con_addr, a_engine->ice_in.cands[a_engine->ice_in.chosen[0]][0].con_addr)
                                         && a_engine->ice_in.cands[a_engine->ice_in.chosen[1]][1].con_port == a_engine->ice_in.cands[a_engine->ice_in.chosen[0]][0].con_port) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Skipping RTCP ICE (Same as RTP)\n");
                                 } else {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating RTCP ICE\n");
                                 
                                         switch_rtp_activate_ice(a_engine->rtp_session, 
                                                                                         a_engine->ice_in.ufrag,
                                                                                         a_engine->ice_out.ufrag,
                                                                                         a_engine->ice_out.pwd,
                                                                                         a_engine->ice_in.pwd,
                                                                                         IPR_RTCP,
 #ifdef GOOGLE_ICE
                                                                                         ICE_GOOGLE_JINGLE,
                                                                                         NULL
 #else
                                                                                         switch_ice_direction(session) == 
                                                                                         SWITCH_CALL_DIRECTION_OUTBOUND ? ICE_VANILLA : (ICE_VANILLA | ICE_CONTROLLED),
                                                                                         &a_engine->ice_in
 #endif
                                                                                 );
                                 }
                                 
                         }
                 }
 
                 if (!zstr(a_engine->local_dtls_fingerprint.str) && switch_rtp_has_dtls() && dtls_ok(smh->session)) {
                         dtls_type_t xtype, dtype = a_engine->dtls_controller ? DTLS_TYPE_CLIENT : DTLS_TYPE_SERVER;
 
                         //if (switch_channel_test_flag(smh->session->channel, CF_3PCC)) {
                         //      dtype = (dtype == DTLS_TYPE_CLIENT) ? DTLS_TYPE_SERVER : DTLS_TYPE_CLIENT;
                         //}
 
                         xtype = DTLS_TYPE_RTP;
                         if (a_engine->rtcp_mux > 0 && smh->mparams->rtcp_audio_interval_msec) xtype |= DTLS_TYPE_RTCP;
                 
                         switch_rtp_add_dtls(a_engine->rtp_session, &a_engine->local_dtls_fingerprint, &a_engine->remote_dtls_fingerprint, dtype | xtype);
 
                         if (a_engine->rtcp_mux < 1 && smh->mparams->rtcp_audio_interval_msec) {
                                 xtype = DTLS_TYPE_RTCP;
                                 switch_rtp_add_dtls(a_engine->rtp_session, &a_engine->local_dtls_fingerprint, &a_engine->remote_dtls_fingerprint, dtype | xtype);
                         }
 
                 }
 
                 check_jb(session, NULL, 0, 0, SWITCH_FALSE);
 
                 if ((val = switch_channel_get_variable(session->channel, "rtp_timeout_sec"))) {
                         int v = atoi(val);
                         if (v >= 0) {
                                 smh->mparams->rtp_timeout_sec = v;
                         }
                 }
 
                 if ((val = switch_channel_get_variable(session->channel, "rtp_hold_timeout_sec"))) {
                         int v = atoi(val);
                         if (v >= 0) {
                                 smh->mparams->rtp_hold_timeout_sec = v;
                         }
                 }
 
                 if (smh->mparams->rtp_timeout_sec) {
                         a_engine->max_missed_packets = (a_engine->read_impl.samples_per_second * smh->mparams->rtp_timeout_sec) / a_engine->read_impl.samples_per_packet;
 
                         switch_rtp_set_max_missed_packets(a_engine->rtp_session, a_engine->max_missed_packets);
                         if (!smh->mparams->rtp_hold_timeout_sec) {
                                 smh->mparams->rtp_hold_timeout_sec = smh->mparams->rtp_timeout_sec * 10;
                         }
                 }
 
                 if (smh->mparams->rtp_hold_timeout_sec) {
                         a_engine->max_missed_hold_packets = (a_engine->read_impl.samples_per_second * smh->mparams->rtp_hold_timeout_sec) / a_engine->read_impl.samples_per_packet;
                 }
 
                 if (smh->mparams->te) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Set 2833 dtmf send payload to %u\n",
                                                           switch_channel_get_name(session->channel), smh->mparams->te);
                         switch_rtp_set_telephony_event(a_engine->rtp_session, smh->mparams->te);
                         switch_channel_set_variable_printf(session->channel, "rtp_2833_send_payload", "%d", smh->mparams->te);
                 }
 
                 if (smh->mparams->recv_te) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Set 2833 dtmf receive payload to %u\n", 
                                                           switch_channel_get_name(session->channel), smh->mparams->recv_te);
                         switch_rtp_set_telephony_recv_event(a_engine->rtp_session, smh->mparams->recv_te);
                         switch_channel_set_variable_printf(session->channel, "rtp_2833_recv_payload", "%d", smh->mparams->recv_te);
                 }
 
                 //XX
 
                 if (switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) ||
                         ((val = switch_channel_get_variable(session->channel, "supress_cng")) && switch_true(val)) ||
                         ((val = switch_channel_get_variable(session->channel, "suppress_cng")) && switch_true(val))) {
                         smh->mparams->cng_pt = 0;
                 }
 
                 if (((val = switch_channel_get_variable(session->channel, "rtp_digit_delay")))) {
                         int delayi = atoi(val);
                         if (delayi < 0) delayi = 0;
                         smh->mparams->dtmf_delay = (uint32_t) delayi;
                 }
 
 
                 if (smh->mparams->dtmf_delay) {
                         switch_rtp_set_interdigit_delay(a_engine->rtp_session, smh->mparams->dtmf_delay);
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, 
                                                           "%s Set rtp dtmf delay to %u\n", switch_channel_get_name(session->channel), smh->mparams->dtmf_delay);
                         
                 }
 
                 if (smh->mparams->cng_pt && !switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG)) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set comfort noise payload to %u\n", smh->mparams->cng_pt);
                         switch_rtp_set_cng_pt(a_engine->rtp_session, smh->mparams->cng_pt);
                 }
 
                 switch_core_session_apply_crypto(session, SWITCH_MEDIA_TYPE_AUDIO);
 
                 switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->cur_payload_map->remote_sdp_port);
                 switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->cur_payload_map->remote_sdp_ip);
                 switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE, tmp);
 
 
                 if (switch_channel_test_flag(session->channel, CF_ZRTP_PASSTHRU)) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating ZRTP PROXY MODE\n");
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Disable NOTIMER_DURING_BRIDGE\n");
                         switch_channel_clear_flag(session->channel, CF_NOTIMER_DURING_BRIDGE);
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Activating audio UDPTL mode\n");
                         switch_rtp_udptl_mode(a_engine->rtp_session);
                 }
 
 
                 
         
 
         
         video:
         
                 if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_core_media_check_video_codecs(session);
                 }
 
                 if (switch_channel_test_flag(session->channel, CF_VIDEO_POSSIBLE) && v_engine->cur_payload_map->rm_encoding && v_engine->cur_payload_map->remote_sdp_port) {
                         /******************************************************************************************/
                         if (v_engine->rtp_session && switch_channel_test_flag(session->channel, CF_REINVITE)) {
                                 //const char *ip = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE);
                                 //const char *port = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE);
                                 char *remote_host = switch_rtp_get_remote_host(v_engine->rtp_session);
                                 switch_port_t remote_port = switch_rtp_get_remote_port(v_engine->rtp_session);
                                 
 
 
                                 if (remote_host && remote_port && !strcmp(remote_host, v_engine->cur_payload_map->remote_sdp_ip) && remote_port == v_engine->cur_payload_map->remote_sdp_port) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Video params are unchanged for %s.\n",
                                                                           switch_channel_get_name(session->channel));
                                         v_engine->cur_payload_map->negotiated = 1;
                                         goto video_up;
                                 } else {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Video params changed for %s from %s:%d to %s:%d\n",
                                                                           switch_channel_get_name(session->channel),
                                                                           remote_host, remote_port, v_engine->cur_payload_map->remote_sdp_ip, v_engine->cur_payload_map->remote_sdp_port);
                                 }
                         }
 
                         if (!switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                                 if (switch_rtp_ready(v_engine->rtp_session)) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                           "VIDEO RTP [%s] %s port %d -> %s port %d codec: %u\n", switch_channel_get_name(session->channel),
                                                                           v_engine->local_sdp_ip, v_engine->local_sdp_port, v_engine->cur_payload_map->remote_sdp_ip,
                                                                           v_engine->cur_payload_map->remote_sdp_port, v_engine->cur_payload_map->agreed_pt);
 
                                         switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->agreed_pt);
                                 }
                         }
                         
                         switch_snprintf(tmp, sizeof(tmp), "%d", v_engine->local_sdp_port);
                         switch_channel_set_variable(session->channel, SWITCH_LOCAL_VIDEO_IP_VARIABLE, a_engine->adv_sdp_ip);
                         switch_channel_set_variable(session->channel, SWITCH_LOCAL_VIDEO_PORT_VARIABLE, tmp);
 
 
                         if (v_engine->rtp_session && switch_channel_test_flag(session->channel, CF_REINVITE)) {
                                 const char *rport = NULL;
                                 switch_port_t remote_rtcp_port = v_engine->remote_rtcp_port;
 
                                 //switch_channel_clear_flag(session->channel, CF_REINVITE);
 
                                 if (!remote_rtcp_port) {
                                         if ((rport = switch_channel_get_variable(session->channel, "rtp_remote_video_rtcp_port"))) {
                                                 remote_rtcp_port = (switch_port_t)atoi(rport);
                                         }
                                 }
                                 
                                 if (switch_rtp_set_remote_address
                                         (v_engine->rtp_session, v_engine->cur_payload_map->remote_sdp_ip, v_engine->cur_payload_map->remote_sdp_port, remote_rtcp_port, SWITCH_TRUE,
                                          &err) != SWITCH_STATUS_SUCCESS) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "VIDEO RTP REPORTS ERROR: [%s]\n", err);
                                 } else {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "VIDEO RTP CHANGING DEST TO: [%s:%d]\n",
                                                                           v_engine->cur_payload_map->remote_sdp_ip, v_engine->cur_payload_map->remote_sdp_port);
                                         if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                                                 !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                                                 /* Reactivate the NAT buster flag. */
                                                 switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                                         }
 
                                 }
                                 goto video_up;
                         }
 
                         if (switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                                 switch_core_media_proxy_remote_addr(session, NULL);
 
                                 memset(flags, 0, sizeof(flags));
                                 flags[SWITCH_RTP_FLAG_PROXY_MEDIA]++;
                                 flags[SWITCH_RTP_FLAG_DATAWAIT]++;
 
                                 if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                                         !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                                         flags[SWITCH_RTP_FLAG_AUTOADJ]++;
                                 }
                                 timer_name = NULL;
 
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                   "PROXY VIDEO RTP [%s] %s:%d->%s:%d codec: %u ms: %d\n",
                                                                   switch_channel_get_name(session->channel),
                                                                   a_engine->cur_payload_map->remote_sdp_ip,
                                                                   v_engine->local_sdp_port,
                                                                   v_engine->cur_payload_map->remote_sdp_ip,
                                                                   v_engine->cur_payload_map->remote_sdp_port, v_engine->cur_payload_map->agreed_pt, v_engine->read_impl.microseconds_per_packet / 1000);
 
                                 if (switch_rtp_ready(v_engine->rtp_session)) {
                                         switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->agreed_pt);
                                 }
                         } else {
                                 timer_name = smh->mparams->timer_name;
 
                                 if ((var = switch_channel_get_variable(session->channel, "rtp_timer_name"))) {
                                         timer_name = (char *) var;
                                 }
                         }
 
                         /******************************************************************************************/
 
                         if (v_engine->rtp_session) {
                                 goto video_up;
                         }
 
 
                         if (!v_engine->local_sdp_port) {
                                 switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 1);
                         }
 
                         memset(flags, 0, sizeof(flags));
                         flags[SWITCH_RTP_FLAG_DATAWAIT]++;
                         flags[SWITCH_RTP_FLAG_RAW_WRITE]++;
 
                         if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_PROXY_MODE) &&
                                 !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) && 
                                 !switch_channel_test_flag(session->channel, CF_AVPF)) {
                                 flags[SWITCH_RTP_FLAG_AUTOADJ]++;                               
                         }
 
                         if (switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                                 flags[SWITCH_RTP_FLAG_PROXY_MEDIA]++;
                         }
                         switch_core_media_set_video_codec(session, 0);
 
                         flags[SWITCH_RTP_FLAG_USE_TIMER] = 0;
                         flags[SWITCH_RTP_FLAG_NOBLOCK] = 0;
                         flags[SWITCH_RTP_FLAG_VIDEO]++;
                         
                         if (v_engine->fir) {
                                 flags[SWITCH_RTP_FLAG_FIR]++;
                         }
 
                         if (v_engine->pli) {
                                 flags[SWITCH_RTP_FLAG_PLI]++;
                         }
 
                         if (v_engine->nack) {
                                 flags[SWITCH_RTP_FLAG_NACK]++;
                         }
 
                         if (v_engine->tmmbr) {
                                 flags[SWITCH_RTP_FLAG_TMMBR]++;
                         }
 
                         v_engine->rtp_session = switch_rtp_new(a_engine->local_sdp_ip,
                                                                                                                  v_engine->local_sdp_port,
                                                                                                                  v_engine->cur_payload_map->remote_sdp_ip,
                                                                                                                  v_engine->cur_payload_map->remote_sdp_port,
                                                                                                                  v_engine->cur_payload_map->agreed_pt,
                                                                                                                  1, 90000, flags, NULL, &err, switch_core_session_get_pool(session));
 
 
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%sVIDEO RTP [%s] %s:%d->%s:%d codec: %u ms: %d [%s]\n",
                                                           switch_channel_test_flag(session->channel, CF_PROXY_MEDIA) ? "PROXY " : "",
                                                           switch_channel_get_name(session->channel),
                                                           a_engine->local_sdp_ip,
                                                           v_engine->local_sdp_port,
                                                           v_engine->cur_payload_map->remote_sdp_ip,
                                                           v_engine->cur_payload_map->remote_sdp_port, v_engine->cur_payload_map->agreed_pt,
                                                           0, switch_rtp_ready(v_engine->rtp_session) ? "SUCCESS" : err);
 
 
                         if (switch_rtp_ready(v_engine->rtp_session)) {
                                 const char *ssrc;
 
                                 if (v_engine->fir) {
                                         switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_FIR);
                                 }
 
                                 if (v_engine->pli) {
                                         switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PLI);
                                 }
                                 
                                 switch_rtp_set_payload_map(v_engine->rtp_session, &v_engine->payload_map);
                                 switch_channel_set_flag(session->channel, CF_VIDEO);
                                 switch_core_session_start_video_thread(session);
 
                                 if ((ssrc = switch_channel_get_variable(session->channel, "rtp_use_video_ssrc"))) {
                                         uint32_t ssrc_ul = (uint32_t) strtoul(ssrc, NULL, 10);
                                         switch_rtp_set_ssrc(v_engine->rtp_session, ssrc_ul);
                                         v_engine->ssrc = ssrc_ul;
                                 } else {
                                         switch_rtp_set_ssrc(v_engine->rtp_session, v_engine->ssrc);
                                 }
                                 
                                 if (v_engine->remote_ssrc) {
                                         switch_rtp_set_remote_ssrc(v_engine->rtp_session, v_engine->remote_ssrc);
                                 }
 
                                 if (v_engine->ice_in.cands[v_engine->ice_in.chosen[0]][0].ready) {
                                         
                                         gen_ice(session, SWITCH_MEDIA_TYPE_VIDEO, NULL, 0);
 
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating Video ICE\n");
                                                 
                                         switch_rtp_activate_ice(v_engine->rtp_session, 
                                                                                         v_engine->ice_in.ufrag,
                                                                                         v_engine->ice_out.ufrag,
                                                                                         v_engine->ice_out.pwd,
                                                                                         v_engine->ice_in.pwd,
                                                                                         IPR_RTP,
 #ifdef GOOGLE_ICE
                                                                                         ICE_GOOGLE_JINGLE,
                                                                                         NULL
 #else
                                                                                         switch_ice_direction(session) == 
                                                                                         SWITCH_CALL_DIRECTION_OUTBOUND ? ICE_VANILLA : (ICE_VANILLA | ICE_CONTROLLED),
                                                                                         &v_engine->ice_in
 #endif
                                                                                         );
                                                 
                                         
                                 }
 
                                 if ((val = switch_channel_get_variable(session->channel, "rtcp_video_interval_msec")) || (val = smh->mparams->rtcp_video_interval_msec)) {
                                         const char *rport = switch_channel_get_variable(session->channel, "rtp_remote_video_rtcp_port");
                                         switch_port_t remote_port = v_engine->remote_rtcp_port;
 
                                         if (rport) {
                                                 remote_port = (switch_port_t)atoi(rport);
                                         }
                                         if (!strcasecmp(val, "passthru")) {
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating VIDEO RTCP PASSTHRU PORT %d\n", remote_port);
                                                 switch_rtp_activate_rtcp(v_engine->rtp_session, -1, remote_port, v_engine->rtcp_mux > 0);
                                         } else {
                                                 int interval = atoi(val);
                                                 if (interval < 100 || interval > 500000) {
                                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                                                                                           "Invalid rtcp interval spec [%d] must be between 100 and 500000\n", interval);
                                                         interval = 5000;
                                                 }
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO,
                                                                                   "Activating VIDEO RTCP PORT %d interval %d mux %d\n", remote_port, interval, v_engine->rtcp_mux);
                                                 switch_rtp_activate_rtcp(v_engine->rtp_session, interval, remote_port, v_engine->rtcp_mux > 0);
                                                         
                                         }
                                         
 
                                         if (v_engine->ice_in.cands[v_engine->ice_in.chosen[1]][1].ready) {
 
                                                 if (v_engine->rtcp_mux > 0 && !strcmp(v_engine->ice_in.cands[v_engine->ice_in.chosen[1]][1].con_addr, v_engine->ice_in.cands[v_engine->ice_in.chosen[0]][0].con_addr)
                                                         && v_engine->ice_in.cands[v_engine->ice_in.chosen[1]][1].con_port == v_engine->ice_in.cands[v_engine->ice_in.chosen[0]][0].con_port) {
                                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Skipping VIDEO RTCP ICE (Same as VIDEO RTP)\n");
                                                 } else {
 
                                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating VIDEO RTCP ICE\n");
                                                         switch_rtp_activate_ice(v_engine->rtp_session, 
                                                                                                         v_engine->ice_in.ufrag,
                                                                                                         v_engine->ice_out.ufrag,
                                                                                                         v_engine->ice_out.pwd,
                                                                                                         v_engine->ice_in.pwd,
                                                                                                         IPR_RTCP,
 #ifdef GOOGLE_ICE
                                                                                                         ICE_GOOGLE_JINGLE,
                                                                                                         NULL
 #else
                                                                                                         switch_ice_direction(session) == 
                                                                                                         SWITCH_CALL_DIRECTION_OUTBOUND ? ICE_VANILLA : (ICE_VANILLA | ICE_CONTROLLED),
                                                                                                         &v_engine->ice_in
 #endif
                                                                                                         );
                                                 
                                                 
                                                 
                                                 }
                                 
                                         }
                                 }
                                 
                                 if (!zstr(v_engine->local_dtls_fingerprint.str) && switch_rtp_has_dtls() && dtls_ok(smh->session)) {
                                         dtls_type_t xtype, 
                                                 dtype = v_engine->dtls_controller ? DTLS_TYPE_CLIENT : DTLS_TYPE_SERVER;
                                         xtype = DTLS_TYPE_RTP;
                                         if (v_engine->rtcp_mux > 0 && smh->mparams->rtcp_video_interval_msec) xtype |= DTLS_TYPE_RTCP;
                                         
                                         switch_rtp_add_dtls(v_engine->rtp_session, &v_engine->local_dtls_fingerprint, &v_engine->remote_dtls_fingerprint, dtype | xtype);
                                         
                                         if (v_engine->rtcp_mux < 1 && smh->mparams->rtcp_video_interval_msec) {
                                                 xtype = DTLS_TYPE_RTCP;
                                                 switch_rtp_add_dtls(v_engine->rtp_session, &v_engine->local_dtls_fingerprint, &v_engine->remote_dtls_fingerprint, dtype | xtype);
                                         }
                                 }
                                         
                                         
                                 if ((val = switch_channel_get_variable(session->channel, "rtp_manual_video_rtp_bugs"))) {
                                         switch_core_media_parse_rtp_bugs(&v_engine->rtp_bugs, val);
                                 }
                                 
                                 if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                                         smh->mparams->manual_video_rtp_bugs = RTP_BUG_SEND_LINEAR_TIMESTAMPS;
                                 }
                                 
                                 switch_rtp_intentional_bugs(v_engine->rtp_session, v_engine->rtp_bugs | smh->mparams->manual_video_rtp_bugs);
 
                                 //XX
 
 
                                 switch_channel_set_variable_printf(session->channel, "rtp_use_video_pt", "%d", v_engine->cur_payload_map->agreed_pt);
                                 v_engine->ssrc = switch_rtp_get_ssrc(v_engine->rtp_session);
                                 switch_channel_set_variable_printf(session->channel, "rtp_use_video_ssrc", "%u", v_engine->ssrc);
 
                                 switch_core_session_apply_crypto(session, SWITCH_MEDIA_TYPE_VIDEO);
 
                                 
                                 if (switch_channel_test_flag(session->channel, CF_ZRTP_PASSTHRU)) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Activating video UDPTL mode\n");
                                         switch_rtp_udptl_mode(v_engine->rtp_session);
                                 }
 
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "VIDEO RTP REPORTS ERROR: [%s]\n", switch_str_nil(err));
                                 switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                 goto end;
                         }
                 }
 
         } else {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "AUDIO RTP REPORTS ERROR: [%s]\n", switch_str_nil(err));
                 switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                 status = SWITCH_STATUS_FALSE;
                 goto end;
         }
 
  video_up:
 
         if (session && v_engine) {
                 check_dtls_reinvite(session, v_engine);
         }
 
         status = SWITCH_STATUS_SUCCESS;
 
  end:
 
         switch_channel_clear_flag(session->channel, CF_REINVITE);
 
         switch_core_recovery_track(session);
 
         return status;
 
 }

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation