RTP (RealTime Transport Protocol)

Collaboration diagram for RTP (RealTime Transport Protocol):

Typedefs
typedef void(*	switch_rtp_invalid_handler_t )(switch_rtp_t *rtp_session, switch_socket_t *sock, void *data, switch_size_t datalen, switch_sockaddr_t *from_addr)

Functions
void	switch_rtp_get_random (void *buf, uint32_t len)
void	switch_rtp_init (switch_memory_pool_t *pool)
	Initilize the RTP System. More...
void	switch_rtp_shutdown (void)
switch_port_t	switch_rtp_set_start_port (switch_port_t port)
	Set/Get RTP start port. More...
switch_status_t	switch_rtp_set_ssrc (switch_rtp_t *rtp_session, uint32_t ssrc)
switch_status_t	switch_rtp_set_remote_ssrc (switch_rtp_t *rtp_session, uint32_t ssrc)
switch_port_t	switch_rtp_set_end_port (switch_port_t port)
	Set/Get RTP end port. More...
switch_port_t	switch_rtp_request_port (const char *ip)
	Request a new port to be used for media. More...
void	switch_rtp_release_port (const char *ip, switch_port_t port)
switch_status_t	switch_rtp_set_interval (switch_rtp_t *rtp_session, uint32_t ms_per_packet, uint32_t samples_per_interval)
switch_status_t	switch_rtp_change_interval (switch_rtp_t *rtp_session, uint32_t ms_per_packet, uint32_t samples_per_interval)
switch_status_t	switch_rtp_create (switch_rtp_t **new_rtp_session, switch_payload_t payload, uint32_t samples_per_interval, uint32_t ms_per_packet, switch_rtp_flag_t flags[], char *timer_name, const char **err, switch_memory_pool_t *pool)
	create a new RTP session handle More...
switch_rtp_t *	switch_rtp_new (const char *rx_host, switch_port_t rx_port, const char *tx_host, switch_port_t tx_port, switch_payload_t payload, uint32_t samples_per_interval, uint32_t ms_per_packet, switch_rtp_flag_t flags[], char *timer_name, const char **err, switch_memory_pool_t *pool)
	prepare a new RTP session handle and fully initilize it More...
switch_status_t	switch_rtp_set_remote_address (switch_rtp_t *rtp_session, const char *host, switch_port_t port, switch_port_t remote_rtcp_port, switch_bool_t change_adv_addr, const char **err)
	Assign a remote address to the RTP session. More...
void	switch_rtp_reset_jb (switch_rtp_t *rtp_session)
char *	switch_rtp_get_remote_host (switch_rtp_t *rtp_session)
switch_port_t	switch_rtp_get_remote_port (switch_rtp_t *rtp_session)
void	switch_rtp_reset_media_timer (switch_rtp_t *rtp_session)
void	switch_rtp_set_max_missed_packets (switch_rtp_t *rtp_session, uint32_t max)
switch_status_t	switch_rtp_udptl_mode (switch_rtp_t *rtp_session)
void	switch_rtp_reset (switch_rtp_t *rtp_session)
switch_status_t	switch_rtp_set_local_address (switch_rtp_t *rtp_session, const char *host, switch_port_t port, const char **err)
	Assign a local address to the RTP session. More...
void	switch_rtp_kill_socket (switch_rtp_t *rtp_session)
	Kill the socket on an existing RTP session. More...
void	switch_rtp_break (switch_rtp_t *rtp_session)
void	switch_rtp_flush (switch_rtp_t *rtp_session)
uint8_t	switch_rtp_ready (switch_rtp_t *rtp_session)
	Test if an RTP session is ready. More...
void	switch_rtp_destroy (switch_rtp_t **rtp_session)
	Destroy an RTP session. More...
switch_status_t	switch_rtp_sync_stats (switch_rtp_t *rtp_session)
switch_status_t	switch_rtp_activate_ice (switch_rtp_t *rtp_session, char *login, char *rlogin, const char *password, const char *rpassword, ice_proto_t proto, switch_core_media_ice_type_t type, ice_t *ice_params)
	Acvite ICE on an RTP session. More...
switch_status_t	switch_rtp_activate_rtcp (switch_rtp_t *rtp_session, int send_rate, switch_port_t remote_port, switch_bool_t mux)
	Activate sending RTCP Sender Reports (SR's) More...
switch_timer_t *	switch_rtp_get_media_timer (switch_rtp_t *rtp_session)
switch_status_t	switch_rtp_set_video_buffer_size (switch_rtp_t *rtp_session, uint32_t frames, uint32_t max_frames)
switch_status_t	switch_rtp_get_video_buffer_size (switch_rtp_t *rtp_session, uint32_t *min_frame_len, uint32_t *max_frame_len, uint32_t *cur_frame_len, uint32_t *highest_frame_len)
switch_status_t	switch_rtp_activate_jitter_buffer (switch_rtp_t *rtp_session, uint32_t queue_frames, uint32_t max_queue_frames, uint32_t samples_per_packet, uint32_t samples_per_second)
	Acvite a jitter buffer on an RTP session. More...
switch_status_t	switch_rtp_debug_jitter_buffer (switch_rtp_t *rtp_session, const char *name)
switch_status_t	switch_rtp_deactivate_jitter_buffer (switch_rtp_t *rtp_session)
switch_status_t	switch_rtp_pause_jitter_buffer (switch_rtp_t *rtp_session, switch_bool_t pause)
switch_jb_t *	switch_rtp_get_jitter_buffer (switch_rtp_t *rtp_session)
void	switch_rtp_set_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flag)
	Set an RTP Flag. More...
void	switch_rtp_set_flags (switch_rtp_t *rtp_session, switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID])
void	switch_rtp_clear_flags (switch_rtp_t *rtp_session, switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID])
uint32_t	switch_rtp_test_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flags)
	Test an RTP Flag. More...
void	switch_rtp_clear_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flag)
	Clear an RTP Flag. More...
switch_socket_t *	switch_rtp_get_rtp_socket (switch_rtp_t *rtp_session)
	Retrieve the socket from an existing RTP session. More...
void	switch_rtp_ping (switch_rtp_t *rtp_session)
uint32_t	switch_rtp_get_default_samples_per_interval (switch_rtp_t *rtp_session)
	Get the default samples per interval for a given RTP session. More...
void	switch_rtp_set_default_payload (switch_rtp_t *rtp_session, switch_payload_t payload)
	Set the default payload number for a given RTP session. More...
uint32_t	switch_rtp_get_default_payload (switch_rtp_t *rtp_session)
	Get the default payload number for a given RTP session. More...
void	switch_rtp_set_invalid_handler (switch_rtp_t *rtp_session, switch_rtp_invalid_handler_t on_invalid)
	Set a callback function to execute when an invalid RTP packet is encountered. More...
switch_status_t	switch_rtp_read (switch_rtp_t *rtp_session, void *data, uint32_t *datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
	Read data from a given RTP session. More...
switch_status_t	switch_rtp_queue_rfc2833 (switch_rtp_t *rtp_session, const switch_dtmf_t *dtmf)
	Queue RFC2833 DTMF data into an RTP Session. More...
switch_status_t	switch_rtp_queue_rfc2833_in (switch_rtp_t *rtp_session, const switch_dtmf_t *dtmf)
	Queue RFC2833 DTMF data into an RTP Session. More...
switch_size_t	switch_rtp_has_dtmf (switch_rtp_t *rtp_session)
	Test for presence of DTMF on a given RTP session. More...
switch_size_t	switch_rtp_dequeue_dtmf (switch_rtp_t *rtp_session, switch_dtmf_t *dtmf)
	Retrieve DTMF digits from a given RTP session. More...
switch_status_t	switch_rtp_zerocopy_read (switch_rtp_t *rtp_session, void **data, uint32_t *datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
	Read data from a given RTP session without copying. More...
switch_status_t	switch_rtp_zerocopy_read_frame (switch_rtp_t *rtp_session, switch_frame_t *frame, switch_io_flag_t io_flags)
	Read data from a given RTP session without copying. More...
switch_status_t	switch_rtcp_zerocopy_read_frame (switch_rtp_t *rtp_session, switch_rtcp_frame_t *frame)
	Read RTCP data from a given RTP session without copying. More...
void	rtp_flush_read_buffer (switch_rtp_t *rtp_session, switch_rtp_flush_t flush)
switch_status_t	switch_rtp_enable_vad (switch_rtp_t *rtp_session, switch_core_session_t *session, switch_codec_t *codec, switch_vad_flag_t flags)
	Enable VAD on an RTP Session. More...
switch_status_t	switch_rtp_disable_vad (switch_rtp_t *rtp_session)
	Disable VAD on an RTP Session. More...
int	switch_rtp_write_frame (switch_rtp_t *rtp_session, switch_frame_t *frame)
	Write data to a given RTP session. More...
int	switch_rtp_write_manual (switch_rtp_t *rtp_session, void *data, uint32_t datalen, uint8_t m, switch_payload_t payload, uint32_t ts, switch_frame_flag_t *flags)
	Write data with a specified payload and sequence number to a given RTP session. More...
switch_status_t	switch_rtp_write_raw (switch_rtp_t *rtp_session, void *data, switch_size_t *bytes, switch_bool_t process_encryption)
uint32_t	switch_rtp_get_ssrc (switch_rtp_t *rtp_session)
	Retrieve the SSRC from a given RTP session. More...
void	switch_rtp_set_private (switch_rtp_t *rtp_session, void *private_data)
	Associate an arbitrary data pointer with and RTP session. More...
void	switch_rtp_set_telephony_event (switch_rtp_t *rtp_session, switch_payload_t te)
	Set the payload type to consider RFC2833 DTMF. More...
void	switch_rtp_set_telephony_recv_event (switch_rtp_t *rtp_session, switch_payload_t te)
void	switch_rtp_set_cng_pt (switch_rtp_t *rtp_session, switch_payload_t pt)
	Set the payload type for comfort noise. More...
void *	switch_rtp_get_private (switch_rtp_t *rtp_session)
	Retrieve the private data from a given RTP session. More...
switch_status_t	switch_rtp_set_payload_map (switch_rtp_t *rtp_session, payload_map_t **pmap)
void	switch_rtp_intentional_bugs (switch_rtp_t *rtp_session, switch_rtp_bug_flag_t bugs)
switch_rtp_stats_t *	switch_rtp_get_stats (switch_rtp_t *rtp_session, switch_memory_pool_t *pool)
switch_byte_t	switch_rtp_check_auto_adj (switch_rtp_t *rtp_session)
void	switch_rtp_set_interdigit_delay (switch_rtp_t *rtp_session, uint32_t delay)
switch_status_t	switch_rtp_add_dtls (switch_rtp_t *rtp_session, dtls_fingerprint_t *local_fp, dtls_fingerprint_t *remote_fp, dtls_type_t type)
switch_status_t	switch_rtp_del_dtls (switch_rtp_t *rtp_session, dtls_type_t type)
dtls_state_t	switch_rtp_dtls_state (switch_rtp_t *rtp_session, dtls_type_t type)
int	switch_rtp_has_dtls (void)
switch_status_t	switch_rtp_req_bitrate (switch_rtp_t *rtp_session, uint32_t bps)
switch_status_t	switch_rtp_ack_bitrate (switch_rtp_t *rtp_session, uint32_t bps)
void	switch_rtp_video_refresh (switch_rtp_t *rtp_session)
void	switch_rtp_video_loss (switch_rtp_t *rtp_session)

Detailed Description

Typedef Documentation

typedef void(* switch_rtp_invalid_handler_t)(switch_rtp_t *rtp_session, switch_socket_t *sock, void *data, switch_size_t datalen, switch_sockaddr_t *from_addr)

Definition at line 177 of file switch_rtp.h.

Function Documentation

void rtp_flush_read_buffer	(	switch_rtp_t *	rtp_session,
		switch_rtp_flush_t	flush
	)

Definition at line 4940 of file switch_rtp.c.

References reset_jitter_seq(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_FLUSH, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_RESET, SWITCH_RTP_FLAG_STICKY_FLUSH, SWITCH_RTP_FLAG_UDPTL, SWITCH_RTP_FLUSH_STICK, SWITCH_RTP_FLUSH_UNSTICK, switch_rtp_ready(), and switch_rtp_set_flag().

Referenced by rtp_common_read(), switch_core_media_receive_message(), switch_rtp_set_flag(), and switch_rtp_set_flags().

{

        if (rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] ||
                rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
                return;
        }


        if (switch_rtp_ready(rtp_session)) {
                rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 1;
                rtp_session->flags[SWITCH_RTP_FLAG_FLUSH] = 1;
                reset_jitter_seq(rtp_session);

                switch (flush) {
                case SWITCH_RTP_FLUSH_STICK:
                        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH);
                        break;
                case SWITCH_RTP_FLUSH_UNSTICK:
                        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH);
                        break;
                default:
                                break;
                }
        }
}

switch_status_t switch_rtcp_zerocopy_read_frame	(	switch_rtp_t *	rtp_session,
		switch_rtcp_frame_t *	frame
	)

Read RTCP data from a given RTP session without copying.

Parameters

rtp_session	the RTP session to read from
frame	an RTCP frame to populate with information

Returns

the number of bytes read

Definition at line 7016 of file switch_rtp.c.

References SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_STATUS_TIMEOUT.

Referenced by switch_core_media_read_frame().

