Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:47 2007

Asterisk developer's documentation :: Codename Pineapple

---

rtp.h File Reference

---

Detailed Description

Supports RTP and RTCP with Symmetric RTP support for NAT traversal.

RTP is defined in RFC 3550.

Definition in file rtp.h.

#include <netinet/in.h>
#include "asterisk/frame.h"
#include "asterisk/io.h"
#include "asterisk/sched.h"
#include "asterisk/channel.h"
#include "asterisk/linkedlists.h"

Include dependency graph for rtp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ast_rtp_protocol
	This is the structure that binds a channel (SIP/Jingle/H.323) to the RTP subsystem. More...
Defines
#define	AST_RTP_CISCO_DTMF   (1 << 2)
#define	AST_RTP_CN   (1 << 1)
#define	AST_RTP_DTMF   (1 << 0)
#define	AST_RTP_MAX   AST_RTP_CISCO_DTMF
#define	FLAG_3389_WARNING   (1 << 0)
#define	MAX_RTP_PT   256
Typedefs
typedef int(*	ast_rtp_callback )(struct ast_rtp *rtp, struct ast_frame *f, void *data)
Enumerations
enum	ast_rtp_get_result { AST_RTP_GET_FAILED = 0, AST_RTP_TRY_PARTIAL, AST_RTP_TRY_NATIVE }
enum	ast_rtp_options { AST_RTP_OPT_G726_NONSTANDARD = (1 << 0) }
Functions
int	ast_rtcp_fd (struct ast_rtp *rtp)
ast_frame *	ast_rtcp_read (struct ast_rtp *rtp)
int	ast_rtcp_send_h261fur (void *data)
	Send an H.261 fast update request. Some devices need this rather than the XML message in SIP.
size_t	ast_rtp_alloc_size (void)
	Get the amount of space required to hold an RTP session.
