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[SWITCH_RTP_FLAG_INVALID], 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[SWITCH_RTP_FLAG_INVALID], char *timer_name, const char **err, switch_memory_pool_t *pool, switch_port_t bundle_internal_ports, switch_port_t bundle_external_port)
	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)
void	switch_rtp_set_media_timeout (switch_rtp_t *rtp_session, uint32_t ms)
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, uint8_t want_DTLSv1_2)
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)
switch_core_session_t *	switch_rtp_get_core_session (switch_rtp_t *rtp_session)

Detailed Description

Typedef Documentation

switch_rtp_invalid_handler_t

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 185 of file switch_rtp.h.

Function Documentation

rtp_flush_read_buffer()

void rtp_flush_read_buffer	(	switch_rtp_t *	rtp_session,
		switch_rtp_flush_t	flush
	)

Definition at line 5638 of file switch_rtp.c.

References switch_rtp::flags, 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(), and switch_rtp_set_flag().

{

        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_rtcp_zerocopy_read_frame()

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 8175 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::rtcp_frame, switch_rtp::rtcp_fresh_frame, 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_rtp_ack_bitrate()

switch_status_t switch_rtp_ack_bitrate	(	switch_rtp_t *	rtp_session,
		uint32_t	bps
	)

Definition at line 5048 of file switch_rtp.c.

References rtp_write_ready(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_rtp::tmmbn.

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_rtp_activate_ice()

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 4933 of file switch_rtp.c.

References switch_rtp_ice_t::addr, switch_rtp_ice_t::cand_responsive, ice_s::cands, ice_s::chosen, icand_s::con_addr, icand_s::con_port, switch_rtp::flags, switch_rtp::ice, switch_rtp::ice_mutex, switch_rtp_ice_t::ice_params, switch_rtp_ice_t::ice_user, ICE_VANILLA, switch_rtp_ice_t::initializing, IPR_RTP, switch_rtp_ice_t::luser_ice, switch_rtp_ice_t::next_run, switch_rtp_ice_t::pass, switch_rtp::pool, switch_rtp_ice_t::proto, switch_rtp_ice_t::ready, switch_rtp::remote_addr, switch_rtp_ice_t::rpass, switch_rtp_ice_t::rready, switch_rtp::rtcp_ice, switch_rtp::rtcp_remote_addr, RTP_BUG_ACCEPT_ANY_PACKETS, switch_rtp::rtp_bugs, rtp_type, SDP_UFRAG_MAX_SIZE, switch_rtp::session, STUN_USERNAME_MAX_SIZE, 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[STUN_USERNAME_MAX_SIZE];
        char user_ice[STUN_USERNAME_MAX_SIZE];
        char luser_ice[SDP_UFRAG_MAX_SIZE];
        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(luser_ice), "%s%s", rlogin, login);
                ice->ready = ice->rready = 0;
                ice->cand_responsive = 0;
        } else {
                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(luser_ice), "");
                ice->ready = ice->rready = 1;
                ice->cand_responsive = 0;
        }

        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();
        ice->initializing = 1;

        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_mutex_unlock(rtp_session->ice_mutex);
                        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_rtp_activate_jitter_buffer()

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 4837 of file switch_rtp.c.

References switch_rtcp_numbers_t::inter_jitter, switch_rtp::jb, switch_rtp::pool, READ_DEC, READ_INC, switch_rtp_stats_t::rtcp, switch_rtp::session, SJB_AUDIO, switch_rtp::stats, switch_channel_get_variable_dup(), switch_core_session_get_channel(), SWITCH_FALSE, switch_jb_create(), switch_jb_set_frames(), switch_jb_set_jitter_estimator(), 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);
                switch_jb_set_jitter_estimator(rtp_session->jb, &rtp_session->stats.rtcp.inter_jitter, samples_per_packet, samples_per_second);
                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_rtp_activate_rtcp()

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 4878 of file switch_rtp.c.

References switch_rtp::eff_remote_host_str, enable_local_rtcp_socket(), enable_remote_rtcp_socket(), switch_rtp::flags, switch_rtp::from_addr, switch_rtp::local_addr, switch_rtp::ms_per_packet, switch_rtp::pool, switch_rtp::recv_msg, switch_rtp::remote_port, switch_rtp::remote_rtcp_port, switch_rtp::rtcp_from_addr, switch_rtp::rtcp_interval, switch_rtp::rtcp_local_addr, switch_rtp::rtcp_recv_msg, switch_rtp::rtcp_recv_msg_p, switch_rtp::rtcp_remote_addr, switch_rtp::rtcp_sock_input, switch_rtp::rtcp_sock_output, switch_rtp::session, switch_rtp::sock_input, switch_rtp::sock_output, 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_rtp_add_dtls()

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,
		uint8_t	want_DTLSv1_2
	)

Definition at line 3816 of file switch_rtp.c.

References BIO_dtls_filter(), switch_dtls_s::ca, switch_directories::certs_dir, DS_HANDSHAKE, switch_rtp::dtls, dtls_set_state, DTLS_SRTP_FNAME, DTLS_TYPE_CLIENT, DTLS_TYPE_RTCP, DTLS_TYPE_RTP, DTLS_TYPE_SERVER, switch_dtls_s::filter_bio, switch_rtp::flags, switch_rtp::ice_mutex, switch_dtls_s::local_fp, MAX_DTLS_MTU, switch_dtls_s::mtu, switch_dtls_s::pem, switch_rtp::pool, switch_dtls_s::pvt, switch_dtls_s::read_bio, switch_dtls_s::remote_addr, switch_rtp::remote_addr, switch_dtls_s::remote_fp, switch_dtls_s::rsa, switch_rtp::rtcp_dtls, switch_rtp::rtcp_remote_addr, switch_rtp::rtcp_sock_output, switch_dtls_s::rtp_session, rtp_type, switch_rtp::session, switch_dtls_s::sock_output, switch_rtp::sock_output, switch_dtls_s::ssl, ssl_ctx, switch_dtls_s::ssl_ctx, ssl_method, dtls_fp_s::str, switch_assert, SWITCH_CAUSE_NORMAL_TEMPORARY_FAILURE, switch_channel_get_variable, switch_channel_hangup, SWITCH_CHANNEL_SESSION_LOG, switch_core_alloc, switch_core_cert_expand_fingerprint(), switch_core_session_get_channel(), switch_core_sprintf(), switch_file_exists(), SWITCH_GLOBAL_dirs, switch_goto_status, SWITCH_LOG_CRIT, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), 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;
        const char *var;
        int ret;
        const char *kind = "";
        unsigned long ssl_method_error = 0;
        unsigned long ssl_ctx_error = 0;
        const SSL_METHOD *ssl_method;
        SSL_CTX *ssl_ctx;
#if OPENSSL_VERSION_NUMBER < 0x30000000
        BIO *bio;
        DH *dh;
#endif
        switch_status_t status = SWITCH_STATUS_SUCCESS;
#ifndef OPENSSL_NO_EC
#if OPENSSL_VERSION_NUMBER < 0x10002000L
        EC_KEY* ecdh;
#endif
#endif

#ifndef HAVE_OPENSSL_DTLS_SRTP
        return SWITCH_STATUS_FALSE;
#endif

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

        switch_mutex_lock(rtp_session->ice_mutex);

        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");
                switch_goto_status(SWITCH_STATUS_FALSE, done);
        }

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

#if OPENSSL_VERSION_NUMBER >= 0x10100000
        ssl_method = (type & DTLS_TYPE_SERVER) ? DTLS_server_method() : DTLS_client_method();