{

        if (!rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                return SWITCH_STATUS_FALSE;
        }

        /* A fresh frame has been found! */
        if (rtp_session->rtcp_fresh_frame) {
                /* turn the flag off! */
                rtp_session->rtcp_fresh_frame = 0;

                *frame = rtp_session->rtcp_frame;

                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_TIMEOUT;
}

switch_status_t switch_rtp_ack_bitrate	(	switch_rtp_t *	rtp_session,
		uint32_t	bps
	)

Definition at line 4351 of file switch_rtp.c.

References rtp_write_ready(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_receive_message().

{
        if (!rtp_write_ready(rtp_session, 0, __LINE__) || rtp_session->tmmbn) {
                return SWITCH_STATUS_FALSE;
        }

        rtp_session->tmmbn = bps;

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_rtp_activate_ice	(	switch_rtp_t *	rtp_session,
		char *	login,
		char *	rlogin,
		const char *	password,
		const char *	rpassword,
		ice_proto_t	proto,
		switch_core_media_ice_type_t	type,
		ice_t *	ice_params
	)

Acvite ICE on an RTP session.

Returns

SWITCH_STATUS_SUCCESS

Definition at line 4241 of file switch_rtp.c.

References switch_rtp_ice_t::addr, ice_s::cands, ice_s::chosen, icand_s::con_addr, icand_s::con_port, switch_rtp_ice_t::ice_params, switch_rtp_ice_t::ice_user, ICE_VANILLA, IPR_RTP, switch_rtp_ice_t::luser_ice, switch_rtp_ice_t::next_run, switch_rtp_ice_t::pass, switch_rtp_ice_t::proto, switch_rtp_ice_t::ready, switch_rtp_ice_t::rpass, switch_rtp_ice_t::rready, RTP_BUG_ACCEPT_ANY_PACKETS, rtp_type, SWITCH_CHANNEL_SESSION_LOG, switch_core_strdup, switch_get_addr(), SWITCH_LOG_ERROR, SWITCH_LOG_NOTICE, switch_log_printf(), switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_break(), SWITCH_RTP_FLAG_MUTE, SWITCH_RTP_FLAG_PAUSE, SWITCH_RTP_FLAG_VIDEO, SWITCH_RTP_FLAG_VIDEO_BREAK, switch_snprintf(), switch_sockaddr_get_port(), switch_sockaddr_info_get(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_UNSPEC, switch_rtp_ice_t::type, and switch_rtp_ice_t::user_ice.

Referenced by check_ice(), and switch_core_media_activate_rtp().

{
        char ice_user[80];
        char user_ice[80];
        char luser_ice[80];
        switch_rtp_ice_t *ice;
        char *host = NULL;
        switch_port_t port = 0;
        char bufc[50];
                                 

        switch_mutex_lock(rtp_session->ice_mutex);

        if (proto == IPR_RTP) {
                ice = &rtp_session->ice;                
                rtp_session->flags[SWITCH_RTP_FLAG_PAUSE] = 0;
                rtp_session->flags[SWITCH_RTP_FLAG_MUTE] = 0;
        } else {
                ice = &rtp_session->rtcp_ice;
        }

        ice->proto = proto;
        
        if ((type & ICE_VANILLA)) {
                switch_snprintf(ice_user, sizeof(ice_user), "%s:%s", login, rlogin);
                switch_snprintf(user_ice, sizeof(user_ice), "%s:%s", rlogin, login);
                switch_snprintf(luser_ice, sizeof(user_ice), "%s%s", rlogin, login);
                ice->ready = ice->rready = 0;
        } else {
                switch_snprintf(ice_user, sizeof(ice_user), "%s%s", login, rlogin);
                switch_snprintf(user_ice, sizeof(user_ice), "%s%s", rlogin, login);
                ice->ready = ice->rready = 1;
        }

        ice->ice_user = switch_core_strdup(rtp_session->pool, ice_user);
        ice->user_ice = switch_core_strdup(rtp_session->pool, user_ice);
        ice->luser_ice = switch_core_strdup(rtp_session->pool, luser_ice);
        ice->type = type;
        ice->ice_params = ice_params;
        ice->pass = "";
        ice->rpass = "";
        ice->next_run = switch_micro_time_now();

        if (password) {
                ice->pass = switch_core_strdup(rtp_session->pool, password);
        }

        if (rpassword) {
                ice->rpass = switch_core_strdup(rtp_session->pool, rpassword);
        }
        
        if ((ice->type & ICE_VANILLA) && ice->ice_params) {
                host = ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_addr;
                port = ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_port;

                if (!host || !port || switch_sockaddr_info_get(&ice->addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !ice->addr) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error setting remote host!\n");
                        return SWITCH_STATUS_FALSE;
                }
        } else {
                if (proto == IPR_RTP) {
                        ice->addr = rtp_session->remote_addr;
                } else {
                        ice->addr = rtp_session->rtcp_remote_addr;
                }

                host = (char *)switch_get_addr(bufc, sizeof(bufc), ice->addr);
                port = switch_sockaddr_get_port(ice->addr);
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_NOTICE, "Activating %s %s ICE: %s %s:%d\n", 
                                          proto == IPR_RTP ? "RTP" : "RTCP", rtp_type(rtp_session), ice_user, host, port);


        rtp_session->rtp_bugs |= RTP_BUG_ACCEPT_ANY_PACKETS;


        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                rtp_session->flags[SWITCH_RTP_FLAG_VIDEO_BREAK] = 1;
                switch_rtp_break(rtp_session);
        }

        switch_mutex_unlock(rtp_session->ice_mutex);

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_rtp_activate_jitter_buffer	(	switch_rtp_t *	rtp_session,
		uint32_t	queue_frames,
		uint32_t	max_queue_frames,
		uint32_t	samples_per_packet,
		uint32_t	samples_per_second
	)

Acvite a jitter buffer on an RTP session.

Parameters

rtp_session	the rtp session
queue_frames	the number of frames to delay

Returns

SWITCH_STATUS_SUCCESS

Definition at line 4146 of file switch_rtp.c.

References READ_DEC, READ_INC, SJB_AUDIO, switch_channel_get_variable_dup(), switch_core_session_get_channel(), SWITCH_FALSE, switch_jb_create(), switch_jb_set_frames(), switch_jb_set_session(), switch_jb_ts_mode(), switch_rtp_ready(), SWITCH_STATUS_FALSE, and switch_true().

Referenced by check_jb().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        if (queue_frames < 1) {
                queue_frames = 3;
        }

        if (max_queue_frames < queue_frames) {
                max_queue_frames = queue_frames * 3;
        }



        if (rtp_session->jb) {
                status = switch_jb_set_frames(rtp_session->jb, queue_frames, max_queue_frames);
        } else {
                READ_INC(rtp_session);
                status = switch_jb_create(&rtp_session->jb, SJB_AUDIO, queue_frames, max_queue_frames, rtp_session->pool);
                switch_jb_set_session(rtp_session->jb, rtp_session->session);
                if (switch_true(switch_channel_get_variable_dup(switch_core_session_get_channel(rtp_session->session), "jb_use_timestamps", SWITCH_FALSE, -1))) {
                        switch_jb_ts_mode(rtp_session->jb, samples_per_packet, samples_per_second);
                }
                //switch_jb_debug_level(rtp_session->jb, 10);
                READ_DEC(rtp_session);
        }


        
        return status;
}

switch_status_t switch_rtp_activate_rtcp	(	switch_rtp_t *	rtp_session,
		int	send_rate,
		switch_port_t	remote_port,
		switch_bool_t	mux
	)

Activate sending RTCP Sender Reports (SR's)

Parameters

send_rate

interval in milliseconds to send at

Returns

SWITCH_STATUS_SUCCESS

Definition at line 4186 of file switch_rtp.c.

References enable_local_rtcp_socket(), enable_remote_rtcp_socket(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_RTCP_MUX, SWITCH_RTP_FLAG_RTCP_PASSTHRU, switch_sockaddr_info_get(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_UNSPEC.

Referenced by check_ice(), and switch_core_media_activate_rtp().

{
        const char *err = NULL;

        if (!rtp_session->ms_per_packet) {
                return SWITCH_STATUS_FALSE;
        }
        
        rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] = 1;

        if (!(rtp_session->remote_rtcp_port = remote_port)) {
                rtp_session->remote_rtcp_port = rtp_session->remote_port + 1;
        }

        if (mux) {
                rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]++;
        }

        
        if (send_rate == -1) {
                
                rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU] = 1;
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "RTCP passthru enabled. Remote Port: %d\n", rtp_session->remote_rtcp_port);
        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "RTCP send rate is: %d and packet rate is: %d Remote Port: %d\n",                                                   send_rate, rtp_session->ms_per_packet, rtp_session->remote_rtcp_port);

                rtp_session->rtcp_interval = send_rate;
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {

                if (switch_sockaddr_info_get(&rtp_session->rtcp_remote_addr, rtp_session->eff_remote_host_str, SWITCH_UNSPEC, 
                                                                         rtp_session->remote_rtcp_port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !rtp_session->rtcp_remote_addr) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "RTCP MUX Remote Address Error!");
                        return SWITCH_STATUS_FALSE;
                }

                rtp_session->rtcp_local_addr = rtp_session->local_addr;
                rtp_session->rtcp_from_addr = rtp_session->from_addr;
                rtp_session->rtcp_sock_input = rtp_session->sock_input;
                rtp_session->rtcp_sock_output = rtp_session->sock_output;

                rtp_session->rtcp_recv_msg_p = (rtcp_msg_t *) &rtp_session->recv_msg;
                
                return SWITCH_STATUS_SUCCESS;

                //return enable_remote_rtcp_socket(rtp_session, &err);
        } else {
                rtp_session->rtcp_recv_msg_p = (rtcp_msg_t *) &rtp_session->rtcp_recv_msg;
        }

        return enable_local_rtcp_socket(rtp_session, &err) || enable_remote_rtcp_socket(rtp_session, &err);

}

switch_status_t switch_rtp_add_dtls	(	switch_rtp_t *	rtp_session,
		dtls_fingerprint_t *	local_fp,
		dtls_fingerprint_t *	remote_fp,
		dtls_type_t	type
	)

Definition at line 3294 of file switch_rtp.c.

References switch_dtls_s::ca, switch_directories::certs_dir, DS_HANDSHAKE, dtls_set_state, DTLS_SRTP_FNAME, DTLS_TYPE_CLIENT, DTLS_TYPE_RTCP, DTLS_TYPE_RTP, DTLS_TYPE_SERVER, switch_dtls_s::local_fp, switch_dtls_s::pem, switch_dtls_s::pvt, switch_dtls_s::read_bio, switch_dtls_s::remote_addr, switch_dtls_s::remote_fp, switch_dtls_s::rsa, switch_dtls_s::rtp_session, rtp_type, switch_dtls_s::sock_output, switch_dtls_s::ssl, switch_dtls_s::ssl_ctx, switch_assert, SWITCH_CHANNEL_SESSION_LOG, switch_core_alloc, switch_core_cert_expand_fingerprint(), switch_core_sprintf(), switch_file_exists(), SWITCH_GLOBAL_dirs, SWITCH_LOG_CRIT, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_PATH_SEPARATOR, switch_rtp_break(), switch_rtp_del_dtls(), SWITCH_RTP_FLAG_VIDEO_BREAK, switch_rtp_ready(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_dtls_s::type, switch_dtls_s::write_bio, and zstr.

Referenced by check_dtls_reinvite(), and switch_core_media_activate_rtp().

{
        switch_dtls_t *dtls;
        int ret;
        const char *kind = "";
        BIO *bio;
        DH *dh;
#ifndef OPENSSL_NO_EC
        EC_KEY* ecdh;
#endif

#ifndef HAVE_OPENSSL_DTLS_SRTP
        return SWITCH_STATUS_FALSE;
#endif

        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }
        
        if (!((type & DTLS_TYPE_RTP) || (type & DTLS_TYPE_RTCP)) || !((type & DTLS_TYPE_CLIENT) || (type & DTLS_TYPE_SERVER))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_CRIT, "INVALID TYPE!\n");
        }

        switch_rtp_del_dtls(rtp_session, type);
        
        if ((type & DTLS_TYPE_RTP) && (type & DTLS_TYPE_RTCP)) {
                kind = "RTP/RTCP";
        } else if ((type & DTLS_TYPE_RTP)) {
                kind = "RTP";
        } else {
                kind = "RTCP";
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, 
                                          "Activate %s %s DTLS %s\n", kind, rtp_type(rtp_session), (type & DTLS_TYPE_SERVER) ? "server" : "client");

        if (((type & DTLS_TYPE_RTP) && rtp_session->dtls) || ((type & DTLS_TYPE_RTCP) && rtp_session->rtcp_dtls)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "DTLS ALREADY INIT\n");
                return SWITCH_STATUS_FALSE;
        }

        dtls = switch_core_alloc(rtp_session->pool, sizeof(*dtls));

        dtls->pem = switch_core_sprintf(rtp_session->pool, "%s%s%s.pem", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, DTLS_SRTP_FNAME);

        if (switch_file_exists(dtls->pem, rtp_session->pool) == SWITCH_STATUS_SUCCESS) {
                dtls->pvt = dtls->rsa = dtls->pem;
        } else {
                dtls->pvt = switch_core_sprintf(rtp_session->pool, "%s%s%s.key", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, DTLS_SRTP_FNAME);
                dtls->rsa = switch_core_sprintf(rtp_session->pool, "%s%s%s.crt", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, DTLS_SRTP_FNAME);
        }

        dtls->ca = switch_core_sprintf(rtp_session->pool, "%s%sca-bundle.crt", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR);
                
        dtls->ssl_ctx = SSL_CTX_new((type & DTLS_TYPE_SERVER) ? DTLSv1_server_method() : DTLSv1_client_method());
        switch_assert(dtls->ssl_ctx);

        bio = BIO_new_file(dtls->pem, "r");
        dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
        BIO_free(bio);
        if (dh) {
                SSL_CTX_set_tmp_dh(dtls->ssl_ctx, dh);
                DH_free(dh);
        }

        SSL_CTX_set_mode(dtls->ssl_ctx, SSL_MODE_AUTO_RETRY);

        //SSL_CTX_set_verify(dtls->ssl_ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
        SSL_CTX_set_verify(dtls->ssl_ctx, SSL_VERIFY_NONE, NULL); 

        SSL_CTX_set_cipher_list(dtls->ssl_ctx, "ALL");
                
#ifdef HAVE_OPENSSL_DTLS_SRTP
        //SSL_CTX_set_tlsext_use_srtp(dtls->ssl_ctx, "SRTP_AES128_CM_SHA1_80:SRTP_AES128_CM_SHA1_32");
        SSL_CTX_set_tlsext_use_srtp(dtls->ssl_ctx, "SRTP_AES128_CM_SHA1_80");
#endif
        
        dtls->type = type;
        dtls->read_bio = BIO_new(BIO_s_mem());
        switch_assert(dtls->read_bio);

        dtls->write_bio = BIO_new(BIO_s_mem());
        switch_assert(dtls->write_bio);
                
        BIO_set_mem_eof_return(dtls->read_bio, -1);
        BIO_set_mem_eof_return(dtls->write_bio, -1);

        if ((ret=SSL_CTX_use_certificate_file(dtls->ssl_ctx, dtls->rsa, SSL_FILETYPE_PEM)) != 1) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS cert err [%d]\n", rtp_type(rtp_session), SSL_get_error(dtls->ssl, ret));
                return SWITCH_STATUS_FALSE;
        }

        if ((ret=SSL_CTX_use_PrivateKey_file(dtls->ssl_ctx, dtls->pvt, SSL_FILETYPE_PEM)) != 1) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS key err [%d]\n", rtp_type(rtp_session), SSL_get_error(dtls->ssl, ret));
                return SWITCH_STATUS_FALSE;
        }

        if (SSL_CTX_check_private_key(dtls->ssl_ctx) == 0) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS check key failed\n", rtp_type(rtp_session));
                return SWITCH_STATUS_FALSE;
        }

        if (!zstr(dtls->ca) && switch_file_exists(dtls->ca, rtp_session->pool) == SWITCH_STATUS_SUCCESS 
                && (ret = SSL_CTX_load_verify_locations(dtls->ssl_ctx, dtls->ca, NULL)) != 1) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS check chain cert failed [%d]\n",
                                                  rtp_type(rtp_session) ,
                                                  SSL_get_error(dtls->ssl, ret));
                return SWITCH_STATUS_FALSE;
        }

        dtls->ssl = SSL_new(dtls->ssl_ctx);

        SSL_set_bio(dtls->ssl, dtls->read_bio, dtls->write_bio);
        SSL_set_mode(dtls->ssl, SSL_MODE_AUTO_RETRY);
        SSL_set_read_ahead(dtls->ssl, 1);
        //SSL_set_verify(dtls->ssl, (SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT), cb_verify_peer);

#ifndef OPENSSL_NO_EC
        ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
        if (!ecdh) {
                return SWITCH_STATUS_FALSE;
        }
        SSL_set_options(dtls->ssl, SSL_OP_SINGLE_ECDH_USE);
        SSL_set_tmp_ecdh(dtls->ssl, ecdh);
        EC_KEY_free(ecdh);
#endif

        SSL_set_verify(dtls->ssl, SSL_VERIFY_NONE, NULL);
        SSL_set_app_data(dtls->ssl, dtls);

        BIO_ctrl(dtls->read_bio, BIO_CTRL_DGRAM_SET_MTU, 1400, NULL);
        BIO_ctrl(dtls->write_bio, BIO_CTRL_DGRAM_SET_MTU, 1400, NULL);
        SSL_set_mtu(dtls->ssl, 1400);
        BIO_ctrl(dtls->write_bio, BIO_C_SET_BUFF_SIZE, 1400, NULL);
        BIO_ctrl(dtls->read_bio, BIO_C_SET_BUFF_SIZE, 1400, NULL);



        dtls->local_fp = local_fp;
        dtls->remote_fp = remote_fp;
        dtls->rtp_session = rtp_session;
                
        switch_core_cert_expand_fingerprint(remote_fp, remote_fp->str);

        if ((type & DTLS_TYPE_RTP)) {
                rtp_session->dtls = dtls;
                dtls->sock_output = rtp_session->sock_output;
                dtls->remote_addr = rtp_session->remote_addr;
        }

        if ((type & DTLS_TYPE_RTCP)) {
                rtp_session->rtcp_dtls = dtls;
                if (!(type & DTLS_TYPE_RTP)) {
                        dtls->sock_output = rtp_session->rtcp_sock_output;
                        dtls->remote_addr = rtp_session->rtcp_remote_addr;
                }
        }

        if ((type & DTLS_TYPE_SERVER)) {
                SSL_set_accept_state(dtls->ssl);
        } else {
                SSL_set_connect_state(dtls->ssl);
        }

        dtls_set_state(dtls, DS_HANDSHAKE);

        rtp_session->flags[SWITCH_RTP_FLAG_VIDEO_BREAK] = 1;
        switch_rtp_break(rtp_session);
                
        return SWITCH_STATUS_SUCCESS;
        
}

