Merge in the RTP engine API.

This API provides a generic way for multiple RTP stacks to be
integrated into Asterisk. Right now there is only one present, res_rtp_asterisk,
which is the existing Asterisk RTP stack. Functionality wise this commit
performs the same as previously. API documentation can be viewed in the
rtp_engine.h header file.

Review: http://reviewboard.digium.com/r/209/


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@186078 65c4cc65-6c06-0410-ace0-fbb531ad65f3

6 files changed, 2049 insertions, 4871 deletions

diff --git a/main/Makefile b/main/Makefile
index 3e6179229..681719799 100644
--- a/main/Makefile
+++ b/main/Makefile
@@ -20,7 +20,7 @@ include $(ASTTOPDIR)/Makefile.moddir_rules
 OBJS= tcptls.o io.o sched.o logger.o frame.o loader.o config.o channel.o \
 	translate.o file.o pbx.o cli.o md5.o term.o heap.o \
 	ulaw.o alaw.o callerid.o fskmodem.o image.o app.o \
-	cdr.o tdd.o acl.o rtp.o udptl.o manager.o asterisk.o \
+	cdr.o tdd.o acl.o udptl.o manager.o asterisk.o \
 	dsp.o chanvars.o indications.o autoservice.o db.o privacy.o \
 	astmm.o enum.o srv.o dns.o aescrypt.o aestab.o aeskey.o \
 	utils.o plc.o jitterbuf.o dnsmgr.o devicestate.o \
@@ -29,7 +29,7 @@ OBJS= tcptls.o io.o sched.o logger.o frame.o loader.o config.o channel.o \
 	strcompat.o threadstorage.o dial.o event.o adsistub.o audiohook.o \
 	astobj2.o hashtab.o global_datastores.o version.o \
 	features.o taskprocessor.o timing.o datastore.o xml.o xmldoc.o \
-	strings.o bridging.o poll.o
+	strings.o bridging.o poll.o rtp_engine.o stun.o
 
 # we need to link in the objects statically, not as a library, because
 # otherwise modules will not have them available if none of the static
diff --git a/main/asterisk.c b/main/asterisk.c
index fdef5e156..20c85b47f 100644
--- a/main/asterisk.c
+++ b/main/asterisk.c
@@ -120,7 +120,6 @@ int daemon(int, int);  /* defined in libresolv of all places */
 #include "asterisk/cdr.h"
 #include "asterisk/pbx.h"
 #include "asterisk/enum.h"
-#include "asterisk/rtp.h"
 #include "asterisk/http.h"
 #include "asterisk/udptl.h"
 #include "asterisk/app.h"
@@ -3579,7 +3578,6 @@ int main(int argc, char *argv[])
 		exit(1);
 	}
 
-	ast_rtp_init();
 	ast_dsp_init();
 	ast_udptl_init();
 
diff --git a/main/loader.c b/main/loader.c
index 5f2fe8678..4e07e843b 100644
--- a/main/loader.c
+++ b/main/loader.c
@@ -43,7 +43,6 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include "asterisk/manager.h"
 #include "asterisk/cdr.h"
 #include "asterisk/enum.h"
-#include "asterisk/rtp.h"
 #include "asterisk/http.h"
 #include "asterisk/lock.h"
 #include "asterisk/features.h"