#else
    #ifdef HAVE_OPENSSL_DTLSv1_2_method
                ssl_method = (type & DTLS_TYPE_SERVER) ? (want_DTLSv1_2 ? DTLSv1_2_server_method() : DTLSv1_server_method()) : (want_DTLSv1_2 ? DTLSv1_2_client_method() : DTLSv1_client_method());
        #else
                ssl_method = (type & DTLS_TYPE_SERVER) ? DTLSv1_server_method() : DTLSv1_client_method();
    #endif // HAVE_OPENSSL_DTLSv1_2_method
#endif

        if (!ssl_method) {
                ssl_method_error = ERR_peek_error();
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s ssl_method is NULL [%lu]\n", rtp_type(rtp_session), ssl_method_error);
        }

        dtls->ssl_ctx = ssl_ctx = SSL_CTX_new(ssl_method);

        if (!ssl_ctx) {
                ssl_ctx_error = ERR_peek_error();
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s SSL_CTX_new failed [%lu]\n", rtp_type(rtp_session), ssl_ctx_error);
                switch_channel_hangup(switch_core_session_get_channel(rtp_session->session), SWITCH_CAUSE_NORMAL_TEMPORARY_FAILURE);
                switch_goto_status(SWITCH_STATUS_FALSE, done);
        }

        switch_assert(dtls->ssl_ctx);

#if OPENSSL_VERSION_NUMBER < 0x30000000
        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);
        }
#else
        if(!SSL_CTX_set_dh_auto(dtls->ssl_ctx, 1)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Failed enable auto DH!\n");
        }
#endif
        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, "ECDH:!RC4:!SSLv3:RSA_WITH_AES_128_CBC_SHA");
        //SSL_CTX_set_cipher_list(dtls->ssl_ctx, "ECDHE-RSA-AES256-GCM-SHA384");
        SSL_CTX_set_cipher_list(dtls->ssl_ctx, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
        //SSL_CTX_set_cipher_list(dtls->ssl_ctx, "SUITEB128");
        SSL_CTX_set_read_ahead(dtls->ssl_ctx, 1);
#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));
                switch_goto_status(SWITCH_STATUS_FALSE, done);
        }

        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));
                switch_goto_status(SWITCH_STATUS_FALSE, done);
        }

        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));
                switch_goto_status(SWITCH_STATUS_FALSE, done);
        }

        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));
                switch_goto_status(SWITCH_STATUS_FALSE, done);
        }

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

#if OPENSSL_VERSION_NUMBER < 0x10100000L
        dtls->filter_bio = BIO_new(BIO_dtls_filter());
#else
        switch_assert(dtls_bio_filter_methods);
        dtls->filter_bio = BIO_new(dtls_bio_filter_methods);
#endif

        switch_assert(dtls->filter_bio);

        BIO_push(dtls->filter_bio, dtls->write_bio);

        SSL_set_bio(dtls->ssl, dtls->read_bio, dtls->filter_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
#if OPENSSL_VERSION_NUMBER < 0x10002000L
        ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
        if (!ecdh) {
                switch_goto_status(SWITCH_STATUS_FALSE, done);
        }
        SSL_set_options(dtls->ssl, SSL_OP_SINGLE_ECDH_USE);
        SSL_set_tmp_ecdh(dtls->ssl, ecdh);
        EC_KEY_free(ecdh);
#elif OPENSSL_VERSION_NUMBER < 0x10100000L
        SSL_set_ecdh_auto(dtls->ssl, 1);
        SSL_set_options(dtls->ssl, SSL_OP_SINGLE_ECDH_USE);
#endif
#endif

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

        dtls->local_fp = local_fp;
        dtls->remote_fp = remote_fp;
        dtls->rtp_session = rtp_session;
        dtls->mtu = 1200;

        if (rtp_session->session) {
                switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
                if ((var = switch_channel_get_variable(channel, "rtp_dtls_mtu"))) {
                        int mtu = atoi(var);

                        if (mtu > 0 && mtu < MAX_DTLS_MTU) {
                                dtls->mtu = mtu;
                        }

                }
        }
        
        BIO_ctrl(dtls->filter_bio, BIO_CTRL_DGRAM_SET_MTU, dtls->mtu, NULL);
        
        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);

 done:

        switch_mutex_unlock(rtp_session->ice_mutex);

        return status;

}

switch_rtp_break()

void switch_rtp_break

(

switch_rtp_t *

rtp_session

)

Definition at line 5083 of file switch_rtp.c.

References CF_VIDEO_BREAK, switch_rtp::flag_mutex, switch_rtp::flags, ping_socket(), switch_rtp::session, switch_rtp::sock_input, 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_rtp_change_interval()

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 4417 of file switch_rtp.c.

References memset(), switch_rtp::ms_per_packet, switch_rtp::pool, READ_DEC, READ_INC, switch_rtp::samples_per_interval, switch_rtp::session, 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, switch_rtp::timer, switch_timer::timer_interface, switch_rtp::timer_name, WRITE_DEC, WRITE_INC, and switch_rtp::write_timer.

Referenced by switch_core_media_set_codec().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        int change_timer = 0;

        if (rtp_session->ms_per_packet != ms_per_packet || rtp_session->samples_per_interval != samples_per_interval) {
                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 (rtp_session->write_timer.timer_interface) {
                        switch_core_timer_destroy(&rtp_session->write_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);
                        switch_core_timer_init(&rtp_session->write_timer, rtp_session->timer_name, (ms_per_packet / 1000), samples_per_interval, rtp_session->pool);
                } 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_rtp_check_auto_adj()

switch_byte_t switch_rtp_check_auto_adj

(

switch_rtp_t *

rtp_session

)

Definition at line 8049 of file switch_rtp.c.

References switch_rtp::auto_adj_used.

{
        return rtp_session->auto_adj_used;
}

switch_rtp_clear_flag()

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 5434 of file switch_rtp.c.

References FALSE, switch_rtp::flag_mutex, switch_rtp::flags, switch_rtp_stats_t::inbound, switch_rtp_numbers_t::last_processed_seq, reset_jitter_seq(), switch_rtp::sock_input, switch_rtp::stats, SWITCH_FALSE, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_DTMF_ON, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLAG_PASSTHRU, SWITCH_RTP_FLAG_PAUSE, switch_rtp_pause_jitter_buffer(), SWITCH_SO_NONBLOCK, and switch_socket_opt_set().

Referenced by do_flush(), handle_ice(), read_bundle_rtp_packet(), read_rtcp_packet(), read_rtp_packet(), rtp_common_read(), rtp_common_write(), rtp_flush_read_buffer(), switch_core_media_clear_rtp_flag(), switch_core_media_negotiate_sdp(), switch_core_media_receive_message(), switch_core_media_resume(), switch_core_media_toggle_hold(), switch_core_session_passthru(), switch_rtp_clear_flags(), switch_rtp_create(), switch_rtp_disable_vad(), switch_rtp_udptl_mode(), and switch_rtp_write_raw().

{
        int old_flag = rtp_session->flags[flag];

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

        if (flag == SWITCH_RTP_FLAG_PASSTHRU) {
                if (old_flag) {
                        switch_rtp_pause_jitter_buffer(rtp_session, SWITCH_FALSE);
                }
        } else 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);
        }
}

switch_rtp_clear_flags()

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

Definition at line 5364 of file switch_rtp.c.

References switch_rtp_clear_flag(), and 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]) {
                        switch_rtp_clear_flag(rtp_session, i);
                }
        }
}

switch_rtp_create()

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[SWITCH_RTP_FLAG_INVALID],
		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

Definition at line 4476 of file switch_rtp.c.