void switch_rtp_break

(

switch_rtp_t *

rtp_session

)

Definition at line 4385 of file switch_rtp.c.

References CF_VIDEO_BREAK, ping_socket(), switch_channel_clear_flag(), switch_channel_test_flag(), switch_core_session_get_channel(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_BREAK, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLAG_VIDEO, SWITCH_RTP_FLAG_VIDEO_BREAK, switch_rtp_ready(), and switch_rtp_video_refresh().

Referenced by switch_core_media_break(), switch_rtp_activate_ice(), switch_rtp_add_dtls(), and switch_rtp_udptl_mode().

{
        if (!switch_rtp_ready(rtp_session)) {
                return;
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                int ret = 1;

                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO_BREAK]) {
                        rtp_session->flags[SWITCH_RTP_FLAG_VIDEO_BREAK] = 0;
                        ret = 0;
                } else if (rtp_session->session) {
                        switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
                        if (switch_channel_test_flag(channel, CF_VIDEO_BREAK)) {
                                switch_channel_clear_flag(channel, CF_VIDEO_BREAK);
                                ret = 0;
                        }
                }

                if (ret) return;

                switch_rtp_video_refresh(rtp_session);
        }

        switch_mutex_lock(rtp_session->flag_mutex);
        rtp_session->flags[SWITCH_RTP_FLAG_BREAK] = 1;

        if (rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK]) {
                switch_mutex_unlock(rtp_session->flag_mutex);
                return;
        }

        if (rtp_session->sock_input) {
                ping_socket(rtp_session);
        }

        switch_mutex_unlock(rtp_session->flag_mutex);
}

switch_status_t switch_rtp_change_interval	(	switch_rtp_t *	rtp_session,
		uint32_t	ms_per_packet,
		uint32_t	samples_per_interval
	)

Definition at line 3687 of file switch_rtp.c.

References memset(), READ_DEC, READ_INC, SWITCH_CHANNEL_SESSION_LOG, switch_core_timer_destroy(), switch_core_timer_init(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_rtp_set_interval(), SWITCH_STATUS_SUCCESS, WRITE_DEC, and WRITE_INC.

Referenced by switch_core_media_set_codec().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        int change_timer = 0;

        if (rtp_session->ms_per_packet && rtp_session->ms_per_packet != ms_per_packet) {
                change_timer = 1;
        }

        switch_rtp_set_interval(rtp_session, ms_per_packet, samples_per_interval);

        if (change_timer && rtp_session->timer_name) {
                READ_INC(rtp_session);
                WRITE_INC(rtp_session);

                if (rtp_session->timer.timer_interface) {
                        switch_core_timer_destroy(&rtp_session->timer);
                }
                if ((status = switch_core_timer_init(&rtp_session->timer,
                                                                                         rtp_session->timer_name, ms_per_packet / 1000,
                                                                                         samples_per_interval, rtp_session->pool)) == SWITCH_STATUS_SUCCESS) {
                        
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG,
                                                          "RE-Starting timer [%s] %d bytes per %dms\n", rtp_session->timer_name, samples_per_interval, ms_per_packet / 1000);
                } else {
                        
                        memset(&rtp_session->timer, 0, sizeof(rtp_session->timer));
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR,
                                                          "Problem RE-Starting timer [%s] %d bytes per %dms\n", rtp_session->timer_name, samples_per_interval, ms_per_packet / 1000);
                }

                WRITE_DEC(rtp_session);
                READ_DEC(rtp_session);
        }

        return status;
}

switch_byte_t switch_rtp_check_auto_adj

(

switch_rtp_t *

rtp_session

)

Definition at line 6893 of file switch_rtp.c.

{
        return rtp_session->auto_adj_used;
}

void switch_rtp_clear_flag	(	switch_rtp_t *	rtp_session,
		switch_rtp_flag_t	flag
	)

Clear an RTP Flag.

Parameters

rtp_session	the RTP session
flags	the flags to clear

Definition at line 4747 of file switch_rtp.c.

References FALSE, reset_jitter_seq(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_DTMF_ON, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLAG_PAUSE, SWITCH_SO_NONBLOCK, and switch_socket_opt_set().

Referenced by do_flush(), handle_ice(), read_rtp_packet(), rtp_common_read(), rtp_common_write(), rtp_flush_read_buffer(), switch_core_media_clear_rtp_flag(), switch_core_media_receive_message(), switch_core_media_resume(), switch_core_media_toggle_hold(), switch_rtp_create(), switch_rtp_disable_vad(), switch_rtp_udptl_mode(), switch_rtp_write_frame(), switch_rtp_write_raw(), and switch_rtp_zerocopy_read_frame().

{

        switch_mutex_lock(rtp_session->flag_mutex);
        rtp_session->flags[flag] = 0;
        switch_mutex_unlock(rtp_session->flag_mutex);

        if (flag == SWITCH_RTP_FLAG_DTMF_ON) {
                rtp_session->stats.inbound.last_processed_seq = 0;
        } else if (flag == SWITCH_RTP_FLAG_PAUSE) {
                reset_jitter_seq(rtp_session);
        } else if (flag == SWITCH_RTP_FLAG_NOBLOCK && rtp_session->sock_input) {
                switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, FALSE);
        }
}

void switch_rtp_clear_flags	(	switch_rtp_t *	rtp_session,
		switch_rtp_flag_t	flags[SWITCH_RTP_FLAG_INVALID]
	)

Definition at line 4691 of file switch_rtp.c.

References SWITCH_RTP_FLAG_INVALID.

Referenced by switch_core_media_receive_message().

{
        int i;

        for(i = 0; i < SWITCH_RTP_FLAG_INVALID; i++) {
                if (flags[i]) {
                        rtp_session->flags[i] = 0;
                }
        }
}

switch_status_t switch_rtp_create	(	switch_rtp_t **	new_rtp_session,
		switch_payload_t	payload,
		uint32_t	samples_per_interval,
		uint32_t	ms_per_packet,
		switch_rtp_flag_t	flags[],
		char *	timer_name,
		const char **	err,
		switch_memory_pool_t *	pool
	)

create a new RTP session handle

Parameters

new_rtp_session	a poiter to aim at the new session
payload	the IANA payload number
samples_per_interval	the default samples_per_interval
ms_per_packet	time in microseconds per packet
flags	flags to control behaviour
timer_name	timer interface to use
err	a pointer to resolve error messages
pool	a memory pool to use for the session

Returns

the new RTP session or NULL on failure

switch_status_t switch_rtp_deactivate_jitter_buffer

(

switch_rtp_t *

rtp_session

)

Definition at line 4079 of file switch_rtp.c.