int	ast_rtp_bridge (struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
	The RTP bridge.
int	ast_rtp_codec_getformat (int pt)
ast_codec_pref *	ast_rtp_codec_getpref (struct ast_rtp *rtp)
int	ast_rtp_codec_setpref (struct ast_rtp *rtp, struct ast_codec_pref *prefs)
void	ast_rtp_destroy (struct ast_rtp *rtp)
int	ast_rtp_early_bridge (struct ast_channel *c0, struct ast_channel *c1)
	If possible, create an early bridge directly between the devices without having to send a re-invite later.
int	ast_rtp_fd (struct ast_rtp *rtp)
ast_rtp *	ast_rtp_get_bridged (struct ast_rtp *rtp)
void	ast_rtp_get_current_formats (struct ast_rtp *rtp, int *astFormats, int *nonAstFormats)
	Return the union of all of the codecs that were set by rtp_set...() calls They're returned as two distinct sets: AST_FORMATs, and AST_RTPs.
int	ast_rtp_get_peer (struct ast_rtp *rtp, struct sockaddr_in *them)
char *	ast_rtp_get_quality (struct ast_rtp *rtp)
int	ast_rtp_get_rtpholdtimeout (struct ast_rtp *rtp)
	Get rtp hold timeout.
int	ast_rtp_get_rtpkeepalive (struct ast_rtp *rtp)
	Get RTP keepalive interval.
int	ast_rtp_get_rtptimeout (struct ast_rtp *rtp)
	Get rtp timeout.
void	ast_rtp_get_us (struct ast_rtp *rtp, struct sockaddr_in *us)
int	ast_rtp_getnat (struct ast_rtp *rtp)
void	ast_rtp_init (void)
	Return RTCP quality string.
int	ast_rtp_lookup_code (struct ast_rtp *rtp, int isAstFormat, int code)
	Looks up an RTP code out of our *static* outbound list.
char *	ast_rtp_lookup_mime_multiple (char *buf, size_t size, const int capability, const int isAstFormat, enum ast_rtp_options options)
	Build a string of MIME subtype names from a capability list.
const char *	ast_rtp_lookup_mime_subtype (int isAstFormat, int code, enum ast_rtp_options options)
	Mapping an Asterisk code into a MIME subtype (string):.
rtpPayloadType	ast_rtp_lookup_pt (struct ast_rtp *rtp, int pt)
	Mapping between RTP payload format codes and Asterisk codes:.
int	ast_rtp_make_compatible (struct ast_channel *dest, struct ast_channel *src, int media)
ast_rtp *	ast_rtp_new (struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
	Initializate a RTP session.
void	ast_rtp_new_init (struct ast_rtp *rtp)
	Initialize a new RTP structure.
ast_rtp *	ast_rtp_new_with_bindaddr (struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr in)
	Initializate a RTP session using an in_addr structure.
int	ast_rtp_proto_register (struct ast_rtp_protocol *proto)
	Register an RTP channel client.
void	ast_rtp_proto_unregister (struct ast_rtp_protocol *proto)
	Unregister an RTP channel client.
void	ast_rtp_pt_clear (struct ast_rtp *rtp)
	Setting RTP payload types from lines in a SDP description:.
void	ast_rtp_pt_copy (struct ast_rtp *dest, struct ast_rtp *src)
	Copy payload types between RTP structures.
void	ast_rtp_pt_default (struct ast_rtp *rtp)
	Set payload types to defaults.
ast_frame *	ast_rtp_read (struct ast_rtp *rtp)
int	ast_rtp_reload (void)
void	ast_rtp_reset (struct ast_rtp *rtp)
int	ast_rtp_sendcng (struct ast_rtp *rtp, int level)
	generate comfort noice (CNG)
int	ast_rtp_senddigit_begin (struct ast_rtp *rtp, char digit)
	Send begin frames for DTMF.
int	ast_rtp_senddigit_end (struct ast_rtp *rtp, char digit)
void	ast_rtp_set_callback (struct ast_rtp *rtp, ast_rtp_callback callback)
void	ast_rtp_set_data (struct ast_rtp *rtp, void *data)
void	ast_rtp_set_m_type (struct ast_rtp *rtp, int pt)
	Make a note of a RTP payload type that was seen in a SDP "m=" line. By default, use the well-known value for this type (although it may still be set to a different value by a subsequent "a=rtpmap:" line).
void	ast_rtp_set_peer (struct ast_rtp *rtp, struct sockaddr_in *them)
void	ast_rtp_set_rtpholdtimeout (struct ast_rtp *rtp, int timeout)
	Set rtp hold timeout.
void	ast_rtp_set_rtpkeepalive (struct ast_rtp *rtp, int period)
	set RTP keepalive interval
void	ast_rtp_set_rtpmap_type (struct ast_rtp *rtp, int pt, char *mimeType, char *mimeSubtype, enum ast_rtp_options options)
	Make a note of a RTP payload type (with MIME type) that was seen in an SDP "a=rtpmap:" line.
void	ast_rtp_set_rtptimeout (struct ast_rtp *rtp, int timeout)
	Set rtp timeout.
void	ast_rtp_set_rtptimers_onhold (struct ast_rtp *rtp)
void	ast_rtp_setdtmf (struct ast_rtp *rtp, int dtmf)
	Indicate whether this RTP session is carrying DTMF or not.
void	ast_rtp_setdtmfcompensate (struct ast_rtp *rtp, int compensate)
	Compensate for devices that send RFC2833 packets all at once.
void	ast_rtp_setnat (struct ast_rtp *rtp, int nat)
void	ast_rtp_setstun (struct ast_rtp *rtp, int stun_enable)
	Enable STUN capability.
int	ast_rtp_settos (struct ast_rtp *rtp, int tos)
void	ast_rtp_stop (struct ast_rtp *rtp)
void	ast_rtp_stun_request (struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
	Send STUN request (??).
int	ast_rtp_write (struct ast_rtp *rtp, struct ast_frame *f)

---

Define Documentation

#define AST_RTP_CISCO_DTMF   (1 << 2)

DTMF (Cisco Proprietary) Definition at line 47 of file rtp.h. Referenced by ast_rtp_read().

#define AST_RTP_CN   (1 << 1)

'Comfort Noise' (RFC3389) Definition at line 45 of file rtp.h. Referenced by ast_rtp_read(), and ast_rtp_sendcng().

#define AST_RTP_DTMF   (1 << 0)

DTMF (RFC2833) Definition at line 43 of file rtp.h. Referenced by add_noncodec_to_sdp(), ast_rtp_read(), ast_rtp_senddigit_begin(), bridge_p2p_rtp_write(), check_peer_ok(), check_user_full(), check_user_ok(), create_addr(), create_addr_from_peer(), oh323_alloc(), oh323_request(), and sip_alloc().

#define AST_RTP_MAX   AST_RTP_CISCO_DTMF

Maximum RTP-specific code Definition at line 49 of file rtp.h. Referenced by ast_rtp_lookup_mime_multiple().

#define FLAG_3389_WARNING   (1 << 0)

Definition at line 54 of file rtp.h.

#define MAX_RTP_PT   256

Maxmum number of payload defintions for a RTP session Definition at line 52 of file rtp.h. Referenced by ast_rtp_codec_getformat(), ast_rtp_get_current_formats(), ast_rtp_pt_clear(), ast_rtp_pt_copy(), ast_rtp_pt_default(), ast_rtp_set_m_type(), and ast_rtp_set_rtpmap_type().

---

Typedef Documentation

typedef int(* ast_rtp_callback)(struct ast_rtp *rtp, struct ast_frame *f, void *data)

RTP callback structure Definition at line 87 of file rtp.h.

---

Enumeration Type Documentation

enum ast_rtp_get_result

Enumerator: AST_RTP_GET_FAILED  Failed to find the RTP structure AST_RTP_TRY_PARTIAL  RTP structure exists but true native bridge can not occur so try partial AST_RTP_TRY_NATIVE  RTP structure exists and native bridge can occur Definition at line 60 of file rtp.h. { /*! Failed to find the RTP structure */ AST_RTP_GET_FAILED = 0, /*! RTP structure exists but true native bridge can not occur so try partial */ AST_RTP_TRY_PARTIAL, /*! RTP structure exists and native bridge can occur */ AST_RTP_TRY_NATIVE, };

enum ast_rtp_options

Enumerator: AST_RTP_OPT_G726_NONSTANDARD  Definition at line 56 of file rtp.h. { AST_RTP_OPT_G726_NONSTANDARD = (1 << 0), };

---

Function Documentation

int ast_rtcp_fd (  struct ast_rtp *  rtp  )

Definition at line 519 of file rtp.c. References ast_rtp::rtcp, and ast_rtcp::s. Referenced by __oh323_new(), __oh323_rtp_create(), __oh323_update_info(), gtalk_new(), jingle_new(), sip_new(), and start_rtp(). { if (rtp->rtcp) return rtp->rtcp->s; return -1; }

struct ast_frame* ast_rtcp_read (  struct ast_rtp *  rtp  )

Definition at line 888 of file rtp.c. References ast_rtcp::accumulated_transit, AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, AST_FRIENDLY_OFFSET, ast_inet_ntoa(), ast_log(), ast_null_frame, ast_verbose(), CRASH, ast_frame::datalen, ast_rtp::f, ast_frame::frametype, len, LOG_DEBUG, LOG_WARNING, ast_frame::mallocd, ast_rtcp::maxrtt, ast_rtcp::minrtt, ast_rtp::nat, option_debug, ast_rtcp::reported_jitter, ast_rtcp::reported_lost, ast_rtp::rtcp, rtcp_debug_test_addr(), RTCP_PT_BYE, RTCP_PT_FUR, RTCP_PT_RR, RTCP_PT_SDES, RTCP_PT_SR, ast_rtcp::rtt, ast_rtcp::rxlsr, ast_rtcp::s, ast_frame::samples, ast_rtcp::soc, ast_rtcp::spc, ast_frame::src, ast_frame::subclass, ast_rtcp::them, ast_rtcp::themrxlsr, and timeval2ntp(). Referenced by oh323_read(), sip_rtp_read(), and skinny_rtp_read(). { socklen_t len; int position, i, packetwords; int res; struct sockaddr_in sin; unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET]; unsigned int *rtcpheader; int pt; struct timeval now; unsigned int length; int rc; double rtt = 0; double a; double dlsr; double lsr; unsigned int msw; unsigned int lsw; unsigned int comp; struct ast_frame *f = &ast_null_frame; if (!rtp || !rtp->rtcp) return &ast_null_frame; len = sizeof(sin); res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len); rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET); if (res < 0) { if (errno != EAGAIN) ast_log(LOG_WARNING, "RTCP Read error: %s\n", strerror(errno)); if (errno == EBADF) CRASH; return &ast_null_frame; } packetwords = res / 4; if (rtp->nat) { /* Send to whoever sent to us */ if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) || (rtp->rtcp->them.sin_port != sin.sin_port)) { memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them)); if (option_debug || rtpdebug) ast_log(LOG_DEBUG, "RTCP NAT: Got RTCP from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); } } if (option_debug) ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res); /* Process a compound packet */ position = 0; while (position < packetwords) { i = position; length = ntohl(rtcpheader[i]); pt = (length & 0xff0000) >> 16; rc = (length & 0x1f000000) >> 24; length &= 0xffff; if ((i + length) > packetwords) { ast_log(LOG_WARNING, "RTCP Read too short\n"); return &ast_null_frame; } if (rtcp_debug_test_addr(&sin)) { ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)); ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown"); ast_verbose("Reception reports: %d\n", rc); ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]); } i += 2; /* Advance past header and ssrc */ switch (pt) { case RTCP_PT_SR: gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */ rtp->rtcp->spc = ntohl(rtcpheader[i+3]); rtp->rtcp->soc = ntohl(rtcpheader[i + 4]); rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff) >> 16); /* Going to LSR in RR*/ if (rtcp_debug_test_addr(&sin)) { ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096); ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2])); ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4])); } i += 5; if (rc < 1) break; /* Intentional fall through */ case RTCP_PT_RR: /* This is the place to calculate RTT */ /* Don't handle multiple reception reports (rc > 1) yet */ gettimeofday(&now, NULL); timeval2ntp(now, &msw, &lsw); /* Use the one we sent them in our SR instead, rtcp->txlsr could have been rewritten if the dlsr is large */ if (ntohl(rtcpheader[i + 4])) { /* We must have the LSR */ comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16); a = (double)((comp & 0xffff0000) >> 16) + (double)((double)(comp & 0xffff)/1000000.); lsr = (double)((ntohl(rtcpheader[i + 4]) & 0xffff0000) >> 16) + (double)((double)(ntohl(rtcpheader[i + 4]) & 0xffff) / 1000000.); dlsr = (double)(ntohl(rtcpheader[i + 5])/65536.); rtt = a - dlsr - lsr; rtp->rtcp->accumulated_transit += rtt; rtp->rtcp->rtt = rtt; if (rtp->rtcp->maxrtt<rtt) rtp->rtcp->maxrtt = rtt; if (rtp->rtcp->minrtt>rtt) rtp->rtcp->minrtt = rtt; } rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]); rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff; if (rtcp_debug_test_addr(&sin)) { ast_verbose("Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24)); ast_verbose("Packets lost so far: %d\n", rtp->rtcp->reported_lost); ast_verbose("Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff)); ast_verbose("Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16); ast_verbose("Interarrival jitter: %u\n", rtp->rtcp->reported_jitter); ast_verbose("Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096); ast_verbose("DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0); if (rtt) ast_verbose("RTT: %f(sec)\n", rtt); } break; case RTCP_PT_FUR: if (rtcp_debug_test_addr(&sin)) ast_verbose("Received an RTCP Fast Update Request\n"); rtp->f.frametype = AST_FRAME_CONTROL; rtp->f.subclass = AST_CONTROL_VIDUPDATE; rtp->f.datalen = 0; rtp->f.samples = 0; rtp->f.mallocd = 0; rtp->f.src = "RTP"; f = &rtp->f; break; case RTCP_PT_SDES: if (rtcp_debug_test_addr(&sin)) ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); break; case RTCP_PT_BYE: if (rtcp_debug_test_addr(&sin)) ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); break; default: if (option_debug) ast_log(LOG_DEBUG, "Unknown RTCP packet (pt=%d) received from %s:%d\n", pt, ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); break; } position += (length + 1); } return f; }

int ast_rtcp_send_h261fur (  void *  data  )

Send an H.261 fast update request. Some devices need this rather than the XML message in SIP. Definition at line 2329 of file rtp.c. References ast_rtcp_write(), ast_rtp::rtcp, and ast_rtcp::sendfur. { struct ast_rtp *rtp = data; int res; rtp->rtcp->sendfur = 1; res = ast_rtcp_write(data); return res; }

size_t ast_rtp_alloc_size (  void   )

Get the amount of space required to hold an RTP session. Returns: number of bytes required Definition at line 399 of file rtp.c. Referenced by process_sdp(). { return sizeof(struct ast_rtp); }

int ast_rtp_bridge (  struct ast_channel *  c0, struct ast_channel *  c1, int  flags, struct ast_frame **  fo, struct ast_channel **  rc, int  timeoutms )

The RTP bridge. The Asterisk RTP bridge Definition at line 3259 of file rtp.c. References AST_BRIDGE_FAILED, AST_BRIDGE_FAILED_NOWARN, ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_log(), AST_RTP_GET_FAILED, AST_RTP_TRY_NATIVE, AST_RTP_TRY_PARTIAL, ast_set_flag, ast_test_flag, ast_verbose(), bridge_native_loop(), bridge_p2p_loop(), FLAG_HAS_DTMF, FLAG_P2P_NEED_DTMF, ast_rtp_protocol::get_codec, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, option_debug, option_verbose, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel_tech::send_digit_begin, ast_channel::tech, ast_channel::tech_pvt, and VERBOSE_PREFIX_3. { struct ast_rtp *p0 = NULL, *p1 = NULL; /* Audio RTP Channels */ struct ast_rtp *vp0 = NULL, *vp1 = NULL; /* Video RTP channels */ struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL; enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED; enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED; enum ast_bridge_result res = AST_BRIDGE_FAILED; int codec0 = 0, codec1 = 0; void *pvt0 = NULL, *pvt1 = NULL; /* Lock channels */ ast_channel_lock(c0); while (ast_channel_trylock(c1)) { ast_channel_unlock(c0); usleep(1); ast_channel_lock(c0); } /* Find channel driver interfaces */ if (!(pr0 = get_proto(c0))) { ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name); ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED; } if (!(pr1 = get_proto(c1))) { ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name); ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED; } /* Get channel specific interface structures */ pvt0 = c0->tech_pvt; pvt1 = c1->tech_pvt; /* Get audio and video interface (if native bridge is possible) */ audio_p0_res = pr0->get_rtp_info(c0, &p0); video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED; audio_p1_res = pr1->get_rtp_info(c1, &p1); video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED; /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */ if (video_p0_res != AST_RTP_GET_FAILED && (audio_p0_res != AST_RTP_TRY_NATIVE || video_p0_res != AST_RTP_TRY_NATIVE)) audio_p0_res = AST_RTP_GET_FAILED; if (video_p1_res != AST_RTP_GET_FAILED && (audio_p1_res != AST_RTP_TRY_NATIVE || video_p1_res != AST_RTP_TRY_NATIVE)) audio_p1_res = AST_RTP_GET_FAILED; /* Check if a bridge is possible (partial/native) */ if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) { /* Somebody doesn't want to play... */ ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED_NOWARN; } /* If we need to feed DTMF frames into the core then only do a partial native bridge */ if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) { ast_set_flag(p0, FLAG_P2P_NEED_DTMF); audio_p0_res = AST_RTP_TRY_PARTIAL; } if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) { ast_set_flag(p1, FLAG_P2P_NEED_DTMF); audio_p1_res = AST_RTP_TRY_PARTIAL; } /* If both sides are not using the same method of DTMF transmission * (ie: one is RFC2833, other is INFO... then we can not do direct media. * -------------------------------------------------- * | DTMF Mode | HAS_DTMF | Accepts Begin Frames | * |-----------|------------|-----------------------| * | Inband | False | True | * | RFC2833 | True | True | * | SIP INFO | False | False | * -------------------------------------------------- * However, if DTMF from both channels is being monitored by the core, then * we can still do packet-to-packet bridging, because passing through the * core will handle DTMF mode translation. */ if ( (ast_test_flag(p0, FLAG_HAS_DTMF) != ast_test_flag(p1, FLAG_HAS_DTMF)) || (!c0->tech->send_digit_begin != !c1->tech->send_digit_begin)) { if (!ast_test_flag(p0, FLAG_P2P_NEED_DTMF) || !ast_test_flag(p1, FLAG_P2P_NEED_DTMF)) { ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED_NOWARN; } audio_p0_res = AST_RTP_TRY_PARTIAL; audio_p1_res = AST_RTP_TRY_PARTIAL; } /* Get codecs from both sides */ codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0; codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0; if (codec0 && codec1 && !(codec0 & codec1)) { /* Hey, we can't do native bridging if both parties speak different codecs */ if (option_debug > 2) ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1); ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED_NOWARN; } /* If either side can only do a partial bridge, then don't try for a true native bridge */ if (audio_p0_res == AST_RTP_TRY_PARTIAL || audio_p1_res == AST_RTP_TRY_PARTIAL) { /* In order to do Packet2Packet bridging both sides must be in the same rawread/rawwrite */ if (c0->rawreadformat != c1->rawwriteformat || c1->rawreadformat != c0->rawwriteformat) { if (option_debug) ast_log(LOG_DEBUG, "Cannot packet2packet bridge - raw formats are incompatible\n"); ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED_NOWARN; } if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Packet2Packet bridging %s and %s\n", c0->name, c1->name); res = bridge_p2p_loop(c0, c1, p0, p1, timeoutms, flags, fo, rc, pvt0, pvt1); } else { if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name); res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1); } return res; }

int ast_rtp_codec_getformat (  int  pt  )

get format from predefined dynamic payload format Definition at line 2711 of file rtp.c. References rtpPayloadType::code, MAX_RTP_PT, and static_RTP_PT. { if (pt < 0 || pt > MAX_RTP_PT) return 0; /* bogus payload type */ if (static_RTP_PT[pt].isAstFormat) return static_RTP_PT[pt].code; else return 0; }

struct ast_codec_pref* ast_rtp_codec_getpref (  struct ast_rtp *  rtp  )

Get codec preference Definition at line 2706 of file rtp.c. References ast_rtp::pref. Referenced by add_codec_to_sdp(). { return &rtp->pref; }

int ast_rtp_codec_setpref (  struct ast_rtp *  rtp, struct ast_codec_pref *  prefs )

Set codec preference Definition at line 2693 of file rtp.c. References ast_codec_pref::framing, ast_codec_pref::order, ast_rtp::pref, and prefs. Referenced by __oh323_rtp_create(), check_peer_ok(), check_user_full(), check_user_ok(), create_addr_from_peer(), register_verify(), set_peer_capabilities(), start_rtp(), transmit_response_with_attachment(), and transmit_response_with_sdp(). { int x; for (x = 0; x < 32; x++) { /* Ugly way */ rtp->pref.order[x] = prefs->order[x]; rtp->pref.framing[x] = prefs->framing[x]; } if (rtp->smoother) ast_smoother_free(rtp->smoother); rtp->smoother = NULL; return 0; }

void ast_rtp_destroy (  struct ast_rtp *  rtp  )

Destroy RTP session Definition at line 2111 of file rtp.c. References ast_io_remove(), ast_mutex_destroy(), ast_sched_del(), ast_smoother_free(), ast_verbose(), ast_rtcp::expected_prior, free, ast_rtp::io, ast_rtp::ioid, ast_rtcp::received_prior, ast_rtcp::reported_jitter, ast_rtcp::reported_lost, ast_rtcp::rr_count, ast_rtp::rtcp, rtcp_debug_test_addr(), rtcpstats, ast_rtcp::rtt, ast_rtp::rxcount, ast_rtp::rxjitter, ast_rtp::rxtransit, ast_rtcp::s, ast_rtp::s, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::smoother, ast_rtcp::sr_count, ast_rtp::ssrc, ast_rtp::them, ast_rtp::themssrc, and ast_rtp::txcount. Referenced by __oh323_destroy(), __sip_destroy(), check_peer_ok(), check_user_full(), check_user_ok(), cleanup_connection(), create_addr_from_peer(), gtalk_free_pvt(), jingle_free_pvt(), mgcp_hangup(), oh323_alloc(), skinny_hangup(), start_rtp(), and unalloc_sub(). { if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) { /*Print some info on the call here */ ast_verbose(" RTP-stats\n"); ast_verbose("* Our Receiver:\n"); ast_verbose(" SSRC: %u\n", rtp->themssrc); ast_verbose(" Received packets: %u\n", rtp->rxcount); ast_verbose(" Lost packets: %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior); ast_verbose(" Jitter: %.4f\n", rtp->rxjitter); ast_verbose(" Transit: %.4f\n", rtp->rxtransit); ast_verbose(" RR-count: %u\n", rtp->rtcp->rr_count); ast_verbose("* Our Sender:\n"); ast_verbose(" SSRC: %u\n", rtp->ssrc); ast_verbose(" Sent packets: %u\n", rtp->txcount); ast_verbose(" Lost packets: %u\n", rtp->rtcp->reported_lost); ast_verbose(" Jitter: %u\n", rtp->rtcp->reported_jitter); ast_verbose(" SR-count: %u\n", rtp->rtcp->sr_count); ast_verbose(" RTT: %f\n", rtp->rtcp->rtt); } if (rtp->smoother) ast_smoother_free(rtp->smoother); if (rtp->ioid) ast_io_remove(rtp->io, rtp->ioid); if (rtp->s > -1) close(rtp->s); if (rtp->rtcp) { if (rtp->rtcp->schedid > 0) ast_sched_del(rtp->sched, rtp->rtcp->schedid); close(rtp->rtcp->s); free(rtp->rtcp); rtp->rtcp=NULL; } #ifdef P2P_INTENSE ast_mutex_destroy(&rtp->bridge_lock); #endif free(rtp); }

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

If possible, create an early bridge directly between the devices without having to send a re-invite later. Definition at line 1522 of file rtp.c. References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_log(), AST_RTP_GET_FAILED, AST_RTP_TRY_NATIVE, ast_test_flag, FLAG_NAT_ACTIVE, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, LOG_DEBUG, LOG_WARNING, option_debug, and ast_rtp_protocol::set_rtp_peer. { // dest = c0, src = c1 struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */ struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */ struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL; enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED; enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; int srccodec, nat_active = 0; /* Lock channels */ ast_channel_lock(c0); if (c1) { while (ast_channel_trylock(c1)) { ast_channel_unlock(c0); usleep(1); ast_channel_lock(c0); } } /* Find channel driver interfaces */ destpr = get_proto(c0); if (c1) srcpr = get_proto(c1); if (!destpr) { if (option_debug) ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c0->name); ast_channel_unlock(c0); if (c1) ast_channel_unlock(c1); return -1; } if (!srcpr) { if (option_debug) ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>"); ast_channel_unlock(c0); if (c1) ast_channel_unlock(c1); return -1; } /* Get audio and video interface (if native bridge is possible) */ audio_dest_res = destpr->get_rtp_info(c0, &destp); video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED; if (srcpr) { audio_src_res = srcpr->get_rtp_info(c1, &srcp); video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED; } /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */ if (audio_dest_res != AST_RTP_TRY_NATIVE) { /* Somebody doesn't want to play... */ ast_channel_unlock(c0); if (c1) ast_channel_unlock(c1); return -1; } if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec) srccodec = srcpr->get_codec(c1); else srccodec = 0; /* Consider empty media as non-existant */ if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr) srcp = NULL; if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE))) nat_active = 1; /* Bridge media early */ if (destpr->set_rtp_peer(c0, srcp, vsrcp, srccodec, nat_active)) ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>"); ast_channel_unlock(c0); if (c1) ast_channel_unlock(c1); if (option_debug) ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>"); return 0; }

int ast_rtp_fd (  struct ast_rtp *  rtp  )

Definition at line 514 of file rtp.c. References ast_rtp::s. Referenced by __oh323_new(), __oh323_rtp_create(), __oh323_update_info(), gtalk_new(), jingle_new(), mgcp_new(), p2p_callback_disable(), sip_new(), skinny_new(), and start_rtp(). { return rtp->s; }

struct ast_rtp* ast_rtp_get_bridged (  struct ast_rtp *  rtp  )

Definition at line 2045 of file rtp.c. References ast_rtp::bridged, rtp_bridge_lock(), and rtp_bridge_unlock(). Referenced by ast_rtp_read(), and check_rtp_timeout(). { struct ast_rtp *bridged = NULL; rtp_bridge_lock(rtp); bridged = rtp->bridged; rtp_bridge_unlock(rtp); return bridged; }

void ast_rtp_get_current_formats (  struct ast_rtp *  rtp, int *  astFormats, int *  nonAstFormats )

Return the union of all of the codecs that were set by rtp_set...() calls They're returned as two distinct sets: AST_FORMATs, and AST_RTPs. Definition at line 1711 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, and rtp_bridge_lock(). Referenced by process_sdp(). { int pt; rtp_bridge_lock(rtp); *astFormats = *nonAstFormats = 0; for (pt = 0; pt < MAX_RTP_PT; ++pt) { if (rtp->current_RTP_PT[pt].isAstFormat) { *astFormats |= rtp->current_RTP_PT[pt].code; } else { *nonAstFormats |= rtp->current_RTP_PT[pt].code; } } rtp_bridge_unlock(rtp); return; }

int ast_rtp_get_peer (  struct ast_rtp *  rtp, struct sockaddr_in *  them )

Definition at line 2027 of file rtp.c. References ast_rtp::them. Referenced by add_sdp(), bridge_native_loop(), check_rtp_timeout(), oh323_set_rtp_peer(), sip_set_rtp_peer(), and transmit_modify_with_sdp(). { if ((them->sin_family != AF_INET) || (them->sin_port != rtp->them.sin_port) || (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) { them->sin_family = AF_INET; them->sin_port = rtp->them.sin_port; them->sin_addr = rtp->them.sin_addr; return 1; } return 0; }

char* ast_rtp_get_quality (  struct ast_rtp *  rtp  )

Definition at line 2093 of file rtp.c. References ast_rtcp::expected_prior, ast_rtcp::quality, ast_rtcp::received_prior, ast_rtcp::reported_jitter, ast_rtcp::reported_lost, ast_rtp::rtcp, ast_rtcp::rtt, ast_rtp::rxcount, ast_rtp::rxjitter, ast_rtp::ssrc, ast_rtp::themssrc, and ast_rtp::txcount. Referenced by handle_request_bye(), and sip_hangup(). { /* *ssrc our ssrc *themssrc their ssrc *lp lost packets *rxjitter our calculated jitter(rx) *rxcount no. received packets *txjitter reported jitter of the other end *txcount transmitted packets *rlp remote lost packets */ snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality), "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f", rtp->ssrc, rtp->themssrc, rtp->rtcp->expected_prior - rtp->rtcp->received_prior, rtp->rxjitter, rtp->rxcount, (double)rtp->rtcp->reported_jitter/65536., rtp->txcount, rtp->rtcp->reported_lost, rtp->rtcp->rtt); return rtp->rtcp->quality; }

int ast_rtp_get_rtpholdtimeout (  struct ast_rtp *  rtp  )

Get rtp hold timeout. Definition at line 569 of file rtp.c. References ast_rtp::rtpholdtimeout, and ast_rtp::rtptimeout. Referenced by check_rtp_timeout(). { if (rtp->rtptimeout < 0) /* We're not checking, but remembering the setting (during T.38 transmission) */ return 0; return rtp->rtpholdtimeout; }

int ast_rtp_get_rtpkeepalive (  struct ast_rtp *  rtp  )

Get RTP keepalive interval. Definition at line 577 of file rtp.c. References ast_rtp::rtpkeepalive. Referenced by check_rtp_timeout(). { return rtp->rtpkeepalive; }

int ast_rtp_get_rtptimeout (  struct ast_rtp *  rtp  )

Get rtp timeout. Definition at line 561 of file rtp.c. References ast_rtp::rtptimeout. Referenced by check_rtp_timeout(). { if (rtp->rtptimeout < 0) /* We're not checking, but remembering the setting (during T.38 transmission) */ return 0; return rtp->rtptimeout; }

void ast_rtp_get_us (  struct ast_rtp *  rtp, struct sockaddr_in *  us )

Definition at line 2040 of file rtp.c. References ast_rtp::us. Referenced by add_sdp(), external_rtp_create(), get_our_media_address(), handle_open_receive_channel_ack_message(), and oh323_set_rtp_peer(). { *us = rtp->us; }

int ast_rtp_getnat (  struct ast_rtp *  rtp  )

Definition at line 597 of file rtp.c. References ast_test_flag, and FLAG_NAT_ACTIVE. Referenced by sip_get_rtp_peer(). { return ast_test_flag(rtp, FLAG_NAT_ACTIVE); }

void ast_rtp_init (  void   )

Return RTCP quality string. Definition at line 3664 of file rtp.c. References ast_cli_register_multiple(), ast_rtp_reload(), and cli_rtp. { ast_cli_register_multiple(cli_rtp, sizeof(cli_rtp) / sizeof(struct ast_cli_entry)); ast_rtp_reload(); }

int ast_rtp_lookup_code (  struct ast_rtp *  rtp, int  isAstFormat, int  code )

Looks up an RTP code out of our *static* outbound list. Definition at line 1754 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, rtp_bridge_lock(), rtp_bridge_unlock(), ast_rtp::rtp_lookup_code_cache_code, ast_rtp::rtp_lookup_code_cache_isAstFormat, and ast_rtp::rtp_lookup_code_cache_result. Referenced by add_codec_to_answer(), add_codec_to_sdp(), add_noncodec_to_sdp(), ast_rtp_sendcng(), ast_rtp_senddigit_begin(), ast_rtp_write(), and bridge_p2p_rtp_write(). { int pt = 0; rtp_bridge_lock(rtp); if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat && code == rtp->rtp_lookup_code_cache_code) { /* Use our cached mapping, to avoid the overhead of the loop below */ pt = rtp->rtp_lookup_code_cache_result; rtp_bridge_unlock(rtp); return pt; } /* Check the dynamic list first */ for (pt = 0; pt < MAX_RTP_PT; ++pt) { if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) { rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat; rtp->rtp_lookup_code_cache_code = code; rtp->rtp_lookup_code_cache_result = pt; rtp_bridge_unlock(rtp); return pt; } } /* Then the static list */ for (pt = 0; pt < MAX_RTP_PT; ++pt) { if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) { rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat; rtp->rtp_lookup_code_cache_code = code; rtp->rtp_lookup_code_cache_result = pt; rtp_bridge_unlock(rtp); return pt; } } rtp_bridge_unlock(rtp); return -1; }