References switch_rtp_numbers_t::burstrate, switch_rtp::cng_pt, switch_rtp::conf_samples_per_interval, switch_rtp::dtmf_data, switch_rtp_rfc2833_data::dtmf_inqueue, switch_rtp_rfc2833_data::dtmf_mutex, switch_rtp_rfc2833_data::dtmf_queue, switch_rtp::flag_mutex, switch_rtp::flags, switch_rtp::from_addr, rtp_msg_t::header, switch_rtp::ice_mutex, switch_rtp_stats_t::inbound, INVALID_PT, switch_rtp_numbers_t::jitter_add, switch_rtp_numbers_t::jitter_addsq, switch_rtp_numbers_t::jitter_n, switch_rtp_numbers_t::last_loss, switch_rtp_numbers_t::last_proc_time, switch_rtp_numbers_t::last_processed_seq, switch_rtp::last_write_ts, switch_rtp_numbers_t::loss, switch_rtp_numbers_t::lossrate, switch_rtp_numbers_t::max_variance, memset(), switch_rtp_numbers_t::min_variance, switch_rtp_numbers_t::mos, switch_rtp::payload, pool, switch_rtp::pool, switch_rtp_numbers_t::R, switch_rtp::read_mutex, switch_rtp::ready, switch_rtp::recv_msg, switch_rtp::recv_te, switch_rtp::rtcp_from_addr, switch_rtp::rtcp_last_sent, switch_rtp::rtp_from_addr, switch_rtp::send_msg, switch_rtp::seq, switch_rtp::session, switch_rtp::ssrc, switch_rtp::stats, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_core_alloc, switch_core_memory_pool_get_data(), switch_core_session_get_channel(), switch_core_strdup, switch_core_timer_init(), switch_epoch_time_now(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_queue_create(), switch_rand(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLAG_USE_TIMER, SWITCH_RTP_FLAG_VIDEO, SWITCH_RTP_MAX_BUF_LEN, switch_rtp_set_flag(), switch_rtp_set_flags(), switch_rtp_set_interval(), switch_sockaddr_create(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_rtp::te, switch_timer::tick, switch_rtp::timer, switch_rtp::timer_name, switch_rtp::write_mutex, switch_rtp::write_timer, and zstr.

Referenced by switch_rtp_new().

{
        switch_rtp_t *rtp_session = NULL;
        switch_core_session_t *session = switch_core_memory_pool_get_data(pool, "__session");
        switch_channel_t *channel = NULL;

        if (session) channel = switch_core_session_get_channel(session);

        *new_rtp_session = NULL;

        if (samples_per_interval > SWITCH_RTP_MAX_BUF_LEN) {
                *err = "Packet Size Too Large!";
                return SWITCH_STATUS_FALSE;
        }

        if (!(rtp_session = switch_core_alloc(pool, sizeof(*rtp_session)))) {
                *err = "Memory Error!";
                return SWITCH_STATUS_MEMERR;
        }

        rtp_session->pool = pool;
        rtp_session->te = INVALID_PT;
        rtp_session->recv_te = INVALID_PT;
        rtp_session->cng_pt = INVALID_PT;
        rtp_session->session = session;

        switch_mutex_init(&rtp_session->flag_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&rtp_session->read_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&rtp_session->write_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&rtp_session->ice_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&rtp_session->dtmf_data.dtmf_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_queue_create(&rtp_session->dtmf_data.dtmf_queue, 100, rtp_session->pool);
        switch_queue_create(&rtp_session->dtmf_data.dtmf_inqueue, 100, rtp_session->pool);

        switch_rtp_set_flags(rtp_session, flags);

        /* for from address on recvfrom calls */
        switch_sockaddr_create(&rtp_session->from_addr, pool);
        switch_sockaddr_create(&rtp_session->rtp_from_addr, pool);

        if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                switch_sockaddr_create(&rtp_session->rtcp_from_addr, pool);
        }

        rtp_session->seq = (uint16_t) switch_rand();
        rtp_session->ssrc = (uint32_t) ((intptr_t) rtp_session + (switch_time_t) switch_epoch_time_now(NULL));
#ifdef DEBUG_TS_ROLLOVER
        rtp_session->last_write_ts = TS_ROLLOVER_START;
#endif
        rtp_session->stats.inbound.R = 100.0;
        rtp_session->stats.inbound.mos = 4.5;
        rtp_session->send_msg.header.ssrc = htonl(rtp_session->ssrc);
        rtp_session->send_msg.header.ts = 0;
        rtp_session->send_msg.header.m = 0;
        rtp_session->send_msg.header.pt = (switch_payload_t) htonl(payload);
        rtp_session->send_msg.header.version = 2;
        rtp_session->send_msg.header.p = 0;
        rtp_session->send_msg.header.x = 0;
        rtp_session->send_msg.header.cc = 0;

        rtp_session->recv_msg.header.ssrc = 0;
        rtp_session->recv_msg.header.ts = 0;
        rtp_session->recv_msg.header.seq = 0;
        rtp_session->recv_msg.header.m = 0;
        rtp_session->recv_msg.header.pt = (switch_payload_t) htonl(payload);
        rtp_session->recv_msg.header.version = 2;
        rtp_session->recv_msg.header.p = 0;
        rtp_session->recv_msg.header.x = 0;
        rtp_session->recv_msg.header.cc = 0;

        rtp_session->payload = payload;
        rtp_session->rtcp_last_sent = switch_micro_time_now();

        switch_rtp_set_interval(rtp_session, ms_per_packet, samples_per_interval);
        rtp_session->conf_samples_per_interval = samples_per_interval;

        if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && zstr(timer_name)) {
                timer_name = "soft";
        }

        if (!zstr(timer_name) && !strcasecmp(timer_name, "none")) {
                timer_name = NULL;
        }

        if (!zstr(timer_name)) {
                rtp_session->timer_name = switch_core_strdup(pool, timer_name);
                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);

                if (switch_core_timer_init(&rtp_session->timer, timer_name, ms_per_packet / 1000, samples_per_interval, pool) == SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG,
                                                          "Starting timer [%s] %d bytes per %dms\n", timer_name, samples_per_interval, ms_per_packet / 1000);
                        switch_core_timer_init(&rtp_session->write_timer, timer_name, (ms_per_packet / 1000), samples_per_interval, pool);
#ifdef DEBUG_TS_ROLLOVER
                        rtp_session->timer.tick = TS_ROLLOVER_START / samples_per_interval;
#endif
                } else {
                        memset(&rtp_session->timer, 0, sizeof(rtp_session->timer));
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR,
                                                          "Error Starting timer [%s] %d bytes per %dms, async RTP disabled\n", timer_name, samples_per_interval, ms_per_packet / 1000);
                        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
                }
        } else {
                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                        if (switch_core_timer_init(&rtp_session->timer, "soft", 1, 90, pool) == SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Starting video timer.\n");
                        }

                        //switch_jb_create(&rtp_session->vb, 3, 10, rtp_session->pool);
                        //switch_jb_debug_level(rtp_session->vb, 10);

                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Not using a timer\n");
                }

                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
        }


        if (channel) {
                switch_channel_set_private(channel, "__rtcp_audio_rtp_session", rtp_session);
        }


        /* Jitter */
        rtp_session->stats.inbound.last_proc_time = switch_micro_time_now() / 1000;
        rtp_session->stats.inbound.jitter_n = 0;
        rtp_session->stats.inbound.jitter_add = 0;
        rtp_session->stats.inbound.jitter_addsq = 0;
        rtp_session->stats.inbound.min_variance = 0;
        rtp_session->stats.inbound.max_variance = 0;

        /* Burst and Packet Loss */
        rtp_session->stats.inbound.lossrate = 0;
        rtp_session->stats.inbound.burstrate = 0;
        memset(rtp_session->stats.inbound.loss, 0, sizeof(rtp_session->stats.inbound.loss));
        rtp_session->stats.inbound.last_loss = 0;
        rtp_session->stats.inbound.last_processed_seq = -1;

        rtp_session->ready = 1;
        *new_rtp_session = rtp_session;

        return SWITCH_STATUS_SUCCESS;
}