References SWITCH_RTP_FLAG_KILL_JB, switch_rtp_ready(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by check_jb().

{
        
        if (!switch_rtp_ready(rtp_session) || !rtp_session->jb) {
                return SWITCH_STATUS_FALSE;
        }

        rtp_session->flags[SWITCH_RTP_FLAG_KILL_JB]++;
        
        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_rtp_debug_jitter_buffer	(	switch_rtp_t *	rtp_session,
		const char *	name
	)

Definition at line 4126 of file switch_rtp.c.

References switch_jb_debug_level(), switch_rtp_ready(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by check_jb().

{
        int x = 0;

        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        if (name) x = atoi(name);
        if (x < 0) x = 0;
        
        if (rtp_session->jb) {
                switch_jb_debug_level(rtp_session->jb, x);
        } else if (rtp_session->vb) {
                switch_jb_debug_level(rtp_session->vb, x);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_rtp_del_dtls	(	switch_rtp_t *	rtp_session,
		dtls_type_t	type
	)

Definition at line 3232 of file switch_rtp.c.

References DTLS_TYPE_RTCP, DTLS_TYPE_RTP, free_dtls(), switch_jb_reset(), SWITCH_RTP_FLAG_SECURE_RECV, SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_rtp_add_dtls().

{

        if (!rtp_session || (!rtp_session->dtls && !rtp_session->rtcp_dtls)) {
                return SWITCH_STATUS_FALSE;
        }

        if ((type & DTLS_TYPE_RTP)) {
                if (rtp_session->dtls && rtp_session->dtls == rtp_session->rtcp_dtls) {
                        rtp_session->rtcp_dtls = NULL;
                }
                
                if (rtp_session->dtls) {
                        free_dtls(&rtp_session->dtls);
                }
                
                if (rtp_session->jb) {
                        switch_jb_reset(rtp_session->jb);
                }

                if (rtp_session->vb) {
                        switch_jb_reset(rtp_session->vb);
                }

                if (rtp_session->vbw) {
                        switch_jb_reset(rtp_session->vbw);
                }

        }

        if ((type & DTLS_TYPE_RTCP) && rtp_session->rtcp_dtls) {
                free_dtls(&rtp_session->rtcp_dtls);
        }


#ifdef ENABLE_SRTP
        if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {
                int x;
                for(x = 0; x < 2; x++) {
                        if (rtp_session->send_ctx[x]) {
                                srtp_dealloc(rtp_session->send_ctx[x]);
                                rtp_session->send_ctx[x] = NULL;
                        }
                }
                rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 0;
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV]) {
                int x;
                for (x = 0; x < 2; x++) {
                        if (rtp_session->recv_ctx[x]) {
                                srtp_dealloc(rtp_session->recv_ctx[x]);
                                rtp_session->recv_ctx[x] = NULL;
                        }
                }
                rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 0;
        }
#endif

        return SWITCH_STATUS_SUCCESS;
}

switch_size_t switch_rtp_dequeue_dtmf	(	switch_rtp_t *	rtp_session,
		switch_dtmf_t *	dtmf
	)

Retrieve DTMF digits from a given RTP session.

Parameters

rtp_session	RTP session to retrieve digits from
dtmf	the dtmf

Returns

number of bytes read into the buffer

Definition at line 6911 of file switch_rtp.c.

References SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_rtp_ready(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_read_frame().

{
        switch_size_t bytes = 0;
        switch_dtmf_t *_dtmf = NULL;
        void *pop;

        if (!switch_rtp_ready(rtp_session)) {
                return bytes;
        }

        switch_mutex_lock(rtp_session->dtmf_data.dtmf_mutex);
        if (switch_queue_trypop(rtp_session->dtmf_data.dtmf_inqueue, &pop) == SWITCH_STATUS_SUCCESS) {
                
                _dtmf = (switch_dtmf_t *) pop;
                *dtmf = *_dtmf;
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "RTP RECV DTMF %c:%d\n", dtmf->digit, dtmf->duration);
                bytes++;
                free(pop);
        }
        switch_mutex_unlock(rtp_session->dtmf_data.dtmf_mutex);

        return bytes;
}

void switch_rtp_destroy

(

switch_rtp_t **

rtp_session

)

Destroy an RTP session.

Parameters

rtp_session

an RTP session to destroy

Definition at line 4491 of file switch_rtp.c.

References free_dtls(), READ_DEC, READ_INC, switch_core_timer_destroy(), switch_jb_destroy(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_rtp_disable_vad(), SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_SECURE_RECV, SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_RTP_FLAG_SHUTDOWN, SWITCH_RTP_FLAG_VAD, switch_rtp_kill_socket(), switch_rtp_release_port(), switch_safe_free, switch_socket_close(), SWITCH_STATUS_SUCCESS, SWITCH_ZRTP_FLAG_SECURE_RECV, SWITCH_ZRTP_FLAG_SECURE_SEND, WRITE_DEC, and WRITE_INC.

Referenced by switch_core_media_deactivate_rtp().

{
        void *pop;
        switch_socket_t *sock;
#ifdef ENABLE_SRTP
        int x;
#endif

        if (!rtp_session || !*rtp_session || !(*rtp_session)->ready) {
                return;
        }

        (*rtp_session)->flags[SWITCH_RTP_FLAG_SHUTDOWN] = 1;

        READ_INC((*rtp_session));
        WRITE_INC((*rtp_session));

        (*rtp_session)->ready = 0;

        READ_DEC((*rtp_session));
        WRITE_DEC((*rtp_session));

        if ((*rtp_session)->flags[SWITCH_RTP_FLAG_VAD]) {
                switch_rtp_disable_vad(*rtp_session);
        }

        switch_mutex_lock((*rtp_session)->flag_mutex);

        switch_rtp_kill_socket(*rtp_session);

        while (switch_queue_trypop((*rtp_session)->dtmf_data.dtmf_inqueue, &pop) == SWITCH_STATUS_SUCCESS) {
                switch_safe_free(pop);
        }

        while (switch_queue_trypop((*rtp_session)->dtmf_data.dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                switch_safe_free(pop);
        }

        if ((*rtp_session)->jb) {
                switch_jb_destroy(&(*rtp_session)->jb);
        }

        if ((*rtp_session)->vb) {
                switch_jb_destroy(&(*rtp_session)->vb);
        }

        if ((*rtp_session)->vbw) {
                switch_jb_destroy(&(*rtp_session)->vbw);
        }

        if ((*rtp_session)->dtls && (*rtp_session)->dtls == (*rtp_session)->rtcp_dtls) {
                (*rtp_session)->rtcp_dtls = NULL;
        }

        if ((*rtp_session)->dtls) {
                free_dtls(&(*rtp_session)->dtls);
        }

        if ((*rtp_session)->rtcp_dtls) {
                free_dtls(&(*rtp_session)->rtcp_dtls);
        }


        sock = (*rtp_session)->sock_input;
        (*rtp_session)->sock_input = NULL;
        switch_socket_close(sock);

        if ((*rtp_session)->sock_output != sock) {
                sock = (*rtp_session)->sock_output;
                (*rtp_session)->sock_output = NULL;
                switch_socket_close(sock);
        }

        if ((sock = (*rtp_session)->rtcp_sock_input)) {
                (*rtp_session)->rtcp_sock_input = NULL;
                switch_socket_close(sock);

                if ((*rtp_session)->rtcp_sock_output && (*rtp_session)->rtcp_sock_output != sock) {
                        if ((sock = (*rtp_session)->rtcp_sock_output)) {
                                (*rtp_session)->rtcp_sock_output = NULL;
                                switch_socket_close(sock);
                        }
                }
        }

#ifdef ENABLE_SRTP
        if ((*rtp_session)->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {
                for(x = 0; x < 2; x++) {
                        if ((*rtp_session)->send_ctx[x]) {
                                srtp_dealloc((*rtp_session)->send_ctx[x]);
                                (*rtp_session)->send_ctx[x] = NULL;
                        }
                }
                (*rtp_session)->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 0;
        }

        if ((*rtp_session)->flags[SWITCH_RTP_FLAG_SECURE_RECV]) {
                for (x = 0; x < 2; x++) {
                        if ((*rtp_session)->recv_ctx[x]) {
                                srtp_dealloc((*rtp_session)->recv_ctx[x]);
                                (*rtp_session)->recv_ctx[x] = NULL;
                        }
                }
                (*rtp_session)->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 0;
        }
#endif

#ifdef ENABLE_ZRTP
        /* ZRTP */
        if (zrtp_on && !(*rtp_session)->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {

                if ((*rtp_session)->zrtp_stream != NULL) {
                        zrtp_stream_stop((*rtp_session)->zrtp_stream);
                }

                if ((*rtp_session)->flags[SWITCH_ZRTP_FLAG_SECURE_SEND]) {
                        (*rtp_session)->flags[SWITCH_ZRTP_FLAG_SECURE_SEND] = 0;
                }

                if ((*rtp_session)->flags[SWITCH_ZRTP_FLAG_SECURE_RECV]) {
                        (*rtp_session)->flags[SWITCH_ZRTP_FLAG_SECURE_RECV] = 0;
                }

                if ((*rtp_session)->zrtp_session) {
                        zrtp_session_down((*rtp_session)->zrtp_session);
                        (*rtp_session)->zrtp_session = NULL;
                }
        }
#endif
        if ((*rtp_session)->timer.timer_interface) {
                switch_core_timer_destroy(&(*rtp_session)->timer);
        }

        switch_rtp_release_port((*rtp_session)->rx_host, (*rtp_session)->rx_port);
        switch_mutex_unlock((*rtp_session)->flag_mutex);

        return;
}

switch_status_t switch_rtp_disable_vad

(

switch_rtp_t *

rtp_session

)

Disable VAD on an RTP Session.

Parameters

rtp_session

the RTP session

Returns

SWITCH_STAUTS_SUCCESS on success

Definition at line 7654 of file switch_rtp.c.

References switch_core_codec_destroy(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_VAD, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

Referenced by switch_rtp_destroy().

{

        if (!rtp_session) {
                return SWITCH_STATUS_FALSE;
        }

        if (!rtp_session->flags[SWITCH_RTP_FLAG_VAD]) {
                return SWITCH_STATUS_GENERR;
        }
        switch_core_codec_destroy(&rtp_session->vad_data.vad_codec);
        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_VAD);
        return SWITCH_STATUS_SUCCESS;
}

dtls_state_t switch_rtp_dtls_state	(	switch_rtp_t *	rtp_session,
		dtls_type_t	type
	)

Definition at line 3215 of file switch_rtp.c.

References DS_OFF, DTLS_TYPE_RTCP, and DTLS_TYPE_RTP.

Referenced by check_engine().

{
        if (!rtp_session || (!rtp_session->dtls && !rtp_session->rtcp_dtls)) {
                return DS_OFF;
        }

        if ((type == DTLS_TYPE_RTP) && rtp_session->dtls) {
                return rtp_session->dtls->state;
        }

        if ((type == DTLS_TYPE_RTCP) && rtp_session->rtcp_dtls) {
                return rtp_session->rtcp_dtls->state;
        }

        return DS_OFF;
}

switch_status_t switch_rtp_enable_vad	(	switch_rtp_t *	rtp_session,
		switch_core_session_t *	session,
		switch_codec_t *	codec,
		switch_vad_flag_t	flags
	)

Enable VAD on an RTP Session.

Parameters

rtp_session	the RTP session
session	the core session associated with the RTP session
codec	the codec the channel is currenty using
flags	flags for control

Returns

SWITCH_STAUTS_SUCCESS on success

Definition at line 7669 of file switch_rtp.c.

References memset(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_init, switch_core_session_get_channel(), switch_epoch_time_now(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_RTP_FLAG_VAD, switch_rtp_ready(), switch_rtp_set_flag(), switch_set_flag, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_time_now(), switch_true(), SWITCH_VAD_FLAG_CNG, SWITCH_VAD_FLAG_TALKING, VAD_FIRE_NOT_TALK, and VAD_FIRE_TALK.

Referenced by switch_core_media_activate_rtp().

{
        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_VAD]) {
                return SWITCH_STATUS_GENERR;
        }

        memset(&rtp_session->vad_data, 0, sizeof(rtp_session->vad_data));

        if (switch_true(switch_channel_get_variable(switch_core_session_get_channel(rtp_session->session), "fire_talk_events"))) {
                rtp_session->vad_data.fire_events |= VAD_FIRE_TALK;
        }

        if (switch_true(switch_channel_get_variable(switch_core_session_get_channel(rtp_session->session), "fire_not_talk_events"))) {
                rtp_session->vad_data.fire_events |= VAD_FIRE_NOT_TALK;
        }
        

        if (switch_core_codec_init(&rtp_session->vad_data.vad_codec,
                                                           codec->implementation->iananame,
                                                           codec->implementation->modname,
                                                           NULL,
                                                           codec->implementation->samples_per_second,
                                                           codec->implementation->microseconds_per_packet / 1000,
                                                           codec->implementation->number_of_channels,
                                                           SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Can't load codec?\n");
                return SWITCH_STATUS_FALSE;
        }
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Activate VAD codec %s %dms\n", codec->implementation->iananame,
                                          codec->implementation->microseconds_per_packet / 1000);
        rtp_session->vad_data.diff_level = 400;
        rtp_session->vad_data.hangunder = 15;
        rtp_session->vad_data.hangover = 40;
        rtp_session->vad_data.bg_len = 5;
        rtp_session->vad_data.bg_count = 5;
        rtp_session->vad_data.bg_level = 300;
        rtp_session->vad_data.read_codec = codec;
        rtp_session->vad_data.session = session;
        rtp_session->vad_data.flags = flags;
        rtp_session->vad_data.cng_freq = 50;
        rtp_session->vad_data.ts = 1;
        rtp_session->vad_data.start = 0;
        rtp_session->vad_data.next_scan = switch_epoch_time_now(NULL);
        rtp_session->vad_data.scan_freq = 0;
        if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
                rtp_session->vad_data.start_talking = switch_time_now();
        }
        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_VAD);
        switch_set_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_CNG);
        return SWITCH_STATUS_SUCCESS;
}

void switch_rtp_flush

(

switch_rtp_t *

rtp_session

)

Definition at line 4331 of file switch_rtp.c.

References SWITCH_RTP_FLAG_FLUSH, switch_rtp_ready(), and switch_rtp_set_flag().

Referenced by switch_core_media_receive_message().

{
        if (!switch_rtp_ready(rtp_session)) {
                return;
        }

        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
}

uint32_t switch_rtp_get_default_payload

(

switch_rtp_t *

rtp_session

)

Get the default payload number for a given RTP session.

Parameters

rtp_session

the RTP session to get the payload number from

Returns

the default payload of the RTP session

Definition at line 4650 of file switch_rtp.c.

{
        return rtp_session->payload;
}

uint32_t switch_rtp_get_default_samples_per_interval

(

switch_rtp_t *

rtp_session

)

Get the default samples per interval for a given RTP session.

Parameters

rtp_session

the RTP session to get the samples per interval from

Returns

the default samples per interval of the RTP session

Definition at line 4640 of file switch_rtp.c.

{
        return rtp_session->samples_per_interval;
}

switch_jb_t* switch_rtp_get_jitter_buffer

(

switch_rtp_t *

rtp_session

)

Definition at line 4050 of file switch_rtp.c.

References switch_rtp_ready().

Referenced by switch_core_media_get_jb().

{
        if (!switch_rtp_ready(rtp_session) || !rtp_session->jb) {
                return NULL;
        }

        return rtp_session->jb;
}

switch_timer_t* switch_rtp_get_media_timer

(

switch_rtp_t *

rtp_session

)

Definition at line 4036 of file switch_rtp.c.

References switch_core_timer_sync(), and SWITCH_RTP_FLAG_VIDEO.

Referenced by switch_core_media_get_timer().

{

        if (rtp_session && rtp_session->timer.timer_interface) {
                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                        switch_core_timer_sync(&rtp_session->timer);
                }
                return &rtp_session->timer;
        }

        return NULL;
}

void* switch_rtp_get_private

(

switch_rtp_t *

rtp_session

)

Retrieve the private data from a given RTP session.

Parameters

rtp_session

the RTP session to retrieve the data from

Returns

the pointer to the private data

Definition at line 8099 of file switch_rtp.c.

{
        return rtp_session->private_data;
}

void switch_rtp_get_random	(	void *	buf,
		uint32_t	len
	)

Definition at line 2338 of file switch_rtp.c.

References switch_stun_random_string().

Referenced by switch_core_media_build_crypto().

{
#ifdef ENABLE_SRTP
        crypto_get_random(buf, len);
#else
        switch_stun_random_string(buf, len, NULL);
#endif
}

char* switch_rtp_get_remote_host

(

switch_rtp_t *

rtp_session

)

Definition at line 2822 of file switch_rtp.c.

References zstr.

Referenced by switch_core_media_activate_rtp(), switch_core_media_negotiate_sdp(), switch_core_media_process_t38_passthru(), switch_core_media_proxy_remote_addr(), and switch_core_media_start_udptl().

{
        return zstr(rtp_session->remote_host_str) ? "0.0.0.0" : rtp_session->remote_host_str;
}

switch_port_t switch_rtp_get_remote_port

(

switch_rtp_t *

rtp_session

)

Definition at line 2827 of file switch_rtp.c.

Referenced by switch_core_media_activate_rtp(), switch_core_media_negotiate_sdp(), switch_core_media_process_t38_passthru(), switch_core_media_proxy_remote_addr(), and switch_core_media_start_udptl().

{
        return rtp_session->remote_port;
}

switch_socket_t* switch_rtp_get_rtp_socket

(

switch_rtp_t *

rtp_session

)

Retrieve the socket from an existing RTP session.

Parameters

rtp_session

the RTP session to retrieve the socket from

Returns

the socket from the RTP session

Definition at line 4635 of file switch_rtp.c.

{
        return rtp_session->sock_input;
}

uint32_t switch_rtp_get_ssrc

(

switch_rtp_t *

rtp_session

)

Retrieve the SSRC from a given RTP session.

Parameters

rtp_session

the RTP session to retrieve from

Returns

the SSRC

Definition at line 8089 of file switch_rtp.c.

Referenced by switch_core_media_activate_rtp().

{
        return rtp_session->ssrc;
}

switch_rtp_stats_t* switch_rtp_get_stats	(	switch_rtp_t *	rtp_session,
		switch_memory_pool_t *	pool
	)

Definition at line 7928 of file switch_rtp.c.

References do_mos(), switch_rtp_stats_t::inbound, switch_rtp_numbers_t::largest_jb_size, switch_core_alloc, SWITCH_FALSE, switch_jb_get_frames(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_media_get_stats().

{
        switch_rtp_stats_t *s;

        if (!rtp_session) {
                return NULL;
        }

        switch_mutex_lock(rtp_session->flag_mutex);
        if (pool) {
                s = switch_core_alloc(pool, sizeof(*s));
                *s = rtp_session->stats;
        } else {
                s = &rtp_session->stats;
        }

        if (rtp_session->jb) {
                switch_jb_get_frames(rtp_session->jb, NULL, NULL, NULL, (uint32_t *)&s->inbound.largest_jb_size);
        }

        do_mos(rtp_session, SWITCH_FALSE);

        switch_mutex_unlock(rtp_session->flag_mutex);

        return s;
}

switch_status_t switch_rtp_get_video_buffer_size	(	switch_rtp_t *	rtp_session,
		uint32_t *	min_frame_len,
		uint32_t *	max_frame_len,
		uint32_t *	cur_frame_len,
		uint32_t *	highest_frame_len
	)

Definition at line 4091 of file switch_rtp.c.

References switch_jb_get_frames(), and SWITCH_STATUS_FALSE.

Referenced by check_jb_sync().

{
        
        if (rtp_session->vb) {
                return switch_jb_get_frames(rtp_session->vb, min_frame_len, max_frame_len, cur_frame_len, highest_frame_len);
        }

        return SWITCH_STATUS_FALSE;
}

int switch_rtp_has_dtls

(

void

)

Definition at line 3207 of file switch_rtp.c.

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

                                              {
#ifdef HAVE_OPENSSL_DTLS_SRTP
        return 1;
#else
        return 0;
#endif
}

switch_size_t switch_rtp_has_dtmf

(

switch_rtp_t *

rtp_session

)

Test for presence of DTMF on a given RTP session.

Parameters

rtp_session

session to test

Returns

number of digits in the queue

Definition at line 6898 of file switch_rtp.c.

References switch_mutex_lock(), switch_mutex_unlock(), switch_queue_size(), and switch_rtp_ready().

Referenced by switch_core_media_read_frame().

{
        switch_size_t has = 0;

        if (switch_rtp_ready(rtp_session)) {
                switch_mutex_lock(rtp_session->dtmf_data.dtmf_mutex);
                has = switch_queue_size(rtp_session->dtmf_data.dtmf_inqueue);
                switch_mutex_unlock(rtp_session->dtmf_data.dtmf_mutex);
        }

        return has;
}

void switch_rtp_init

(

switch_memory_pool_t *

pool

)

Initilize the RTP System.

Parameters

pool	the memory pool to use for long term allocations

Note

Generally called by the core_init

Definition at line 1442 of file switch_rtp.c.

References switch_directories::db_dir, port_lock, SSHF_NO_DEL, SSHF_NONE, SWITCH_CHANNEL_LOG, switch_core_get_variable_pdup(), switch_core_hash_init, switch_core_set_variable(), switch_epoch_time_now(), SWITCH_GLOBAL_dirs, SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_PATH_SEPARATOR, switch_scheduler_add_task(), switch_snprintf(), and switch_true().

Referenced by switch_core_init().

{
#ifdef ENABLE_ZRTP
        const char *zid_string = switch_core_get_variable_pdup("switch_serial", pool);
        const char *zrtp_enabled = switch_core_get_variable_pdup("zrtp_enabled", pool);
        zrtp_config_t zrtp_config;
        char zrtp_cache_path[256] = "";
        zrtp_on = zrtp_enabled ? switch_true(zrtp_enabled) : 0;
#endif
        if (global_init) {
                return;
        }
        switch_core_hash_init(&alloc_hash);
#ifdef ENABLE_ZRTP
        if (zrtp_on) {
                uint32_t cache_len;
                zrtp_config_defaults(&zrtp_config);
                strcpy(zrtp_config.client_id, "FreeSWITCH");
                zrtp_config.is_mitm = 1;
                zrtp_config.lic_mode = ZRTP_LICENSE_MODE_ACTIVE;
                switch_snprintf(zrtp_cache_path, sizeof(zrtp_cache_path), "%s%szrtp.dat", SWITCH_GLOBAL_dirs.db_dir, SWITCH_PATH_SEPARATOR);
                cache_len=(uint32_t)strlen(zrtp_cache_path);
                ZSTR_SET_EMPTY(zrtp_config.def_cache_path);
                zrtp_config.def_cache_path.length = cache_len > zrtp_config.def_cache_path.max_length ? zrtp_config.def_cache_path.max_length : (uint16_t)cache_len;
                strncpy(zrtp_config.def_cache_path.buffer, zrtp_cache_path, zrtp_config.def_cache_path.max_length);
                zrtp_config.cb.event_cb.on_zrtp_protocol_event = (void (*)(zrtp_stream_t*,zrtp_protocol_event_t))zrtp_event_callback;
                zrtp_config.cb.misc_cb.on_send_packet = zrtp_send_rtp_callback;
                zrtp_config.cb.event_cb.on_zrtp_security_event = (void (*)(zrtp_stream_t*,zrtp_security_event_t))zrtp_event_callback;
                zrtp_log_set_log_engine((zrtp_log_engine *) zrtp_logger);
                zrtp_log_set_level(4);
                if (zrtp_status_ok == zrtp_init(&zrtp_config, &zrtp_global)) {
                        memcpy(zid, zid_string, 12);
                        switch_scheduler_add_task(switch_epoch_time_now(NULL) + 900, zrtp_cache_save_callback, "zrtp_cache_save", "core", 0, NULL,
                                                                          SSHF_NONE | SSHF_NO_DEL);
                } else {
                        switch_core_set_variable("zrtp_enabled", NULL);
                        zrtp_on = 0;
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "ZRTP init failed!\n");
                }
        }
#endif
#ifdef ENABLE_SRTP
        srtp_init();
#endif
        switch_mutex_init(&port_lock, SWITCH_MUTEX_NESTED, pool);
        global_init = 1;
}

void switch_rtp_intentional_bugs	(	switch_rtp_t *	rtp_session,
		switch_rtp_bug_flag_t	bugs
	)

Definition at line 2467 of file switch_rtp.c.

References RTP_BUG_START_SEQ_AT_ZERO.

Referenced by switch_core_media_activate_rtp().

{
        rtp_session->rtp_bugs = bugs;

        if ((rtp_session->rtp_bugs & RTP_BUG_START_SEQ_AT_ZERO)) {
                rtp_session->seq = 0;
        }

}

void switch_rtp_kill_socket

(

switch_rtp_t *

rtp_session

)

Kill the socket on an existing RTP session.

Parameters

rtp_session

an RTP session to kill the socket of

Definition at line 4425 of file switch_rtp.c.

References ping_socket(), switch_assert, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_IO, SWITCH_SHUTDOWN_READWRITE, and switch_socket_shutdown().

Referenced by switch_core_media_kill_socket(), switch_rtp_destroy(), and switch_rtp_set_local_address().

{
        switch_assert(rtp_session != NULL);
        switch_mutex_lock(rtp_session->flag_mutex);
        if (rtp_session->flags[SWITCH_RTP_FLAG_IO]) {
                rtp_session->flags[SWITCH_RTP_FLAG_IO] = 0;
                if (rtp_session->sock_input) {
                        ping_socket(rtp_session);
                        switch_socket_shutdown(rtp_session->sock_input, SWITCH_SHUTDOWN_READWRITE);
                }
                if (rtp_session->sock_output && rtp_session->sock_output != rtp_session->sock_input) {
                        switch_socket_shutdown(rtp_session->sock_output, SWITCH_SHUTDOWN_READWRITE);
                }
                
                if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                        if (rtp_session->rtcp_sock_input) {
                                ping_socket(rtp_session);
                                switch_socket_shutdown(rtp_session->rtcp_sock_input, SWITCH_SHUTDOWN_READWRITE);
                        }
                        if (rtp_session->rtcp_sock_output && rtp_session->rtcp_sock_output != rtp_session->rtcp_sock_input) {
                                switch_socket_shutdown(rtp_session->rtcp_sock_output, SWITCH_SHUTDOWN_READWRITE);
                        }
                }
        }
        switch_mutex_unlock(rtp_session->flag_mutex);
}

switch_rtp_t* switch_rtp_new	(	const char *	rx_host,
		switch_port_t	rx_port,
		const char *	tx_host,
		switch_port_t	tx_port,
		switch_payload_t	payload,
		uint32_t	samples_per_interval,
		uint32_t	ms_per_packet,
		switch_rtp_flag_t	flags[],
		char *	timer_name,
		const char **	err,
		switch_memory_pool_t *	pool
	)

prepare a new RTP session handle and fully initilize it

Parameters

rx_host	the local address
rx_port	the local port
tx_host	the remote address
tx_port	the remote port
payload	the IANA payload number
samples_per_interval	the default samples_per_interval
ms_per_packet	time in microseconds per packet
flags	flags to control behaviour
timer_name	timer interface to use
err	a pointer to resolve error messages
pool	a memory pool to use for the session

Returns

the new RTP session or NULL on failure

Referenced by switch_core_media_activate_rtp().

switch_status_t switch_rtp_pause_jitter_buffer	(	switch_rtp_t *	rtp_session,
		switch_bool_t	pause
	)

Definition at line 4059 of file switch_rtp.c.

References switch_jb_reset(), switch_rtp_ready(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by check_jb(), and switch_core_media_receive_message().

{
        
        if (!switch_rtp_ready(rtp_session) || !rtp_session->jb) {
                return SWITCH_STATUS_FALSE;
        }

        if (!!pause == !!rtp_session->pause_jb) {
                return SWITCH_STATUS_FALSE;
        }

        if (rtp_session->pause_jb && !pause) {
                switch_jb_reset(rtp_session->jb);
        }

        rtp_session->pause_jb = pause ? 1 : 0;
        
        return SWITCH_STATUS_SUCCESS;
}

void switch_rtp_ping

(

switch_rtp_t *

rtp_session

)

Definition at line 2333 of file switch_rtp.c.

References check_rtcp_and_ice().

{
        check_rtcp_and_ice(rtp_session);
}

switch_status_t switch_rtp_queue_rfc2833	(	switch_rtp_t *	rtp_session,
		const switch_dtmf_t *	dtmf
	)

Queue RFC2833 DTMF data into an RTP Session.

Parameters

rtp_session	the rtp session to use
dtmf	the dtmf digits to queue

Returns

SWITCH_STATUS_SUCCESS on success

Definition at line 6935 of file switch_rtp.c.

References switch_dtmf_t::duration, switch_core_min_dtmf_duration(), switch_queue_trypush(), switch_rtp_ready(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_queue_rfc2833().

{

        switch_dtmf_t *rdigit;

        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        if ((rdigit = malloc(sizeof(*rdigit))) != 0) {
                *rdigit = *dtmf;
                if (rdigit->duration < switch_core_min_dtmf_duration(0)) {
                        rdigit->duration = switch_core_min_dtmf_duration(0);
                }

                if ((switch_queue_trypush(rtp_session->dtmf_data.dtmf_queue, rdigit)) != SWITCH_STATUS_SUCCESS) {
                        free(rdigit);
                        return SWITCH_STATUS_FALSE;
                }
        } else {
                abort();
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_rtp_queue_rfc2833_in	(	switch_rtp_t *	rtp_session,
		const switch_dtmf_t *	dtmf
	)

Queue RFC2833 DTMF data into an RTP Session.

Parameters

rtp_session	the rtp session to use
dtmf	the dtmf digits to queue

Returns

SWITCH_STATUS_SUCCESS on success

Definition at line 6961 of file switch_rtp.c.

References switch_dtmf_t::duration, switch_core_min_dtmf_duration(), switch_queue_trypush(), switch_rtp_ready(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by handle_rfc2833(), and switch_core_media_queue_rfc2833_in().

{
        switch_dtmf_t *rdigit;

        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        if ((rdigit = malloc(sizeof(*rdigit))) != 0) {
                *rdigit = *dtmf;
                if (rdigit->duration < switch_core_min_dtmf_duration(0)) {
                        rdigit->duration = switch_core_min_dtmf_duration(0);
                }

                if ((switch_queue_trypush(rtp_session->dtmf_data.dtmf_inqueue, rdigit)) != SWITCH_STATUS_SUCCESS) {
                        free(rdigit);
                        return SWITCH_STATUS_FALSE;
                }
        } else {
                abort();
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_rtp_read	(	switch_rtp_t *	rtp_session,
		void *	data,
		uint32_t *	datalen,
		switch_payload_t *	payload_type,
		switch_frame_flag_t *	flags,
		switch_io_flag_t	io_flags
	)

Read data from a given RTP session.

Parameters

rtp_session	the RTP session to read from
data	the data to read
datalen	a pointer to the datalen
payload_type	the IANA payload of the packet
flags	flags
io_flags	i/o flags

Returns

the number of bytes read

Definition at line 6986 of file switch_rtp.c.

References RTP_BODY, rtp_common_read(), rtp_header_len, switch_rtp_ready(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, and SWITCH_STATUS_TIMEOUT.

{
        int bytes = 0;

        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        bytes = rtp_common_read(rtp_session, payload_type, NULL, flags, io_flags);

        if (bytes < 0) {
                *datalen = 0;
                return bytes == -2 ? SWITCH_STATUS_TIMEOUT : SWITCH_STATUS_GENERR;
        } else if (bytes == 0) {
                *datalen = 0;
                return SWITCH_STATUS_BREAK;
        } else {
                if (bytes > rtp_header_len) {
                        bytes -= rtp_header_len;
                }
        }

        *datalen = bytes;

        memcpy(data, RTP_BODY(rtp_session), bytes);

        return SWITCH_STATUS_SUCCESS;
}

uint8_t switch_rtp_ready

(

switch_rtp_t *

rtp_session

)

Test if an RTP session is ready.

Parameters

rtp_session

an RTP session to test

Returns

a true value if it's ready

Definition at line 4452 of file switch_rtp.c.

References switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_IO, and SWITCH_RTP_FLAG_SHUTDOWN.

Referenced by check_ice(), do_flush(), handle_ice(), handle_rfc2833(), rtp_common_read(), rtp_common_write(), rtp_flush_read_buffer(), switch_core_media_activate_rtp(), switch_core_media_break(), switch_core_media_check_udptl_mode(), switch_core_media_clear_rtp_flag(), switch_core_media_get_jb(), switch_core_media_kill_socket(), switch_core_media_negotiate_sdp(), switch_core_media_patch_sdp(), switch_core_media_proxy_remote_addr(), switch_core_media_queue_rfc2833(), switch_core_media_queue_rfc2833_in(), switch_core_media_read_frame(), switch_core_media_read_lock_unlock(), switch_core_media_ready(), switch_core_media_receive_message(), switch_core_media_reset_jb(), switch_core_media_set_codec(), switch_core_media_set_rtp_flag(), switch_core_media_set_telephony_event(), switch_core_media_set_telephony_recv_event(), switch_core_media_set_video_codec(), switch_core_media_start_udptl(), switch_core_media_udptl_mode(), switch_core_media_write_frame(), switch_core_session_check_incoming_crypto(), switch_rtp_activate_jitter_buffer(), switch_rtp_add_dtls(), switch_rtp_break(), switch_rtp_deactivate_jitter_buffer(), switch_rtp_debug_jitter_buffer(), switch_rtp_dequeue_dtmf(), switch_rtp_enable_vad(), switch_rtp_flush(), switch_rtp_get_jitter_buffer(), switch_rtp_has_dtmf(), switch_rtp_pause_jitter_buffer(), switch_rtp_queue_rfc2833(), switch_rtp_queue_rfc2833_in(), switch_rtp_read(), switch_rtp_reset_jb(), switch_rtp_set_local_address(), switch_rtp_set_max_missed_packets(), switch_rtp_set_video_buffer_size(), switch_rtp_udptl_mode(), switch_rtp_write_frame(), switch_rtp_write_manual(), switch_rtp_write_raw(), switch_rtp_zerocopy_read(), and switch_rtp_zerocopy_read_frame().

{
        uint8_t ret;

        if (!rtp_session || !rtp_session->flag_mutex || rtp_session->flags[SWITCH_RTP_FLAG_SHUTDOWN]) {
                return 0;
        }

        switch_mutex_lock(rtp_session->flag_mutex);
        ret = (rtp_session->flags[SWITCH_RTP_FLAG_IO] && rtp_session->sock_input && rtp_session->sock_output && rtp_session->remote_addr
                   && rtp_session->ready == 2) ? 1 : 0;
        switch_mutex_unlock(rtp_session->flag_mutex);

        return ret;
}

void switch_rtp_release_port	(	const char *	ip,
		switch_port_t	port
	)

Definition at line 2415 of file switch_rtp.c.

References port_lock, switch_core_hash_find(), switch_core_port_allocator_free_port(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_media_choose_port(), switch_core_media_deactivate_rtp(), switch_rtp_destroy(), and switch_rtp_new().

{
        switch_core_port_allocator_t *alloc = NULL;

        if (!ip || !port) {
                return;
        }

        switch_mutex_lock(port_lock);
        if ((alloc = switch_core_hash_find(alloc_hash, ip))) {
                switch_core_port_allocator_free_port(alloc, port);
        }
        switch_mutex_unlock(port_lock);

}

switch_status_t switch_rtp_req_bitrate	(	switch_rtp_t *	rtp_session,
		uint32_t	bps
	)

Definition at line 4340 of file switch_rtp.c.

References rtp_write_ready(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_receive_message().

{
        if (!rtp_write_ready(rtp_session, 0, __LINE__) || rtp_session->tmmbr) {
                return SWITCH_STATUS_FALSE;
        }

        rtp_session->tmmbr = bps;

        return SWITCH_STATUS_SUCCESS;
}

switch_port_t switch_rtp_request_port

(

const char *

ip

)

Request a new port to be used for media.

Parameters

ip	the ip to request a port from

Returns

the new port to use

Definition at line 2431 of file switch_rtp.c.

References END_PORT, port_lock, SPF_EVEN, START_PORT, switch_core_hash_find(), switch_core_hash_insert, switch_core_port_allocator_new(), switch_core_port_allocator_request_port(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_choose_port().

{
        switch_port_t port = 0;
        switch_core_port_allocator_t *alloc = NULL;

        switch_mutex_lock(port_lock);
        alloc = switch_core_hash_find(alloc_hash, ip);
        if (!alloc) {
                if (switch_core_port_allocator_new(ip, START_PORT, END_PORT, SPF_EVEN, &alloc) != SWITCH_STATUS_SUCCESS) {
                        abort();
                }

                switch_core_hash_insert(alloc_hash, ip, alloc);
        }

        if (switch_core_port_allocator_request_port(alloc, &port) != SWITCH_STATUS_SUCCESS) {
                port = 0;
        }

        switch_mutex_unlock(port_lock);
        return port;
}

void switch_rtp_reset

(

switch_rtp_t *

rtp_session

)

Definition at line 2789 of file switch_rtp.c.

References memset(), rtcp_stats_init(), SWITCH_RTP_FLAG_MUTE, SWITCH_RTP_FLAG_PAUSE, switch_rtp_reset_vb(), and switch_rtp_set_flag().

Referenced by clear_ice(), and switch_core_session_stop_media().

{
        if (!rtp_session) {
                return;
        }

        rtp_session->seq = (uint16_t) rand();
        rtp_session->ts = 0;
        memset(&rtp_session->ts_norm, 0, sizeof(rtp_session->ts_norm));

        rtp_session->last_stun = rtp_session->first_stun = 0;
        rtp_session->wrong_addrs = 0;
        rtp_session->rtcp_sent_packets = 0;
        rtp_session->rtcp_last_sent = 0;
        rtp_session->ice_adj = 0;
        
        //switch_rtp_del_dtls(rtp_session, DTLS_TYPE_RTP|DTLS_TYPE_RTCP);
        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_PAUSE);
        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_MUTE);
        rtcp_stats_init(rtp_session);
        
        if (rtp_session->ice.ready) {
                switch_rtp_reset_vb(rtp_session);
                rtp_session->ice.ready = rtp_session->ice.rready = 0;
        }

}

void switch_rtp_reset_jb

(

switch_rtp_t *

rtp_session

)

Definition at line 2769 of file switch_rtp.c.

References switch_jb_reset(), and switch_rtp_ready().

Referenced by switch_core_media_receive_message(), switch_core_media_reset_jb(), and switch_core_media_set_codec().

{
        if (switch_rtp_ready(rtp_session)) {
                if (rtp_session->jb) {
                        switch_jb_reset(rtp_session->jb);
                }
        }
}

void switch_rtp_reset_media_timer

(

switch_rtp_t *

rtp_session

)

Definition at line 2817 of file switch_rtp.c.

Referenced by rtp_common_read(), switch_core_media_activate_rtp(), and switch_core_media_toggle_hold().

{
        rtp_session->missed_count = 0;
}

void switch_rtp_set_cng_pt	(	switch_rtp_t *	rtp_session,
		switch_payload_t	pt
	)

Set the payload type for comfort noise.

Parameters

rtp_session	the RTP session to modify
pt	the payload type

Definition at line 4030 of file switch_rtp.c.

References SWITCH_RTP_FLAG_AUTO_CNG.

Referenced by switch_core_media_activate_rtp(), and switch_core_media_negotiate_sdp().

{
        rtp_session->cng_pt = pt;
        rtp_session->flags[SWITCH_RTP_FLAG_AUTO_CNG] = 1;
}

void switch_rtp_set_default_payload	(	switch_rtp_t *	rtp_session,
		switch_payload_t	payload
	)

Set the default payload number for a given RTP session.

Parameters

rtp_session	the RTP session to set the payload number on
payload	the new default payload number

Definition at line 4645 of file switch_rtp.c.

Referenced by switch_core_media_activate_rtp(), switch_core_media_negotiate_sdp(), switch_core_media_set_codec(), switch_core_media_set_video_codec(), and switch_core_session_start_video_thread().

{
        rtp_session->payload = payload;
}

switch_port_t switch_rtp_set_end_port

(

switch_port_t

port

)

Set/Get RTP end port.

Parameters

port	new value (if > 0)

Returns

the current RTP end port

Definition at line 2401 of file switch_rtp.c.

References END_PORT, port_lock, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_get_rtp_port_range_end_port(), and switch_load_core_config().

{
        if (port) {
                if (port_lock) {
                        switch_mutex_lock(port_lock);
                }
                END_PORT = port;
                if (port_lock) {
                        switch_mutex_unlock(port_lock);
                }
        }
        return END_PORT;
}

void switch_rtp_set_flag	(	switch_rtp_t *	rtp_session,
		switch_rtp_flag_t	flag
	)

Set an RTP Flag.

Parameters

rtp_session	the RTP session
flags	the flags to set

Definition at line 4702 of file switch_rtp.c.

References reset_jitter_seq(), rtp_flush_read_buffer(), switch_channel_get_variable, switch_core_session_get_channel(), switch_jb_reset(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_AUTOADJ, SWITCH_RTP_FLAG_DTMF_ON, SWITCH_RTP_FLAG_FLUSH, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLUSH_ONCE, SWITCH_SO_NONBLOCK, switch_socket_opt_set(), and TRUE.

Referenced by do_flush(), handle_ice(), read_rtp_packet(), rtp_common_read(), rtp_flush_read_buffer(), switch_core_media_activate_rtp(), switch_core_media_check_autoadj(), switch_core_media_pause(), switch_core_media_proxy_remote_addr(), switch_core_media_receive_message(), switch_core_media_set_rtp_flag(), switch_core_media_start_udptl(), switch_core_media_toggle_hold(), switch_rtp_create(), switch_rtp_enable_vad(), switch_rtp_flush(), switch_rtp_new(), switch_rtp_reset(), switch_rtp_set_local_address(), and switch_rtp_udptl_mode().

{

        switch_mutex_lock(rtp_session->flag_mutex);
        rtp_session->flags[flag] = 1;
        switch_mutex_unlock(rtp_session->flag_mutex);

        if (flag == SWITCH_RTP_FLAG_DTMF_ON) {
                rtp_session->stats.inbound.last_processed_seq = 0;
        } else if (flag == SWITCH_RTP_FLAG_FLUSH) {
                reset_jitter_seq(rtp_session);
        } else if (flag == SWITCH_RTP_FLAG_AUTOADJ) {
                rtp_session->autoadj_window = 20;
                rtp_session->autoadj_threshold = 10;
                rtp_session->autoadj_tally = 0;
                if (rtp_session->session) {
                        switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
                        const char *x = switch_channel_get_variable(channel, "rtp_auto_adjust_threshold");
                        if (x && *x) {
                                int xn = atoi(x);
                                if (xn > 0 && xn <= 65535) {
                                        rtp_session->autoadj_window = xn*2;
                                        rtp_session->autoadj_threshold = xn;
                                }
                        }
                }


                rtp_flush_read_buffer(rtp_session, SWITCH_RTP_FLUSH_ONCE);


                if (rtp_session->jb) {
                        switch_jb_reset(rtp_session->jb);
                }
        } else if (flag == SWITCH_RTP_FLAG_NOBLOCK && rtp_session->sock_input) {
                switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, TRUE);
        }

}

void switch_rtp_set_flags	(	switch_rtp_t *	rtp_session,
		switch_rtp_flag_t	flags[SWITCH_RTP_FLAG_INVALID]
	)

Definition at line 4660 of file switch_rtp.c.

References rtp_flush_read_buffer(), switch_channel_get_variable, switch_core_session_get_channel(), SWITCH_RTP_FLAG_AUTOADJ, SWITCH_RTP_FLAG_INVALID, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLUSH_ONCE, SWITCH_SO_NONBLOCK, switch_socket_opt_set(), and TRUE.

Referenced by switch_core_media_receive_message(), and switch_rtp_create().

{
        int i;

        for(i = 0; i < SWITCH_RTP_FLAG_INVALID; i++) {
                if (flags[i]) {
                        rtp_session->flags[i] = flags[i];

                        if (i == SWITCH_RTP_FLAG_AUTOADJ) {
                                rtp_session->autoadj_window = 20;
                                rtp_session->autoadj_threshold = 10;
                                rtp_session->autoadj_tally = 0;
                                if (rtp_session->session) {
                                        switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
                                        const char *x = switch_channel_get_variable(channel, "rtp_auto_adjust_threshold");
                                        if (x && *x) {
                                                int xn = atoi(x);
                                                if (xn > 0 && xn <= 65535) {
                                                        rtp_session->autoadj_window = xn*2;
                                                        rtp_session->autoadj_threshold = xn;
                                                }
                                        }
                                }
                                rtp_flush_read_buffer(rtp_session, SWITCH_RTP_FLUSH_ONCE);
                        } else if (i == SWITCH_RTP_FLAG_NOBLOCK && rtp_session->sock_input) {
                                switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, TRUE);
                        }
                }
        }
}

void switch_rtp_set_interdigit_delay	(	switch_rtp_t *	rtp_session,
		uint32_t	delay
	)

Definition at line 4630 of file switch_rtp.c.

Referenced by switch_core_media_activate_rtp().

{
        rtp_session->interdigit_delay = delay;
}

switch_status_t switch_rtp_set_interval	(	switch_rtp_t *	rtp_session,
		uint32_t	ms_per_packet,
		uint32_t	samples_per_interval
	)

Definition at line 3674 of file switch_rtp.c.

References SWITCH_STATUS_SUCCESS.

Referenced by switch_rtp_change_interval(), and switch_rtp_create().

{
        rtp_session->ms_per_packet = ms_per_packet;
        rtp_session->samples_per_interval = rtp_session->conf_samples_per_interval = samples_per_interval;
        rtp_session->missed_count = 0;
        rtp_session->samples_per_second =
                (uint32_t) ((double) (1000.0f / (double) (rtp_session->ms_per_packet / 1000)) * (double) rtp_session->samples_per_interval);

        rtp_session->one_second = (rtp_session->samples_per_second / rtp_session->samples_per_interval);

        return SWITCH_STATUS_SUCCESS;
}

void switch_rtp_set_invalid_handler	(	switch_rtp_t *	rtp_session,
		switch_rtp_invalid_handler_t	on_invalid
	)

Set a callback function to execute when an invalid RTP packet is encountered.

Parameters

rtp_session	the RTP session
on_invalid	the function to set

Returns

Definition at line 4655 of file switch_rtp.c.

{
        rtp_session->invalid_handler = on_invalid;
}

switch_status_t switch_rtp_set_local_address	(	switch_rtp_t *	rtp_session,
		const char *	host,
		switch_port_t	port,
		const char **	err
	)

Assign a local address to the RTP session.

Parameters

rtp_session	an RTP session to assign the local address to
host	the ip or fqhn of the local address
port	the local port
change_adv_addr	change the advertised address for doing compare
err	pointer for error messages

Note

this call also binds the RTP session's socket to the new address

Definition at line 2585 of file switch_rtp.c.

References enable_local_rtcp_socket(), FALSE, READ_DEC, READ_INC, switch_channel_get_variable, switch_cond_next(), switch_core_session_get_channel(), switch_core_sprintf(), switch_core_strdup, switch_mcast_hops(), switch_mcast_interface(), switch_mcast_join(), SWITCH_POLLERR, SWITCH_POLLIN, SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_IO, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLAG_USE_TIMER, SWITCH_RTP_FLAG_VIDEO, switch_rtp_kill_socket(), switch_rtp_ready(), switch_rtp_set_flag(), SWITCH_SO_NONBLOCK, SWITCH_SO_RCVBUF, SWITCH_SO_REUSEADDR, SWITCH_SO_SNDBUF, switch_sockaddr_get_family(), switch_sockaddr_info_get(), switch_socket_bind(), switch_socket_close(), switch_socket_create(), switch_socket_create_pollset(), switch_socket_opt_set(), switch_socket_recvfrom(), switch_socket_sendto(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_UNSPEC, TRUE, WRITE_DEC, WRITE_INC, and zstr.

Referenced by switch_rtp_new().

{
        switch_socket_t *new_sock = NULL, *old_sock = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int j = 0;
#ifndef WIN32
        char o[5] = "TEST", i[5] = "";
        switch_size_t len, ilen = 0;
        int x;
#endif

        if (rtp_session->ready != 1) {
                if (!switch_rtp_ready(rtp_session)) {
                        return SWITCH_STATUS_FALSE;
                }

                WRITE_INC(rtp_session);
                READ_INC(rtp_session);

                if (!switch_rtp_ready(rtp_session)) {
                        goto done;
                }
        }


        *err = NULL;

        if (zstr(host) || !port) {
                *err = "Address Error";
                goto done;
        }


        rtp_session->local_host_str = switch_core_strdup(rtp_session->pool, host);
        rtp_session->local_port = port;


        if (switch_sockaddr_info_get(&rtp_session->local_addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
                *err = "Local Address Error!";
                goto done;
        }

        
        if (rtp_session->sock_input) {
                switch_rtp_kill_socket(rtp_session);
        }

        if (switch_socket_create(&new_sock, switch_sockaddr_get_family(rtp_session->local_addr), SOCK_DGRAM, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
                *err = "Socket Error!";
                goto done;
        }

        if (switch_socket_opt_set(new_sock, SWITCH_SO_REUSEADDR, 1) != SWITCH_STATUS_SUCCESS) {
                *err = "Socket Error!";
                goto done;
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                switch_socket_opt_set(new_sock, SWITCH_SO_RCVBUF, 1572864);
                switch_socket_opt_set(new_sock, SWITCH_SO_SNDBUF, 1572864);
        }

        if (switch_socket_bind(new_sock, rtp_session->local_addr) != SWITCH_STATUS_SUCCESS) {
                char *em = switch_core_sprintf(rtp_session->pool, "Bind Error! %s:%d", host, port);
                *err = em;
                goto done;
        }


        if ((j = atoi(host)) && j > 223 && j < 240) { /* mcast */
                if (switch_mcast_interface(new_sock, rtp_session->local_addr) != SWITCH_STATUS_SUCCESS) {
                        *err = "Multicast Socket interface Error";
                        goto done;
                }
                
                if (switch_mcast_join(new_sock, rtp_session->local_addr, NULL, NULL) != SWITCH_STATUS_SUCCESS) {
                        *err = "Multicast Error";
                        goto done;
                }

                if (rtp_session->session) {
                        switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
                        const char *var;

                        if ((var = switch_channel_get_variable(channel, "multicast_ttl"))) {
                                int ttl = atoi(var);

                                if (ttl > 0 && ttl < 256) {
                                        if (switch_mcast_hops(new_sock, (uint8_t) ttl) != SWITCH_STATUS_SUCCESS) {
                                                *err = "Mutlicast TTL set failed";
                                                goto done;
                                        }
                                        
                                }
                        }

                }

        }



#ifndef WIN32
        len = sizeof(i);
        switch_socket_opt_set(new_sock, SWITCH_SO_NONBLOCK, TRUE);

        switch_socket_sendto(new_sock, rtp_session->local_addr, 0, (void *) o, &len);

        x = 0;
        while (!ilen) {
                switch_status_t status;
                ilen = len;
                status = switch_socket_recvfrom(rtp_session->from_addr, new_sock, 0, (void *) i, &ilen);

                if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
                        break;
                }

                if (++x > 1000) {
                        break;
                }
                switch_cond_next();
        }
        switch_socket_opt_set(new_sock, SWITCH_SO_NONBLOCK, FALSE);

#endif

        old_sock = rtp_session->sock_input;
        rtp_session->sock_input = new_sock;
        new_sock = NULL;

        if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] || rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK] || rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, TRUE);
                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
        }

        switch_socket_create_pollset(&rtp_session->read_pollfd, rtp_session->sock_input, SWITCH_POLLIN | SWITCH_POLLERR, rtp_session->pool);

        if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                if ((status = enable_local_rtcp_socket(rtp_session, err)) == SWITCH_STATUS_SUCCESS) {
                        *err = "Success";
                }
        } else {
                status = SWITCH_STATUS_SUCCESS;
                *err = "Success";
        }
        
        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_IO);

 done:

        if (new_sock) {
                switch_socket_close(new_sock);
        }

        if (old_sock) {
                switch_socket_close(old_sock);
        }


        if (rtp_session->ready != 1) {
                WRITE_DEC(rtp_session);
                READ_DEC(rtp_session);
        }

        return status;
}

void switch_rtp_set_max_missed_packets	(	switch_rtp_t *	rtp_session,
		uint32_t	max
	)

Definition at line 2753 of file switch_rtp.c.

References SWITCH_CHANNEL_SESSION_LOG, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_RTP_FLAG_UDPTL, and switch_rtp_ready().

Referenced by switch_core_media_activate_rtp(), switch_core_media_negotiate_sdp(), switch_core_media_read_frame(), and switch_core_media_toggle_hold().

{
        if (!switch_rtp_ready(rtp_session) || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
                return;
        }

        if (rtp_session->missed_count >= max) {
                
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING,
                                                  "new max missed packets(%d->%d) greater than current missed packets(%d). RTP will timeout.\n",
                                                  rtp_session->missed_count, max, rtp_session->missed_count);
        }

        rtp_session->max_missed_packets = max;
}

switch_status_t switch_rtp_set_payload_map	(	switch_rtp_t *	rtp_session,
		payload_map_t **	pmap
	)

Definition at line 2454 of file switch_rtp.c.

References switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_activate_rtp().

{

        if (rtp_session) {
                switch_mutex_lock(rtp_session->flag_mutex);
                rtp_session->pmaps = pmap;
                switch_mutex_unlock(rtp_session->flag_mutex);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

void switch_rtp_set_private	(	switch_rtp_t *	rtp_session,
		void *	private_data
	)

Associate an arbitrary data pointer with and RTP session.

Parameters

rtp_session	the RTP session to assign the pointer to
private_data	the private data to assign

Definition at line 8094 of file switch_rtp.c.

{
        rtp_session->private_data = private_data;
}

switch_status_t switch_rtp_set_remote_address	(	switch_rtp_t *	rtp_session,
		const char *	host,
		switch_port_t	port,
		switch_port_t	remote_rtcp_port,
		switch_bool_t	change_adv_addr,
		const char **	err
	)

Assign a remote address to the RTP session.

Parameters

rtp_session	an RTP session to assign the remote address to
host	the ip or fqhn of the remote address
port	the remote port
err	pointer for error messages

Definition at line 2913 of file switch_rtp.c.

References enable_remote_rtcp_socket(), switch_core_strdup, switch_cp_addr(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_RTCP_MUX, switch_sockaddr_get_family(), switch_sockaddr_info_get(), switch_socket_close(), switch_socket_create(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_UNSPEC.

Referenced by handle_ice(), rtp_common_read(), switch_core_media_activate_rtp(), switch_core_media_negotiate_sdp(), switch_core_media_process_t38_passthru(), switch_core_media_proxy_remote_addr(), switch_core_media_start_udptl(), switch_rtp_change_ice_dest(), and switch_rtp_new().

{
        switch_sockaddr_t *remote_addr;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        *err = "Success";

        if (switch_sockaddr_info_get(&remote_addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !remote_addr) {
                *err = "Remote Address Error!";
                return SWITCH_STATUS_FALSE;
        }


        switch_mutex_lock(rtp_session->write_mutex);

        rtp_session->remote_addr = remote_addr;
        switch_cp_addr(rtp_session->rtp_from_addr, rtp_session->remote_addr);

        if (change_adv_addr) {
                rtp_session->remote_host_str = switch_core_strdup(rtp_session->pool, host);
                rtp_session->remote_port = port;
        }

        rtp_session->eff_remote_host_str = switch_core_strdup(rtp_session->pool, host);
        rtp_session->eff_remote_port = port;

        if (rtp_session->sock_input && switch_sockaddr_get_family(rtp_session->remote_addr) == switch_sockaddr_get_family(rtp_session->local_addr)) {
                rtp_session->sock_output = rtp_session->sock_input;
        } else {
                if (rtp_session->sock_output && rtp_session->sock_output != rtp_session->sock_input) {
                        switch_socket_close(rtp_session->sock_output);
                }
                if ((status = switch_socket_create(&rtp_session->sock_output,
                                                                                   switch_sockaddr_get_family(rtp_session->remote_addr),
                                                                                   SOCK_DGRAM, 0, rtp_session->pool)) != SWITCH_STATUS_SUCCESS) {

                        *err = "Socket Error!";
                }
        }

        if (rtp_session->dtls) {
                rtp_session->dtls->sock_output = rtp_session->sock_output;

                if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                        switch_sockaddr_info_get(&rtp_session->dtls->remote_addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool);
                }
        }


        if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {     
                        rtp_session->rtcp_remote_addr = rtp_session->remote_addr;
                        rtp_session->rtcp_sock_output = rtp_session->sock_output;
                } else {
                        if (remote_rtcp_port) {
                                rtp_session->remote_rtcp_port = remote_rtcp_port;
                        } else {
                                rtp_session->remote_rtcp_port = rtp_session->eff_remote_port + 1;
                        }
                        status = enable_remote_rtcp_socket(rtp_session, err);
                        
                        if (rtp_session->rtcp_dtls) {
                                //switch_sockaddr_info_get(&rtp_session->rtcp_dtls->remote_addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool);
                                rtp_session->rtcp_dtls->remote_addr = rtp_session->rtcp_remote_addr;
                                rtp_session->rtcp_dtls->sock_output = rtp_session->rtcp_sock_output;
                        }
                }
        }

        switch_mutex_unlock(rtp_session->write_mutex);

        return status;
}

switch_status_t switch_rtp_set_remote_ssrc	(	switch_rtp_t *	rtp_session,
		uint32_t	ssrc
	)

Definition at line 3733 of file switch_rtp.c.

References SWITCH_STATUS_SUCCESS.

Referenced by check_ice(), and switch_core_media_activate_rtp().

{
        rtp_session->remote_ssrc = ssrc;

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_rtp_set_ssrc	(	switch_rtp_t *	rtp_session,
		uint32_t	ssrc
	)

Definition at line 3725 of file switch_rtp.c.

References SWITCH_STATUS_SUCCESS.

Referenced by rtp_common_write(), and switch_core_media_activate_rtp().

{
        rtp_session->ssrc = ssrc;
        rtp_session->send_msg.header.ssrc = htonl(rtp_session->ssrc);

        return SWITCH_STATUS_SUCCESS;
}

switch_port_t switch_rtp_set_start_port

(

switch_port_t

port

)

Set/Get RTP start port.

Parameters

port	new value (if > 0)

Returns

the current RTP start port

Definition at line 2387 of file switch_rtp.c.

References port_lock, START_PORT, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_get_rtp_port_range_start_port(), and switch_load_core_config().

{
        if (port) {
                if (port_lock) {
                        switch_mutex_lock(port_lock);
                }
                START_PORT = port;
                if (port_lock) {
                        switch_mutex_unlock(port_lock);
                }
        }
        return START_PORT;
}

void switch_rtp_set_telephony_event	(	switch_rtp_t *	rtp_session,
		switch_payload_t	te
	)

Set the payload type to consider RFC2833 DTMF.

Parameters

rtp_session	the RTP session to modify
te	the payload type

Definition at line 4014 of file switch_rtp.c.

Referenced by switch_core_media_activate_rtp(), switch_core_media_negotiate_sdp(), switch_core_media_recover_session(), and switch_core_media_set_telephony_event().

{
        if (te > 95) {
                rtp_session->te = te;
        }
}

void switch_rtp_set_telephony_recv_event	(	switch_rtp_t *	rtp_session,
		switch_payload_t	te
	)

Definition at line 4022 of file switch_rtp.c.

Referenced by switch_core_media_activate_rtp(), switch_core_media_negotiate_sdp(), switch_core_media_recover_session(), and switch_core_media_set_telephony_recv_event().

{
        if (te > 95) {
                rtp_session->recv_te = te;
        }
}

switch_status_t switch_rtp_set_video_buffer_size	(	switch_rtp_t *	rtp_session,
		uint32_t	frames,
		uint32_t	max_frames
	)

Definition at line 4101 of file switch_rtp.c.

References SJB_VIDEO, SWITCH_CHANNEL_SESSION_LOG, switch_core_session_request_video_refresh(), switch_jb_create(), switch_jb_set_frames(), switch_jb_set_session(), SWITCH_LOG_DEBUG1, switch_log_printf(), switch_rtp_ready(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by check_jb(), and check_jb_sync().

{
        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!max_frames) {
                max_frames = 50;
        }

        if (!rtp_session->vb) {
                switch_jb_create(&rtp_session->vb, SJB_VIDEO, frames, max_frames, rtp_session->pool);
                switch_jb_set_session(rtp_session->vb, rtp_session->session);
        } else {
                switch_jb_set_frames(rtp_session->vb, frames, max_frames);
        }

        //switch_rtp_flush(rtp_session);
        switch_core_session_request_video_refresh(rtp_session->session);

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Setting video buffer %u Frames.\n", frames);
        
        return SWITCH_STATUS_SUCCESS;
}

void switch_rtp_shutdown

(

void

)

Definition at line 2348 of file switch_rtp.c.

References port_lock, SWITCH_CHANNEL_LOG, switch_core_hash_destroy(), switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_core_port_allocator_destroy(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_destroy().

{
        switch_core_port_allocator_t *alloc = NULL;
        switch_hash_index_t *hi;
        const void *var;
        void *val;

        if (!global_init) {
                return;
        }

        switch_mutex_lock(port_lock);

        for (hi = switch_core_hash_first(alloc_hash); hi; hi = switch_core_hash_next(&hi)) {
                switch_core_hash_this(hi, &var, NULL, &val);
                if ((alloc = (switch_core_port_allocator_t *) val)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Destroy port allocator for %s\n", (char *) var);
                        switch_core_port_allocator_destroy(&alloc);
                }
        }

        switch_core_hash_destroy(&alloc_hash);
        switch_mutex_unlock(port_lock);

#ifdef ENABLE_ZRTP
        if (zrtp_on) {
                zrtp_status_t status = zrtp_status_ok;

                status = zrtp_def_cache_store(zrtp_global);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Saving ZRTP cache: %s\n", zrtp_status_ok == status ? "OK" : "FAIL");
                zrtp_down(zrtp_global);
        }
#endif
#ifdef ENABLE_SRTP
        crypto_kernel_shutdown();
#endif

}

switch_status_t switch_rtp_sync_stats

(

switch_rtp_t *

rtp_session

)

Definition at line 4468 of file switch_rtp.c.

References do_mos(), switch_channel_set_variable_printf(), switch_core_session_get_channel(), switch_micro_time_now(), SWITCH_RTP_FLAG_VAD, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_TRUE.

Referenced by switch_core_media_sync_stats().

{
        if (!rtp_session) {
                return SWITCH_STATUS_FALSE;
        }
        
        if (rtp_session->flags[SWITCH_RTP_FLAG_VAD]) {
                switch_channel_t *channel = switch_core_session_get_channel(rtp_session->vad_data.session);

                switch_channel_set_variable_printf(channel, "vad_total_talk_time_ms", "%u", (uint32_t)rtp_session->vad_data.total_talk_time / 1000);
                switch_channel_set_variable_printf(channel, "vad_total_talk_time_sec", "%u", (uint32_t)rtp_session->vad_data.total_talk_time / 1000000);
        }

        do_mos(rtp_session, SWITCH_TRUE);

        if (rtp_session->stats.inbound.error_log && !rtp_session->stats.inbound.error_log->stop) {
                rtp_session->stats.inbound.error_log->stop = switch_micro_time_now();
        }

        return SWITCH_STATUS_SUCCESS;
}

uint32_t switch_rtp_test_flag	(	switch_rtp_t *	rtp_session,
		switch_rtp_flag_t	flags
	)

Test an RTP Flag.

Parameters

rtp_session	the RTP session
flags	the flags to test

Returns

TRUE or FALSE

Definition at line 4742 of file switch_rtp.c.

Referenced by check_rtcp_and_ice(), get_next_write_ts(), rtp_common_read(), rtp_common_write(), switch_core_media_check_udptl_mode(), switch_core_media_receive_message(), and switch_rtp_udptl_mode().

{
        return (uint32_t) rtp_session->flags[flags];
}

switch_status_t switch_rtp_udptl_mode

(

switch_rtp_t *

rtp_session

)

Definition at line 2843 of file switch_rtp.c.

References FALSE, memset(), ping_socket(), READ_DEC, READ_INC, switch_core_timer_destroy(), switch_rtp_break(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_FLUSH, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_RTCP_MUX, SWITCH_RTP_FLAG_STICKY_FLUSH, SWITCH_RTP_FLAG_UDPTL, SWITCH_RTP_FLAG_USE_TIMER, switch_rtp_ready(), switch_rtp_set_flag(), switch_rtp_test_flag(), SWITCH_SHUTDOWN_READWRITE, SWITCH_SO_NONBLOCK, switch_socket_close(), switch_socket_opt_set(), switch_socket_shutdown(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, WRITE_DEC, and WRITE_INC.

Referenced by switch_core_media_activate_rtp(), switch_core_media_start_udptl(), and switch_core_media_udptl_mode().

{
        switch_socket_t *sock;

        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA)) {
                ping_socket(rtp_session);
        }

        READ_INC(rtp_session);
        WRITE_INC(rtp_session);

        if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] || rtp_session->timer.timer_interface) {
                switch_core_timer_destroy(&rtp_session->timer);
                memset(&rtp_session->timer, 0, sizeof(rtp_session->timer));
                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
        }

        rtp_session->missed_count = 0;
        rtp_session->max_missed_packets = 0;

        rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] = 0;

        if (rtp_session->rtcp_sock_input) {
                ping_socket(rtp_session);
                switch_socket_shutdown(rtp_session->rtcp_sock_input, SWITCH_SHUTDOWN_READWRITE);
        }

        if (rtp_session->rtcp_sock_output && rtp_session->rtcp_sock_output != rtp_session->rtcp_sock_input) {
                switch_socket_shutdown(rtp_session->rtcp_sock_output, SWITCH_SHUTDOWN_READWRITE);
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                rtp_session->rtcp_sock_input = NULL;
                rtp_session->rtcp_sock_output = NULL;
        } else {
                if ((sock = rtp_session->rtcp_sock_input)) {
                        rtp_session->rtcp_sock_input = NULL;
                        switch_socket_close(sock);
                        
                        if (rtp_session->rtcp_sock_output && rtp_session->rtcp_sock_output != sock) {
                                if ((sock = rtp_session->rtcp_sock_output)) {
                                        rtp_session->rtcp_sock_output = NULL;
                                        switch_socket_close(sock);
                                }
                        }
                }
        }

        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_UDPTL);
        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA);
        switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, FALSE);
        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
                
        WRITE_DEC(rtp_session);
        READ_DEC(rtp_session);

        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH);
        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);

        switch_rtp_break(rtp_session);
        
        return SWITCH_STATUS_SUCCESS;

}

void switch_rtp_video_loss

(

switch_rtp_t *

rtp_session

)

Definition at line 4374 of file switch_rtp.c.

References rtp_write_ready(), SWITCH_RTP_FLAG_PLI, and SWITCH_RTP_FLAG_VIDEO.

Referenced by switch_core_media_receive_message().

{
        if (!rtp_write_ready(rtp_session, 0, __LINE__)) {
                return;
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && (rtp_session->ice.ice_user || rtp_session->flags[SWITCH_RTP_FLAG_PLI])) {
                rtp_session->pli_count = 1;
        }
}

void switch_rtp_video_refresh

(

switch_rtp_t *

rtp_session

)

Definition at line 4362 of file switch_rtp.c.

References rtp_write_ready(), SWITCH_RTP_FLAG_FIR, and SWITCH_RTP_FLAG_VIDEO.

Referenced by read_rtp_packet(), switch_core_media_receive_message(), and switch_rtp_break().

{

        if (!rtp_write_ready(rtp_session, 0, __LINE__)) {
                return;
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && (rtp_session->ice.ice_user || rtp_session->flags[SWITCH_RTP_FLAG_FIR])) {
                rtp_session->fir_count = 1;
        }
}

int switch_rtp_write_frame	(	switch_rtp_t *	rtp_session,
		switch_frame_t *	frame
	)

Write data to a given RTP session.

Parameters

rtp_session	the RTP session to write to
frame	the frame to write

Returns

the number of bytes written

Definition at line 7726 of file switch_rtp.c.

References payload_map_s::current, payload_map_s::hash, rtp_msg_t::header, INVALID_PT, payload_map_s::negotiated, payload_map_s::next, payload_map_s::pt, payload_map_s::recv_pt, RTP_BUG_GEN_ONE_GEN_ALL, rtp_common_write(), rtp_write_ready(), SFF_CNG, SFF_PROXY_PACKET, SFF_RAW_RTP, SFF_RAW_RTP_PARSE_FRAME, SFF_RTP_HEADER, SFF_UDPTL_PACKET, switch_assert, switch_channel_get_partner_uuid(), switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_RAW_WRITE, SWITCH_RTP_FLAG_RESET, SWITCH_RTP_FLAG_UDPTL, SWITCH_RTP_FLAG_VIDEO, switch_rtp_ready(), switch_rtp_write_manual(), switch_socket_sendto(), SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV, and SWITCH_ZRTP_FLAG_SECURE_MITM_SEND.

Referenced by switch_core_media_write_frame().

{
        uint8_t fwd = 0;
        void *data = NULL;
        uint32_t len, ts = 0;
        switch_payload_t payload = 0;
        rtp_msg_t *send_msg = NULL;
        srtp_hdr_t local_header;
        int r = 0;

        if (!switch_rtp_ready(rtp_session) || !rtp_session->remote_addr) {
                return -1;
        }

        if (!rtp_write_ready(rtp_session, frame->datalen, __LINE__)) {
                return 0;
        }
        
        //if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
        //      rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_READ]++;
        //      rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]++;
        //}


        if (switch_test_flag(frame, SFF_PROXY_PACKET) || switch_test_flag(frame, SFF_UDPTL_PACKET) ||
                rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
                
                //if (rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
                switch_size_t bytes;
                //char bufa[50];

                /* Fast PASS! */
                if (!switch_test_flag(frame, SFF_PROXY_PACKET) && !switch_test_flag(frame, SFF_UDPTL_PACKET)) {
                        return 0;
                }
                bytes = frame->packetlen;
                //tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->remote_addr);

                send_msg = frame->packet;

                if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] && !switch_test_flag(frame, SFF_UDPTL_PACKET)) {

                        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->payload > 0) {
                                send_msg->header.pt = rtp_session->payload;
                        }
                
                        send_msg->header.ssrc = htonl(rtp_session->ssrc);
                        send_msg->header.seq = htons(++rtp_session->seq);
                }

                if (switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, frame->packet, &bytes) != SWITCH_STATUS_SUCCESS) {
                        return -1;
                }


                rtp_session->stats.outbound.raw_bytes += bytes;
                rtp_session->stats.outbound.media_bytes += bytes;
                rtp_session->stats.outbound.media_packet_count++;
                rtp_session->stats.outbound.packet_count++;
                return (int) bytes;
        }