char* ast_rtp_lookup_mime_multiple (  char *  buf, size_t  size, const int  capability, const int  isAstFormat, enum ast_rtp_options  options )

Build a string of MIME subtype names from a capability list. Definition at line 1814 of file rtp.c. References ast_rtp_lookup_mime_subtype(), AST_RTP_MAX, format, len, and name. { int format; unsigned len; char *end = buf; char *start = buf; if (!buf || !size) return NULL; snprintf(end, size, "0x%x (", capability); len = strlen(end); end += len; size -= len; start = end; for (format = 1; format < AST_RTP_MAX; format <<= 1) { if (capability & format) { const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options); snprintf(end, size, "%s|", name); len = strlen(end); end += len; size -= len; } } if (start == end) snprintf(start, size, "nothing)"); else if (size > 1) *(end -1) = ')'; return buf; }

const char* ast_rtp_lookup_mime_subtype (  int  isAstFormat, int  code, enum ast_rtp_options  options )

Mapping an Asterisk code into a MIME subtype (string):. Definition at line 1795 of file rtp.c. References AST_FORMAT_G726_AAL2, AST_RTP_OPT_G726_NONSTANDARD, rtpPayloadType::code, mimeTypes, and payloadType. Referenced by add_codec_to_sdp(), add_noncodec_to_sdp(), ast_rtp_lookup_mime_multiple(), transmit_connect_with_sdp(), and transmit_modify_with_sdp(). { unsigned int i; for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) { if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) { if (isAstFormat && (code == AST_FORMAT_G726_AAL2) && (options & AST_RTP_OPT_G726_NONSTANDARD)) return "G726-32"; else return mimeTypes[i].subtype; } } return ""; }