@@ -243,7 +242,6 @@ static struct reload_classes {
 	{ "extconfig",	read_config_maps },
 	{ "enum",	ast_enum_reload },
 	{ "manager",	reload_manager },
-	{ "rtp",	ast_rtp_reload },
 	{ "http",	ast_http_reload },
 	{ "logger",	logger_reload },
 	{ "features",	ast_features_reload },
diff --git a/main/rtp.c b/main/rtp.c
deleted file mode 100644
index 38ff9ad3a..000000000
--- a/main/rtp.c
+++ /dev/null
@@ -1,4865 +0,0 @@
-/*
- * Asterisk -- An open source telephony toolkit.
- *
- * Copyright (C) 1999 - 2006, Digium, Inc.
- *
- * Mark Spencer <markster@digium.com>
- *
- * See http://www.asterisk.org for more information about
- * the Asterisk project. Please do not directly contact
- * any of the maintainers of this project for assistance;
- * the project provides a web site, mailing lists and IRC
- * channels for your use.
- *
- * This program is free software, distributed under the terms of
- * the GNU General Public License Version 2. See the LICENSE file
- * at the top of the source tree.
- */
-
-/*! 
- * \file 
- *
- * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
- *
- * \author Mark Spencer <markster@digium.com>
- * 
- * \note RTP is defined in RFC 3550.
- */
-
-#include "asterisk.h"
-
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
-
-#include <sys/time.h>
-#include <signal.h>
-#include <fcntl.h>
-#include <math.h> 
-
-#include "asterisk/rtp.h"
-#include "asterisk/pbx.h"
-#include "asterisk/frame.h"
-#include "asterisk/channel.h"
-#include "asterisk/acl.h"
-#include "asterisk/config.h"
-#include "asterisk/lock.h"
-#include "asterisk/utils.h"
-#include "asterisk/netsock.h"
-#include "asterisk/cli.h"
-#include "asterisk/manager.h"
-#include "asterisk/unaligned.h"
-
-#define MAX_TIMESTAMP_SKEW	640
-
-#define RTP_SEQ_MOD     (1<<16) 	/*!< A sequence number can't be more than 16 bits */
-#define RTCP_DEFAULT_INTERVALMS   5000	/*!< Default milli-seconds between RTCP reports we send */
-#define RTCP_MIN_INTERVALMS       500	/*!< Min milli-seconds between RTCP reports we send */
-#define RTCP_MAX_INTERVALMS       60000	/*!< Max milli-seconds between RTCP reports we send */
-
-#define RTCP_PT_FUR     192
-#define RTCP_PT_SR      200
-#define RTCP_PT_RR      201
-#define RTCP_PT_SDES    202
-#define RTCP_PT_BYE     203
-#define RTCP_PT_APP     204
-
-#define RTP_MTU		1200
-
-#define DEFAULT_DTMF_TIMEOUT 3000	/*!< samples */
-
-static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
-
-static int rtpstart = 5000;     /*!< First port for RTP sessions (set in rtp.conf) */
-static int rtpend = 31000;      /*!< Last port for RTP sessions (set in rtp.conf) */
-static int rtpdebug;			/*!< Are we debugging? */
-static int rtcpdebug;			/*!< Are we debugging RTCP? */
-static int rtcpstats;			/*!< Are we debugging RTCP? */
-static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
-static int stundebug;			/*!< Are we debugging stun? */
-static struct sockaddr_in rtpdebugaddr;	/*!< Debug packets to/from this host */
-static struct sockaddr_in rtcpdebugaddr;	/*!< Debug RTCP packets to/from this host */
-#ifdef SO_NO_CHECK
-static int nochecksums;
-#endif
-static int strictrtp;
-
-enum strict_rtp_state {
-	STRICT_RTP_OPEN = 0, /*! No RTP packets should be dropped, all sources accepted */
-	STRICT_RTP_LEARN,    /*! Accept next packet as source */
-	STRICT_RTP_CLOSED,   /*! Drop all RTP packets not coming from source that was learned */
-};
-
-/* Uncomment this to enable more intense native bridging, but note: this is currently buggy */
-/* #define P2P_INTENSE */
-
-/*!
- * \brief Structure representing a RTP session.
- *
- * RTP session is defined on page 9 of RFC 3550: "An association among a set of participants communicating with RTP.  A participant may be involved in multiple RTP sessions at the same time [...]"
- *
- */
-
-/*! \brief RTP session description */
-struct ast_rtp {
-	int s;
-	struct ast_frame f;
-	unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
-	unsigned int ssrc;		/*!< Synchronization source, RFC 3550, page 10. */
-	unsigned int themssrc;		/*!< Their SSRC */
-	unsigned int rxssrc;
-	unsigned int lastts;
-	unsigned int lastrxts;
-	unsigned int lastividtimestamp;
-	unsigned int lastovidtimestamp;
-	unsigned int lastitexttimestamp;
-	unsigned int lastotexttimestamp;
-	unsigned int lasteventseqn;
-	int lastrxseqno;                /*!< Last received sequence number */
-	unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
-	unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
-	unsigned int rxcount;           /*!< How many packets have we received? */
-	unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
-	unsigned int txcount;           /*!< How many packets have we sent? */
-	unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
-	unsigned int cycles;            /*!< Shifted count of sequence number cycles */
-	double rxjitter;                /*!< Interarrival jitter at the moment */
-	double rxtransit;               /*!< Relative transit time for previous packet */
-	int lasttxformat;
-	int lastrxformat;
-
-	int rtptimeout;			/*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
-	int rtpholdtimeout;		/*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
-	int rtpkeepalive;		/*!< Send RTP comfort noice packets for keepalive */
-
-	/* DTMF Reception Variables */
-	char resp;
-	unsigned int lastevent;
-	int dtmfcount;
-	unsigned int dtmfsamples;
-	/* DTMF Transmission Variables */
-	unsigned int lastdigitts;
-	char sending_digit;	/*!< boolean - are we sending digits */
-	char send_digit;	/*!< digit we are sending */
-	int send_payload;
-	int send_duration;
-	int nat;
-	unsigned int flags;
-	struct sockaddr_in us;		/*!< Socket representation of the local endpoint. */
-	struct sockaddr_in them;	/*!< Socket representation of the remote endpoint. */
-	struct timeval rxcore;
-	struct timeval txcore;
-	double drxcore;                 /*!< The double representation of the first received packet */
-	struct timeval lastrx;          /*!< timeval when we last received a packet */
-	struct timeval dtmfmute;
-	struct ast_smoother *smoother;
-	int *ioid;
-	unsigned short seqno;		/*!< Sequence number, RFC 3550, page 13. */
-	unsigned short rxseqno;
-	struct sched_context *sched;
-	struct io_context *io;
-	void *data;
-	ast_rtp_callback callback;
-#ifdef P2P_INTENSE
-	ast_mutex_t bridge_lock;
-#endif
-	struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
-	int rtp_lookup_code_cache_isAstFormat; /*!< a cache for the result of rtp_lookup_code(): */
-	int rtp_lookup_code_cache_code;
-	int rtp_lookup_code_cache_result;
-	struct ast_rtcp *rtcp;
-	struct ast_codec_pref pref;
-	struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
-
-	enum strict_rtp_state strict_rtp_state; /*!< Current state that strict RTP protection is in */
-	struct sockaddr_in strict_rtp_address;  /*!< Remote address information for strict RTP purposes */
-
-	int set_marker_bit:1;           /*!< Whether to set the marker bit or not */
-	struct rtp_red *red;
-};
-
-static struct ast_frame *red_t140_to_red(struct rtp_red *red);
-static int red_write(const void *data);
- 
-struct rtp_red {
-	struct ast_frame t140;  /*!< Primary data  */
-	struct ast_frame t140red;   /*!< Redundant t140*/
-	unsigned char pt[RED_MAX_GENERATION];  /*!< Payload types for redundancy data */
-	unsigned char ts[RED_MAX_GENERATION]; /*!< Time stamps */
-	unsigned char len[RED_MAX_GENERATION]; /*!< length of each generation */
-	int num_gen; /*!< Number of generations */
-	int schedid; /*!< Timer id */
-	int ti; /*!< How long to buffer data before send */
-	unsigned char t140red_data[64000];  
-	unsigned char buf_data[64000]; /*!< buffered primary data */
-	int hdrlen; 
-	long int prev_ts;
-};
-
-/* Forward declarations */
-static int ast_rtcp_write(const void *data);
-static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw);
-static int ast_rtcp_write_sr(const void *data);
-static int ast_rtcp_write_rr(const void *data);
-static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp);
-static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp);
-int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit);
-
-#define FLAG_3389_WARNING		(1 << 0)
-#define FLAG_NAT_ACTIVE			(3 << 1)
-#define FLAG_NAT_INACTIVE		(0 << 1)
-#define FLAG_NAT_INACTIVE_NOWARN	(1 << 1)
-#define FLAG_HAS_DTMF			(1 << 3)
-#define FLAG_P2P_SENT_MARK              (1 << 4)
-#define FLAG_P2P_NEED_DTMF              (1 << 5)
-#define FLAG_CALLBACK_MODE              (1 << 6)
-#define FLAG_DTMF_COMPENSATE            (1 << 7)
-#define FLAG_HAS_STUN                   (1 << 8)
-
-/*!
- * \brief Structure defining an RTCP session.
- * 
- * The concept "RTCP session" is not defined in RFC 3550, but since 
- * this structure is analogous to ast_rtp, which tracks a RTP session, 
- * it is logical to think of this as a RTCP session.
- *
- * RTCP packet is defined on page 9 of RFC 3550.
- * 
- */
-struct ast_rtcp {
-	int rtcp_info;
-	int s;				/*!< Socket */
-	struct sockaddr_in us;		/*!< Socket representation of the local endpoint. */
-	struct sockaddr_in them;	/*!< Socket representation of the remote endpoint. */
-	unsigned int soc;		/*!< What they told us */
-	unsigned int spc;		/*!< What they told us */
-	unsigned int themrxlsr;		/*!< The middle 32 bits of the NTP timestamp in the last received SR*/
-	struct timeval rxlsr;		/*!< Time when we got their last SR */
-	struct timeval txlsr;		/*!< Time when we sent or last SR*/
-	unsigned int expected_prior;	/*!< no. packets in previous interval */
-	unsigned int received_prior;	/*!< no. packets received in previous interval */
-	int schedid;			/*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
-	unsigned int rr_count;		/*!< number of RRs we've sent, not including report blocks in SR's */
-	unsigned int sr_count;		/*!< number of SRs we've sent */
-	unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
-	double accumulated_transit;	/*!< accumulated a-dlsr-lsr */
-	double rtt;			/*!< Last reported rtt */
-	unsigned int reported_jitter;	/*!< The contents of their last jitter entry in the RR */
-	unsigned int reported_lost;	/*!< Reported lost packets in their RR */
-	char quality[AST_MAX_USER_FIELD];
-	char quality_jitter[AST_MAX_USER_FIELD];
-	char quality_loss[AST_MAX_USER_FIELD];
-	char quality_rtt[AST_MAX_USER_FIELD];
-
-	double reported_maxjitter;
-	double reported_minjitter;
-	double reported_normdev_jitter;
-	double reported_stdev_jitter;
-	unsigned int reported_jitter_count;
-
-	double reported_maxlost;
-	double reported_minlost;
-	double reported_normdev_lost;
-	double reported_stdev_lost;
-
-	double rxlost;
-	double maxrxlost;
-	double minrxlost;
-	double normdev_rxlost;
-	double stdev_rxlost;
-	unsigned int rxlost_count;
-
-	double maxrxjitter;
-	double minrxjitter;
-	double normdev_rxjitter;
-	double stdev_rxjitter;
-	unsigned int rxjitter_count;
-	double maxrtt;
-	double minrtt;
-	double normdevrtt;
-	double stdevrtt;
-	unsigned int rtt_count;
-	int sendfur;
-};
-
-/*!
- * \brief STUN support code
- *
- * This code provides some support for doing STUN transactions.
- * Eventually it should be moved elsewhere as other protocols
- * than RTP can benefit from it - e.g. SIP.
- * STUN is described in RFC3489 and it is based on the exchange
- * of UDP packets between a client and one or more servers to
- * determine the externally visible address (and port) of the client
- * once it has gone through the NAT boxes that connect it to the
- * outside.
- * The simplest request packet is just the header defined in
- * struct stun_header, and from the response we may just look at
- * one attribute, STUN_MAPPED_ADDRESS, that we find in the response.
- * By doing more transactions with different server addresses we
- * may determine more about the behaviour of the NAT boxes, of
- * course - the details are in the RFC.
- *
- * All STUN packets start with a simple header made of a type,
- * length (excluding the header) and a 16-byte random transaction id.
- * Following the header we may have zero or more attributes, each
- * structured as a type, length and a value (whose format depends
- * on the type, but often contains addresses).
- * Of course all fields are in network format.
- */
-
-typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
-
-struct stun_header {
-	unsigned short msgtype;
-	unsigned short msglen;
-	stun_trans_id  id;
-	unsigned char ies[0];
-} __attribute__((packed));
-
-struct stun_attr {
-	unsigned short attr;
-	unsigned short len;
-	unsigned char value[0];
-} __attribute__((packed));
-
-/*
- * The format normally used for addresses carried by STUN messages.
- */
-struct stun_addr {
-	unsigned char unused;
-	unsigned char family;
-	unsigned short port;
-	unsigned int addr;
-} __attribute__((packed));
-
-#define STUN_IGNORE		(0)
-#define STUN_ACCEPT		(1)
-
-/*! \brief STUN message types
- * 'BIND' refers to transactions used to determine the externally
- * visible addresses. 'SEC' refers to transactions used to establish
- * a session key for subsequent requests.
- * 'SEC' functionality is not supported here.
- */
- 
-#define STUN_BINDREQ	0x0001
-#define STUN_BINDRESP	0x0101
-#define STUN_BINDERR	0x0111
-#define STUN_SECREQ	0x0002
-#define STUN_SECRESP	0x0102
-#define STUN_SECERR	0x0112
-
-/*! \brief Basic attribute types in stun messages.
- * Messages can also contain custom attributes (codes above 0x7fff)
- */
-#define STUN_MAPPED_ADDRESS	0x0001
-#define STUN_RESPONSE_ADDRESS	0x0002
-#define STUN_CHANGE_REQUEST	0x0003
-#define STUN_SOURCE_ADDRESS	0x0004
-#define STUN_CHANGED_ADDRESS	0x0005
-#define STUN_USERNAME		0x0006
-#define STUN_PASSWORD		0x0007
-#define STUN_MESSAGE_INTEGRITY	0x0008
-#define STUN_ERROR_CODE		0x0009
-#define STUN_UNKNOWN_ATTRIBUTES	0x000a
-#define STUN_REFLECTED_FROM	0x000b
-
-/*! \brief helper function to print message names */
-static const char *stun_msg2str(int msg)
-{
-	switch (msg) {
-	case STUN_BINDREQ:
-		return "Binding Request";
-	case STUN_BINDRESP:
-		return "Binding Response";
-	case STUN_BINDERR:
-		return "Binding Error Response";
-	case STUN_SECREQ:
-		return "Shared Secret Request";
-	case STUN_SECRESP:
-		return "Shared Secret Response";
-	case STUN_SECERR:
-		return "Shared Secret Error Response";
-	}
-	return "Non-RFC3489 Message";
-}
-
-/*! \brief helper function to print attribute names */
-static const char *stun_attr2str(int msg)
-{
-	switch (msg) {
-	case STUN_MAPPED_ADDRESS:
-		return "Mapped Address";
-	case STUN_RESPONSE_ADDRESS:
-		return "Response Address";
-	case STUN_CHANGE_REQUEST:
-		return "Change Request";
-	case STUN_SOURCE_ADDRESS:
-		return "Source Address";
-	case STUN_CHANGED_ADDRESS:
-		return "Changed Address";
-	case STUN_USERNAME:
-		return "Username";
-	case STUN_PASSWORD:
-		return "Password";
-	case STUN_MESSAGE_INTEGRITY:
-		return "Message Integrity";
-	case STUN_ERROR_CODE:
-		return "Error Code";
-	case STUN_UNKNOWN_ATTRIBUTES:
-		return "Unknown Attributes";
-	case STUN_REFLECTED_FROM:
-		return "Reflected From";
-	}
-	return "Non-RFC3489 Attribute";
-}
-
-/*! \brief here we store credentials extracted from a message */
-struct stun_state {
-	const char *username;
-	const char *password;
-};
-
-static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
-{
-	if (stundebug)
-		ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
-			    stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
-	switch (ntohs(attr->attr)) {
-	case STUN_USERNAME:
-		state->username = (const char *) (attr->value);
-		break;
-	case STUN_PASSWORD:
-		state->password = (const char *) (attr->value);
-		break;
-	default:
-		if (stundebug)
-			ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n", 
-				    stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
-	}
-	return 0;
-}
-
-/*! \brief append a string to an STUN message */
-static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
-{
-	int size = sizeof(**attr) + strlen(s);
-	if (*left > size) {
-		(*attr)->attr = htons(attrval);
-		(*attr)->len = htons(strlen(s));
-		memcpy((*attr)->value, s, strlen(s));
-		(*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
-		*len += size;
-		*left -= size;
-	}
-}
-
-/*! \brief append an address to an STUN message */
-static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sock_in, int *len, int *left)
-{
-	int size = sizeof(**attr) + 8;
-	struct stun_addr *addr;
-	if (*left > size) {
-		(*attr)->attr = htons(attrval);
-		(*attr)->len = htons(8);
-		addr = (struct stun_addr *)((*attr)->value);
-		addr->unused = 0;
-		addr->family = 0x01;
-		addr->port = sock_in->sin_port;
-		addr->addr = sock_in->sin_addr.s_addr;
-		(*attr) = (struct stun_attr *)((*attr)->value + 8);
-		*len += size;
-		*left -= size;
-	}
-}
-
-/*! \brief wrapper to send an STUN message */
-static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
-{
-	return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
-		      (struct sockaddr *)dst, sizeof(*dst));
-}
-
-/*! \brief helper function to generate a random request id */
-static void stun_req_id(struct stun_header *req)
-{
-	int x;
-	for (x = 0; x < 4; x++)
-		req->id.id[x] = ast_random();
-}
-
-size_t ast_rtp_alloc_size(void)
-{
-	return sizeof(struct ast_rtp);
-}
-
-/*! \brief callback type to be invoked on stun responses. */
-typedef int (stun_cb_f)(struct stun_attr *attr, void *arg);
-
-/*! \brief handle an incoming STUN message.
- *
- * Do some basic sanity checks on packet size and content,
- * try to extract a bit of information, and possibly reply.
- * At the moment this only processes BIND requests, and returns
- * the externally visible address of the request.
- * If a callback is specified, invoke it with the attribute.
- */
-static int stun_handle_packet(int s, struct sockaddr_in *src,
-	unsigned char *data, size_t len, stun_cb_f *stun_cb, void *arg)
-{
-	struct stun_header *hdr = (struct stun_header *)data;
-	struct stun_attr *attr;
-	struct stun_state st;
-	int ret = STUN_IGNORE;	
-	int x;
-
-	/* On entry, 'len' is the length of the udp payload. After the
-	 * initial checks it becomes the size of unprocessed options,
-	 * while 'data' is advanced accordingly.
-	 */
-	if (len < sizeof(struct stun_header)) {
-		ast_debug(1, "Runt STUN packet (only %d, wanting at least %d)\n", (int) len, (int) sizeof(struct stun_header));
-		return -1;
-	}
-	len -= sizeof(struct stun_header);
-	data += sizeof(struct stun_header);
-	x = ntohs(hdr->msglen);	/* len as advertised in the message */
-	if (stundebug)
-		ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), x);
-	if (x > len) {
-		ast_debug(1, "Scrambled STUN packet length (got %d, expecting %d)\n", x, (int)len);
-	} else
-		len = x;
-	memset(&st, 0, sizeof(st));
-	while (len) {
-		if (len < sizeof(struct stun_attr)) {
-			ast_debug(1, "Runt Attribute (got %d, expecting %d)\n", (int)len, (int) sizeof(struct stun_attr));
-			break;
-		}
-		attr = (struct stun_attr *)data;
-		/* compute total attribute length */
-		x = ntohs(attr->len) + sizeof(struct stun_attr);
-		if (x > len) {
-			ast_debug(1, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", x, (int)len);
-			break;
-		}
-		if (stun_cb)
-			stun_cb(attr, arg);
-		if (stun_process_attr(&st, attr)) {
-			ast_debug(1, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
-			break;
-		}
-		/* Clear attribute id: in case previous entry was a string,
-		 * this will act as the terminator for the string.
-		 */
-		attr->attr = 0;
-		data += x;
-		len -= x;
-	}
-	/* Null terminate any string.
-	 * XXX NOTE, we write past the size of the buffer passed by the
-	 * caller, so this is potentially dangerous. The only thing that
-	 * saves us is that usually we read the incoming message in a
-	 * much larger buffer in the struct ast_rtp
-	 */
-	*data = '\0';
-
-	/* Now prepare to generate a reply, which at the moment is done
-	 * only for properly formed (len == 0) STUN_BINDREQ messages.
-	 */
-	if (len == 0) {
-		unsigned char respdata[1024];
-		struct stun_header *resp = (struct stun_header *)respdata;
-		int resplen = 0;	/* len excluding header */
-		int respleft = sizeof(respdata) - sizeof(struct stun_header);
-
-		resp->id = hdr->id;
-		resp->msgtype = 0;
-		resp->msglen = 0;
-		attr = (struct stun_attr *)resp->ies;
-		switch (ntohs(hdr->msgtype)) {
-		case STUN_BINDREQ:
-			if (stundebug)
-				ast_verbose("STUN Bind Request, username: %s\n", 
-					    st.username ? st.username : "<none>");
-			if (st.username)
-				append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
-			append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
-			resp->msglen = htons(resplen);
-			resp->msgtype = htons(STUN_BINDRESP);
-			stun_send(s, src, resp);
-			ret = STUN_ACCEPT;
-			break;
-		default:
-			if (stundebug)
-				ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
-		}
-	}
-	return ret;
-}
-
-/*! \brief Extract the STUN_MAPPED_ADDRESS from the stun response.
- * This is used as a callback for stun_handle_response
- * when called from ast_stun_request.
- */
-static int stun_get_mapped(struct stun_attr *attr, void *arg)
-{
-	struct stun_addr *addr = (struct stun_addr *)(attr + 1);
-	struct sockaddr_in *sa = (struct sockaddr_in *)arg;
-
-	if (ntohs(attr->attr) != STUN_MAPPED_ADDRESS || ntohs(attr->len) != 8)
-		return 1;	/* not us. */
-	sa->sin_port = addr->port;
-	sa->sin_addr.s_addr = addr->addr;
-	return 0;
-}
-
-/*! \brief Generic STUN request
- * Send a generic stun request to the server specified,
- * possibly waiting for a reply and filling the 'reply' field with
- * the externally visible address. Note that in this case the request
- * will be blocking.
- * (Note, the interface may change slightly in the future).
- *
- * \param s the socket used to send the request
- * \param dst the address of the STUN server
- * \param username if non null, add the username in the request
- * \param answer if non null, the function waits for a response and
- *    puts here the externally visible address.
- * \return 0 on success, other values on error.
- */
-int ast_stun_request(int s, struct sockaddr_in *dst,
-	const char *username, struct sockaddr_in *answer)
-{
-	struct stun_header *req;
-	unsigned char reqdata[1024];
-	int reqlen, reqleft;
-	struct stun_attr *attr;
-	int res = 0;
-	int retry;
-	
-	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);
-	for (retry = 0; retry < 3; retry++) {	/* XXX make retries configurable */
-		/* send request, possibly wait for reply */
-		unsigned char reply_buf[1024];
-		fd_set rfds;
-		struct timeval to = { 3, 0 };	/* timeout, make it configurable */
-		struct sockaddr_in src;
-		socklen_t srclen;
-
-		res = stun_send(s, dst, req);
-		if (res < 0) {
-			ast_log(LOG_WARNING, "ast_stun_request send #%d failed error %d, retry\n",
-				retry, res);
-			continue;
-		}
-		if (answer == NULL)
-			break;
-		FD_ZERO(&rfds);
-		FD_SET(s, &rfds);
-		res = ast_select(s + 1, &rfds, NULL, NULL, &to);
-		if (res <= 0)	/* timeout or error */
-			continue;
-		memset(&src, '\0', sizeof(src));
-		srclen = sizeof(src);
-		/* XXX pass -1 in the size, because stun_handle_packet might
-		 * write past the end of the buffer.
-		 */
-		res = recvfrom(s, reply_buf, sizeof(reply_buf) - 1,
-			0, (struct sockaddr *)&src, &srclen);
-		if (res < 0) {
-			ast_log(LOG_WARNING, "ast_stun_request recvfrom #%d failed error %d, retry\n",
-				retry, res);
-			continue;
-		}
-		memset(answer, '\0', sizeof(struct sockaddr_in));
-		stun_handle_packet(s, &src, reply_buf, res,
-			stun_get_mapped, answer);
-		res = 0; /* signal regular exit */
-		break;
-	}
-	return res;
-}
-
-/*! \brief send a STUN BIND request to the given destination.
- * Optionally, add a username if specified.
- */
-void ast_rtp_stun_request(struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
-{
-	ast_stun_request(rtp->s, suggestion, username, NULL);
-}
-
-/*! \brief List of current sessions */
-static AST_RWLIST_HEAD_STATIC(protos, ast_rtp_protocol);
-
-static void timeval2ntp(struct timeval when, unsigned int *msw, unsigned int *lsw)
-{
-	unsigned int sec, usec, frac;
-	sec = when.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
-	usec = when.tv_usec;
-	frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
-	*msw = sec;
-	*lsw = frac;
-}
-
-int ast_rtp_fd(struct ast_rtp *rtp)
-{
-	return rtp->s;
-}
-
-int ast_rtcp_fd(struct ast_rtp *rtp)
-{
-	if (rtp->rtcp)
-		return rtp->rtcp->s;
-	return -1;
-}
-
-unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
-{
-	unsigned int interval;
-	/*! \todo XXX Do a more reasonable calculation on this one
-	 * Look in RFC 3550 Section A.7 for an example*/
-	interval = rtcpinterval;
-	return interval;
-}
-
-/* \brief Put RTP timeout timers on hold during another transaction, like T.38 */
-void ast_rtp_set_rtptimers_onhold(struct ast_rtp *rtp)
-{
-	rtp->rtptimeout = (-1) * rtp->rtptimeout;
-	rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout;
-}
-
-/*! \brief Set rtp timeout */
-void ast_rtp_set_rtptimeout(struct ast_rtp *rtp, int timeout)
-{
-	rtp->rtptimeout = timeout;
-}
-
-/*! \brief Set rtp hold timeout */
-void ast_rtp_set_rtpholdtimeout(struct ast_rtp *rtp, int timeout)
-{
-	rtp->rtpholdtimeout = timeout;
-}
-
-/*! \brief set RTP keepalive interval */
-void ast_rtp_set_rtpkeepalive(struct ast_rtp *rtp, int period)
-{
-	rtp->rtpkeepalive = period;
-}
-
-/*! \brief Get rtp timeout */
-int ast_rtp_get_rtptimeout(struct ast_rtp *rtp)
-{
-	if (rtp->rtptimeout < 0)	/* We're not checking, but remembering the setting (during T.38 transmission) */
-		return 0;
-	return rtp->rtptimeout;
-}
-
-/*! \brief Get rtp hold timeout */
-int ast_rtp_get_rtpholdtimeout(struct ast_rtp *rtp)
-{
-	if (rtp->rtptimeout < 0)	/* We're not checking, but remembering the setting (during T.38 transmission) */
-		return 0;
-	return rtp->rtpholdtimeout;
-}
-
-/*! \brief Get RTP keepalive interval */
-int ast_rtp_get_rtpkeepalive(struct ast_rtp *rtp)
-{
-	return rtp->rtpkeepalive;
-}
-
-void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
-{
-	rtp->data = data;
-}
-
-void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
-{
-	rtp->callback = callback;
-}
-
-void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
-{
-	rtp->nat = nat;
-}
-
-int ast_rtp_getnat(struct ast_rtp *rtp)
-{
-	return ast_test_flag(rtp, FLAG_NAT_ACTIVE);
-}
-
-void ast_rtp_setdtmf(struct ast_rtp *rtp, int dtmf)
-{
-	ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF);
-}
-
-void ast_rtp_setdtmfcompensate(struct ast_rtp *rtp, int compensate)
-{
-	ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE);
-}
-
-void ast_rtp_setstun(struct ast_rtp *rtp, int stun_enable)
-{
-	ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN);
-}
-
-static void rtp_bridge_lock(struct ast_rtp *rtp)
-{
-#ifdef P2P_INTENSE
-	ast_mutex_lock(&rtp->bridge_lock);
-#endif
-	return;
-}
-
-static void rtp_bridge_unlock(struct ast_rtp *rtp)
-{
-#ifdef P2P_INTENSE
-	ast_mutex_unlock(&rtp->bridge_lock);
-#endif
-	return;
-}
-
-/*! \brief Calculate normal deviation */
-static double normdev_compute(double normdev, double sample, unsigned int sample_count)
-{
-	normdev = normdev * sample_count + sample;
-	sample_count++;
-
-	return normdev / sample_count;
-}
-
-static double stddev_compute(double stddev, double sample, double normdev, double normdev_curent, unsigned int sample_count)
-{
-/*
-		for the formula check http://www.cs.umd.edu/~austinjp/constSD.pdf
-		return sqrt( (sample_count*pow(stddev,2) + sample_count*pow((sample-normdev)/(sample_count+1),2) + pow(sample-normdev_curent,2)) / (sample_count+1));
-		we can compute the sigma^2 and that way we would have to do the sqrt only 1 time at the end and would save another pow 2 compute
-		optimized formula
-*/
-#define SQUARE(x) ((x) * (x))
-
-	stddev = sample_count * stddev;
-	sample_count++;
-
-	return stddev + 
-	       ( sample_count * SQUARE( (sample - normdev) / sample_count ) ) + 
-	       ( SQUARE(sample - normdev_curent) / sample_count );
-
-#undef SQUARE
-}
-
-static struct ast_frame *send_dtmf(struct ast_rtp *rtp, enum ast_frame_type type)
-{
-	if (((ast_test_flag(rtp, FLAG_DTMF_COMPENSATE) && type == AST_FRAME_DTMF_END) ||
-	     (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
-		ast_debug(1, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(rtp->them.sin_addr));
-		rtp->resp = 0;
-		rtp->dtmfsamples = 0;
-		return &ast_null_frame;
-	}
-	ast_debug(1, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(rtp->them.sin_addr));
-	if (rtp->resp == 'X') {
-		rtp->f.frametype = AST_FRAME_CONTROL;
-		rtp->f.subclass = AST_CONTROL_FLASH;
-	} else {
-		rtp->f.frametype = type;
-		rtp->f.subclass = rtp->resp;
-	}
-	rtp->f.datalen = 0;
-	rtp->f.samples = 0;
-	rtp->f.mallocd = 0;
-	rtp->f.src = "RTP";
-	return &rtp->f;
-	
-}
-
-static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
-{
-	if (rtpdebug == 0)
-		return 0;
-	if (rtpdebugaddr.sin_addr.s_addr) {
-		if (((ntohs(rtpdebugaddr.sin_port) != 0)
-		     && (rtpdebugaddr.sin_port != addr->sin_port))
-		    || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
-			return 0;
-	}
-	return 1;
-}
-
-static inline int rtcp_debug_test_addr(struct sockaddr_in *addr)
-{
-	if (rtcpdebug == 0)
-		return 0;
-	if (rtcpdebugaddr.sin_addr.s_addr) {
-		if (((ntohs(rtcpdebugaddr.sin_port) != 0)
-		     && (rtcpdebugaddr.sin_port != addr->sin_port))
-		    || (rtcpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
-			return 0;
-	}
-	return 1;
-}
-
-
-static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
-{
-	unsigned int event;
-	char resp = 0;
-	struct ast_frame *f = NULL;
-	unsigned char seq;
-	unsigned int flags;
-	unsigned int power;
-
-	/* We should have at least 4 bytes in RTP data */
-	if (len < 4)
-		return f;
-
-	/*	The format of Cisco RTP DTMF packet looks like next:
-		+0				- sequence number of DTMF RTP packet (begins from 1,
-						  wrapped to 0)
-		+1				- set of flags
-		+1 (bit 0)		- flaps by different DTMF digits delimited by audio
-						  or repeated digit without audio???
-		+2 (+4,+6,...)	- power level? (rises from 0 to 32 at begin of tone
-						  then falls to 0 at its end)
-		+3 (+5,+7,...)	- detected DTMF digit (0..9,*,#,A-D,...)
-		Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
-		by each new packet and thus provides some redudancy.
-		
-		Sample of Cisco RTP DTMF packet is (all data in hex):
-			19 07 00 02 12 02 20 02
-		showing end of DTMF digit '2'.
-
-		The packets
-			27 07 00 02 0A 02 20 02
-			28 06 20 02 00 02 0A 02
-		shows begin of new digit '2' with very short pause (20 ms) after
-		previous digit '2'. Bit +1.0 flips at begin of new digit.
-		
-		Cisco RTP DTMF packets comes as replacement of audio RTP packets
-		so its uses the same sequencing and timestamping rules as replaced
-		audio packets. Repeat interval of DTMF packets is 20 ms and not rely
-		on audio framing parameters. Marker bit isn't used within stream of
-		DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
-		are not sequential at borders between DTMF and audio streams,
-	*/
-
-	seq = data[0];
-	flags = data[1];
-	power = data[2];
-	event = data[3] & 0x1f;
-
-	if (option_debug > 2 || rtpdebug)
-		ast_debug(0, "Cisco DTMF Digit: %02x (len=%d, seq=%d, flags=%02x, power=%d, history count=%d)\n", event, len, seq, flags, power, (len - 4) / 2);
-	if (event < 10) {
-		resp = '0' + event;
-	} else if (event < 11) {
-		resp = '*';
-	} else if (event < 12) {
-		resp = '#';
-	} else if (event < 16) {
-		resp = 'A' + (event - 12);
-	} else if (event < 17) {
-		resp = 'X';
-	}
-	if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
-		rtp->resp = resp;
-		/* Why we should care on DTMF compensation at reception? */
-		if (!ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
-			f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
-			rtp->dtmfsamples = 0;
-		}
-	} else if ((rtp->resp == resp) && !power) {
-		f = send_dtmf(rtp, AST_FRAME_DTMF_END);
-		f->samples = rtp->dtmfsamples * 8;
-		rtp->resp = 0;
-	} else if (rtp->resp == resp)
-		rtp->dtmfsamples += 20 * 8;
-	rtp->dtmfcount = dtmftimeout;
-	return f;
-}
-
-/*! 
- * \brief Process RTP DTMF and events according to RFC 2833.
- * 
- * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
- * 
- * \param rtp
- * \param data
- * \param len
- * \param seqno
- * \param timestamp
- * \returns
- */
-static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp)
-{
-	unsigned int event;
-	unsigned int event_end;
-	unsigned int samples;
-	char resp = 0;
-	struct ast_frame *f = NULL;
-
-	/* Figure out event, event end, and samples */
-	event = ntohl(*((unsigned int *)(data)));
-	event >>= 24;
-	event_end = ntohl(*((unsigned int *)(data)));
-	event_end <<= 8;
-	event_end >>= 24;
-	samples = ntohl(*((unsigned int *)(data)));
-	samples &= 0xFFFF;
-
-	/* Print out debug if turned on */
-	if (rtpdebug || option_debug > 2)
-		ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
-
-	/* Figure out what digit was pressed */
-	if (event < 10) {
-		resp = '0' + event;
-	} else if (event < 11) {
-		resp = '*';
-	} else if (event < 12) {
-		resp = '#';
-	} else if (event < 16) {
-		resp = 'A' + (event - 12);
-	} else if (event < 17) {	/* Event 16: Hook flash */
-		resp = 'X';	
-	} else {
-		/* Not a supported event */
-		ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
-		return &ast_null_frame;
-	}
-
-	if (ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
-		if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
-			rtp->resp = resp;
-			rtp->dtmfcount = 0;
-			f = send_dtmf(rtp, AST_FRAME_DTMF_END);
-			f->len = 0;
-			rtp->lastevent = timestamp;
-		}
-	} else {
-		if ((!(rtp->resp) && (!(event_end & 0x80))) || (rtp->resp && rtp->resp != resp)) {
-			rtp->resp = resp;
-			f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
-			rtp->dtmfcount = dtmftimeout;
-		} else if ((event_end & 0x80) && (rtp->lastevent != seqno) && rtp->resp) {
-			f = send_dtmf(rtp, AST_FRAME_DTMF_END);
-			f->len = ast_tvdiff_ms(ast_samp2tv(samples, 8000), ast_tv(0, 0)); /* XXX hard coded 8kHz */
-			rtp->resp = 0;
-			rtp->dtmfcount = 0;
-			rtp->lastevent = seqno;
-		}
-	}
-
-	rtp->dtmfsamples = samples;
-
-	return f;
-}
-
-/*!
- * \brief Process Comfort Noise RTP.
- * 
- * This is incomplete at the moment.
- * 
-*/
-static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
-{
-	struct ast_frame *f = NULL;
-	/* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
-	   totally help us out becuase we don't have an engine to keep it going and we are not
-	   guaranteed to have it every 20ms or anything */
-	if (rtpdebug)
-		ast_debug(0, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
-
-	if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
-		ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
-			ast_inet_ntoa(rtp->them.sin_addr));
-		ast_set_flag(rtp, FLAG_3389_WARNING);
-	}
-	
-	/* Must have at least one byte */
-	if (!len)
-		return NULL;
-	if (len < 24) {
-		rtp->f.data.ptr = rtp->rawdata + AST_FRIENDLY_OFFSET;
-		rtp->f.datalen = len - 1;
-		rtp->f.offset = AST_FRIENDLY_OFFSET;
-		memcpy(rtp->f.data.ptr, data + 1, len - 1);
-	} else {
-		rtp->f.data.ptr = NULL;
-		rtp->f.offset = 0;
-		rtp->f.datalen = 0;
-	}
-	rtp->f.frametype = AST_FRAME_CNG;
-	rtp->f.subclass = data[0] & 0x7f;
-	rtp->f.datalen = len - 1;
-	rtp->f.samples = 0;
-	rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
-	f = &rtp->f;
-	return f;
-}
-
-static int rtpread(int *id, int fd, short events, void *cbdata)
-{
-	struct ast_rtp *rtp = cbdata;
-	struct ast_frame *f;
-	f = ast_rtp_read(rtp);
-	if (f) {
-		if (rtp->callback)
-			rtp->callback(rtp, f, rtp->data);
-	}
-	return 1;
-}
-
-struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
-{
-	socklen_t len;
-	int position, i, packetwords;
-	int res;
-	struct sockaddr_in sock_in;
-	unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
-	unsigned int *rtcpheader;
-	int pt;
-	struct timeval now;
-	unsigned int length;
-	int rc;
-	double rttsec;
-	uint64_t rtt = 0;
-	unsigned int dlsr;
-	unsigned int lsr;
-	unsigned int msw;
-	unsigned int lsw;
-	unsigned int comp;
-	struct ast_frame *f = &ast_null_frame;
-	
-	double reported_jitter;
-	double reported_normdev_jitter_current;
-	double normdevrtt_current;
-	double reported_lost;
-	double reported_normdev_lost_current;
-
-	if (!rtp || !rtp->rtcp)
-		return &ast_null_frame;
-
-	len = sizeof(sock_in);
-	
-	res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
-					0, (struct sockaddr *)&sock_in, &len);
-	rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
-	
-	if (res < 0) {
-		ast_assert(errno != EBADF);
-		if (errno != EAGAIN) {
-			ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
-			return NULL;
-		}
-		return &ast_null_frame;
-	}
-
-	packetwords = res / 4;
-	
-	if (rtp->nat) {
-		/* Send to whoever sent to us */
-		if ((rtp->rtcp->them.sin_addr.s_addr != sock_in.sin_addr.s_addr) ||
-		    (rtp->rtcp->them.sin_port != sock_in.sin_port)) {
-			memcpy(&rtp->rtcp->them, &sock_in, sizeof(rtp->rtcp->them));
-			if (option_debug || rtpdebug)
-				ast_debug(0, "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));
-		}
-	}
-
-	ast_debug(1, "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) {
-			if (option_debug || rtpdebug)
-				ast_log(LOG_DEBUG, "RTCP Read too short\n");
-			return &ast_null_frame;
-		}
-		
-		if (rtcp_debug_test_addr(&sock_in)) {
-		  	ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sock_in.sin_addr), ntohs(sock_in.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]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
- 
-			if (rtcp_debug_test_addr(&sock_in)) {
-				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:
-			/* Don't handle multiple reception reports (rc > 1) yet */
-			/* Calculate RTT per RFC */
-			gettimeofday(&now, NULL);
-			timeval2ntp(now, &msw, &lsw);
-			if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
-				comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
-				lsr = ntohl(rtcpheader[i + 4]);
-				dlsr = ntohl(rtcpheader[i + 5]);
-				rtt = comp - lsr - dlsr;
-
-				/* Convert end to end delay to usec (keeping the calculation in 64bit space)
-				   sess->ee_delay = (eedelay * 1000) / 65536; */
-				if (rtt < 4294) {
-				    rtt = (rtt * 1000000) >> 16;
-				} else {
-				    rtt = (rtt * 1000) >> 16;
-				    rtt *= 1000;
-				}
-				rtt = rtt / 1000.;
-				rttsec = rtt / 1000.;
-				rtp->rtcp->rtt = rttsec;
-
-				if (comp - dlsr >= lsr) {
-					rtp->rtcp->accumulated_transit += rttsec;
-
-					if (rtp->rtcp->rtt_count == 0) 
-						rtp->rtcp->minrtt = rttsec;
-
-					if (rtp->rtcp->maxrtt<rttsec)
-						rtp->rtcp->maxrtt = rttsec;
-
-					if (rtp->rtcp->minrtt>rttsec)
-						rtp->rtcp->minrtt = rttsec;
-
-					normdevrtt_current = normdev_compute(rtp->rtcp->normdevrtt, rttsec, rtp->rtcp->rtt_count);
-
-					rtp->rtcp->stdevrtt = stddev_compute(rtp->rtcp->stdevrtt, rttsec, rtp->rtcp->normdevrtt, normdevrtt_current, rtp->rtcp->rtt_count);
-
-					rtp->rtcp->normdevrtt = normdevrtt_current;
-
-					rtp->rtcp->rtt_count++;
-				} else if (rtcp_debug_test_addr(&sock_in)) {
-					ast_verbose("Internal RTCP NTP clock skew detected: "
-							   "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
-							   "diff=%d\n",
-							   lsr, comp, dlsr, dlsr / 65536,
-							   (dlsr % 65536) * 1000 / 65536,
-							   dlsr - (comp - lsr));
-				}
-			}
-
-			rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
-			reported_jitter = (double) rtp->rtcp->reported_jitter;
-
-			if (rtp->rtcp->reported_jitter_count == 0) 
-				rtp->rtcp->reported_minjitter = reported_jitter;
-
-			if (reported_jitter < rtp->rtcp->reported_minjitter) 
-				rtp->rtcp->reported_minjitter = reported_jitter;
-
-			if (reported_jitter > rtp->rtcp->reported_maxjitter) 
-				rtp->rtcp->reported_maxjitter = reported_jitter;
-
-			reported_normdev_jitter_current = normdev_compute(rtp->rtcp->reported_normdev_jitter, reported_jitter, rtp->rtcp->reported_jitter_count);
-
-			rtp->rtcp->reported_stdev_jitter = stddev_compute(rtp->rtcp->reported_stdev_jitter, reported_jitter, rtp->rtcp->reported_normdev_jitter, reported_normdev_jitter_current, rtp->rtcp->reported_jitter_count);
-
-			rtp->rtcp->reported_normdev_jitter = reported_normdev_jitter_current;
-
-			rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
-
-			reported_lost = (double) rtp->rtcp->reported_lost;
-
-			/* using same counter as for jitter */
-			if (rtp->rtcp->reported_jitter_count == 0)
-				rtp->rtcp->reported_minlost = reported_lost;
-
-			if (reported_lost < rtp->rtcp->reported_minlost)
-				rtp->rtcp->reported_minlost = reported_lost;
-
-			if (reported_lost > rtp->rtcp->reported_maxlost) 
-				rtp->rtcp->reported_maxlost = reported_lost;
-
-			reported_normdev_lost_current = normdev_compute(rtp->rtcp->reported_normdev_lost, reported_lost, rtp->rtcp->reported_jitter_count);
-
-			rtp->rtcp->reported_stdev_lost = stddev_compute(rtp->rtcp->reported_stdev_lost, reported_lost, rtp->rtcp->reported_normdev_lost, reported_normdev_lost_current, rtp->rtcp->reported_jitter_count);
-
-			rtp->rtcp->reported_normdev_lost = reported_normdev_lost_current;
-
-			rtp->rtcp->reported_jitter_count++;
-
-			if (rtcp_debug_test_addr(&sock_in)) {
-				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: %lu(sec)\n", (unsigned long) rtt);
-			}
-
-			if (rtt) {
-				manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From: %s:%d\r\n"
-								    "PT: %d(%s)\r\n"
-								    "ReceptionReports: %d\r\n"
-								    "SenderSSRC: %u\r\n"
-								    "FractionLost: %ld\r\n"
-								    "PacketsLost: %d\r\n"
-								    "HighestSequence: %ld\r\n"
-								    "SequenceNumberCycles: %ld\r\n"
-								    "IAJitter: %u\r\n"
-								    "LastSR: %lu.%010lu\r\n"
-								    "DLSR: %4.4f(sec)\r\n"
-								    "RTT: %llu(sec)\r\n",
-								    ast_inet_ntoa(sock_in.sin_addr), ntohs(sock_in.sin_port),
-								    pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
-								    rc,
-								    rtcpheader[i + 1],
-								    (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
-								    rtp->rtcp->reported_lost,
-								    (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
-								    (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
-								    rtp->rtcp->reported_jitter,
-								    (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
-								    ntohl(rtcpheader[i + 5])/65536.0,
-								    (unsigned long long)rtt);
-			} else {
-				manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From: %s:%d\r\n"
-								    "PT: %d(%s)\r\n"
-								    "ReceptionReports: %d\r\n"
-								    "SenderSSRC: %u\r\n"
-								    "FractionLost: %ld\r\n"
-								    "PacketsLost: %d\r\n"
-								    "HighestSequence: %ld\r\n"
-								    "SequenceNumberCycles: %ld\r\n"
-								    "IAJitter: %u\r\n"
-								    "LastSR: %lu.%010lu\r\n"
-								    "DLSR: %4.4f(sec)\r\n",
-								    ast_inet_ntoa(sock_in.sin_addr), ntohs(sock_in.sin_port),
-								    pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
-								    rc,
-								    rtcpheader[i + 1],
-								    (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
-								    rtp->rtcp->reported_lost,
-								    (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
-								    (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
-								    rtp->rtcp->reported_jitter,
-								    (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
-								    ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
-								    ntohl(rtcpheader[i + 5])/65536.0);
-			}
-			break;
-		case RTCP_PT_FUR:
-			if (rtcp_debug_test_addr(&sock_in))
-				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(&sock_in))
-				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(&sock_in))
-				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:
-			ast_debug(1, "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);
-	}
-	rtp->rtcp->rtcp_info = 1;	
-	return f;
-}
-
-static void calc_rxstamp(struct timeval *when, struct ast_rtp *rtp, unsigned int timestamp, int mark)
-{
-	struct timeval now;
-	double transit;
-	double current_time;
-	double d;
-	double dtv;
-	double prog;
-	
-	double normdev_rxjitter_current;
-	if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
-		gettimeofday(&rtp->rxcore, NULL);
-		rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
-		/* map timestamp to a real time */
-		rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
-		rtp->rxcore.tv_sec -= timestamp / 8000;
-		rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
-		/* Round to 0.1ms for nice, pretty timestamps */
-		rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
-		if (rtp->rxcore.tv_usec < 0) {
-			/* Adjust appropriately if necessary */
-			rtp->rxcore.tv_usec += 1000000;
-			rtp->rxcore.tv_sec -= 1;
-		}
-	}
-
-	gettimeofday(&now,NULL);
-	/* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
-	when->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
-	when->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
-	if (when->tv_usec >= 1000000) {
-		when->tv_usec -= 1000000;
-		when->tv_sec += 1;
-	}
-	prog = (double)((timestamp-rtp->seedrxts)/8000.);
-	dtv = (double)rtp->drxcore + (double)(prog);
-	current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
-	transit = current_time - dtv;
-	d = transit - rtp->rxtransit;
-	rtp->rxtransit = transit;
-	if (d<0)
-		d=-d;
-	rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
-	if (rtp->rtcp && rtp->rxjitter > rtp->rtcp->maxrxjitter)
-		rtp->rtcp->maxrxjitter = rtp->rxjitter;
-	if (rtp->rtcp->rxjitter_count == 1) 
-		rtp->rtcp->minrxjitter = rtp->rxjitter;
-	if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
-		rtp->rtcp->minrxjitter = rtp->rxjitter;
-		
-	normdev_rxjitter_current = normdev_compute(rtp->rtcp->normdev_rxjitter,rtp->rxjitter,rtp->rtcp->rxjitter_count);
-	rtp->rtcp->stdev_rxjitter = stddev_compute(rtp->rtcp->stdev_rxjitter,rtp->rxjitter,rtp->rtcp->normdev_rxjitter,normdev_rxjitter_current,rtp->rtcp->rxjitter_count);
-
-	rtp->rtcp->normdev_rxjitter = normdev_rxjitter_current;
-	rtp->rtcp->rxjitter_count++;
-}
-
-/*! \brief Perform a Packet2Packet RTP write */
-static int bridge_p2p_rtp_write(struct ast_rtp *rtp, struct ast_rtp *bridged, unsigned int *rtpheader, int len, int hdrlen)
-{
-	int res = 0, payload = 0, bridged_payload = 0, mark;
-	struct rtpPayloadType rtpPT;
-	int reconstruct = ntohl(rtpheader[0]);
-
-	/* Get fields from packet */
-	payload = (reconstruct & 0x7f0000) >> 16;
-	mark = (((reconstruct & 0x800000) >> 23) != 0);
-
-	/* Check what the payload value should be */
-	rtpPT = ast_rtp_lookup_pt(rtp, payload);
-
-	/* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
-	if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) && !rtpPT.isAstFormat && rtpPT.code == AST_RTP_DTMF)
-		return -1;
-
-	/* Otherwise adjust bridged payload to match */
-	bridged_payload = ast_rtp_lookup_code(bridged, rtpPT.isAstFormat, rtpPT.code);
-
-	/* If the payload coming in is not one of the negotiated ones then send it to the core, this will cause formats to change and the bridge to break */
-	if (!bridged->current_RTP_PT[bridged_payload].code)
-		return -1;
-
-
-	/* If the mark bit has not been sent yet... do it now */
-	if (!ast_test_flag(rtp, FLAG_P2P_SENT_MARK)) {
-		mark = 1;
-		ast_set_flag(rtp, FLAG_P2P_SENT_MARK);
-	}
-
-	/* Reconstruct part of the packet */
-	reconstruct &= 0xFF80FFFF;
-	reconstruct |= (bridged_payload << 16);
-	reconstruct |= (mark << 23);
-	rtpheader[0] = htonl(reconstruct);
-
-	/* Send the packet back out */
-	res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&bridged->them, sizeof(bridged->them));
-	if (res < 0) {
-		if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
-			ast_debug(1, "RTP Transmission error of packet to %s:%d: %s\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), strerror(errno));
-		} else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
-			if (option_debug || rtpdebug)
-				ast_debug(0, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port));
-			ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
-		}
-		return 0;
-	} else if (rtp_debug_test_addr(&bridged->them))
-			ast_verbose("Sent RTP P2P packet to %s:%u (type %-2.2d, len %-6.6u)\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), bridged_payload, len - hdrlen);
-
-	return 0;
-}
-
-struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
-{
-	int res;
-	struct sockaddr_in sock_in;
-	socklen_t len;
-	unsigned int seqno;
-	int version;
-	int payloadtype;
-	int hdrlen = 12;
-	int padding;
-	int mark;
-	int ext;
-	int cc;
-	unsigned int ssrc;
-	unsigned int timestamp;
-	unsigned int *rtpheader;
-	struct rtpPayloadType rtpPT;
-	struct ast_rtp *bridged = NULL;
-	int prev_seqno;
-	
-	/* If time is up, kill it */
-	if (rtp->sending_digit)
-		ast_rtp_senddigit_continuation(rtp);
-
-	len = sizeof(sock_in);
-	
-	/* Cache where the header will go */
-	res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
-					0, (struct sockaddr *)&sock_in, &len);
-
-	/* If strict RTP protection is enabled see if we need to learn this address or if the packet should be dropped */
-	if (rtp->strict_rtp_state == STRICT_RTP_LEARN) {
-		/* Copy over address that this packet was received on */
-		memcpy(&rtp->strict_rtp_address, &sock_in, sizeof(rtp->strict_rtp_address));
-		/* Now move over to actually protecting the RTP port */
-		rtp->strict_rtp_state = STRICT_RTP_CLOSED;
-		ast_debug(1, "Learned remote address is %s:%d for strict RTP purposes, now protecting the port.\n", ast_inet_ntoa(rtp->strict_rtp_address.sin_addr), ntohs(rtp->strict_rtp_address.sin_port));
-	} else if (rtp->strict_rtp_state == STRICT_RTP_CLOSED) {
-		/* If the address we previously learned doesn't match the address this packet came in on simply drop it */
-		if ((rtp->strict_rtp_address.sin_addr.s_addr != sock_in.sin_addr.s_addr) || (rtp->strict_rtp_address.sin_port != sock_in.sin_port)) {
-			ast_debug(1, "Received RTP packet from %s:%d, dropping due to strict RTP protection. Expected it to be from %s:%d\n", ast_inet_ntoa(sock_in.sin_addr), ntohs(sock_in.sin_port), ast_inet_ntoa(rtp->strict_rtp_address.sin_addr), ntohs(rtp->strict_rtp_address.sin_port));
-			return &ast_null_frame;
-		}
-	}
-
-	rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
-	if (res < 0) {
-		ast_assert(errno != EBADF);
-		if (errno != EAGAIN) {
-			ast_log(LOG_WARNING, "RTP Read error: %s.  Hanging up.\n", strerror(errno));
-			return NULL;
-		}
-		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 the two high bits are 0, this might be a
-		 * STUN message, so process it. stun_handle_packet()
-		 * answers to requests, and it returns STUN_ACCEPT
-		 * if the request is valid.
-		 */
-		if ((stun_handle_packet(rtp->s, &sock_in, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == STUN_ACCEPT) &&
-			(!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
-			memcpy(&rtp->them, &sock_in, 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 != sock_in.sin_addr.s_addr) ||
-		    (rtp->them.sin_port != sock_in.sin_port)) {
-			rtp->them = sock_in;
-			if (rtp->rtcp) {
-				int h = 0;
-				memcpy(&rtp->rtcp->them, &sock_in, sizeof(rtp->rtcp->them));
-				h = ntohs(rtp->them.sin_port);
-				rtp->rtcp->them.sin_port = htons(h + 1);
-			}
-			rtp->rxseqno = 0;
-			ast_set_flag(rtp, FLAG_NAT_ACTIVE);
-			if (option_debug || rtpdebug)
-				ast_debug(0, "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);
-	cc = (seqno & 0xF000000) >> 24;
-	seqno &= 0xffff;
-	timestamp = ntohl(rtpheader[1]);
-	ssrc = ntohl(rtpheader[2]);
-	
-	if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
-		if (option_debug || rtpdebug)
-			ast_debug(0, "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 (cc) {
-		/* CSRC fields present */
-		hdrlen += cc*4;
-	}
-
-	if (ext) {
-		/* RTP Extension present */
-		hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
-		hdrlen += 4;
-		if (option_debug) {
-			int profile;
-			profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
-			if (profile == 0x505a)
-				ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
-			else
-				ast_debug(1, "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 */
-
-	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 ((int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
-		rtp->cycles += RTP_SEQ_MOD;
-	
-	prev_seqno = rtp->lastrxseqno;
-
-	rtp->lastrxseqno = seqno;
-	
-	if (!rtp->themssrc)
-		rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
-	
-	if (rtp_debug_test_addr(&sock_in))
-		ast_verbose("Got  RTP packet from    %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
-			ast_inet_ntoa(sock_in.sin_addr), ntohs(sock_in.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(&sock_in)) {
-				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(sock_in.sin_addr), ntohs(sock_in.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, timestamp);
-		} else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
-			/* It's really special -- process it the Cisco way */
-			if (rtp->lastevent <= seqno || (rtp->lastevent >= 65530 && seqno <= 6)) {
-				f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
-				rtp->lastevent = 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_AUDIO_MASK) ? AST_FRAME_VOICE : (rtp->f.subclass & AST_FORMAT_VIDEO_MASK) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
-
-	rtp->rxseqno = seqno;
-
-	if (rtp->dtmfcount) {
-		rtp->dtmfcount -= (timestamp - rtp->lastrxts);
-
-		if (rtp->dtmfcount < 0) {
-			rtp->dtmfcount = 0;
-		}
-
-		if (rtp->resp && !rtp->dtmfcount) {
-			struct ast_frame *f;
-			f = send_dtmf(rtp, AST_FRAME_DTMF_END);
-			rtp->resp = 0;
-			return f;
-		}
-	}
-
-	/* Record received timestamp as last received now */
-	rtp->lastrxts = timestamp;
-
-	rtp->f.mallocd = 0;
-	rtp->f.datalen = res - hdrlen;
-	rtp->f.data.ptr = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
-	rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
-	rtp->f.seqno = seqno;
-
-	if (rtp->f.subclass == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
-		  unsigned char *data = rtp->f.data.ptr;
-		  
-		  memmove(rtp->f.data.ptr+3, rtp->f.data.ptr, rtp->f.datalen);
-		  rtp->f.datalen +=3;
-		  *data++ = 0xEF;
-		  *data++ = 0xBF;
-		  *data = 0xBD;
-	}
- 
-	if (rtp->f.subclass == AST_FORMAT_T140RED) {
-		unsigned char *data = rtp->f.data.ptr;
-		unsigned char *header_end;
-		int num_generations;
-		int header_length;
-		int length;
-		int diff =(int)seqno - (prev_seqno+1); /* if diff = 0, no drop*/
-		int x;
-
-		rtp->f.subclass = AST_FORMAT_T140;
-		header_end = memchr(data, ((*data) & 0x7f), rtp->f.datalen);
-		header_end++;
-		
-		header_length = header_end - data;
-		num_generations = header_length / 4;
-		length = header_length;
-
-		if (!diff) {
-			for (x = 0; x < num_generations; x++)
-				length += data[x * 4 + 3];
-			
-			if (!(rtp->f.datalen - length))
-				return &ast_null_frame;
-			
-			rtp->f.data.ptr += length;
-			rtp->f.datalen -= length;
-		} else if (diff > num_generations && diff < 10) {
-			length -= 3;
-			rtp->f.data.ptr += length;
-			rtp->f.datalen -= length;
-			
-			data = rtp->f.data.ptr;
-			*data++ = 0xEF;
-			*data++ = 0xBF;
-			*data = 0xBD;
-		} else 	{
-			for ( x = 0; x < num_generations - diff; x++) 
-				length += data[x * 4 + 3];
-			
-			rtp->f.data.ptr += length;
-			rtp->f.datalen -= length;
-		}
-	}
-
-	if (rtp->f.subclass & AST_FORMAT_AUDIO_MASK) {
-		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 */
-		ast_set_flag(&rtp->f, AST_FRFLAG_HAS_TIMING_INFO);
-		rtp->f.ts = timestamp / 8;
-		rtp->f.len = rtp->f.samples / ((ast_format_rate(rtp->f.subclass) / 1000));
-	} else if (rtp->f.subclass & AST_FORMAT_VIDEO_MASK) {
-		/* 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;
-		/* Pass the RTP marker bit as bit 0 in the subclass field.
-		 * This is ok because subclass is actually a bitmask, and
-		 * the low bits represent audio formats, that are not
-		 * involved here since we deal with video.
-		 */
-		if (mark)
-			rtp->f.subclass |= 0x1;
-	} else {
-		/* TEXT -- samples is # of samples vs. 1000 */
-		if (!rtp->lastitexttimestamp)
-			rtp->lastitexttimestamp = timestamp;
-		rtp->f.samples = timestamp - rtp->lastitexttimestamp;
-		rtp->lastitexttimestamp = timestamp;
-		rtp->f.delivery.tv_sec = 0;
-		rtp->f.delivery.tv_usec = 0;
-	}
-	rtp->f.src = "RTP";
-	return &rtp->f;
-}
-
-/* The following array defines the MIME Media type (and subtype) for each
-   of our codecs, or RTP-specific data type. */
-static const struct mimeType {
-	struct rtpPayloadType payloadType;
-	char *type;
-	char *subtype;
-	unsigned int sample_rate;
-} mimeTypes[] = {
-	{{1, AST_FORMAT_G723_1}, "audio", "G723", 8000},
-	{{1, AST_FORMAT_GSM}, "audio", "GSM", 8000},
-	{{1, AST_FORMAT_ULAW}, "audio", "PCMU", 8000},
-	{{1, AST_FORMAT_ULAW}, "audio", "G711U", 8000},
-	{{1, AST_FORMAT_ALAW}, "audio", "PCMA", 8000},
-	{{1, AST_FORMAT_ALAW}, "audio", "G711A", 8000},
-	{{1, AST_FORMAT_G726}, "audio", "G726-32", 8000},
-	{{1, AST_FORMAT_ADPCM}, "audio", "DVI4", 8000},
-	{{1, AST_FORMAT_SLINEAR}, "audio", "L16", 8000},
-	{{1, AST_FORMAT_LPC10}, "audio", "LPC", 8000},
-	{{1, AST_FORMAT_G729A}, "audio", "G729", 8000},
-	{{1, AST_FORMAT_G729A}, "audio", "G729A", 8000},
-	{{1, AST_FORMAT_G729A}, "audio", "G.729", 8000},
-	{{1, AST_FORMAT_SPEEX}, "audio", "speex", 8000},
-	{{1, AST_FORMAT_ILBC}, "audio", "iLBC", 8000},
-	/* this is the sample rate listed in the RTP profile for the G.722
-	   codec, *NOT* the actual sample rate of the media stream
-	*/
-	{{1, AST_FORMAT_G722}, "audio", "G722", 8000},
-	{{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32", 8000},
-	{{0, AST_RTP_DTMF}, "audio", "telephone-event", 8000},
-	{{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event", 8000},
-	{{0, AST_RTP_CN}, "audio", "CN", 8000},
-	{{1, AST_FORMAT_JPEG}, "video", "JPEG", 90000},
-	{{1, AST_FORMAT_PNG}, "video", "PNG", 90000},
-	{{1, AST_FORMAT_H261}, "video", "H261", 90000},
-	{{1, AST_FORMAT_H263}, "video", "H263", 90000},
-	{{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998", 90000},
-	{{1, AST_FORMAT_H264}, "video", "H264", 90000},
-	{{1, AST_FORMAT_MP4_VIDEO}, "video", "MP4V-ES", 90000},
-	{{1, AST_FORMAT_T140RED}, "text", "RED", 1000},
-	{{1, AST_FORMAT_T140}, "text", "T140", 1000},
-	{{1, AST_FORMAT_SIREN7}, "audio", "G7221", 16000},
-	{{1, AST_FORMAT_SIREN14}, "audio", "G7221", 32000},
-};
-
-/*! 
- * \brief Mapping between Asterisk codecs and rtp payload types
- *
- * Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
- * also, our own choices for dynamic payload types.  This is our master
- * table for transmission 
- * 
- * See http://www.iana.org/assignments/rtp-parameters for a list of
- * assigned values
- */
-static const struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
-	[0] = {1, AST_FORMAT_ULAW},
-#ifdef USE_DEPRECATED_G726
-	[2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
-#endif
-	[3] = {1, AST_FORMAT_GSM},
-	[4] = {1, AST_FORMAT_G723_1},
-	[5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
-	[6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
-	[7] = {1, AST_FORMAT_LPC10},
-	[8] = {1, AST_FORMAT_ALAW},
-	[9] = {1, AST_FORMAT_G722},
-	[10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
-	[11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
-	[13] = {0, AST_RTP_CN},
-	[16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
-	[17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
-	[18] = {1, AST_FORMAT_G729A},
-	[19] = {0, AST_RTP_CN},		/* Also used for CN */
-	[26] = {1, AST_FORMAT_JPEG},
-	[31] = {1, AST_FORMAT_H261},
-	[34] = {1, AST_FORMAT_H263},
-	[97] = {1, AST_FORMAT_ILBC},
-	[98] = {1, AST_FORMAT_H263_PLUS},
-	[99] = {1, AST_FORMAT_H264},
-	[101] = {0, AST_RTP_DTMF},
-	[102] = {1, AST_FORMAT_SIREN7},
-	[103] = {1, AST_FORMAT_H263_PLUS},
-	[104] = {1, AST_FORMAT_MP4_VIDEO},
-	[105] = {1, AST_FORMAT_T140RED},	/* Real time text chat (with redundancy encoding) */
-	[106] = {1, AST_FORMAT_T140},	/* Real time text chat */
-	[110] = {1, AST_FORMAT_SPEEX},
-	[111] = {1, AST_FORMAT_G726},
-	[112] = {1, AST_FORMAT_G726_AAL2},
-	[115] = {1, AST_FORMAT_SIREN14},
-	[121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
-};
-
-void ast_rtp_pt_clear(struct ast_rtp* rtp) 
-{
-	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_default(struct ast_rtp* rtp) 
-{
-	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);
-}
-
-void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
-{
-	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);
-}
-
-/*! \brief Get channel driver interface structure */
-static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
-{
-	struct ast_rtp_protocol *cur = NULL;
-
-	AST_RWLIST_RDLOCK(&protos);
-	AST_RWLIST_TRAVERSE(&protos, cur, list) {
-		if (cur->type == chan->tech->type)
-			break;
-	}
-	AST_RWLIST_UNLOCK(&protos);
-
-	return cur;
-}
-
-int ast_rtp_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
-{
-	struct ast_rtp *destp = NULL, *srcp = NULL;		/* Audio RTP Channels */
-	struct ast_rtp *vdestp = NULL, *vsrcp = NULL;		/* Video RTP channels */
-	struct ast_rtp *tdestp = NULL, *tsrcp = NULL;		/* Text 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, text_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, text_src_res = AST_RTP_GET_FAILED;
-	int srccodec, destcodec, 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) {
-		ast_debug(1, "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) {
-		ast_debug(1, "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, video  and text 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;
-	text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(c0, &tdestp) : 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;
-		text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(c1, &tsrcp) : 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 || (video_dest_res != AST_RTP_GET_FAILED && video_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 && (video_src_res == AST_RTP_GET_FAILED || video_src_res == AST_RTP_TRY_NATIVE) && srcpr->get_codec)
-		srccodec = srcpr->get_codec(c1);
-	else
-		srccodec = 0;
-	if (audio_dest_res == AST_RTP_TRY_NATIVE && (video_dest_res == AST_RTP_GET_FAILED || video_dest_res == AST_RTP_TRY_NATIVE) && destpr->get_codec)
-		destcodec = destpr->get_codec(c0);
-	else
-		destcodec = 0;
-	/* Ensure we have at least one matching codec */
-	if (srcp && !(srccodec & destcodec)) {
-		ast_channel_unlock(c0);
-		ast_channel_unlock(c1);
-		return 0;
-	}
-	/* Consider empty media as non-existent */
-	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, tsrcp, 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);
-	ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
-	return 0;
-}
-
-int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
-{
-	struct ast_rtp *destp = NULL, *srcp = NULL;		/* Audio RTP Channels */
-	struct ast_rtp *vdestp = NULL, *vsrcp = NULL;		/* Video RTP channels */
-	struct ast_rtp *tdestp = NULL, *tsrcp = NULL;		/* Text 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, text_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, text_src_res = AST_RTP_GET_FAILED; 
-	int srccodec, destcodec;
-
-	/* 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))) {
-		ast_debug(1, "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))) {
-		ast_debug(1, "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;
-	text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(dest, &tdestp) : 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;
-	text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(src, &tsrcp) : AST_RTP_GET_FAILED;
-
-	/* Ensure we have at least one matching codec */
-	if (srcpr->get_codec)
-		srccodec = srcpr->get_codec(src);
-	else
-		srccodec = 0;
-	if (destpr->get_codec)
-		destcodec = destpr->get_codec(dest);
-	else
-		destcodec = 0;
-
-	/* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
-	if (audio_dest_res != AST_RTP_TRY_NATIVE || (video_dest_res != AST_RTP_GET_FAILED && video_dest_res != AST_RTP_TRY_NATIVE) || audio_src_res != AST_RTP_TRY_NATIVE || (video_src_res != AST_RTP_GET_FAILED && video_src_res != AST_RTP_TRY_NATIVE) || !(srccodec & destcodec)) {
-		/* 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 (tdestp && tsrcp)
-		ast_rtp_pt_copy(tdestp, tsrcp);
-	if (media) {
-		/* Bridge early */
-		if (destpr->set_rtp_peer(dest, srcp, vsrcp, tsrcp, 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);
-	ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
-	return 1;
-}
-
-/*! \brief  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_m_type(struct ast_rtp* rtp, int pt) 
-{
-	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);
-} 
-
-/*! \brief remove setting from payload type list if the rtpmap header indicates
-	an unknown media type */
-void ast_rtp_unset_m_type(struct ast_rtp* rtp, int pt) 
-{
-	if (pt < 0 || pt > MAX_RTP_PT)
-		return; /* bogus payload type */
-
-	rtp_bridge_lock(rtp);
-	rtp->current_RTP_PT[pt].isAstFormat = 0;
-	rtp->current_RTP_PT[pt].code = 0;
-	rtp_bridge_unlock(rtp);
-}
-
-/*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
- * an SDP "a=rtpmap:" line.
- * \return 0 if the MIME type was found and set, -1 if it wasn't found
- */
-int ast_rtp_set_rtpmap_type_rate(struct ast_rtp *rtp, int pt,
-				 char *mimeType, char *mimeSubtype,
-				 enum ast_rtp_options options,
-				 unsigned int sample_rate)
-{
-	unsigned int i;
-	int found = 0;
-
-	if (pt < 0 || pt > MAX_RTP_PT)
-		return -1; /* bogus payload type */
-
-	rtp_bridge_lock(rtp);
-
-	for (i = 0; i < ARRAY_LEN(mimeTypes); ++i) {
-		const struct mimeType *t = &mimeTypes[i];
-
-		if (strcasecmp(mimeSubtype, t->subtype)) {
-			continue;
-		}
-
-		if (strcasecmp(mimeType, t->type)) {
-			continue;
-		}
-
-		/* if both sample rates have been supplied, and they don't match,
-		   then this not a match; if one has not been supplied, then the
-		   rates are not compared */
-		if (sample_rate && t->sample_rate &&
-		    (sample_rate != t->sample_rate)) {
-			continue;
-		}
-
-		found = 1;
-		rtp->current_RTP_PT[pt] = t->payloadType;
-
-		if ((t->payloadType.code == AST_FORMAT_G726) &&
-		    t->payloadType.isAstFormat &&
-		    (options & AST_RTP_OPT_G726_NONSTANDARD)) {
-			rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
-		}
-
-		break;
-	}
-
-	rtp_bridge_unlock(rtp);
-
-	return (found ? 0 : -2);
-}
-
-int ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
-			    char *mimeType, char *mimeSubtype,
-			    enum ast_rtp_options options)
-{
-	return ast_rtp_set_rtpmap_type_rate(rtp, pt, mimeType, mimeSubtype, options, 0);
-}
-
-/*! \brief 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 */
-void ast_rtp_get_current_formats(struct ast_rtp* rtp,
-				 int* astFormats, int* nonAstFormats)
-{
-	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);
-}
-
-struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
-{
-	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;
-}
-
-/*! \brief Looks up an RTP code out of our *static* outbound list */
-int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
-{
-	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;
-}
-
-const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
-				  enum ast_rtp_options options)
-{
-	unsigned int i;
-
-	for (i = 0; i < ARRAY_LEN(mimeTypes); ++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 "";
-}
-
-unsigned int ast_rtp_lookup_sample_rate(int isAstFormat, int code)
-{
-	unsigned int i;
-
-	for (i = 0; i < ARRAY_LEN(mimeTypes); ++i) {
-		if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
-			return mimeTypes[i].sample_rate;
-		}
-	}
-
-	return 0;
-}
-
-char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
-				   const int isAstFormat, enum ast_rtp_options options)
-{
-	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)
-		ast_copy_string(start, "nothing)", size); 
-	else if (size > 1)
-		*(end -1) = ')';
-	
-	return buf;
-}
-
-/*! \brief Open RTP or RTCP socket for a session.
- * Print a message on failure. 
- */
-static int rtp_socket(const char *type)
-{
-	int s = socket(AF_INET, SOCK_DGRAM, 0);
-	if (s < 0) {
-		if (type == NULL)
-			type = "RTP/RTCP";
-		ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
-	} else {
-		long flags = fcntl(s, F_GETFL);
-		fcntl(s, F_SETFL, flags | O_NONBLOCK);
-#ifdef SO_NO_CHECK
-		if (nochecksums)
-			setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
-#endif
-	}
-	return s;
-}
-
-/*!
- * \brief Initialize a new RTCP session.
- * 
- * \returns The newly initialized RTCP session.
- */
-static struct ast_rtcp *ast_rtcp_new(void)
-{
-	struct ast_rtcp *rtcp;
-
-	if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
-		return NULL;
-	rtcp->s = rtp_socket("RTCP");
-	rtcp->us.sin_family = AF_INET;
-	rtcp->them.sin_family = AF_INET;
-	rtcp->schedid = -1;
-
-	if (rtcp->s < 0) {
-		ast_free(rtcp);
-		return NULL;
-	}
-
-	return rtcp;
-}
-
-/*!
- * \brief Initialize a new RTP structure.
- *
- */
-void ast_rtp_new_init(struct ast_rtp *rtp)
-{
-#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);
-	rtp->strict_rtp_state = (strictrtp ? STRICT_RTP_LEARN : STRICT_RTP_OPEN);
-}
-
-struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
-{
-	struct ast_rtp *rtp;
-	int x;
-	int startplace;
-	
-	if (!(rtp = ast_calloc(1, sizeof(*rtp))))
-		return NULL;
-
-	ast_rtp_new_init(rtp);
-
-	rtp->s = rtp_socket("RTP");
-	if (rtp->s < 0)
-		goto fail;
-	if (sched && rtcpenable) {
-		rtp->sched = sched;
-		rtp->rtcp = ast_rtcp_new();
-	}
-	
-	/*
-	 * Try to bind the RTP port, x, and possibly the RTCP port, x+1 as well.
-	 * Start from a random (even, by RTP spec) port number, and
-	 * iterate until success or no ports are available.
-	 * Note that the requirement of RTP port being even, or RTCP being the
-	 * next one, cannot be enforced in presence of a NAT box because the
-	 * mapping is not under our control.
-	 */
-	x = (rtpend == rtpstart) ? rtpstart : (ast_random() % (rtpend - rtpstart)) + rtpstart;
-	x = x & ~1;		/* make it an even number */
-	startplace = x;		/* remember the starting point */
-	/* this is constant across the loop */
-	rtp->us.sin_addr = addr;
-	if (rtp->rtcp)
-		rtp->rtcp->us.sin_addr = addr;
-	for (;;) {
-		rtp->us.sin_port = htons(x);
-		if (!bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) {
-			/* bind succeeded, if no rtcp then we are done */
-			if (!rtp->rtcp)
-				break;
-			/* have rtcp, try to bind it */
-			rtp->rtcp->us.sin_port = htons(x + 1);
-			if (!bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us)))
-				break;	/* success again, we are really done */
-			/*
-			 * RTCP bind failed, so close and recreate the
-			 * already bound RTP socket for the next round.
-			 */
-			close(rtp->s);
-			rtp->s = rtp_socket("RTP");
-			if (rtp->s < 0)
-				goto fail;
-		}
-		/*
-		 * If we get here, there was an error in one of the bind()
-		 * calls, so make sure it is nothing unexpected.
-		 */
-		if (errno != EADDRINUSE) {
-			/* We got an error that wasn't expected, abort! */
-			ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
-			goto fail;
-		}
-		/*
-		 * One of the ports is in use. For the next iteration,
-		 * increment by two and handle wraparound.
-		 * If we reach the starting point, then declare failure.
-		 */
-		x += 2;
-		if (x > rtpend)
-			x = (rtpstart + 1) & ~1;
-		if (x == startplace) {
-			ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
-			goto fail;
-		}
-	}
-	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;
-
-fail:
-	if (rtp->s >= 0)
-		close(rtp->s);
-	if (rtp->rtcp) {
-		close(rtp->rtcp->s);
-		ast_free(rtp->rtcp);
-	}
-	ast_free(rtp);
-	return NULL;
-}
-
-struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
-{
-	struct in_addr ia;
-
-	memset(&ia, 0, sizeof(ia));
-	return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
-}
-
-int ast_rtp_setqos(struct ast_rtp *rtp, int type_of_service, int class_of_service, char *desc)
-{
-	return ast_netsock_set_qos(rtp->s, type_of_service, class_of_service, desc);
-}
-
-void ast_rtp_new_source(struct ast_rtp *rtp)
-{
-	if (rtp) {
-		rtp->set_marker_bit = 1;
-	}
-	return;
-}
-
-void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
-{
-	rtp->them.sin_port = them->sin_port;
-	rtp->them.sin_addr = them->sin_addr;
-	if (rtp->rtcp) {
-		int h = ntohs(them->sin_port);
-		rtp->rtcp->them.sin_port = htons(h + 1);
-		rtp->rtcp->them.sin_addr = them->sin_addr;
-	}
-	rtp->rxseqno = 0;
-	/* If strict RTP protection is enabled switch back to the learn state so we don't drop packets from above */
-	if (strictrtp)
-		rtp->strict_rtp_state = STRICT_RTP_LEARN;
-}
-
-int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
-{
-	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;
-}
-
-void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
-{
-	*us = rtp->us;
-}
-
-struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
-{
-	struct ast_rtp *bridged = NULL;
-
-	rtp_bridge_lock(rtp);
-	bridged = rtp->bridged;
-	rtp_bridge_unlock(rtp);
-
-	return bridged;
-}
-
-void ast_rtp_stop(struct ast_rtp *rtp)
-{
-	if (rtp->rtcp) {
-		AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
-	}
-	if (rtp->red) {
-		AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
-		free(rtp->red);
-		rtp->red = NULL;
-	}
-
-	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_reset(struct ast_rtp *rtp)
-{
-	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->lastitexttimestamp = 0;
-	rtp->lastotexttimestamp = 0;
-	rtp->lasteventseqn = 0;
-	rtp->lastevent = 0;
-	rtp->lasttxformat = 0;
-	rtp->lastrxformat = 0;
-	rtp->dtmfcount = 0;
-	rtp->dtmfsamples = 0;
-	rtp->seqno = 0;
-	rtp->rxseqno = 0;
-}
-
-/*! Get QoS values from RTP and RTCP data (used in "sip show channelstats") */
-unsigned int ast_rtp_get_qosvalue(struct ast_rtp *rtp, enum ast_rtp_qos_vars value)
-{
-	if (rtp == NULL) {
-		if (option_debug > 1)
-			ast_log(LOG_DEBUG, "NO RTP Structure? Kidding me? \n");
-		return 0;
-	}
-	if (option_debug > 1 && rtp->rtcp == NULL) {
-		ast_log(LOG_DEBUG, "NO RTCP structure. Maybe in RTP p2p bridging mode? \n");
-	}
-
-	switch (value) {
-	case AST_RTP_TXCOUNT:
-		return (unsigned int) rtp->txcount;
-	case AST_RTP_RXCOUNT:
-		return (unsigned int) rtp->rxcount;
-	case AST_RTP_TXJITTER:
-		return (unsigned int) (rtp->rxjitter * 100.0);
-	case AST_RTP_RXJITTER:
-		return (unsigned int) (rtp->rtcp ? (rtp->rtcp->reported_jitter / (unsigned int) 65536.0) : 0);
-	case AST_RTP_RXPLOSS:
-		return rtp->rtcp ? (rtp->rtcp->expected_prior - rtp->rtcp->received_prior) : 0;
-	case AST_RTP_TXPLOSS:
-		return rtp->rtcp ? rtp->rtcp->reported_lost : 0;
-	case AST_RTP_RTT:
-		return (unsigned int) (rtp->rtcp ? (rtp->rtcp->rtt * 100) : 0);
-	}
-	return 0;	/* To make the compiler happy */
-}
-
-static double __ast_rtp_get_qos(struct ast_rtp *rtp, const char *qos, int *found)
-{
-	*found = 1;
-
-	if (!strcasecmp(qos, "remote_maxjitter"))
-		return rtp->rtcp->reported_maxjitter * 1000.0;
-	if (!strcasecmp(qos, "remote_minjitter"))
-		return rtp->rtcp->reported_minjitter * 1000.0;
-	if (!strcasecmp(qos, "remote_normdevjitter"))
-		return rtp->rtcp->reported_normdev_jitter * 1000.0;
-	if (!strcasecmp(qos, "remote_stdevjitter"))
-		return sqrt(rtp->rtcp->reported_stdev_jitter) * 1000.0;
-
-	if (!strcasecmp(qos, "local_maxjitter"))
-		return rtp->rtcp->maxrxjitter * 1000.0;
-	if (!strcasecmp(qos, "local_minjitter"))
-		return rtp->rtcp->minrxjitter * 1000.0;
-	if (!strcasecmp(qos, "local_normdevjitter"))
-		return rtp->rtcp->normdev_rxjitter * 1000.0;
-	if (!strcasecmp(qos, "local_stdevjitter"))
-		return sqrt(rtp->rtcp->stdev_rxjitter) * 1000.0;
-
-	if (!strcasecmp(qos, "maxrtt"))
-		return rtp->rtcp->maxrtt * 1000.0;
-	if (!strcasecmp(qos, "minrtt"))
-		return rtp->rtcp->minrtt * 1000.0;
-	if (!strcasecmp(qos, "normdevrtt"))
-		return rtp->rtcp->normdevrtt * 1000.0;
-	if (!strcasecmp(qos, "stdevrtt"))
-		return sqrt(rtp->rtcp->stdevrtt) * 1000.0;
-
-	*found = 0;
-
-	return 0.0;
-}
-
-int ast_rtp_get_qos(struct ast_rtp *rtp, const char *qos, char *buf, unsigned int buflen)
-{
-	double value;
-	int found;
-
-	value = __ast_rtp_get_qos(rtp, qos, &found);
-
-	if (!found)
-		return -1;
-
-	snprintf(buf, buflen, "%.0lf", value);
-
-	return 0;
-}
-
-void ast_rtp_set_vars(struct ast_channel *chan, struct ast_rtp *rtp) {
-	char *audioqos;
-	char *audioqos_jitter;
-	char *audioqos_loss;
-	char *audioqos_rtt;
-	struct ast_channel *bridge;
-
-	if (!rtp || !chan)
-		return;
-
-	bridge = ast_bridged_channel(chan);
-
-	audioqos        = ast_rtp_get_quality(rtp, NULL, RTPQOS_SUMMARY);
-	audioqos_jitter = ast_rtp_get_quality(rtp, NULL, RTPQOS_JITTER);
-	audioqos_loss   = ast_rtp_get_quality(rtp, NULL, RTPQOS_LOSS);
-	audioqos_rtt    = ast_rtp_get_quality(rtp, NULL, RTPQOS_RTT);
-
-	pbx_builtin_setvar_helper(chan, "RTPAUDIOQOS", audioqos);
-	pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSJITTER", audioqos_jitter);
-	pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSLOSS", audioqos_loss);
-	pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSRTT", audioqos_rtt);
-
-	if (!bridge)
-		return;
-
-	pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSBRIDGED", audioqos);
-	pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSJITTERBRIDGED", audioqos_jitter);
-	pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSLOSSBRIDGED", audioqos_loss);
-	pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSRTTBRIDGED", audioqos_rtt);
-}
-
-static char *__ast_rtp_get_quality_jitter(struct ast_rtp *rtp)
-{
-	/*
-	*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
-	*rtt           round trip time
-	*/
-#define RTCP_JITTER_FORMAT1 \
-	"minrxjitter=%f;" \
-	"maxrxjitter=%f;" \
-	"avgrxjitter=%f;" \
-	"stdevrxjitter=%f;" \
-	"reported_minjitter=%f;" \
-	"reported_maxjitter=%f;" \
-	"reported_avgjitter=%f;" \
-	"reported_stdevjitter=%f;"
-
-#define RTCP_JITTER_FORMAT2 \
-	"rxjitter=%f;"
-
-	if (rtp->rtcp && rtp->rtcp->rtcp_info) {
-		snprintf(rtp->rtcp->quality_jitter, sizeof(rtp->rtcp->quality_jitter), RTCP_JITTER_FORMAT1,
-			rtp->rtcp->minrxjitter,
-			rtp->rtcp->maxrxjitter,
-			rtp->rtcp->normdev_rxjitter,
-			sqrt(rtp->rtcp->stdev_rxjitter),
-			rtp->rtcp->reported_minjitter,
-			rtp->rtcp->reported_maxjitter,
-			rtp->rtcp->reported_normdev_jitter,
-			sqrt(rtp->rtcp->reported_stdev_jitter)
-		);
-	} else {
-		snprintf(rtp->rtcp->quality_jitter, sizeof(rtp->rtcp->quality_jitter), RTCP_JITTER_FORMAT2,
-			rtp->rxjitter
-		);
-	}
-
-	return rtp->rtcp->quality_jitter;
-
-#undef RTCP_JITTER_FORMAT1
-#undef RTCP_JITTER_FORMAT2
-}
-
-static char *__ast_rtp_get_quality_loss(struct ast_rtp *rtp)
-{
-	unsigned int lost;
-	unsigned int extended;
-	unsigned int expected;
-	int fraction;
-
-#define RTCP_LOSS_FORMAT1 \
-	"minrxlost=%f;" \
-	"maxrxlost=%f;" \
-	"avgrxlostr=%f;" \
-	"stdevrxlost=%f;" \
-	"reported_minlost=%f;" \
-	"reported_maxlost=%f;" \
-	"reported_avglost=%f;" \
-	"reported_stdevlost=%f;"
-
-#define RTCP_LOSS_FORMAT2 \
-	"lost=%d;" \
-	"expected=%d;"
-	
-	if (rtp->rtcp && rtp->rtcp->rtcp_info && rtp->rtcp->maxrxlost > 0) {
-		snprintf(rtp->rtcp->quality_loss, sizeof(rtp->rtcp->quality_loss), RTCP_LOSS_FORMAT1,
-			rtp->rtcp->minrxlost,
-			rtp->rtcp->maxrxlost,
-			rtp->rtcp->normdev_rxlost,
-			sqrt(rtp->rtcp->stdev_rxlost),
-			rtp->rtcp->reported_minlost,
-			rtp->rtcp->reported_maxlost,
-			rtp->rtcp->reported_normdev_lost,
-			sqrt(rtp->rtcp->reported_stdev_lost)
-		);
-	} else {
-		extended = rtp->cycles + rtp->lastrxseqno;
-		expected = extended - rtp->seedrxseqno + 1;
-		if (rtp->rxcount > expected) 
-			expected += rtp->rxcount - expected;
-		lost = expected - rtp->rxcount;
-
-		if (!expected || lost <= 0)
-			fraction = 0;
-		else
-			fraction = (lost << 8) / expected;
-
-		snprintf(rtp->rtcp->quality_loss, sizeof(rtp->rtcp->quality_loss), RTCP_LOSS_FORMAT2,
-			lost,
-			expected
-		);
-	}
-
-	return rtp->rtcp->quality_loss;
-
-#undef RTCP_LOSS_FORMAT1
-#undef RTCP_LOSS_FORMAT2
-}
-
-static char *__ast_rtp_get_quality_rtt(struct ast_rtp *rtp)
-{
-	if (rtp->rtcp && rtp->rtcp->rtcp_info) {
-		snprintf(rtp->rtcp->quality_rtt, sizeof(rtp->rtcp->quality_rtt), "minrtt=%f;maxrtt=%f;avgrtt=%f;stdevrtt=%f;",
-			rtp->rtcp->minrtt,
-			rtp->rtcp->maxrtt,
-			rtp->rtcp->normdevrtt,
-			sqrt(rtp->rtcp->stdevrtt)
-		);
-	} else {
-		snprintf(rtp->rtcp->quality_rtt, sizeof(rtp->rtcp->quality_rtt), "Not available");
-	}
-
-	return rtp->rtcp->quality_rtt;
-}
-
-static char *__ast_rtp_get_quality(struct ast_rtp *rtp)
-{
-	/*
-	*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
-	*rtt           round trip time
-	*/	
-
-	if (rtp->rtcp && rtp->rtcp->rtcp_info) {
-		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.0,
-			rtp->txcount,
-			rtp->rtcp->reported_lost,
-			rtp->rtcp->rtt
-		);
-	} else {
-		snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality), "ssrc=%u;themssrc=%u;rxjitter=%f;rxcount=%u;txcount=%u;",
-			rtp->ssrc,
-			rtp->themssrc,
-			rtp->rxjitter,
-			rtp->rxcount,
-			rtp->txcount
-		);
-	}
-
-	return rtp->rtcp->quality;
-}
-
-char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual, enum ast_rtp_quality_type qtype) 
-{
-	if (qual && rtp) {
-		qual->local_ssrc   = rtp->ssrc;
-		qual->local_jitter = rtp->rxjitter;
-		qual->local_count  = rtp->rxcount;
-		qual->remote_ssrc  = rtp->themssrc;
-		qual->remote_count = rtp->txcount;
-
-		if (rtp->rtcp) {
-			qual->local_lostpackets  = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
-			qual->remote_lostpackets = rtp->rtcp->reported_lost;
-			qual->remote_jitter      = rtp->rtcp->reported_jitter / 65536.0;
-			qual->rtt                = rtp->rtcp->rtt;
-		}
-	}
-
-	switch (qtype) {
-	case RTPQOS_SUMMARY:
-		return __ast_rtp_get_quality(rtp);
-	case RTPQOS_JITTER:
-		return __ast_rtp_get_quality_jitter(rtp);
-	case RTPQOS_LOSS:
-		return __ast_rtp_get_quality_loss(rtp);
-	case RTPQOS_RTT:
-		return __ast_rtp_get_quality_rtt(rtp);
-	}
-
-	return NULL;
-}
-
-void ast_rtp_destroy(struct ast_rtp *rtp)
-{
-	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 ? (rtp->rtcp->expected_prior - rtp->rtcp->received_prior) : 0);
-		ast_verbose("  Jitter:		 %.4f\n", rtp->rxjitter);
-		ast_verbose("  Transit:		 %.4f\n", rtp->rxtransit);
-		ast_verbose("  RR-count:	 %u\n", rtp->rtcp ? rtp->rtcp->rr_count : 0);
-		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 ? rtp->rtcp->reported_lost : 0);
-		ast_verbose("  Jitter:		 %u\n", rtp->rtcp ? (rtp->rtcp->reported_jitter / (unsigned int)65536.0) : 0);
-		ast_verbose("  SR-count:	 %u\n", rtp->rtcp ? rtp->rtcp->sr_count : 0);
-		ast_verbose("  RTT:		 %f\n", rtp->rtcp ? rtp->rtcp->rtt : 0);
-	}
-
-	manager_event(EVENT_FLAG_REPORTING, "RTPReceiverStat", "SSRC: %u\r\n"
-					    "ReceivedPackets: %u\r\n"
-					    "LostPackets: %u\r\n"
-					    "Jitter: %.4f\r\n"
-					    "Transit: %.4f\r\n"
-					    "RRCount: %u\r\n",
-					    rtp->themssrc,
-					    rtp->rxcount,
-					    rtp->rtcp ? (rtp->rtcp->expected_prior - rtp->rtcp->received_prior) : 0,
-					    rtp->rxjitter,
-					    rtp->rxtransit,
-					    rtp->rtcp ? rtp->rtcp->rr_count : 0);
-	manager_event(EVENT_FLAG_REPORTING, "RTPSenderStat", "SSRC: %u\r\n"
-					    "SentPackets: %u\r\n"
-					    "LostPackets: %u\r\n"
-					    "Jitter: %u\r\n"
-					    "SRCount: %u\r\n"
-					    "RTT: %f\r\n",
-					    rtp->ssrc,
-					    rtp->txcount,
-					    rtp->rtcp ? rtp->rtcp->reported_lost : 0,
-					    rtp->rtcp ? rtp->rtcp->reported_jitter : 0,
-					    rtp->rtcp ? rtp->rtcp->sr_count : 0,
-					    rtp->rtcp ? rtp->rtcp->rtt : 0);
-	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) {
-		AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
-		close(rtp->rtcp->s);
-		ast_free(rtp->rtcp);
-		rtp->rtcp=NULL;
-	}
-#ifdef P2P_INTENSE
-	ast_mutex_destroy(&rtp->bridge_lock);
-#endif
-	ast_free(rtp);
-}
-
-static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
-{
-	struct timeval t;
-	long ms;
-	if (ast_tvzero(rtp->txcore)) {
-		rtp->txcore = ast_tvnow();
-		/* Round to 20ms for nice, pretty timestamps */
-		rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
-	}
-	/* Use previous txcore if available */
-	t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
-	ms = ast_tvdiff_ms(t, rtp->txcore);
-	if (ms < 0)
-		ms = 0;
-	/* Use what we just got for next time */
-	rtp->txcore = t;
-	return (unsigned int) ms;
-}
-
-/*! \brief Send begin frames for DTMF */
-int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
-{
-	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;
-	rtp->lastdigitts = rtp->lastts + rtp->send_duration;
-	
-	/* 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;
-}
-
-/*! \brief Send continuation frame for DTMF */
-static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
-{
-	unsigned int *rtpheader;
-	int hdrlen = 12, res = 0;
-	char data[256];
-
-	if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
-		return 0;
-
-	/* Setup packet to send */
-	rtpheader = (unsigned int *)data;
-	rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
-	rtpheader[1] = htonl(rtp->lastdigitts);
-	rtpheader[2] = htonl(rtp->ssrc);
-	rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
-	rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
-	
-	/* Transmit */
-	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:%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 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), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
-
-	/* Increment sequence number */
-	rtp->seqno++;
-	/* Increment duration */
-	rtp->send_duration += 160;
-
-	return 0;
-}
-
-/*! \brief Send end packets for DTMF */
-int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
-{
-	unsigned int *rtpheader;
-	int hdrlen = 12, res = 0, i = 0;
-	char data[256];
-	
-	/* If no address, then bail out */
-	if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
-		return 0;
-	
-	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;
-	}
-
-	rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
-
-	rtpheader = (unsigned int *)data;
-	rtpheader[1] = htonl(rtp->lastdigitts);
-	rtpheader[2] = htonl(rtp->ssrc);
-	rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
-	/* Set end bit */
-	rtpheader[3] |= htonl((1 << 23));
-
-	/* Send 3 termination packets */
-	for (i = 0; i < 3; i++) {
-		rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
-		res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
-		rtp->seqno++;
-		if (res < 0)
-			ast_log(LOG_ERROR, "RTP 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 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), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
-	}
-	rtp->lastts += rtp->send_duration;
-	rtp->sending_digit = 0;
-	rtp->send_digit = 0;
-
-	return res;
-}
-
-/*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
-int ast_rtcp_send_h261fur(void *data)
-{
-	struct ast_rtp *rtp = data;
-	int res;
-
-	rtp->rtcp->sendfur = 1;
-	res = ast_rtcp_write(data);
-	
-	return res;
-}
-
-/*! \brief Send RTCP sender's report */
-static int ast_rtcp_write_sr(const void *data)
-{
-	struct ast_rtp *rtp = (struct ast_rtp *)data;
-	int res;
-	int len = 0;
-	struct timeval now;
-	unsigned int now_lsw;
-	unsigned int now_msw;
-	unsigned int *rtcpheader;
-	unsigned int lost;
-	unsigned int extended;
-	unsigned int expected;
-	unsigned int expected_interval;
-	unsigned int received_interval;
-	int lost_interval;
-	int fraction;
-	struct timeval dlsr;
-	char bdata[512];
-
-	/* Commented condition is always not NULL if rtp->rtcp is not NULL */
-	if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
-		return 0;
-	
-	if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
-		ast_verbose("RTCP SR transmission error, rtcp halted\n");
-		AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
-		return 0;
-	}
-
-	gettimeofday(&now, NULL);
-	timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
-	rtcpheader = (unsigned int *)bdata;
-	rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
-	rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
-	rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
-	rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
-	rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
-	rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
-	len += 28;
-	
-	extended = rtp->cycles + rtp->lastrxseqno;
-	expected = extended - rtp->seedrxseqno + 1;
-	if (rtp->rxcount > expected) 
-		expected += rtp->rxcount - expected;
-	lost = expected - rtp->rxcount;
-	expected_interval = expected - rtp->rtcp->expected_prior;
-	rtp->rtcp->expected_prior = expected;
-	received_interval = rtp->rxcount - rtp->rtcp->received_prior;
-	rtp->rtcp->received_prior = rtp->rxcount;
-	lost_interval = expected_interval - received_interval;
-	if (expected_interval == 0 || lost_interval <= 0)
-		fraction = 0;
-	else
-		fraction = (lost_interval << 8) / expected_interval;
-	timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
-	rtcpheader[7] = htonl(rtp->themssrc);
-	rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
-	rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
-	rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
-	rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
-	rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
-	len += 24;
-	
-	rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
-
-	if (rtp->rtcp->sendfur) {
-		rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
-		rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
-		len += 8;
-		rtp->rtcp->sendfur = 0;
-	}
-	
-	/* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
-	/* it can change mid call, and SDES can't) */
-	rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
-	rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
-	rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
-	len += 12;
-	
-	res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
-	if (res < 0) {
-		ast_log(LOG_ERROR, "RTCP SR transmission error to %s:%d, rtcp halted %s\n",ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port), strerror(errno));
-		AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
-		return 0;
-	}
-	
-	/* FIXME Don't need to get a new one */
-	gettimeofday(&rtp->rtcp->txlsr, NULL);
-	rtp->rtcp->sr_count++;
-
-	rtp->rtcp->lastsrtxcount = rtp->txcount;	
-	
-	if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
-		ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
-		ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
-		ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
-		ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
-		ast_verbose("  Sent packets: %u\n", rtp->txcount);
-		ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
-		ast_verbose("  Report block:\n");
-		ast_verbose("  Fraction lost: %u\n", fraction);
-		ast_verbose("  Cumulative loss: %u\n", lost);
-		ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
-		ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
-		ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
-	}
-	manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To: %s:%d\r\n"
-					    "OurSSRC: %u\r\n"
-					    "SentNTP: %u.%010u\r\n"
-					    "SentRTP: %u\r\n"
-					    "SentPackets: %u\r\n"
-					    "SentOctets: %u\r\n"
-					    "ReportBlock:\r\n"
-					    "FractionLost: %u\r\n"
-					    "CumulativeLoss: %u\r\n"
-					    "IAJitter: %.4f\r\n"
-					    "TheirLastSR: %u\r\n"
-					    "DLSR: %4.4f (sec)\r\n",
-					    ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
-					    rtp->ssrc,
-					    (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
-					    rtp->lastts,
-					    rtp->txcount,
-					    rtp->txoctetcount,
-					    fraction,
-					    lost,
-					    rtp->rxjitter,
-					    rtp->rtcp->themrxlsr,
-					    (double)(ntohl(rtcpheader[12])/65536.0));
-	return res;
-}
-
-/*! \brief Send RTCP recipient's report */
-static int ast_rtcp_write_rr(const void *data)
-{
-	struct ast_rtp *rtp = (struct ast_rtp *)data;
-	int res;
-	int len = 32;
-	unsigned int lost;
-	unsigned int extended;
-	unsigned int expected;
-	unsigned int expected_interval;
-	unsigned int received_interval;
-	int lost_interval;
-	struct timeval now;
-	unsigned int *rtcpheader;
-	char bdata[1024];
-	struct timeval dlsr;
-	int fraction;
-
-	double rxlost_current;
-	
-	if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
-		return 0;
-	  
-	if (!rtp->rtcp->them.sin_addr.s_addr) {
-		ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
-		AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
-		return 0;
-	}
-
-	extended = rtp->cycles + rtp->lastrxseqno;
-	expected = extended - rtp->seedrxseqno + 1;
-	lost = expected - rtp->rxcount;
-	expected_interval = expected - rtp->rtcp->expected_prior;
-	rtp->rtcp->expected_prior = expected;
-	received_interval = rtp->rxcount - rtp->rtcp->received_prior;
-	rtp->rtcp->received_prior = rtp->rxcount;
-	lost_interval = expected_interval - received_interval;
-
-	if (lost_interval <= 0)
-		rtp->rtcp->rxlost = 0;
-	else rtp->rtcp->rxlost = rtp->rtcp->rxlost;
-	if (rtp->rtcp->rxlost_count == 0)
-		rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
-	if (lost_interval < rtp->rtcp->minrxlost) 
-		rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
-	if (lost_interval > rtp->rtcp->maxrxlost) 
-		rtp->rtcp->maxrxlost = rtp->rtcp->rxlost;
-
-	rxlost_current = normdev_compute(rtp->rtcp->normdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->rxlost_count);
-	rtp->rtcp->stdev_rxlost = stddev_compute(rtp->rtcp->stdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->normdev_rxlost, rxlost_current, rtp->rtcp->rxlost_count);
-	rtp->rtcp->normdev_rxlost = rxlost_current;
-	rtp->rtcp->rxlost_count++;
-
-	if (expected_interval == 0 || lost_interval <= 0)
-		fraction = 0;
-	else
-		fraction = (lost_interval << 8) / expected_interval;
-	gettimeofday(&now, NULL);
-	timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
-	rtcpheader = (unsigned int *)bdata;
-	rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
-	rtcpheader[1] = htonl(rtp->ssrc);
-	rtcpheader[2] = htonl(rtp->themssrc);
-	rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
-	rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
-	rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
-	rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
-	rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
-
-	if (rtp->rtcp->sendfur) {
-		rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
-		rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
-		len += 8;
-		rtp->rtcp->sendfur = 0;
-	}
-
-	/*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
-	it can change mid call, and SDES can't) */
-	rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
-	rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
-	rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
-	len += 12;
-	
-	res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
-
-	if (res < 0) {
-		ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
-		/* Remove the scheduler */
-		AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
-		return 0;
-	}
-
-	rtp->rtcp->rr_count++;
-
-	if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
-		ast_verbose("\n* Sending RTCP RR to %s:%d\n"
-			"  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
-			"  IA jitter: %.4f\n" 
-			"  Their last SR: %u\n" 
-			"  DLSR: %4.4f (sec)\n\n",
-			ast_inet_ntoa(rtp->rtcp->them.sin_addr),
-			ntohs(rtp->rtcp->them.sin_port),
-			rtp->ssrc, rtp->themssrc, fraction, lost,
-			rtp->rxjitter,
-			rtp->rtcp->themrxlsr,
-			(double)(ntohl(rtcpheader[7])/65536.0));
-	}
-
-	return res;
-}
-
-/*! \brief Write and RTCP packet to the far end
- * \note Decide if we are going to send an SR (with Reception Block) or RR 
- * RR is sent if we have not sent any rtp packets in the previous interval */
-static int ast_rtcp_write(const void *data)
-{
-	struct ast_rtp *rtp = (struct ast_rtp *)data;
-	int res;
-	
-	if (!rtp || !rtp->rtcp)
-		return 0;
-
-	if (rtp->txcount > rtp->rtcp->lastsrtxcount)
-		res = ast_rtcp_write_sr(data);
-	else
-		res = ast_rtcp_write_rr(data);
-	
-	return res;
-}
-
-/*! \brief generate comfort noice (CNG) */
-int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
-{
-	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;
-}
-
-/*! \brief Write RTP packet with audio or video media frames into UDP packet */
-static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
-{
-	unsigned char *rtpheader;
-	int hdrlen = 12;
-	int res;
-	unsigned int ms;
-	int pred;
-	int mark = 0;
-
-	if (rtp->sending_digit) {
-		return 0;
-	}
-
-	ms = calc_txstamp(rtp, &f->delivery);
-	/* Default prediction */
-	if (f->frametype == AST_FRAME_VOICE) {
-		pred = rtp->lastts + f->samples;
-
-		/* Re-calculate last TS */
-		rtp->lastts = rtp->lastts + ms * 8;
-		if (ast_tvzero(f->delivery)) {
-			/* If this isn't an absolute delivery time, Check if it is close to our prediction, 
-			   and if so, go with our prediction */
-			if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
-				rtp->lastts = pred;
-			else {
-				ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
-				mark = 1;
-			}
-		}
-	} else if (f->frametype == AST_FRAME_VIDEO) {
-		mark = f->subclass & 0x1;
-		pred = rtp->lastovidtimestamp + f->samples;
-		/* Re-calculate last TS */
-		rtp->lastts = rtp->lastts + ms * 90;
-		/* If it's close to our prediction, go for it */
-		if (ast_tvzero(f->delivery)) {
-			if (abs(rtp->lastts - pred) < 7200) {
-				rtp->lastts = pred;
-				rtp->lastovidtimestamp += f->samples;
-			} else {
-				ast_debug(3, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, f->samples);
-				rtp->lastovidtimestamp = rtp->lastts;
-			}
-		}
-	} else {
-		pred = rtp->lastotexttimestamp + f->samples;
-		/* Re-calculate last TS */
-		rtp->lastts = rtp->lastts + ms * 90;
-		/* If it's close to our prediction, go for it */
-		if (ast_tvzero(f->delivery)) {
-			if (abs(rtp->lastts - pred) < 7200) {
-				rtp->lastts = pred;
-				rtp->lastotexttimestamp += f->samples;
-			} else {
-				ast_debug(3, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, f->samples);
-				rtp->lastotexttimestamp = rtp->lastts;
-			}
-		}
-	}
-
-	/* If we have been explicitly told to set the marker bit do so */
-	if (rtp->set_marker_bit) {
-		mark = 1;
-		rtp->set_marker_bit = 0;
-	}
-
-	/* If the timestamp for non-digit packets has moved beyond the timestamp
-	   for digits, update the digit timestamp.
-	*/
-	if (rtp->lastts > rtp->lastdigitts)
-		rtp->lastdigitts = rtp->lastts;
-
-	if (ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO))
-		rtp->lastts = f->ts * 8;
-
-	/* Get a pointer to the header */
-	rtpheader = (unsigned char *)(f->data.ptr - hdrlen);
-
-	put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
-	put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
-	put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
-
-	if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
-		res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
-		if (res < 0) {
-			if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
-				ast_debug(1, "RTP Transmission error of packet %d to %s:%d: %s\n", rtp->seqno, ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
-			} else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
-				/* Only give this error message once if we are not RTP debugging */
-				if (option_debug || rtpdebug)
-					ast_debug(0, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
-				ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
-			}
-		} else {
-			rtp->txcount++;
-			rtp->txoctetcount +=(res - hdrlen);
-			
-			/* Do not schedule RR if RTCP isn't run */
-			if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
-				rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
-			}
-		}
-				
-		if (rtp_debug_test_addr(&rtp->them))
-			ast_verbose("Sent RTP 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), codec, rtp->seqno, rtp->lastts,res - hdrlen);
-	}
-
-	rtp->seqno++;
-
-	return 0;
-}
-
-void ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
-{
-	struct ast_format_list current_format_old, current_format_new;
-
-	/* if no packets have been sent through this session yet, then
-	 *  changing preferences does not require any extra work
-	 */
-	if (rtp->lasttxformat == 0) {
-		rtp->pref = *prefs;
-		return;
-	}
-
-	current_format_old = ast_codec_pref_getsize(&rtp->pref, rtp->lasttxformat);
-
-	rtp->pref = *prefs;
-
-	current_format_new = ast_codec_pref_getsize(&rtp->pref, rtp->lasttxformat);
-
-	/* if the framing desired for the current format has changed, we may have to create
-	 * or adjust the smoother for this session
-	 */
-	if ((current_format_new.inc_ms != 0) &&
-	    (current_format_new.cur_ms != current_format_old.cur_ms)) {
-		int new_size = (current_format_new.cur_ms * current_format_new.fr_len) / current_format_new.inc_ms;
-
-		if (rtp->smoother) {
-			ast_smoother_reconfigure(rtp->smoother, new_size);
-			if (option_debug) {
-				ast_log(LOG_DEBUG, "Adjusted smoother to %d ms and %d bytes\n", current_format_new.cur_ms, new_size);
-			}
-		} else {
-			if (!(rtp->smoother = ast_smoother_new(new_size))) {
-				ast_log(LOG_WARNING, "Unable to create smoother: format: %d ms: %d len: %d\n", rtp->lasttxformat, current_format_new.cur_ms, new_size);
-				return;
-			}
-			if (current_format_new.flags) {
-				ast_smoother_set_flags(rtp->smoother, current_format_new.flags);
-			}
-			if (option_debug) {
-				ast_log(LOG_DEBUG, "Created smoother: format: %d ms: %d len: %d\n", rtp->lasttxformat, current_format_new.cur_ms, new_size);
-			}
-		}
-	}
-
-}
-
-struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
-{
-	return &rtp->pref;
-}
-
-int ast_rtp_codec_getformat(int 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;
-}
-
-int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
-{
-	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 && !rtp->red)
-		return 0;
-	
-	/* Make sure we have enough space for RTP header */
-	if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO) && (_f->frametype != AST_FRAME_TEXT)) {
-		ast_log(LOG_WARNING, "RTP can only send voice, video and text\n");
-		return -1;
-	}
-
-	if (rtp->red) {
-		/* return 0; */
-		/* no primary data or generations to send */
-		if ((_f = red_t140_to_red(rtp->red)) == NULL) 
-			return 0;
-	}
-
-	/* The bottom bit of a video subclass contains the marker bit */
-	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 */
-		ast_debug(1, "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);
-
-		switch (subclass) {
-		case AST_FORMAT_SPEEX:
-		case AST_FORMAT_G723_1:
-		case AST_FORMAT_SIREN7:
-		case AST_FORMAT_SIREN14:
-			/* these are all frame-based codecs and cannot be safely run through
-			   a smoother */
-			break;
-		default:
-			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);
-				ast_debug(1, "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)) && (f->data.ptr)) {
-			if (f->subclass == AST_FORMAT_G722) {
-				/* G.722 is silllllllllllllly */
-				f->samples /= 2;
-			}
-
-			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;
-		if (f->data.ptr)
-			ast_rtp_raw_write(rtp, f, codec);
-		if (f != _f)
-			ast_frfree(f);
-	}
-		
-	return 0;
-}
-
-/*! \brief Unregister interface to channel driver */
-void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
-{
-	AST_RWLIST_WRLOCK(&protos);
-	AST_RWLIST_REMOVE(&protos, proto, list);
-	AST_RWLIST_UNLOCK(&protos);
-}
-
-/*! \brief Register interface to channel driver */
-int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
-{
-	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;
-}
-
-/*! \brief Bridge loop for true native bridge (reinvite) */
-static enum ast_bridge_result bridge_native_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, struct ast_rtp *vp0, struct ast_rtp *vp1, struct ast_rtp *tp0, struct ast_rtp *tp1, struct ast_rtp_protocol *pr0, struct ast_rtp_protocol *pr1, int codec0, int codec1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
-{
-	struct ast_frame *fr = NULL;
-	struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
-	int oldcodec0 = codec0, oldcodec1 = codec1;
-	struct sockaddr_in ac1 = {0,}, vac1 = {0,}, tac1 = {0,}, ac0 = {0,}, vac0 = {0,}, tac0 = {0,};
-	struct sockaddr_in t1 = {0,}, vt1 = {0,}, tt1 = {0,}, t0 = {0,}, vt0 = {0,}, tt0 = {0,};
-	
-	/* Set it up so audio goes directly between the two endpoints */
-
-	/* Test the first channel */
-	if (!(pr0->set_rtp_peer(c0, p1, vp1, tp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
-		ast_rtp_get_peer(p1, &ac1);
-		if (vp1)
-			ast_rtp_get_peer(vp1, &vac1);
-		if (tp1)
-			ast_rtp_get_peer(tp1, &tac1);
-	} else
-		ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
-	
-	/* Test the second channel */
-	if (!(pr1->set_rtp_peer(c1, p0, vp0, tp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
-		ast_rtp_get_peer(p0, &ac0);
-		if (vp0)
-			ast_rtp_get_peer(vp0, &vac0);
-		if (tp0)
-			ast_rtp_get_peer(tp0, &tac0);
-	} else
-		ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
-
-	/* Now we can unlock and move into our loop */
-	ast_channel_unlock(c0);
-	ast_channel_unlock(c1);
-
-	ast_poll_channel_add(c0, c1);
-
-	/* Throw our channels into the structure and enter the loop */
-	cs[0] = c0;
-	cs[1] = c1;
-	cs[2] = NULL;
-	for (;;) {
-		/* Check if anything changed */
-		if ((c0->tech_pvt != pvt0) ||
-		    (c1->tech_pvt != pvt1) ||
-		    (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
-		    (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
-			ast_debug(1, "Oooh, something is weird, backing out\n");
-			if (c0->tech_pvt == pvt0)
-				if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
-					ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
-			if (c1->tech_pvt == pvt1)
-				if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
-					ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
-			ast_poll_channel_del(c0, c1);
-			return AST_BRIDGE_RETRY;
-		}
-
-		/* Check if they have changed their address */
-		ast_rtp_get_peer(p1, &t1);
-		if (vp1)
-			ast_rtp_get_peer(vp1, &vt1);
-		if (tp1)
-			ast_rtp_get_peer(tp1, &tt1);
-		if (pr1->get_codec)
-			codec1 = pr1->get_codec(c1);
-		ast_rtp_get_peer(p0, &t0);
-		if (vp0)
-			ast_rtp_get_peer(vp0, &vt0);
-		if (tp0)
-			ast_rtp_get_peer(tp0, &tt0);
-		if (pr0->get_codec)
-			codec0 = pr0->get_codec(c0);
-		if ((inaddrcmp(&t1, &ac1)) ||
-		    (vp1 && inaddrcmp(&vt1, &vac1)) ||
-		    (tp1 && inaddrcmp(&tt1, &tac1)) ||
-		    (codec1 != oldcodec1)) {
-			ast_debug(2, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
-				c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
-			ast_debug(2, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
-				c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
-			ast_debug(2, "Oooh, '%s' changed end taddress to %s:%d (format %d)\n",
-				c1->name, ast_inet_ntoa(tt1.sin_addr), ntohs(tt1.sin_port), codec1);
-			ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
-				c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
-			ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
-				c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
-			ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
-				c1->name, ast_inet_ntoa(tac1.sin_addr), ntohs(tac1.sin_port), oldcodec1);
-			if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, tt1.sin_addr.s_addr ? tp1 : NULL, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))
-				ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
-			memcpy(&ac1, &t1, sizeof(ac1));
-			memcpy(&vac1, &vt1, sizeof(vac1));
-			memcpy(&tac1, &tt1, sizeof(tac1));
-			oldcodec1 = codec1;
-		}
-		if ((inaddrcmp(&t0, &ac0)) ||
-		    (vp0 && inaddrcmp(&vt0, &vac0)) ||
-		    (tp0 && inaddrcmp(&tt0, &tac0))) {
-			ast_debug(2, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
-				c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
-			ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
-				c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
-			if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, tt0.sin_addr.s_addr ? tp0 : NULL, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
-				ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
-			memcpy(&ac0, &t0, sizeof(ac0));
-			memcpy(&vac0, &vt0, sizeof(vac0));
-			memcpy(&tac0, &tt0, sizeof(tac0));
-			oldcodec0 = codec0;
-		}
-
-		/* Wait for frame to come in on the channels */
-		if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
-			if (!timeoutms) {
-				if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
-					ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
-				if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
-					ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
-				return AST_BRIDGE_RETRY;
-			}
-			ast_debug(1, "Ooh, empty read...\n");
-			if (ast_check_hangup(c0) || ast_check_hangup(c1))
-				break;
-			continue;
-		}
-		fr = ast_read(who);
-		other = (who == c0) ? c1 : c0;
-		if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
-			    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
-			     ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
-			/* Break out of bridge */
-			*fo = fr;
-			*rc = who;
-			ast_debug(1, "Oooh, got a %s\n", fr ? "digit" : "hangup");
-			if (c0->tech_pvt == pvt0)
-				if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
-					ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
-			if (c1->tech_pvt == pvt1)
-				if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
-					ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
-			ast_poll_channel_del(c0, c1);
-			return AST_BRIDGE_COMPLETE;
-		} else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
-			if ((fr->subclass == AST_CONTROL_HOLD) ||
-			    (fr->subclass == AST_CONTROL_UNHOLD) ||
-			    (fr->subclass == AST_CONTROL_VIDUPDATE) ||
-			    (fr->subclass == AST_CONTROL_T38) ||
-			    (fr->subclass == AST_CONTROL_SRCUPDATE)) {
-				if (fr->subclass == AST_CONTROL_HOLD) {
-					/* If we someone went on hold we want the other side to reinvite back to us */
-					if (who == c0)
-						pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0);
-					else
-						pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0);
-				} else if (fr->subclass == AST_CONTROL_UNHOLD) {
-					/* If they went off hold they should go back to being direct */
-					if (who == c0)
-						pr1->set_rtp_peer(c1, p0, vp0, tp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE));
-					else
-						pr0->set_rtp_peer(c0, p1, vp1, tp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE));
-				}
-				/* Update local address information */
-				ast_rtp_get_peer(p0, &t0);
-				memcpy(&ac0, &t0, sizeof(ac0));
-				ast_rtp_get_peer(p1, &t1);
-				memcpy(&ac1, &t1, sizeof(ac1));
-				/* Update codec information */
-				if (pr0->get_codec && c0->tech_pvt)
-					oldcodec0 = codec0 = pr0->get_codec(c0);
-				if (pr1->get_codec && c1->tech_pvt)
-					oldcodec1 = codec1 = pr1->get_codec(c1);
-				ast_indicate_data(other, fr->subclass, fr->data.ptr, fr->datalen);
-				ast_frfree(fr);
-			} else {
-				*fo = fr;
-				*rc = who;
-				ast_debug(1, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
-				return AST_BRIDGE_COMPLETE;
-			}
-		} else {
-			if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
-			    (fr->frametype == AST_FRAME_DTMF_END) ||
-			    (fr->frametype == AST_FRAME_VOICE) ||
-			    (fr->frametype == AST_FRAME_VIDEO) ||
-			    (fr->frametype == AST_FRAME_IMAGE) ||
-			    (fr->frametype == AST_FRAME_HTML) ||
-			    (fr->frametype == AST_FRAME_MODEM) ||
-			    (fr->frametype == AST_FRAME_TEXT)) {
-				ast_write(other, fr);
-			}
-			ast_frfree(fr);
-		}
-		/* Swap priority */
-#ifndef HAVE_EPOLL
-		cs[2] = cs[0];
-		cs[0] = cs[1];
-		cs[1] = cs[2];
-#endif
-	}
-
-	ast_poll_channel_del(c0, c1);
-
-	if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
-		ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
-	if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
-		ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
-
-	return AST_BRIDGE_FAILED;
-}
-
-/*! \brief P2P RTP Callback */
-#ifdef P2P_INTENSE
-static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
-{
-	int res = 0, hdrlen = 12;
-	struct sockaddr_in sin;
-	socklen_t len;
-	unsigned int *header;
-	struct ast_rtp *rtp = cbdata, *bridged = NULL;
-
-	if (!rtp)
-		return 1;
-
-	len = sizeof(sin);
-	if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
-		return 1;
-
-	header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
-	
-	/* If NAT support is turned on, then see if we need to change their address */
-	if ((rtp->nat) && 
-	    ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
-	     (rtp->them.sin_port != sin.sin_port))) {
-		rtp->them = sin;
-		rtp->rxseqno = 0;
-		ast_set_flag(rtp, FLAG_NAT_ACTIVE);
-		if (option_debug || rtpdebug)
-			ast_debug(0, "P2P 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));
-	}
-
-	/* Write directly out to other RTP stream if bridged */
-	if ((bridged = ast_rtp_get_bridged(rtp)))
-		bridge_p2p_rtp_write(rtp, bridged, header, res, hdrlen);
-	
-	return 1;
-}
-
-/*! \brief Helper function to switch a channel and RTP stream into callback mode */
-static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
-{
-	/* If we need DTMF, are looking for STUN, or we have no IO structure then we can't do direct callback */
-	if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || ast_test_flag(rtp, FLAG_HAS_STUN) || !rtp->io)
-		return 0;
-
-	/* If the RTP structure is already in callback mode, remove it temporarily */
-	if (rtp->ioid) {
-		ast_io_remove(rtp->io, rtp->ioid);
-		rtp->ioid = NULL;
-	}
-
-	/* Steal the file descriptors from the channel */
-	chan->fds[0] = -1;
-
-	/* Now, fire up callback mode */
-	iod[0] = ast_io_add(rtp->io, ast_rtp_fd(rtp), p2p_rtp_callback, AST_IO_IN, rtp);
-
-	return 1;
-}
-#else
-static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
-{
-	return 0;
-}
-#endif
-
-/*! \brief Helper function to switch a channel and RTP stream out of callback mode */
-static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
-{
-	ast_channel_lock(chan);
-
-	/* Remove the callback from the IO context */
-	ast_io_remove(rtp->io, iod[0]);
-
-	/* Restore file descriptors */
-	chan->fds[0] = ast_rtp_fd(rtp);
-	ast_channel_unlock(chan);
-
-	/* Restore callback mode if previously used */
-	if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
-		rtp->ioid = ast_io_add(rtp->io, ast_rtp_fd(rtp), rtpread, AST_IO_IN, rtp);
-
-	return 0;
-}
-
-/*! \brief Helper function that sets what an RTP structure is bridged to */
-static void p2p_set_bridge(struct ast_rtp *rtp0, struct ast_rtp *rtp1)
-{
-	rtp_bridge_lock(rtp0);
-	rtp0->bridged = rtp1;
-	rtp_bridge_unlock(rtp0);
-}
-
-/*! \brief Bridge loop for partial native bridge (packet2packet) 
-
-	In p2p mode, Asterisk is a very basic RTP proxy, just forwarding whatever
-	rtp/rtcp we get in to the channel. 
-	\note this currently only works for Audio
-*/
-static enum ast_bridge_result bridge_p2p_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
-{
-	struct ast_frame *fr = NULL;
-	struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
-	int *p0_iod[2] = {NULL, NULL}, *p1_iod[2] = {NULL, NULL};
-	int p0_callback = 0, p1_callback = 0;
-	enum ast_bridge_result res = AST_BRIDGE_FAILED;
-
-	/* Okay, setup each RTP structure to do P2P forwarding */
-	ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
-	p2p_set_bridge(p0, p1);
-	ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
-	p2p_set_bridge(p1, p0);
-
-	/* Activate callback modes if possible */
-	p0_callback = p2p_callback_enable(c0, p0, &p0_iod[0]);
-	p1_callback = p2p_callback_enable(c1, p1, &p1_iod[0]);
-
-	/* Now let go of the channel locks and be on our way */
-	ast_channel_unlock(c0);
-	ast_channel_unlock(c1);
-
-	ast_poll_channel_add(c0, c1);
-
-	/* Go into a loop forwarding frames until we don't need to anymore */
-	cs[0] = c0;
-	cs[1] = c1;
-	cs[2] = NULL;
-	for (;;) {
-		/* If the underlying formats have changed force this bridge to break */
-		if ((c0->rawreadformat != c1->rawwriteformat) || (c1->rawreadformat != c0->rawwriteformat)) {
-			ast_debug(3, "p2p-rtp-bridge: Oooh, formats changed, backing out\n");
-			res = AST_BRIDGE_FAILED_NOWARN;
-			break;
-		}
-		/* Check if anything changed */
-		if ((c0->tech_pvt != pvt0) ||
-		    (c1->tech_pvt != pvt1) ||
-		    (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
-		    (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
-			ast_debug(3, "p2p-rtp-bridge: Oooh, something is weird, backing out\n");
-			/* If a masquerade needs to happen we have to try to read in a frame so that it actually happens. Without this we risk being called again and going into a loop */
-			if ((c0->masq || c0->masqr) && (fr = ast_read(c0)))
-				ast_frfree(fr);
-			if ((c1->masq || c1->masqr) && (fr = ast_read(c1)))
-				ast_frfree(fr);
-			res = AST_BRIDGE_RETRY;
-			break;
-		}
-		/* Wait on a channel to feed us a frame */
-		if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
-			if (!timeoutms) {
-				res = AST_BRIDGE_RETRY;
-				break;
-			}
-			if (option_debug > 2)
-				ast_log(LOG_NOTICE, "p2p-rtp-bridge: Ooh, empty read...\n");
-			if (ast_check_hangup(c0) || ast_check_hangup(c1))
-				break;
-			continue;
-		}
-		/* Read in frame from channel */
-		fr = ast_read(who);
-		other = (who == c0) ? c1 : c0;
-		/* Depending on the frame we may need to break out of our bridge */
-		if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
-			    ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
-			    ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
-			/* Record received frame and who */
-			*fo = fr;
-			*rc = who;
-			ast_debug(3, "p2p-rtp-bridge: Ooh, got a %s\n", fr ? "digit" : "hangup");
-			res = AST_BRIDGE_COMPLETE;
-			break;
-		} else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
-			if ((fr->subclass == AST_CONTROL_HOLD) ||
-			    (fr->subclass == AST_CONTROL_UNHOLD) ||
-			    (fr->subclass == AST_CONTROL_VIDUPDATE) ||
-			    (fr->subclass == AST_CONTROL_T38) ||
-			    (fr->subclass == AST_CONTROL_SRCUPDATE)) {
-				/* If we are going on hold, then break callback mode and P2P bridging */
-				if (fr->subclass == AST_CONTROL_HOLD) {
-					if (p0_callback)
-						p0_callback = p2p_callback_disable(c0, p0, &p0_iod[0]);
-					if (p1_callback)
-						p1_callback = p2p_callback_disable(c1, p1, &p1_iod[0]);
-					p2p_set_bridge(p0, NULL);
-					p2p_set_bridge(p1, NULL);
-				} else if (fr->subclass == AST_CONTROL_UNHOLD) {
-					/* If we are off hold, then go back to callback mode and P2P bridging */
-					ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
-					p2p_set_bridge(p0, p1);
-					ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
-					p2p_set_bridge(p1, p0);
-					p0_callback = p2p_callback_enable(c0, p0, &p0_iod[0]);
-					p1_callback = p2p_callback_enable(c1, p1, &p1_iod[0]);
-				}
-				ast_indicate_data(other, fr->subclass, fr->data.ptr, fr->datalen);
-				ast_frfree(fr);
-			} else {
-				*fo = fr;
-				*rc = who;
-				ast_debug(3, "p2p-rtp-bridge: Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
-				res = AST_BRIDGE_COMPLETE;
-				break;
-			}
-		} else {
-			if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
-			    (fr->frametype == AST_FRAME_DTMF_END) ||
-			    (fr->frametype == AST_FRAME_VOICE) ||
-			    (fr->frametype == AST_FRAME_VIDEO) ||
-			    (fr->frametype == AST_FRAME_IMAGE) ||
-			    (fr->frametype == AST_FRAME_HTML) ||
-			    (fr->frametype == AST_FRAME_MODEM) ||
-			    (fr->frametype == AST_FRAME_TEXT)) {
-				ast_write(other, fr);
-			}
-
-			ast_frfree(fr);
-		}
-		/* Swap priority */
-#ifndef HAVE_EPOLL
-		cs[2] = cs[0];
-		cs[0] = cs[1];
-		cs[1] = cs[2];
-#endif
-	}
-
-	/* If we are totally avoiding the core, then restore our link to it */
-	if (p0_callback)
-		p0_callback = p2p_callback_disable(c0, p0, &p0_iod[0]);
-	if (p1_callback)
-		p1_callback = p2p_callback_disable(c1, p1, &p1_iod[0]);
-
-	/* Break out of the direct bridge */
-	p2p_set_bridge(p0, NULL);
-	p2p_set_bridge(p1, NULL);
-
-	ast_poll_channel_del(c0, c1);
-
-	return res;
-}
-
-/*! \page AstRTPbridge The Asterisk RTP bridge 
-	The RTP bridge is called from the channel drivers that are using the RTP
-	subsystem in Asterisk - like SIP, H.323 and Jingle/Google Talk.
-
-	This bridge aims to offload the Asterisk server by setting up
-	the media stream directly between the endpoints, keeping the
-	signalling in Asterisk.
-
-	It checks with the channel driver, using a callback function, if
-	there are possibilities for a remote bridge.
-
-	If this fails, the bridge hands off to the core bridge. Reasons
-	can be NAT support needed, DTMF features in audio needed by
-	the PBX for transfers or spying/monitoring on channels.
-
-	If transcoding is needed - we can't do a remote bridge.
-	If only NAT support is needed, we're using Asterisk in
-	RTP proxy mode with the p2p RTP bridge, basically
-	forwarding incoming audio packets to the outbound
-	stream on a network level.
-
-	References:
-	- ast_rtp_bridge()
-	- ast_channel_early_bridge()
-	- ast_channel_bridge()
-	- rtp.c
-	- rtp.h
-*/
-/*! \brief Bridge calls. If possible and allowed, initiate
-	re-invite so the peers exchange media directly outside 
-	of Asterisk. 
-*/
-enum ast_bridge_result ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
-{
-	struct ast_rtp *p0 = NULL, *p1 = NULL;		/* Audio RTP Channels */
-	struct ast_rtp *vp0 = NULL, *vp1 = NULL;	/* Video RTP channels */
-	struct ast_rtp *tp0 = NULL, *tp1 = NULL;	/* Text 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, text_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, text_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);
-	}
-
-	/* Ensure neither channel got hungup during lock avoidance */
-	if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
-		ast_log(LOG_WARNING, "Got hangup while attempting to bridge '%s' and '%s'\n", c0->name, c1->name);
-		ast_channel_unlock(c0);
-		ast_channel_unlock(c1);
-		return AST_BRIDGE_FAILED;
-	}
-		
-	/* 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;
-	text_p0_res = pr0->get_trtp_info ? pr0->get_trtp_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;
-	text_p1_res = pr1->get_trtp_info ? pr1->get_trtp_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;
-	}
-
-	/* If we need to feed frames into the core don't do a P2P bridge */
-	if ((audio_p0_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p0, FLAG_P2P_NEED_DTMF)) ||
-	    (audio_p1_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p1, FLAG_P2P_NEED_DTMF))) {
-		ast_channel_unlock(c0);
-		ast_channel_unlock(c1);
-		return AST_BRIDGE_FAILED_NOWARN;
-	}
-
-	/* 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 */
-		ast_debug(3, "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) {
-		struct ast_format_list fmt0, fmt1;
-
-		/* In order to do Packet2Packet bridging both sides must be in the same rawread/rawwrite */
-		if (c0->rawreadformat != c1->rawwriteformat || c1->rawreadformat != c0->rawwriteformat) {
-			ast_debug(1, "Cannot packet2packet bridge - raw formats are incompatible\n");
-			ast_channel_unlock(c0);
-			ast_channel_unlock(c1);
-			return AST_BRIDGE_FAILED_NOWARN;
-		}
-		/* They must also be using the same packetization */
-		fmt0 = ast_codec_pref_getsize(&p0->pref, c0->rawreadformat);
-		fmt1 = ast_codec_pref_getsize(&p1->pref, c1->rawreadformat);
-		if (fmt0.cur_ms != fmt1.cur_ms) {
-			ast_debug(1, "Cannot packet2packet bridge - packetization settings prevent it\n");
-			ast_channel_unlock(c0);
-			ast_channel_unlock(c1);
-			return AST_BRIDGE_FAILED_NOWARN;
-		}
-
-		ast_verb(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 {
-		ast_verb(3, "Native bridging %s and %s\n", c0->name, c1->name);
-		res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, tp0, tp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1);
-	}
-
-	return res;
-}
-
-static char *rtp_do_debug_ip(struct ast_cli_args *a)
-{
-	struct hostent *hp;
-	struct ast_hostent ahp;
-	int port = 0;
-	char *p, *arg;
-
-	arg = a->argv[3];
-	p = strstr(arg, ":");
-	if (p) {
-		*p = '\0';
-		p++;
-		port = atoi(p);
-	}
-	hp = ast_gethostbyname(arg, &ahp);
-	if (hp == NULL) {
-		ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
-		return CLI_FAILURE;
-	}
-	rtpdebugaddr.sin_family = AF_INET;
-	memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
-	rtpdebugaddr.sin_port = htons(port);
-	if (port == 0)
-		ast_cli(a->fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr.sin_addr));
-	else
-		ast_cli(a->fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr.sin_addr), port);
-	rtpdebug = 1;
-	return CLI_SUCCESS;
-}
-
-static char *rtcp_do_debug_ip(struct ast_cli_args *a)
-{
-	struct hostent *hp;
-	struct ast_hostent ahp;
-	int port = 0;
-	char *p, *arg;
-
-	arg = a->argv[3];
-	p = strstr(arg, ":");
-	if (p) {
-		*p = '\0';
-		p++;
-		port = atoi(p);
-	}
-	hp = ast_gethostbyname(arg, &ahp);
-	if (hp == NULL) {
-		ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
-		return CLI_FAILURE;
-	}
-	rtcpdebugaddr.sin_family = AF_INET;
-	memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
-	rtcpdebugaddr.sin_port = htons(port);
-	if (port == 0)
-		ast_cli(a->fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
-	else
-		ast_cli(a->fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
-	rtcpdebug = 1;
-	return CLI_SUCCESS;
-}
-
-static char *handle_cli_rtp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "rtp set debug {on|off|ip}";
-		e->usage =
-			"Usage: rtp set debug {on|off|ip host[:port]}\n"
-			"       Enable/Disable dumping of all RTP packets. If 'ip' is\n"
-			"       specified, limit the dumped packets to those to and from\n"
-			"       the specified 'host' with optional port.\n";
-		return NULL;
-	case CLI_GENERATE:
-		return NULL;
-	}
-
-	if (a->argc == e->args) { /* set on or off */
-		if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
-			rtpdebug = 1;
-			memset(&rtpdebugaddr, 0, sizeof(rtpdebugaddr));
-			ast_cli(a->fd, "RTP Debugging Enabled\n");
-			return CLI_SUCCESS;
-		} else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
-			rtpdebug = 0;
-			ast_cli(a->fd, "RTP Debugging Disabled\n");
-			return CLI_SUCCESS;
-		}
-	} else if (a->argc == e->args +1) { /* ip */
-		return rtp_do_debug_ip(a);
-	}
-
-	return CLI_SHOWUSAGE;   /* default, failure */
-}
-
-static char *handle_cli_rtcp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "rtcp set debug {on|off|ip}";
-		e->usage =
-			"Usage: rtcp set debug {on|off|ip host[:port]}\n"
-			"       Enable/Disable dumping of all RTCP packets. If 'ip' is\n"
-			"       specified, limit the dumped packets to those to and from\n"
-			"       the specified 'host' with optional port.\n";
-		return NULL;
-	case CLI_GENERATE:
-		return NULL;
-	}
-
-	if (a->argc == e->args) { /* set on or off */
-		if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
-			rtcpdebug = 1;
-			memset(&rtcpdebugaddr, 0, sizeof(rtcpdebugaddr));
-			ast_cli(a->fd, "RTCP Debugging Enabled\n");
-			return CLI_SUCCESS;
-		} else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
-			rtcpdebug = 0;
-			ast_cli(a->fd, "RTCP Debugging Disabled\n");
-			return CLI_SUCCESS;
-		}
-	} else if (a->argc == e->args +1) { /* ip */
-		return rtcp_do_debug_ip(a);
-	}
-
-	return CLI_SHOWUSAGE;   /* default, failure */
-}
-
-static char *handle_cli_rtcp_set_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "rtcp set stats {on|off}";
-		e->usage =
-			"Usage: rtcp set stats {on|off}\n"
-			"       Enable/Disable dumping of RTCP stats.\n";
-		return NULL;
-	case CLI_GENERATE:
-		return NULL;
-	}
-
-	if (a->argc != e->args)
-		return CLI_SHOWUSAGE;
-
-	if (!strncasecmp(a->argv[e->args-1], "on", 2))
-		rtcpstats = 1;
-	else if (!strncasecmp(a->argv[e->args-1], "off", 3))
-		rtcpstats = 0;
-	else
-		return CLI_SHOWUSAGE;
-
-	ast_cli(a->fd, "RTCP Stats %s\n", rtcpstats ? "Enabled" : "Disabled");
-	return CLI_SUCCESS;
-}
-
-static char *handle_cli_stun_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "stun set debug {on|off}";
-		e->usage =
-			"Usage: stun set debug {on|off}\n"
-			"       Enable/Disable STUN (Simple Traversal of UDP through NATs)\n"
-			"       debugging\n";
-		return NULL;
-	case CLI_GENERATE:
-		return NULL;
-	}
-
-	if (a->argc != e->args)
-		return CLI_SHOWUSAGE;
-
-	if (!strncasecmp(a->argv[e->args-1], "on", 2))
-		stundebug = 1;
-	else if (!strncasecmp(a->argv[e->args-1], "off", 3))
-		stundebug = 0;
-	else
-		return CLI_SHOWUSAGE;
-
-	ast_cli(a->fd, "STUN Debugging %s\n", stundebug ? "Enabled" : "Disabled");
-	return CLI_SUCCESS;
-}
-
-static struct ast_cli_entry cli_rtp[] = {
-	AST_CLI_DEFINE(handle_cli_rtp_set_debug,  "Enable/Disable RTP debugging"),
-	AST_CLI_DEFINE(handle_cli_rtcp_set_debug, "Enable/Disable RTCP debugging"),
-	AST_CLI_DEFINE(handle_cli_rtcp_set_stats, "Enable/Disable RTCP stats"),
-	AST_CLI_DEFINE(handle_cli_stun_set_debug, "Enable/Disable STUN debugging"),
-};
-
-static int __ast_rtp_reload(int reload)
-{
-	struct ast_config *cfg;
-	const char *s;
-	struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
-
-	cfg = ast_config_load2("rtp.conf", "rtp", config_flags);
-	if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
-		return 0;
-	}
-
-	rtpstart = 5000;
-	rtpend = 31000;
-	dtmftimeout = DEFAULT_DTMF_TIMEOUT;
-	strictrtp = STRICT_RTP_OPEN;
-	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;
-			};
-		}
-		if ((s = ast_variable_retrieve(cfg, "general", "strictrtp"))) {
-			strictrtp = ast_true(s);
-		}
-		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;
-	}
-	ast_verb(2, "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
-	return 0;
-}
-
-int ast_rtp_reload(void)
-{
-	return __ast_rtp_reload(1);
-}
-
-/*! \brief Initialize the RTP system in Asterisk */
-void ast_rtp_init(void)
-{
-	ast_cli_register_multiple(cli_rtp, sizeof(cli_rtp) / sizeof(struct ast_cli_entry));
-	__ast_rtp_reload(0);
-}
-
-/*! \brief Write t140 redundacy frame 
- * \param data primary data to be buffered
- */
-static int red_write(const void *data)
-{
-	struct ast_rtp *rtp = (struct ast_rtp*) data;
-	
-	ast_rtp_write(rtp, &rtp->red->t140); 
-
-	return 1;  	
-}
-
-/*! \brief Construct a redundant frame 
- * \param red redundant data structure
- */
-static struct ast_frame *red_t140_to_red(struct rtp_red *red) {
-	unsigned char *data = red->t140red.data.ptr;
-	int len = 0;
-	int i;
-
-	/* replace most aged generation */
-	if (red->len[0]) {
-		for (i = 1; i < red->num_gen+1; i++)
-			len += red->len[i];
-
-		memmove(&data[red->hdrlen], &data[red->hdrlen+red->len[0]], len); 
-	}
-	
-	/* Store length of each generation and primary data length*/
-	for (i = 0; i < red->num_gen; i++)
-		red->len[i] = red->len[i+1];
-	red->len[i] = red->t140.datalen;
-	
-	/* write each generation length in red header */
-	len = red->hdrlen;
-	for (i = 0; i < red->num_gen; i++)
-		len += data[i*4+3] = red->len[i];
-	
-	/* add primary data to buffer */
-	memcpy(&data[len], red->t140.data.ptr, red->t140.datalen); 
-	red->t140red.datalen = len + red->t140.datalen;
-	
-	/* no primary data and no generations to send */
-	if (len == red->hdrlen && !red->t140.datalen)
-		return NULL;
-
-	/* reset t.140 buffer */
-	red->t140.datalen = 0; 
-	
-	return &red->t140red;
-}
-
-/*! \brief Initialize t140 redundancy 
- * \param rtp
- * \param ti buffer t140 for ti (msecs) before sending redundant frame
- * \param red_data_pt Payloadtypes for primary- and generation-data
- * \param num_gen numbers of generations (primary generation not encounted)
- *
-*/
-int ast_rtp_red_init(struct ast_rtp *rtp, int ti, int *red_data_pt, int num_gen)
-{
-	struct rtp_red *r;
-	int x;
-	
-	if (!(r = ast_calloc(1, sizeof(struct rtp_red))))
-		return -1;
-
-	r->t140.frametype = AST_FRAME_TEXT;
-	r->t140.subclass = AST_FORMAT_T140RED;
-	r->t140.data.ptr = &r->buf_data; 
-
-	r->t140.ts = 0;
-	r->t140red = r->t140;
-	r->t140red.data.ptr = &r->t140red_data;
-	r->t140red.datalen = 0;
-	r->ti = ti;
-	r->num_gen = num_gen;
-	r->hdrlen = num_gen * 4 + 1;
-	r->prev_ts = 0;
-
-	for (x = 0; x < num_gen; x++) {
-		r->pt[x] = red_data_pt[x];
-		r->pt[x] |= 1 << 7; /* mark redundant generations pt */ 
-		r->t140red_data[x*4] = r->pt[x];
-	}
-	r->t140red_data[x*4] = r->pt[x] = red_data_pt[x]; /* primary pt */
-	r->schedid = ast_sched_add(rtp->sched, ti, red_write, rtp);
-	rtp->red = r;
-
-	r->t140.datalen = 0;
-	
-	return 0;
-}
-
-/*! \brief Buffer t140 from chan_sip
- * \param rtp
- * \param f frame
- */
-void ast_red_buffer_t140(struct ast_rtp *rtp, struct ast_frame *f)
-{
-	if (f->datalen > -1) {
-		struct rtp_red *red = rtp->red;
-		memcpy(&red->buf_data[red->t140.datalen], f->data.ptr, f->datalen);
-		red->t140.datalen += f->datalen;
-		red->t140.ts = f->ts;
-	}
-}
diff --git a/main/rtp_engine.c b/main/rtp_engine.c
new file mode 100644
index 000000000..fd448b849
--- /dev/null
+++ b/main/rtp_engine.c
@@ -0,0 +1,1572 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2008, Digium, Inc.
+ *
+ * Joshua Colp <jcolp@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Pluggable RTP Architecture
+ *
+ * \author Joshua Colp <jcolp@digium.com>
+ */
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <math.h>
+
+#include "asterisk/channel.h"
+#include "asterisk/frame.h"
+#include "asterisk/module.h"
+#include "asterisk/rtp_engine.h"
+#include "asterisk/manager.h"
+#include "asterisk/options.h"
+#include "asterisk/astobj2.h"
+#include "asterisk/pbx.h"
+
+/*! Structure that represents an RTP session (instance) */
+struct ast_rtp_instance {
+	/*! Engine that is handling this RTP instance */
+	struct ast_rtp_engine *engine;
+	/*! Data unique to the RTP engine */
+	void *data;
+	/*! RTP properties that have been set and their value */
+	int properties[AST_RTP_PROPERTY_MAX];
+	/*! Address that we are expecting RTP to come in to */
+	struct sockaddr_in local_address;
+	/*! Address that we are sending RTP to */
+	struct sockaddr_in remote_address;
+	/*! Instance that we are bridged to if doing remote or local bridging */
+	struct ast_rtp_instance *bridged;
+	/*! Payload and packetization information */
+	struct ast_rtp_codecs codecs;
+	/*! RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
+	int timeout;
+	/*! RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
+	int holdtimeout;
+	/*! DTMF mode in use */
+	enum ast_rtp_dtmf_mode dtmf_mode;
+};
+
+/*! List of RTP engines that are currently registered */
+static AST_RWLIST_HEAD_STATIC(engines, ast_rtp_engine);
+
+/*! List of RTP glues */
+static AST_RWLIST_HEAD_STATIC(glues, ast_rtp_glue);
+
+/*! The following array defines the MIME Media type (and subtype) for each
+   of our codecs, or RTP-specific data type. */
+static const struct ast_rtp_mime_type {
+	struct ast_rtp_payload_type payload_type;
+	char *type;
+	char *subtype;
+	unsigned int sample_rate;
+} ast_rtp_mime_types[] = {
+	{{1, AST_FORMAT_G723_1}, "audio", "G723", 8000},
+	{{1, AST_FORMAT_GSM}, "audio", "GSM", 8000},
+	{{1, AST_FORMAT_ULAW}, "audio", "PCMU", 8000},
+	{{1, AST_FORMAT_ULAW}, "audio", "G711U", 8000},
+	{{1, AST_FORMAT_ALAW}, "audio", "PCMA", 8000},
+	{{1, AST_FORMAT_ALAW}, "audio", "G711A", 8000},
+	{{1, AST_FORMAT_G726}, "audio", "G726-32", 8000},
+	{{1, AST_FORMAT_ADPCM}, "audio", "DVI4", 8000},
+	{{1, AST_FORMAT_SLINEAR}, "audio", "L16", 8000},
+	{{1, AST_FORMAT_LPC10}, "audio", "LPC", 8000},
+	{{1, AST_FORMAT_G729A}, "audio", "G729", 8000},
+	{{1, AST_FORMAT_G729A}, "audio", "G729A", 8000},
+	{{1, AST_FORMAT_G729A}, "audio", "G.729", 8000},
+	{{1, AST_FORMAT_SPEEX}, "audio", "speex", 8000},
+	{{1, AST_FORMAT_ILBC}, "audio", "iLBC", 8000},
+	/* this is the sample rate listed in the RTP profile for the G.722
+	              codec, *NOT* the actual sample rate of the media stream
+	*/
+	{{1, AST_FORMAT_G722}, "audio", "G722", 8000},
+	{{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32", 8000},
+	{{0, AST_RTP_DTMF}, "audio", "telephone-event", 8000},
+	{{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event", 8000},
+	{{0, AST_RTP_CN}, "audio", "CN", 8000},
+	{{1, AST_FORMAT_JPEG}, "video", "JPEG", 90000},
+	{{1, AST_FORMAT_PNG}, "video", "PNG", 90000},
+	{{1, AST_FORMAT_H261}, "video", "H261", 90000},
+	{{1, AST_FORMAT_H263}, "video", "H263", 90000},
+	{{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998", 90000},
+	{{1, AST_FORMAT_H264}, "video", "H264", 90000},
+	{{1, AST_FORMAT_MP4_VIDEO}, "video", "MP4V-ES", 90000},
+	{{1, AST_FORMAT_T140RED}, "text", "RED", 1000},
+	{{1, AST_FORMAT_T140}, "text", "T140", 1000},
+	{{1, AST_FORMAT_SIREN7}, "audio", "G7221", 16000},
+	{{1, AST_FORMAT_SIREN14}, "audio", "G7221", 32000},
+};
+
+/*!
+ * \brief Mapping between Asterisk codecs and rtp payload types
+ *
+ * Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
+ * also, our own choices for dynamic payload types.  This is our master
+ * table for transmission
+ *
+ * See http://www.iana.org/assignments/rtp-parameters for a list of
+ * assigned values
+ */
+static const struct ast_rtp_payload_type static_RTP_PT[AST_RTP_MAX_PT] = {
+	[0] = {1, AST_FORMAT_ULAW},
+	#ifdef USE_DEPRECATED_G726
+	[2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
+	#endif
+	[3] = {1, AST_FORMAT_GSM},
+	[4] = {1, AST_FORMAT_G723_1},
+	[5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
+	[6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
+	[7] = {1, AST_FORMAT_LPC10},
+	[8] = {1, AST_FORMAT_ALAW},
+	[9] = {1, AST_FORMAT_G722},
+	[10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
+	[11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
+	[13] = {0, AST_RTP_CN},
+	[16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
+	[17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
+	[18] = {1, AST_FORMAT_G729A},
+	[19] = {0, AST_RTP_CN},         /* Also used for CN */
+	[26] = {1, AST_FORMAT_JPEG},
+	[31] = {1, AST_FORMAT_H261},
+	[34] = {1, AST_FORMAT_H263},
+	[97] = {1, AST_FORMAT_ILBC},
+	[98] = {1, AST_FORMAT_H263_PLUS},
+	[99] = {1, AST_FORMAT_H264},
+	[101] = {0, AST_RTP_DTMF},
+	[102] = {1, AST_FORMAT_SIREN7},
+	[103] = {1, AST_FORMAT_H263_PLUS},
+	[104] = {1, AST_FORMAT_MP4_VIDEO},
+	[105] = {1, AST_FORMAT_T140RED},        /* Real time text chat (with redundancy encoding) */
+	[106] = {1, AST_FORMAT_T140},   /* Real time text chat */
+	[110] = {1, AST_FORMAT_SPEEX},
+	[111] = {1, AST_FORMAT_G726},
+	[112] = {1, AST_FORMAT_G726_AAL2},
+	[115] = {1, AST_FORMAT_SIREN14},
+	[121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
+};
+
+int ast_rtp_engine_register2(struct ast_rtp_engine *engine, struct ast_module *module)
+{
+	struct ast_rtp_engine *current_engine;
+
+	/* Perform a sanity check on the engine structure to make sure it has the basics */
+	if (ast_strlen_zero(engine->name) || !engine->new || !engine->destroy || !engine->write || !engine->read) {
+		ast_log(LOG_WARNING, "RTP Engine '%s' failed sanity check so it was not registered.\n", !ast_strlen_zero(engine->name) ? engine->name : "Unknown");
+		return -1;
+	}
+
+	/* Link owner module to the RTP engine for reference counting purposes */
+	engine->mod = module;
+
+	AST_RWLIST_WRLOCK(&engines);
+
+	/* Ensure that no two modules with the same name are registered at the same time */
+	AST_RWLIST_TRAVERSE(&engines, current_engine, entry) {
+		if (!strcmp(current_engine->name, engine->name)) {
+			ast_log(LOG_WARNING, "An RTP engine with the name '%s' has already been registered.\n", engine->name);
+			AST_RWLIST_UNLOCK(&engines);
+			return -1;
+		}
+	}
+
+	/* The engine survived our critique. Off to the list it goes to be used */
+	AST_RWLIST_INSERT_TAIL(&engines, engine, entry);
+
+	AST_RWLIST_UNLOCK(&engines);
+
+	ast_verb(2, "Registered RTP engine '%s'\n", engine->name);
+
+	return 0;
+}
+
+int ast_rtp_engine_unregister(struct ast_rtp_engine *engine)
+{
+	struct ast_rtp_engine *current_engine = NULL;
+
+	AST_RWLIST_WRLOCK(&engines);
+
+	if ((current_engine = AST_RWLIST_REMOVE(&engines, engine, entry))) {
+		ast_verb(2, "Unregistered RTP engine '%s'\n", engine->name);
+	}
+
+	AST_RWLIST_UNLOCK(&engines);
+
+	return current_engine ? 0 : -1;
+}
+
+int ast_rtp_glue_register2(struct ast_rtp_glue *glue, struct ast_module *module)
+{
+	struct ast_rtp_glue *current_glue = NULL;
+
+	if (ast_strlen_zero(glue->type)) {
+		return -1;
+	}
+
+	glue->mod = module;
+
+	AST_RWLIST_WRLOCK(&glues);
+
+	AST_RWLIST_TRAVERSE(&glues, current_glue, entry) {
+		if (!strcasecmp(current_glue->type, glue->type)) {
+			ast_log(LOG_WARNING, "RTP glue with the name '%s' has already been registered.\n", glue->type);
+			AST_RWLIST_UNLOCK(&glues);
+			return -1;
+		}
+	}
+
+	AST_RWLIST_INSERT_TAIL(&glues, glue, entry);
+
+	AST_RWLIST_UNLOCK(&glues);
+
+	ast_verb(2, "Registered RTP glue '%s'\n", glue->type);
+
+	return 0;
+}
+
+int ast_rtp_glue_unregister(struct ast_rtp_glue *glue)
+{
+	struct ast_rtp_glue *current_glue = NULL;
+
+	AST_RWLIST_WRLOCK(&glues);
+
+	if ((current_glue = AST_RWLIST_REMOVE(&glues, glue, entry))) {
+		ast_verb(2, "Unregistered RTP glue '%s'\n", glue->type);
+	}
+
+	AST_RWLIST_UNLOCK(&glues);
+
+	return current_glue ? 0 : -1;
+}
+
+static void instance_destructor(void *obj)
+{
+	struct ast_rtp_instance *instance = obj;
+
+	/* Pass us off to the engine to destroy */
+	if (instance->data && instance->engine->destroy(instance)) {
+		ast_debug(1, "Engine '%s' failed to destroy RTP instance '%p'\n", instance->engine->name, instance);
+		return;
+	}
+
+	/* Drop our engine reference */
+	ast_module_unref(instance->engine->mod);
+
+	ast_debug(1, "Destroyed RTP instance '%p'\n", instance);
+}
+
+int ast_rtp_instance_destroy(struct ast_rtp_instance *instance)
+{
+	ao2_ref(instance, -1);
+
+	return 0;
+}
+
+struct ast_rtp_instance *ast_rtp_instance_new(const char *engine_name, struct sched_context *sched, struct sockaddr_in *sin, void *data)
+{
+	struct ast_rtp_instance *instance = NULL;
+	struct ast_rtp_engine *engine = NULL;
+
+	AST_RWLIST_RDLOCK(&engines);
+
+	/* If an engine name was specified try to use it or otherwise use the first one registered */
+	if (!ast_strlen_zero(engine_name)) {
+		AST_RWLIST_TRAVERSE(&engines, engine, entry) {
+			if (!strcmp(engine->name, engine_name)) {
+				break;
+			}
+		}
+	} else {
+		engine = AST_RWLIST_FIRST(&engines);
+	}
+
+	/* If no engine was actually found bail out now */
+	if (!engine) {
+		ast_log(LOG_ERROR, "No RTP engine was found. Do you have one loaded?\n");
+		AST_RWLIST_UNLOCK(&engines);
+		return NULL;
+	}
+
+	/* Bump up the reference count before we return so the module can not be unloaded */
+	ast_module_ref(engine->mod);
+
+	AST_RWLIST_UNLOCK(&engines);
+
+	/* Allocate a new RTP instance */
+	if (!(instance = ao2_alloc(sizeof(*instance), instance_destructor))) {
+		ast_module_unref(engine->mod);
+		return NULL;
+	}
+	instance->engine = engine;
+	memcpy(&instance->local_address, sin, sizeof(instance->local_address));
+
+	ast_debug(1, "Using engine '%s' for RTP instance '%p'\n", engine->name, instance);
+
+	/* And pass it off to the engine to setup */
+	if (instance->engine->new(instance, sched, sin, data)) {
+		ast_debug(1, "Engine '%s' failed to setup RTP instance '%p'\n", engine->name, instance);
+		ao2_ref(instance, -1);
+		return NULL;
+	}
+
+	ast_debug(1, "RTP instance '%p' is setup and ready to go\n", instance);
+
+	return instance;
+}
+
+void ast_rtp_instance_set_data(struct ast_rtp_instance *instance, void *data)
+{
+	instance->data = data;
+}
+
+void *ast_rtp_instance_get_data(struct ast_rtp_instance *instance)
+{
+	return instance->data;
+}
+
+int ast_rtp_instance_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
+{
+	return instance->engine->write(instance, frame);
+}
+
+struct ast_frame *ast_rtp_instance_read(struct ast_rtp_instance *instance, int rtcp)
+{
+	return instance->engine->read(instance, rtcp);
+}
+
+int ast_rtp_instance_set_local_address(struct ast_rtp_instance *instance, struct sockaddr_in *address)
+{
+	memcpy(&instance->local_address, address, sizeof(instance->local_address));
+	return 0;
+}
+
+int ast_rtp_instance_set_remote_address(struct ast_rtp_instance *instance, struct sockaddr_in *address)
+{
+	if (&instance->remote_address != address) {
+		memcpy(&instance->remote_address, address, sizeof(instance->remote_address));
+	}
+
+	/* moo */
+
+	if (instance->engine->remote_address_set) {
+		instance->engine->remote_address_set(instance, address);
+	}
+
+	return 0;
+}
+
+int ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance, struct sockaddr_in *address)
+{
+	if ((address->sin_family != AF_INET) ||
+	    (address->sin_port != instance->local_address.sin_port) ||
+	    (address->sin_addr.s_addr != instance->local_address.sin_addr.s_addr)) {
+		memcpy(address, &instance->local_address, sizeof(address));
+		return 1;
+	}
+
+	return 0;
+}
+
+int ast_rtp_instance_get_remote_address(struct ast_rtp_instance *instance, struct sockaddr_in *address)
+{
+	if ((address->sin_family != AF_INET) ||
+	    (address->sin_port != instance->remote_address.sin_port) ||
+	    (address->sin_addr.s_addr != instance->remote_address.sin_addr.s_addr)) {
+		memcpy(address, &instance->remote_address, sizeof(address));
+		return 1;
+	}
+
+	return 0;
+}
+
+void ast_rtp_instance_set_extended_prop(struct ast_rtp_instance *instance, int property, void *value)
+{
+	if (instance->engine->extended_prop_set) {
+		instance->engine->extended_prop_set(instance, property, value);
+	}
+}
+
+void *ast_rtp_instance_get_extended_prop(struct ast_rtp_instance *instance, int property)
+{
+	if (instance->engine->extended_prop_get) {
+		return instance->engine->extended_prop_get(instance, property);
+	}
+
+	return NULL;
+}
+
+void ast_rtp_instance_set_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
+{
+	instance->properties[property] = value;
+
+	if (instance->engine->prop_set) {
+		instance->engine->prop_set(instance, property, value);
+	}
+}
+
+int ast_rtp_instance_get_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property)
+{
+	return instance->properties[property];
+}
+
+struct ast_rtp_codecs *ast_rtp_instance_get_codecs(struct ast_rtp_instance *instance)
+{
+	return &instance->codecs;
+}
+
+void ast_rtp_codecs_payloads_clear(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance)
+{
+	int i;
+
+	for (i = 0; i < AST_RTP_MAX_PT; i++) {
+		ast_debug(2, "Clearing payload %d on %p\n", i, codecs);
+		codecs->payloads[i].asterisk_format = 0;
+		codecs->payloads[i].code = 0;
+		if (instance && instance->engine && instance->engine->payload_set) {
+			instance->engine->payload_set(instance, i, 0, 0);
+		}
+	}
+}
+
+void ast_rtp_codecs_payloads_default(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance)
+{
+	int i;
+
+	for (i = 0; i < AST_RTP_MAX_PT; i++) {
+		if (static_RTP_PT[i].code) {
+			ast_debug(2, "Set default payload %d on %p\n", i, codecs);
+			codecs->payloads[i].asterisk_format = static_RTP_PT[i].asterisk_format;
+			codecs->payloads[i].code = static_RTP_PT[i].code;
+			if (instance && instance->engine && instance->engine->payload_set) {
+				instance->engine->payload_set(instance, i, codecs->payloads[i].asterisk_format, codecs->payloads[i].code);
+			}
+		}
+	}
+}
+
+void ast_rtp_codecs_payloads_copy(struct ast_rtp_codecs *src, struct ast_rtp_codecs *dest, struct ast_rtp_instance *instance)
+{
+	int i;
+
+	for (i = 0; i < AST_RTP_MAX_PT; i++) {
+		if (src->payloads[i].code) {
+			ast_debug(2, "Copying payload %d from %p to %p\n", i, src, dest);
+			dest->payloads[i].asterisk_format = src->payloads[i].asterisk_format;
+			dest->payloads[i].code = src->payloads[i].code;
+			if (instance && instance->engine && instance->engine->payload_set) {
+				instance->engine->payload_set(instance, i, dest->payloads[i].asterisk_format, dest->payloads[i].code);
+			}
+		}
+	}
+}
+
+void ast_rtp_codecs_payloads_set_m_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload)
+{
+	if (payload < 0 || payload > AST_RTP_MAX_PT || !static_RTP_PT[payload].code) {
+		return;
+	}
+
+	codecs->payloads[payload].asterisk_format = static_RTP_PT[payload].asterisk_format;
+	codecs->payloads[payload].code = static_RTP_PT[payload].code;
+
+	ast_debug(1, "Setting payload %d based on m type on %p\n", payload, codecs);
+
+	if (instance && instance->engine && instance->engine->payload_set) {
+		instance->engine->payload_set(instance, payload, codecs->payloads[payload].asterisk_format, codecs->payloads[payload].code);
+	}
+}
+
+int ast_rtp_codecs_payloads_set_rtpmap_type_rate(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int pt,
+				 char *mimetype, char *mimesubtype,
+				 enum ast_rtp_options options,
+				 unsigned int sample_rate)
+{
+	unsigned int i;
+	int found = 0;
+
+	if (pt < 0 || pt > AST_RTP_MAX_PT)
+		return -1; /* bogus payload type */
+
+	for (i = 0; i < ARRAY_LEN(ast_rtp_mime_types); ++i) {
+		const struct ast_rtp_mime_type *t = &ast_rtp_mime_types[i];
+
+		if (strcasecmp(mimesubtype, t->subtype)) {
+			continue;
+		}
+
+		if (strcasecmp(mimetype, t->type)) {
+			continue;
+		}
+
+		/* if both sample rates have been supplied, and they don't match,
+		                      then this not a match; if one has not been supplied, then the
+				      rates are not compared */
+		if (sample_rate && t->sample_rate &&
+		    (sample_rate != t->sample_rate)) {
+			continue;
+		}
+
+		found = 1;
+		codecs->payloads[pt] = t->payload_type;
+
+		if ((t->payload_type.code == AST_FORMAT_G726) &&
+		                        t->payload_type.asterisk_format &&
+		    (options & AST_RTP_OPT_G726_NONSTANDARD)) {
+			codecs->payloads[pt].code = AST_FORMAT_G726_AAL2;
+		}
+
+		if (instance && instance->engine && instance->engine->payload_set) {
+			instance->engine->payload_set(instance, pt, codecs->payloads[i].asterisk_format, codecs->payloads[i].code);
+		}
+
+		break;
+	}
+
+	return (found ? 0 : -2);
+}
+
+int ast_rtp_codecs_payloads_set_rtpmap_type(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload, char *mimetype, char *mimesubtype, enum ast_rtp_options options)
+{
+	return ast_rtp_codecs_payloads_set_rtpmap_type_rate(codecs, instance, payload, mimetype, mimesubtype, options, 0);
+}
+
+void ast_rtp_codecs_payloads_unset(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload)
+{
+	if (payload < 0 || payload > AST_RTP_MAX_PT) {
+		return;
+	}
+
+	ast_debug(2, "Unsetting payload %d on %p\n", payload, codecs);
+
+	codecs->payloads[payload].asterisk_format = 0;
+	codecs->payloads[payload].code = 0;
+
+	if (instance && instance->engine && instance->engine->payload_set) {
+		instance->engine->payload_set(instance, payload, 0, 0);
+	}
+}
+
+struct ast_rtp_payload_type ast_rtp_codecs_payload_lookup(struct ast_rtp_codecs *codecs, int payload)
+{
+	struct ast_rtp_payload_type result = { .asterisk_format = 0, };
+
+	if (payload < 0 || payload > AST_RTP_MAX_PT) {
+		return result;
+	}
+
+	result.asterisk_format = codecs->payloads[payload].asterisk_format;
+	result.code = codecs->payloads[payload].code;
+
+	if (!result.code) {
+		result = static_RTP_PT[payload];
+	}
+
+	return result;
+}
+
+void ast_rtp_codecs_payload_formats(struct ast_rtp_codecs *codecs, int *astformats, int *nonastformats)
+{
+	int i;
+
+	*astformats = *nonastformats = 0;
+
+	for (i = 0; i < AST_RTP_MAX_PT; i++) {
+		if (codecs->payloads[i].code) {
+			ast_debug(1, "Incorporating payload %d on %p\n", i, codecs);
+		}
+		if (codecs->payloads[i].asterisk_format) {
+			*astformats |= codecs->payloads[i].code;
+		} else {
+			*nonastformats |= codecs->payloads[i].code;
+		}
+	}
+}
+
+int ast_rtp_codecs_payload_code(struct ast_rtp_codecs *codecs, const int asterisk_format, const int code)
+{
+	int i;
+
+	for (i = 0; i < AST_RTP_MAX_PT; i++) {
+		if (codecs->payloads[i].asterisk_format == asterisk_format && codecs->payloads[i].code == code) {
+			ast_debug(2, "Found code %d at payload %d on %p\n", code, i, codecs);
+			return i;
+		}
+	}
+
+	for (i = 0; i < AST_RTP_MAX_PT; i++) {
+		if (static_RTP_PT[i].asterisk_format == asterisk_format && static_RTP_PT[i].code == code) {
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+const char *ast_rtp_lookup_mime_subtype2(const int asterisk_format, const int code, enum ast_rtp_options options)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_LEN(ast_rtp_mime_types); i++) {
+		if (ast_rtp_mime_types[i].payload_type.code == code && ast_rtp_mime_types[i].payload_type.asterisk_format == asterisk_format) {
+			if (asterisk_format && (code == AST_FORMAT_G726_AAL2) && (options & AST_RTP_OPT_G726_NONSTANDARD)) {
+				return "G726-32";
+			} else {
+				return ast_rtp_mime_types[i].subtype;
+			}
+		}
+	}
+
+	return "";
+}
+
+unsigned int ast_rtp_lookup_sample_rate2(int asterisk_format, int code)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_LEN(ast_rtp_mime_types); ++i) {
+		if ((ast_rtp_mime_types[i].payload_type.code == code) && (ast_rtp_mime_types[i].payload_type.asterisk_format == asterisk_format)) {
+			return ast_rtp_mime_types[i].sample_rate;
+		}
+	}
+
+	return 0;
+}
+
+char *ast_rtp_lookup_mime_multiple2(struct ast_str *buf, const int capability, const int asterisk_format, enum ast_rtp_options options)
+{
+	int format, found = 0;
+
+	if (!buf) {
+		return NULL;
+	}
+
+	ast_str_append(&buf, 0, "0x%x (", capability);
+
+	for (format = 1; format < AST_RTP_MAX; format <<= 1) {
+		if (capability & format) {
+			const char *name = ast_rtp_lookup_mime_subtype2(asterisk_format, format, options);
+			ast_str_append(&buf, 0, "%s|", name);
+			found = 1;
+		}
+	}
+
+	ast_str_append(&buf, 0, "%s", found ? ")" : "nothing)");
+
+	return ast_str_buffer(buf);
+}
+
+void ast_rtp_codecs_packetization_set(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, struct ast_codec_pref *prefs)
+{
+	codecs->pref = *prefs;
+
+	if (instance && instance->engine->packetization_set) {
+		instance->engine->packetization_set(instance, &instance->codecs.pref);
+	}
+}
+
+int ast_rtp_instance_dtmf_begin(struct ast_rtp_instance *instance, char digit)
+{
+	return instance->engine->dtmf_begin ? instance->engine->dtmf_begin(instance, digit) : -1;
+}
+
+int ast_rtp_instance_dtmf_end(struct ast_rtp_instance *instance, char digit)
+{
+	return instance->engine->dtmf_end ? instance->engine->dtmf_end(instance, digit) : -1;
+}
+
+int ast_rtp_instance_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode)
+{
+	if (!instance->engine->dtmf_mode_set || instance->engine->dtmf_mode_set(instance, dtmf_mode)) {
+		return -1;
+	}
+
+	instance->dtmf_mode = dtmf_mode;
+
+	return 0;
+}
+
+enum ast_rtp_dtmf_mode ast_rtp_instance_dtmf_mode_get(struct ast_rtp_instance *instance)
+{
+	return instance->dtmf_mode;
+}
+
+void ast_rtp_instance_new_source(struct ast_rtp_instance *instance)
+{
+	if (instance->engine->new_source) {
+		instance->engine->new_source(instance);
+	}
+}
+
+int ast_rtp_instance_set_qos(struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
+{
+	return instance->engine->qos ? instance->engine->qos(instance, tos, cos, desc) : -1;
+}
+
+void ast_rtp_instance_stop(struct ast_rtp_instance *instance)
+{
+	if (instance->engine->stop) {
+		instance->engine->stop(instance);
+	}
+}
+
+int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp)
+{
+	return instance->engine->fd ? instance->engine->fd(instance, rtcp) : -1;
+}
+
+struct ast_rtp_glue *ast_rtp_instance_get_glue(const char *type)
+{
+	struct ast_rtp_glue *glue = NULL;
+
+	AST_RWLIST_RDLOCK(&glues);
+
+	AST_RWLIST_TRAVERSE(&glues, glue, entry) {
+		if (!strcasecmp(glue->type, type)) {
+			break;
+		}
+	}
+
+	AST_RWLIST_UNLOCK(&glues);
+
+	return glue;
+}
+
+static enum ast_bridge_result local_bridge_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
+{
+	enum ast_bridge_result res = AST_BRIDGE_FAILED;
+	struct ast_channel *who = NULL, *other = NULL, *cs[3] = { NULL, };
+	struct ast_frame *fr = NULL;
+
+	/* Start locally bridging both instances */
+	if (instance0->engine->local_bridge && instance0->engine->local_bridge(instance0, instance1)) {
+		ast_debug(1, "Failed to locally bridge %s to %s, backing out.\n", c0->name, c1->name);
+		ast_channel_unlock(c0);
+		ast_channel_unlock(c1);
+		return AST_BRIDGE_FAILED_NOWARN;
+	}
+	if (instance1->engine->local_bridge && instance1->engine->local_bridge(instance1, instance0)) {
+		ast_debug(1, "Failed to locally bridge %s to %s, backing out.\n", c1->name, c0->name);
+		if (instance0->engine->local_bridge) {
+			instance0->engine->local_bridge(instance0, NULL);
+		}
+		ast_channel_unlock(c0);
+		ast_channel_unlock(c1);
+		return AST_BRIDGE_FAILED_NOWARN;
+	}
+
+	ast_channel_unlock(c0);
+	ast_channel_unlock(c1);
+
+	instance0->bridged = instance1;
+	instance1->bridged = instance0;
+
+	ast_poll_channel_add(c0, c1);
+
+	/* Hop into a loop waiting for a frame from either channel */
+	cs[0] = c0;
+	cs[1] = c1;
+	cs[2] = NULL;
+	for (;;) {
+		/* If the underlying formats have changed force this bridge to break */
+		if ((c0->rawreadformat != c1->rawwriteformat) || (c1->rawreadformat != c0->rawwriteformat)) {
+			ast_debug(1, "rtp-engine-local-bridge: Oooh, formats changed, backing out\n");
+			res = AST_BRIDGE_FAILED_NOWARN;
+			break;
+		}
+		/* Check if anything changed */
+		if ((c0->tech_pvt != pvt0) ||
+		    (c1->tech_pvt != pvt1) ||
+		    (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
+		    (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
+			ast_debug(1, "rtp-engine-local-bridge: Oooh, something is weird, backing out\n");
+			/* If a masquerade needs to happen we have to try to read in a frame so that it actually happens. Without this we risk being called again and going into a loop */
+			if ((c0->masq || c0->masqr) && (fr = ast_read(c0))) {
+				ast_frfree(fr);
+			}
+			if ((c1->masq || c1->masqr) && (fr = ast_read(c1))) {
+				ast_frfree(fr);
+			}
+			res = AST_BRIDGE_RETRY;
+			break;
+		}
+		/* Wait on a channel to feed us a frame */
+		if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
+			if (!timeoutms) {
+				res = AST_BRIDGE_RETRY;
+				break;
+			}
+			ast_debug(2, "rtp-engine-local-bridge: Ooh, empty read...\n");
+			if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
+				break;
+			}
+			continue;
+		}
+		/* Read in frame from channel */
+		fr = ast_read(who);
+		other = (who == c0) ? c1 : c0;
+		/* Depending on the frame we may need to break out of our bridge */
+		if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
+			    ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
+			    ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
+			/* Record received frame and who */
+			*fo = fr;
+			*rc = who;
+			ast_debug(1, "rtp-engine-local-bridge: Ooh, got a %s\n", fr ? "digit" : "hangup");
+			res = AST_BRIDGE_COMPLETE;
+			break;
+		} else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
+			if ((fr->subclass == AST_CONTROL_HOLD) ||
+			    (fr->subclass == AST_CONTROL_UNHOLD) ||
+			    (fr->subclass == AST_CONTROL_VIDUPDATE) ||
+			    (fr->subclass == AST_CONTROL_T38) ||
+			    (fr->subclass == AST_CONTROL_SRCUPDATE)) {
+				/* If we are going on hold, then break callback mode and P2P bridging */
+				if (fr->subclass == AST_CONTROL_HOLD) {
+					if (instance0->engine->local_bridge) {
+						instance0->engine->local_bridge(instance0, NULL);
+					}
+					if (instance1->engine->local_bridge) {
+						instance1->engine->local_bridge(instance1, NULL);
+					}
+					instance0->bridged = NULL;
+					instance1->bridged = NULL;
+				} else if (fr->subclass == AST_CONTROL_UNHOLD) {
+					if (instance0->engine->local_bridge) {
+						instance0->engine->local_bridge(instance0, instance1);
+					}
+					if (instance1->engine->local_bridge) {
+						instance1->engine->local_bridge(instance1, instance0);
+					}
+					instance0->bridged = instance1;
+					instance1->bridged = instance0;
+				}
+				ast_indicate_data(other, fr->subclass, fr->data.ptr, fr->datalen);
+				ast_frfree(fr);
+			} else {
+				*fo = fr;
+				*rc = who;
+				ast_debug(1, "rtp-engine-local-bridge: Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
+				res = AST_BRIDGE_COMPLETE;
+				break;
+			}
+		} else {
+			if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
+			    (fr->frametype == AST_FRAME_DTMF_END) ||
+			    (fr->frametype == AST_FRAME_VOICE) ||
+			    (fr->frametype == AST_FRAME_VIDEO) ||
+			    (fr->frametype == AST_FRAME_IMAGE) ||
+			    (fr->frametype == AST_FRAME_HTML) ||
+			    (fr->frametype == AST_FRAME_MODEM) ||
+			    (fr->frametype == AST_FRAME_TEXT)) {
+				ast_write(other, fr);
+			}
+
+			ast_frfree(fr);
+		}
+		/* Swap priority */
+		cs[2] = cs[0];
+		cs[0] = cs[1];
+		cs[1] = cs[2];
+	}
+
+	/* Stop locally bridging both instances */
+	if (instance0->engine->local_bridge) {
+		instance0->engine->local_bridge(instance0, NULL);
+	}
+	if (instance1->engine->local_bridge) {
+		instance1->engine->local_bridge(instance1, NULL);
+	}
+
+	instance0->bridged = NULL;
+	instance1->bridged = NULL;
+
+	ast_poll_channel_del(c0, c1);
+
+	return res;
+}
+
+static enum ast_bridge_result remote_bridge_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1,
+						 struct ast_rtp_instance *vinstance0, struct ast_rtp_instance *vinstance1, struct ast_rtp_instance *tinstance0,
+						 struct ast_rtp_instance *tinstance1, struct ast_rtp_glue *glue0, struct ast_rtp_glue *glue1, int codec0, int codec1, int timeoutms,
+						 int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
+{
+	enum ast_bridge_result res = AST_BRIDGE_FAILED;
+	struct ast_channel *who = NULL, *other = NULL, *cs[3] = { NULL, };
+	int oldcodec0 = codec0, oldcodec1 = codec1;
+	struct sockaddr_in ac1 = {0,}, vac1 = {0,}, tac1 = {0,}, ac0 = {0,}, vac0 = {0,}, tac0 = {0,};
+	struct sockaddr_in t1 = {0,}, vt1 = {0,}, tt1 = {0,}, t0 = {0,}, vt0 = {0,}, tt0 = {0,};
+	struct ast_frame *fr = NULL;
+
+	/* Test the first channel */
+	if (!(glue0->update_peer(c0, instance1, vinstance1, tinstance1, codec1, 0))) {
+		ast_rtp_instance_get_remote_address(instance1, &ac1);
+		if (vinstance1) {
+			ast_rtp_instance_get_remote_address(vinstance1, &vac1);
+		}
+		if (tinstance1) {
+			ast_rtp_instance_get_remote_address(tinstance1, &tac1);
+		}
+	} else {
+		ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
+	}
+
+	/* Test the second channel */
+	if (!(glue1->update_peer(c1, instance0, vinstance0, tinstance0, codec0, 0))) {
+		ast_rtp_instance_get_remote_address(instance0, &ac0);
+		if (vinstance0) {
+			ast_rtp_instance_get_remote_address(instance0, &vac0);
+		}
+		if (tinstance0) {
+			ast_rtp_instance_get_remote_address(instance0, &tac0);
+		}
+	} else {
+		ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
+	}
+
+	ast_channel_unlock(c0);
+	ast_channel_unlock(c1);
+
+	instance0->bridged = instance1;
+	instance1->bridged = instance0;
+
+	ast_poll_channel_add(c0, c1);
+
+	/* Go into a loop handling any stray frames that may come in */
+	cs[0] = c0;
+	cs[1] = c1;
+	cs[2] = NULL;
+	for (;;) {
+		/* Check if anything changed */
+		if ((c0->tech_pvt != pvt0) ||
+		    (c1->tech_pvt != pvt1) ||
+		    (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
+		    (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
+			ast_debug(1, "Oooh, something is weird, backing out\n");
+			res = AST_BRIDGE_RETRY;
+			break;
+		}
+
+		/* Check if they have changed their address */
+		ast_rtp_instance_get_remote_address(instance1, &t1);
+		if (vinstance1) {
+			ast_rtp_instance_get_remote_address(vinstance1, &vt1);
+		}
+		if (tinstance1) {
+			ast_rtp_instance_get_remote_address(tinstance1, &tt1);
+		}
+		if (glue1->get_codec) {
+			codec1 = glue1->get_codec(c1);
+		}
+
+		ast_rtp_instance_get_remote_address(instance0, &t0);
+		if (vinstance0) {
+			ast_rtp_instance_get_remote_address(vinstance0, &vt0);
+		}
+		if (tinstance0) {
+			ast_rtp_instance_get_remote_address(tinstance0, &tt0);
+		}
+		if (glue0->get_codec) {
+			codec0 = glue0->get_codec(c0);
+		}
+
+		if ((inaddrcmp(&t1, &ac1)) ||
+		    (vinstance1 && inaddrcmp(&vt1, &vac1)) ||
+		    (tinstance1 && inaddrcmp(&tt1, &tac1)) ||
+		    (codec1 != oldcodec1)) {
+			ast_debug(1, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
+				  c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
+			ast_debug(1, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
+				  c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
+			ast_debug(1, "Oooh, '%s' changed end taddress to %s:%d (format %d)\n",
+				  c1->name, ast_inet_ntoa(tt1.sin_addr), ntohs(tt1.sin_port), codec1);
+			ast_debug(1, "Oooh, '%s' was %s:%d/(format %d)\n",
+				  c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
+			ast_debug(1, "Oooh, '%s' was %s:%d/(format %d)\n",
+				  c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
+			ast_debug(1, "Oooh, '%s' was %s:%d/(format %d)\n",
+				  c1->name, ast_inet_ntoa(tac1.sin_addr), ntohs(tac1.sin_port), oldcodec1);
+			if (glue0->update_peer(c0, t1.sin_addr.s_addr ? instance1 : NULL, vt1.sin_addr.s_addr ? vinstance1 : NULL, tt1.sin_addr.s_addr ? tinstance1 : NULL, codec1, 0)) {
+				ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
+			}
+			memcpy(&ac1, &t1, sizeof(ac1));
+			memcpy(&vac1, &vt1, sizeof(vac1));
+			memcpy(&tac1, &tt1, sizeof(tac1));
+			oldcodec1 = codec1;
+		}
+		if ((inaddrcmp(&t0, &ac0)) ||
+		    (vinstance0 && inaddrcmp(&vt0, &vac0)) ||
+		    (tinstance0 && inaddrcmp(&tt0, &tac0))) {
+			ast_debug(1, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
+				  c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
+			ast_debug(1, "Oooh, '%s' was %s:%d/(format %d)\n",
+				  c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
+			if (glue1->update_peer(c1, t0.sin_addr.s_addr ? instance0 : NULL, vt0.sin_addr.s_addr ? vinstance0 : NULL, tt0.sin_addr.s_addr ? tinstance0 : NULL, codec0, 0)) {
+				ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
+			}
+			memcpy(&ac0, &t0, sizeof(ac0));
+			memcpy(&vac0, &vt0, sizeof(vac0));
+			memcpy(&tac0, &tt0, sizeof(tac0));
+			oldcodec0 = codec0;
+		}
+
+		/* Wait for frame to come in on the channels */
+		if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
+			if (!timeoutms) {
+				res = AST_BRIDGE_RETRY;
+				break;
+			}
+			ast_debug(1, "Ooh, empty read...\n");
+			if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
+				break;
+			}
+			continue;
+		}
+		fr = ast_read(who);
+		other = (who == c0) ? c1 : c0;
+		if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
+			    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
+			     ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
+			/* Break out of bridge */
+			*fo = fr;
+			*rc = who;
+			ast_debug(1, "Oooh, got a %s\n", fr ? "digit" : "hangup");
+			res = AST_BRIDGE_COMPLETE;
+			break;
+		} else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
+			if ((fr->subclass == AST_CONTROL_HOLD) ||
+			    (fr->subclass == AST_CONTROL_UNHOLD) ||
+			    (fr->subclass == AST_CONTROL_VIDUPDATE) ||
+			    (fr->subclass == AST_CONTROL_T38) ||
+			    (fr->subclass == AST_CONTROL_SRCUPDATE)) {
+				if (fr->subclass == AST_CONTROL_HOLD) {
+					/* If we someone went on hold we want the other side to reinvite back to us */
+					if (who == c0) {
+						glue1->update_peer(c1, NULL, NULL, NULL, 0, 0);
+					} else {
+						glue0->update_peer(c0, NULL, NULL, NULL, 0, 0);
+					}
+				} else if (fr->subclass == AST_CONTROL_UNHOLD) {
+					/* If they went off hold they should go back to being direct */
+					if (who == c0) {
+						glue1->update_peer(c1, instance0, vinstance0, tinstance0, codec0, 0);
+					} else {
+						glue0->update_peer(c0, instance1, vinstance1, tinstance1, codec1, 0);
+					}
+				}
+				/* Update local address information */
+				ast_rtp_instance_get_remote_address(instance0, &t0);
+				memcpy(&ac0, &t0, sizeof(ac0));
+				ast_rtp_instance_get_remote_address(instance1, &t1);
+				memcpy(&ac1, &t1, sizeof(ac1));
+				/* Update codec information */
+				if (glue0->get_codec && c0->tech_pvt) {
+					oldcodec0 = codec0 = glue0->get_codec(c0);
+				}
+				if (glue1->get_codec && c1->tech_pvt) {
+					oldcodec1 = codec1 = glue1->get_codec(c1);
+				}
+				ast_indicate_data(other, fr->subclass, fr->data.ptr, fr->datalen);
+				ast_frfree(fr);
+			} else {
+				*fo = fr;
+				*rc = who;
+				ast_debug(1, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
+				return AST_BRIDGE_COMPLETE;
+			}
+		} else {
+			if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
+			    (fr->frametype == AST_FRAME_DTMF_END) ||
+			    (fr->frametype == AST_FRAME_VOICE) ||
+			    (fr->frametype == AST_FRAME_VIDEO) ||
+			    (fr->frametype == AST_FRAME_IMAGE) ||
+			    (fr->frametype == AST_FRAME_HTML) ||
+			    (fr->frametype == AST_FRAME_MODEM) ||
+			    (fr->frametype == AST_FRAME_TEXT)) {
+				ast_write(other, fr);
+			}
+			ast_frfree(fr);
+		}
+		/* Swap priority */
+		cs[2] = cs[0];
+		cs[0] = cs[1];
+		cs[1] = cs[2];
+	}
+
+	if (glue0->update_peer(c0, NULL, NULL, NULL, 0, 0)) {
+		ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
+	}
+	if (glue1->update_peer(c1, NULL, NULL, NULL, 0, 0)) {
+		ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
+	}
+
+	instance0->bridged = NULL;
+	instance1->bridged = NULL;
+
+	ast_poll_channel_del(c0, c1);
+
+	return res;
+}
+
+/*!
+ * \brief Conditionally unref an rtp instance
+ */
+static void unref_instance_cond(struct ast_rtp_instance **instance)
+{
+	if (*instance) {
+		ao2_ref(*instance, -1);
+		*instance = NULL;
+	}
+}
+
+enum ast_bridge_result ast_rtp_instance_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
+{
+	struct ast_rtp_instance *instance0 = NULL, *instance1 = NULL,
+			*vinstance0 = NULL, *vinstance1 = NULL,
+			*tinstance0 = NULL, *tinstance1 = NULL;
+	struct ast_rtp_glue *glue0, *glue1;
+	enum ast_rtp_glue_result audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID, video_glue0_res = AST_RTP_GLUE_RESULT_FORBID, text_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
+	enum ast_rtp_glue_result audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID, video_glue1_res = AST_RTP_GLUE_RESULT_FORBID, text_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
+	enum ast_bridge_result res = AST_BRIDGE_FAILED;
+	int codec0 = 0, codec1 = 0;
+	int unlock_chans = 1;
+
+	/* Lock both channels so we can look for the glue that binds them together */
+	ast_channel_lock(c0);
+	while (ast_channel_trylock(c1)) {
+		ast_channel_unlock(c0);
+		usleep(1);
+		ast_channel_lock(c0);
+	}
+
+	/* Ensure neither channel got hungup during lock avoidance */
+	if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
+		ast_log(LOG_WARNING, "Got hangup while attempting to bridge '%s' and '%s'\n", c0->name, c1->name);
+		goto done;
+	}
+
+	/* Grab glue that binds each channel to something using the RTP engine */
+	if (!(glue0 = ast_rtp_instance_get_glue(c0->tech->type)) || !(glue1 = ast_rtp_instance_get_glue(c1->tech->type))) {
+		ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", glue0 ? c1->name : c0->name);
+		goto done;
+	}
+
+	audio_glue0_res = glue0->get_rtp_info(c0, &instance0);
+	video_glue0_res = glue0->get_vrtp_info ? glue0->get_vrtp_info(c0, &vinstance0) : AST_RTP_GLUE_RESULT_FORBID;
+	text_glue0_res = glue0->get_trtp_info ? glue0->get_trtp_info(c0, &tinstance0) : AST_RTP_GLUE_RESULT_FORBID;
+
+	audio_glue1_res = glue1->get_rtp_info(c1, &instance1);
+	video_glue1_res = glue1->get_vrtp_info ? glue1->get_vrtp_info(c1, &vinstance1) : AST_RTP_GLUE_RESULT_FORBID;
+	text_glue1_res = glue1->get_trtp_info ? glue1->get_trtp_info(c1, &tinstance1) : AST_RTP_GLUE_RESULT_FORBID;
+
+	/* If we are carrying video, and both sides are not going to remotely bridge... fail the native bridge */
+	if (video_glue0_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue0_res != AST_RTP_GLUE_RESULT_REMOTE)) {
+		audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
+	}
+	if (video_glue1_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue1_res != AST_RTP_GLUE_RESULT_REMOTE)) {
+		audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
+	}
+
+	/* If any sort of bridge is forbidden just completely bail out and go back to generic bridging */
+	if (audio_glue0_res == AST_RTP_GLUE_RESULT_FORBID || audio_glue1_res == AST_RTP_GLUE_RESULT_FORBID) {
+		res = AST_BRIDGE_FAILED_NOWARN;
+		goto done;
+	}
+
+	/* If we have gotten to a local bridge make sure that both sides have the same local bridge callback and that they are DTMF compatible */
+	if ((audio_glue0_res == AST_RTP_GLUE_RESULT_LOCAL || audio_glue1_res == AST_RTP_GLUE_RESULT_LOCAL) && ((instance0->engine->local_bridge != instance1->engine->local_bridge) || (instance0->engine->dtmf_compatible && !instance0->engine->dtmf_compatible(c0, instance0, c1, instance1)))) {
+		res = AST_BRIDGE_FAILED_NOWARN;
+		goto done;
+	}
+
+	/* Make sure that codecs match */
+	codec0 = glue0->get_codec ? glue0->get_codec(c0) : 0;
+	codec1 = glue1->get_codec ? glue1->get_codec(c1) : 0;
+	if (codec0 && codec1 && !(codec0 & codec1)) {
+		ast_debug(1, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
+		res = AST_BRIDGE_FAILED_NOWARN;
+		goto done;
+	}
+
+	/* Depending on the end result for bridging either do a local bridge or remote bridge */
+	if (audio_glue0_res == AST_RTP_GLUE_RESULT_LOCAL || audio_glue1_res == AST_RTP_GLUE_RESULT_LOCAL) {
+		ast_verbose(VERBOSE_PREFIX_3 "Locally bridging %s and %s\n", c0->name, c1->name);
+		res = local_bridge_loop(c0, c1, instance0, instance1, timeoutms, flags, fo, rc, c0->tech_pvt, c1->tech_pvt);
+	} else {
+		ast_verbose(VERBOSE_PREFIX_3 "Remotely bridging %s and %s\n", c0->name, c1->name);
+		res = remote_bridge_loop(c0, c1, instance0, instance1, vinstance0, vinstance1,
+				tinstance0, tinstance1, glue0, glue1, codec0, codec1, timeoutms, flags,
+				fo, rc, c0->tech_pvt, c1->tech_pvt);
+	}
+
+	unlock_chans = 0;
+
+done:
+	if (unlock_chans) {
+		ast_channel_unlock(c0);
+		ast_channel_unlock(c1);
+	}
+
+	unref_instance_cond(&instance0);
+	unref_instance_cond(&instance1);
+	unref_instance_cond(&vinstance0);
+	unref_instance_cond(&vinstance1);
+	unref_instance_cond(&tinstance0);
+	unref_instance_cond(&tinstance1);
+
+	return res;
+}
+
+struct ast_rtp_instance *ast_rtp_instance_get_bridged(struct ast_rtp_instance *instance)
+{
+	return instance->bridged;
+}
+
+void ast_rtp_instance_early_bridge_make_compatible(struct ast_channel *c0, struct ast_channel *c1)
+{
+	struct ast_rtp_instance *instance0 = NULL, *instance1 = NULL,
+		*vinstance0 = NULL, *vinstance1 = NULL,
+		*tinstance0 = NULL, *tinstance1 = NULL;
+	struct ast_rtp_glue *glue0, *glue1;
+	enum ast_rtp_glue_result audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID, video_glue0_res = AST_RTP_GLUE_RESULT_FORBID, text_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
+	enum ast_rtp_glue_result audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID, video_glue1_res = AST_RTP_GLUE_RESULT_FORBID, text_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
+	int codec0 = 0, codec1 = 0;
+	int res = 0;
+
+	/* Lock both channels so we can look for the glue that binds them together */
+	ast_channel_lock(c0);
+	while (ast_channel_trylock(c1)) {
+		ast_channel_unlock(c0);
+		usleep(1);
+		ast_channel_lock(c0);
+	}
+
+	/* Grab glue that binds each channel to something using the RTP engine */
+	if (!(glue0 = ast_rtp_instance_get_glue(c0->tech->type)) || !(glue1 = ast_rtp_instance_get_glue(c1->tech->type))) {
+		ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", glue0 ? c1->name : c0->name);
+		goto done;
+	}
+
+	audio_glue0_res = glue0->get_rtp_info(c0, &instance0);
+	video_glue0_res = glue0->get_vrtp_info ? glue0->get_vrtp_info(c0, &vinstance0) : AST_RTP_GLUE_RESULT_FORBID;
+	text_glue0_res = glue0->get_trtp_info ? glue0->get_trtp_info(c0, &tinstance0) : AST_RTP_GLUE_RESULT_FORBID;
+
+	audio_glue1_res = glue1->get_rtp_info(c1, &instance1);
+	video_glue1_res = glue1->get_vrtp_info ? glue1->get_vrtp_info(c1, &vinstance1) : AST_RTP_GLUE_RESULT_FORBID;
+	text_glue1_res = glue1->get_trtp_info ? glue1->get_trtp_info(c1, &tinstance1) : AST_RTP_GLUE_RESULT_FORBID;
+
+	/* If we are carrying video, and both sides are not going to remotely bridge... fail the native bridge */
+	if (video_glue0_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue0_res != AST_RTP_GLUE_RESULT_REMOTE)) {
+		audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
+	}
+	if (video_glue1_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue1_res != AST_RTP_GLUE_RESULT_REMOTE)) {
+		audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
+	}
+	if (audio_glue0_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue0_res == AST_RTP_GLUE_RESULT_FORBID || video_glue0_res == AST_RTP_GLUE_RESULT_REMOTE) && glue0->get_codec(c0)) {
+		codec0 = glue0->get_codec(c0);
+	}
+	if (audio_glue1_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue1_res == AST_RTP_GLUE_RESULT_FORBID || video_glue1_res == AST_RTP_GLUE_RESULT_REMOTE) && glue1->get_codec(c1)) {
+		codec1 = glue1->get_codec(c1);
+	}
+
+	/* If any sort of bridge is forbidden just completely bail out and go back to generic bridging */
+	if (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE) {
+		goto done;
+	}
+
+	/* Make sure we have matching codecs */
+	if (!(codec0 & codec1)) {
+		goto done;
+	}
+
+	ast_rtp_codecs_payloads_copy(&instance0->codecs, &instance1->codecs, instance1);
+
+	if (vinstance0 && vinstance1) {
+		ast_rtp_codecs_payloads_copy(&vinstance0->codecs, &vinstance1->codecs, vinstance1);
+	}
+	if (tinstance0 && tinstance1) {
+		ast_rtp_codecs_payloads_copy(&tinstance0->codecs, &tinstance1->codecs, tinstance1);
+	}
+
+	res = 0;
+
+done:
+	ast_channel_unlock(c0);
+	ast_channel_unlock(c1);
+
+	unref_instance_cond(&instance0);
+	unref_instance_cond(&instance1);
+	unref_instance_cond(&vinstance0);
+	unref_instance_cond(&vinstance1);
+	unref_instance_cond(&tinstance0);
+	unref_instance_cond(&tinstance1);
+
+	if (!res) {
+		ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
+	}
+}
+
+int ast_rtp_instance_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
+{
+	struct ast_rtp_instance *instance0 = NULL, *instance1 = NULL,
+			*vinstance0 = NULL, *vinstance1 = NULL,
+			*tinstance0 = NULL, *tinstance1 = NULL;
+	struct ast_rtp_glue *glue0, *glue1;
+	enum ast_rtp_glue_result audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID, video_glue0_res = AST_RTP_GLUE_RESULT_FORBID, text_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
+	enum ast_rtp_glue_result audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID, video_glue1_res = AST_RTP_GLUE_RESULT_FORBID, text_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
+	int codec0 = 0, codec1 = 0;
+	int res = 0;
+
+	/* If there is no second channel just immediately bail out, we are of no use in that scenario */
+	if (!c1) {
+		return -1;
+	}
+
+	/* Lock both channels so we can look for the glue that binds them together */
+	ast_channel_lock(c0);
+	while (ast_channel_trylock(c1)) {
+		ast_channel_unlock(c0);
+		usleep(1);
+		ast_channel_lock(c0);
+	}
+
+	/* Grab glue that binds each channel to something using the RTP engine */
+	if (!(glue0 = ast_rtp_instance_get_glue(c0->tech->type)) || !(glue1 = ast_rtp_instance_get_glue(c1->tech->type))) {
+		ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", glue0 ? c1->name : c0->name);
+		goto done;
+	}
+
+	audio_glue0_res = glue0->get_rtp_info(c0, &instance0);
+	video_glue0_res = glue0->get_vrtp_info ? glue0->get_vrtp_info(c0, &vinstance0) : AST_RTP_GLUE_RESULT_FORBID;
+	text_glue0_res = glue0->get_trtp_info ? glue0->get_trtp_info(c0, &tinstance0) : AST_RTP_GLUE_RESULT_FORBID;
+
+	audio_glue1_res = glue1->get_rtp_info(c1, &instance1);
+	video_glue1_res = glue1->get_vrtp_info ? glue1->get_vrtp_info(c1, &vinstance1) : AST_RTP_GLUE_RESULT_FORBID;
+	text_glue1_res = glue1->get_trtp_info ? glue1->get_trtp_info(c1, &tinstance1) : AST_RTP_GLUE_RESULT_FORBID;
+
+	/* If we are carrying video, and both sides are not going to remotely bridge... fail the native bridge */
+	if (video_glue0_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue0_res != AST_RTP_GLUE_RESULT_REMOTE)) {
+		audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
+	}
+	if (video_glue1_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue1_res != AST_RTP_GLUE_RESULT_REMOTE)) {
+		audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
+	}
+	if (audio_glue0_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue0_res == AST_RTP_GLUE_RESULT_FORBID || video_glue0_res == AST_RTP_GLUE_RESULT_REMOTE) && glue0->get_codec(c0)) {
+		codec0 = glue0->get_codec(c0);
+	}
+	if (audio_glue1_res == AST_RTP_GLUE_RESULT_REMOTE && (video_glue1_res == AST_RTP_GLUE_RESULT_FORBID || video_glue1_res == AST_RTP_GLUE_RESULT_REMOTE) && glue1->get_codec(c1)) {
+		codec1 = glue1->get_codec(c1);
+	}
+
+	/* If any sort of bridge is forbidden just completely bail out and go back to generic bridging */
+	if (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE) {
+		goto done;
+	}
+
+	/* Make sure we have matching codecs */
+	if (!(codec0 & codec1)) {
+		goto done;
+	}
+
+	/* Bridge media early */
+	if (glue0->update_peer(c0, instance1, vinstance1, tinstance1, codec1, 0)) {
+		ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
+	}
+
+	res = 0;
+
+done:
+	ast_channel_unlock(c0);
+	ast_channel_unlock(c1);
+
+	unref_instance_cond(&instance0);
+	unref_instance_cond(&instance1);
+	unref_instance_cond(&vinstance0);
+	unref_instance_cond(&vinstance1);
+	unref_instance_cond(&tinstance0);
+	unref_instance_cond(&tinstance1);
+
+	if (!res) {
+		ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
+	}
+
+	return res;
+}
+
+int ast_rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
+{
+	return instance->engine->red_init ? instance->engine->red_init(instance, buffer_time, payloads, generations) : -1;
+}
+
+int ast_rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
+{
+	return instance->engine->red_buffer ? instance->engine->red_buffer(instance, frame) : -1;
+}
+
+int ast_rtp_instance_get_stats(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
+{
+	return instance->engine->get_stat ? instance->engine->get_stat(instance, stats, stat) : -1;
+}
+
+char *ast_rtp_instance_get_quality(struct ast_rtp_instance *instance, enum ast_rtp_instance_stat_field field, char *buf, size_t size)
+{
+	struct ast_rtp_instance_stats stats;
+	enum ast_rtp_instance_stat stat;
+
+	/* Determine what statistics we will need to retrieve based on field passed in */
+	if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY) {
+		stat = AST_RTP_INSTANCE_STAT_ALL;
+	} else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER) {
+		stat = AST_RTP_INSTANCE_STAT_COMBINED_JITTER;
+	} else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS) {
+		stat = AST_RTP_INSTANCE_STAT_COMBINED_LOSS;
+	} else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT) {
+		stat = AST_RTP_INSTANCE_STAT_COMBINED_RTT;
+	} else {
+		return NULL;
+	}
+
+	/* Attempt to actually retrieve the statistics we need to generate the quality string */
+	if (ast_rtp_instance_get_stats(instance, &stats, stat)) {
+		return NULL;
+	}
+
+	/* Now actually fill the buffer with the good information */
+	if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY) {
+		snprintf(buf, size, "ssrc=%i;themssrc=%u;lp=%u;rxjitter=%u;rxcount=%u;txjitter=%u;txcount=%u;rlp=%u;rtt=%u",
+			 stats.local_ssrc, stats.remote_ssrc, stats.rxploss, stats.txjitter, stats.rxcount, stats.rxjitter, stats.txcount, stats.txploss, stats.rtt);
+	} else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER) {
+		snprintf(buf, size, "minrxjitter=%f;maxrxjitter=%f;avgrxjitter=%f;stdevrxjitter=%f;reported_minjitter=%f;reported_maxjitter=%f;reported_avgjitter=%f;reported_stdevjitter=%f;",
+			 stats.local_minjitter, stats.local_maxjitter, stats.local_normdevjitter, sqrt(stats.local_stdevjitter), stats.remote_minjitter, stats.remote_maxjitter, stats.remote_normdevjitter, sqrt(stats.remote_stdevjitter));
+	} else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS) {
+		snprintf(buf, size, "minrxlost=%f;maxrxlost=%f;avgrxlost=%f;stdevrxlost=%f;reported_minlost=%f;reported_maxlost=%f;reported_avglost=%f;reported_stdevlost=%f;",
+			 stats.local_minrxploss, stats.local_maxrxploss, stats.local_normdevrxploss, sqrt(stats.local_stdevrxploss), stats.remote_minrxploss, stats.remote_maxrxploss, stats.remote_normdevrxploss, sqrt(stats.remote_stdevrxploss));
+	} else if (field == AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT) {
+		snprintf(buf, size, "minrtt=%f;maxrtt=%f;avgrtt=%f;stdevrtt=%f;", stats.minrtt, stats.maxrtt, stats.normdevrtt, stats.stdevrtt);
+	}
+
+	return buf;
+}
+
+void ast_rtp_instance_set_stats_vars(struct ast_channel *chan, struct ast_rtp_instance *instance)
+{
+	char quality_buf[AST_MAX_USER_FIELD], *quality;
+	struct ast_channel *bridge = ast_bridged_channel(chan);
+
+	if ((quality = ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, quality_buf, sizeof(quality_buf)))) {
+		pbx_builtin_setvar_helper(chan, "RTPAUDIOQOS", quality);
+		if (bridge) {
+			pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSBRIDGED", quality);
+		}
+	}
+
+	if ((quality = ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER, quality_buf, sizeof(quality_buf)))) {
+		pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSJITTER", quality);
+		if (bridge) {
+			pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSJITTERBRIDGED", quality);
+		}
+	}
+
+	if ((quality = ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS, quality_buf, sizeof(quality_buf)))) {
+		pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSLOSS", quality);
+		if (bridge) {
+			pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSLOSSBRIDGED", quality);
+		}
+	}
+
+	if ((quality = ast_rtp_instance_get_quality(instance, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT, quality_buf, sizeof(quality_buf)))) {
+		pbx_builtin_setvar_helper(chan, "RTPAUDIOQOSRTT", quality);
+		if (bridge) {
+			pbx_builtin_setvar_helper(bridge, "RTPAUDIOQOSRTTBRIDGED", quality);
+		}
+	}
+}
+
+int ast_rtp_instance_set_read_format(struct ast_rtp_instance *instance, int format)
+{
+	return instance->engine->set_read_format ? instance->engine->set_read_format(instance, format) : -1;
+}
+
+int ast_rtp_instance_set_write_format(struct ast_rtp_instance *instance, int format)
+{
+	return instance->engine->set_write_format ? instance->engine->set_write_format(instance, format) : -1;
+}
+
+int ast_rtp_instance_make_compatible(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_channel *peer)
+{
+	struct ast_rtp_glue *glue;
+	struct ast_rtp_instance *peer_instance = NULL;
+	int res = -1;
+
+	if (!instance->engine->make_compatible) {
+		return -1;
+	}
+
+	ast_channel_lock(peer);
+
+	if (!(glue = ast_rtp_instance_get_glue(peer->tech->type))) {
+		ast_channel_unlock(peer);
+		return -1;
+	}
+
+	glue->get_rtp_info(peer, &peer_instance);
+
+	if (!peer_instance || peer_instance->engine != instance->engine) {
+		ast_channel_unlock(peer);
+		peer_instance = (ao2_ref(peer_instance, -1), NULL);
+		return -1;
+	}
+
+	res = instance->engine->make_compatible(chan, instance, peer, peer_instance);
+
+	ast_channel_unlock(peer);
+
+	peer_instance = (ao2_ref(peer_instance, -1), NULL);
+
+	return res;
+}
+
+int ast_rtp_instance_activate(struct ast_rtp_instance *instance)
+{
+	return instance->engine->activate ? instance->engine->activate(instance) : 0;
+}
+
+void ast_rtp_instance_stun_request(struct ast_rtp_instance *instance, struct sockaddr_in *suggestion, const char *username)
+{
+	if (instance->engine->stun_request) {
+		instance->engine->stun_request(instance, suggestion, username);
+	}
+}
+
+void ast_rtp_instance_set_timeout(struct ast_rtp_instance *instance, int timeout)
+{
+	instance->timeout = timeout;
+}
+
+void ast_rtp_instance_set_hold_timeout(struct ast_rtp_instance *instance, int timeout)
+{
+	instance->holdtimeout = timeout;
+}
+
+int ast_rtp_instance_get_timeout(struct ast_rtp_instance *instance)
+{
+	return instance->timeout;
+}
+
+int ast_rtp_instance_get_hold_timeout(struct ast_rtp_instance *instance)
+{
+	return instance->holdtimeout;
+}
diff --git a/main/stun.c b/main/stun.c
new file mode 100644
index 000000000..264430718
--- /dev/null
+++ b/main/stun.c
@@ -0,0 +1,475 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 1999 - 2008, Digium, Inc.
+ *
+ * Mark Spencer <markster@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ *
+ * \brief STUN Support
+ *
+ * \author Mark Spencer <markster@digium.com>
+ *
+ * \note STUN is defined in RFC 3489.
+ */
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision: 124370 $")
+
+#include "asterisk/_private.h"
+#include "asterisk/stun.h"
+#include "asterisk/cli.h"
+#include "asterisk/utils.h"
+#include "asterisk/channel.h"
+
+static int stundebug;			/*!< Are we debugging stun? */
+
+/*!
+ * \brief STUN support code
+ *
+ * This code provides some support for doing STUN transactions.
+ * Eventually it should be moved elsewhere as other protocols
+ * than RTP can benefit from it - e.g. SIP.
+ * STUN is described in RFC3489 and it is based on the exchange
+ * of UDP packets between a client and one or more servers to
+ * determine the externally visible address (and port) of the client
+ * once it has gone through the NAT boxes that connect it to the
+ * outside.
+ * The simplest request packet is just the header defined in
+ * struct stun_header, and from the response we may just look at
+ * one attribute, STUN_MAPPED_ADDRESS, that we find in the response.
+ * By doing more transactions with different server addresses we
+ * may determine more about the behaviour of the NAT boxes, of
+ * course - the details are in the RFC.
+ *
+ * All STUN packets start with a simple header made of a type,
+ * length (excluding the header) and a 16-byte random transaction id.
+ * Following the header we may have zero or more attributes, each
+ * structured as a type, length and a value (whose format depends
+ * on the type, but often contains addresses).
+ * Of course all fields are in network format.
+ */
+
+typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
+
+struct stun_header {
+	unsigned short msgtype;
+	unsigned short msglen;
+	stun_trans_id  id;
+	unsigned char ies[0];
+} __attribute__((packed));
+
+struct stun_attr {
+	unsigned short attr;
+	unsigned short len;
+	unsigned char value[0];
+} __attribute__((packed));
+
+/*
+ * The format normally used for addresses carried by STUN messages.
+ */
+struct stun_addr {
+	unsigned char unused;
+	unsigned char family;
+	unsigned short port;
+	unsigned int addr;
+} __attribute__((packed));
+
+/*! \brief STUN message types
+ * 'BIND' refers to transactions used to determine the externally
+ * visible addresses. 'SEC' refers to transactions used to establish
+ * a session key for subsequent requests.
+ * 'SEC' functionality is not supported here.
+ */
+
+#define STUN_BINDREQ	0x0001
+#define STUN_BINDRESP	0x0101
+#define STUN_BINDERR	0x0111
+#define STUN_SECREQ	0x0002
+#define STUN_SECRESP	0x0102
+#define STUN_SECERR	0x0112
+
+/*! \brief Basic attribute types in stun messages.
+ * Messages can also contain custom attributes (codes above 0x7fff)
+ */
+#define STUN_MAPPED_ADDRESS	0x0001
+#define STUN_RESPONSE_ADDRESS	0x0002
+#define STUN_CHANGE_REQUEST	0x0003
+#define STUN_SOURCE_ADDRESS	0x0004
+#define STUN_CHANGED_ADDRESS	0x0005
+#define STUN_USERNAME		0x0006
+#define STUN_PASSWORD		0x0007
+#define STUN_MESSAGE_INTEGRITY	0x0008
+#define STUN_ERROR_CODE		0x0009
+#define STUN_UNKNOWN_ATTRIBUTES	0x000a
+#define STUN_REFLECTED_FROM	0x000b
+
+/*! \brief helper function to print message names */
+static const char *stun_msg2str(int msg)
+{
+	switch (msg) {
+	case STUN_BINDREQ:
+		return "Binding Request";
+	case STUN_BINDRESP:
+		return "Binding Response";
+	case STUN_BINDERR:
+		return "Binding Error Response";
+	case STUN_SECREQ:
+		return "Shared Secret Request";
+	case STUN_SECRESP:
+		return "Shared Secret Response";
+	case STUN_SECERR:
+		return "Shared Secret Error Response";
+	}
+	return "Non-RFC3489 Message";
+}
+
+/*! \brief helper function to print attribute names */
+static const char *stun_attr2str(int msg)
+{
+	switch (msg) {
+	case STUN_MAPPED_ADDRESS:
+		return "Mapped Address";
+	case STUN_RESPONSE_ADDRESS:
+		return "Response Address";
+	case STUN_CHANGE_REQUEST:
+		return "Change Request";
+	case STUN_SOURCE_ADDRESS:
+		return "Source Address";
+	case STUN_CHANGED_ADDRESS:
+		return "Changed Address";
+	case STUN_USERNAME:
+		return "Username";
+	case STUN_PASSWORD:
+		return "Password";
+	case STUN_MESSAGE_INTEGRITY:
+		return "Message Integrity";
+	case STUN_ERROR_CODE:
+		return "Error Code";
+	case STUN_UNKNOWN_ATTRIBUTES:
+		return "Unknown Attributes";
+	case STUN_REFLECTED_FROM:
+		return "Reflected From";
+	}
+	return "Non-RFC3489 Attribute";
+}
+
+/*! \brief here we store credentials extracted from a message */
+struct stun_state {
+	const char *username;
+	const char *password;
+};
+
+static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
+{
+	if (stundebug)
+		ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
+			    stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
+	switch (ntohs(attr->attr)) {
+	case STUN_USERNAME:
+		state->username = (const char *) (attr->value);
+		break;
+	case STUN_PASSWORD:
+		state->password = (const char *) (attr->value);
+		break;
+	default:
+		if (stundebug)
+			ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n",
+				    stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
+	}
+	return 0;
+}
+
+/*! \brief append a string to an STUN message */
+static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
+{
+	int size = sizeof(**attr) + strlen(s);
+	if (*left > size) {
+		(*attr)->attr = htons(attrval);
+		(*attr)->len = htons(strlen(s));
+		memcpy((*attr)->value, s, strlen(s));
+		(*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
+		*len += size;
+		*left -= size;
+	}
+}
+
+/*! \brief append an address to an STUN message */
+static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
+{
+	int size = sizeof(**attr) + 8;
+	struct stun_addr *addr;
+	if (*left > size) {
+		(*attr)->attr = htons(attrval);
+		(*attr)->len = htons(8);
+		addr = (struct stun_addr *)((*attr)->value);
+		addr->unused = 0;
+		addr->family = 0x01;
+		addr->port = sin->sin_port;
+		addr->addr = sin->sin_addr.s_addr;
+		(*attr) = (struct stun_attr *)((*attr)->value + 8);
+		*len += size;
+		*left -= size;
+	}
+}
+
+/*! \brief wrapper to send an STUN message */
+static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
+{
+	return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
+		      (struct sockaddr *)dst, sizeof(*dst));
+}
+
+/*! \brief helper function to generate a random request id */
+static void stun_req_id(struct stun_header *req)
+{
+	int x;
+	for (x = 0; x < 4; x++)
+		req->id.id[x] = ast_random();
+}
+
+/*! \brief handle an incoming STUN message.
+ *
+ * Do some basic sanity checks on packet size and content,
+ * try to extract a bit of information, and possibly reply.
+ * At the moment this only processes BIND requests, and returns
+ * the externally visible address of the request.
+ * If a callback is specified, invoke it with the attribute.
+ */
+int ast_stun_handle_packet(int s, struct sockaddr_in *src, unsigned char *data, size_t len, stun_cb_f *stun_cb, void *arg)
+{
+	struct stun_header *hdr = (struct stun_header *)data;
+	struct stun_attr *attr;
+	struct stun_state st;
+	int ret = AST_STUN_IGNORE;
+	int x;
+
+	/* On entry, 'len' is the length of the udp payload. After the
+	 * initial checks it becomes the size of unprocessed options,
+	 * while 'data' is advanced accordingly.
+	 */
+	if (len < sizeof(struct stun_header)) {
+		ast_debug(1, "Runt STUN packet (only %d, wanting at least %d)\n", (int) len, (int) sizeof(struct stun_header));
+		return -1;
+	}
+	len -= sizeof(struct stun_header);
+	data += sizeof(struct stun_header);
+	x = ntohs(hdr->msglen);	/* len as advertised in the message */
+	if (stundebug)
+		ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), x);
+	if (x > len) {
+		ast_debug(1, "Scrambled STUN packet length (got %d, expecting %d)\n", x, (int)len);
+	} else
+		len = x;
+	memset(&st, 0, sizeof(st));
+	while (len) {
+		if (len < sizeof(struct stun_attr)) {
+			ast_debug(1, "Runt Attribute (got %d, expecting %d)\n", (int)len, (int) sizeof(struct stun_attr));
+			break;
+		}
+		attr = (struct stun_attr *)data;
+		/* compute total attribute length */
+		x = ntohs(attr->len) + sizeof(struct stun_attr);
+		if (x > len) {
+			ast_debug(1, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", x, (int)len);
+			break;
+		}
+		if (stun_cb)
+			stun_cb(attr, arg);
+		if (stun_process_attr(&st, attr)) {
+			ast_debug(1, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
+			break;
+		}
+		/* Clear attribute id: in case previous entry was a string,
+		 * this will act as the terminator for the string.
+		 */
+		attr->attr = 0;
+		data += x;
+		len -= x;
+	}
+	/* Null terminate any string.
+	 * XXX NOTE, we write past the size of the buffer passed by the
+	 * caller, so this is potentially dangerous. The only thing that
+	 * saves us is that usually we read the incoming message in a
+	 * much larger buffer in the struct ast_rtp
+	 */
+	*data = '\0';
+
+	/* Now prepare to generate a reply, which at the moment is done
+	 * only for properly formed (len == 0) STUN_BINDREQ messages.
+	 */
+	if (len == 0) {
+		unsigned char respdata[1024];
+		struct stun_header *resp = (struct stun_header *)respdata;
+		int resplen = 0;	/* len excluding header */
+		int respleft = sizeof(respdata) - sizeof(struct stun_header);
+
+		resp->id = hdr->id;
+		resp->msgtype = 0;
+		resp->msglen = 0;
+		attr = (struct stun_attr *)resp->ies;
+		switch (ntohs(hdr->msgtype)) {
+		case STUN_BINDREQ:
+			if (stundebug)
+				ast_verbose("STUN Bind Request, username: %s\n",
+					    st.username ? st.username : "<none>");
+			if (st.username)
+				append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
+			append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
+			resp->msglen = htons(resplen);
+			resp->msgtype = htons(STUN_BINDRESP);
+			stun_send(s, src, resp);
+			ret = AST_STUN_ACCEPT;
+			break;
+		default:
+			if (stundebug)
+				ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
+		}
+	}
+	return ret;
+}
+
+/*! \brief Extract the STUN_MAPPED_ADDRESS from the stun response.
+ * This is used as a callback for stun_handle_response
+ * when called from ast_stun_request.
+ */
+static int stun_get_mapped(struct stun_attr *attr, void *arg)
+{
+	struct stun_addr *addr = (struct stun_addr *)(attr + 1);
+	struct sockaddr_in *sa = (struct sockaddr_in *)arg;
+
+	if (ntohs(attr->attr) != STUN_MAPPED_ADDRESS || ntohs(attr->len) != 8)
+		return 1;	/* not us. */
+	sa->sin_port = addr->port;
+	sa->sin_addr.s_addr = addr->addr;
+	return 0;
+}
+
+/*! \brief Generic STUN request
+ * Send a generic stun request to the server specified,
+ * possibly waiting for a reply and filling the 'reply' field with
+ * the externally visible address. Note that in this case the request
+ * will be blocking.
+ * (Note, the interface may change slightly in the future).
+ *
+ * \param s the socket used to send the request
+ * \param dst the address of the STUN server
+ * \param username if non null, add the username in the request
+ * \param answer if non null, the function waits for a response and
+ *    puts here the externally visible address.
+ * \return 0 on success, other values on error.
+ */
+int ast_stun_request(int s, struct sockaddr_in *dst,
+	const char *username, struct sockaddr_in *answer)
+{
+	struct stun_header *req;
+	unsigned char reqdata[1024];
+	int reqlen, reqleft;
+	struct stun_attr *attr;
+	int res = 0;
+	int retry;
+
+	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);
+	for (retry = 0; retry < 3; retry++) {	/* XXX make retries configurable */
+		/* send request, possibly wait for reply */
+		unsigned char reply_buf[1024];
+		fd_set rfds;
+		struct timeval to = { 3, 0 };	/* timeout, make it configurable */
+		struct sockaddr_in src;
+		socklen_t srclen;
+
+		res = stun_send(s, dst, req);
+		if (res < 0) {
+			ast_log(LOG_WARNING, "ast_stun_request send #%d failed error %d, retry\n",
+				retry, res);
+			continue;
+		}
+		if (answer == NULL)
+			break;
+		FD_ZERO(&rfds);
+		FD_SET(s, &rfds);
+		res = ast_select(s + 1, &rfds, NULL, NULL, &to);
+		if (res <= 0)	/* timeout or error */
+			continue;
+		memset(&src, 0, sizeof(src));
+		srclen = sizeof(src);
+		/* XXX pass -1 in the size, because stun_handle_packet might
+		 * write past the end of the buffer.
+		 */
+		res = recvfrom(s, reply_buf, sizeof(reply_buf) - 1,
+			0, (struct sockaddr *)&src, &srclen);
+		if (res < 0) {
+			ast_log(LOG_WARNING, "ast_stun_request recvfrom #%d failed error %d, retry\n",
+				retry, res);
+			continue;
+		}
+		memset(answer, 0, sizeof(struct sockaddr_in));
+		ast_stun_handle_packet(s, &src, reply_buf, res,
+			stun_get_mapped, answer);
+		res = 0; /* signal regular exit */
+		break;
+	}
+	return res;
+}
+
+static char *handle_cli_stun_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "stun set debug {on|off}";
+		e->usage =
+			"Usage: stun set debug {on|off}\n"
+			"       Enable/Disable STUN (Simple Traversal of UDP through NATs)\n"
+			"       debugging\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != e->args)
+		return CLI_SHOWUSAGE;
+
+	if (!strncasecmp(a->argv[e->args-1], "on", 2))
+		stundebug = 1;
+	else if (!strncasecmp(a->argv[e->args-1], "off", 3))
+		stundebug = 0;
+	else
+		return CLI_SHOWUSAGE;
+
+	ast_cli(a->fd, "STUN Debugging %s\n", stundebug ? "Enabled" : "Disabled");
+	return CLI_SUCCESS;
+}
+
+static struct ast_cli_entry cli_stun[] = {
+	AST_CLI_DEFINE(handle_cli_stun_set_debug, "Enable/Disable STUN debugging"),
+};
+
+/*! \brief Initialize the STUN system in Asterisk */
+void ast_stun_init(void)
+{
+	ast_cli_register_multiple(cli_stun, sizeof(cli_stun) / sizeof(struct ast_cli_entry));
+}