Don't swap channel priority if using epoll as polling should/will only happen off...
[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         }
965         
966         if (ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
967                 if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
968                         rtp->resp = resp;
969                         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
970                         f->len = 0;
971                         rtp->lastevent = timestamp;
972                 }
973         } else {
974                 if ((!(rtp->resp) && (!(event_end & 0x80))) || (rtp->resp && rtp->resp != resp)) {
975                         rtp->resp = resp;
976                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
977                 } else if ((event_end & 0x80) && (rtp->lastevent != seqno) && rtp->resp) {
978                         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
979                         f->len = ast_tvdiff_ms(ast_samp2tv(samples, 8000), ast_tv(0, 0)); /* XXX hard coded 8kHz */
980                         rtp->resp = 0;
981                         rtp->lastevent = seqno;
982                 }
983         }
984
985         rtp->dtmfcount = dtmftimeout;
986         rtp->dtmfsamples = samples;
987
988         return f;
989 }
990
991 /*!
992  * \brief Process Comfort Noise RTP.
993  * 
994  * This is incomplete at the moment.
995  * 
996 */
997 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
998 {
999         struct ast_frame *f = NULL;
1000         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
1001            totally help us out becuase we don't have an engine to keep it going and we are not
1002            guaranteed to have it every 20ms or anything */
1003         if (rtpdebug)
1004                 ast_debug(0, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
1005
1006         if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
1007                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
1008                         ast_inet_ntoa(rtp->them.sin_addr));
1009                 ast_set_flag(rtp, FLAG_3389_WARNING);
1010         }
1011         
1012         /* Must have at least one byte */
1013         if (!len)
1014                 return NULL;
1015         if (len < 24) {
1016                 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
1017                 rtp->f.datalen = len - 1;
1018                 rtp->f.offset = AST_FRIENDLY_OFFSET;
1019                 memcpy(rtp->f.data, data + 1, len - 1);
1020         } else {
1021                 rtp->f.data = NULL;
1022                 rtp->f.offset = 0;
1023                 rtp->f.datalen = 0;
1024         }
1025         rtp->f.frametype = AST_FRAME_CNG;
1026         rtp->f.subclass = data[0] & 0x7f;
1027         rtp->f.datalen = len - 1;
1028         rtp->f.samples = 0;
1029         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
1030         f = &rtp->f;
1031         return f;
1032 }
1033
1034 static int rtpread(int *id, int fd, short events, void *cbdata)
1035 {
1036         struct ast_rtp *rtp = cbdata;
1037         struct ast_frame *f;
1038         f = ast_rtp_read(rtp);
1039         if (f) {
1040                 if (rtp->callback)
1041                         rtp->callback(rtp, f, rtp->data);
1042         }
1043         return 1;
1044 }
1045
1046 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
1047 {
1048         socklen_t len;
1049         int position, i, packetwords;
1050         int res;
1051         struct sockaddr_in sin;
1052         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
1053         unsigned int *rtcpheader;
1054         int pt;
1055         struct timeval now;
1056         unsigned int length;
1057         int rc;
1058         double rttsec;
1059         uint64_t rtt = 0;
1060         unsigned int dlsr;
1061         unsigned int lsr;
1062         unsigned int msw;
1063         unsigned int lsw;
1064         unsigned int comp;
1065         struct ast_frame *f = &ast_null_frame;
1066         
1067         if (!rtp || !rtp->rtcp)
1068                 return &ast_null_frame;
1069
1070         len = sizeof(sin);
1071         
1072         res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
1073                                         0, (struct sockaddr *)&sin, &len);
1074         rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
1075         
1076         if (res < 0) {
1077                 if (errno == EBADF)
1078                         CRASH;
1079                 if (errno != EAGAIN) {
1080                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
1081                         return NULL;
1082                 }
1083                 return &ast_null_frame;
1084         }
1085
1086         packetwords = res / 4;
1087         
1088         if (rtp->nat) {
1089                 /* Send to whoever sent to us */
1090                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1091                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
1092                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1093                         if (option_debug || rtpdebug)
1094                                 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));
1095                 }
1096         }
1097
1098         ast_debug(1, "Got RTCP report of %d bytes\n", res);
1099
1100         /* Process a compound packet */
1101         position = 0;
1102         while (position < packetwords) {
1103                 i = position;
1104                 length = ntohl(rtcpheader[i]);
1105                 pt = (length & 0xff0000) >> 16;
1106                 rc = (length & 0x1f000000) >> 24;
1107                 length &= 0xffff;
1108     
1109                 if ((i + length) > packetwords) {
1110                         ast_log(LOG_WARNING, "RTCP Read too short\n");
1111                         return &ast_null_frame;
1112                 }
1113                 
1114                 if (rtcp_debug_test_addr(&sin)) {
1115                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
1116                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
1117                         ast_verbose("Reception reports: %d\n", rc);
1118                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
1119                 }
1120     
1121                 i += 2; /* Advance past header and ssrc */
1122                 
1123                 switch (pt) {
1124                 case RTCP_PT_SR:
1125                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
1126                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
1127                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
1128                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
1129     
1130                         if (rtcp_debug_test_addr(&sin)) {
1131                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
1132                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
1133                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
1134                         }
1135                         i += 5;
1136                         if (rc < 1)
1137                                 break;
1138                         /* Intentional fall through */
1139                 case RTCP_PT_RR:
1140                         /* Don't handle multiple reception reports (rc > 1) yet */
1141                         /* Calculate RTT per RFC */
1142                         gettimeofday(&now, NULL);
1143                         timeval2ntp(now, &msw, &lsw);
1144                         if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
1145                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
1146                                 lsr = ntohl(rtcpheader[i + 4]);
1147                                 dlsr = ntohl(rtcpheader[i + 5]);
1148                                 rtt = comp - lsr - dlsr;
1149
1150                                 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
1151                                    sess->ee_delay = (eedelay * 1000) / 65536; */
1152                                 if (rtt < 4294) {
1153                                     rtt = (rtt * 1000000) >> 16;
1154                                 } else {
1155                                     rtt = (rtt * 1000) >> 16;
1156                                     rtt *= 1000;
1157                                 }
1158                                 rtt = rtt / 1000.;
1159                                 rttsec = rtt / 1000.;
1160
1161                                 if (comp - dlsr >= lsr) {
1162                                         rtp->rtcp->accumulated_transit += rttsec;
1163                                         rtp->rtcp->rtt = rttsec;
1164                                         if (rtp->rtcp->maxrtt<rttsec)
1165                                                 rtp->rtcp->maxrtt = rttsec;
1166                                         if (rtp->rtcp->minrtt>rttsec)
1167                                                 rtp->rtcp->minrtt = rttsec;
1168                                 } else if (rtcp_debug_test_addr(&sin)) {
1169                                         ast_verbose("Internal RTCP NTP clock skew detected: "
1170                                                            "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
1171                                                            "diff=%d\n",
1172                                                            lsr, comp, dlsr, dlsr / 65536,
1173                                                            (dlsr % 65536) * 1000 / 65536,
1174                                                            dlsr - (comp - lsr));
1175                                 }
1176                         }
1177
1178                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
1179                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
1180                         if (rtcp_debug_test_addr(&sin)) {
1181                                 ast_verbose("  Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
1182                                 ast_verbose("  Packets lost so far: %d\n", rtp->rtcp->reported_lost);
1183                                 ast_verbose("  Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
1184                                 ast_verbose("  Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
1185                                 ast_verbose("  Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
1186                                 ast_verbose("  Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
1187                                 ast_verbose("  DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
1188                                 if (rtt)
1189                                         ast_verbose("  RTT: %lu(sec)\n", (unsigned long) rtt);
1190                         }
1191                         if (rtt) {
1192                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1193                                                                     "PT: %d(%s)\r\n"
1194                                                                     "ReceptionReports: %d\r\n"
1195                                                                     "SenderSSRC: %u\r\n"
1196                                                                     "FractionLost: %ld\r\n"
1197                                                                     "PacketsLost: %d\r\n"
1198                                                                     "HighestSequence: %ld\r\n"
1199                                                                     "SequenceNumberCycles: %ld\r\n"
1200                                                                     "IAJitter: %u\r\n"
1201                                                                     "LastSR: %lu.%010lu\r\n"
1202                                                                     "DLSR: %4.4f(sec)\r\n"
1203                                                                     "RTT: %llu(sec)\r\n",
1204                                                                     ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1205                                                                     pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1206                                                                     rc,
1207                                                                     rtcpheader[i + 1],
1208                                                                     (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1209                                                                     rtp->rtcp->reported_lost,
1210                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1211                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1212                                                                     rtp->rtcp->reported_jitter,
1213                                                                     (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1214                                                                     ntohl(rtcpheader[i + 5])/65536.0,
1215                                                                     (unsigned long long)rtt);
1216                         } else {
1217                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1218                                                                     "PT: %d(%s)\r\n"
1219                                                                     "ReceptionReports: %d\r\n"
1220                                                                     "SenderSSRC: %u\r\n"
1221                                                                     "FractionLost: %ld\r\n"
1222                                                                     "PacketsLost: %d\r\n"
1223                                                                     "HighestSequence: %ld\r\n"
1224                                                                     "SequenceNumberCycles: %ld\r\n"
1225                                                                     "IAJitter: %u\r\n"
1226                                                                     "LastSR: %lu.%010lu\r\n"
1227                                                                     "DLSR: %4.4f(sec)\r\n",
1228                                                                     ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1229                                                                     pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1230                                                                     rc,
1231                                                                     rtcpheader[i + 1],
1232                                                                     (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1233                                                                     rtp->rtcp->reported_lost,
1234                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1235                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1236                                                                     rtp->rtcp->reported_jitter,
1237                                                                     (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
1238                                                                     ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1239                                                                     ntohl(rtcpheader[i + 5])/65536.0);
1240                         }
1241                         break;
1242                 case RTCP_PT_FUR:
1243                         if (rtcp_debug_test_addr(&sin))
1244                                 ast_verbose("Received an RTCP Fast Update Request\n");
1245                         rtp->f.frametype = AST_FRAME_CONTROL;
1246                         rtp->f.subclass = AST_CONTROL_VIDUPDATE;
1247                         rtp->f.datalen = 0;
1248                         rtp->f.samples = 0;
1249                         rtp->f.mallocd = 0;
1250                         rtp->f.src = "RTP";
1251                         f = &rtp->f;
1252                         break;
1253                 case RTCP_PT_SDES:
1254                         if (rtcp_debug_test_addr(&sin))
1255                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1256                         break;
1257                 case RTCP_PT_BYE:
1258                         if (rtcp_debug_test_addr(&sin))
1259                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1260                         break;
1261                 default:
1262                         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));
1263                         break;
1264                 }
1265                 position += (length + 1);
1266         }
1267                         
1268         return f;
1269 }
1270
1271 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1272 {
1273         struct timeval now;
1274         double transit;
1275         double current_time;
1276         double d;
1277         double dtv;
1278         double prog;
1279         
1280         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1281                 gettimeofday(&rtp->rxcore, NULL);
1282                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1283                 /* map timestamp to a real time */
1284                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1285                 rtp->rxcore.tv_sec -= timestamp / 8000;
1286                 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
1287                 /* Round to 0.1ms for nice, pretty timestamps */
1288                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1289                 if (rtp->rxcore.tv_usec < 0) {
1290                         /* Adjust appropriately if necessary */
1291                         rtp->rxcore.tv_usec += 1000000;
1292                         rtp->rxcore.tv_sec -= 1;
1293                 }
1294         }
1295
1296         gettimeofday(&now,NULL);
1297         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1298         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
1299         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
1300         if (tv->tv_usec >= 1000000) {
1301                 tv->tv_usec -= 1000000;
1302                 tv->tv_sec += 1;
1303         }
1304         prog = (double)((timestamp-rtp->seedrxts)/8000.);
1305         dtv = (double)rtp->drxcore + (double)(prog);
1306         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1307         transit = current_time - dtv;
1308         d = transit - rtp->rxtransit;
1309         rtp->rxtransit = transit;
1310         if (d<0)
1311                 d=-d;
1312         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1313         if (rtp->rtcp && rtp->rxjitter > rtp->rtcp->maxrxjitter)
1314                 rtp->rtcp->maxrxjitter = rtp->rxjitter;
1315         if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1316                 rtp->rtcp->minrxjitter = rtp->rxjitter;
1317 }
1318
1319 /*! \brief Perform a Packet2Packet RTP write */
1320 static int bridge_p2p_rtp_write(struct ast_rtp *rtp, struct ast_rtp *bridged, unsigned int *rtpheader, int len, int hdrlen)
1321 {
1322         int res = 0, payload = 0, bridged_payload = 0, mark;
1323         struct rtpPayloadType rtpPT;
1324         int reconstruct = ntohl(rtpheader[0]);
1325
1326         /* Get fields from packet */
1327         payload = (reconstruct & 0x7f0000) >> 16;
1328         mark = (((reconstruct & 0x800000) >> 23) != 0);
1329
1330         /* Check what the payload value should be */
1331         rtpPT = ast_rtp_lookup_pt(rtp, payload);
1332
1333         /* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
1334         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) && !rtpPT.isAstFormat && rtpPT.code == AST_RTP_DTMF)
1335                 return -1;
1336
1337         /* Otherwise adjust bridged payload to match */
1338         bridged_payload = ast_rtp_lookup_code(bridged, rtpPT.isAstFormat, rtpPT.code);
1339
1340         /* If the mark bit has not been sent yet... do it now */
1341         if (!ast_test_flag(rtp, FLAG_P2P_SENT_MARK)) {
1342                 mark = 1;
1343                 ast_set_flag(rtp, FLAG_P2P_SENT_MARK);
1344         }
1345
1346         /* Reconstruct part of the packet */
1347         reconstruct &= 0xFF80FFFF;
1348         reconstruct |= (bridged_payload << 16);
1349         reconstruct |= (mark << 23);
1350         rtpheader[0] = htonl(reconstruct);
1351
1352         /* Send the packet back out */
1353         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&bridged->them, sizeof(bridged->them));
1354         if (res < 0) {
1355                 if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1356                         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));
1357                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1358                         if (option_debug || rtpdebug)
1359                                 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));
1360                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1361                 }
1362                 return 0;
1363         } else if (rtp_debug_test_addr(&bridged->them))
1364                         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);
1365
1366         return 0;
1367 }
1368
1369 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
1370 {
1371         int res;
1372         struct sockaddr_in sin;
1373         socklen_t len;
1374         unsigned int seqno;
1375         int version;
1376         int payloadtype;
1377         int hdrlen = 12;
1378         int padding;
1379         int mark;
1380         int ext;
1381         int cc;
1382         unsigned int ssrc;
1383         unsigned int timestamp;
1384         unsigned int *rtpheader;
1385         struct rtpPayloadType rtpPT;
1386         struct ast_rtp *bridged = NULL;
1387         
1388         /* If time is up, kill it */
1389         if (rtp->sending_digit)
1390                 ast_rtp_senddigit_continuation(rtp);
1391
1392         len = sizeof(sin);
1393         
1394         /* Cache where the header will go */
1395         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
1396                                         0, (struct sockaddr *)&sin, &len);
1397
1398         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
1399         if (res < 0) {
1400                 if (errno == EBADF)
1401                         CRASH;
1402                 if (errno != EAGAIN) {
1403                         ast_log(LOG_WARNING, "RTP Read error: %s.  Hanging up.\n", strerror(errno));
1404                         return NULL;
1405                 }
1406                 return &ast_null_frame;
1407         }
1408         
1409         if (res < hdrlen) {
1410                 ast_log(LOG_WARNING, "RTP Read too short\n");
1411                 return &ast_null_frame;
1412         }
1413
1414         /* Get fields */
1415         seqno = ntohl(rtpheader[0]);
1416
1417         /* Check RTP version */
1418         version = (seqno & 0xC0000000) >> 30;
1419         if (!version) {
1420                 /* If the two high bits are 0, this might be a
1421                  * STUN message, so process it. stun_handle_packet()
1422                  * answers to requests, and it returns STUN_ACCEPT
1423                  * if the request is valid.
1424                  */
1425                 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == STUN_ACCEPT) &&
1426                         (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
1427                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
1428                 }
1429                 return &ast_null_frame;
1430         }
1431
1432 #if 0   /* Allow to receive RTP stream with closed transmission path */
1433         /* If we don't have the other side's address, then ignore this */
1434         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
1435                 return &ast_null_frame;
1436 #endif
1437
1438         /* Send to whoever send to us if NAT is turned on */
1439         if (rtp->nat) {
1440                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1441                     (rtp->them.sin_port != sin.sin_port)) {
1442                         rtp->them = sin;
1443                         if (rtp->rtcp) {
1444                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1445                                 rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1);
1446                         }
1447                         rtp->rxseqno = 0;
1448                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1449                         if (option_debug || rtpdebug)
1450                                 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));
1451                 }
1452         }
1453
1454         /* If we are bridged to another RTP stream, send direct */
1455         if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen))
1456                 return &ast_null_frame;
1457
1458         if (version != 2)
1459                 return &ast_null_frame;
1460
1461         payloadtype = (seqno & 0x7f0000) >> 16;
1462         padding = seqno & (1 << 29);
1463         mark = seqno & (1 << 23);
1464         ext = seqno & (1 << 28);
1465         cc = (seqno & 0xF000000) >> 24;
1466         seqno &= 0xffff;
1467         timestamp = ntohl(rtpheader[1]);
1468         ssrc = ntohl(rtpheader[2]);
1469         
1470         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1471                 if (option_debug || rtpdebug)
1472                         ast_debug(0, "Forcing Marker bit, because SSRC has changed\n");
1473                 mark = 1;
1474         }
1475
1476         rtp->rxssrc = ssrc;
1477         
1478         if (padding) {
1479                 /* Remove padding bytes */
1480                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1481         }
1482         
1483         if (cc) {
1484                 /* CSRC fields present */
1485                 hdrlen += cc*4;
1486         }
1487
1488         if (ext) {
1489                 /* RTP Extension present */
1490                 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
1491                 hdrlen += 4;
1492                 if (option_debug) {
1493                         int profile;
1494                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1495                         if (profile == 0x505a)
1496                                 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1497                         else
1498                                 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
1499                 }
1500         }
1501
1502         if (res < hdrlen) {
1503                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
1504                 return &ast_null_frame;
1505         }
1506
1507         rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1508
1509         if (rtp->rxcount==1) {
1510                 /* This is the first RTP packet successfully received from source */
1511                 rtp->seedrxseqno = seqno;
1512         }
1513
1514         /* Do not schedule RR if RTCP isn't run */
1515         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
1516                 /* Schedule transmission of Receiver Report */
1517                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1518         }
1519         if ( (int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
1520                 rtp->cycles += RTP_SEQ_MOD;
1521
1522         rtp->lastrxseqno = seqno;
1523         
1524         if (rtp->themssrc==0)
1525                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
1526         
1527         if (rtp_debug_test_addr(&sin))
1528                 ast_verbose("Got  RTP packet from    %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1529                         ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
1530
1531         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
1532         if (!rtpPT.isAstFormat) {
1533                 struct ast_frame *f = NULL;
1534
1535                 /* This is special in-band data that's not one of our codecs */
1536                 if (rtpPT.code == AST_RTP_DTMF) {
1537                         /* It's special -- rfc2833 process it */
1538                         if (rtp_debug_test_addr(&sin)) {
1539                                 unsigned char *data;
1540                                 unsigned int event;
1541                                 unsigned int event_end;
1542                                 unsigned int duration;
1543                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
1544                                 event = ntohl(*((unsigned int *)(data)));
1545                                 event >>= 24;
1546                                 event_end = ntohl(*((unsigned int *)(data)));
1547                                 event_end <<= 8;
1548                                 event_end >>= 24;
1549                                 duration = ntohl(*((unsigned int *)(data)));
1550                                 duration &= 0xFFFF;
1551                                 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);
1552                         }
1553                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp);
1554                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
1555                         /* It's really special -- process it the Cisco way */
1556                         if (rtp->lastevent <= seqno || (rtp->lastevent >= 65530 && seqno <= 6)) {
1557                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1558                                 rtp->lastevent = seqno;
1559                         }
1560                 } else if (rtpPT.code == AST_RTP_CN) {
1561                         /* Comfort Noise */
1562                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1563                 } else {
1564                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr));
1565                 }
1566                 return f ? f : &ast_null_frame;
1567         }
1568         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
1569         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;
1570
1571         if (!rtp->lastrxts)
1572                 rtp->lastrxts = timestamp;
1573
1574         rtp->rxseqno = seqno;
1575
1576         /* Record received timestamp as last received now */
1577         rtp->lastrxts = timestamp;
1578
1579         rtp->f.mallocd = 0;
1580         rtp->f.datalen = res - hdrlen;
1581         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
1582         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
1583         rtp->f.seqno = seqno;
1584         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
1585                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
1586                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
1587                         ast_frame_byteswap_be(&rtp->f);
1588                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
1589                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1590                 rtp->f.has_timing_info = 1;
1591                 rtp->f.ts = timestamp / 8;
1592                 rtp->f.len = rtp->f.samples / 8;
1593         } else if(rtp->f.subclass < AST_FORMAT_MAX_VIDEO) {
1594                 /* Video -- samples is # of samples vs. 90000 */
1595                 if (!rtp->lastividtimestamp)
1596                         rtp->lastividtimestamp = timestamp;
1597                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
1598                 rtp->lastividtimestamp = timestamp;
1599                 rtp->f.delivery.tv_sec = 0;
1600                 rtp->f.delivery.tv_usec = 0;
1601                 /* Pass the RTP marker bit as bit 0 in the subclass field.
1602                  * This is ok because subclass is actually a bitmask, and
1603                  * the low bits represent audio formats, that are not
1604                  * involved here since we deal with video.
1605                  */
1606                 if (mark)
1607                         rtp->f.subclass |= 0x1;
1608         } else {
1609                 /* TEXT -- samples is # of samples vs. 1000 */
1610                 if (!rtp->lastitexttimestamp)
1611                         rtp->lastitexttimestamp = timestamp;
1612                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
1613                 rtp->lastitexttimestamp = timestamp;
1614                 rtp->f.delivery.tv_sec = 0;
1615                 rtp->f.delivery.tv_usec = 0;
1616         }
1617         rtp->f.src = "RTP";
1618         return &rtp->f;
1619 }
1620
1621 /* The following array defines the MIME Media type (and subtype) for each
1622    of our codecs, or RTP-specific data type. */
1623 static struct {
1624         struct rtpPayloadType payloadType;
1625         char* type;
1626         char* subtype;
1627 } mimeTypes[] = {
1628         {{1, AST_FORMAT_G723_1}, "audio", "G723"},
1629         {{1, AST_FORMAT_GSM}, "audio", "GSM"},
1630         {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
1631         {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
1632         {{1, AST_FORMAT_G726}, "audio", "G726-32"},
1633         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
1634         {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
1635         {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
1636         {{1, AST_FORMAT_G729A}, "audio", "G729"},
1637         {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
1638         {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
1639         {{1, AST_FORMAT_G722}, "audio", "G722"},
1640         {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32"},
1641         {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
1642         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
1643         {{0, AST_RTP_CN}, "audio", "CN"},
1644         {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
1645         {{1, AST_FORMAT_PNG}, "video", "PNG"},
1646         {{1, AST_FORMAT_H261}, "video", "H261"},
1647         {{1, AST_FORMAT_H263}, "video", "H263"},
1648         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
1649         {{1, AST_FORMAT_H264}, "video", "H264"},
1650         {{1, AST_FORMAT_MP4_VIDEO}, "video", "MP4V-ES"},
1651         {{1, AST_FORMAT_T140}, "text", "T140"},
1652 };
1653
1654 /*! 
1655  * \brief Mapping between Asterisk codecs and rtp payload types
1656  *
1657  * Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1658  * also, our own choices for dynamic payload types.  This is our master
1659  * table for transmission 
1660  * 
1661  * See http://www.iana.org/assignments/rtp-parameters for a list of
1662  * assigned values
1663  */
1664 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1665         [0] = {1, AST_FORMAT_ULAW},
1666 #ifdef USE_DEPRECATED_G726
1667         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1668 #endif
1669         [3] = {1, AST_FORMAT_GSM},
1670         [4] = {1, AST_FORMAT_G723_1},
1671         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1672         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1673         [7] = {1, AST_FORMAT_LPC10},
1674         [8] = {1, AST_FORMAT_ALAW},
1675         [9] = {1, AST_FORMAT_G722},
1676         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1677         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1678         [13] = {0, AST_RTP_CN},
1679         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1680         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1681         [18] = {1, AST_FORMAT_G729A},
1682         [19] = {0, AST_RTP_CN},         /* Also used for CN */
1683         [26] = {1, AST_FORMAT_JPEG},
1684         [31] = {1, AST_FORMAT_H261},
1685         [34] = {1, AST_FORMAT_H263},
1686         [97] = {1, AST_FORMAT_ILBC},
1687         [98] = {1, AST_FORMAT_H263_PLUS},
1688         [99] = {1, AST_FORMAT_H264},
1689         [101] = {0, AST_RTP_DTMF},
1690         [102] = {1, AST_FORMAT_T140},   /* Real time text chat */
1691         [103] = {1, AST_FORMAT_H263_PLUS},
1692         [104] = {1, AST_FORMAT_MP4_VIDEO},
1693         [110] = {1, AST_FORMAT_SPEEX},
1694         [111] = {1, AST_FORMAT_G726},
1695         [112] = {1, AST_FORMAT_G726_AAL2},
1696         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1697 };
1698
1699 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
1700 {
1701         int i;
1702
1703         if (!rtp)
1704                 return;
1705
1706         rtp_bridge_lock(rtp);
1707
1708         for (i = 0; i < MAX_RTP_PT; ++i) {
1709                 rtp->current_RTP_PT[i].isAstFormat = 0;
1710                 rtp->current_RTP_PT[i].code = 0;
1711         }
1712
1713         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1714         rtp->rtp_lookup_code_cache_code = 0;
1715         rtp->rtp_lookup_code_cache_result = 0;
1716
1717         rtp_bridge_unlock(rtp);
1718 }
1719
1720 void ast_rtp_pt_default(struct ast_rtp* rtp) 
1721 {
1722         int i;
1723
1724         rtp_bridge_lock(rtp);
1725
1726         /* Initialize to default payload types */
1727         for (i = 0; i < MAX_RTP_PT; ++i) {
1728                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1729                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1730         }
1731
1732         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1733         rtp->rtp_lookup_code_cache_code = 0;
1734         rtp->rtp_lookup_code_cache_result = 0;
1735
1736         rtp_bridge_unlock(rtp);
1737 }
1738
1739 void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
1740 {
1741         unsigned int i;
1742
1743         rtp_bridge_lock(dest);
1744         rtp_bridge_lock(src);
1745
1746         for (i=0; i < MAX_RTP_PT; ++i) {
1747                 dest->current_RTP_PT[i].isAstFormat = 
1748                         src->current_RTP_PT[i].isAstFormat;
1749                 dest->current_RTP_PT[i].code = 
1750                         src->current_RTP_PT[i].code; 
1751         }
1752         dest->rtp_lookup_code_cache_isAstFormat = 0;
1753         dest->rtp_lookup_code_cache_code = 0;
1754         dest->rtp_lookup_code_cache_result = 0;
1755
1756         rtp_bridge_unlock(src);
1757         rtp_bridge_unlock(dest);
1758 }
1759
1760 /*! \brief Get channel driver interface structure */
1761 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1762 {
1763         struct ast_rtp_protocol *cur = NULL;
1764
1765         AST_RWLIST_RDLOCK(&protos);
1766         AST_RWLIST_TRAVERSE(&protos, cur, list) {
1767                 if (cur->type == chan->tech->type)
1768                         break;
1769         }
1770         AST_RWLIST_UNLOCK(&protos);
1771
1772         return cur;
1773 }
1774
1775 int ast_rtp_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
1776 {
1777         // dest = c0, src = c1
1778         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1779         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1780         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1781         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1782         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;
1783         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;
1784         int srccodec, destcodec, nat_active = 0;
1785
1786         /* Lock channels */
1787         ast_channel_lock(c0);
1788         if (c1) {
1789                 while (ast_channel_trylock(c1)) {
1790                         ast_channel_unlock(c0);
1791                         usleep(1);
1792                         ast_channel_lock(c0);
1793                 }
1794         }
1795
1796         /* Find channel driver interfaces */
1797         destpr = get_proto(c0);
1798         if (c1)
1799                 srcpr = get_proto(c1);
1800         if (!destpr) {
1801                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c0->name);
1802                 ast_channel_unlock(c0);
1803                 if (c1)
1804                         ast_channel_unlock(c1);
1805                 return -1;
1806         }
1807         if (!srcpr) {
1808                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>");
1809                 ast_channel_unlock(c0);
1810                 if (c1)
1811                         ast_channel_unlock(c1);
1812                 return -1;
1813         }
1814
1815         /* Get audio, video  and text interface (if native bridge is possible) */
1816         audio_dest_res = destpr->get_rtp_info(c0, &destp);
1817         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED;
1818         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(c0, &tdestp) : AST_RTP_GET_FAILED;
1819         if (srcpr) {
1820                 audio_src_res = srcpr->get_rtp_info(c1, &srcp);
1821                 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED;
1822                 text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(c1, &tsrcp) : AST_RTP_GET_FAILED;
1823         }
1824
1825         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1826         if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1827                 /* Somebody doesn't want to play... */
1828                 ast_channel_unlock(c0);
1829                 if (c1)
1830                         ast_channel_unlock(c1);
1831                 return -1;
1832         }
1833         if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1834                 srccodec = srcpr->get_codec(c1);
1835         else
1836                 srccodec = 0;
1837         if (audio_dest_res == AST_RTP_TRY_NATIVE && destpr->get_codec)
1838                 destcodec = destpr->get_codec(c0);
1839         else
1840                 destcodec = 0;
1841         /* Ensure we have at least one matching codec */
1842         if (!(srccodec & destcodec)) {
1843                 ast_channel_unlock(c0);
1844                 if (c1)
1845                         ast_channel_unlock(c1);
1846                 return 0;
1847         }
1848         /* Consider empty media as non-existant */
1849         if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1850                 srcp = NULL;
1851         if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1852                 nat_active = 1;
1853         /* Bridge media early */
1854         if (destpr->set_rtp_peer(c0, srcp, vsrcp, tsrcp, srccodec, nat_active))
1855                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1856         ast_channel_unlock(c0);
1857         if (c1)
1858                 ast_channel_unlock(c1);
1859         ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1860         return 0;
1861 }
1862
1863 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1864 {
1865         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1866         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1867         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1868         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1869         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;
1870         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; 
1871         int srccodec, destcodec;
1872
1873         /* Lock channels */
1874         ast_channel_lock(dest);
1875         while (ast_channel_trylock(src)) {
1876                 ast_channel_unlock(dest);
1877                 usleep(1);
1878                 ast_channel_lock(dest);
1879         }
1880
1881         /* Find channel driver interfaces */
1882         if (!(destpr = get_proto(dest))) {
1883                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1884                 ast_channel_unlock(dest);
1885                 ast_channel_unlock(src);
1886                 return 0;
1887         }
1888         if (!(srcpr = get_proto(src))) {
1889                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", src->name);
1890                 ast_channel_unlock(dest);
1891                 ast_channel_unlock(src);
1892                 return 0;
1893         }
1894
1895         /* Get audio and video interface (if native bridge is possible) */
1896         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1897         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1898         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(dest, &tdestp) : AST_RTP_GET_FAILED;
1899         audio_src_res = srcpr->get_rtp_info(src, &srcp);
1900         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1901         text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(src, &tsrcp) : AST_RTP_GET_FAILED;
1902
1903         /* Ensure we have at least one matching codec */
1904         if (srcpr->get_codec)
1905                 srccodec = srcpr->get_codec(src);
1906         else
1907                 srccodec = 0;
1908         if (destpr->get_codec)
1909                 destcodec = destpr->get_codec(dest);
1910         else
1911                 destcodec = 0;
1912
1913         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1914         if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE || !(srccodec & destcodec)) {
1915                 /* Somebody doesn't want to play... */
1916                 ast_channel_unlock(dest);
1917                 ast_channel_unlock(src);
1918                 return 0;
1919         }
1920         ast_rtp_pt_copy(destp, srcp);
1921         if (vdestp && vsrcp)
1922                 ast_rtp_pt_copy(vdestp, vsrcp);
1923         if (tdestp && tsrcp)
1924                 ast_rtp_pt_copy(tdestp, tsrcp);
1925         if (media) {
1926                 /* Bridge early */
1927                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, tsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1928                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1929         }
1930         ast_channel_unlock(dest);
1931         ast_channel_unlock(src);
1932         ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1933         return 1;
1934 }
1935
1936 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
1937  * By default, use the well-known value for this type (although it may 
1938  * still be set to a different value by a subsequent "a=rtpmap:" line)
1939  */
1940 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1941 {
1942         if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) 
1943                 return; /* bogus payload type */
1944
1945         rtp_bridge_lock(rtp);
1946         rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1947         rtp_bridge_unlock(rtp);
1948
1949
1950 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1951  * an SDP "a=rtpmap:" line.
1952  */
1953 void ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1954                              char *mimeType, char *mimeSubtype,
1955                              enum ast_rtp_options options)
1956 {
1957         unsigned int i;
1958
1959         if (pt < 0 || pt > MAX_RTP_PT) 
1960                 return; /* bogus payload type */
1961         
1962         rtp_bridge_lock(rtp);
1963
1964         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1965                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1966                     strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1967                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1968                         if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1969                             mimeTypes[i].payloadType.isAstFormat &&
1970                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1971                                 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1972                         break;
1973                 }
1974         }
1975
1976         rtp_bridge_unlock(rtp);
1977
1978         return;
1979
1980
1981 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
1982  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1983 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1984                                  int* astFormats, int* nonAstFormats)
1985 {
1986         int pt;
1987         
1988         rtp_bridge_lock(rtp);
1989         
1990         *astFormats = *nonAstFormats = 0;
1991         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1992                 if (rtp->current_RTP_PT[pt].isAstFormat) {
1993                         *astFormats |= rtp->current_RTP_PT[pt].code;
1994                 } else {
1995                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1996                 }
1997         }
1998
1999         rtp_bridge_unlock(rtp);
2000         
2001         return;
2002 }
2003
2004 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
2005 {
2006         struct rtpPayloadType result;
2007
2008         result.isAstFormat = result.code = 0;
2009
2010         if (pt < 0 || pt > MAX_RTP_PT) 
2011                 return result; /* bogus payload type */
2012
2013         /* Start with negotiated codecs */
2014         rtp_bridge_lock(rtp);
2015         result = rtp->current_RTP_PT[pt];
2016         rtp_bridge_unlock(rtp);
2017
2018         /* If it doesn't exist, check our static RTP type list, just in case */
2019         if (!result.code) 
2020                 result = static_RTP_PT[pt];
2021
2022         return result;
2023 }
2024
2025 /*! \brief Looks up an RTP code out of our *static* outbound list */
2026 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
2027 {
2028         int pt = 0;
2029
2030         rtp_bridge_lock(rtp);
2031
2032         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
2033                 code == rtp->rtp_lookup_code_cache_code) {
2034                 /* Use our cached mapping, to avoid the overhead of the loop below */
2035                 pt = rtp->rtp_lookup_code_cache_result;
2036                 rtp_bridge_unlock(rtp);
2037                 return pt;
2038         }
2039
2040         /* Check the dynamic list first */
2041         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2042                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
2043                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
2044                         rtp->rtp_lookup_code_cache_code = code;
2045                         rtp->rtp_lookup_code_cache_result = pt;
2046                         rtp_bridge_unlock(rtp);
2047                         return pt;
2048                 }
2049         }
2050
2051         /* Then the static list */
2052         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
2053                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
2054                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
2055                         rtp->rtp_lookup_code_cache_code = code;
2056                         rtp->rtp_lookup_code_cache_result = pt;
2057                         rtp_bridge_unlock(rtp);
2058                         return pt;
2059                 }
2060         }
2061
2062         rtp_bridge_unlock(rtp);
2063
2064         return -1;
2065 }
2066
2067 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
2068                                   enum ast_rtp_options options)
2069 {
2070         unsigned int i;
2071
2072         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
2073                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
2074                         if (isAstFormat &&
2075                             (code == AST_FORMAT_G726_AAL2) &&
2076                             (options & AST_RTP_OPT_G726_NONSTANDARD))
2077                                 return "G726-32";
2078                         else
2079                                 return mimeTypes[i].subtype;
2080                 }
2081         }
2082
2083         return "";
2084 }
2085
2086 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
2087                                    const int isAstFormat, enum ast_rtp_options options)
2088 {
2089         int format;
2090         unsigned len;
2091         char *end = buf;
2092         char *start = buf;
2093
2094         if (!buf || !size)
2095                 return NULL;
2096
2097         snprintf(end, size, "0x%x (", capability);
2098
2099         len = strlen(end);
2100         end += len;
2101         size -= len;
2102         start = end;
2103
2104         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
2105                 if (capability & format) {
2106                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
2107
2108                         snprintf(end, size, "%s|", name);
2109                         len = strlen(end);
2110                         end += len;
2111                         size -= len;
2112                 }
2113         }
2114
2115         if (start == end)
2116                 ast_copy_string(start, "nothing)", size); 
2117         else if (size > 1)
2118                 *(end -1) = ')';
2119         
2120         return buf;
2121 }
2122
2123 /*! \brief Open RTP or RTCP socket for a session.
2124  * Print a message on failure. 
2125  */
2126 static int rtp_socket(const char *type)
2127 {
2128         int s = socket(AF_INET, SOCK_DGRAM, 0);
2129         if (s < 0) {
2130                 if (type == NULL)
2131                         type = "RTP/RTCP";
2132                 ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
2133         } else {
2134                 long flags = fcntl(s, F_GETFL);
2135                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
2136 #ifdef SO_NO_CHECK
2137                 if (nochecksums)
2138                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
2139 #endif
2140         }
2141         return s;
2142 }
2143
2144 /*!
2145  * \brief Initialize a new RTCP session.
2146  * 
2147  * \returns The newly initialized RTCP session.
2148  */
2149 static struct ast_rtcp *ast_rtcp_new(void)
2150 {
2151         struct ast_rtcp *rtcp;
2152
2153         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
2154                 return NULL;
2155         rtcp->s = rtp_socket("RTCP");
2156         rtcp->us.sin_family = AF_INET;
2157         rtcp->them.sin_family = AF_INET;
2158
2159         if (rtcp->s < 0) {
2160                 ast_free(rtcp);
2161                 return NULL;
2162         }
2163
2164         return rtcp;
2165 }
2166
2167 /*!
2168  * \brief Initialize a new RTP structure.
2169  *
2170  */
2171 void ast_rtp_new_init(struct ast_rtp *rtp)
2172 {
2173 #ifdef P2P_INTENSE
2174         ast_mutex_init(&rtp->bridge_lock);
2175 #endif
2176
2177         rtp->them.sin_family = AF_INET;
2178         rtp->us.sin_family = AF_INET;
2179         rtp->ssrc = ast_random();
2180         rtp->seqno = ast_random() & 0xffff;
2181         ast_set_flag(rtp, FLAG_HAS_DTMF);
2182
2183         return;
2184 }
2185
2186 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
2187 {
2188         struct ast_rtp *rtp;
2189         int x;
2190         int startplace;
2191         
2192         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
2193                 return NULL;
2194
2195         ast_rtp_new_init(rtp);
2196
2197         rtp->s = rtp_socket("RTP");
2198         if (rtp->s < 0)
2199                 goto fail;
2200         if (sched && rtcpenable) {
2201                 rtp->sched = sched;
2202                 rtp->rtcp = ast_rtcp_new();
2203         }
2204         
2205         /*
2206          * Try to bind the RTP port, x, and possibly the RTCP port, x+1 as well.
2207          * Start from a random (even, by RTP spec) port number, and
2208          * iterate until success or no ports are available.
2209          * Note that the requirement of RTP port being even, or RTCP being the
2210          * next one, cannot be enforced in presence of a NAT box because the
2211          * mapping is not under our control.
2212          */
2213         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
2214         x = x & ~1;             /* make it an even number */
2215         startplace = x;         /* remember the starting point */
2216         /* this is constant across the loop */
2217         rtp->us.sin_addr = addr;
2218         if (rtp->rtcp)
2219                 rtp->rtcp->us.sin_addr = addr;
2220         for (;;) {
2221                 rtp->us.sin_port = htons(x);
2222                 if (!bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) {
2223                         /* bind succeeded, if no rtcp then we are done */
2224                         if (!rtp->rtcp)
2225                                 break;
2226                         /* have rtcp, try to bind it */
2227                         rtp->rtcp->us.sin_port = htons(x + 1);
2228                         if (!bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us)))
2229                                 break;  /* success again, we are really done */
2230                         /*
2231                          * RTCP bind failed, so close and recreate the
2232                          * already bound RTP socket for the next round.
2233                          */
2234                         close(rtp->s);
2235                         rtp->s = rtp_socket("RTP");
2236                         if (rtp->s < 0)
2237                                 goto fail;
2238                 }
2239                 /*
2240                  * If we get here, there was an error in one of the bind()
2241                  * calls, so make sure it is nothing unexpected.
2242                  */
2243                 if (errno != EADDRINUSE) {
2244                         /* We got an error that wasn't expected, abort! */
2245                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
2246                         goto fail;
2247                 }
2248                 /*
2249                  * One of the ports is in use. For the next iteration,
2250                  * increment by two and handle wraparound.
2251                  * If we reach the starting point, then declare failure.
2252                  */
2253                 x += 2;
2254                 if (x > rtpend)
2255                         x = (rtpstart + 1) & ~1;
2256                 if (x == startplace) {
2257                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
2258                         goto fail;
2259                 }
2260         }
2261         rtp->sched = sched;
2262         rtp->io = io;
2263         if (callbackmode) {
2264                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
2265                 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
2266         }
2267         ast_rtp_pt_default(rtp);
2268         return rtp;
2269
2270 fail:
2271         if (rtp->s >= 0)
2272                 close(rtp->s);
2273         if (rtp->rtcp) {
2274                 close(rtp->rtcp->s);
2275                 ast_free(rtp->rtcp);
2276         }
2277         ast_free(rtp);
2278         return NULL;
2279 }
2280
2281 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
2282 {
2283         struct in_addr ia;
2284
2285         memset(&ia, 0, sizeof(ia));
2286         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
2287 }
2288
2289 int ast_rtp_setqos(struct ast_rtp *rtp, int tos, int cos)
2290 {
2291         return ast_netsock_set_qos(rtp->s, tos, cos);
2292 }
2293
2294 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2295 {
2296         rtp->them.sin_port = them->sin_port;
2297         rtp->them.sin_addr = them->sin_addr;
2298         if (rtp->rtcp) {
2299                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
2300                 rtp->rtcp->them.sin_addr = them->sin_addr;
2301         }
2302         rtp->rxseqno = 0;
2303 }
2304
2305 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2306 {
2307         if ((them->sin_family != AF_INET) ||
2308                 (them->sin_port != rtp->them.sin_port) ||
2309                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2310                 them->sin_family = AF_INET;
2311                 them->sin_port = rtp->them.sin_port;
2312                 them->sin_addr = rtp->them.sin_addr;
2313                 return 1;
2314         }
2315         return 0;
2316 }
2317
2318 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2319 {
2320         *us = rtp->us;
2321 }
2322
2323 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2324 {
2325         struct ast_rtp *bridged = NULL;
2326
2327         rtp_bridge_lock(rtp);
2328         bridged = rtp->bridged;
2329         rtp_bridge_unlock(rtp);
2330
2331         return bridged;
2332 }
2333
2334 void ast_rtp_stop(struct ast_rtp *rtp)
2335 {
2336         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
2337                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2338                 rtp->rtcp->schedid = -1;
2339         }
2340
2341         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2342         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2343         if (rtp->rtcp) {
2344                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2345                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2346         }
2347         
2348         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2349 }
2350
2351 void ast_rtp_reset(struct ast_rtp *rtp)
2352 {
2353         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2354         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2355         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2356         rtp->lastts = 0;
2357         rtp->lastdigitts = 0;
2358         rtp->lastrxts = 0;
2359         rtp->lastividtimestamp = 0;
2360         rtp->lastovidtimestamp = 0;
2361         rtp->lastitexttimestamp = 0;
2362         rtp->lastotexttimestamp = 0;
2363         rtp->lasteventseqn = 0;
2364         rtp->lastevent = 0;
2365         rtp->lasttxformat = 0;
2366         rtp->lastrxformat = 0;
2367         rtp->dtmfcount = 0;
2368         rtp->dtmfsamples = 0;
2369         rtp->seqno = 0;
2370         rtp->rxseqno = 0;
2371 }
2372
2373 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual)
2374 {
2375         /*
2376         *ssrc          our ssrc
2377         *themssrc      their ssrc
2378         *lp            lost packets
2379         *rxjitter      our calculated jitter(rx)
2380         *rxcount       no. received packets
2381         *txjitter      reported jitter of the other end
2382         *txcount       transmitted packets
2383         *rlp           remote lost packets
2384         *rtt           round trip time
2385         */
2386
2387         if (qual) {
2388                 qual->local_ssrc = rtp->ssrc;
2389                 qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2390                 qual->local_jitter = rtp->rxjitter;
2391                 qual->local_count = rtp->rxcount;
2392                 qual->remote_ssrc = rtp->themssrc;
2393                 qual->remote_lostpackets = rtp->rtcp->reported_lost;
2394                 qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0;
2395                 qual->remote_count = rtp->txcount;
2396                 qual->rtt = rtp->rtcp->rtt;
2397         }
2398         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);
2399         
2400         return rtp->rtcp->quality;
2401 }
2402
2403 void ast_rtp_destroy(struct ast_rtp *rtp)
2404 {
2405         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2406                 /*Print some info on the call here */
2407                 ast_verbose("  RTP-stats\n");
2408                 ast_verbose("* Our Receiver:\n");
2409                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
2410                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
2411                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2412                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
2413                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
2414                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2415                 ast_verbose("* Our Sender:\n");
2416                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2417                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2418                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2419                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter / (unsigned int)65536.0);
2420                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2421                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2422         }
2423
2424         manager_event(EVENT_FLAG_REPORTING, "RTPReceiverStat", "SSRC: %u\r\n"
2425                                             "ReceivedPackets: %u\r\n"
2426                                             "LostPackets: %u\r\n"
2427                                             "Jitter: %.4f\r\n"
2428                                             "Transit: %.4f\r\n"
2429                                             "RRCount: %u\r\n",
2430                                             rtp->themssrc,
2431                                             rtp->rxcount,
2432                                             rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2433                                             rtp->rxjitter,
2434                                             rtp->rxtransit,
2435                                             rtp->rtcp->rr_count);
2436         manager_event(EVENT_FLAG_REPORTING, "RTPSenderStat", "SSRC: %u\r\n"
2437                                             "SentPackets: %u\r\n"
2438                                             "LostPackets: %u\r\n"
2439                                             "Jitter: %u\r\n"
2440                                             "SRCount: %u\r\n"
2441                                             "RTT: %f\r\n",
2442                                             rtp->ssrc,
2443                                             rtp->txcount,
2444                                             rtp->rtcp->reported_lost,
2445                                             rtp->rtcp->reported_jitter,
2446                                             rtp->rtcp->sr_count,
2447                                             rtp->rtcp->rtt);
2448         if (rtp->smoother)
2449                 ast_smoother_free(rtp->smoother);
2450         if (rtp->ioid)
2451                 ast_io_remove(rtp->io, rtp->ioid);
2452         if (rtp->s > -1)
2453                 close(rtp->s);
2454         if (rtp->rtcp) {
2455                 if (rtp->rtcp->schedid > 0)
2456                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2457                 close(rtp->rtcp->s);
2458                 ast_free(rtp->rtcp);
2459                 rtp->rtcp=NULL;
2460         }
2461 #ifdef P2P_INTENSE
2462         ast_mutex_destroy(&rtp->bridge_lock);
2463 #endif
2464         ast_free(rtp);
2465 }
2466
2467 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2468 {
2469         struct timeval t;
2470         long ms;
2471         if (ast_tvzero(rtp->txcore)) {
2472                 rtp->txcore = ast_tvnow();
2473                 /* Round to 20ms for nice, pretty timestamps */
2474                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2475         }
2476         /* Use previous txcore if available */
2477         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2478         ms = ast_tvdiff_ms(t, rtp->txcore);
2479         if (ms < 0)
2480                 ms = 0;
2481         /* Use what we just got for next time */
2482         rtp->txcore = t;
2483         return (unsigned int) ms;
2484 }
2485
2486 /*! \brief Send begin frames for DTMF */
2487 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2488 {
2489         unsigned int *rtpheader;
2490         int hdrlen = 12, res = 0, i = 0, payload = 0;
2491         char data[256];
2492
2493         if ((digit <= '9') && (digit >= '0'))
2494                 digit -= '0';
2495         else if (digit == '*')
2496                 digit = 10;
2497         else if (digit == '#')
2498                 digit = 11;
2499         else if ((digit >= 'A') && (digit <= 'D'))
2500                 digit = digit - 'A' + 12;
2501         else if ((digit >= 'a') && (digit <= 'd'))
2502                 digit = digit - 'a' + 12;
2503         else {
2504                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2505                 return 0;
2506         }
2507
2508         /* If we have no peer, return immediately */    
2509         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2510                 return 0;
2511
2512         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2513
2514         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2515         rtp->send_duration = 160;
2516         
2517         /* Get a pointer to the header */
2518         rtpheader = (unsigned int *)data;
2519         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2520         rtpheader[1] = htonl(rtp->lastdigitts);
2521         rtpheader[2] = htonl(rtp->ssrc); 
2522
2523         for (i = 0; i < 2; i++) {
2524                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2525                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2526                 if (res < 0) 
2527                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
2528                                 ast_inet_ntoa(rtp->them.sin_addr),
2529                                 ntohs(rtp->them.sin_port), strerror(errno));
2530                 if (rtp_debug_test_addr(&rtp->them))
2531                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2532                                     ast_inet_ntoa(rtp->them.sin_addr),
2533                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2534                 /* Increment sequence number */
2535                 rtp->seqno++;
2536                 /* Increment duration */
2537                 rtp->send_duration += 160;
2538                 /* Clear marker bit and set seqno */
2539                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2540         }
2541
2542         /* Since we received a begin, we can safely store the digit and disable any compensation */
2543         rtp->sending_digit = 1;
2544         rtp->send_digit = digit;
2545         rtp->send_payload = payload;
2546
2547         return 0;
2548 }
2549
2550 /*! \brief Send continuation frame for DTMF */
2551 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2552 {
2553         unsigned int *rtpheader;
2554         int hdrlen = 12, res = 0;
2555         char data[256];
2556
2557         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2558                 return 0;
2559
2560         /* Setup packet to send */
2561         rtpheader = (unsigned int *)data;
2562         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2563         rtpheader[1] = htonl(rtp->lastdigitts);
2564         rtpheader[2] = htonl(rtp->ssrc);
2565         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2566         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2567         
2568         /* Transmit */
2569         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2570         if (res < 0)
2571                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2572                         ast_inet_ntoa(rtp->them.sin_addr),
2573                         ntohs(rtp->them.sin_port), strerror(errno));
2574         if (rtp_debug_test_addr(&rtp->them))
2575                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2576                             ast_inet_ntoa(rtp->them.sin_addr),
2577                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2578
2579         /* Increment sequence number */
2580         rtp->seqno++;
2581         /* Increment duration */
2582         rtp->send_duration += 160;
2583
2584         return 0;
2585 }
2586
2587 /*! \brief Send end packets for DTMF */
2588 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2589 {
2590         unsigned int *rtpheader;
2591         int hdrlen = 12, res = 0, i = 0;
2592         char data[256];
2593         
2594         /* If no address, then bail out */
2595         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2596                 return 0;
2597         
2598         if ((digit <= '9') && (digit >= '0'))
2599                 digit -= '0';
2600         else if (digit == '*')
2601                 digit = 10;
2602         else if (digit == '#')
2603                 digit = 11;
2604         else if ((digit >= 'A') && (digit <= 'D'))
2605                 digit = digit - 'A' + 12;
2606         else if ((digit >= 'a') && (digit <= 'd'))
2607                 digit = digit - 'a' + 12;
2608         else {
2609                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2610                 return 0;
2611         }
2612
2613         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2614
2615         rtpheader = (unsigned int *)data;
2616         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2617         rtpheader[1] = htonl(rtp->lastdigitts);
2618         rtpheader[2] = htonl(rtp->ssrc);
2619         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2620         /* Set end bit */
2621         rtpheader[3] |= htonl((1 << 23));
2622         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2623         /* Send 3 termination packets */
2624         for (i = 0; i < 3; i++) {
2625                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2626                 if (res < 0)
2627                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2628                                 ast_inet_ntoa(rtp->them.sin_addr),
2629                                 ntohs(rtp->them.sin_port), strerror(errno));
2630                 if (rtp_debug_test_addr(&rtp->them))
2631                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2632                                     ast_inet_ntoa(rtp->them.sin_addr),
2633                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2634         }
2635         rtp->sending_digit = 0;
2636         rtp->send_digit = 0;
2637         /* Increment lastdigitts */
2638         rtp->lastdigitts += 960;
2639         rtp->seqno++;
2640
2641         return res;
2642 }
2643
2644 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2645 int ast_rtcp_send_h261fur(void *data)
2646 {
2647         struct ast_rtp *rtp = data;
2648         int res;
2649
2650         rtp->rtcp->sendfur = 1;
2651         res = ast_rtcp_write(data);
2652         
2653         return res;
2654 }
2655
2656 /*! \brief Send RTCP sender's report */
2657 static int ast_rtcp_write_sr(const void *data)
2658 {
2659         struct ast_rtp *rtp = (struct ast_rtp *)data;
2660         int res;
2661         int len = 0;
2662         struct timeval now;
2663         unsigned int now_lsw;
2664         unsigned int now_msw;
2665         unsigned int *rtcpheader;
2666         unsigned int lost;
2667         unsigned int extended;
2668         unsigned int expected;
2669         unsigned int expected_interval;
2670         unsigned int received_interval;
2671         int lost_interval;
2672         int fraction;
2673         struct timeval dlsr;
2674         char bdata[512];
2675
2676         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2677         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2678                 return 0;
2679         
2680         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2681                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2682                 if (rtp->rtcp->schedid > 0)
2683                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2684                 rtp->rtcp->schedid = -1;
2685                 return 0;
2686         }
2687
2688         gettimeofday(&now, NULL);
2689         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2690         rtcpheader = (unsigned int *)bdata;
2691         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2692         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2693         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2694         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2695         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2696         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2697         len += 28;
2698         
2699         extended = rtp->cycles + rtp->lastrxseqno;
2700         expected = extended - rtp->seedrxseqno + 1;
2701         if (rtp->rxcount > expected) 
2702                 expected += rtp->rxcount - expected;
2703         lost = expected - rtp->rxcount;
2704         expected_interval = expected - rtp->rtcp->expected_prior;
2705         rtp->rtcp->expected_prior = expected;
2706         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2707         rtp->rtcp->received_prior = rtp->rxcount;
2708         lost_interval = expected_interval - received_interval;
2709         if (expected_interval == 0 || lost_interval <= 0)
2710                 fraction = 0;
2711         else
2712                 fraction = (lost_interval << 8) / expected_interval;
2713         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2714         rtcpheader[7] = htonl(rtp->themssrc);
2715         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2716         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2717         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2718         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2719         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2720         len += 24;
2721         
2722         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2723
2724         if (rtp->rtcp->sendfur) {
2725                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2726                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2727                 len += 8;
2728                 rtp->rtcp->sendfur = 0;
2729         }
2730         
2731         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2732         /* it can change mid call, and SDES can't) */
2733         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2734         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2735         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2736         len += 12;
2737         
2738         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2739         if (res < 0) {
2740                 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));
2741                 if (rtp->rtcp->schedid > 0)
2742                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2743                 rtp->rtcp->schedid = -1;
2744                 return 0;
2745         }
2746         
2747         /* FIXME Don't need to get a new one */
2748         gettimeofday(&rtp->rtcp->txlsr, NULL);
2749         rtp->rtcp->sr_count++;
2750
2751         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2752         
2753         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2754                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2755                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2756                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2757                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2758                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2759                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2760                 ast_verbose("  Report block:\n");
2761                 ast_verbose("  Fraction lost: %u\n", fraction);
2762                 ast_verbose("  Cumulative loss: %u\n", lost);
2763                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2764                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2765                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2766         }
2767         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To %s:%d\r\n"
2768                                             "OurSSRC: %u\r\n"
2769                                             "SentNTP: %u.%010u\r\n"
2770                                             "SentRTP: %u\r\n"
2771                                             "SentPackets: %u\r\n"
2772                                             "SentOctets: %u\r\n"
2773                                             "ReportBlock:\r\n"
2774                                             "FractionLost: %u\r\n"
2775                                             "CumulativeLoss: %u\r\n"
2776                                             "IAJitter: %.4f\r\n"
2777                                             "TheirLastSR: %u\r\n"
2778                                             "DLSR: %4.4f (sec)\r\n",
2779                                             ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
2780                                             rtp->ssrc,
2781                                             (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
2782                                             rtp->lastts,
2783                                             rtp->txcount,
2784                                             rtp->txoctetcount,
2785                                             fraction,
2786                                             lost,
2787                                             rtp->rxjitter,
2788                                             rtp->rtcp->themrxlsr,
2789                                             (double)(ntohl(rtcpheader[12])/65536.0));
2790         return res;
2791 }
2792
2793 /*! \brief Send RTCP recipient's report */
2794 static int ast_rtcp_write_rr(const void *data)
2795 {
2796         struct ast_rtp *rtp = (struct ast_rtp *)data;
2797         int res;
2798         int len = 32;
2799         unsigned int lost;
2800         unsigned int extended;
2801         unsigned int expected;
2802         unsigned int expected_interval;
2803         unsigned int received_interval;
2804         int lost_interval;
2805         struct timeval now;
2806         unsigned int *rtcpheader;
2807         char bdata[1024];
2808         struct timeval dlsr;
2809         int fraction;
2810
2811         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2812                 return 0;
2813           
2814         if (!rtp->rtcp->them.sin_addr.s_addr) {
2815                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
2816                 if (rtp->rtcp->schedid > 0)
2817                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2818                 rtp->rtcp->schedid = -1;
2819                 return 0;
2820         }
2821
2822         extended = rtp->cycles + rtp->lastrxseqno;
2823         expected = extended - rtp->seedrxseqno + 1;
2824         lost = expected - rtp->rxcount;
2825         expected_interval = expected - rtp->rtcp->expected_prior;
2826         rtp->rtcp->expected_prior = expected;
2827         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2828         rtp->rtcp->received_prior = rtp->rxcount;
2829         lost_interval = expected_interval - received_interval;
2830         if (expected_interval == 0 || lost_interval <= 0)
2831                 fraction = 0;
2832         else
2833                 fraction = (lost_interval << 8) / expected_interval;
2834         gettimeofday(&now, NULL);
2835         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2836         rtcpheader = (unsigned int *)bdata;
2837         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2838         rtcpheader[1] = htonl(rtp->ssrc);
2839         rtcpheader[2] = htonl(rtp->themssrc);
2840         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2841         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2842         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2843         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2844         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2845
2846         if (rtp->rtcp->sendfur) {
2847                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2848                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2849                 len += 8;
2850                 rtp->rtcp->sendfur = 0;
2851         }
2852
2853         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2854         it can change mid call, and SDES can't) */
2855         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2856         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2857         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2858         len += 12;
2859         
2860         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2861
2862         if (res < 0) {
2863                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2864                 /* Remove the scheduler */
2865                 if (rtp->rtcp->schedid > 0)
2866                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2867                 rtp->rtcp->schedid = -1;
2868                 return 0;
2869         }
2870
2871         rtp->rtcp->rr_count++;
2872
2873         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2874                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2875                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2876                         "  IA jitter: %.4f\n" 
2877                         "  Their last SR: %u\n" 
2878                         "  DLSR: %4.4f (sec)\n\n",
2879                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2880                         ntohs(rtp->rtcp->them.sin_port),
2881                         rtp->ssrc, rtp->themssrc, fraction, lost,
2882                         rtp->rxjitter,
2883                         rtp->rtcp->themrxlsr,
2884                         (double)(ntohl(rtcpheader[7])/65536.0));
2885         }
2886
2887         return res;
2888 }
2889
2890 /*! \brief Write and RTCP packet to the far end
2891  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2892  * RR is sent if we have not sent any rtp packets in the previous interval */
2893 static int ast_rtcp_write(const void *data)
2894 {
2895         struct ast_rtp *rtp = (struct ast_rtp *)data;
2896         int res;
2897         
2898         if (!rtp || !rtp->rtcp)
2899                 return 0;
2900
2901         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2902                 res = ast_rtcp_write_sr(data);
2903         else
2904                 res = ast_rtcp_write_rr(data);
2905         
2906         return res;
2907 }
2908
2909 /*! \brief generate comfort noice (CNG) */
2910 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2911 {
2912         unsigned int *rtpheader;
2913         int hdrlen = 12;
2914         int res;
2915         int payload;
2916         char data[256];
2917         level = 127 - (level & 0x7f);
2918         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2919
2920         /* If we have no peer, return immediately */    
2921         if (!rtp->them.sin_addr.s_addr)
2922                 return 0;
2923
2924         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2925
2926         /* Get a pointer to the header */
2927         rtpheader = (unsigned int *)data;
2928         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2929         rtpheader[1] = htonl(rtp->lastts);
2930         rtpheader[2] = htonl(rtp->ssrc); 
2931         data[12] = level;
2932         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2933                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2934                 if (res <0) 
2935                         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));
2936                 if (rtp_debug_test_addr(&rtp->them))
2937                         ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2938                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2939                    
2940         }
2941         return 0;
2942 }
2943
2944 /*! \brief Write RTP packet with audio or video media frames into UDP packet */
2945 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2946 {
2947         unsigned char *rtpheader;
2948         int hdrlen = 12;
2949         int res;
2950         unsigned int ms;
2951         int pred;
2952         int mark = 0;
2953
2954         ms = calc_txstamp(rtp, &f->delivery);
2955         /* Default prediction */
2956         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2957                 pred = rtp->lastts + f->samples;
2958
2959                 /* Re-calculate last TS */
2960                 rtp->lastts = rtp->lastts + ms * 8;
2961                 if (ast_tvzero(f->delivery)) {
2962                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2963                            and if so, go with our prediction */
2964                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2965                                 rtp->lastts = pred;
2966                         else {
2967                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2968                                 mark = 1;
2969                         }
2970                 }
2971         } else if(f->subclass < AST_FORMAT_MAX_VIDEO) {
2972                 mark = f->subclass & 0x1;
2973                 pred = rtp->lastovidtimestamp + f->samples;
2974                 /* Re-calculate last TS */
2975                 rtp->lastts = rtp->lastts + ms * 90;
2976                 /* If it's close to our prediction, go for it */
2977                 if (ast_tvzero(f->delivery)) {
2978                         if (abs(rtp->lastts - pred) < 7200) {
2979                                 rtp->lastts = pred;
2980                                 rtp->lastovidtimestamp += f->samples;
2981                         } else {
2982                                 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);
2983                                 rtp->lastovidtimestamp = rtp->lastts;
2984                         }
2985                 }
2986         } else {
2987                 pred = rtp->lastotexttimestamp + f->samples;
2988                 /* Re-calculate last TS */
2989                 rtp->lastts = rtp->lastts + ms * 90;
2990                 /* If it's close to our prediction, go for it */
2991                 if (ast_tvzero(f->delivery)) {
2992                         if (abs(rtp->lastts - pred) < 7200) {
2993                                 rtp->lastts = pred;
2994                                 rtp->lastotexttimestamp += f->samples;
2995                         } else {
2996                                 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);
2997                                 rtp->lastotexttimestamp = rtp->lastts;
2998                         }
2999                 }
3000         }
3001         /* If the timestamp for non-digit packets has moved beyond the timestamp
3002            for digits, update the digit timestamp.
3003         */
3004         if (rtp->lastts > rtp->lastdigitts)
3005                 rtp->lastdigitts = rtp->lastts;
3006
3007         if (f->has_timing_info)
3008                 rtp->lastts = f->ts * 8;
3009
3010         /* Get a pointer to the header */
3011         rtpheader = (unsigned char *)(f->data - hdrlen);
3012
3013         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
3014         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
3015         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
3016
3017         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
3018                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
3019                 if (res <0) {
3020                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
3021                                 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));
3022                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
3023                                 /* Only give this error message once if we are not RTP debugging */
3024                                 if (option_debug || rtpdebug)
3025                                         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));
3026                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
3027                         }
3028                 } else {
3029                         rtp->txcount++;
3030                         rtp->txoctetcount +=(res - hdrlen);
3031                         
3032                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
3033                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
3034                 }
3035                                 
3036                 if (rtp_debug_test_addr(&rtp->them))
3037                         ast_verbose("Sent RTP packet to      %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
3038                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
3039         }
3040
3041         rtp->seqno++;
3042
3043         return 0;
3044 }
3045
3046 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
3047 {
3048         int x;
3049         for (x = 0; x < 32; x++) {  /* Ugly way */
3050                 rtp->pref.order[x] = prefs->order[x];
3051                 rtp->pref.framing[x] = prefs->framing[x];
3052         }
3053         if (rtp->smoother)
3054                 ast_smoother_free(rtp->smoother);
3055         rtp->smoother = NULL;
3056         return 0;
3057 }
3058
3059 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
3060 {
3061         return &rtp->pref;
3062 }
3063
3064 int ast_rtp_codec_getformat(int pt)
3065 {
3066         if (pt < 0 || pt > MAX_RTP_PT)
3067                 return 0; /* bogus payload type */
3068
3069         if (static_RTP_PT[pt].isAstFormat)
3070                 return static_RTP_PT[pt].code;
3071         else
3072                 return 0;
3073 }
3074
3075 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
3076 {
3077         struct ast_frame *f;
3078         int codec;
3079         int hdrlen = 12;
3080         int subclass;
3081         
3082
3083         /* If we have no peer, return immediately */    
3084         if (!rtp->them.sin_addr.s_addr)
3085                 return 0;
3086
3087         /* If there is no data length, return immediately */
3088         if (!_f->datalen) 
3089                 return 0;
3090         
3091         /* Make sure we have enough space for RTP header */
3092         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO) && (_f->frametype != AST_FRAME_TEXT)) {
3093                 ast_log(LOG_WARNING, "RTP can only send voice, video and text\n");
3094                 return -1;
3095         }
3096
3097         /* The bottom bit of a video subclass contains the marker bit */
3098         subclass = _f->subclass;
3099         if (_f->frametype == AST_FRAME_VIDEO)
3100                 subclass &= ~0x1;
3101
3102         codec = ast_rtp_lookup_code(rtp, 1, subclass);
3103         if (codec < 0) {
3104                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
3105                 return -1;
3106         }
3107
3108         if (rtp->lasttxformat != subclass) {
3109                 /* New format, reset the smoother */
3110                 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
3111                 rtp->lasttxformat = subclass;
3112                 if (rtp->smoother)
3113                         ast_smoother_free(rtp->smoother);
3114                 rtp->smoother = NULL;
3115         }
3116
3117         if (!rtp->smoother && subclass != AST_FORMAT_SPEEX) {
3118                 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
3119                 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
3120                         if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
3121                                 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));
3122                                 return -1;
3123                         }
3124                         if (fmt.flags)
3125                                 ast_smoother_set_flags(rtp->smoother, fmt.flags);
3126                         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));
3127                 }
3128         }
3129         if (rtp->smoother) {
3130                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
3131                         ast_smoother_feed_be(rtp->smoother, _f);
3132                 } else {
3133                         ast_smoother_feed(rtp->smoother, _f);
3134                 }
3135
3136                 while ((f = ast_smoother_read(rtp->smoother)) && (f->data))
3137                         ast_rtp_raw_write(rtp, f, codec);
3138         } else {
3139                 /* Don't buffer outgoing frames; send them one-per-packet: */
3140                 if (_f->offset < hdrlen) 
3141