struct rtpPayloadType ast_rtp_lookup_pt (  struct ast_rtp *  rtp, int  pt )

Mapping between RTP payload format codes and Asterisk codes:. Definition at line 1732 of file rtp.c. Referenced by ast_rtp_read(), bridge_p2p_rtp_write(), and setup_rtp_connection(). { struct rtpPayloadType result; result.isAstFormat = result.code = 0; if (pt < 0 || pt > MAX_RTP_PT) return result; /* bogus payload type */ /* Start with negotiated codecs */ rtp_bridge_lock(rtp); result = rtp->current_RTP_PT[pt]; rtp_bridge_unlock(rtp); /* If it doesn't exist, check our static RTP type list, just in case */ if (!result.code) result = static_RTP_PT[pt]; return result; }

int ast_rtp_make_compatible (  struct ast_channel *  dest, struct ast_channel *  src, int  media )

Definition at line 1599 of file rtp.c. References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_log(), AST_RTP_GET_FAILED, ast_rtp_pt_copy(), AST_RTP_TRY_NATIVE, ast_test_flag, FLAG_NAT_ACTIVE, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, LOG_DEBUG, LOG_WARNING, option_debug, and ast_rtp_protocol::set_rtp_peer. { struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */ struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */ struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL; enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED; enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; int srccodec; /* Lock channels */ ast_channel_lock(dest); while (ast_channel_trylock(src)) { ast_channel_unlock(dest); usleep(1); ast_channel_lock(dest); } /* Find channel driver interfaces */ if (!(destpr = get_proto(dest))) { if (option_debug) ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name); ast_channel_unlock(dest); ast_channel_unlock(src); return 0; } if (!(srcpr = get_proto(src))) { if (option_debug) ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name); ast_channel_unlock(dest); ast_channel_unlock(src); return 0; } /* Get audio and video interface (if native bridge is possible) */ audio_dest_res = destpr->get_rtp_info(dest, &destp); video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED; audio_src_res = srcpr->get_rtp_info(src, &srcp); video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED; /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */ if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE) { /* Somebody doesn't want to play... */ ast_channel_unlock(dest); ast_channel_unlock(src); return 0; } ast_rtp_pt_copy(destp, srcp); if (vdestp && vsrcp) ast_rtp_pt_copy(vdestp, vsrcp); if (srcpr->get_codec) srccodec = srcpr->get_codec(src); else srccodec = 0; if (media) { /* Bridge early */ if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE))) ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name); } ast_channel_unlock(dest); ast_channel_unlock(src); if (option_debug) ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name); return 1; }