switch_rtp_deactivate_jitter_buffer()

switch_status_t switch_rtp_deactivate_jitter_buffer

(

switch_rtp_t *

rtp_session

)

Definition at line 4764 of file switch_rtp.c.

References switch_rtp::flags, 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)) {
                return SWITCH_STATUS_FALSE;
        }

        rtp_session->flags[SWITCH_RTP_FLAG_KILL_JB]++;

        return SWITCH_STATUS_SUCCESS;
}

switch_rtp_debug_jitter_buffer()

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

Definition at line 4817 of file switch_rtp.c.

References switch_rtp::jb, switch_jb_debug_level(), switch_rtp_ready(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_rtp::vb.

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_rtp_del_dtls()

switch_status_t switch_rtp_del_dtls	(	switch_rtp_t *	rtp_session,
		dtls_type_t	type
	)

Definition at line 3739 of file switch_rtp.c.

References switch_rtp::dtls, DTLS_TYPE_RTCP, DTLS_TYPE_RTP, switch_rtp::flags, free_dtls(), switch_rtp::ice_mutex, switch_rtp::jb, switch_rtp::recv_ctx, switch_rtp::rtcp_dtls, switch_rtp::send_ctx, switch_goto_status, switch_jb_reset(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_SECURE_RECV, SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_rtp::vb, and switch_rtp::vbw.

Referenced by switch_rtp_add_dtls().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if (!rtp_session) {
                return SWITCH_STATUS_FALSE;
        }

        switch_mutex_lock(rtp_session->ice_mutex);

        if (!rtp_session->dtls && !rtp_session->rtcp_dtls) {
                switch_goto_status(SWITCH_STATUS_FALSE, done);
        }

        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;

                rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 0;

                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;
                        }
                }
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV]) {
                int x;

                rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 0;

                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;
                        }
                }
        }
#endif

 done:

        switch_mutex_unlock(rtp_session->ice_mutex);

        return status;
}

switch_rtp_dequeue_dtmf()

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 8067 of file switch_rtp.c.

References switch_dtmf_t::digit, switch_rtp::dtmf_data, switch_rtp_rfc2833_data::dtmf_inqueue, switch_rtp_rfc2833_data::dtmf_mutex, switch_dtmf_t::duration, switch_rtp::session, SWITCH_CHANNEL_SESSION_LOG, switch_channel_var_true(), switch_core_session_get_channel(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_rtp_ready(), SWITCH_SENSITIVE_DTMF_VARIABLE, 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;
                /* Only log DTMF buffer if sensitive_dtmf channel variable not set to true */
                if (!(switch_channel_var_true(switch_core_session_get_channel(rtp_session->session), SWITCH_SENSITIVE_DTMF_VARIABLE))) {                        
                        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;
}

switch_rtp_destroy()

void switch_rtp_destroy

(

switch_rtp_t **

rtp_session

)

Destroy an RTP session.

Parameters

rtp_session

an RTP session to destroy

Definition at line 5189 of file switch_rtp.c.

References free_dtls(), READ_DEC, READ_INC, switch_rtp::ready, SWITCH_CHANNEL_SESSION_LOG, switch_core_timer_destroy(), switch_jb_destroy(), switch_jb_get_nack_success(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_rtp_disable_vad(), 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, 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;
        }

        if ((*rtp_session)->vb) {
                /* retrieve counter for ALL received NACKed packets */
                uint32_t nack_jb_ok = switch_jb_get_nack_success((*rtp_session)->vb);
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG((*rtp_session)->session), SWITCH_LOG_DEBUG, 
                                "NACK: Added to JB: [%u]\n", nack_jb_ok);
        }

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

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

        (*rtp_session)->ready = 0;

        WRITE_DEC((*rtp_session));
        READ_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);
        }

        if ((*rtp_session)->rtcp_sock_input == (*rtp_session)->sock_input) {
                (*rtp_session)->rtcp_sock_input = NULL;
        }

        if ((*rtp_session)->rtcp_sock_output == (*rtp_session)->sock_output) {
                (*rtp_session)->rtcp_sock_output = NULL;
        }

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

        if ((*rtp_session)->timer.timer_interface) {
                switch_core_timer_destroy(&(*rtp_session)->timer);
        }

        if ((*rtp_session)->write_timer.timer_interface) {
                switch_core_timer_destroy(&(*rtp_session)->write_timer);
        }

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

        return;
}

switch_rtp_disable_vad()

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 8818 of file switch_rtp.c.

References switch_rtp::flags, switch_core_codec_destroy(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_VAD, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_rtp_vad_data::vad_codec, and switch_rtp::vad_data.

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;
}

switch_rtp_dtls_state()

dtls_state_t switch_rtp_dtls_state	(	switch_rtp_t *	rtp_session,
		dtls_type_t	type
	)

Definition at line 3708 of file switch_rtp.c.

References DS_OFF, switch_rtp::dtls, DTLS_TYPE_RTCP, DTLS_TYPE_RTP, switch_rtp::ice_mutex, switch_rtp::rtcp_dtls, switch_dtls_s::state, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by check_engine().

{
        dtls_state_t s = DS_OFF;

        if (!rtp_session) {
                return s;
        }

        switch_mutex_lock(rtp_session->ice_mutex);

        if (!rtp_session->dtls && !rtp_session->rtcp_dtls) {
                s = DS_OFF;
                goto done;
        }

        if ((type == DTLS_TYPE_RTP) && rtp_session->dtls) {
                s = rtp_session->dtls->state;
                goto done;
        }

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

 done:

        switch_mutex_unlock(rtp_session->ice_mutex);

        return s;
}

switch_rtp_enable_vad()

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 8833 of file switch_rtp.c.

References switch_rtp_vad_data::bg_count, switch_rtp_vad_data::bg_len, switch_rtp_vad_data::bg_level, switch_rtp_vad_data::cng_freq, switch_rtp_vad_data::diff_level, switch_rtp_vad_data::fire_events, switch_rtp_vad_data::flags, switch_rtp::flags, switch_rtp_vad_data::hangover, switch_rtp_vad_data::hangunder, switch_codec_implementation::iananame, switch_codec::implementation, memset(), switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::modname, switch_rtp_vad_data::next_scan, switch_codec_implementation::number_of_channels, switch_rtp::pool, switch_rtp_vad_data::read_codec, switch_codec_implementation::samples_per_second, switch_rtp_vad_data::scan_freq, switch_rtp_vad_data::session, switch_rtp::session, switch_rtp_vad_data::start, switch_rtp_vad_data::start_talking, 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_micro_time_now(), 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_true(), SWITCH_VAD_FLAG_CNG, SWITCH_VAD_FLAG_TALKING, switch_rtp_vad_data::ts, switch_rtp_vad_data::vad_codec, switch_rtp::vad_data, 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_micro_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;
}

switch_rtp_flush()

void switch_rtp_flush

(

switch_rtp_t *

rtp_session

)

Definition at line 5028 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);
}

switch_rtp_get_core_session()

switch_core_session_t* switch_rtp_get_core_session

(

switch_rtp_t *

rtp_session

)

Definition at line 9241 of file switch_rtp.c.

References switch_rtp::session.

{
        return rtp_session->session;
}

switch_rtp_get_default_payload()

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 5343 of file switch_rtp.c.

References switch_rtp::payload.

{
        return rtp_session->payload;
}

switch_rtp_get_default_samples_per_interval()

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 5333 of file switch_rtp.c.

References switch_rtp::samples_per_interval.

{
        return rtp_session->samples_per_interval;
}