#ifdef ENABLE_ZRTP
        if (zrtp_on && rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND]) {
                zrtp_session_info_t zrtp_session_info;

                if (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info)) {
                        if (zrtp_session_info.sas_is_ready) {
                                
                                switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);

                                const char *uuid = switch_channel_get_partner_uuid(channel);
                                if (uuid) {
                                        switch_core_session_t *other_session;

                                        if ((other_session = switch_core_session_locate(uuid))) {
                                                switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
                                                switch_rtp_t *other_rtp_session = switch_channel_get_private(other_channel, "__zrtp_audio_rtp_session");


                                                if (other_rtp_session) {
                                                        if (zrtp_status_ok == zrtp_session_get(other_rtp_session->zrtp_session, &zrtp_session_info)) {
                                                                if (rtp_session->zrtp_mitm_tries > ZRTP_MITM_TRIES) {
                                                                        rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
                                                                        rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
                                                                        switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
                                                                        switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
                                                                } else if (zrtp_status_ok == zrtp_resolve_mitm_call(other_rtp_session->zrtp_stream, rtp_session->zrtp_stream)) {
                                                                        rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
                                                                        rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
                                                                        switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
                                                                        switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
                                                                        rtp_session->zrtp_mitm_tries++;
                                                                }
                                                                rtp_session->zrtp_mitm_tries++;
                                                        }
                                                }

                                                switch_core_session_rwunlock(other_session);
                                        }
                                }
                        }
                }
        }