struct ast_rtp* ast_rtp_new (  struct sched_context *  sched, struct io_context *  io, int  rtcpenable, int  callbackmode )

Initializate a RTP session. Parameters: sched  io  rtcpenable  callbackmode  Returns: A representation (structure) of an RTP session. Definition at line 1999 of file rtp.c. References ast_rtp_new_with_bindaddr(), io, and sched. { struct in_addr ia; memset(&ia, 0, sizeof(ia)); return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia); }

void ast_rtp_new_init (  struct ast_rtp *  rtp  )

Initialize a new RTP structure. reload rtp configuration Definition at line 1896 of file rtp.c. References ast_mutex_init(), ast_random(), ast_set_flag, FLAG_HAS_DTMF, ast_rtp::seqno, ast_rtp::ssrc, ast_rtp::them, and ast_rtp::us. Referenced by ast_rtp_new_with_bindaddr(), and process_sdp(). { #ifdef P2P_INTENSE ast_mutex_init(&rtp->bridge_lock); #endif rtp->them.sin_family = AF_INET; rtp->us.sin_family = AF_INET; rtp->ssrc = ast_random(); rtp->seqno = ast_random() & 0xffff; ast_set_flag(rtp, FLAG_HAS_DTMF); return; }

struct ast_rtp* ast_rtp_new_with_bindaddr (  struct sched_context *  sched, struct io_context *  io, int  rtcpenable, int  callbackmode, struct in_addr  in )

Initializate a RTP session using an in_addr structure. This fuction gets called by ast_rtp_new(). Parameters: sched  io  rtcpenable  callbackmode  in  Returns: A representation (structure) of an RTP session. Definition at line 1911 of file rtp.c. References ast_calloc, ast_log(), ast_random(), ast_rtcp_new(), ast_rtp_new_init(), free, LOG_ERROR, rtp_socket(), rtpend, rtpstart, and sched. Referenced by __oh323_rtp_create(), ast_rtp_new(), dialog_activate_media(), gtalk_alloc(), jingle_alloc(), sip_alloc(), and start_rtp(). { struct ast_rtp *rtp; int x; int first; int startplace; if (!(rtp = ast_calloc(1, sizeof(*rtp)))) return NULL; ast_rtp_new_init(rtp); rtp->s = rtp_socket(); if (rtp->s < 0) { free(rtp); ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno)); return NULL; } if (sched && rtcpenable) { rtp->sched = sched; rtp->rtcp = ast_rtcp_new(); } /* Select a random port number in the range of possible RTP */ x = (ast_random() % (rtpend-rtpstart)) + rtpstart; x = x & ~1; /* Save it for future references. */ startplace = x; /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */ for (;;) { /* Must be an even port number by RTP spec */ rtp->us.sin_port = htons(x); rtp->us.sin_addr = addr; /* If there's rtcp, initialize it as well. */ if (rtp->rtcp) { rtp->rtcp->us.sin_port = htons(x + 1); rtp->rtcp->us.sin_addr = addr; } /* Try to bind it/them. */ if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) && (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us)))) break; if (!first) { /* Primary bind succeeded! Gotta recreate it */ close(rtp->s); rtp->s = rtp_socket(); } if (errno != EADDRINUSE) { /* We got an error that wasn't expected, abort! */ ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno)); close(rtp->s); if (rtp->rtcp) { close(rtp->rtcp->s); free(rtp->rtcp); } free(rtp); return NULL; } /* The port was used, increment it (by two). */ x += 2; /* Did we go over the limit ? */ if (x > rtpend) /* then, start from the begingig. */ x = (rtpstart + 1) & ~1; /* Check if we reached the place were we started. */ if (x == startplace) { /* If so, there's no ports available. */ ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n"); close(rtp->s); if (rtp->rtcp) { close(rtp->rtcp->s); free(rtp->rtcp); } free(rtp); return NULL; } } rtp->sched = sched; rtp->io = io; if (callbackmode) { rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp); ast_set_flag(rtp, FLAG_CALLBACK_MODE); } ast_rtp_pt_default(rtp); return rtp; }

int ast_rtp_proto_register (  struct ast_rtp_protocol *  proto  )

Register an RTP channel client. Definition at line 2809 of file rtp.c. References ast_log(), AST_RWLIST_INSERT_HEAD, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, LOG_WARNING, protos, and ast_rtp_protocol::type. Referenced by load_module(), and register_rtp_and_udptl(). { struct ast_rtp_protocol *cur; AST_RWLIST_WRLOCK(&protos); AST_RWLIST_TRAVERSE(&protos, cur, list) { if (!strcmp(cur->type, proto->type)) { ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type); AST_RWLIST_UNLOCK(&protos); return -1; } } AST_RWLIST_INSERT_HEAD(&protos, proto, list); AST_RWLIST_UNLOCK(&protos); return 0; }

void ast_rtp_proto_unregister (  struct ast_rtp_protocol *  proto  )

Unregister an RTP channel client. Definition at line 2801 of file rtp.c. References AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and protos. Referenced by load_module(), unload_module(), and unregister_rtp_and_udptl(). { AST_RWLIST_WRLOCK(&protos); AST_RWLIST_REMOVE(&protos, proto, list); AST_RWLIST_UNLOCK(&protos); }

void ast_rtp_pt_clear (  struct ast_rtp *  rtp  )