switch_rtp_get_jitter_buffer()

switch_jb_t* switch_rtp_get_jitter_buffer

(

switch_rtp_t *

rtp_session

)

Definition at line 4729 of file switch_rtp.c.

References switch_rtp::jb, switch_rtp_ready(), and switch_rtp::vb.

Referenced by switch_core_media_get_jb(), switch_core_media_read_frame(), and switch_core_media_receive_message().

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

        return rtp_session->jb ? rtp_session->jb : rtp_session->vb;
}

switch_rtp_get_media_timer()

switch_timer_t* switch_rtp_get_media_timer

(

switch_rtp_t *

rtp_session

)

Definition at line 4715 of file switch_rtp.c.

References switch_rtp::flags, switch_core_timer_sync(), SWITCH_RTP_FLAG_VIDEO, switch_rtp::timer, and switch_timer::timer_interface.

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;
}

switch_rtp_get_private()

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 9236 of file switch_rtp.c.

References switch_rtp::private_data.

{
        return rtp_session->private_data;
}

switch_rtp_get_random()

void switch_rtp_get_random	(	void *	buf,
		uint32_t	len
	)

Definition at line 2545 of file switch_rtp.c.

References switch_stun_random_string().

Referenced by switch_core_media_build_crypto().

{
#ifdef HAVE_OPENSSL
        RAND_bytes(buf, len);
#else
        switch_stun_random_string(buf, len, NULL);
#endif
}

switch_rtp_get_remote_host()

char* switch_rtp_get_remote_host

(

switch_rtp_t *

rtp_session

)

Definition at line 3037 of file switch_rtp.c.

References switch_rtp::remote_host_str, and 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_rtp_get_remote_port()

switch_port_t switch_rtp_get_remote_port

(

switch_rtp_t *

rtp_session

)

Definition at line 3042 of file switch_rtp.c.

References switch_rtp::remote_port.

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_rtp_get_rtp_socket()

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 5328 of file switch_rtp.c.

References switch_rtp::sock_input.

{
        return rtp_session->sock_input;
}

switch_rtp_get_ssrc()

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 9226 of file switch_rtp.c.

References switch_rtp::ssrc.

Referenced by switch_core_media_activate_rtp().

{
        return rtp_session->ssrc;
}

switch_rtp_get_stats()

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

Definition at line 9083 of file switch_rtp.c.

References do_mos(), switch_rtp::flag_mutex, switch_rtp_stats_t::inbound, switch_rtp::jb, switch_rtp_numbers_t::largest_jb_size, switch_rtp::stats, switch_core_alloc, 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_mutex_unlock(rtp_session->flag_mutex);

        return s;
}

switch_rtp_get_video_buffer_size()

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 4776 of file switch_rtp.c.

References switch_jb_get_frames(), SWITCH_STATUS_FALSE, and switch_rtp::vb.

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;
}

switch_rtp_has_dtls()

int switch_rtp_has_dtls

(

void

)

Definition at line 3700 of file switch_rtp.c.

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

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

switch_rtp_has_dtmf()

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 8054 of file switch_rtp.c.

References switch_rtp::dtmf_data, switch_rtp_rfc2833_data::dtmf_inqueue, switch_rtp_rfc2833_data::dtmf_mutex, 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;
}

switch_rtp_init()

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 1526 of file switch_rtp.c.

References port_lock, SWITCH_CHANNEL_LOG, switch_core_hash_init, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_init(), SWITCH_MUTEX_NESTED, and switch_rtp_dtls_init().

Referenced by switch_core_init().

{
        if (global_init) {
                return;
        }
        switch_core_hash_init(&alloc_hash);
#ifdef ENABLE_SRTP
        {
                srtp_err_status_t stat = srtp_init();
                if (stat == srtp_err_status_ok) { 
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SRTP (%s) initialized.\n", srtp_get_version_string());
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error initializing SRTP (%d).\n", stat);
                }
        }
#endif
        switch_mutex_init(&port_lock, SWITCH_MUTEX_NESTED, pool);
        switch_rtp_dtls_init();
        global_init = 1;
}

switch_rtp_intentional_bugs()

void switch_rtp_intentional_bugs	(	switch_rtp_t *	rtp_session,
		switch_rtp_bug_flag_t	bugs
	)

Definition at line 2665 of file switch_rtp.c.

References RTP_BUG_START_SEQ_AT_ZERO, switch_rtp::rtp_bugs, and switch_rtp::seq.

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;
        }

}

switch_rtp_kill_socket()

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 5123 of file switch_rtp.c.

References switch_rtp::flag_mutex, switch_rtp::flags, ping_socket(), switch_rtp::rtcp_sock_input, switch_rtp::rtcp_sock_output, switch_rtp::sock_input, switch_rtp::sock_output, 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->sock_input && rtp_session->rtcp_sock_input && rtp_session->rtcp_sock_input != rtp_session->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->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_new()

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[SWITCH_RTP_FLAG_INVALID],
		char *	timer_name,
		const char **	err,
		switch_memory_pool_t *	pool,
		switch_port_t	bundle_internal_ports,
		switch_port_t	bundle_external_port
	)

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
bundle_port	port used by bundled stream locally, for video thread this is the port where it will forward audio (internal bundle port on which audio is listening), and for audio this is the port where it will send RTP (external bundle port where video is listening)

Returns

the new RTP session or NULL on failure

Definition at line 4626 of file switch_rtp.c.

References switch_rtp::flag_mutex, switch_rtp::pool, switch_rtp::ready, switch_rtp::rx_host, switch_rtp::rx_port, switch_core_strdup, switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_create(), SWITCH_RTP_FLAG_DETECT_SSRC, SWITCH_RTP_FLAG_FLUSH, switch_rtp_release_port(), switch_rtp_set_flag(), switch_rtp_set_local_address(), switch_rtp_set_remote_address(), SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and zstr.

Referenced by switch_core_media_activate_rtp().

{
        switch_rtp_t *rtp_session = NULL;

        if (zstr(rx_host)) {
                *err = "Missing local host";
                goto end;
        }

        if (!rx_port) {
                *err = "Missing local port";
                goto end;
        }

        if (zstr(tx_host)) {
                *err = "Missing remote host";
                goto end;
        }

        if (!tx_port) {
                *err = "Missing remote port";
                goto end;
        }

        if (switch_rtp_create(&rtp_session, payload, samples_per_interval, ms_per_packet, flags, timer_name, err, pool) != SWITCH_STATUS_SUCCESS) {
                goto end;
        }

        switch_mutex_lock(rtp_session->flag_mutex);

        if (switch_rtp_set_local_address(rtp_session, rx_host, rx_port, err) != SWITCH_STATUS_SUCCESS) {
                switch_mutex_unlock(rtp_session->flag_mutex);
                rtp_session = NULL;
                goto end;
        }

        if (switch_rtp_set_remote_address(rtp_session, tx_host, tx_port, 0, SWITCH_TRUE, err) != SWITCH_STATUS_SUCCESS) {
                switch_mutex_unlock(rtp_session->flag_mutex);
                rtp_session = NULL;
                goto end;
        }

 end:

        if (rtp_session) {
                switch_mutex_unlock(rtp_session->flag_mutex);
                rtp_session->ready = 2;
                rtp_session->rx_host = switch_core_strdup(rtp_session->pool, rx_host);
                rtp_session->rx_port = rx_port;
                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_DETECT_SSRC);
        } else {
                switch_rtp_release_port(rx_host, rx_port);
        }

        return rtp_session;
}

switch_rtp_pause_jitter_buffer()

switch_status_t switch_rtp_pause_jitter_buffer	(	switch_rtp_t *	rtp_session,
		switch_bool_t	pause
	)

Definition at line 4738 of file switch_rtp.c.

