RTP (RealTime Transport Protocol)
[Core Library]

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.
void	switch_rtp_shutdown (void)
switch_port_t	switch_rtp_set_start_port (switch_port_t port)
	Set/Get RTP start port.
switch_port_t	switch_rtp_set_end_port (switch_port_t port)
	Set/Get RTP end port.
switch_port_t	switch_rtp_request_port (const char *ip)
	Request a new port to be used for media.
void	switch_rtp_release_port (const char *ip, switch_port_t port)
switch_status_t	switch_rtp_create (switch_rtp_t **new_rtp_session, switch_payload_t payload, uint32_t samples_per_interval, uint32_t ms_per_packet, switch_rtp_flag_t flags, char *timer_name, const char **err, switch_memory_pool_t *pool)
	create a new RTP session handle
switch_rtp_t *	switch_rtp_new (const char *rx_host, switch_port_t rx_port, const char *tx_host, switch_port_t tx_port, switch_payload_t payload, uint32_t samples_per_interval, uint32_t ms_per_packet, switch_rtp_flag_t flags, char *timer_name, const char **err, switch_memory_pool_t *pool)
	prepare a new RTP session handle and fully initilize it
switch_status_t	switch_rtp_set_remote_address (switch_rtp_t *rtp_session, const char *host, switch_port_t port, switch_bool_t change_adv_addr, const char **err)
	Assign a remote address to the 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_set_max_missed_packets (switch_rtp_t *rtp_session, uint32_t max)
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.
void	switch_rtp_kill_socket (switch_rtp_t *rtp_session)
	Kill the socket on an existing RTP session.
void	switch_rtp_break (switch_rtp_t *rtp_session)
uint8_t	switch_rtp_ready (switch_rtp_t *rtp_session)
	Test if an RTP session is ready.
void	switch_rtp_destroy (switch_rtp_t **rtp_session)
	Destroy an RTP session.
switch_status_t	switch_rtp_activate_ice (switch_rtp_t *rtp_session, char *login, char *rlogin)
	Acvite ICE on an RTP session.
switch_status_t	switch_rtp_activate_jitter_buffer (switch_rtp_t *rtp_session, uint32_t queue_frames)
	Acvite a jitter buffer on an RTP session.
void	switch_rtp_set_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flags)
	Set an RTP Flag.
uint32_t	switch_rtp_test_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flags)
	Test an RTP Flag.
void	switch_rtp_clear_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flags)
	Clear an RTP Flag.
switch_socket_t *	switch_rtp_get_rtp_socket (switch_rtp_t *rtp_session)
	Retrieve the socket from an existing RTP session.
void	switch_rtp_set_default_samples_per_interval (switch_rtp_t *rtp_session, uint16_t samples_per_interval)
	Set the default samples per interval for a given 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.
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.
uint32_t	switch_rtp_get_default_payload (switch_rtp_t *rtp_session)
	Get the default payload number for a given RTP session.
void	switch_rtp_set_invald_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.
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.
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.
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.
switch_size_t	switch_rtp_has_dtmf (switch_rtp_t *rtp_session)
	Test for presence of DTMF on a given RTP session.
switch_size_t	switch_rtp_dequeue_dtmf (switch_rtp_t *rtp_session, switch_dtmf_t *dtmf)
	Retrieve DTMF digits from a given RTP session.
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.
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.
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.
switch_status_t	switch_rtp_disable_vad (switch_rtp_t *rtp_session)
	Disable VAD on an RTP Session.
int	switch_rtp_write_frame (switch_rtp_t *rtp_session, switch_frame_t *frame)
	Write data to a given RTP session.
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.
uint32_t	switch_rtp_get_ssrc (switch_rtp_t *rtp_session)
	Retrieve the SSRC from a given RTP session.
void	switch_rtp_set_private (switch_rtp_t *rtp_session, void *private_data)
	Associate an arbitrary data pointer with and RTP session.
void	switch_rtp_set_telephony_event (switch_rtp_t *rtp_session, switch_payload_t te)
	Set the payload type to consider RFC2833 DTMF.