#endif

        fwd = (rtp_session->flags[SWITCH_RTP_FLAG_RAW_WRITE] && 
                   (switch_test_flag(frame, SFF_RAW_RTP) || switch_test_flag(frame, SFF_RAW_RTP_PARSE_FRAME))) ? 1 : 0;

        if (!fwd && !rtp_session->sending_dtmf && !rtp_session->queue_delay && 
                rtp_session->flags[SWITCH_RTP_FLAG_RAW_WRITE] && (rtp_session->rtp_bugs & RTP_BUG_GEN_ONE_GEN_ALL)) {
                
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "Generating RTP locally but timestamp passthru is configured, disabling....\n");
                rtp_session->flags[SWITCH_RTP_FLAG_RAW_WRITE] = 0;
                rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 1;
        }

        switch_assert(frame != NULL);

        if (switch_test_flag(frame, SFF_CNG)) {
                if (rtp_session->cng_pt != INVALID_PT) {
                        payload = rtp_session->cng_pt;
                } else {
                        return (int) frame->packetlen;
                }
        } else {
                payload = rtp_session->payload;
#if 0
                if (rtp_session->pmaps && *rtp_session->pmaps) {
                        payload_map_t *pmap;
                        for (pmap = *rtp_session->pmaps; pmap; pmap = pmap->next) {
                                if (pmap->current) {
                                        payload = pmap->pt;
                                }
                        }
                }
#endif
        }

        if (switch_test_flag(frame, SFF_RTP_HEADER)) {
                switch_size_t wrote = switch_rtp_write_manual(rtp_session, frame->data, frame->datalen,
                                                                                                          frame->m, frame->payload, (uint32_t) (frame->timestamp), &frame->flags);
                
                rtp_session->stats.outbound.raw_bytes += wrote;
                rtp_session->stats.outbound.media_bytes += wrote;
                rtp_session->stats.outbound.media_packet_count++;
                rtp_session->stats.outbound.packet_count++;
        }

        if (frame->pmap && rtp_session->pmaps && *rtp_session->pmaps) {
                payload_map_t *pmap;

                switch_mutex_lock(rtp_session->flag_mutex);
                for (pmap = *rtp_session->pmaps; pmap; pmap = pmap->next) {
                        if (pmap->negotiated && pmap->hash == frame->pmap->hash) {
                                payload = pmap->recv_pt;
                                break;
                        }
                }
                switch_mutex_unlock(rtp_session->flag_mutex);
        }

        if (fwd) {
                send_msg = frame->packet;
                local_header = send_msg->header;
                len = frame->packetlen;
                ts = 0;

                send_msg->header.pt = payload;

                if (switch_test_flag(frame, SFF_RAW_RTP_PARSE_FRAME)) {
                        send_msg->header.version = 2;
                        send_msg->header.m = frame->m;
                        send_msg->header.ts = htonl(frame->timestamp);
                        if (frame->ssrc) {
                                send_msg->header.ssrc = htonl(frame->ssrc);
                        } else {
                                send_msg->header.ssrc = htonl(rtp_session->ssrc);
                        }
                }

        } else {
                data = frame->data;
                len = frame->datalen;
                ts = rtp_session->flags[SWITCH_RTP_FLAG_RAW_WRITE] ? (uint32_t) frame->timestamp : 0;
        }

        /*
          if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
          send_msg->header.pt = rtp_session->payload;
          }
        */

        r = rtp_common_write(rtp_session, send_msg, data, len, payload, ts, &frame->flags);

        if (send_msg) {
                send_msg->header = local_header;
        }

        return r;

}