References switch_rtp::jb, switch_rtp::pause_jb, rtp_type, switch_rtp::session, SWITCH_CHANNEL_SESSION_LOG, switch_jb_reset(), SWITCH_LOG_DEBUG1, switch_log_printf(), SWITCH_STATUS_SUCCESS, and switch_rtp::vb.

Referenced by check_jb(), switch_core_media_receive_message(), switch_rtp_clear_flag(), and switch_rtp_set_flag().

{
        int new_val;

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

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

        new_val = pause ? 1 : -1;

        if (rtp_session->pause_jb + new_val > -1) {
                rtp_session->pause_jb += new_val;
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1,
                                          "Jitterbuffer %s is %s\n", rtp_type(rtp_session), rtp_session->pause_jb ? "paused" : "enabled");
        
        return SWITCH_STATUS_SUCCESS;
}

switch_rtp_ping()

void switch_rtp_ping

(

switch_rtp_t *

rtp_session

)

Definition at line 2540 of file switch_rtp.c.

References check_rtcp_and_ice().

{
        check_rtcp_and_ice(rtp_session);
}

switch_rtp_queue_rfc2833()

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 8094 of file switch_rtp.c.

References switch_rtp::dtmf_data, switch_rtp_rfc2833_data::dtmf_queue, 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_rtp_queue_rfc2833_in()

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 8120 of file switch_rtp.c.

References switch_rtp::dtmf_data, switch_rtp_rfc2833_data::dtmf_inqueue, 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_rtp_read()

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 8145 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;
}

switch_rtp_ready()

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 5150 of file switch_rtp.c.

References switch_rtp::flag_mutex, switch_rtp::flags, switch_rtp::ready, switch_rtp::remote_addr, switch_rtp::sock_input, switch_rtp::sock_output, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_IO, and SWITCH_RTP_FLAG_SHUTDOWN.

Referenced by check_ice(), check_media_timeout_params(), 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_core_session_passthru(), 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_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_media_timeout(), 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;
}

switch_rtp_release_port()

void switch_rtp_release_port	(	const char *	ip,
		switch_port_t	port
	)

Definition at line 2613 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_rtp_req_bitrate()

switch_status_t switch_rtp_req_bitrate	(	switch_rtp_t *	rtp_session,
		uint32_t	bps
	)

Definition at line 5037 of file switch_rtp.c.

References rtp_write_ready(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_rtp::tmmbr.

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_rtp_request_port()

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 2629 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;
}

switch_rtp_reset()

void switch_rtp_reset

(

switch_rtp_t *

rtp_session

)

Definition at line 3003 of file switch_rtp.c.

References switch_rtp_ice_t::cand_responsive, switch_rtp::first_stun, switch_rtp::ice, switch_rtp::last_adj, switch_rtp::last_stun, memset(), switch_rtp_ice_t::ready, switch_rtp_ice_t::rready, switch_rtp::rtcp_last_sent, switch_rtp::rtcp_sent_packets, rtcp_stats_init(), SWITCH_RTP_FLAG_MUTE, SWITCH_RTP_FLAG_PAUSE, switch_rtp_reset_vb(), switch_rtp_set_flag(), and switch_rtp::ts_norm.

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->rtcp_sent_packets = 0;
        rtp_session->rtcp_last_sent = 0;
        rtp_session->last_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;
                rtp_session->ice.cand_responsive = 0;
        }

}

switch_rtp_reset_jb()

void switch_rtp_reset_jb

(

switch_rtp_t *

rtp_session

)

Definition at line 2982 of file switch_rtp.c.

References switch_rtp::jb, 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);
                }
        }
}

switch_rtp_reset_media_timer()

void switch_rtp_reset_media_timer

(

switch_rtp_t *

rtp_session

)

Definition at line 3031 of file switch_rtp.c.

References switch_rtp::last_media, switch_rtp::missed_count, and switch_micro_time_now().

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

{
        rtp_session->missed_count = 0;
        rtp_session->last_media = switch_micro_time_now();
}

switch_rtp_set_cng_pt()

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 4709 of file switch_rtp.c.

References switch_rtp::cng_pt, switch_rtp::flags, and 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;
}

switch_rtp_set_default_payload()

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 5338 of file switch_rtp.c.

References switch_rtp::payload.

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

{
        rtp_session->payload = payload;
}

switch_rtp_set_end_port()

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 2599 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;
}

switch_rtp_set_flag()

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 5375 of file switch_rtp.c.

References switch_rtp::autoadj_tally, switch_rtp::autoadj_threshold, switch_rtp::autoadj_window, switch_rtp::flag_mutex, switch_rtp::flags, switch_rtp_stats_t::inbound, switch_rtp::jb, switch_rtp_numbers_t::last_processed_seq, reset_jitter_seq(), switch_rtp::rtcp_autoadj_tally, switch_rtp::rtcp_autoadj_threshold, switch_rtp::rtcp_autoadj_window, rtp_flush_read_buffer(), switch_rtp::session, switch_rtp::sock_input, switch_rtp::stats, 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_FLAG_PASSTHRU, SWITCH_RTP_FLAG_RTCP_AUTOADJ, SWITCH_RTP_FLUSH_ONCE, switch_rtp_pause_jitter_buffer(), SWITCH_SO_NONBLOCK, switch_socket_opt_set(), SWITCH_TRUE, and TRUE.

Referenced by do_flush(), handle_ice(), process_rtcp_report(), read_rtcp_packet(), read_rtp_packet(), rtp_common_read(), rtp_flush_read_buffer(), switch_core_media_activate_rtp(), switch_core_media_check_autoadj(), switch_core_media_negotiate_sdp(), 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_core_session_passthru(), switch_rtp_create(), switch_rtp_enable_vad(), switch_rtp_flush(), switch_rtp_new(), switch_rtp_reset(), switch_rtp_set_flags(), switch_rtp_set_local_address(), and switch_rtp_udptl_mode().

{
        int old_flag = rtp_session->flags[flag];

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

        if (flag == SWITCH_RTP_FLAG_PASSTHRU) {
                if (!old_flag) {
                        switch_rtp_pause_jitter_buffer(rtp_session, SWITCH_TRUE);
                }
        } else 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;

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

                rtp_session->rtcp_autoadj_window = 20;
                rtp_session->rtcp_autoadj_threshold = 1;
                rtp_session->rtcp_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);
        }

}

switch_rtp_set_flags()

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

Definition at line 5353 of file switch_rtp.c.

References SWITCH_RTP_FLAG_INVALID, and switch_rtp_set_flag().

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]) {
                        switch_rtp_set_flag(rtp_session, i);
                }
        }
}

switch_rtp_set_interdigit_delay()

void switch_rtp_set_interdigit_delay	(	switch_rtp_t *	rtp_session,
		uint32_t	delay
	)

Definition at line 5323 of file switch_rtp.c.

References switch_rtp::interdigit_delay.

Referenced by switch_core_media_activate_rtp().

{
        rtp_session->interdigit_delay = delay;
}

switch_rtp_set_interval()

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 4404 of file switch_rtp.c.

References switch_rtp::conf_samples_per_interval, switch_rtp::missed_count, switch_rtp::ms_per_packet, switch_rtp::one_second, switch_rtp::samples_per_interval, switch_rtp::samples_per_second, and 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;
}

switch_rtp_set_invalid_handler()

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 5348 of file switch_rtp.c.

References switch_rtp::invalid_handler.

{
        rtp_session->invalid_handler = on_invalid;
}

switch_rtp_set_local_address()

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 2783 of file switch_rtp.c.