void	switch_rtp_set_cng_pt (switch_rtp_t *rtp_session, switch_payload_t pt)
	Set the payload type for comfort noise.
void *	switch_rtp_get_private (switch_rtp_t *rtp_session)
	Retrieve the private data from a given RTP session.
switch_status_t	switch_rtp_activate_stun_ping (switch_rtp_t *rtp_session, const char *stun_ip, switch_port_t stun_port, uint32_t packet_count, switch_bool_t funny)

---

Typedef Documentation

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

---

Function Documentation

switch_status_t switch_rtp_activate_ice (  switch_rtp_t *  rtp_session, char *  login, char *  rlogin )

Acvite ICE on an RTP session. Returns: SWITCH_STATUS_SUCCESS { char ice_user[80]; char user_ice[80]; switch_snprintf(ice_user, sizeof(ice_user), "%s%s", login, rlogin); switch_snprintf(user_ice, sizeof(user_ice), "%s%s", rlogin, login); rtp_session->ice_user = switch_core_strdup(rtp_session->pool, ice_user); rtp_session->user_ice = switch_core_strdup(rtp_session->pool, user_ice); rtp_session->default_stuncount = 25; if (rtp_session->ice_user) { if (ice_out(rtp_session) != SWITCH_STATUS_SUCCESS) { return -1; } } return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

switch_status_t switch_rtp_activate_jitter_buffer (  switch_rtp_t *  rtp_session, uint32_t  queue_frames )

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 { rtp_session->jb = stfu_n_init(queue_frames); return SWITCH_STATUS_SUCCESS; }

switch_status_t switch_rtp_activate_stun_ping (  switch_rtp_t *  rtp_session, const char *  stun_ip, switch_port_t  stun_port, uint32_t  packet_count, switch_bool_t  funny )

{ if (switch_sockaddr_info_get(&rtp_session->remote_stun_addr, stun_ip, SWITCH_UNSPEC, stun_port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !rtp_session->remote_stun_addr) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error resolving stun ping addr\n"); return SWITCH_STATUS_FALSE; } if (funny) { rtp_session->funny_stun++; } rtp_session->stun_port = stun_port; rtp_session->default_stuncount = packet_count; rtp_session->stun_ip = switch_core_strdup(rtp_session->pool, stun_ip); return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

void switch_rtp_break (  switch_rtp_t *  rtp_session  )

{ int o = 42; switch_size_t len = sizeof(o); switch_assert(rtp_session != NULL); switch_mutex_lock(rtp_session->flag_mutex); if (rtp_session->sock_input) { switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_BREAK); switch_socket_sendto(rtp_session->sock_input, rtp_session->local_addr, 0, (void *) &o, &len); } switch_mutex_unlock(rtp_session->flag_mutex); }

Here is the call graph for this function:

void switch_rtp_clear_flag (  switch_rtp_t *  rtp_session, switch_rtp_flag_t  flags )

Clear an RTP Flag. Parameters: rtp_session  the RTP session flags  the flags to clear { switch_clear_flag_locked(rtp_session, flags); }

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

create a new RTP session handle Parameters: new_rtp_session  a poiter to aim at the new session payload  the IANA payload number samples_per_interval  the default samples_per_interval ms_per_packet  time in microseconds per packet flags  flags to control behaviour timer_name  timer interface to use err  a pointer to resolve error messages pool  a memory pool to use for the session Returns: the new RTP session or NULL on failure { switch_rtp_t *rtp_session = NULL; *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 = 101; 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->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_flag(rtp_session, flags); /* for from address on recvfrom calls */ switch_sockaddr_info_get(&rtp_session->from_addr, NULL, SWITCH_UNSPEC, 0, 0, pool); rtp_session->seq = (uint16_t) rand(); rtp_session->ssrc = (uint32_t) ((intptr_t) &rtp_session + (uint32_t) switch_timestamp(NULL)); 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->ms_per_packet = ms_per_packet; rtp_session->samples_per_interval = rtp_session->conf_samples_per_interval = samples_per_interval; if (timer_name && !strcasecmp(timer_name, "none")) { timer_name = NULL; } if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER) && switch_strlen_zero(timer_name)) { timer_name = "soft"; } if (!switch_strlen_zero(timer_name)) { rtp_session->timer_name = switch_core_strdup(pool, timer_name); switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_USE_TIMER); switch_set_flag_locked(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_LOG, SWITCH_LOG_DEBUG, "Starting timer [%s] %d bytes per %dms\n", timer_name, samples_per_interval, ms_per_packet); } else { memset(&rtp_session->timer, 0, sizeof(rtp_session->timer)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error starting timer [%s], async RTP disabled\n", timer_name); switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_USE_TIMER); } } else { switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_USE_TIMER); switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_NOBLOCK); } rtp_session->ready = 1; *new_rtp_session = rtp_session; return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

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 { 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; bytes++; } switch_mutex_unlock(rtp_session->dtmf_data.dtmf_mutex); return bytes; }

Here is the call graph for this function:

void switch_rtp_destroy (  switch_rtp_t **  rtp_session  )

Destroy an RTP session. Parameters: rtp_session  an RTP session to destroy { void *pop; switch_socket_t *sock; if (!rtp_session || !*rtp_session || !(*rtp_session)->ready) { return; } switch_set_flag_locked((*rtp_session), SWITCH_RTP_FLAG_SHUTDOWN); READ_INC((*rtp_session)); WRITE_INC((*rtp_session)); (*rtp_session)->ready = 0; READ_DEC((*rtp_session)); WRITE_DEC((*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) { stfu_n_destroy(&(*rtp_session)->jb); } 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 (switch_test_flag((*rtp_session), SWITCH_RTP_FLAG_VAD)) { switch_rtp_disable_vad(*rtp_session); } if (switch_test_flag((*rtp_session), SWITCH_RTP_FLAG_SECURE_SEND)) { srtp_dealloc((*rtp_session)->send_ctx); (*rtp_session)->send_ctx = NULL; switch_clear_flag((*rtp_session), SWITCH_RTP_FLAG_SECURE_SEND); } if (switch_test_flag((*rtp_session), SWITCH_RTP_FLAG_SECURE_RECV)) { srtp_dealloc((*rtp_session)->recv_ctx); (*rtp_session)->recv_ctx = NULL; switch_clear_flag((*rtp_session), SWITCH_RTP_FLAG_SECURE_RECV); } if ((*rtp_session)->timer.timer_interface) { switch_core_timer_destroy(&(*rtp_session)->timer); } switch_rtp_release_port((*rtp_session)->rx_host, (*rtp_session)->rx_port); switch_mutex_unlock((*rtp_session)->flag_mutex); return; }

Here is the call graph for this function:

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 { if (!switch_rtp_ready(rtp_session)) { return SWITCH_STATUS_FALSE; } if (!switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VAD)) { return SWITCH_STATUS_GENERR; } switch_core_codec_destroy(&rtp_session->vad_data.vad_codec); switch_clear_flag_locked(rtp_session, SWITCH_RTP_FLAG_VAD); return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

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 { if (!switch_rtp_ready(rtp_session)) { return SWITCH_STATUS_FALSE; } if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_VAD)) { return SWITCH_STATUS_GENERR; } memset(&rtp_session->vad_data, 0, sizeof(rtp_session->vad_data)); if (switch_core_codec_init(&rtp_session->vad_data.vad_codec, codec->implementation->iananame, NULL, codec->implementation->samples_per_second, codec->implementation->microseconds_per_frame / 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_LOG, SWITCH_LOG_ERROR, "Can't load codec?\n"); return SWITCH_STATUS_FALSE; } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Activate VAD codec %s %dms\n", codec->implementation->iananame, codec->implementation->microseconds_per_frame / 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_timestamp(NULL); rtp_session->vad_data.scan_freq = 0; switch_set_flag_locked(rtp_session, SWITCH_RTP_FLAG_VAD); switch_set_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_CNG); return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

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 { return rtp_session->payload; }

uint32_t switch_rtp_get_default_samples_per_interval (  switch_rtp_t *  rtp_session  )

Get the default samples per interval for a given RTP session. Parameters: rtp_session  the RTP session to get the samples per interval from Returns: the default samples per interval of the RTP session { return rtp_session->samples_per_interval; }

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 { return rtp_session->private_data; }

void switch_rtp_get_random (  void *  buf, uint32_t  len )

{ crypto_get_random(buf, len); }

char* switch_rtp_get_remote_host (  switch_rtp_t *  rtp_session  )

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

switch_port_t switch_rtp_get_remote_port (  switch_rtp_t *  rtp_session  )

{ return rtp_session->remote_port; }

switch_socket_t* switch_rtp_get_rtp_socket (  switch_rtp_t *  rtp_session  )

Retrieve the socket from an existing RTP session. Parameters: rtp_session  the RTP session to retrieve the socket from Returns: the socket from the RTP session { return rtp_session->sock_input; }

uint32_t switch_rtp_get_ssrc (  switch_rtp_t *  rtp_session  )

Retrieve the SSRC from a given RTP session. Parameters: rtp_session  the RTP session to retrieve from Returns: the SSRC { return rtp_session->send_msg.header.ssrc; }

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

Here is the call graph for this function:

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 { if (global_init) { return; } switch_core_hash_init(&alloc_hash, pool); srtp_init(); switch_mutex_init(&port_lock, SWITCH_MUTEX_NESTED, pool); global_init = 1; }

Here is the call graph for this function:

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 { switch_assert(rtp_session != NULL); switch_mutex_lock(rtp_session->flag_mutex); if (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_IO)) { switch_clear_flag(rtp_session, SWITCH_RTP_FLAG_IO); if (rtp_session->sock_input) { 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); } } switch_mutex_unlock(rtp_session->flag_mutex); }