Setting RTP payload types from lines in a SDP description:. Definition at line 1446 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, and rtp_bridge_lock(). Referenced by process_sdp(). { int i; if (!rtp) return; rtp_bridge_lock(rtp); for (i = 0; i < MAX_RTP_PT; ++i) { rtp->current_RTP_PT[i].isAstFormat = 0; rtp->current_RTP_PT[i].code = 0; } rtp->rtp_lookup_code_cache_isAstFormat = 0; rtp->rtp_lookup_code_cache_code = 0; rtp->rtp_lookup_code_cache_result = 0; rtp_bridge_unlock(rtp); }

void ast_rtp_pt_copy (  struct ast_rtp *  dest, struct ast_rtp *  src )

Copy payload types between RTP structures. Definition at line 1486 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, and rtp_bridge_lock(). Referenced by ast_rtp_make_compatible(). { unsigned int i; rtp_bridge_lock(dest); rtp_bridge_lock(src); for (i=0; i < MAX_RTP_PT; ++i) { dest->current_RTP_PT[i].isAstFormat = src->current_RTP_PT[i].isAstFormat; dest->current_RTP_PT[i].code = src->current_RTP_PT[i].code; } dest->rtp_lookup_code_cache_isAstFormat = 0; dest->rtp_lookup_code_cache_code = 0; dest->rtp_lookup_code_cache_result = 0; rtp_bridge_unlock(src); rtp_bridge_unlock(dest); }

void ast_rtp_pt_default (  struct ast_rtp *  rtp  )

Set payload types to defaults. Definition at line 1467 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, rtp_bridge_lock(), and static_RTP_PT. { int i; rtp_bridge_lock(rtp); /* Initialize to default payload types */ for (i = 0; i < MAX_RTP_PT; ++i) { rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat; rtp->current_RTP_PT[i].code = static_RTP_PT[i].code; } rtp->rtp_lookup_code_cache_isAstFormat = 0; rtp->rtp_lookup_code_cache_code = 0; rtp->rtp_lookup_code_cache_result = 0; rtp_bridge_unlock(rtp); }

struct ast_frame* ast_rtp_read (  struct ast_rtp *  rtp  )

Definition at line 1144 of file rtp.c. References ast_codec_get_samples(), AST_FORMAT_MAX_AUDIO, AST_FORMAT_SLINEAR, ast_frame_byteswap_be, AST_FRAME_VIDEO, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_inet_ntoa(), ast_log(), ast_null_frame, ast_rtcp_calc_interval(), ast_rtcp_write(), AST_RTP_CISCO_DTMF, AST_RTP_CN, AST_RTP_DTMF, ast_rtp_get_bridged(), ast_rtp_lookup_pt(), ast_rtp_senddigit_continuation(), ast_sched_add(), ast_set_flag, ast_verbose(), bridge_p2p_rtp_write(), ast_rtp::bridged, calc_rxstamp(), rtpPayloadType::code, CRASH, ast_rtp::cycles, ast_frame::data, ast_frame::datalen, ast_frame::delivery, event, ext, ast_rtp::f, FLAG_NAT_ACTIVE, ast_frame::frametype, ast_frame::has_timing_info, rtpPayloadType::isAstFormat, ast_rtp::lasteventseqn, ast_rtp::lastividtimestamp, ast_rtp::lastrxformat, ast_rtp::lastrxseqno, ast_rtp::lastrxts, ast_frame::len, len, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, ast_frame::mallocd, ast_rtp::nat, ast_frame::offset, option_debug, process_cisco_dtmf(), process_rfc2833(), process_rfc3389(), ast_rtp::rawdata, ast_rtp::rtcp, rtp_debug_test_addr(), RTP_SEQ_MOD, ast_rtp::rxcount, ast_rtp::rxseqno, ast_rtp::rxssrc, ast_rtp::s, ast_frame::samples, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::seedrxseqno, ast_rtp::sending_digit, ast_frame::seqno, ast_frame::src, STUN_ACCEPT, stun_handle_packet(), ast_frame::subclass, ast_rtcp::them, ast_rtp::them, ast_rtp::themssrc, and ast_frame::ts. Referenced by gtalk_rtp_read(), jingle_rtp_read(), mgcp_rtp_read(), oh323_rtp_read(), rtpread(), sip_rtp_read(), and skinny_rtp_read(). { int res; struct sockaddr_in sin; socklen_t len; unsigned int seqno; int version; int payloadtype; int tseqno; int hdrlen = 12; int padding; int mark; int ext; unsigned int ssrc; unsigned int timestamp; unsigned int *rtpheader; struct rtpPayloadType rtpPT; struct ast_rtp *bridged = NULL; /* If time is up, kill it */ if (rtp->sending_digit) ast_rtp_senddigit_continuation(rtp); len = sizeof(sin); /* Cache where the header will go */ res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len); rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET); if (res < 0) { if (errno != EAGAIN) ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno)); if (errno == EBADF) CRASH; return &ast_null_frame; } if (res < hdrlen) { ast_log(LOG_WARNING, "RTP Read too short\n"); return &ast_null_frame; } /* Get fields */ seqno = ntohl(rtpheader[0]); /* Check RTP version */ version = (seqno & 0xC0000000) >> 30; if (!version) { if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) && (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) { memcpy(&rtp->them, &sin, sizeof(rtp->them)); } return &ast_null_frame; } #if 0 /* Allow to receive RTP stream with closed transmission path */ /* If we don't have the other side's address, then ignore this */ if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port) return &ast_null_frame; #endif /* Send to whoever send to us if NAT is turned on */ if (rtp->nat) { if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) || (rtp->them.sin_port != sin.sin_port)) { rtp->them = sin; if (rtp->rtcp) { memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them)); rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1); } rtp->rxseqno = 0; ast_set_flag(rtp, FLAG_NAT_ACTIVE); if (option_debug || rtpdebug) ast_log(LOG_DEBUG, "RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port)); } } /* If we are bridged to another RTP stream, send direct */ if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen)) return &ast_null_frame; if (version != 2) return &ast_null_frame; payloadtype = (seqno & 0x7f0000) >> 16; padding = seqno & (1 << 29); mark = seqno & (1 << 23); ext = seqno & (1 << 28); seqno &= 0xffff; timestamp = ntohl(rtpheader[1]); ssrc = ntohl(rtpheader[2]); if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) { if (option_debug || rtpdebug) ast_log(LOG_DEBUG, "Forcing Marker bit, because SSRC has changed\n"); mark = 1; } rtp->rxssrc = ssrc; if (padding) { /* Remove padding bytes */ res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1]; } if (ext) { /* RTP Extension present */ hdrlen += 4; hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2; if (option_debug) { int profile; profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16; if (profile == 0x505a) ast_log(LOG_DEBUG, "Found Zfone extension in RTP stream - zrtp - not supported.\n"); else ast_log(LOG_DEBUG, "Found unknown RTP Extensions %x\n", profile); } } if (res < hdrlen) { ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen); return &ast_null_frame; } rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */ tseqno = rtp->lastrxseqno +1; if (rtp->rxcount==1) { /* This is the first RTP packet successfully received from source */ rtp->seedrxseqno = seqno; } /* Do not schedule RR if RTCP isn't run */ if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) { /* Schedule transmission of Receiver Report */ rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp); } if (tseqno > RTP_SEQ_MOD) { /* if tseqno is greater than RTP_SEQ_MOD it would indicate that the sender cycled */ rtp->cycles += RTP_SEQ_MOD; ast_verbose("SEQNO cycled: %u\t%d\n", rtp->cycles, seqno); } rtp->lastrxseqno = seqno; if (rtp->themssrc==0) rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */ if (rtp_debug_test_addr(&sin)) ast_verbose("Got RTP packet from %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen); rtpPT = ast_rtp_lookup_pt(rtp, payloadtype); if (!rtpPT.isAstFormat) { struct ast_frame *f = NULL; /* This is special in-band data that's not one of our codecs */ if (rtpPT.code == AST_RTP_DTMF) { /* It's special -- rfc2833 process it */ if (rtp_debug_test_addr(&sin)) { unsigned char *data; unsigned int event; unsigned int event_end; unsigned int duration; data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen; event = ntohl(*((unsigned int *)(data))); event >>= 24; event_end = ntohl(*((unsigned int *)(data))); event_end <<= 8; event_end >>= 24; duration = ntohl(*((unsigned int *)(data))); duration &= 0xFFFF; ast_verbose("Got RTP RFC2833 from %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u, mark %d, event %08x, end %d, duration %-5.5d) \n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp, res - hdrlen, (mark?1:0), event, ((event_end & 0x80)?1:0), duration); } f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno); } else if (rtpPT.code == AST_RTP_CISCO_DTMF) { /* It's really special -- process it the Cisco way */ if (rtp->lasteventseqn <= seqno || (rtp->lasteventseqn >= 65530 && seqno <= 6)) { f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen); rtp->lasteventseqn = seqno; } } else if (rtpPT.code == AST_RTP_CN) { /* Comfort Noise */ f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen); } else { ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr)); } return f ? f : &ast_null_frame; } rtp->lastrxformat = rtp->f.subclass = rtpPT.code; rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO; if (!rtp->lastrxts) rtp->lastrxts = timestamp; rtp->rxseqno = seqno; /* Record received timestamp as last received now */ rtp->lastrxts = timestamp; rtp->f.mallocd = 0; rtp->f.datalen = res - hdrlen; rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET; rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET; if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) { rtp->f.samples = ast_codec_get_samples(&rtp->f); if (rtp->f.subclass == AST_FORMAT_SLINEAR) ast_frame_byteswap_be(&rtp->f); calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark); /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */ rtp->f.has_timing_info = 1; rtp->f.ts = timestamp / 8; rtp->f.len = rtp->f.samples / 8; rtp->f.seqno = seqno; } else { /* Video -- samples is # of samples vs. 90000 */ if (!rtp->lastividtimestamp) rtp->lastividtimestamp = timestamp; rtp->f.samples = timestamp - rtp->lastividtimestamp; rtp->lastividtimestamp = timestamp; rtp->f.delivery.tv_sec = 0; rtp->f.delivery.tv_usec = 0; if (mark) rtp->f.subclass |= 0x1; } rtp->f.src = "RTP"; return &rtp->f; }