References enable_local_rtcp_socket(), FALSE, switch_rtp::flags, switch_rtp::from_addr, switch_rtp::local_addr, switch_rtp::local_host_str, switch_rtp::local_port, switch_rtp::pool, READ_DEC, READ_INC, switch_rtp::read_pollfd, switch_rtp::ready, switch_rtp::session, switch_rtp::sock_input, 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;
                }

                READ_INC(rtp_session);
                WRITE_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);
        } else {
                switch_socket_opt_set(new_sock, SWITCH_SO_RCVBUF, 851968);
                switch_socket_opt_set(new_sock, SWITCH_SO_SNDBUF, 851968);
        }

        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;
}

switch_rtp_set_max_missed_packets()

void switch_rtp_set_max_missed_packets	(	switch_rtp_t *	rtp_session,
		uint32_t	max
	)

Definition at line 2966 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::max_missed_packets, switch_rtp::missed_count, switch_rtp::session, SWITCH_CHANNEL_SESSION_LOG, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_RTP_FLAG_UDPTL, and switch_rtp_ready().

Referenced by check_media_timeout_params(), switch_core_media_activate_rtp(), switch_core_media_negotiate_sdp(), switch_core_media_read_frame(), switch_core_media_receive_message(), 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->max_missed_packets, max, rtp_session->missed_count);
        }

        rtp_session->max_missed_packets = max;
}

switch_rtp_set_media_timeout()

void switch_rtp_set_media_timeout	(	switch_rtp_t *	rtp_session,
		uint32_t	ms
	)

Definition at line 2954 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::media_timeout, rtp_type, switch_rtp::session, SWITCH_CHANNEL_SESSION_LOG, switch_core_session_get_name, SWITCH_LOG_DEBUG1, switch_log_printf(), SWITCH_RTP_FLAG_UDPTL, switch_rtp_ready(), and switch_rtp_reset_media_timer().

Referenced by check_media_timeout_params(), switch_core_media_negotiate_sdp(), switch_core_media_receive_message(), and switch_core_media_toggle_hold().

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

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1,
                                          "%s MEDIA TIMEOUT %s set to %u\n", switch_core_session_get_name(rtp_session->session), rtp_type(rtp_session), ms);
        rtp_session->media_timeout = ms;
        switch_rtp_reset_media_timer(rtp_session);
}

switch_rtp_set_payload_map()

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

Definition at line 2652 of file switch_rtp.c.

References switch_rtp::flag_mutex, switch_rtp::pmaps, 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;
}

switch_rtp_set_private()

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 9231 of file switch_rtp.c.

References switch_rtp::private_data.

{
        rtp_session->private_data = private_data;
}

switch_rtp_set_remote_address()

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 3128 of file switch_rtp.c.

References switch_rtp::dtls, switch_rtp::eff_remote_host_str, switch_rtp::eff_remote_port, switch_rtp::flags, switch_rtp::local_addr, switch_rtp::pool, switch_dtls_s::remote_addr, switch_rtp::remote_addr, switch_rtp::remote_host_str, switch_rtp::remote_port, switch_rtp::rtcp_remote_addr, switch_rtp::rtcp_sock_output, switch_rtp::sock_input, switch_dtls_s::sock_output, switch_rtp::sock_output, switch_core_strdup, 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, SWITCH_UNSPEC, and switch_rtp::write_mutex.

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;

        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]) {
                        status = 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_rtp_set_remote_ssrc()

switch_status_t switch_rtp_set_remote_ssrc	(	switch_rtp_t *	rtp_session,
		uint32_t	ssrc
	)

Definition at line 4469 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::remote_ssrc, switch_rtcp_report_block_frame::ssrc, SWITCH_RTP_FLAG_DETECT_SSRC, and SWITCH_STATUS_SUCCESS.

Referenced by check_ice(), and switch_core_media_activate_rtp().

{
        rtp_session->remote_ssrc = ssrc;
        rtp_session->flags[SWITCH_RTP_FLAG_DETECT_SSRC] = 0;
        return SWITCH_STATUS_SUCCESS;
}

switch_rtp_set_ssrc()

switch_status_t switch_rtp_set_ssrc	(	switch_rtp_t *	rtp_session,
		uint32_t	ssrc
	)

Definition at line 4461 of file switch_rtp.c.

References rtp_msg_t::header, switch_rtp::send_msg, switch_rtcp_report_block_frame::ssrc, switch_rtp::ssrc, and 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_rtp_set_start_port()

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 2585 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;
}

switch_rtp_set_telephony_event()

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 4693 of file switch_rtp.c.

References switch_rtp::te.

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;
        }
}

switch_rtp_set_telephony_recv_event()

void switch_rtp_set_telephony_recv_event	(	switch_rtp_t *	rtp_session,
		switch_payload_t	te
	)

Definition at line 4701 of file switch_rtp.c.

References switch_rtp::recv_te.

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_rtp_set_video_buffer_size()

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

Definition at line 4786 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::last_max_vb_frames, switch_rtp::pool, switch_rtp::session, SJB_TEXT, 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_FLAG_TEXT, switch_rtp_ready(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_rtp::vb.

Referenced by check_jb(), and switch_core_media_activate_rtp().

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

        if (!max_frames) {
                max_frames = rtp_session->last_max_vb_frames;
        }

        if (!max_frames || frames >= max_frames) {
                max_frames = frames * 10;
        }

        rtp_session->last_max_vb_frames = max_frames;

        if (!rtp_session->vb) {
                switch_jb_create(&rtp_session->vb, rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? SJB_TEXT : 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;
}

switch_rtp_shutdown()

void switch_rtp_shutdown

(

void

)

Definition at line 2555 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(), switch_mutex_unlock(), and switch_rtp_dtls_destroy().

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_SRTP
        srtp_crypto_kernel_shutdown();
#endif
        switch_rtp_dtls_destroy();
}

switch_rtp_sync_stats()

switch_status_t switch_rtp_sync_stats

(

switch_rtp_t *

rtp_session

)

Definition at line 5166 of file switch_rtp.c.

References do_mos(), switch_rtp_numbers_t::error_log, switch_rtp::flags, switch_rtp_stats_t::inbound, switch_rtp_vad_data::session, switch_rtp::stats, error_period::stop, switch_channel_set_variable_printf(), switch_core_session_get_channel(), switch_micro_time_now(), SWITCH_RTP_FLAG_VAD, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_rtp_vad_data::total_talk_time, and switch_rtp::vad_data.

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

        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;
}

switch_rtp_test_flag()

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 5429 of file switch_rtp.c.

References switch_rtp::flags.

Referenced by check_rtcp_and_ice(), get_next_write_ts(), process_rtcp_report(), 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_rtp_udptl_mode()

switch_status_t switch_rtp_udptl_mode

(

switch_rtp_t *

rtp_session

)

Definition at line 3058 of file switch_rtp.c.

References FALSE, switch_rtp::flags, switch_rtp::max_missed_packets, memset(), switch_rtp::missed_count, ping_socket(), READ_DEC, READ_INC, switch_rtp::rtcp_sock_input, switch_rtp::rtcp_sock_output, switch_rtp::sock_input, 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, switch_rtp::timer, switch_timer::timer_interface, WRITE_DEC, and WRITE_INC.

Referenced by 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->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                rtp_session->rtcp_sock_input = NULL;
                rtp_session->rtcp_sock_output = NULL;
        } else {
                if (rtp_session->rtcp_sock_input && rtp_session->rtcp_sock_input != rtp_session->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 &&
                        rtp_session->rtcp_sock_output != rtp_session->sock_input) {
                        switch_socket_shutdown(rtp_session->rtcp_sock_output, SWITCH_SHUTDOWN_READWRITE);
                }

                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) {
                                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;

}

switch_rtp_video_loss()

void switch_rtp_video_loss

(

switch_rtp_t *

rtp_session

)