int switch_rtp_write_manual	(	switch_rtp_t *	rtp_session,
		void *	data,
		uint32_t	datalen,
		uint8_t	m,
		switch_payload_t	payload,
		uint32_t	ts,
		switch_frame_flag_t *	flags
	)

Write data with a specified payload and sequence number to a given RTP session.

Parameters

rtp_session	the RTP session to write to
data	data to write
datalen	the size of the data
m	set mark bit or not
payload	the IANA payload number
ts	then number of bytes to increment the timestamp by
flags	frame flags

Returns

the number of bytes written

Definition at line 7955 of file switch_rtp.c.

References INVALID_PT, rtp_header_len, rtp_write_ready(), SFF_RTP_HEADER, SWITCH_RTP_FLAG_RESET, SWITCH_RTP_MAX_BUF_LEN, switch_rtp_ready(), switch_rtp_write_raw(), SWITCH_STATUS_SUCCESS, SWITCH_TRUE, WRITE_DEC, and WRITE_INC.

Referenced by check_rtcp_and_ice(), do_2833(), and switch_rtp_write_frame().

{
        switch_size_t bytes;
        int ret = -1;

        if (!switch_rtp_ready(rtp_session) || !rtp_session->remote_addr || datalen > SWITCH_RTP_MAX_BUF_LEN) {
                return -1;
        }

        if (!rtp_write_ready(rtp_session, datalen, __LINE__)) {
                return 0;
        }

        if (payload == INVALID_PT) {
                return 0;
        }

        WRITE_INC(rtp_session);

        rtp_session->write_msg = rtp_session->send_msg;
        rtp_session->write_msg.header.seq = htons(++rtp_session->seq);
        rtp_session->write_msg.header.ts = htonl(ts);
        rtp_session->write_msg.header.pt = payload;
        rtp_session->write_msg.header.m = m;
        memcpy(rtp_session->write_msg.body, data, datalen);

        bytes = rtp_header_len + datalen;

        if (switch_rtp_write_raw(rtp_session, (void *) &rtp_session->write_msg, &bytes, SWITCH_TRUE) != SWITCH_STATUS_SUCCESS) {
                rtp_session->seq--;
                ret = -1;
                goto end;
        }

        if (((*flags) & SFF_RTP_HEADER)) {
                rtp_session->last_write_ts = ts;
                rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 0;
        }

        ret = (int) bytes;

 end:

        WRITE_DEC(rtp_session);

        return ret;
}