int ast_rtp_reload (  void   )

Initialize RTP subsystem Definition at line 3599 of file rtp.c. References ast_config_destroy(), ast_config_load(), ast_false(), ast_log(), ast_variable_retrieve(), ast_verbose(), DEFAULT_DTMF_TIMEOUT, dtmftimeout, option_verbose, RTCP_MAX_INTERVALMS, RTCP_MIN_INTERVALMS, rtcpinterval, rtpend, rtpstart, s, and VERBOSE_PREFIX_2. Referenced by ast_rtp_init(). { struct ast_config *cfg; const char *s; rtpstart = 5000; rtpend = 31000; dtmftimeout = DEFAULT_DTMF_TIMEOUT; cfg = ast_config_load("rtp.conf"); if (cfg) { if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) { rtpstart = atoi(s); if (rtpstart < 1024) rtpstart = 1024; if (rtpstart > 65535) rtpstart = 65535; } if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) { rtpend = atoi(s); if (rtpend < 1024) rtpend = 1024; if (rtpend > 65535) rtpend = 65535; } if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) { rtcpinterval = atoi(s); if (rtcpinterval == 0) rtcpinterval = 0; /* Just so we're clear... it's zero */ if (rtcpinterval < RTCP_MIN_INTERVALMS) rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */ if (rtcpinterval > RTCP_MAX_INTERVALMS) rtcpinterval = RTCP_MAX_INTERVALMS; } if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) { #ifdef SO_NO_CHECK if (ast_false(s)) nochecksums = 1; else nochecksums = 0; #else if (ast_false(s)) ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n"); #endif } if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) { dtmftimeout = atoi(s); if ((dtmftimeout < 0) || (dtmftimeout > 20000)) { ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n", dtmftimeout, DEFAULT_DTMF_TIMEOUT); dtmftimeout = DEFAULT_DTMF_TIMEOUT; }; } ast_config_destroy(cfg); } if (rtpstart >= rtpend) { ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n"); rtpstart = 5000; rtpend = 31000; } if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend); return 0; }

void ast_rtp_reset (  struct ast_rtp *  rtp  )

Definition at line 2073 of file rtp.c. References ast_rtp::dtmfcount, ast_rtp::dtmfmute, ast_rtp::dtmfsamples, ast_rtp::lastdigitts, ast_rtp::lasteventendseqn, ast_rtp::lasteventseqn, ast_rtp::lastividtimestamp, ast_rtp::lastovidtimestamp, ast_rtp::lastrxformat, ast_rtp::lastrxts, ast_rtp::lastts, ast_rtp::lasttxformat, ast_rtp::rxcore, ast_rtp::rxseqno, ast_rtp::seqno, and ast_rtp::txcore. { memset(&rtp->rxcore, 0, sizeof(rtp->rxcore)); memset(&rtp->txcore, 0, sizeof(rtp->txcore)); memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute)); rtp->lastts = 0; rtp->lastdigitts = 0; rtp->lastrxts = 0; rtp->lastividtimestamp = 0; rtp->lastovidtimestamp = 0; rtp->lasteventseqn = 0; rtp->lasteventendseqn = 0; rtp->lasttxformat = 0; rtp->lastrxformat = 0; rtp->dtmfcount = 0; rtp->dtmfsamples = 0; rtp->seqno = 0; rtp->rxseqno = 0; }

int ast_rtp_sendcng (  struct ast_rtp *  rtp, int  level )

generate comfort noice (CNG) Definition at line 2568 of file rtp.c. References ast_inet_ntoa(), ast_log(), AST_RTP_CN, ast_rtp_lookup_code(), ast_tvadd(), ast_verbose(), ast_rtp::data, ast_rtp::dtmfmute, ast_rtp::lastts, LOG_ERROR, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them. Referenced by check_rtp_timeout(). { unsigned int *rtpheader; int hdrlen = 12; int res; int payload; char data[256]; level = 127 - (level & 0x7f); payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN); /* If we have no peer, return immediately */ if (!rtp->them.sin_addr.s_addr) return 0; rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000)); /* Get a pointer to the header */ rtpheader = (unsigned int *)data; rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++)); rtpheader[1] = htonl(rtp->lastts); rtpheader[2] = htonl(rtp->ssrc); data[12] = level; if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) { res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them)); if (res <0) ast_log(LOG_ERROR, "RTP Comfort Noise Transmission error to %s:%d: %s\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno)); if (rtp_debug_test_addr(&rtp->them)) ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n" , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen); } return 0; }

int ast_rtp_senddigit_begin (  struct ast_rtp *  rtp, char  digit )

Send begin frames for DTMF. Definition at line 2171 of file rtp.c. References ast_inet_ntoa(), ast_log(), AST_RTP_DTMF, ast_rtp_lookup_code(), ast_tvadd(), ast_verbose(), ast_rtp::dtmfmute, ast_rtp::lastdigitts, LOG_ERROR, LOG_WARNING, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::send_duration, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them. Referenced by oh323_digit_begin(), and sip_senddigit_begin(). { unsigned int *rtpheader; int hdrlen = 12, res = 0, i = 0, payload = 0; char data[256]; if ((digit <= '9') && (digit >= '0')) digit -= '0'; else if (digit == '*') digit = 10; else if (digit == '#') digit = 11; else if ((digit >= 'A') && (digit <= 'D')) digit = digit - 'A' + 12; else if ((digit >= 'a') && (digit <= 'd')) digit = digit - 'a' + 12; else { ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit); return 0; } /* If we have no peer, return immediately */ if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port) return 0; payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF); rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000)); rtp->send_duration = 160; /* Get a pointer to the header */ rtpheader = (unsigned int *)data; rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno)); rtpheader[1] = htonl(rtp->lastdigitts); rtpheader[2] = htonl(rtp->ssrc); for (i = 0; i < 2; i++) { rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration)); res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them)); if (res < 0) ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno)); if (rtp_debug_test_addr(&rtp->them)) ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen); /* Increment sequence number */ rtp->seqno++; /* Increment duration */ rtp->send_duration += 160; /* Clear marker bit and set seqno */ rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno)); } /* Since we received a begin, we can safely store the digit and disable any compensation */ rtp->sending_digit = 1; rtp->send_digit = digit; rtp->send_payload = payload; return 0; }

int ast_rtp_senddigit_end (  struct ast_rtp *  rtp, char  digit )

void ast_rtp_set_callback (  struct ast_rtp *  rtp, ast_rtp_callback  callback )

Definition at line 587 of file rtp.c. References ast_rtp::callback. Referenced by start_rtp(). { rtp->callback = callback; }

void ast_rtp_set_data (  struct ast_rtp *  rtp, void *  data )

Definition at line 582 of file rtp.c. References ast_rtp::data. Referenced by start_rtp(). { rtp->data = data; }

void ast_rtp_set_m_type (  struct ast_rtp *  rtp, int  pt )

Make a note of a RTP payload type that was seen in a SDP "m=" line. By default, use the well-known value for this type (although it may still be set to a different value by a subsequent "a=rtpmap:" line). Definition at line 1668 of file rtp.c. References ast_rtp::current_RTP_PT, MAX_RTP_PT, rtp_bridge_lock(), rtp_bridge_unlock(), and static_RTP_PT. Referenced by gtalk_newcall(), jingle_newcall(), and process_sdp(). { if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) return; /* bogus payload type */ rtp_bridge_lock(rtp); rtp->current_RTP_PT[pt] = static_RTP_PT[pt]; rtp_bridge_unlock(rtp); }

void ast_rtp_set_peer (  struct ast_rtp *  rtp, struct sockaddr_in *  them )

Definition at line 2016 of file rtp.c. References ast_rtp::rtcp, ast_rtp::rxseqno, ast_rtcp::them, and ast_rtp::them. Referenced by handle_open_receive_channel_ack_message(), process_sdp(), and setup_rtp_connection(). { rtp->them.sin_port = them->sin_port; rtp->them.sin_addr = them->sin_addr; if (rtp->rtcp) { rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1); rtp->rtcp->them.sin_addr = them->sin_addr; } rtp->rxseqno = 0; }