Definition at line 5071 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::ice, switch_rtp_ice_t::ice_user, switch_rtp::pli_count, 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;
        }
}

switch_rtp_video_refresh()

void switch_rtp_video_refresh

(

switch_rtp_t *

rtp_session

)

Definition at line 5059 of file switch_rtp.c.

References switch_rtp::fir_count, switch_rtp::flags, switch_rtp::ice, switch_rtp_ice_t::ice_user, rtp_write_ready(), SWITCH_RTP_FLAG_FIR, SWITCH_RTP_FLAG_OLD_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->flags[SWITCH_RTP_FLAG_OLD_FIR])) {
                rtp_session->fir_count = 1;
        }
}

switch_rtp_write_frame()

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 8890 of file switch_rtp.c.

References CF_AUDIO_VIDEO_BUNDLE, switch_rtp::cng_pt, payload_map_s::current, switch_frame::data, switch_frame::datalen, switch_rtp::flag_mutex, switch_frame::flags, switch_rtp::flags, payload_map_s::hash, rtp_msg_t::header, INVALID_PT, switch_rtp::local_addr, switch_frame::m, switch_rtp_numbers_t::media_bytes, switch_rtp_numbers_t::media_packet_count, payload_map_s::negotiated, payload_map_s::next, switch_rtp_stats_t::outbound, switch_frame::packet, switch_rtp_numbers_t::packet_count, switch_frame::packetlen, switch_frame::payload, switch_rtp::payload, switch_frame::pmap, switch_rtp::pmaps, payload_map_s::pt, switch_rtp::queue_delay, switch_rtp_numbers_t::raw_bytes, payload_map_s::recv_pt, switch_rtp::remote_addr, switch_rtp::remote_port, RTP_BUG_GEN_ONE_GEN_ALL, switch_rtp::rtp_bugs, rtp_common_write(), switch_rtp::rtp_from_addr, rtp_write_ready(), switch_rtp::sending_dtmf, switch_rtp::seq, switch_rtp::session, SFF_CNG, SFF_PROXY_PACKET, SFF_RAW_RTP, SFF_RAW_RTP_PARSE_FRAME, SFF_RTP_HEADER, SFF_UDPTL_PACKET, switch_rtp::sock_output, switch_frame::ssrc, switch_rtp::ssrc, switch_rtp::stats, switch_assert, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_CHANNEL_SESSION_LOG_CLEAN, switch_channel_test_flag(), switch_core_session_get_channel(), switch_get_addr(), SWITCH_LOG_CONSOLE, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_FLAG_DEBUG_RTP_WRITE, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_RAW_WRITE, SWITCH_RTP_FLAG_RESET, SWITCH_RTP_FLAG_TEXT, SWITCH_RTP_FLAG_UDPTL, SWITCH_RTP_FLAG_VIDEO, switch_rtp_ready(), switch_rtp_write_manual(), SWITCH_SIZE_T_FMT, switch_sockaddr_get_port(), switch_socket_sendto(), SWITCH_STATUS_SUCCESS, switch_test_flag, and switch_frame::timestamp.

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;
        switch_status_t status;

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

        if (!rtp_write_ready(rtp_session, frame->datalen, __LINE__)) {
                if (!switch_channel_test_flag(switch_core_session_get_channel(rtp_session->session), CF_AUDIO_VIDEO_BUNDLE)) 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 (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
                        const char *tx_host;
                        const char *old_host;
                        const char *my_host;

                        char bufa[50], bufb[50], bufc[50];


                        tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtp_from_addr);
                        old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
                        my_host = switch_get_addr(bufc, sizeof(bufc), rtp_session->local_addr);

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session), SWITCH_LOG_CONSOLE,
                                                          "W %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
                                                          rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName",
                                                          (long) bytes,
                                                          my_host, switch_sockaddr_get_port(rtp_session->local_addr),
                                                          old_host, rtp_session->remote_port,
                                                          tx_host, switch_sockaddr_get_port(rtp_session->rtp_from_addr),
                                                          send_msg->header.pt, ntohl(send_msg->header.ts), ntohs(send_msg->header.seq), send_msg->header.m);

                }

                if ((status = switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, frame->packet, &bytes)) != SWITCH_STATUS_SUCCESS) {
                        if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session), SWITCH_LOG_ERROR, "bytes: %" SWITCH_SIZE_T_FMT ", status: %d", bytes, status);
                        }

                        return -1 * status;
                }


                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;
        }

        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_VIDEO] &&
                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) || rtp_session->flags[SWITCH_RTP_FLAG_TEXT]) {
                switch_size_t wrote;

                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++;

                return wrote;
        }

        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;

}

switch_rtp_write_manual()

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 9110 of file switch_rtp.c.

References rtp_msg_t::body, switch_rtp::flags, rtp_msg_t::header, INVALID_PT, switch_rtp::last_write_ts, switch_rtp::remote_addr, rtp_header_len, rtp_write_ready(), switch_rtp::send_msg, switch_rtp::seq, 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, WRITE_INC, and switch_rtp::write_msg.

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_rtp_write_raw()

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 9161 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::ice_mutex, switch_rtp::remote_addr, rtp_write_ready(), switch_rtp::send_ctx, switch_rtp::send_policy, switch_rtp::session, switch_rtp::sock_output, switch_rtp::srtp_idx_rtp, switch_assert, SWITCH_CHANNEL_SESSION_LOG, SWITCH_CRYPTO_MKI_INDEX, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_RTP_FLAG_SECURE_SEND_MKI, SWITCH_RTP_FLAG_SECURE_SEND_RESET, SWITCH_RTP_MAX_BUF_LEN, switch_rtp_ready(), switch_socket_sendto(), SWITCH_STATUS_FALSE, SWITCH_STATUS_NOT_INITALIZED, WRITE_DEC, WRITE_INC, and switch_rtp::write_msg.

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) {
#ifdef ENABLE_SRTP
                switch_mutex_lock(rtp_session->ice_mutex);
                if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {

                        int sbytes = (int) *bytes;
                        srtp_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 (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;
                                        switch_mutex_unlock(rtp_session->ice_mutex);
                                        goto end;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "RE-Activating Secure RTP SEND\n");
                                }
                        }

                        if (!rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_MKI]) {
                                stat = srtp_protect(rtp_session->send_ctx[rtp_session->srtp_idx_rtp], &rtp_session->write_msg, &sbytes);
                        } else {
                                stat = srtp_protect_mki(rtp_session->send_ctx[rtp_session->srtp_idx_rtp], &rtp_session->write_msg, &sbytes, 1, SWITCH_CRYPTO_MKI_INDEX);
                        }

                        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;
                }
                switch_mutex_unlock(rtp_session->ice_mutex);
#endif
        }

        status = switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, data, bytes);
#if defined(ENABLE_SRTP)
 end:
#endif

        WRITE_DEC(rtp_session);

        return status;
}

switch_rtp_zerocopy_read()

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 8247 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_rtp_zerocopy_read_frame()

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 8195 of file switch_rtp.c.

References switch_frame::data, switch_frame::datalen, switch_frame::flags, switch_rtp::flags, switch_rtp::last_rtp_hdr, switch_frame::m, switch_frame::packet, switch_frame::packetlen, switch_frame::payload, switch_frame::pmap, switch_rtp::recv_msg, switch_rtp::recv_te, RTP_BODY, rtp_common_read(), rtp_header_len, switch_frame::seq, SFF_CNG, SFF_EXTERNAL, SFF_RAW_RTP, SFF_RFC2833, switch_frame::source, switch_frame::ssrc, SWITCH_FALSE, 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, and switch_frame::timestamp.

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);
                switch_set_flag(frame, SFF_EXTERNAL);
                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;
        }


        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;
}