Here is the call graph for this function:

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

prepare a new RTP session handle and fully initilize it Parameters: rx_host  the local address rx_port  the local port tx_host  the remote address tx_port  the remote port payload  the IANA payload number samples_per_interval  the default samples_per_interval ms_per_packet  time in microseconds per packet flags  flags to control behaviour timer_name  timer interface to use err  a pointer to resolve error messages pool  a memory pool to use for the session Returns: the new RTP session or NULL on failure { switch_rtp_t *rtp_session = NULL; if (switch_strlen_zero(rx_host)) { *err = "Missing local host"; goto end; } if (!rx_port) { *err = "Missing local port"; goto end; } if (switch_strlen_zero(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, 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; } else { switch_rtp_release_port(rx_host, rx_port); } return rtp_session; }

Here is the call graph for this function:

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 { 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_default_dtmf_duration(0)) { rdigit->duration = switch_core_default_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; }

Here is the call graph for this function:

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 { 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_default_dtmf_duration(0)) { rdigit->duration = switch_core_default_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; }

Here is the call graph for this function:

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 { int bytes = 0; if (!switch_rtp_ready(rtp_session)) { return SWITCH_STATUS_FALSE; } bytes = rtp_common_read(rtp_session, payload_type, 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 { bytes -= rtp_header_len; } *datalen = bytes; memcpy(data, rtp_session->recv_msg.body, bytes); return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

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 { uint8_t ret; if (!rtp_session || !rtp_session->flag_mutex || switch_test_flag(rtp_session, SWITCH_RTP_FLAG_SHUTDOWN)) { return 0; } switch_mutex_lock(rtp_session->flag_mutex); ret = (switch_test_flag(rtp_session, 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; }

Here is the call graph for this function:

void switch_rtp_release_port (  const char *  ip, switch_port_t  port )

{ switch_core_port_allocator_t *alloc = NULL; if (!ip) { 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); }

Here is the call graph for this function:

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 { switch_port_t port = 0; switch_core_port_allocator_t *alloc = NULL; switch_mutex_lock(port_lo