switch_status_t switch_rtp_write_raw	(	switch_rtp_t *	rtp_session,
		void *	data,
		switch_size_t *	bytes,
		switch_bool_t	process_encryption
	)

Definition at line 8006 of file switch_rtp.c.

References rtp_write_ready(), switch_assert, SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_SESSION_LOG, SWITCH_FALSE, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_RTP_FLAG_SECURE_SEND_RESET, SWITCH_RTP_MAX_BUF_LEN, switch_rtp_ready(), switch_socket_sendto(), SWITCH_STATUS_FALSE, SWITCH_STATUS_NOT_INITALIZED, SWITCH_STATUS_SUCCESS, WRITE_DEC, and WRITE_INC.

Referenced by handle_nack(), and switch_rtp_write_manual().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        
        switch_assert(bytes);

        if (!switch_rtp_ready(rtp_session) || !rtp_session->remote_addr || *bytes > SWITCH_RTP_MAX_BUF_LEN) {
                return status;
        }

        if (!rtp_write_ready(rtp_session, *bytes, __LINE__)) {
                return SWITCH_STATUS_NOT_INITALIZED;
        }

        WRITE_INC(rtp_session);

        if (process_encryption) {
                process_encryption = SWITCH_FALSE;
#ifdef ENABLE_SRTP
                if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {
                
                        int sbytes = (int) *bytes;
                        err_status_t stat;

                        if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_RESET]) {
                                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND_RESET);
                                srtp_dealloc(rtp_session->send_ctx[rtp_session->srtp_idx_rtp]);
                                rtp_session->send_ctx[rtp_session->srtp_idx_rtp] = NULL;
                                if ((stat = srtp_create(&rtp_session->send_ctx[rtp_session->srtp_idx_rtp], 
                                                                                &rtp_session->send_policy[rtp_session->srtp_idx_rtp])) || !rtp_session->send_ctx[rtp_session->srtp_idx_rtp]) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error! RE-Activating Secure RTP SEND\n");
                                        rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 0;
                                        status = SWITCH_STATUS_FALSE;
                                        goto end;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "RE-Activating Secure RTP SEND\n");
                                }
                        }

                        stat = srtp_protect(rtp_session->send_ctx[rtp_session->srtp_idx_rtp], &rtp_session->write_msg.header, &sbytes);
                        if (stat) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error: SRTP protection failed with code %d\n", stat);
                        }
                        *bytes = sbytes;
                }
#endif
#ifdef ENABLE_ZRTP
                /* ZRTP Send */
                if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
                        unsigned int sbytes = (int) *bytes;
                        zrtp_status_t stat = zrtp_status_fail;

                        stat = zrtp_process_rtp(rtp_session->zrtp_stream, (void *) &rtp_session->write_msg, &sbytes);

                        switch (stat) {
                        case zrtp_status_ok:
                                break;
                        case zrtp_status_drop:
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
                                status = SWITCH_STATUS_SUCCESS;
                                goto end;
                                break;
                        case zrtp_status_fail:
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
                                break;
                        default:
                                break;
                        }

                        *bytes = sbytes;
                }
#endif
        }

        status = switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, data, bytes);

 end:

        WRITE_DEC(rtp_session);

        return status;
}

switch_status_t switch_rtp_zerocopy_read	(	switch_rtp_t *	rtp_session,
		void **	data,
		uint32_t *	datalen,
		switch_payload_t *	payload_type,
		switch_frame_flag_t *	flags,
		switch_io_flag_t	io_flags
	)

Read data from a given RTP session without copying.

Parameters

rtp_session	the RTP session to read from
data	a pointer to point directly to the RTP read buffer
datalen	a pointer to the datalen
payload_type	the IANA payload of the packet
flags	flags
io_flags	i/o flags

Returns

the number of bytes read

Definition at line 7135 of file switch_rtp.c.

References RTP_BODY, rtp_common_read(), rtp_header_len, switch_rtp_ready(), SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

{
        int bytes = 0;

        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        bytes = rtp_common_read(rtp_session, payload_type, NULL, flags, io_flags);
        *data = RTP_BODY(rtp_session);

        if (bytes < 0) {
                *datalen = 0;
                return SWITCH_STATUS_GENERR;
        } else {
                if (bytes > rtp_header_len) {
                        bytes -= rtp_header_len;
                }
        }

        *datalen = bytes;
        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_rtp_zerocopy_read_frame	(	switch_rtp_t *	rtp_session,
		switch_frame_t *	frame,
		switch_io_flag_t	io_flags
	)

Read data from a given RTP session without copying.

Parameters

rtp_session	the RTP session to read from
frame	a frame to populate with information
io_flags	i/o flags

Returns

the number of bytes read

Definition at line 7036 of file switch_rtp.c.

References switch_rtp::read_mutex, RTP_BODY, rtp_common_read(), rtp_header_len, SFF_CNG, SFF_RAW_RTP, SFF_RFC2833, SWITCH_CALL_DIRECTION_INBOUND, switch_channel_direction(), switch_channel_get_partner_uuid(), switch_channel_get_private(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), SWITCH_FALSE, switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_UDPTL, switch_rtp_ready(), switch_set_flag, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, switch_test_flag, SWITCH_TRUE, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV, and SWITCH_ZRTP_FLAG_SECURE_MITM_SEND.

Referenced by check_engine(), and switch_core_media_read_frame().

{
        int bytes = 0;

        if (!switch_rtp_ready(rtp_session)) {
                return SWITCH_STATUS_FALSE;
        }

        bytes = rtp_common_read(rtp_session, &frame->payload, &frame->pmap, &frame->flags, io_flags);

        frame->data = RTP_BODY(rtp_session);

        if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] && (bytes < rtp_header_len || switch_test_flag(frame, SFF_CNG))) {
                frame->packet = NULL;
                frame->timestamp = 0;
                frame->seq = 0;
                frame->ssrc = 0;
                frame->m = 0;
        } else {

                frame->packet = &rtp_session->recv_msg;
                frame->packetlen = bytes;
                frame->source = __FILE__;

                switch_set_flag(frame, SFF_RAW_RTP);
                if (frame->payload == rtp_session->recv_te) {
                        switch_set_flag(frame, SFF_RFC2833);
                }
                frame->timestamp = ntohl(rtp_session->last_rtp_hdr.ts);
                frame->seq = (uint16_t) ntohs((uint16_t) rtp_session->last_rtp_hdr.seq);
                frame->ssrc = ntohl(rtp_session->last_rtp_hdr.ssrc);
                frame->m = rtp_session->last_rtp_hdr.m ? SWITCH_TRUE : SWITCH_FALSE;
        }
        
#ifdef ENABLE_ZRTP
        if (zrtp_on && rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV]) {
                zrtp_session_info_t zrtp_session_info;

                if (rtp_session->zrtp_session && (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info))) {
                        if (zrtp_session_info.sas_is_ready) {
                                
                                switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);

                                const char *uuid = switch_channel_get_partner_uuid(channel);
                                if (uuid) {
                                        switch_core_session_t *other_session;

                                        if ((other_session = switch_core_session_locate(uuid))) {
                                                switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
                                                switch_rtp_t *other_rtp_session = switch_channel_get_private(other_channel, "__zrtp_audio_rtp_session");

                                                if (other_rtp_session) {
                                                        if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                                                                switch_mutex_lock(other_rtp_session->read_mutex);
                                                                if (zrtp_status_ok == zrtp_session_get(other_rtp_session->zrtp_session, &zrtp_session_info)) {
                                                                        if (rtp_session->zrtp_mitm_tries > ZRTP_MITM_TRIES) {
                                                                                switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
                                                                                switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
                                                                                rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
                                                                                rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
                                                                        } else if (zrtp_status_ok == zrtp_resolve_mitm_call(other_rtp_session->zrtp_stream, rtp_session->zrtp_stream)) {
                                                                                rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
                                                                                rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
                                                                                switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
                                                                                switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
                                                                                rtp_session->zrtp_mitm_tries++;
                                                                        }
                                                                }
                                                                switch_mutex_unlock(other_rtp_session->read_mutex);
                                                        }
                                                }

                                                switch_core_session_rwunlock(other_session);
                                        }
                                }
                        }
                } else {
                        rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
                        rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
                }
        }
#endif

        if (bytes < 0) {
                frame->datalen = 0;
                return bytes == -2 ? SWITCH_STATUS_TIMEOUT : SWITCH_STATUS_GENERR;
        } else if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
                if (bytes < rtp_header_len) {
                        frame->datalen = 0;
                        return SWITCH_STATUS_BREAK;
                } else {
                        bytes -= rtp_header_len;
                }
        }

        frame->datalen = bytes;
        return SWITCH_STATUS_SUCCESS;
}