Drop the RTCP Read too short message to debug. There are some phones out there that...
[asterisk/asterisk.git] / main / rtp.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! 
20  * \file 
21  *
22  * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
23  *
24  * \author Mark Spencer <markster@digium.com>
25  * 
26  * \note RTP is defined in RFC 3550.
27  */
28
29 #include "asterisk.h"
30
31 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <sys/time.h>
37 #include <signal.h>
38 #include <errno.h>
39 #include <unistd.h>
40 #include <netinet/in.h>
41 #include <sys/time.h>
42 #include <sys/socket.h>
43 #include <arpa/inet.h>
44 #include <fcntl.h>
45
46 #include "asterisk/rtp.h"
47 #include "asterisk/frame.h"
48 #include "asterisk/logger.h"
49 #include "asterisk/options.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/acl.h"
52 #include "asterisk/channel.h"
53 #include "asterisk/config.h"
54 #include "asterisk/lock.h"
55 #include "asterisk/utils.h"
56 #include "asterisk/netsock.h"
57 #include "asterisk/cli.h"
58 #include "asterisk/manager.h"
59 #include "asterisk/unaligned.h"
60 #include "asterisk/utils.h"
61
62 #define MAX_TIMESTAMP_SKEW      640
63
64 #define RTP_SEQ_MOD     (1<<16)         /*!< A sequence number can't be more than 16 bits */
65 #define RTCP_DEFAULT_INTERVALMS   5000  /*!< Default milli-seconds between RTCP reports we send */
66 #define RTCP_MIN_INTERVALMS       500   /*!< Min milli-seconds between RTCP reports we send */
67 #define RTCP_MAX_INTERVALMS       60000 /*!< Max milli-seconds between RTCP reports we send */
68
69 #define RTCP_PT_FUR     192
70 #define RTCP_PT_SR      200
71 #define RTCP_PT_RR      201
72 #define RTCP_PT_SDES    202
73 #define RTCP_PT_BYE     203
74 #define RTCP_PT_APP     204
75
76 #define RTP_MTU         1200
77
78 #define DEFAULT_DTMF_TIMEOUT 3000       /*!< samples */
79
80 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
81
82 static int rtpstart;                    /*!< First port for RTP sessions (set in rtp.conf) */
83 static int rtpend;                      /*!< Last port for RTP sessions (set in rtp.conf) */
84 static int rtpdebug;                    /*!< Are we debugging? */
85 static int rtcpdebug;                   /*!< Are we debugging RTCP? */
86 static int rtcpstats;                   /*!< Are we debugging RTCP? */
87 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
88 static int stundebug;                   /*!< Are we debugging stun? */
89 static struct sockaddr_in rtpdebugaddr; /*!< Debug packets to/from this host */
90 static struct sockaddr_in rtcpdebugaddr;        /*!< Debug RTCP packets to/from this host */
91 #ifdef SO_NO_CHECK
92 static int nochecksums;
93 #endif
94
95 /* Uncomment this to enable more intense native bridging, but note: this is currently buggy */
96 /* #define P2P_INTENSE */
97
98 /*!
99  * \brief Structure representing a RTP session.
100  *
101  * 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 [...]"
102  *
103  */
104 /*! \brief The value of each payload format mapping: */
105 struct rtpPayloadType {
106         int isAstFormat;        /*!< whether the following code is an AST_FORMAT */
107         int code;
108 };
109
110
111 /*! \brief RTP session description */
112 struct ast_rtp {
113         int s;
114         struct ast_frame f;
115         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
116         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
117         unsigned int themssrc;          /*!< Their SSRC */
118         unsigned int rxssrc;
119         unsigned int lastts;
120         unsigned int lastrxts;
121         unsigned int lastividtimestamp;
122         unsigned int lastovidtimestamp;
123         unsigned int lastitexttimestamp;
124         unsigned int lastotexttimestamp;
125         unsigned int lasteventseqn;
126         int lastrxseqno;                /*!< Last received sequence number */
127         unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
128         unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
129         unsigned int rxcount;           /*!< How many packets have we received? */
130         unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
131         unsigned int txcount;           /*!< How many packets have we sent? */
132         unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
133         unsigned int cycles;            /*!< Shifted count of sequence number cycles */
134         double rxjitter;                /*!< Interarrival jitter at the moment */
135         double rxtransit;               /*!< Relative transit time for previous packet */
136         int lasttxformat;
137         int lastrxformat;
138
139         int rtptimeout;                 /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
140         int rtpholdtimeout;             /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
141         int rtpkeepalive;               /*!< Send RTP comfort noice packets for keepalive */
142
143         /* DTMF Reception Variables */
144         char resp;
145         unsigned int lastevent;
146         int dtmfcount;
147         unsigned int dtmfsamples;
148         /* DTMF Transmission Variables */
149         unsigned int lastdigitts;
150         char sending_digit;     /*!< boolean - are we sending digits */
151         char send_digit;        /*!< digit we are sending */
152         int send_payload;
153         int send_duration;
154         int nat;
155         unsigned int flags;
156         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
157         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
158         struct timeval rxcore;
159         struct timeval txcore;
160         double drxcore;                 /*!< The double representation of the first received packet */
161         struct timeval lastrx;          /*!< timeval when we last received a packet */
162         struct timeval dtmfmute;
163         struct ast_smoother *smoother;
164         int *ioid;
165         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
166         unsigned short rxseqno;
167         struct sched_context *sched;
168         struct io_context *io;
169         void *data;
170         ast_rtp_callback callback;
171 #ifdef P2P_INTENSE
172         ast_mutex_t bridge_lock;
173 #endif
174         struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
175         int rtp_lookup_code_cache_isAstFormat; /*!< a cache for the result of rtp_lookup_code(): */
176         int rtp_lookup_code_cache_code;
177         int rtp_lookup_code_cache_result;
178         struct ast_rtcp *rtcp;
179         struct ast_codec_pref pref;
180         struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
181 };
182
183 /* Forward declarations */
184 static int ast_rtcp_write(const void *data);
185 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw);
186 static int ast_rtcp_write_sr(const void *data);
187 static int ast_rtcp_write_rr(const void *data);
188 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp);
189 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp);
190 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit);
191
192 #define FLAG_3389_WARNING               (1 << 0)
193 #define FLAG_NAT_ACTIVE                 (3 << 1)
194 #define FLAG_NAT_INACTIVE               (0 << 1)
195 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
196 #define FLAG_HAS_DTMF                   (1 << 3)
197 #define FLAG_P2P_SENT_MARK              (1 << 4)
198 #define FLAG_P2P_NEED_DTMF              (1 << 5)
199 #define FLAG_CALLBACK_MODE              (1 << 6)
200 #define FLAG_DTMF_COMPENSATE            (1 << 7)
201 #define FLAG_HAS_STUN                   (1 << 8)
202
203 /*!
204  * \brief Structure defining an RTCP session.
205  * 
206  * The concept "RTCP session" is not defined in RFC 3550, but since 
207  * this structure is analogous to ast_rtp, which tracks a RTP session, 
208  * it is logical to think of this as a RTCP session.
209  *
210  * RTCP packet is defined on page 9 of RFC 3550.
211  * 
212  */
213 struct ast_rtcp {
214         int s;                          /*!< Socket */
215         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
216         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
217         unsigned int soc;               /*!< What they told us */
218         unsigned int spc;               /*!< What they told us */
219         unsigned int themrxlsr;         /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
220         struct timeval rxlsr;           /*!< Time when we got their last SR */
221         struct timeval txlsr;           /*!< Time when we sent or last SR*/
222         unsigned int expected_prior;    /*!< no. packets in previous interval */
223         unsigned int received_prior;    /*!< no. packets received in previous interval */
224         int schedid;                    /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
225         unsigned int rr_count;          /*!< number of RRs we've sent, not including report blocks in SR's */
226         unsigned int sr_count;          /*!< number of SRs we've sent */
227         unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
228         double accumulated_transit;     /*!< accumulated a-dlsr-lsr */
229         double rtt;                     /*!< Last reported rtt */
230         unsigned int reported_jitter;   /*!< The contents of their last jitter entry in the RR */
231         unsigned int reported_lost;     /*!< Reported lost packets in their RR */
232         char quality[AST_MAX_USER_FIELD];
233         double maxrxjitter;
234         double minrxjitter;
235         double maxrtt;
236         double minrtt;
237         int sendfur;
238 };
239
240 /*!
241  * \brief STUN support code
242  *
243  * This code provides some support for doing STUN transactions.
244  * Eventually it should be moved elsewhere as other protocols
245  * than RTP can benefit from it - e.g. SIP.
246  * STUN is described in RFC3489 and it is based on the exchange
247  * of UDP packets between a client and one or more servers to
248  * determine the externally visible address (and port) of the client
249  * once it has gone through the NAT boxes that connect it to the
250  * outside.
251  * The simplest request packet is just the header defined in
252  * struct stun_header, and from the response we may just look at
253  * one attribute, STUN_MAPPED_ADDRESS, that we find in the response.
254  * By doing more transactions with different server addresses we
255  * may determine more about the behaviour of the NAT boxes, of
256  * course - the details are in the RFC.
257  *
258  * All STUN packets start with a simple header made of a type,
259  * length (excluding the header) and a 16-byte random transaction id.
260  * Following the header we may have zero or more attributes, each
261  * structured as a type, length and a value (whose format depends
262  * on the type, but often contains addresses).
263  * Of course all fields are in network format.
264  */
265
266 typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
267
268 struct stun_header {
269         unsigned short msgtype;
270         unsigned short msglen;
271         stun_trans_id  id;
272         unsigned char ies[0];
273 } __attribute__((packed));
274
275 struct stun_attr {
276         unsigned short attr;
277         unsigned short len;
278         unsigned char value[0];
279 } __attribute__((packed));
280
281 /*
282  * The format normally used for addresses carried by STUN messages.
283  */
284 struct stun_addr {
285         unsigned char unused;
286         unsigned char family;
287         unsigned short port;
288         unsigned int addr;
289 } __attribute__((packed));
290
291 #define STUN_IGNORE             (0)
292 #define STUN_ACCEPT             (1)
293
294 /*! \brief STUN message types
295  * 'BIND' refers to transactions used to determine the externally
296  * visible addresses. 'SEC' refers to transactions used to establish
297  * a session key for subsequent requests.
298  * 'SEC' functionality is not supported here.
299  */
300  
301 #define STUN_BINDREQ    0x0001
302 #define STUN_BINDRESP   0x0101
303 #define STUN_BINDERR    0x0111
304 #define STUN_SECREQ     0x0002
305 #define STUN_SECRESP    0x0102
306 #define STUN_SECERR     0x0112
307
308 /*! \brief Basic attribute types in stun messages.
309  * Messages can also contain custom attributes (codes above 0x7fff)
310  */
311 #define STUN_MAPPED_ADDRESS     0x0001
312 #define STUN_RESPONSE_ADDRESS   0x0002
313 #define STUN_CHANGE_REQUEST     0x0003
314 #define STUN_SOURCE_ADDRESS     0x0004
315 #define STUN_CHANGED_ADDRESS    0x0005
316 #define STUN_USERNAME           0x0006
317 #define STUN_PASSWORD           0x0007
318 #define STUN_MESSAGE_INTEGRITY  0x0008
319 #define STUN_ERROR_CODE         0x0009
320 #define STUN_UNKNOWN_ATTRIBUTES 0x000a
321 #define STUN_REFLECTED_FROM     0x000b
322
323 /*! \brief helper function to print message names */
324 static const char *stun_msg2str(int msg)
325 {
326         switch (msg) {
327         case STUN_BINDREQ:
328                 return "Binding Request";
329         case STUN_BINDRESP:
330                 return "Binding Response";
331         case STUN_BINDERR:
332                 return "Binding Error Response";
333         case STUN_SECREQ:
334                 return "Shared Secret Request";
335         case STUN_SECRESP:
336                 return "Shared Secret Response";
337         case STUN_SECERR:
338                 return "Shared Secret Error Response";
339         }
340         return "Non-RFC3489 Message";
341 }
342
343 /*! \brief helper function to print attribute names */
344 static const char *stun_attr2str(int msg)
345 {
346         switch (msg) {
347         case STUN_MAPPED_ADDRESS:
348                 return "Mapped Address";
349         case STUN_RESPONSE_ADDRESS:
350                 return "Response Address";
351         case STUN_CHANGE_REQUEST:
352                 return "Change Request";
353         case STUN_SOURCE_ADDRESS:
354                 return "Source Address";
355         case STUN_CHANGED_ADDRESS:
356                 return "Changed Address";
357         case STUN_USERNAME:
358                 return "Username";
359         case STUN_PASSWORD:
360                 return "Password";
361         case STUN_MESSAGE_INTEGRITY:
362                 return "Message Integrity";
363         case STUN_ERROR_CODE:
364                 return "Error Code";
365         case STUN_UNKNOWN_ATTRIBUTES:
366                 return "Unknown Attributes";
367         case STUN_REFLECTED_FROM:
368                 return "Reflected From";
369         }
370         return "Non-RFC3489 Attribute";
371 }
372
373 /*! \brief here we store credentials extracted from a message */
374 struct stun_state {
375         const char *username;
376         const char *password;
377 };
378
379 static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
380 {
381         if (stundebug)
382                 ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
383                             stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
384         switch (ntohs(attr->attr)) {
385         case STUN_USERNAME:
386                 state->username = (const char *) (attr->value);
387                 break;
388         case STUN_PASSWORD:
389                 state->password = (const char *) (attr->value);
390                 break;
391         default:
392                 if (stundebug)
393                         ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n", 
394                                     stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
395         }
396         return 0;
397 }
398
399 /*! \brief append a string to an STUN message */
400 static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
401 {
402         int size = sizeof(**attr) + strlen(s);
403         if (*left > size) {
404                 (*attr)->attr = htons(attrval);
405                 (*attr)->len = htons(strlen(s));
406                 memcpy((*attr)->value, s, strlen(s));
407                 (*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
408                 *len += size;
409                 *left -= size;
410         }
411 }
412
413 /*! \brief append an address to an STUN message */
414 static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
415 {
416         int size = sizeof(**attr) + 8;
417         struct stun_addr *addr;
418         if (*left > size) {
419                 (*attr)->attr = htons(attrval);
420                 (*attr)->len = htons(8);
421                 addr = (struct stun_addr *)((*attr)->value);
422                 addr->unused = 0;
423                 addr->family = 0x01;
424                 addr->port = sin->sin_port;
425                 addr->addr = sin->sin_addr.s_addr;
426                 (*attr) = (struct stun_attr *)((*attr)->value + 8);
427                 *len += size;
428                 *left -= size;
429         }
430 }
431
432 /*! \brief wrapper to send an STUN message */
433 static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
434 {
435         return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
436                       (struct sockaddr *)dst, sizeof(*dst));
437 }
438
439 /*! \brief helper function to generate a random request id */
440 static void stun_req_id(struct stun_header *req)
441 {
442         int x;
443         for (x = 0; x < 4; x++)
444                 req->id.id[x] = ast_random();
445 }
446
447 size_t ast_rtp_alloc_size(void)
448 {
449         return sizeof(struct ast_rtp);
450 }
451
452 /*! \brief callback type to be invoked on stun responses. */
453 typedef int (stun_cb_f)(struct stun_attr *attr, void *arg);
454
455 /*! \brief handle an incoming STUN message.
456  *
457  * Do some basic sanity checks on packet size and content,
458  * try to extract a bit of information, and possibly reply.
459  * At the moment this only processes BIND requests, and returns
460  * the externally visible address of the request.
461  * If a callback is specified, invoke it with the attribute.
462  */
463 static int stun_handle_packet(int s, struct sockaddr_in *src,
464         unsigned char *data, size_t len, stun_cb_f *stun_cb, void *arg)
465 {
466         struct stun_header *hdr = (struct stun_header *)data;
467         struct stun_attr *attr;
468         struct stun_state st;
469         int ret = STUN_IGNORE;  
470         int x;
471
472         /* On entry, 'len' is the length of the udp payload. After the
473          * initial checks it becomes the size of unprocessed options,
474          * while 'data' is advanced accordingly.
475          */
476         if (len < sizeof(struct stun_header)) {
477                 ast_debug(1, "Runt STUN packet (only %d, wanting at least %d)\n", (int) len, (int) sizeof(struct stun_header));
478                 return -1;
479         }
480         len -= sizeof(struct stun_header);
481         data += sizeof(struct stun_header);
482         x = ntohs(hdr->msglen); /* len as advertised in the message */
483         if (stundebug)
484                 ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), x);
485         if (x > len) {
486                 ast_debug(1, "Scrambled STUN packet length (got %d, expecting %d)\n", x, (int)len);
487         } else
488                 len = x;
489         memset(&st, 0, sizeof(st));
490         while (len) {
491                 if (len < sizeof(struct stun_attr)) {
492                         ast_debug(1, "Runt Attribute (got %d, expecting %d)\n", (int)len, (int) sizeof(struct stun_attr));
493                         break;
494                 }
495                 attr = (struct stun_attr *)data;
496                 /* compute total attribute length */
497                 x = ntohs(attr->len) + sizeof(struct stun_attr);
498                 if (x > len) {
499                         ast_debug(1, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", x, (int)len);
500                         break;
501                 }
502                 if (stun_cb)
503                         stun_cb(attr, arg);
504                 if (stun_process_attr(&st, attr)) {
505                         ast_debug(1, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
506                         break;
507                 }
508                 /* Clear attribute id: in case previous entry was a string,
509                  * this will act as the terminator for the string.
510                  */
511                 attr->attr = 0;
512                 data += x;
513                 len -= x;
514         }
515         /* Null terminate any string.
516          * XXX NOTE, we write past the size of the buffer passed by the
517          * caller, so this is potentially dangerous. The only thing that
518          * saves us is that usually we read the incoming message in a
519          * much larger buffer in the struct ast_rtp
520          */
521         *data = '\0';
522
523         /* Now prepare to generate a reply, which at the moment is done
524          * only for properly formed (len == 0) STUN_BINDREQ messages.
525          */
526         if (len == 0) {
527                 unsigned char respdata[1024];
528                 struct stun_header *resp = (struct stun_header *)respdata;
529                 int resplen = 0;        /* len excluding header */
530                 int respleft = sizeof(respdata) - sizeof(struct stun_header);
531
532                 resp->id = hdr->id;
533                 resp->msgtype = 0;
534                 resp->msglen = 0;
535                 attr = (struct stun_attr *)resp->ies;
536                 switch (ntohs(hdr->msgtype)) {
537                 case STUN_BINDREQ:
538                         if (stundebug)
539                                 ast_verbose("STUN Bind Request, username: %s\n", 
540                                             st.username ? st.username : "<none>");
541                         if (st.username)
542                                 append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
543                         append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
544                         resp->msglen = htons(resplen);
545                         resp->msgtype = htons(STUN_BINDRESP);
546                         stun_send(s, src, resp);
547                         ret = STUN_ACCEPT;
548                         break;
549                 default:
550                         if (stundebug)
551                                 ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
552                 }
553         }
554         return ret;
555 }
556
557 /*! \brief Extract the STUN_MAPPED_ADDRESS from the stun response.
558  * This is used as a callback for stun_handle_response
559  * when called from ast_stun_request.
560  */
561 static int stun_get_mapped(struct stun_attr *attr, void *arg)
562 {
563         struct stun_addr *addr = (struct stun_addr *)(attr + 1);
564         struct sockaddr_in *sa = (struct sockaddr_in *)arg;
565
566         if (ntohs(attr->attr) != STUN_MAPPED_ADDRESS || ntohs(attr->len) != 8)
567                 return 1;       /* not us. */
568         sa->sin_port = addr->port;
569         sa->sin_addr.s_addr = addr->addr;
570         return 0;
571 }
572
573 /*! \brief Generic STUN request
574  * Send a generic stun request to the server specified,
575  * possibly waiting for a reply and filling the 'reply' field with
576  * the externally visible address. Note that in this case the request
577  * will be blocking.
578  * (Note, the interface may change slightly in the future).
579  *
580  * \param s the socket used to send the request
581  * \param dst the address of the STUN server
582  * \param username if non null, add the username in the request
583  * \param answer if non null, the function waits for a response and
584  *    puts here the externally visible address.
585  * \return 0 on success, other values on error.
586  */
587 int ast_stun_request(int s, struct sockaddr_in *dst,
588         const char *username, struct sockaddr_in *answer)
589 {
590         struct stun_header *req;
591         unsigned char reqdata[1024];
592         int reqlen, reqleft;
593         struct stun_attr *attr;
594         int res = 0;
595         int retry;
596         
597         req = (struct stun_header *)reqdata;
598         stun_req_id(req);
599         reqlen = 0;
600         reqleft = sizeof(reqdata) - sizeof(struct stun_header);
601         req->msgtype = 0;
602         req->msglen = 0;
603         attr = (struct stun_attr *)req->ies;
604         if (username)
605                 append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
606         req->msglen = htons(reqlen);
607         req->msgtype = htons(STUN_BINDREQ);
608         for (retry = 0; retry < 3; retry++) {   /* XXX make retries configurable */
609                 /* send request, possibly wait for reply */
610                 unsigned char reply_buf[1024];
611                 fd_set rfds;
612                 struct timeval to = { 3, 0 };   /* timeout, make it configurable */
613                 struct sockaddr_in src;
614                 socklen_t srclen;
615
616                 res = stun_send(s, dst, req);
617                 if (res < 0) {
618                         ast_log(LOG_WARNING, "ast_stun_request send #%d failed error %d, retry\n",
619                                 retry, res);
620                         continue;
621                 }
622                 if (answer == NULL)
623                         break;
624                 FD_ZERO(&rfds);
625                 FD_SET(s, &rfds);
626                 res = ast_select(s + 1, &rfds, NULL, NULL, &to);
627                 if (res <= 0)   /* timeout or error */
628                         continue;
629                 bzero(&src, sizeof(src));
630                 srclen = sizeof(src);
631                 /* XXX pass -1 in the size, because stun_handle_packet might
632                  * write past the end of the buffer.
633                  */
634                 res = recvfrom(s, reply_buf, sizeof(reply_buf) - 1,
635                         0, (struct sockaddr *)&src, &srclen);
636                 if (res < 0) {
637                         ast_log(LOG_WARNING, "ast_stun_request recvfrom #%d failed error %d, retry\n",
638                                 retry, res);
639                         continue;
640                 }
641                 bzero(answer, sizeof(struct sockaddr_in));
642                 stun_handle_packet(s, &src, reply_buf, res,
643                         stun_get_mapped, answer);
644                 res = 0; /* signal regular exit */
645                 break;
646         }
647         return res;
648 }
649
650 /*! \brief send a STUN BIND request to the given destination.
651  * Optionally, add a username if specified.
652  */
653 void ast_rtp_stun_request(struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
654 {
655         ast_stun_request(rtp->s, suggestion, username, NULL);
656 }
657
658 /*! \brief List of current sessions */
659 static AST_RWLIST_HEAD_STATIC(protos, ast_rtp_protocol);
660
661 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
662 {
663         unsigned int sec, usec, frac;
664         sec = tv.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
665         usec = tv.tv_usec;
666         frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
667         *msw = sec;
668         *lsw = frac;
669 }
670
671 int ast_rtp_fd(struct ast_rtp *rtp)
672 {
673         return rtp->s;
674 }
675
676 int ast_rtcp_fd(struct ast_rtp *rtp)
677 {
678         if (rtp->rtcp)
679                 return rtp->rtcp->s;
680         return -1;
681 }
682
683 unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
684 {
685         unsigned int interval;
686         /*! \todo XXX Do a more reasonable calculation on this one
687          * Look in RFC 3550 Section A.7 for an example*/
688         interval = rtcpinterval;
689         return interval;
690 }
691
692 /* \brief Put RTP timeout timers on hold during another transaction, like T.38 */
693 void ast_rtp_set_rtptimers_onhold(struct ast_rtp *rtp)
694 {
695         rtp->rtptimeout = (-1) * rtp->rtptimeout;
696         rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout;
697 }
698
699 /*! \brief Set rtp timeout */
700 void ast_rtp_set_rtptimeout(struct ast_rtp *rtp, int timeout)
701 {
702         rtp->rtptimeout = timeout;
703 }
704
705 /*! \brief Set rtp hold timeout */
706 void ast_rtp_set_rtpholdtimeout(struct ast_rtp *rtp, int timeout)
707 {
708         rtp->rtpholdtimeout = timeout;
709 }
710
711 /*! \brief set RTP keepalive interval */
712 void ast_rtp_set_rtpkeepalive(struct ast_rtp *rtp, int period)
713 {
714         rtp->rtpkeepalive = period;
715 }
716
717 /*! \brief Get rtp timeout */
718 int ast_rtp_get_rtptimeout(struct ast_rtp *rtp)
719 {
720         if (rtp->rtptimeout < 0)        /* We're not checking, but remembering the setting (during T.38 transmission) */
721                 return 0;
722         return rtp->rtptimeout;
723 }
724
725 /*! \brief Get rtp hold timeout */
726 int ast_rtp_get_rtpholdtimeout(struct ast_rtp *rtp)
727 {
728         if (rtp->rtptimeout < 0)        /* We're not checking, but remembering the setting (during T.38 transmission) */
729                 return 0;
730         return rtp->rtpholdtimeout;
731 }
732
733 /*! \brief Get RTP keepalive interval */
734 int ast_rtp_get_rtpkeepalive(struct ast_rtp *rtp)
735 {
736         return rtp->rtpkeepalive;
737 }
738
739 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
740 {
741         rtp->data = data;
742 }
743
744 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
745 {
746         rtp->callback = callback;
747 }
748
749 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
750 {
751         rtp->nat = nat;
752 }
753
754 int ast_rtp_getnat(struct ast_rtp *rtp)
755 {
756         return ast_test_flag(rtp, FLAG_NAT_ACTIVE);
757 }
758
759 void ast_rtp_setdtmf(struct ast_rtp *rtp, int dtmf)
760 {
761         ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF);
762 }
763
764 void ast_rtp_setdtmfcompensate(struct ast_rtp *rtp, int compensate)
765 {
766         ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE);
767 }
768
769 void ast_rtp_setstun(struct ast_rtp *rtp, int stun_enable)
770 {
771         ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN);
772 }
773
774 static void rtp_bridge_lock(struct ast_rtp *rtp)
775 {
776 #ifdef P2P_INTENSE
777         ast_mutex_lock(&rtp->bridge_lock);
778 #endif
779         return;
780 }
781
782 static void rtp_bridge_unlock(struct ast_rtp *rtp)
783 {
784 #ifdef P2P_INTENSE
785         ast_mutex_unlock(&rtp->bridge_lock);
786 #endif
787         return;
788 }
789
790 static struct ast_frame *send_dtmf(struct ast_rtp *rtp, enum ast_frame_type type)
791 {
792         if (((ast_test_flag(rtp, FLAG_DTMF_COMPENSATE) && type == AST_FRAME_DTMF_END) ||
793              (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
794                 ast_debug(1, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(rtp->them.sin_addr));
795                 rtp->resp = 0;
796                 rtp->dtmfsamples = 0;
797                 return &ast_null_frame;
798         }
799         ast_debug(1, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(rtp->them.sin_addr));
800         if (rtp->resp == 'X') {
801                 rtp->f.frametype = AST_FRAME_CONTROL;
802                 rtp->f.subclass = AST_CONTROL_FLASH;
803         } else {
804                 rtp->f.frametype = type;
805                 rtp->f.subclass = rtp->resp;
806         }
807         rtp->f.datalen = 0;
808         rtp->f.samples = 0;
809         rtp->f.mallocd = 0;
810         rtp->f.src = "RTP";
811         return &rtp->f;
812         
813 }
814
815 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
816 {
817         if (rtpdebug == 0)
818                 return 0;
819         if (rtpdebugaddr.sin_addr.s_addr) {
820                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
821                      && (rtpdebugaddr.sin_port != addr->sin_port))
822                     || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
823                         return 0;
824         }
825         return 1;
826 }
827
828 static inline int rtcp_debug_test_addr(struct sockaddr_in *addr)
829 {
830         if (rtcpdebug == 0)
831                 return 0;
832         if (rtcpdebugaddr.sin_addr.s_addr) {
833                 if (((ntohs(rtcpdebugaddr.sin_port) != 0)
834                      && (rtcpdebugaddr.sin_port != addr->sin_port))
835                     || (rtcpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
836                         return 0;
837         }
838         return 1;
839 }
840
841
842 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
843 {
844         unsigned int event;
845         char resp = 0;
846         struct ast_frame *f = NULL;
847         unsigned char seq;
848         unsigned int flags;
849         unsigned int power;
850
851         /* We should have at least 4 bytes in RTP data */
852         if (len < 4)
853                 return f;
854
855         /*      The format of Cisco RTP DTMF packet looks like next:
856                 +0                              - sequence number of DTMF RTP packet (begins from 1,
857                                                   wrapped to 0)
858                 +1                              - set of flags
859                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
860                                                   or repeated digit without audio???
861                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
862                                                   then falls to 0 at its end)
863                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
864                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
865                 by each new packet and thus provides some redudancy.
866                 
867                 Sample of Cisco RTP DTMF packet is (all data in hex):
868                         19 07 00 02 12 02 20 02
869                 showing end of DTMF digit '2'.
870
871                 The packets
872                         27 07 00 02 0A 02 20 02
873                         28 06 20 02 00 02 0A 02
874                 shows begin of new digit '2' with very short pause (20 ms) after
875                 previous digit '2'. Bit +1.0 flips at begin of new digit.
876                 
877                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
878                 so its uses the same sequencing and timestamping rules as replaced
879                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
880                 on audio framing parameters. Marker bit isn't used within stream of
881                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
882                 are not sequential at borders between DTMF and audio streams,
883         */
884
885         seq = data[0];
886         flags = data[1];
887         power = data[2];
888         event = data[3] & 0x1f;
889
890         if (option_debug > 2 || rtpdebug)
891                 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);
892         if (event < 10) {
893                 resp = '0' + event;
894         } else if (event < 11) {
895                 resp = '*';
896         } else if (event < 12) {
897                 resp = '#';
898         } else if (event < 16) {
899                 resp = 'A' + (event - 12);
900         } else if (event < 17) {
901                 resp = 'X';
902         }
903         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
904                 rtp->resp = resp;
905                 /* Why we should care on DTMF compensation at reception? */
906                 if (!ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
907                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
908                         rtp->dtmfsamples = 0;
909                 }
910         } else if ((rtp->resp == resp) && !power) {
911                 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
912                 f->samples = rtp->dtmfsamples * 8;
913                 rtp->resp = 0;
914         } else if (rtp->resp == resp)
915                 rtp->dtmfsamples += 20 * 8;
916         rtp->dtmfcount = dtmftimeout;
917         return f;
918 }
919
920 /*! 
921  * \brief Process RTP DTMF and events according to RFC 2833.
922  * 
923  * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
924  * 
925  * \param rtp
926  * \param data
927  * \param len
928  * \param seqno
929  * \param timestamp
930  * \returns
931  */
932 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp)
933 {
934         unsigned int event;
935         unsigned int event_end;
936         unsigned int samples;
937         char resp = 0;
938         struct ast_frame *f = NULL;
939
940         /* Figure out event, event end, and samples */
941         event = ntohl(*((unsigned int *)(data)));
942         event >>= 24;
943         event_end = ntohl(*((unsigned int *)(data)));
944         event_end <<= 8;
945         event_end >>= 24;
946         samples = ntohl(*((unsigned int *)(data)));
947         samples &= 0xFFFF;
948
949         /* Print out debug if turned on */
950         if (rtpdebug || option_debug > 2)
951                 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
952
953         /* Figure out what digit was pressed */
954         if (event < 10) {
955                 resp = '0' + event;
956         } else if (event < 11) {
957                 resp = '*';
958         } else if (event < 12) {
959                 resp = '#';
960         } else if (event < 16) {
961                 resp = 'A' + (event - 12);
962         } else if (event < 17) {        /* Event 16: Hook flash */
963                 resp = 'X';     
964         } else {
965                 /* Not a supported event */
966                 ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
967                 return &ast_null_frame;
968         }
969         
970         if (ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
971                 if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
972                         rtp->resp = resp;
973                         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
974                         f->len = 0;
975                         rtp->lastevent = timestamp;
976                 }
977         } else {
978                 if ((!(rtp->resp) && (!(event_end & 0x80))) || (rtp->resp && rtp->resp != resp)) {
979                         rtp->resp = resp;
980                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
981                 } else if ((event_end & 0x80) && (rtp->lastevent != seqno) && rtp->resp) {
982                         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
983                         f->len = ast_tvdiff_ms(ast_samp2tv(samples, 8000), ast_tv(0, 0)); /* XXX hard coded 8kHz */
984                         rtp->resp = 0;
985                         rtp->lastevent = seqno;
986                 }
987         }
988
989         rtp->dtmfcount = dtmftimeout;
990         rtp->dtmfsamples = samples;
991
992         return f;
993 }
994
995 /*!
996  * \brief Process Comfort Noise RTP.
997  * 
998  * This is incomplete at the moment.
999  * 
1000 */
1001 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
1002 {
1003         struct ast_frame *f = NULL;
1004         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
1005            totally help us out becuase we don't have an engine to keep it going and we are not
1006            guaranteed to have it every 20ms or anything */
1007         if (rtpdebug)
1008                 ast_debug(0, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
1009
1010         if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
1011                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
1012                         ast_inet_ntoa(rtp->them.sin_addr));
1013                 ast_set_flag(rtp, FLAG_3389_WARNING);
1014         }
1015         
1016         /* Must have at least one byte */
1017         if (!len)
1018                 return NULL;
1019         if (len < 24) {
1020                 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
1021                 rtp->f.datalen = len - 1;
1022                 rtp->f.offset = AST_FRIENDLY_OFFSET;
1023                 memcpy(rtp->f.data, data + 1, len - 1);
1024         } else {
1025                 rtp->f.data = NULL;
1026                 rtp->f.offset = 0;
1027                 rtp->f.datalen = 0;
1028         }
1029         rtp->f.frametype = AST_FRAME_CNG;
1030         rtp->f.subclass = data[0] & 0x7f;
1031         rtp->f.datalen = len - 1;
1032         rtp->f.samples = 0;
1033         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
1034         f = &rtp->f;
1035         return f;
1036 }
1037
1038 static int rtpread(int *id, int fd, short events, void *cbdata)
1039 {
1040         struct ast_rtp *rtp = cbdata;
1041         struct ast_frame *f;
1042         f = ast_rtp_read(rtp);
1043         if (f) {
1044                 if (rtp->callback)
1045                         rtp->callback(rtp, f, rtp->data);
1046         }
1047         return 1;
1048 }
1049
1050 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
1051 {
1052         socklen_t len;
1053         int position, i, packetwords;
1054         int res;
1055         struct sockaddr_in sin;
1056         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
1057         unsigned int *rtcpheader;
1058         int pt;
1059         struct timeval now;
1060         unsigned int length;
1061         int rc;
1062         double rttsec;
1063         uint64_t rtt = 0;
1064         unsigned int dlsr;
1065         unsigned int lsr;
1066         unsigned int msw;
1067         unsigned int lsw;
1068         unsigned int comp;
1069         struct ast_frame *f = &ast_null_frame;
1070         
1071         if (!rtp || !rtp->rtcp)
1072                 return &ast_null_frame;
1073
1074         len = sizeof(sin);
1075         
1076         res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
1077                                         0, (struct sockaddr *)&sin, &len);
1078         rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
1079         
1080         if (res < 0) {
1081                 if (errno == EBADF)
1082                         CRASH;
1083                 if (errno != EAGAIN) {
1084                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
1085                         return NULL;
1086                 }
1087                 return &ast_null_frame;
1088         }
1089
1090         packetwords = res / 4;
1091         
1092         if (rtp->nat) {
1093                 /* Send to whoever sent to us */
1094                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1095                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
1096                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1097                         if (option_debug || rtpdebug)
1098                                 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));
1099                 }
1100         }
1101
1102         ast_debug(1, "Got RTCP report of %d bytes\n", res);
1103
1104         /* Process a compound packet */
1105         position = 0;
1106         while (position < packetwords) {
1107                 i = position;
1108                 length = ntohl(rtcpheader[i]);
1109                 pt = (length & 0xff0000) >> 16;
1110                 rc = (length & 0x1f000000) >> 24;
1111                 length &= 0xffff;
1112     
1113                 if ((i + length) > packetwords) {
1114                         if (option_debug || rtpdebug)
1115                                 ast_log(LOG_DEBUG, "RTCP Read too short\n");
1116                         return &ast_null_frame;
1117                 }
1118                 
1119                 if (rtcp_debug_test_addr(&sin)) {
1120                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
1121                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
1122                         ast_verbose("Reception reports: %d\n", rc);
1123                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
1124                 }
1125     
1126                 i += 2; /* Advance past header and ssrc */
1127                 
1128                 switch (pt) {
1129                 case RTCP_PT_SR:
1130                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
1131                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
1132                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
1133                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
1134     
1135                         if (rtcp_debug_test_addr(&sin)) {
1136                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
1137                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
1138                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
1139                         }
1140                         i += 5;
1141                         if (rc < 1)
1142                                 break;
1143                         /* Intentional fall through */
1144                 case RTCP_PT_RR:
1145                         /* Don't handle multiple reception reports (rc > 1) yet */
1146                         /* Calculate RTT per RFC */
1147                         gettimeofday(&now, NULL);
1148                         timeval2ntp(now, &msw, &lsw);
1149                         if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
1150                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
1151                                 lsr = ntohl(rtcpheader[i + 4]);
1152                                 dlsr = ntohl(rtcpheader[i + 5]);
1153                                 rtt = comp - lsr - dlsr;
1154
1155                                 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
1156                                    sess->ee_delay = (eedelay * 1000) / 65536; */
1157                                 if (rtt < 4294) {
1158                                     rtt = (rtt * 1000000) >> 16;
1159                                 } else {
1160                                     rtt = (rtt * 1000) >> 16;
1161                                     rtt *= 1000;
1162                                 }
1163                                 rtt = rtt / 1000.;
1164                                 rttsec = rtt / 1000.;
1165
1166                                 if (comp - dlsr >= lsr) {
1167                                         rtp->rtcp->accumulated_transit += rttsec;
1168                                         rtp->rtcp->rtt = rttsec;
1169                                         if (rtp->rtcp->maxrtt<rttsec)
1170                                                 rtp->rtcp->maxrtt = rttsec;
1171                                         if (rtp->rtcp->minrtt>rttsec)
1172                                                 rtp->rtcp->minrtt = rttsec;
1173                                 } else if (rtcp_debug_test_addr(&sin)) {
1174                                         ast_verbose("Internal RTCP NTP clock skew detected: "
1175                                                            "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
1176                                                            "diff=%d\n",
1177                                                            lsr, comp, dlsr, dlsr / 65536,
1178                                                            (dlsr % 65536) * 1000 / 65536,
1179                                                            dlsr - (comp - lsr));
1180                                 }
1181                         }
1182
1183                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
1184                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
1185                         if (rtcp_debug_test_addr(&sin)) {
1186                                 ast_verbose("  Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
1187                                 ast_verbose("  Packets lost so far: %d\n", rtp->rtcp->reported_lost);
1188                                 ast_verbose("  Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
1189                                 ast_verbose("  Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
1190                                 ast_verbose("  Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
1191                                 ast_verbose("  Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
1192                                 ast_verbose("  DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
1193                                 if (rtt)
1194                                         ast_verbose("  RTT: %lu(sec)\n", (unsigned long) rtt);
1195                         }
1196                         if (rtt) {
1197                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1198                                                                     "PT: %d(%s)\r\n"
1199                                                                     "ReceptionReports: %d\r\n"
1200                                                                     "SenderSSRC: %u\r\n"
1201                                                                     "FractionLost: %ld\r\n"
1202                                                                     "PacketsLost: %d\r\n"
1203                                                                     "HighestSequence: %ld\r\n"
1204                                                                     "SequenceNumberCycles: %ld\r\n"
1205                                                                     "IAJitter: %u\r\n"
1206                                                                     "LastSR: %lu.%010lu\r\n"
1207                                                                     "DLSR: %4.4f(sec)\r\n"
1208                                                                     "RTT: %llu(sec)\r\n",
1209                                                                     ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1210                                                                     pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1211                                                                     rc,
1212                                                                     rtcpheader[i + 1],
1213                                                                     (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1214                                                                     rtp->rtcp->reported_lost,
1215                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1216                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1217                                                                     rtp->rtcp->reported_jitter,
1218                                                                     (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1219                                                                     ntohl(rtcpheader[i + 5])/65536.0,
1220                                                                     (unsigned long long)rtt);
1221                         } else {
1222                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1223                                                                     "PT: %d(%s)\r\n"
1224                                                                     "ReceptionReports: %d\r\n"
1225                                                                     "SenderSSRC: %u\r\n"
1226                                                                     "FractionLost: %ld\r\n"
1227                                                                     "PacketsLost: %d\r\n"
1228                                                                     "HighestSequence: %ld\r\n"
1229                                                                     "SequenceNumberCycles: %ld\r\n"
1230                                                                     "IAJitter: %u\r\n"
1231                                                                     "LastSR: %lu.%010lu\r\n"
1232                                                                     "DLSR: %4.4f(sec)\r\n",
1233                                                                     ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1234                                                                     pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1235                                                                     rc,
1236                                                                     rtcpheader[i + 1],
1237                                                                     (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1238                                                                     rtp->rtcp->reported_lost,
1239                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1240                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1241                                                                     rtp->rtcp->reported_jitter,
1242                                                                     (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
1243                                                                     ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1244                                                                     ntohl(rtcpheader[i + 5])/65536.0);
1245                         }
1246                         break;
1247                 case RTCP_PT_FUR:
1248                         if (rtcp_debug_test_addr(&sin))
1249                                 ast_verbose("Received an RTCP Fast Update Request\n");
1250                         rtp->f.frametype = AST_FRAME_CONTROL;
1251                         rtp->f.subclass = AST_CONTROL_VIDUPDATE;
1252                         rtp->f.datalen = 0;
1253                         rtp->f.samples = 0;
1254                         rtp->f.mallocd = 0;
1255                         rtp->f.src = "RTP";
1256                         f = &rtp->f;
1257                         break;
1258                 case RTCP_PT_SDES:
1259                         if (rtcp_debug_test_addr(&sin))
1260                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1261                         break;
1262                 case RTCP_PT_BYE:
1263                         if (rtcp_debug_test_addr(&sin))
1264                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1265                         break;
1266                 default:
1267                         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));
1268                         break;
1269                 }
1270                 position += (length + 1);
1271         }
1272                         
1273         return f;
1274 }
1275
1276 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1277 {
1278         struct timeval now;
1279         double transit;
1280         double current_time;
1281         double d;
1282         double dtv;
1283         double prog;
1284         
1285         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1286                 gettimeofday(&rtp->rxcore, NULL);
1287                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1288                 /* map timestamp to a real time */
1289                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1290                 rtp->rxcore.tv_sec -= timestamp / 8000;
1291                 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
1292                 /* Round to 0.1ms for nice, pretty timestamps */
1293                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1294                 if (rtp->rxcore.tv_usec < 0) {
1295                         /* Adjust appropriately if necessary */
1296                         rtp->rxcore.tv_usec += 1000000;
1297                         rtp->rxcore.tv_sec -= 1;
1298                 }
1299         }
1300
1301         gettimeofday(&now,NULL);
1302         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1303         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
1304         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
1305         if (tv->tv_usec >= 1000000) {
1306                 tv->tv_usec -= 1000000;
1307                 tv->tv_sec += 1;
1308         }
1309         prog = (double)((timestamp-rtp->seedrxts)/8000.);
1310         dtv = (double)rtp->drxcore + (double)(prog);
1311         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1312         transit = current_time - dtv;
1313         d = transit - rtp->rxtransit;
1314         rtp->rxtransit = transit;
1315         if (d<0)
1316                 d=-d;
1317         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1318         if (rtp->rtcp && rtp->rxjitter > rtp->rtcp->maxrxjitter)
1319                 rtp->rtcp->maxrxjitter = rtp->rxjitter;
1320         if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1321                 rtp->rtcp->minrxjitter = rtp->rxjitter;
1322 }
1323
1324 /*! \brief Perform a Packet2Packet RTP write */
1325 static int bridge_p2p_rtp_write(struct ast_rtp *rtp, struct ast_rtp *bridged, unsigned int *rtpheader, int len, int hdrlen)
1326 {
1327         int res = 0, payload = 0, bridged_payload = 0, mark;
1328         struct rtpPayloadType rtpPT;
1329         int reconstruct = ntohl(rtpheader[0]);
1330
1331         /* Get fields from packet */
1332         payload = (reconstruct & 0x7f0000) >> 16;
1333         mark = (((reconstruct & 0x800000) >> 23) != 0);
1334
1335         /* Check what the payload value should be */
1336         rtpPT = ast_rtp_lookup_pt(rtp, payload);
1337
1338         /* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
1339         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) && !rtpPT.isAstFormat && rtpPT.code == AST_RTP_DTMF)
1340                 return -1;
1341
1342         /* Otherwise adjust bridged payload to match */
1343         bridged_payload = ast_rtp_lookup_code(bridged, rtpPT.isAstFormat, rtpPT.code);
1344
1345         /* If the mark bit has not been sent yet... do it now */
1346         if (!ast_test_flag(rtp, FLAG_P2P_SENT_MARK)) {
1347                 mark = 1;
1348                 ast_set_flag(rtp, FLAG_P2P_SENT_MARK);
1349         }
1350
1351         /* Reconstruct part of the packet */
1352         reconstruct &= 0xFF80FFFF;
1353         reconstruct |= (bridged_payload << 16);
1354         reconstruct |= (mark << 23);
1355         rtpheader[0] = htonl(reconstruct);
1356
1357         /* Send the packet back out */
1358         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&bridged->them, sizeof(bridged->them));
1359         if (res < 0) {
1360                 if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1361                         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));
1362                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1363                         if (option_debug || rtpdebug)
1364                                 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));
1365                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1366                 }
1367                 return 0;
1368         } else if (rtp_debug_test_addr(&bridged->them))
1369                         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);
1370
1371         return 0;
1372 }
1373
1374 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
1375 {
1376         int res;
1377         struct sockaddr_in sin;
1378         socklen_t len;
1379         unsigned int seqno;
1380         int version;
1381         int payloadtype;
1382         int hdrlen = 12;
1383         int padding;
1384         int mark;
1385         int ext;
1386         int cc;
1387         unsigned int ssrc;
1388         unsigned int timestamp;
1389         unsigned int *rtpheader;
1390         struct rtpPayloadType rtpPT;
1391         struct ast_rtp *bridged = NULL;
1392         
1393         /* If time is up, kill it */
1394         if (rtp->sending_digit)
1395                 ast_rtp_senddigit_continuation(rtp);
1396
1397         len = sizeof(sin);
1398         
1399         /* Cache where the header will go */
1400         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
1401                                         0, (struct sockaddr *)&sin, &len);
1402
1403         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
1404         if (res < 0) {
1405                 if (errno == EBADF)
1406                         CRASH;
1407                 if (errno != EAGAIN) {
1408                         ast_log(LOG_WARNING, "RTP Read error: %s.  Hanging up.\n", strerror(errno));
1409                         return NULL;
1410                 }
1411                 return &ast_null_frame;
1412         }
1413         
1414         if (res < hdrlen) {
1415                 ast_log(LOG_WARNING, "RTP Read too short\n");
1416                 return &ast_null_frame;
1417         }
1418
1419         /* Get fields */
1420         seqno = ntohl(rtpheader[0]);
1421
1422         /* Check RTP version */
1423         version = (seqno & 0xC0000000) >> 30;
1424         if (!version) {
1425                 /* If the two high bits are 0, this might be a
1426                  * STUN message, so process it. stun_handle_packet()
1427                  * answers to requests, and it returns STUN_ACCEPT
1428                  * if the request is valid.
1429                  */
1430                 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == STUN_ACCEPT) &&
1431                         (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
1432                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
1433                 }
1434                 return &ast_null_frame;
1435         }
1436
1437 #if 0   /* Allow to receive RTP stream with closed transmission path */
1438         /* If we don't have the other side's address, then ignore this */
1439         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
1440                 return &ast_null_frame;
1441 #endif
1442
1443         /* Send to whoever send to us if NAT is turned on */
1444         if (rtp->nat) {
1445                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1446                     (rtp->them.sin_port != sin.sin_port)) {
1447                         rtp->them = sin;
1448                         if (rtp->rtcp) {
1449                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1450                                 rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1);
1451                         }
1452                         rtp->rxseqno = 0;
1453                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1454                         if (option_debug || rtpdebug)
1455                                 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));
1456                 }
1457         }
1458
1459         /* If we are bridged to another RTP stream, send direct */
1460         if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen))
1461                 return &ast_null_frame;
1462
1463         if (version != 2)
1464                 return &ast_null_frame;
1465
1466         payloadtype = (seqno & 0x7f0000) >> 16;
1467         padding = seqno & (1 << 29);
1468         mark = seqno & (1 << 23);
1469         ext = seqno & (1 << 28);
1470         cc = (seqno & 0xF000000) >> 24;
1471         seqno &= 0xffff;
1472         timestamp = ntohl(rtpheader[1]);
1473         ssrc = ntohl(rtpheader[2]);
1474         
1475         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1476                 if (option_debug || rtpdebug)
1477                         ast_debug(0, "Forcing Marker bit, because SSRC has changed\n");
1478                 mark = 1;
1479         }
1480
1481         rtp->rxssrc = ssrc;
1482         
1483         if (padding) {
1484                 /* Remove padding bytes */
1485                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1486         }
1487         
1488         if (cc) {
1489                 /* CSRC fields present */
1490                 hdrlen += cc*4;
1491         }
1492
1493         if (ext) {
1494                 /* RTP Extension present */
1495                 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
1496                 hdrlen += 4;
1497                 if (option_debug) {
1498                         int profile;
1499                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1500                         if (profile == 0x505a)
1501                                 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1502                         else
1503                                 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
1504                 }
1505         }
1506
1507         if (res < hdrlen) {
1508                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
1509                 return &ast_null_frame;
1510         }
1511
1512         rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1513
1514         if (rtp->rxcount==1) {
1515                 /* This is the first RTP packet successfully received from source */
1516                 rtp->seedrxseqno = seqno;
1517         }
1518
1519         /* Do not schedule RR if RTCP isn't run */
1520         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
1521                 /* Schedule transmission of Receiver Report */
1522                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1523         }
1524         if ( (int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
1525                 rtp->cycles += RTP_SEQ_MOD;
1526
1527         rtp->lastrxseqno = seqno;
1528         
1529         if (rtp->themssrc==0)
1530                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
1531         
1532         if (rtp_debug_test_addr(&sin))
1533                 ast_verbose("Got  RTP packet from    %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1534                         ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
1535
1536         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
1537         if (!rtpPT.isAstFormat) {
1538                 struct ast_frame *f = NULL;
1539
1540                 /* This is special in-band data that's not one of our codecs */
1541                 if (rtpPT.code == AST_RTP_DTMF) {
1542                         /* It's special -- rfc2833 process it */
1543                         if (rtp_debug_test_addr(&sin)) {
1544                                 unsigned char *data;
1545                                 unsigned int event;
1546                                 unsigned int event_end;
1547                                 unsigned int duration;
1548                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
1549                                 event = ntohl(*((unsigned int *)(data)));
1550                                 event >>= 24;
1551                                 event_end = ntohl(*((unsigned int *)(data)));
1552                                 event_end <<= 8;
1553                                 event_end >>= 24;
1554                                 duration = ntohl(*((unsigned int *)(data)));
1555                                 duration &= 0xFFFF;
1556                                 ast_verbose("Got  RTP RFC2833 from   %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u, mark %d, event %08x, end %d, duration %-5.5d) \n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp, res - hdrlen, (mark?1:0), event, ((event_end & 0x80)?1:0), duration);
1557                         }
1558                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp);
1559                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
1560                         /* It's really special -- process it the Cisco way */
1561                         if (rtp->lastevent <= seqno || (rtp->lastevent >= 65530 && seqno <= 6)) {
1562                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1563                                 rtp->lastevent = seqno;
1564                         }
1565                 } else if (rtpPT.code == AST_RTP_CN) {
1566                         /* Comfort Noise */
1567                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1568                 } else {
1569                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr));
1570                 }
1571                 return f ? f : &ast_null_frame;
1572         }
1573         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
1574         rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : (rtp->f.subclass < AST_FORMAT_MAX_VIDEO) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
1575
1576         if (!rtp->lastrxts)
1577                 rtp->lastrxts = timestamp;
1578
1579         rtp->rxseqno = seqno;
1580
1581         /* Record received timestamp as last received now */
1582         rtp->lastrxts = timestamp;
1583
1584         rtp->f.mallocd = 0;
1585         rtp->f.datalen = res - hdrlen;
1586         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
1587         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
1588         rtp->f.seqno = seqno;
1589         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
1590                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
1591                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
1592                         ast_frame_byteswap_be(&rtp->f);
1593                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
1594                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1595                 rtp->f.has_timing_info = 1;
1596                 rtp->f.ts = timestamp / 8;
1597                 rtp->f.len = rtp->f.samples / 8;
1598         } else if(rtp->f.subclass < AST_FORMAT_MAX_VIDEO) {
1599                 /* Video -- samples is # of samples vs. 90000 */
1600                 if (!rtp->lastividtimestamp)
1601                         rtp->lastividtimestamp = timestamp;
1602                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
1603                 rtp->lastividtimestamp = timestamp;
1604                 rtp->f.delivery.tv_sec = 0;
1605                 rtp->f.delivery.tv_usec = 0;
1606                 /* Pass the RTP marker bit as bit 0 in the subclass field.
1607                  * This is ok because subclass is actually a bitmask, and
1608                  * the low bits represent audio formats, that are not
1609                  * involved here since we deal with video.
1610                  */
1611                 if (mark)
1612                         rtp->f.subclass |= 0x1;
1613         } else {
1614                 /* TEXT -- samples is # of samples vs. 1000 */
1615                 if (!rtp->lastitexttimestamp)
1616                         rtp->lastitexttimestamp = timestamp;
1617                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
1618                 rtp->lastitexttimestamp = timestamp;
1619                 rtp->f.delivery.tv_sec = 0;
1620                 rtp->f.delivery.tv_usec = 0;
1621         }
1622         rtp->f.src = "RTP";
1623         return &rtp->f;
1624 }
1625
1626 /* The following array defines the MIME Media type (and subtype) for each
1627    of our codecs, or RTP-specific data type. */
1628 static struct {
1629         struct rtpPayloadType payloadType;
1630         char* type;
1631         char* subtype;
1632 } mimeTypes[] = {
1633         {{1, AST_FORMAT_G723_1}, "audio", "G723"},
1634         {{1, AST_FORMAT_GSM}, "audio", "GSM"},
1635         {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
1636         {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
1637         {{1, AST_FORMAT_G726}, "audio", "G726-32"},
1638         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
1639         {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
1640         {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
1641         {{1, AST_FORMAT_G729A}, "audio", "G729"},
1642         {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
1643         {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
1644         {{1, AST_FORMAT_G722}, "audio", "G722"},
1645         {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32"},
1646         {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
1647         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
1648         {{0, AST_RTP_CN}, "audio", "CN"},
1649         {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
1650         {{1, AST_FORMAT_PNG}, "video", "PNG"},
1651         {{1, AST_FORMAT_H261}, "video", "H261"},
1652         {{1, AST_FORMAT_H263}, "video", "H263"},
1653         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
1654         {{1, AST_FORMAT_H264}, "video", "H264"},
1655         {{1, AST_FORMAT_MP4_VIDEO}, "video", "MP4V-ES"},
1656         {{1, AST_FORMAT_T140}, "text", "T140"},
1657 };
1658
1659 /*! 
1660  * \brief Mapping between Asterisk codecs and rtp payload types
1661  *
1662  * Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1663  * also, our own choices for dynamic payload types.  This is our master
1664  * table for transmission 
1665  * 
1666  * See http://www.iana.org/assignments/rtp-parameters for a list of
1667  * assigned values
1668  */
1669 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1670         [0] = {1, AST_FORMAT_ULAW},
1671 #ifdef USE_DEPRECATED_G726
1672         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1673 #endif
1674         [3] = {1, AST_FORMAT_GSM},
1675         [4] = {1, AST_FORMAT_G723_1},
1676         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1677         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1678         [7] = {1, AST_FORMAT_LPC10},
1679         [8] = {1, AST_FORMAT_ALAW},
1680         [9] = {1, AST_FORMAT_G722},
1681         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1682         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1683         [13] = {0, AST_RTP_CN},
1684         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1685         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1686         [18] = {1, AST_FORMAT_G729A},
1687         [19] = {0, AST_RTP_CN},         /* Also used for CN */
1688         [26] = {1, AST_FORMAT_JPEG},
1689         [31] = {1, AST_FORMAT_H261},
1690         [34] = {1, AST_FORMAT_H263},
1691         [97] = {1, AST_FORMAT_ILBC},
1692         [98] = {1, AST_FORMAT_H263_PLUS},
1693         [99] = {1, AST_FORMAT_H264},
1694         [101] = {0, AST_RTP_DTMF},
1695         [102] = {1, AST_FORMAT_T140},   /* Real time text chat */
1696         [103] = {1, AST_FORMAT_H263_PLUS},
1697         [104] = {1, AST_FORMAT_MP4_VIDEO},
1698         [110] = {1, AST_FORMAT_SPEEX},
1699         [111] = {1, AST_FORMAT_G726},
1700         [112] = {1, AST_FORMAT_G726_AAL2},
1701         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1702 };
1703
1704 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
1705 {
1706         int i;
1707
1708         if (!rtp)
1709                 return;
1710
1711         rtp_bridge_lock(rtp);
1712
1713         for (i = 0; i < MAX_RTP_PT; ++i) {
1714                 rtp->current_RTP_PT[i].isAstFormat = 0;
1715                 rtp->current_RTP_PT[i].code = 0;
1716         }
1717
1718         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1719         rtp->rtp_lookup_code_cache_code = 0;
1720         rtp->rtp_lookup_code_cache_result = 0;
1721
1722         rtp_bridge_unlock(rtp);
1723 }
1724
1725 void ast_rtp_pt_default(struct ast_rtp* rtp) 
1726 {
1727         int i;
1728
1729         rtp_bridge_lock(rtp);
1730
1731         /* Initialize to default payload types */
1732         for (i = 0; i < MAX_RTP_PT; ++i) {
1733                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1734                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1735         }
1736
1737         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1738         rtp->rtp_lookup_code_cache_code = 0;
1739         rtp->rtp_lookup_code_cache_result = 0;
1740
1741         rtp_bridge_unlock(rtp);
1742 }
1743
1744 void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
1745 {
1746         unsigned int i;
1747
1748         rtp_bridge_lock(dest);
1749         rtp_bridge_lock(src);
1750
1751         for (i=0; i < MAX_RTP_PT; ++i) {
1752                 dest->current_RTP_PT[i].isAstFormat = 
1753                         src->current_RTP_PT[i].isAstFormat;
1754                 dest->current_RTP_PT[i].code = 
1755                         src->current_RTP_PT[i].code; 
1756         }
1757         dest->rtp_lookup_code_cache_isAstFormat = 0;
1758         dest->rtp_lookup_code_cache_code = 0;
1759         dest->rtp_lookup_code_cache_result = 0;
1760
1761         rtp_bridge_unlock(src);
1762         rtp_bridge_unlock(dest);
1763 }
1764
1765 /*! \brief Get channel driver interface structure */
1766 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1767 {
1768         struct ast_rtp_protocol *cur = NULL;
1769
1770         AST_RWLIST_RDLOCK(&protos);
1771         AST_RWLIST_TRAVERSE(&protos, cur, list) {
1772                 if (cur->type == chan->tech->type)
1773                         break;
1774         }
1775         AST_RWLIST_UNLOCK(&protos);
1776
1777         return cur;
1778 }
1779
1780 int ast_rtp_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
1781 {
1782         // dest = c0, src = c1
1783         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1784         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1785         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1786         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1787         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;
1788         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;
1789         int srccodec, destcodec, nat_active = 0;
1790
1791         /* Lock channels */
1792         ast_channel_lock(c0);
1793         if (c1) {
1794                 while (ast_channel_trylock(c1)) {
1795                         ast_channel_unlock(c0);
1796                         usleep(1);
1797                         ast_channel_lock(c0);
1798                 }
1799         }
1800
1801         /* Find channel driver interfaces */
1802         destpr = get_proto(c0);
1803         if (c1)
1804                 srcpr = get_proto(c1);
1805         if (!destpr) {
1806                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c0->name);
1807                 ast_channel_unlock(c0);
1808                 if (c1)
1809                         ast_channel_unlock(c1);
1810                 return -1;
1811         }
1812         if (!srcpr) {
1813                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>");
1814                 ast_channel_unlock(c0);
1815                 if (c1)
1816                         ast_channel_unlock(c1);
1817                 return -1;
1818         }
1819
1820         /* Get audio, video  and text interface (if native bridge is possible) */
1821         audio_dest_res = destpr->get_rtp_info(c0, &destp);
1822         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED;
1823         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(c0, &tdestp) : AST_RTP_GET_FAILED;
1824         if (srcpr) {
1825                 audio_src_res = srcpr->get_rtp_info(c1, &srcp);
1826                 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED;
1827                 text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(c1, &tsrcp) : AST_RTP_GET_FAILED;
1828         }
1829
1830         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1831         if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1832                 /* Somebody doesn't want to play... */
1833                 ast_channel_unlock(c0);
1834                 if (c1)
1835                         ast_channel_unlock(c1);
1836                 return -1;
1837         }
1838         if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1839                 srccodec = srcpr->get_codec(c1);
1840         else
1841                 srccodec = 0;
1842         if (audio_dest_res == AST_RTP_TRY_NATIVE && destpr->get_codec)
1843                 destcodec = destpr->get_codec(c0);
1844         else
1845                 destcodec = 0;
1846         /* Ensure we have at least one matching codec */
1847         if (!(srccodec & destcodec)) {
1848                 ast_channel_unlock(c0);
1849                 if (c1)
1850                         ast_channel_unlock(c1);
1851                 return 0;
1852         }
1853         /* Consider empty media as non-existant */
1854         if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1855                 srcp = NULL;
1856         if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1857                 nat_active = 1;
1858         /* Bridge media early */
1859         if (destpr->set_rtp_peer(c0, srcp, vsrcp, tsrcp, srccodec, nat_active))
1860                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1861         ast_channel_unlock(c0);
1862         if (c1)
1863                 ast_channel_unlock(c1);
1864         ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1865         return 0;
1866 }
1867
1868 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1869 {
1870         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1871         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1872         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1873         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1874         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;
1875         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; 
1876         int srccodec, destcodec;
1877
1878         /* Lock channels */
1879         ast_channel_lock(dest);
1880         while (ast_channel_trylock(src)) {
1881                 ast_channel_unlock(dest);
1882                 usleep(1);
1883                 ast_channel_lock(dest);
1884         }
1885
1886         /* Find channel driver interfaces */
1887         if (!(destpr = get_proto(dest))) {
1888                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1889                 ast_channel_unlock(dest);
1890                 ast_channel_unlock(src);
1891                 return 0;
1892         }
1893         if (!(srcpr = get_proto(src))) {
1894                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", src->name);
1895                 ast_channel_unlock(dest);
1896                 ast_channel_unlock(src);
1897                 return 0;
1898         }
1899
1900         /* Get audio and video interface (if native bridge is possible) */
1901         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1902         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1903         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(dest, &tdestp) : AST_RTP_GET_FAILED;
1904         audio_src_res = srcpr->get_rtp_info(src, &srcp);
1905         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1906         text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(src, &tsrcp) : AST_RTP_GET_FAILED;
1907
1908         /* Ensure we have at least one matching codec */
1909         if (srcpr->get_codec)
1910                 srccodec = srcpr->get_codec(src);
1911         else
1912                 srccodec = 0;
1913         if (destpr->get_codec)
1914                 destcodec = destpr->get_codec(dest);
1915         else
1916                 destcodec = 0;
1917
1918         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1919         if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE || !(srccodec & destcodec)) {
1920                 /* Somebody doesn't want to play... */
1921                 ast_channel_unlock(dest);
1922                 ast_channel_unlock(src);
1923                 return 0;
1924         }
1925         ast_rtp_pt_copy(destp, srcp);
1926         if (vdestp && vsrcp)
1927                 ast_rtp_pt_copy(vdestp, vsrcp);
1928         if (tdestp && tsrcp)
1929                 ast_rtp_pt_copy(tdestp, tsrcp);
1930         if (media) {
1931                 /* Bridge early */
1932                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, tsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1933                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1934         }
1935         ast_channel_unlock(dest);
1936         ast_channel_unlock(src);
1937         ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1938         return 1;
1939 }
1940
1941 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
1942  * By default, use the well-known value for this type (although it may 
1943  * still be set to a different value by a subsequent "a=rtpmap:" line)
1944  */
1945 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1946 {
1947         if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) 
1948                 return; /* bogus payload type */
1949
1950         rtp_bridge_lock(rtp);
1951         rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1952         rtp_bridge_unlock(rtp);
1953
1954
1955 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1956  * an SDP "a=rtpmap:" line.
1957  */
1958 void ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1959                              char *mimeType, char *mimeSubtype,
1960                              enum ast_rtp_options options)
1961 {
1962         unsigned int i;
1963
1964         if (pt < 0 || pt > MAX_RTP_PT) 
1965                 return; /* bogus payload type */
1966         
1967         rtp_bridge_lock(rtp);
1968
1969         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1970                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1971                     strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1972                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1973                         if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1974                             mimeTypes[i].payloadType.isAstFormat &&
1975                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1976                                 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1977                         break;
1978                 }
1979         }
1980
1981         rtp_bridge_unlock(rtp);
1982
1983         return;
1984
1985
1986 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
1987  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1988 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1989                                  int* astFormats, int* nonAstFormats)
1990 {
1991         int pt;
1992         
1993         rtp_bridge_lock(rtp);
1994         
1995         *astFormats = *nonAstFormats = 0;
1996         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1997                 if (rtp->current_RTP_PT[pt].isAstFormat) {
1998                         *astFormats |= rtp->current_RTP_PT[pt].code;
1999                 } else {
2000                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
2001                 }
2002         }
2003
2004         rtp_bridge_unlock(rtp);
2005         
2006         return;
2007 }
2008
2009 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
2010 {
2011         struct rtpPayloadType result;
2012
2013         result.isAstFormat = result.code = 0;
2014
2015         if (pt < 0 || pt > MAX_RTP_PT) 
2016                 return result; /* bogus payload type */
2017
2018         /* Start with negotiated codecs */
2019         rtp_bridge_lock(rtp);
2020         result = rtp->current_RTP_PT[pt];
2021         rtp_bridge_unlock(rtp);
2022
2023         /* If it doesn't exist, check our static RTP type list, just in case */
2024         if (!result.code) 
2025                 result = static_RTP_PT[pt];
2026
2027         return result;
2028 }
2029
2030 /*! \brief Looks up an RTP code out of our *static* outbound list */
2031 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
2032 {
2033         int pt = 0;
2034
2035         rtp_bridge_lock(rtp);
2036
2037         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
2038                 code == rtp->rtp_lookup_code_cache_code) {
2039                 /* Use our cached mapping, to avoid the overhead of the loop below */
2040                 pt = rtp->rtp_lookup_code_cache_result;
2041                 rtp_bridge_unlock(rtp);
2042                 return pt;
2043         }
2044
2045         /* Check the dynamic list first */
2046         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2047                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
2048                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
2049                         rtp->rtp_lookup_code_cache_code = code;
2050                         rtp->rtp_lookup_code_cache_result = pt;
2051                         rtp_bridge_unlock(rtp);
2052                         return pt;
2053                 }
2054         }
2055
2056         /* Then the static list */
2057         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2058                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
2059                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
2060                         rtp->rtp_lookup_code_cache_code = code;
2061                         rtp->rtp_lookup_code_cache_result = pt;
2062                         rtp_bridge_unlock(rtp);
2063                         return pt;
2064                 }
2065         }
2066
2067         rtp_bridge_unlock(rtp);
2068
2069         return -1;
2070 }
2071
2072 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
2073                                   enum ast_rtp_options options)
2074 {
2075         unsigned int i;
2076
2077         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
2078                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
2079                         if (isAstFormat &&
2080                             (code == AST_FORMAT_G726_AAL2) &&
2081                             (options & AST_RTP_OPT_G726_NONSTANDARD))
2082                                 return "G726-32";
2083                         else
2084                                 return mimeTypes[i].subtype;
2085                 }
2086         }
2087
2088         return "";
2089 }
2090
2091 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
2092                                    const int isAstFormat, enum ast_rtp_options options)
2093 {
2094         int format;
2095         unsigned len;
2096         char *end = buf;
2097         char *start = buf;
2098
2099         if (!buf || !size)
2100                 return NULL;
2101
2102         snprintf(end, size, "0x%x (", capability);
2103
2104         len = strlen(end);
2105         end += len;
2106         size -= len;
2107         start = end;
2108
2109         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
2110                 if (capability & format) {
2111                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
2112
2113                         snprintf(end, size, "%s|", name);
2114                         len = strlen(end);
2115                         end += len;
2116                         size -= len;
2117                 }
2118         }
2119
2120         if (start == end)
2121                 ast_copy_string(start, "nothing)", size); 
2122         else if (size > 1)
2123                 *(end -1) = ')';
2124         
2125         return buf;
2126 }
2127
2128 /*! \brief Open RTP or RTCP socket for a session.
2129  * Print a message on failure. 
2130  */
2131 static int rtp_socket(const char *type)
2132 {
2133         int s = socket(AF_INET, SOCK_DGRAM, 0);
2134         if (s < 0) {
2135                 if (type == NULL)
2136                         type = "RTP/RTCP";
2137                 ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
2138         } else {
2139                 long flags = fcntl(s, F_GETFL);
2140                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
2141 #ifdef SO_NO_CHECK
2142                 if (nochecksums)
2143                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
2144 #endif
2145         }
2146         return s;
2147 }
2148
2149 /*!
2150  * \brief Initialize a new RTCP session.
2151  * 
2152  * \returns The newly initialized RTCP session.
2153  */
2154 static struct ast_rtcp *ast_rtcp_new(void)
2155 {
2156         struct ast_rtcp *rtcp;
2157
2158         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
2159                 return NULL;
2160         rtcp->s = rtp_socket("RTCP");
2161         rtcp->us.sin_family = AF_INET;
2162         rtcp->them.sin_family = AF_INET;
2163
2164         if (rtcp->s < 0) {
2165                 ast_free(rtcp);
2166                 return NULL;
2167         }
2168
2169         return rtcp;
2170 }
2171
2172 /*!
2173  * \brief Initialize a new RTP structure.
2174  *
2175  */
2176 void ast_rtp_new_init(struct ast_rtp *rtp)
2177 {
2178 #ifdef P2P_INTENSE
2179         ast_mutex_init(&rtp->bridge_lock);
2180 #endif
2181
2182         rtp->them.sin_family = AF_INET;
2183         rtp->us.sin_family = AF_INET;
2184         rtp->ssrc = ast_random();
2185         rtp->seqno = ast_random() & 0xffff;
2186         ast_set_flag(rtp, FLAG_HAS_DTMF);
2187
2188         return;
2189 }
2190
2191 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
2192 {
2193         struct ast_rtp *rtp;
2194         int x;
2195         int startplace;
2196         
2197         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
2198                 return NULL;
2199
2200         ast_rtp_new_init(rtp);
2201
2202         rtp->s = rtp_socket("RTP");
2203         if (rtp->s < 0)
2204                 goto fail;
2205         if (sched && rtcpenable) {
2206                 rtp->sched = sched;
2207                 rtp->rtcp = ast_rtcp_new();
2208         }
2209         
2210         /*
2211          * Try to bind the RTP port, x, and possibly the RTCP port, x+1 as well.
2212          * Start from a random (even, by RTP spec) port number, and
2213          * iterate until success or no ports are available.
2214          * Note that the requirement of RTP port being even, or RTCP being the
2215          * next one, cannot be enforced in presence of a NAT box because the
2216          * mapping is not under our control.
2217          */
2218         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
2219         x = x & ~1;             /* make it an even number */
2220         startplace = x;         /* remember the starting point */
2221         /* this is constant across the loop */
2222         rtp->us.sin_addr = addr;
2223         if (rtp->rtcp)
2224                 rtp->rtcp->us.sin_addr = addr;
2225         for (;;) {
2226                 rtp->us.sin_port = htons(x);
2227                 if (!bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) {
2228                         /* bind succeeded, if no rtcp then we are done */
2229                         if (!rtp->rtcp)
2230                                 break;
2231                         /* have rtcp, try to bind it */
2232                         rtp->rtcp->us.sin_port = htons(x + 1);
2233                         if (!bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us)))
2234                                 break;  /* success again, we are really done */
2235                         /*
2236                          * RTCP bind failed, so close and recreate the
2237                          * already bound RTP socket for the next round.
2238                          */
2239                         close(rtp->s);
2240                         rtp->s = rtp_socket("RTP");
2241                         if (rtp->s < 0)
2242                                 goto fail;
2243                 }
2244                 /*
2245                  * If we get here, there was an error in one of the bind()
2246                  * calls, so make sure it is nothing unexpected.
2247                  */
2248                 if (errno != EADDRINUSE) {
2249                         /* We got an error that wasn't expected, abort! */
2250                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
2251                         goto fail;
2252                 }
2253                 /*
2254                  * One of the ports is in use. For the next iteration,
2255                  * increment by two and handle wraparound.
2256                  * If we reach the starting point, then declare failure.
2257                  */
2258                 x += 2;
2259                 if (x > rtpend)
2260                         x = (rtpstart + 1) & ~1;
2261                 if (x == startplace) {
2262                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
2263                         goto fail;
2264                 }
2265         }
2266         rtp->sched = sched;
2267         rtp->io = io;
2268         if (callbackmode) {
2269                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
2270                 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
2271         }
2272         ast_rtp_pt_default(rtp);
2273         return rtp;
2274
2275 fail:
2276         if (rtp->s >= 0)
2277                 close(rtp->s);
2278         if (rtp->rtcp) {
2279                 close(rtp->rtcp->s);
2280                 ast_free(rtp->rtcp);
2281         }
2282         ast_free(rtp);
2283         return NULL;
2284 }
2285
2286 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
2287 {
2288         struct in_addr ia;
2289
2290         memset(&ia, 0, sizeof(ia));
2291         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
2292 }
2293
2294 int ast_rtp_setqos(struct ast_rtp *rtp, int tos, int cos)
2295 {
2296         return ast_netsock_set_qos(rtp->s, tos, cos);
2297 }
2298
2299 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2300 {
2301         rtp->them.sin_port = them->sin_port;
2302         rtp->them.sin_addr = them->sin_addr;
2303         if (rtp->rtcp) {
2304                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
2305                 rtp->rtcp->them.sin_addr = them->sin_addr;
2306         }
2307         rtp->rxseqno = 0;
2308 }
2309
2310 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2311 {
2312         if ((them->sin_family != AF_INET) ||
2313                 (them->sin_port != rtp->them.sin_port) ||
2314                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2315                 them->sin_family = AF_INET;
2316                 them->sin_port = rtp->them.sin_port;
2317                 them->sin_addr = rtp->them.sin_addr;
2318                 return 1;
2319         }
2320         return 0;
2321 }
2322
2323 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2324 {
2325         *us = rtp->us;
2326 }
2327
2328 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2329 {
2330         struct ast_rtp *bridged = NULL;
2331
2332         rtp_bridge_lock(rtp);
2333         bridged = rtp->bridged;
2334         rtp_bridge_unlock(rtp);
2335
2336         return bridged;
2337 }
2338
2339 void ast_rtp_stop(struct ast_rtp *rtp)
2340 {
2341         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
2342                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2343                 rtp->rtcp->schedid = -1;
2344         }
2345
2346         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2347         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2348         if (rtp->rtcp) {
2349                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2350                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2351         }
2352         
2353         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2354 }
2355
2356 void ast_rtp_reset(struct ast_rtp *rtp)
2357 {
2358         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2359         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2360         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2361         rtp->lastts = 0;
2362         rtp->lastdigitts = 0;
2363         rtp->lastrxts = 0;
2364         rtp->lastividtimestamp = 0;
2365         rtp->lastovidtimestamp = 0;
2366         rtp->lastitexttimestamp = 0;
2367         rtp->lastotexttimestamp = 0;
2368         rtp->lasteventseqn = 0;
2369         rtp->lastevent = 0;
2370         rtp->lasttxformat = 0;
2371         rtp->lastrxformat = 0;
2372         rtp->dtmfcount = 0;
2373         rtp->dtmfsamples = 0;
2374         rtp->seqno = 0;
2375         rtp->rxseqno = 0;
2376 }
2377
2378 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual)
2379 {
2380         /*
2381         *ssrc          our ssrc
2382         *themssrc      their ssrc
2383         *lp            lost packets
2384         *rxjitter      our calculated jitter(rx)
2385         *rxcount       no. received packets
2386         *txjitter      reported jitter of the other end
2387         *txcount       transmitted packets
2388         *rlp           remote lost packets
2389         *rtt           round trip time
2390         */
2391
2392         if (qual) {
2393                 qual->local_ssrc = rtp->ssrc;
2394                 qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2395                 qual->local_jitter = rtp->rxjitter;
2396                 qual->local_count = rtp->rxcount;
2397                 qual->remote_ssrc = rtp->themssrc;
2398                 qual->remote_lostpackets = rtp->rtcp->reported_lost;
2399                 qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0;
2400                 qual->remote_count = rtp->txcount;
2401                 qual->rtt = rtp->rtcp->rtt;
2402         }
2403         snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality), "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f", rtp->ssrc, rtp->themssrc, rtp->rtcp->expected_prior - rtp->rtcp->received_prior, rtp->rxjitter, rtp->rxcount, (double)rtp->rtcp->reported_jitter/65536., rtp->txcount, rtp->rtcp->reported_lost, rtp->rtcp->rtt);
2404         
2405         return rtp->rtcp->quality;
2406 }
2407
2408 void ast_rtp_destroy(struct ast_rtp *rtp)
2409 {
2410         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2411                 /*Print some info on the call here */
2412                 ast_verbose("  RTP-stats\n");
2413                 ast_verbose("* Our Receiver:\n");
2414                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
2415                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
2416                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2417                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
2418                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
2419                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2420                 ast_verbose("* Our Sender:\n");
2421                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2422                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2423                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2424                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter / (unsigned int)65536.0);
2425                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2426                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2427         }
2428
2429         manager_event(EVENT_FLAG_REPORTING, "RTPReceiverStat", "SSRC: %u\r\n"
2430                                             "ReceivedPackets: %u\r\n"
2431                                             "LostPackets: %u\r\n"
2432                                             "Jitter: %.4f\r\n"
2433                                             "Transit: %.4f\r\n"
2434                                             "RRCount: %u\r\n",
2435                                             rtp->themssrc,
2436                                             rtp->rxcount,
2437                                             rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2438                                             rtp->rxjitter,
2439                                             rtp->rxtransit,
2440                                             rtp->rtcp->rr_count);
2441         manager_event(EVENT_FLAG_REPORTING, "RTPSenderStat", "SSRC: %u\r\n"
2442                                             "SentPackets: %u\r\n"
2443                                             "LostPackets: %u\r\n"
2444                                             "Jitter: %u\r\n"
2445                                             "SRCount: %u\r\n"
2446                                             "RTT: %f\r\n",
2447                                             rtp->ssrc,
2448                                             rtp->txcount,
2449                                             rtp->rtcp->reported_lost,
2450                                             rtp->rtcp->reported_jitter,
2451                                             rtp->rtcp->sr_count,
2452                                             rtp->rtcp->rtt);
2453         if (rtp->smoother)
2454                 ast_smoother_free(rtp->smoother);
2455         if (rtp->ioid)
2456                 ast_io_remove(rtp->io, rtp->ioid);
2457         if (rtp->s > -1)
2458                 close(rtp->s);
2459         if (rtp->rtcp) {
2460                 if (rtp->rtcp->schedid > 0)
2461                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2462                 close(rtp->rtcp->s);
2463                 ast_free(rtp->rtcp);
2464                 rtp->rtcp=NULL;
2465         }
2466 #ifdef P2P_INTENSE
2467         ast_mutex_destroy(&rtp->bridge_lock);
2468 #endif
2469         ast_free(rtp);
2470 }
2471
2472 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2473 {
2474         struct timeval t;
2475         long ms;
2476         if (ast_tvzero(rtp->txcore)) {
2477                 rtp->txcore = ast_tvnow();
2478                 /* Round to 20ms for nice, pretty timestamps */
2479                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2480         }
2481         /* Use previous txcore if available */
2482         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2483         ms = ast_tvdiff_ms(t, rtp->txcore);
2484         if (ms < 0)
2485                 ms = 0;
2486         /* Use what we just got for next time */
2487         rtp->txcore = t;
2488         return (unsigned int) ms;
2489 }
2490
2491 /*! \brief Send begin frames for DTMF */
2492 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2493 {
2494         unsigned int *rtpheader;
2495         int hdrlen = 12, res = 0, i = 0, payload = 0;
2496         char data[256];
2497
2498         if ((digit <= '9') && (digit >= '0'))
2499                 digit -= '0';
2500         else if (digit == '*')
2501                 digit = 10;
2502         else if (digit == '#')
2503                 digit = 11;
2504         else if ((digit >= 'A') && (digit <= 'D'))
2505                 digit = digit - 'A' + 12;
2506         else if ((digit >= 'a') && (digit <= 'd'))
2507                 digit = digit - 'a' + 12;
2508         else {
2509                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2510                 return 0;
2511         }
2512
2513         /* If we have no peer, return immediately */    
2514         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2515                 return 0;
2516
2517         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2518
2519         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2520         rtp->send_duration = 160;
2521         
2522         /* Get a pointer to the header */
2523         rtpheader = (unsigned int *)data;
2524         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2525         rtpheader[1] = htonl(rtp->lastdigitts);
2526         rtpheader[2] = htonl(rtp->ssrc); 
2527
2528         for (i = 0; i < 2; i++) {
2529                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2530                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2531                 if (res < 0) 
2532                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
2533                                 ast_inet_ntoa(rtp->them.sin_addr),
2534                                 ntohs(rtp->them.sin_port), strerror(errno));
2535                 if (rtp_debug_test_addr(&rtp->them))
2536                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2537                                     ast_inet_ntoa(rtp->them.sin_addr),
2538                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2539                 /* Increment sequence number */
2540                 rtp->seqno++;
2541                 /* Increment duration */
2542                 rtp->send_duration += 160;
2543                 /* Clear marker bit and set seqno */
2544                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2545         }
2546
2547         /* Since we received a begin, we can safely store the digit and disable any compensation */
2548         rtp->sending_digit = 1;
2549         rtp->send_digit = digit;
2550         rtp->send_payload = payload;
2551
2552         return 0;
2553 }
2554
2555 /*! \brief Send continuation frame for DTMF */
2556 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2557 {
2558         unsigned int *rtpheader;
2559         int hdrlen = 12, res = 0;
2560         char data[256];
2561
2562         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2563                 return 0;
2564
2565         /* Setup packet to send */
2566         rtpheader = (unsigned int *)data;
2567         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2568         rtpheader[1] = htonl(rtp->lastdigitts);
2569         rtpheader[2] = htonl(rtp->ssrc);
2570         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2571         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2572         
2573         /* Transmit */
2574         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2575         if (res < 0)
2576                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2577                         ast_inet_ntoa(rtp->them.sin_addr),
2578                         ntohs(rtp->them.sin_port), strerror(errno));
2579         if (rtp_debug_test_addr(&rtp->them))
2580                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2581                             ast_inet_ntoa(rtp->them.sin_addr),
2582                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2583
2584         /* Increment sequence number */
2585         rtp->seqno++;
2586         /* Increment duration */
2587         rtp->send_duration += 160;
2588
2589         return 0;
2590 }
2591
2592 /*! \brief Send end packets for DTMF */
2593 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2594 {
2595         unsigned int *rtpheader;
2596         int hdrlen = 12, res = 0, i = 0;
2597         char data[256];
2598         
2599         /* If no address, then bail out */
2600         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2601                 return 0;
2602         
2603         if ((digit <= '9') && (digit >= '0'))
2604                 digit -= '0';
2605         else if (digit == '*')
2606                 digit = 10;
2607         else if (digit == '#')
2608                 digit = 11;
2609         else if ((digit >= 'A') && (digit <= 'D'))
2610                 digit = digit - 'A' + 12;
2611         else if ((digit >= 'a') && (digit <= 'd'))
2612                 digit = digit - 'a' + 12;
2613         else {
2614                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2615                 return 0;
2616         }
2617
2618         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2619
2620         rtpheader = (unsigned int *)data;
2621         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2622         rtpheader[1] = htonl(rtp->lastdigitts);
2623         rtpheader[2] = htonl(rtp->ssrc);
2624         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2625         /* Set end bit */
2626         rtpheader[3] |= htonl((1 << 23));
2627         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2628         /* Send 3 termination packets */
2629         for (i = 0; i < 3; i++) {
2630                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2631                 if (res < 0)
2632                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2633                                 ast_inet_ntoa(rtp->them.sin_addr),
2634                                 ntohs(rtp->them.sin_port), strerror(errno));
2635                 if (rtp_debug_test_addr(&rtp->them))
2636                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2637                                     ast_inet_ntoa(rtp->them.sin_addr),
2638                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2639         }
2640         rtp->sending_digit = 0;
2641         rtp->send_digit = 0;
2642         /* Increment lastdigitts */
2643         rtp->lastdigitts += 960;
2644         rtp->seqno++;
2645
2646         return res;
2647 }
2648
2649 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2650 int ast_rtcp_send_h261fur(void *data)
2651 {
2652         struct ast_rtp *rtp = data;
2653         int res;
2654
2655         rtp->rtcp->sendfur = 1;
2656         res = ast_rtcp_write(data);
2657         
2658         return res;
2659 }
2660
2661 /*! \brief Send RTCP sender's report */
2662 static int ast_rtcp_write_sr(const void *data)
2663 {
2664         struct ast_rtp *rtp = (struct ast_rtp *)data;
2665         int res;
2666         int len = 0;
2667         struct timeval now;
2668         unsigned int now_lsw;
2669         unsigned int now_msw;
2670         unsigned int *rtcpheader;
2671         unsigned int lost;
2672         unsigned int extended;
2673         unsigned int expected;
2674         unsigned int expected_interval;
2675         unsigned int received_interval;
2676         int lost_interval;
2677         int fraction;
2678         struct timeval dlsr;
2679         char bdata[512];
2680
2681         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2682         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2683                 return 0;
2684         
2685         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2686                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2687                 if (rtp->rtcp->schedid > 0)
2688                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2689                 rtp->rtcp->schedid = -1;
2690                 return 0;
2691         }
2692
2693         gettimeofday(&now, NULL);
2694         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2695         rtcpheader = (unsigned int *)bdata;
2696         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2697         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2698         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2699         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2700         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2701         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2702         len += 28;
2703         
2704         extended = rtp->cycles + rtp->lastrxseqno;
2705         expected = extended - rtp->seedrxseqno + 1;
2706         if (rtp->rxcount > expected) 
2707                 expected += rtp->rxcount - expected;
2708         lost = expected - rtp->rxcount;
2709         expected_interval = expected - rtp->rtcp->expected_prior;
2710         rtp->rtcp->expected_prior = expected;
2711         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2712         rtp->rtcp->received_prior = rtp->rxcount;
2713         lost_interval = expected_interval - received_interval;
2714         if (expected_interval == 0 || lost_interval <= 0)
2715                 fraction = 0;
2716         else
2717                 fraction = (lost_interval << 8) / expected_interval;
2718         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2719         rtcpheader[7] = htonl(rtp->themssrc);
2720         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2721         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2722         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2723         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2724         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2725         len += 24;
2726         
2727         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2728
2729         if (rtp->rtcp->sendfur) {
2730                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2731                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2732                 len += 8;
2733                 rtp->rtcp->sendfur = 0;
2734         }
2735         
2736         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2737         /* it can change mid call, and SDES can't) */
2738         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2739         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2740         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2741         len += 12;
2742         
2743         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2744         if (res < 0) {
2745                 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));
2746                 if (rtp->rtcp->schedid > 0)
2747                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2748                 rtp->rtcp->schedid = -1;
2749                 return 0;
2750         }
2751         
2752         /* FIXME Don't need to get a new one */
2753         gettimeofday(&rtp->rtcp->txlsr, NULL);
2754         rtp->rtcp->sr_count++;
2755
2756         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2757         
2758         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2759                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2760                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2761                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2762                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2763                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2764                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2765                 ast_verbose("  Report block:\n");
2766                 ast_verbose("  Fraction lost: %u\n", fraction);
2767                 ast_verbose("  Cumulative loss: %u\n", lost);
2768                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2769                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2770                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2771         }
2772         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To %s:%d\r\n"
2773                                             "OurSSRC: %u\r\n"
2774                                             "SentNTP: %u.%010u\r\n"
2775                                             "SentRTP: %u\r\n"
2776                                             "SentPackets: %u\r\n"
2777                                             "SentOctets: %u\r\n"
2778                                             "ReportBlock:\r\n"
2779                                             "FractionLost: %u\r\n"
2780                                             "CumulativeLoss: %u\r\n"
2781                                             "IAJitter: %.4f\r\n"
2782                                             "TheirLastSR: %u\r\n"
2783                                             "DLSR: %4.4f (sec)\r\n",
2784                                             ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
2785                                             rtp->ssrc,
2786                                             (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
2787                                             rtp->lastts,
2788                                             rtp->txcount,
2789                                             rtp->txoctetcount,
2790                                             fraction,
2791                                             lost,
2792                                             rtp->rxjitter,
2793                                             rtp->rtcp->themrxlsr,
2794                                             (double)(ntohl(rtcpheader[12])/65536.0));
2795         return res;
2796 }
2797
2798 /*! \brief Send RTCP recipient's report */
2799 static int ast_rtcp_write_rr(const void *data)
2800 {
2801         struct ast_rtp *rtp = (struct ast_rtp *)data;
2802         int res;
2803         int len = 32;
2804         unsigned int lost;
2805         unsigned int extended;
2806         unsigned int expected;
2807         unsigned int expected_interval;
2808         unsigned int received_interval;
2809         int lost_interval;
2810         struct timeval now;
2811         unsigned int *rtcpheader;
2812         char bdata[1024];
2813         struct timeval dlsr;
2814         int fraction;
2815
2816         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2817                 return 0;
2818           
2819         if (!rtp->rtcp->them.sin_addr.s_addr) {
2820                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
2821                 if (rtp->rtcp->schedid > 0)
2822                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2823                 rtp->rtcp->schedid = -1;
2824                 return 0;
2825         }
2826
2827         extended = rtp->cycles + rtp->lastrxseqno;
2828         expected = extended - rtp->seedrxseqno + 1;
2829         lost = expected - rtp->rxcount;
2830         expected_interval = expected - rtp->rtcp->expected_prior;
2831         rtp->rtcp->expected_prior = expected;
2832         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2833         rtp->rtcp->received_prior = rtp->rxcount;
2834         lost_interval = expected_interval - received_interval;
2835         if (expected_interval == 0 || lost_interval <= 0)
2836                 fraction = 0;
2837         else
2838                 fraction = (lost_interval << 8) / expected_interval;
2839         gettimeofday(&now, NULL);
2840         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2841         rtcpheader = (unsigned int *)bdata;
2842         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2843         rtcpheader[1] = htonl(rtp->ssrc);
2844         rtcpheader[2] = htonl(rtp->themssrc);
2845         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2846         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2847         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2848         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2849         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2850
2851         if (rtp->rtcp->sendfur) {
2852                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2853                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2854                 len += 8;
2855                 rtp->rtcp->sendfur = 0;
2856         }
2857
2858         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2859         it can change mid call, and SDES can't) */
2860         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2861         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2862         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2863         len += 12;
2864         
2865         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2866
2867         if (res < 0) {
2868                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2869                 /* Remove the scheduler */
2870                 if (rtp->rtcp->schedid > 0)
2871                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2872                 rtp->rtcp->schedid = -1;
2873                 return 0;
2874         }
2875
2876         rtp->rtcp->rr_count++;
2877
2878         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2879                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2880                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2881                         "  IA jitter: %.4f\n" 
2882                         "  Their last SR: %u\n" 
2883                         "  DLSR: %4.4f (sec)\n\n",
2884                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2885                         ntohs(rtp->rtcp->them.sin_port),
2886                         rtp->ssrc, rtp->themssrc, fraction, lost,
2887                         rtp->rxjitter,
2888                         rtp->rtcp->themrxlsr,
2889                         (double)(ntohl(rtcpheader[7])/65536.0));
2890         }
2891
2892         return res;
2893 }
2894
2895 /*! \brief Write and RTCP packet to the far end
2896  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2897  * RR is sent if we have not sent any rtp packets in the previous interval */
2898 static int ast_rtcp_write(const void *data)
2899 {
2900         struct ast_rtp *rtp = (struct ast_rtp *)data;
2901         int res;
2902         
2903         if (!rtp || !rtp->rtcp)
2904                 return 0;
2905
2906         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2907                 res = ast_rtcp_write_sr(data);
2908         else
2909                 res = ast_rtcp_write_rr(data);
2910         
2911         return res;
2912 }
2913
2914 /*! \brief generate comfort noice (CNG) */
2915 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2916 {
2917         unsigned int *rtpheader;
2918         int hdrlen = 12;
2919         int res;
2920         int payload;
2921         char data[256];
2922         level = 127 - (level & 0x7f);
2923         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2924
2925         /* If we have no peer, return immediately */    
2926         if (!rtp->them.sin_addr.s_addr)
2927                 return 0;
2928
2929         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2930
2931         /* Get a pointer to the header */
2932         rtpheader = (unsigned int *)data;
2933         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2934         rtpheader[1] = htonl(rtp->lastts);
2935         rtpheader[2] = htonl(rtp->ssrc); 
2936         data[12] = level;
2937         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2938                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2939                 if (res <0) 
2940                         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));
2941                 if (rtp_debug_test_addr(&rtp->them))
2942                         ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2943                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2944                    
2945         }
2946         return 0;
2947 }
2948
2949 /*! \brief Write RTP packet with audio or video media frames into UDP packet */
2950 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2951 {
2952         unsigned char *rtpheader;
2953         int hdrlen = 12;
2954         int res;
2955         unsigned int ms;
2956         int pred;
2957         int mark = 0;
2958
2959         ms = calc_txstamp(rtp, &f->delivery);
2960         /* Default prediction */
2961         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2962                 pred = rtp->lastts + f->samples;
2963
2964                 /* Re-calculate last TS */
2965                 rtp->lastts = rtp->lastts + ms * 8;
2966                 if (ast_tvzero(f->delivery)) {
2967                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2968                            and if so, go with our prediction */
2969                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2970                                 rtp->lastts = pred;
2971                         else {
2972                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2973                                 mark = 1;
2974                         }
2975                 }
2976         } else if(f->subclass < AST_FORMAT_MAX_VIDEO) {
2977                 mark = f->subclass & 0x1;
2978                 pred = rtp->lastovidtimestamp + f->samples;
2979                 /* Re-calculate last TS */
2980                 rtp->lastts = rtp->lastts + ms * 90;
2981                 /* If it's close to our prediction, go for it */
2982                 if (ast_tvzero(f->delivery)) {
2983                         if (abs(rtp->lastts - pred) < 7200) {
2984                                 rtp->lastts = pred;
2985                                 rtp->lastovidtimestamp += f->samples;
2986                         } else {
2987                                 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);
2988                                 rtp->lastovidtimestamp = rtp->lastts;
2989                         }
2990                 }
2991         } else {
2992                 pred = rtp->lastotexttimestamp + f->samples;
2993                 /* Re-calculate last TS */
2994                 rtp->lastts = rtp->lastts + ms * 90;
2995                 /* If it's close to our prediction, go for it */
2996                 if (ast_tvzero(f->delivery)) {
2997                         if (abs(rtp->lastts - pred) < 7200) {
2998                                 rtp->lastts = pred;
2999                                 rtp->lastotexttimestamp += f->samples;
3000                         } else {
3001                                 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);
3002                                 rtp->lastotexttimestamp = rtp->lastts;
3003                         }
3004                 }
3005         }
3006         /* If the timestamp for non-digit packets has moved beyond the timestamp
3007            for digits, update the digit timestamp.
3008         */
3009         if (rtp->lastts > rtp->lastdigitts)
3010                 rtp->lastdigitts = rtp->lastts;
3011
3012         if (f->has_timing_info)
3013                 rtp->lastts = f->ts * 8;
3014
3015         /* Get a pointer to the header */
3016         rtpheader = (unsigned char *)(f->data - hdrlen);
3017
3018         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
3019         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
3020         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
3021
3022         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
3023                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
3024                 if (res <0) {
3025                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
3026                                 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));
3027                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
3028                                 /* Only give this error message once if we are not RTP debugging */
3029                                 if (option_debug || rtpdebug)
3030                                         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));
3031                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
3032                         }
3033                 } else {
3034                         rtp->txcount++;
3035                         rtp->txoctetcount +=(res - hdrlen);
3036                         
3037                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
3038                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
3039                 }
3040                                 
3041                 if (rtp_debug_test_addr(&rtp->them))
3042                         ast_verbose("Sent RTP packet to      %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
3043                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
3044         }
3045
3046         rtp->seqno++;
3047
3048         return 0;
3049 }
3050
3051 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
3052 {
3053         int x;
3054         for (x = 0; x < 32; x++) {  /* Ugly way */
3055                 rtp->pref.order[x] = prefs->order[x];
3056                 rtp->pref.framing[x] = prefs->framing[x];
3057         }
3058         if (rtp->smoother)
3059                 ast_smoother_free(rtp->smoother);
3060         rtp->smoother = NULL;
3061         return 0;
3062 }
3063
3064 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
3065 {
3066         return &rtp->pref;
3067 }
3068
3069 int ast_rtp_codec_getformat(int pt)
3070 {
3071         if (pt < 0 || pt > MAX_RTP_PT)
3072                 return 0; /* bogus payload type */
3073
3074         if (static_RTP_PT[pt].isAstFormat)
3075                 return static_RTP_PT[pt].code;
3076         else
3077                 return 0;
3078 }
3079
3080 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
3081 {
3082         struct ast_frame *f;
3083         int codec;
3084         int hdrlen = 12;
3085         int subclass;
3086         
3087
3088         /* If we have no peer, return immediately */    
3089         if (!rtp->them.sin_addr.s_addr)
3090                 return 0;
3091
3092         /* If there is no data length, return immediately */
3093         if (!_f->datalen) 
3094                 return 0;
3095         
3096         /* Make sure we have enough space for RTP header */
3097         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO) && (_f->frametype != AST_FRAME_TEXT)) {
3098                 ast_log(LOG_WARNING, "RTP can only send voice, video and text\n");
3099                 return -1;
3100         }
3101
3102         /* The bottom bit of a video subclass contains the marker bit */
3103         subclass = _f->subclass;
3104         if (_f->frametype == AST_FRAME_VIDEO)
3105                 subclass &= ~0x1;
3106
3107         codec = ast_rtp_lookup_code(rtp, 1, subclass);
3108         if (codec < 0) {
3109                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
3110                 return -1;
3111         }
3112
3113         if (rtp->lasttxformat != subclass) {
3114                 /* New format, reset the smoother */
3115                 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
3116                 rtp->lasttxformat = subclass;
3117                 if (rtp->smoother)
3118                         ast_smoother_free(rtp->smoother);
3119                 rtp->smoother = NULL;
3120         }
3121
3122         if (!rtp->smoother && subclass != AST_FORMAT_SPEEX) {
3123                 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
3124                 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
3125                         if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
3126                                 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));
3127                                 return -1;
3128                         }
3129                         if (fmt.flags)
3130                                 ast_smoother_set_flags(rtp->smoother, fmt.flags);
3131                         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));
3132                 }
3133         }
3134         if (rtp->smoother) {
3135                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
3136                         ast_smoother_feed_be(rtp->smoother, _f);
3137                 } else {
3138                         ast_smoother_feed(rtp->smoother, _f);
3139                 }
3140
3141          &