void ast_rtp_set_rtpholdtimeout (  struct ast_rtp *  rtp, int  timeout )

Set rtp hold timeout. Definition at line 549 of file rtp.c. References ast_rtp::rtpholdtimeout. Referenced by check_rtp_timeout(), create_addr_from_peer(), dialog_activate_media(), and sip_alloc(). { rtp->rtpholdtimeout = timeout; }

void ast_rtp_set_rtpkeepalive (  struct ast_rtp *  rtp, int  period )

set RTP keepalive interval Definition at line 555 of file rtp.c. References ast_rtp::rtpkeepalive. Referenced by create_addr_from_peer(), dialog_activate_media(), and sip_alloc(). { rtp->rtpkeepalive = period; }

void ast_rtp_set_rtpmap_type (  struct ast_rtp *  rtp, int  pt, char *  mimeType, char *  mimeSubtype, enum ast_rtp_options  options )

Make a note of a RTP payload type (with MIME type) that was seen in an SDP "a=rtpmap:" line. Definition at line 1681 of file rtp.c. References AST_FORMAT_G726, AST_FORMAT_G726_AAL2, AST_RTP_OPT_G726_NONSTANDARD, rtpPayloadType::code, ast_rtp::current_RTP_PT, MAX_RTP_PT, mimeTypes, payloadType, rtp_bridge_lock(), subtype, and type. Referenced by __oh323_rtp_create(), gtalk_newcall(), jingle_newcall(), process_sdp(), set_dtmf_payload(), and setup_rtp_connection(). { unsigned int i; if (pt < 0 || pt > MAX_RTP_PT) return; /* bogus payload type */ rtp_bridge_lock(rtp); for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) { if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 && strcasecmp(mimeType, mimeTypes[i].type) == 0) { rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType; if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) && mimeTypes[i].payloadType.isAstFormat && (options & AST_RTP_OPT_G726_NONSTANDARD)) rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2; break; } } rtp_bridge_unlock(rtp); return; }

void ast_rtp_set_rtptimeout (  struct ast_rtp *  rtp, int  timeout )

Set rtp timeout. Definition at line 543 of file rtp.c. References ast_rtp::rtptimeout. Referenced by check_rtp_timeout(), create_addr_from_peer(), dialog_activate_media(), and sip_alloc(). { rtp->rtptimeout = timeout; }

void ast_rtp_set_rtptimers_onhold (  struct ast_rtp *  rtp  )

Definition at line 536 of file rtp.c. References ast_rtp::rtpholdtimeout, and ast_rtp::rtptimeout. Referenced by handle_response_answer(), and handle_response_invite(). { rtp->rtptimeout = (-1) * rtp->rtptimeout; rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout; }

void ast_rtp_setdtmf (  struct ast_rtp *  rtp, int  dtmf )

Indicate whether this RTP session is carrying DTMF or not. Definition at line 602 of file rtp.c. References ast_set2_flag, and FLAG_HAS_DTMF. Referenced by create_addr_from_peer(), dialog_activate_media(), handle_request_invite(), and sip_alloc(). { ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF); }

void ast_rtp_setdtmfcompensate (  struct ast_rtp *  rtp, int  compensate )

Compensate for devices that send RFC2833 packets all at once. Definition at line 607 of file rtp.c. References ast_set2_flag, and FLAG_DTMF_COMPENSATE. Referenced by create_addr_from_peer(), dialog_activate_media(), handle_request_invite(), and sip_alloc(). { ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE); }

void ast_rtp_setnat (  struct ast_rtp *  rtp, int  nat )

Definition at line 592 of file rtp.c. References ast_rtp::nat. Referenced by __oh323_rtp_create(), do_setnat(), oh323_rtp_read(), and start_rtp(). { rtp->nat = nat; }

void ast_rtp_setstun (  struct ast_rtp *  rtp, int  stun_enable )

Enable STUN capability. Definition at line 612 of file rtp.c. References ast_set2_flag, and FLAG_HAS_STUN. Referenced by gtalk_new(). { ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN); }

int ast_rtp_settos (  struct ast_rtp *  rtp, int  tos )

Definition at line 2007 of file rtp.c. References ast_log(), LOG_WARNING, and ast_rtp::s. Referenced by __oh323_rtp_create(), dialog_activate_media(), and sip_alloc(). { int res; if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos); return res; }

void ast_rtp_stop (  struct ast_rtp *  rtp  )

Stop RTP session, do not destroy structure Definition at line 2056 of file rtp.c. References ast_clear_flag, ast_sched_del(), FLAG_P2P_SENT_MARK, ast_rtp::rtcp, ast_rtp::sched, ast_rtcp::schedid, ast_rtcp::them, and ast_rtp::them. Referenced by setup_rtp_connection(), and stop_media_flows(). { if (rtp->rtcp && rtp->rtcp->schedid > 0) { ast_sched_del(rtp->sched, rtp->rtcp->schedid); rtp->rtcp->schedid = -1; } memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr)); memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port)); if (rtp->rtcp) { memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr)); memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port)); } ast_clear_flag(rtp, FLAG_P2P_SENT_MARK); }

void ast_rtp_stun_request (  struct ast_rtp *  rtp, struct sockaddr_in *  suggestion, const char *  username )

Send STUN request (??). Definition at line 404 of file rtp.c. References append_attr_string(), stun_attr::attr, ast_rtp::s, STUN_BINDREQ, stun_req_id(), stun_send(), and STUN_USERNAME. Referenced by gtalk_update_stun(), and jingle_update_stun(). { struct stun_header *req; unsigned char reqdata[1024]; int reqlen, reqleft; struct stun_attr *attr; req = (struct stun_header *)reqdata; stun_req_id(req); reqlen = 0; reqleft = sizeof(reqdata) - sizeof(struct stun_header); req->msgtype = 0; req->msglen = 0; attr = (struct stun_attr *)req->ies; if (username) append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft); req->msglen = htons(reqlen); req->msgtype = htons(STUN_BINDREQ); stun_send(rtp->s, suggestion, req); }

int ast_rtp_write (  struct ast_rtp *  rtp, struct ast_frame *  _f )

Bug: XXX this might never be free'd. Why do we do this? Definition at line 2722 of file rtp.c. References ast_codec_pref_getsize(), AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frdup(), ast_frfree(), ast_getformatname(), ast_log(), ast_rtp_lookup_code(), ast_rtp_raw_write(), ast_smoother_feed, ast_smoother_feed_be, AST_SMOOTHER_FLAG_BE, ast_smoother_free(), ast_smoother_new(), ast_smoother_read(), ast_smoother_set_flags(), ast_smoother_test_flag(), ast_frame::datalen, fmt, ast_frame::frametype, ast_rtp::lasttxformat, LOG_DEBUG, LOG_WARNING, ast_frame::offset, option_debug, ast_rtp::pref, ast_rtp::smoother, ast_frame::subclass, and ast_rtp::them. Referenced by gtalk_write(), jingle_write(), mgcp_write(), oh323_write(), sip_write(), skinny_write(), and write_media_frame(). { struct ast_frame *f; int codec; int hdrlen = 12; int subclass; /* If we have no peer, return immediately */ if (!rtp->them.sin_addr.s_addr) return 0; /* If there is no data length, return immediately */ if (!_f->datalen) return 0; /* Make sure we have enough space for RTP header */ if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) { ast_log(LOG_WARNING, "RTP can only send voice and video\n"); return -1; } subclass = _f->subclass; if (_f->frametype == AST_FRAME_VIDEO) subclass &= ~0x1; codec = ast_rtp_lookup_code(rtp, 1, subclass); if (codec < 0) { ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass)); return -1; } if (rtp->lasttxformat != subclass) { /* New format, reset the smoother */ if (option_debug) ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass)); rtp->lasttxformat = subclass; if (rtp->smoother) ast_smoother_free(rtp->smoother); rtp->smoother = NULL; } if (!rtp->smoother) { struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass); if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */ if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) { ast_log(LOG_WARNING, "Unable to create smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms)); return -1; } if (fmt.flags) ast_smoother_set_flags(rtp->smoother, fmt.flags); if (option_debug) ast_log(LOG_DEBUG, "Created smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms)); } } if (rtp->smoother) { if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) { ast_smoother_feed_be(rtp->smoother, _f); } else { ast_smoother_feed(rtp->smoother, _f); } while ((f = ast_smoother_read(rtp->smoother))) ast_rtp_raw_write(rtp, f, codec); } else { /* Don't buffer outgoing frames; send them one-per-packet: */ if (_f->offset < hdrlen) f = ast_frdup(_f); /*! \bug XXX this might never be free'd. Why do we do this? */ else f = _f; ast_rtp_raw_write(rtp, f, codec); if (f != _f) ast_frfree(f); } return 0; }

---

Asterisk is a trademark for Digium, inc.. | Edvina.net | Asterisk.org | This documentation was generated with Doxygen