Grab each lock individually...
[asterisk/asterisk.git] / rtp.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Real-time Protocol Support
5  *      Supports RTP and RTCP with Symmetric RTP support for NAT
6  *      traversal
7  * 
8  * Copyright (C) 1999-2004, Digium, Inc.
9  *
10  * Mark Spencer <markster@digium.com>
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License
14  */
15
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <string.h>
19 #include <sys/time.h>
20 #include <signal.h>
21 #include <errno.h>
22 #include <unistd.h>
23 #include <netinet/in.h>
24 #include <sys/time.h>
25 #include <sys/socket.h>
26 #include <arpa/inet.h>
27 #include <fcntl.h>
28
29 #include <asterisk/rtp.h>
30 #include <asterisk/frame.h>
31 #include <asterisk/logger.h>
32 #include <asterisk/options.h>
33 #include <asterisk/channel.h>
34 #include <asterisk/acl.h>
35 #include <asterisk/channel.h>
36 #include <asterisk/channel_pvt.h>
37 #include <asterisk/config.h>
38 #include <asterisk/lock.h>
39 #include <asterisk/utils.h>
40
41 #define MAX_TIMESTAMP_SKEW      640
42
43 #define RTP_MTU         1200
44
45 #define TYPE_HIGH        0x0
46 #define TYPE_LOW         0x1
47 #define TYPE_SILENCE     0x2
48 #define TYPE_DONTSEND    0x3
49 #define TYPE_MASK        0x3
50
51 static int dtmftimeout = 3000;  /* 3000 samples */
52
53 static int rtpstart = 0;
54 static int rtpend = 0;
55 #ifdef SO_NO_CHECK
56 static int checksums = 1;
57 #endif
58
59 /* The value of each payload format mapping: */
60 struct rtpPayloadType {
61   int isAstFormat;      /* whether the following code is an AST_FORMAT */
62   int code;
63 };
64
65 #define MAX_RTP_PT 256
66
67 #define FLAG_3389_WARNING (1 << 0)
68
69 struct ast_rtp {
70         int s;
71         char resp;
72         struct ast_frame f;
73         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
74         unsigned int ssrc;
75         unsigned int lastts;
76         unsigned int lastrxts;
77         unsigned int lastividtimestamp;
78         unsigned int lastovidtimestamp;
79         unsigned int lasteventseqn;
80         int lasttxformat;
81         int lastrxformat;
82         int dtmfcount;
83         unsigned int dtmfduration;
84         int nat;
85         int flags;
86         struct sockaddr_in us;
87         struct sockaddr_in them;
88         struct timeval rxcore;
89         struct timeval txcore;
90         struct timeval dtmfmute;
91         struct ast_smoother *smoother;
92         int *ioid;
93         unsigned short seqno;
94         struct sched_context *sched;
95         struct io_context *io;
96         void *data;
97         ast_rtp_callback callback;
98     struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
99     int rtp_lookup_code_cache_isAstFormat;      /* a cache for the result of rtp_lookup_code(): */
100     int rtp_lookup_code_cache_code;
101     int rtp_lookup_code_cache_result;
102     int rtp_offered_from_local;
103         struct ast_rtcp *rtcp;
104 };
105
106 struct ast_rtcp {
107         int s;          /* Socket */
108         struct sockaddr_in us;
109         struct sockaddr_in them;
110 };
111
112 static struct ast_rtp_protocol *protos = NULL;
113
114 int ast_rtp_fd(struct ast_rtp *rtp)
115 {
116         return rtp->s;
117 }
118
119 int ast_rtcp_fd(struct ast_rtp *rtp)
120 {
121         if (rtp->rtcp)
122                 return rtp->rtcp->s;
123         return -1;
124 }
125
126 static int g723_len(unsigned char buf)
127 {
128         switch(buf & TYPE_MASK) {
129         case TYPE_DONTSEND:
130                 return 0;
131                 break;
132         case TYPE_SILENCE:
133                 return 4;
134                 break;
135         case TYPE_HIGH:
136                 return 24;
137                 break;
138         case TYPE_LOW:
139                 return 20;
140                 break;
141         default:
142                 ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", buf & TYPE_MASK);
143         }
144         return -1;
145 }
146
147 static int g723_samples(unsigned char *buf, int maxlen)
148 {
149         int pos = 0;
150         int samples = 0;
151         int res;
152         while(pos < maxlen) {
153                 res = g723_len(buf[pos]);
154                 if (res <= 0)
155                         break;
156                 samples += 240;
157                 pos += res;
158         }
159         return samples;
160 }
161
162 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
163 {
164         rtp->data = data;
165 }
166
167 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
168 {
169         rtp->callback = callback;
170 }
171
172 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
173 {
174         rtp->nat = nat;
175 }
176
177 static struct ast_frame *send_dtmf(struct ast_rtp *rtp)
178 {
179         struct timeval tv;
180         static struct ast_frame null_frame = { AST_FRAME_NULL, };
181         char iabuf[INET_ADDRSTRLEN];
182         gettimeofday(&tv, NULL);
183         if ((tv.tv_sec < rtp->dtmfmute.tv_sec) ||
184             ((tv.tv_sec == rtp->dtmfmute.tv_sec) && (tv.tv_usec < rtp->dtmfmute.tv_usec))) {
185                 ast_log(LOG_DEBUG, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
186                 rtp->resp = 0;
187                 rtp->dtmfduration = 0;
188                 return &null_frame;
189         }
190         ast_log(LOG_DEBUG, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
191         rtp->f.frametype = AST_FRAME_DTMF;
192         rtp->f.subclass = rtp->resp;
193         rtp->f.datalen = 0;
194         rtp->f.samples = 0;
195         rtp->f.mallocd = 0;
196         rtp->f.src = "RTP";
197         rtp->resp = 0;
198         rtp->dtmfduration = 0;
199         return &rtp->f;
200         
201 }
202
203 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
204 {
205         unsigned int event;
206         char resp = 0;
207         struct ast_frame *f = NULL;
208         event = ntohl(*((unsigned int *)(data)));
209         event &= 0x001F;
210 #if 0
211         printf("Cisco Digit: %08x (len = %d)\n", event, len);
212 #endif  
213         if (event < 10) {
214                 resp = '0' + event;
215         } else if (event < 11) {
216                 resp = '*';
217         } else if (event < 12) {
218                 resp = '#';
219         } else if (event < 16) {
220                 resp = 'A' + (event - 12);
221         }
222         if (rtp->resp && (rtp->resp != resp)) {
223                 f = send_dtmf(rtp);
224         }
225         rtp->resp = resp;
226         rtp->dtmfcount = dtmftimeout;
227         return f;
228 }
229
230 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len)
231 {
232         unsigned int event;
233         unsigned int event_end;
234         unsigned int duration;
235         char resp = 0;
236         struct ast_frame *f = NULL;
237         event = ntohl(*((unsigned int *)(data)));
238         event >>= 24;
239         event_end = ntohl(*((unsigned int *)(data)));
240         event_end <<= 8;
241         event_end >>= 24;
242         duration = ntohl(*((unsigned int *)(data)));
243         duration &= 0xFFFF;
244 #if 0
245         printf("Event: %08x (len = %d)\n", event, len);
246 #endif  
247         if (event < 10) {
248                 resp = '0' + event;
249         } else if (event < 11) {
250                 resp = '*';
251         } else if (event < 12) {
252                 resp = '#';
253         } else if (event < 16) {
254                 resp = 'A' + (event - 12);
255         }
256         if (rtp->resp && (rtp->resp != resp)) {
257                 f = send_dtmf(rtp);
258         }
259         else if(event_end & 0x80)
260         {
261                 if (rtp->resp) {
262                         f = send_dtmf(rtp);
263                         rtp->resp = 0;
264                 }
265                 resp = 0;
266                 duration = 0;
267         }
268         else if(rtp->dtmfduration && (duration < rtp->dtmfduration))
269         {
270                 f = send_dtmf(rtp);
271         }
272         if (!(event_end & 0x80))
273                 rtp->resp = resp;
274         rtp->dtmfcount = dtmftimeout;
275         rtp->dtmfduration = duration;
276         return f;
277 }
278
279 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
280 {
281         struct ast_frame *f = NULL;
282         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
283            totally help us out becuase we don't have an engine to keep it going and we are not
284            guaranteed to have it every 20ms or anything */
285 #if 1
286         printf("RFC3389: %d bytes, level %d...\n", len, rtp->lastrxformat);
287 #endif  
288         if (!(rtp->flags & FLAG_3389_WARNING)) {
289                 ast_log(LOG_NOTICE, "RFC3389 support incomplete.  Turn off on client if possible\n");
290                 rtp->flags |= FLAG_3389_WARNING;
291         }
292         /* Must have at least one byte */
293         if (!len)
294                 return NULL;
295         if (len < 24) {
296                 rtp->f.datalen = len - 1;
297                 memcpy(rtp->f.data, data + 1, len - 1);
298         } else {
299                 rtp->f.datalen = 0;
300         }
301         rtp->f.frametype = AST_FRAME_CNG;
302         rtp->f.subclass = data[0] & 0x7f;
303         rtp->f.datalen = len - 1;
304         rtp->f.samples = 0;
305         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
306         f = &rtp->f;
307         return f;
308 }
309
310 static int rtpread(int *id, int fd, short events, void *cbdata)
311 {
312         struct ast_rtp *rtp = cbdata;
313         struct ast_frame *f;
314         f = ast_rtp_read(rtp);
315         if (f) {
316                 if (rtp->callback)
317                         rtp->callback(rtp, f, rtp->data);
318         }
319         return 1;
320 }
321
322 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
323 {
324         static struct ast_frame null_frame = { AST_FRAME_NULL, };
325         int len;
326         int hdrlen = 8;
327         int res;
328         struct sockaddr_in sin;
329         unsigned int rtcpdata[1024];
330         char iabuf[INET_ADDRSTRLEN];
331         
332         if (!rtp->rtcp)
333                 return &null_frame;
334
335         len = sizeof(sin);
336         
337         res = recvfrom(rtp->rtcp->s, rtcpdata, sizeof(rtcpdata),
338                                         0, (struct sockaddr *)&sin, &len);
339         
340         if (res < 0) {
341                 if (errno == EAGAIN)
342                         ast_log(LOG_NOTICE, "RTP: Received packet with bad UDP checksum\n");
343                 else
344                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
345                 if (errno == EBADF)
346                         CRASH;
347                 return &null_frame;
348         }
349
350         if (res < hdrlen) {
351                 ast_log(LOG_WARNING, "RTP Read too short\n");
352                 return &null_frame;
353         }
354
355         if (rtp->nat) {
356                 /* Send to whoever sent to us */
357                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
358                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
359                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
360                         ast_log(LOG_DEBUG, "RTP NAT: Using address %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
361                 }
362         }
363         if (option_debug)
364                 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
365         return &null_frame;
366 }
367
368 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
369 {
370         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
371                 gettimeofday(&rtp->rxcore, NULL);
372                 rtp->rxcore.tv_sec -= timestamp / 8000;
373                 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
374                 /* Round to 20ms for nice, pretty timestamps */
375                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 20000;
376                 if (rtp->rxcore.tv_usec < 0) {
377                         /* Adjust appropriately if necessary */
378                         rtp->rxcore.tv_usec += 1000000;
379                         rtp->rxcore.tv_sec -= 1;
380                 }
381         }
382         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
383         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
384         if (tv->tv_usec >= 1000000) {
385                 tv->tv_usec -= 1000000;
386                 tv->tv_sec += 1;
387         }
388 }
389
390 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
391 {
392         int res;
393         struct sockaddr_in sin;
394         int len;
395         unsigned int seqno;
396         int payloadtype;
397         int hdrlen = 12;
398         int mark;
399         int ext;
400         char iabuf[INET_ADDRSTRLEN];
401         unsigned int timestamp;
402         unsigned int *rtpheader;
403         static struct ast_frame *f, null_frame = { AST_FRAME_NULL, };
404         struct rtpPayloadType rtpPT;
405         
406         len = sizeof(sin);
407         
408         /* Cache where the header will go */
409         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
410                                         0, (struct sockaddr *)&sin, &len);
411
412
413         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
414         if (res < 0) {
415                 if (errno == EAGAIN)
416                         ast_log(LOG_NOTICE, "RTP: Received packet with bad UDP checksum\n");
417                 else
418                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
419                 if (errno == EBADF)
420                         CRASH;
421                 return &null_frame;
422         }
423         if (res < hdrlen) {
424                 ast_log(LOG_WARNING, "RTP Read too short\n");
425                 return &null_frame;
426         }
427
428         /* Ignore if the other side hasn't been given an address
429            yet.  */
430         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
431                 return &null_frame;
432
433         if (rtp->nat) {
434                 /* Send to whoever sent to us */
435                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
436                     (rtp->them.sin_port != sin.sin_port)) {
437                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
438                         ast_log(LOG_DEBUG, "RTP NAT: Using address %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port));
439                 }
440         }
441
442         /* Get fields */
443         seqno = ntohl(rtpheader[0]);
444         payloadtype = (seqno & 0x7f0000) >> 16;
445         mark = seqno & (1 << 23);
446         ext = seqno & (1 << 28);
447         seqno &= 0xffff;
448         timestamp = ntohl(rtpheader[1]);
449         if (ext) {
450                 /* RTP Extension present */
451                 hdrlen += 4;
452                 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2;
453         }
454
455         if (res < hdrlen) {
456                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
457                 return &null_frame;
458         }
459
460 #if 0
461         printf("Got RTP packet from %s:%d (type %d, seq %d, ts %d, len = %d)\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
462 #endif  
463         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
464         if (!rtpPT.isAstFormat) {
465           /* This is special in-band data that's not one of our codecs */
466           if (rtpPT.code == AST_RTP_DTMF) {
467             /* It's special -- rfc2833 process it */
468             if (rtp->lasteventseqn <= seqno) {
469               f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
470               rtp->lasteventseqn = seqno;
471             }
472             if (f) return f; else return &null_frame;
473           } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
474             /* It's really special -- process it the Cisco way */
475             if (rtp->lasteventseqn <= seqno) {
476               f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
477               rtp->lasteventseqn = seqno;
478             }
479             if (f) return f; else return &null_frame;
480           } else if (rtpPT.code == AST_RTP_CN) {
481             /* Comfort Noise */
482             f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
483             if (f) return f; else return &null_frame;
484           } else {
485             ast_log(LOG_NOTICE, "Unknown RTP codec %d received\n", payloadtype);
486             return &null_frame;
487           }
488         }
489         rtp->f.subclass = rtpPT.code;
490         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO)
491                 rtp->f.frametype = AST_FRAME_VOICE;
492         else
493                 rtp->f.frametype = AST_FRAME_VIDEO;
494         rtp->lastrxformat = rtp->f.subclass;
495
496         if (!rtp->lastrxts)
497                 rtp->lastrxts = timestamp;
498
499         if (rtp->dtmfcount) {
500 #if 0
501                 printf("dtmfcount was %d\n", rtp->dtmfcount);
502 #endif          
503                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
504                 if (rtp->dtmfcount < 0)
505                         rtp->dtmfcount = 0;
506 #if 0
507                 if (dtmftimeout != rtp->dtmfcount)
508                         printf("dtmfcount is %d\n", rtp->dtmfcount);
509 #endif
510         }
511         rtp->lastrxts = timestamp;
512
513         /* Send any pending DTMF */
514         if (rtp->resp && !rtp->dtmfcount) {
515                 ast_log(LOG_DEBUG, "Sending pending DTMF\n");
516                 return send_dtmf(rtp);
517         }
518         rtp->f.mallocd = 0;
519         rtp->f.datalen = res - hdrlen;
520         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
521         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
522         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
523                 switch(rtp->f.subclass) {
524                 case AST_FORMAT_ULAW:
525                 case AST_FORMAT_ALAW:
526                         rtp->f.samples = rtp->f.datalen;
527                         break;
528                 case AST_FORMAT_SLINEAR:
529                         rtp->f.samples = rtp->f.datalen / 2;
530                         break;
531                 case AST_FORMAT_GSM:
532                         rtp->f.samples = 160 * (rtp->f.datalen / 33);
533                         break;
534                 case AST_FORMAT_ILBC:
535                         rtp->f.samples = 240 * (rtp->f.datalen / 50);
536                         break;
537                 case AST_FORMAT_ADPCM:
538                 case AST_FORMAT_G726:
539                         rtp->f.samples = rtp->f.datalen * 2;
540                         break;
541                 case AST_FORMAT_G729A:
542                         rtp->f.samples = rtp->f.datalen * 8;
543                         break;
544                 case AST_FORMAT_G723_1:
545                         rtp->f.samples = g723_samples(rtp->f.data, rtp->f.datalen);
546                         break;
547                 case AST_FORMAT_SPEEX:
548                         rtp->f.samples = 160;
549                         /* assumes that the RTP packet contained one Speex frame */
550                         break;
551                 default:
552                         ast_log(LOG_NOTICE, "Unable to calculate samples for format %s\n", ast_getformatname(rtp->f.subclass));
553                         break;
554                 }
555                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
556         } else {
557                 /* Video -- samples is # of samples vs. 90000 */
558                 if (!rtp->lastividtimestamp)
559                         rtp->lastividtimestamp = timestamp;
560                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
561                 rtp->lastividtimestamp = timestamp;
562                 rtp->f.delivery.tv_sec = 0;
563                 rtp->f.delivery.tv_usec = 0;
564                 if (mark)
565                         rtp->f.subclass |= 0x1;
566                 
567         }
568         rtp->f.src = "RTP";
569         return &rtp->f;
570 }
571
572 /* The following array defines the MIME Media type (and subtype) for each
573    of our codecs, or RTP-specific data type. */
574 static struct {
575   struct rtpPayloadType payloadType;
576   char* type;
577   char* subtype;
578 } mimeTypes[] = {
579   {{1, AST_FORMAT_G723_1}, "audio", "G723"},
580   {{1, AST_FORMAT_GSM}, "audio", "GSM"},
581   {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
582   {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
583   {{1, AST_FORMAT_G726}, "audio", "G726-32"},
584   {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
585   {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
586   {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
587   {{1, AST_FORMAT_G729A}, "audio", "G729"},
588   {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
589   {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
590   {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
591   {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
592   {{0, AST_RTP_CN}, "audio", "CN"},
593   {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
594   {{1, AST_FORMAT_PNG}, "video", "PNG"},
595   {{1, AST_FORMAT_H261}, "video", "H261"},
596   {{1, AST_FORMAT_H263}, "video", "H263"},
597 };
598
599 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
600    also, our own choices for dynamic payload types.  This is our master
601    table for transmission */
602 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
603   [0] = {1, AST_FORMAT_ULAW},
604   [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
605   [3] = {1, AST_FORMAT_GSM},
606   [4] = {1, AST_FORMAT_G723_1},
607   [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
608   [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
609   [7] = {1, AST_FORMAT_LPC10},
610   [8] = {1, AST_FORMAT_ALAW},
611   [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
612   [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
613   [13] = {0, AST_RTP_CN},
614   [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
615   [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
616   [18] = {1, AST_FORMAT_G729A},
617   [19] = {0, AST_RTP_CN},               /* Also used for CN */
618   [26] = {1, AST_FORMAT_JPEG},
619   [31] = {1, AST_FORMAT_H261},
620   [34] = {1, AST_FORMAT_H263},
621   [97] = {1, AST_FORMAT_ILBC},
622   [101] = {0, AST_RTP_DTMF},
623   [110] = {1, AST_FORMAT_SPEEX},
624   [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
625 };
626
627 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
628 {
629   int i;
630
631   for (i = 0; i < MAX_RTP_PT; ++i) {
632     rtp->current_RTP_PT[i].isAstFormat = 0;
633     rtp->current_RTP_PT[i].code = 0;
634   }
635
636   rtp->rtp_lookup_code_cache_isAstFormat = 0;
637   rtp->rtp_lookup_code_cache_code = 0;
638   rtp->rtp_lookup_code_cache_result = 0;
639 }
640
641 void ast_rtp_pt_default(struct ast_rtp* rtp) 
642 {
643   int i;
644   /* Initialize to default payload types */
645   for (i = 0; i < MAX_RTP_PT; ++i) {
646     rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
647     rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
648   }
649
650   rtp->rtp_lookup_code_cache_isAstFormat = 0;
651   rtp->rtp_lookup_code_cache_code = 0;
652   rtp->rtp_lookup_code_cache_result = 0;
653 }
654
655 /* Make a note of a RTP payload type that was seen in a SDP "m=" line. */
656 /* By default, use the well-known value for this type (although it may */
657 /* still be set to a different value by a subsequent "a=rtpmap:" line): */
658 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) {
659   if (pt < 0 || pt > MAX_RTP_PT) return; /* bogus payload type */
660
661   if (static_RTP_PT[pt].code != 0) {
662     rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
663   }
664
665
666 /* Make a note of a RTP payload type (with MIME type) that was seen in */
667 /* a SDP "a=rtpmap:" line. */
668 void ast_rtp_set_rtpmap_type(struct ast_rtp* rtp, int pt,
669                          char* mimeType, char* mimeSubtype) {
670   int i;
671
672   if (pt < 0 || pt > MAX_RTP_PT) return; /* bogus payload type */
673
674   for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
675     if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
676         strcasecmp(mimeType, mimeTypes[i].type) == 0) {
677       rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
678       return;
679     }
680   }
681
682
683 /* Return the union of all of the codecs that were set by rtp_set...() calls */
684 /* They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
685 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
686                              int* astFormats, int* nonAstFormats) {
687   int pt;
688
689   *astFormats = *nonAstFormats = 0;
690   for (pt = 0; pt < MAX_RTP_PT; ++pt) {
691     if (rtp->current_RTP_PT[pt].isAstFormat) {
692       *astFormats |= rtp->current_RTP_PT[pt].code;
693     } else {
694       *nonAstFormats |= rtp->current_RTP_PT[pt].code;
695     }
696   }
697 }
698
699 void ast_rtp_offered_from_local(struct ast_rtp* rtp, int local) {
700   if (rtp)
701     rtp->rtp_offered_from_local = local;
702   else
703     ast_log(LOG_WARNING, "rtp structure is null\n");
704 }
705
706 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
707 {
708   struct rtpPayloadType result;
709
710   result.isAstFormat = result.code = 0;
711   if (pt < 0 || pt > MAX_RTP_PT) {
712     return result; /* bogus payload type */
713   }
714   /* Start with the negotiated codecs */
715   if (!rtp->rtp_offered_from_local)
716     result = rtp->current_RTP_PT[pt];
717   /* If it doesn't exist, check our static RTP type list, just in case */
718   if (!result.code) 
719     result = static_RTP_PT[pt];
720   return result;
721 }
722
723 /* Looks up an RTP code out of our *static* outbound list */
724 int ast_rtp_lookup_code(struct ast_rtp* rtp, int isAstFormat, int code) {
725   int pt;
726
727
728   if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
729       code == rtp->rtp_lookup_code_cache_code) {
730     /* Use our cached mapping, to avoid the overhead of the loop below */
731     return rtp->rtp_lookup_code_cache_result;
732   }
733
734         /* Check the dynamic list first */
735   for (pt = 0; pt < MAX_RTP_PT; ++pt) {
736     if (rtp->current_RTP_PT[pt].code == code &&
737                 rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
738       rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
739       rtp->rtp_lookup_code_cache_code = code;
740       rtp->rtp_lookup_code_cache_result = pt;
741       return pt;
742     }
743   }
744
745         /* Then the static list */
746   for (pt = 0; pt < MAX_RTP_PT; ++pt) {
747     if (static_RTP_PT[pt].code == code &&
748                 static_RTP_PT[pt].isAstFormat == isAstFormat) {
749       rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
750       rtp->rtp_lookup_code_cache_code = code;
751       rtp->rtp_lookup_code_cache_result = pt;
752       return pt;
753     }
754   }
755   return -1;
756 }
757
758 char* ast_rtp_lookup_mime_subtype(int isAstFormat, int code) {
759   int i;
760
761   for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
762     if (mimeTypes[i].payloadType.code == code &&
763         mimeTypes[i].payloadType.isAstFormat == isAstFormat) {
764       return mimeTypes[i].subtype;
765     }
766   }
767   return "";
768 }
769
770 static int rtp_socket(void)
771 {
772         int s;
773         long flags;
774         s = socket(AF_INET, SOCK_DGRAM, 0);
775         if (s > -1) {
776                 flags = fcntl(s, F_GETFL);
777                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
778 #ifdef SO_NO_CHECK
779                 if (checksums) {
780                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &checksums, sizeof(checksums));
781                 }
782 #endif
783         }
784         return s;
785 }
786
787 static struct ast_rtcp *ast_rtcp_new(void)
788 {
789         struct ast_rtcp *rtcp;
790         rtcp = malloc(sizeof(struct ast_rtcp));
791         if (!rtcp)
792                 return NULL;
793         memset(rtcp, 0, sizeof(struct ast_rtcp));
794         rtcp->s = rtp_socket();
795         rtcp->us.sin_family = AF_INET;
796         if (rtcp->s < 0) {
797                 free(rtcp);
798                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
799                 return NULL;
800         }
801         return rtcp;
802 }
803
804 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
805 {
806         struct ast_rtp *rtp;
807         int x;
808         int first;
809         int startplace;
810         rtp = malloc(sizeof(struct ast_rtp));
811         if (!rtp)
812                 return NULL;
813         memset(rtp, 0, sizeof(struct ast_rtp));
814         rtp->them.sin_family = AF_INET;
815         rtp->us.sin_family = AF_INET;
816         rtp->s = rtp_socket();
817         rtp->ssrc = rand();
818         rtp->seqno = rand() & 0xffff;
819         if (rtp->s < 0) {
820                 free(rtp);
821                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
822                 return NULL;
823         }
824         if (sched && rtcpenable) {
825                 rtp->sched = sched;
826                 rtp->rtcp = ast_rtcp_new();
827         }
828         /* Find us a place */
829         x = (rand() % (rtpend-rtpstart)) + rtpstart;
830         x = x & ~1;
831         startplace = x;
832         for (;;) {
833                 /* Must be an even port number by RTP spec */
834                 rtp->us.sin_port = htons(x);
835                 rtp->us.sin_addr = addr;
836                 if (rtp->rtcp)
837                         rtp->rtcp->us.sin_port = htons(x + 1);
838                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
839                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
840                         break;
841                 if (!first) {
842                         /* Primary bind succeeded! Gotta recreate it */
843                         close(rtp->s);
844                         rtp->s = rtp_socket();
845                 }
846                 if (errno != EADDRINUSE) {
847                         ast_log(LOG_WARNING, "Unexpected bind error: %s\n", strerror(errno));
848                         close(rtp->s);
849                         if (rtp->rtcp) {
850                                 close(rtp->rtcp->s);
851                                 free(rtp->rtcp);
852                         }
853                         free(rtp);
854                         return NULL;
855                 }
856                 x += 2;
857                 if (x > rtpend)
858                         x = (rtpstart + 1) & ~1;
859                 if (x == startplace) {
860                         ast_log(LOG_WARNING, "No RTP ports remaining\n");
861                         close(rtp->s);
862                         if (rtp->rtcp) {
863                                 close(rtp->rtcp->s);
864                                 free(rtp->rtcp);
865                         }
866                         free(rtp);
867                         return NULL;
868                 }
869         }
870         if (io && sched && callbackmode) {
871                 /* Operate this one in a callback mode */
872                 rtp->sched = sched;
873                 rtp->io = io;
874                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
875         }
876         ast_rtp_pt_default(rtp);
877         return rtp;
878 }
879
880 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
881 {
882         struct in_addr ia;
883         memset(&ia, 0, sizeof(ia));
884         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
885 }
886
887 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
888 {
889         int res;
890         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
891                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
892         return res;
893 }
894
895 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
896 {
897         rtp->them.sin_port = them->sin_port;
898         rtp->them.sin_addr = them->sin_addr;
899         if (rtp->rtcp) {
900                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
901                 rtp->rtcp->them.sin_addr = them->sin_addr;
902         }
903 }
904
905 void ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
906 {
907         them->sin_family = AF_INET;
908         them->sin_port = rtp->them.sin_port;
909         them->sin_addr = rtp->them.sin_addr;
910 }
911
912 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
913 {
914         memcpy(us, &rtp->us, sizeof(rtp->us));
915 }
916
917 void ast_rtp_stop(struct ast_rtp *rtp)
918 {
919         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
920         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
921         if (rtp->rtcp) {
922                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
923                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->them.sin_port));
924         }
925 }
926
927 void ast_rtp_destroy(struct ast_rtp *rtp)
928 {
929         if (rtp->smoother)
930                 ast_smoother_free(rtp->smoother);
931         if (rtp->ioid)
932                 ast_io_remove(rtp->io, rtp->ioid);
933         if (rtp->s > -1)
934                 close(rtp->s);
935         if (rtp->rtcp) {
936                 close(rtp->rtcp->s);
937                 free(rtp->rtcp);
938         }
939         free(rtp);
940 }
941
942 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
943 {
944         struct timeval now;
945         unsigned int ms;
946         if (!rtp->txcore.tv_sec && !rtp->txcore.tv_usec) {
947                 gettimeofday(&rtp->txcore, NULL);
948                 /* Round to 20ms for nice, pretty timestamps */
949                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
950         }
951         if (delivery && (delivery->tv_sec || delivery->tv_usec)) {
952                 /* Use previous txcore */
953                 ms = (delivery->tv_sec - rtp->txcore.tv_sec) * 1000;
954                 ms += (1000000 + delivery->tv_usec - rtp->txcore.tv_usec) / 1000 - 1000;
955                 rtp->txcore.tv_sec = delivery->tv_sec;
956                 rtp->txcore.tv_usec = delivery->tv_usec;
957         } else {
958                 gettimeofday(&now, NULL);
959                 ms = (now.tv_sec - rtp->txcore.tv_sec) * 1000;
960                 ms += (1000000 + now.tv_usec - rtp->txcore.tv_usec) / 1000 - 1000;
961                 /* Use what we just got for next time */
962                 rtp->txcore.tv_sec = now.tv_sec;
963                 rtp->txcore.tv_usec = now.tv_usec;
964         }
965         return ms;
966 }
967
968 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
969 {
970         unsigned int *rtpheader;
971         int hdrlen = 12;
972         int res;
973         int ms;
974         int x;
975         int payload;
976         char data[256];
977         char iabuf[INET_ADDRSTRLEN];
978
979         if ((digit <= '9') && (digit >= '0'))
980                 digit -= '0';
981         else if (digit == '*')
982                 digit = 10;
983         else if (digit == '#')
984                 digit = 11;
985         else if ((digit >= 'A') && (digit <= 'D')) 
986                 digit = digit - 'A' + 12;
987         else if ((digit >= 'a') && (digit <= 'd')) 
988                 digit = digit - 'a' + 12;
989         else {
990                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
991                 return -1;
992         }
993         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
994
995         /* If we have no peer, return immediately */    
996         if (!rtp->them.sin_addr.s_addr)
997                 return 0;
998
999         gettimeofday(&rtp->dtmfmute, NULL);
1000         rtp->dtmfmute.tv_usec += (500 * 1000);
1001         if (rtp->dtmfmute.tv_usec > 1000000) {
1002                 rtp->dtmfmute.tv_usec -= 1000000;
1003                 rtp->dtmfmute.tv_sec += 1;
1004         }
1005
1006         ms = calc_txstamp(rtp, NULL);
1007         /* Default prediction */
1008         rtp->lastts = rtp->lastts + ms * 8;
1009         
1010         /* Get a pointer to the header */
1011         rtpheader = (unsigned int *)data;
1012         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1013         rtpheader[1] = htonl(rtp->lastts);
1014         rtpheader[2] = htonl(rtp->ssrc); 
1015         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
1016         for (x=0;x<4;x++) {
1017                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1018                         res = sendto(rtp->s, (void *)rtpheader, hdrlen + 4, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1019                         if (res <0) 
1020                                 ast_log(LOG_NOTICE, "RTP Transmission error to %s:%d: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
1021         #if 0
1022                 printf("Sent %d bytes of RTP data to %s:%d\n", res, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port));
1023         #endif          
1024                 }
1025                 if (x ==0) {
1026                         /* Clear marker bit and increment seqno */
1027                         rtpheader[0] = htonl((2 << 30)  | (payload << 16) | (rtp->seqno++));
1028                         /* Make duration 800 (100ms) */
1029                         rtpheader[3] |= htonl((800));
1030                         /* Set the End bit for the last 3 */
1031                         rtpheader[3] |= htonl((1 << 23));
1032                 }
1033         }
1034         return 0;
1035 }
1036
1037 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
1038 {
1039         unsigned int *rtpheader;
1040         char iabuf[INET_ADDRSTRLEN];
1041         int hdrlen = 12;
1042         int res;
1043         int ms;
1044         int pred;
1045         int mark = 0;
1046
1047         ms = calc_txstamp(rtp, &f->delivery);
1048         /* Default prediction */
1049         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
1050                 pred = rtp->lastts + ms * 8;
1051                 
1052                 switch(f->subclass) {
1053                 case AST_FORMAT_ULAW:
1054                 case AST_FORMAT_ALAW:
1055                         /* If we're within +/- 20ms from when where we
1056                            predict we should be, use that */
1057                         pred = rtp->lastts + f->datalen;
1058                         break;
1059                 case AST_FORMAT_ADPCM:
1060                 case AST_FORMAT_G726:
1061                         /* If we're within +/- 20ms from when where we
1062                            predict we should be, use that */
1063                         pred = rtp->lastts + f->datalen * 2;
1064                         break;
1065                 case AST_FORMAT_G729A:
1066                         pred = rtp->lastts + f->datalen * 8;
1067                         break;
1068                 case AST_FORMAT_GSM:
1069                         pred = rtp->lastts + (f->datalen * 160 / 33);
1070                         break;
1071                 case AST_FORMAT_ILBC:
1072                         pred = rtp->lastts + (f->datalen * 240 / 50);
1073                         break;
1074                 case AST_FORMAT_G723_1:
1075                         pred = rtp->lastts + g723_samples(f->data, f->datalen);
1076                         break;
1077                 case AST_FORMAT_SPEEX:
1078                     pred = rtp->lastts + 160;
1079                         /* assumes that the RTP packet contains one Speex frame */
1080                         break;
1081                 default:
1082                         ast_log(LOG_WARNING, "Not sure about timestamp format for codec format %s\n", ast_getformatname(f->subclass));
1083                 }
1084                 /* Re-calculate last TS */
1085                 rtp->lastts = rtp->lastts + ms * 8;
1086                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1087                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
1088                            and if so, go with our prediction */
1089                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
1090                                 rtp->lastts = pred;
1091                         else {
1092                                 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1093                                 mark = 1;
1094                         }
1095                 }
1096         } else {
1097                 mark = f->subclass & 0x1;
1098                 pred = rtp->lastovidtimestamp + f->samples;
1099                 /* Re-calculate last TS */
1100                 rtp->lastts = rtp->lastts + ms * 90;
1101                 /* If it's close to our prediction, go for it */
1102                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1103                         if (abs(rtp->lastts - pred) < 7200) {
1104                                 rtp->lastts = pred;
1105                                 rtp->lastovidtimestamp += f->samples;
1106                         } else {
1107                                 ast_log(LOG_DEBUG, "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);
1108                                 rtp->lastovidtimestamp = rtp->lastts;
1109                         }
1110                 }
1111         }
1112         /* Get a pointer to the header */
1113         rtpheader = (unsigned int *)(f->data - hdrlen);
1114         rtpheader[0] = htonl((2 << 30) | (codec << 16) | (rtp->seqno++) | (mark << 23));
1115         rtpheader[1] = htonl(rtp->lastts);
1116         rtpheader[2] = htonl(rtp->ssrc); 
1117         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1118                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1119                 if (res <0) 
1120                         ast_log(LOG_NOTICE, "RTP Transmission error to %s:%d: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
1121 #if 0
1122                 printf("Sent %d bytes of RTP data to %s:%d\n", res, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port));
1123 #endif          
1124         }
1125         return 0;
1126 }
1127
1128 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1129 {
1130         struct ast_frame *f;
1131         int codec;
1132         int hdrlen = 12;
1133         int subclass;
1134         
1135
1136         /* If we have no peer, return immediately */    
1137         if (!rtp->them.sin_addr.s_addr)
1138                 return 0;
1139
1140         /* If there is no data length, return immediately */
1141         if (!_f->datalen) 
1142                 return 0;
1143         
1144         /* Make sure we have enough space for RTP header */
1145         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1146                 ast_log(LOG_WARNING, "RTP can only send voice\n");
1147                 return -1;
1148         }
1149
1150         subclass = _f->subclass;
1151         if (_f->frametype == AST_FRAME_VIDEO)
1152                 subclass &= ~0x1;
1153
1154         codec = ast_rtp_lookup_code(rtp, 1, subclass);
1155         if (codec < 0) {
1156                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1157                 return -1;
1158         }
1159
1160         if (rtp->lasttxformat != subclass) {
1161                 /* New format, reset the smoother */
1162                 ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1163                 rtp->lasttxformat = subclass;
1164                 if (rtp->smoother)
1165                         ast_smoother_free(rtp->smoother);
1166                 rtp->smoother = NULL;
1167         }
1168
1169
1170         switch(subclass) {
1171         case AST_FORMAT_ULAW:
1172         case AST_FORMAT_ALAW:
1173                 if (!rtp->smoother) {
1174                         rtp->smoother = ast_smoother_new(160);
1175                 }
1176                 if (!rtp->smoother) {
1177                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1178                         return -1;
1179                 }
1180                 ast_smoother_feed(rtp->smoother, _f);
1181                 
1182                 while((f = ast_smoother_read(rtp->smoother)))
1183                         ast_rtp_raw_write(rtp, f, codec);
1184                 break;
1185         case AST_FORMAT_ADPCM:
1186         case AST_FORMAT_G726:
1187                 if (!rtp->smoother) {
1188                         rtp->smoother = ast_smoother_new(80);
1189                 }
1190                 if (!rtp->smoother) {
1191                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1192                         return -1;
1193                 }
1194                 ast_smoother_feed(rtp->smoother, _f);
1195                 
1196                 while((f = ast_smoother_read(rtp->smoother)))
1197                         ast_rtp_raw_write(rtp, f, codec);
1198                 break;
1199         case AST_FORMAT_G729A:
1200                 if (!rtp->smoother) {
1201                         rtp->smoother = ast_smoother_new(20);
1202                         if (rtp->smoother)
1203                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1204                 }
1205                 if (!rtp->smoother) {
1206                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1207                         return -1;
1208                 }
1209                 ast_smoother_feed(rtp->smoother, _f);
1210                 
1211                 while((f = ast_smoother_read(rtp->smoother)))
1212                         ast_rtp_raw_write(rtp, f, codec);
1213                 break;
1214         case AST_FORMAT_GSM:
1215                 if (!rtp->smoother) {
1216                         rtp->smoother = ast_smoother_new(33);
1217                 }
1218                 if (!rtp->smoother) {
1219                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1220                         return -1;
1221                 }
1222                 ast_smoother_feed(rtp->smoother, _f);
1223                 while((f = ast_smoother_read(rtp->smoother)))
1224                         ast_rtp_raw_write(rtp, f, codec);
1225                 break;
1226         case AST_FORMAT_ILBC:
1227                 if (!rtp->smoother) {
1228                         rtp->smoother = ast_smoother_new(50);
1229                 }
1230                 if (!rtp->smoother) {
1231                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1232                         return -1;
1233                 }
1234                 ast_smoother_feed(rtp->smoother, _f);
1235                 while((f = ast_smoother_read(rtp->smoother)))
1236                         ast_rtp_raw_write(rtp, f, codec);
1237                 break;
1238         default:        
1239                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1240                 /* fall through to... */
1241         case AST_FORMAT_H261:
1242         case AST_FORMAT_H263:
1243         case AST_FORMAT_G723_1:
1244         case AST_FORMAT_SPEEX:
1245                 /* Don't buffer outgoing frames; send them one-per-packet: */
1246                 if (_f->offset < hdrlen) {
1247                         f = ast_frdup(_f);
1248                 } else {
1249                         f = _f;
1250                 }
1251                 ast_rtp_raw_write(rtp, f, codec);
1252         }
1253                 
1254         return 0;
1255 }
1256
1257 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1258 {
1259         struct ast_rtp_protocol *cur, *prev;
1260         cur = protos;
1261         prev = NULL;
1262         while(cur) {
1263                 if (cur == proto) {
1264                         if (prev)
1265                                 prev->next = proto->next;
1266                         else
1267                                 protos = proto->next;
1268                         return;
1269                 }
1270                 prev = cur;
1271                 cur = cur->next;
1272         }
1273 }
1274
1275 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1276 {
1277         struct ast_rtp_protocol *cur;
1278         cur = protos;
1279         while(cur) {
1280                 if (cur->type == proto->type) {
1281                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1282                         return -1;
1283                 }
1284                 cur = cur->next;
1285         }
1286         proto->next = protos;
1287         protos = proto;
1288         return 0;
1289 }
1290
1291 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1292 {
1293         struct ast_rtp_protocol *cur;
1294         cur = protos;
1295         while(cur) {
1296                 if (cur->type == chan->type) {
1297                         return cur;
1298                 }
1299                 cur = cur->next;
1300         }
1301         return NULL;
1302 }
1303
1304 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
1305 {
1306         struct ast_frame *f;
1307         struct ast_channel *who, *cs[3];
1308         struct ast_rtp *p0, *p1;
1309         struct ast_rtp *vp0, *vp1;
1310         struct ast_rtp_protocol *pr0, *pr1;
1311         struct sockaddr_in ac0, ac1;
1312         struct sockaddr_in vac0, vac1;
1313         struct sockaddr_in t0, t1;
1314         struct sockaddr_in vt0, vt1;
1315         char iabuf[INET_ADDRSTRLEN];
1316         
1317         void *pvt0, *pvt1;
1318         int to;
1319         int codec0,codec1, oldcodec0, oldcodec1;
1320         
1321         memset(&vt0, 0, sizeof(vt0));
1322         memset(&vt1, 0, sizeof(vt1));
1323         memset(&vac0, 0, sizeof(vac0));
1324         memset(&vac1, 0, sizeof(vac1));
1325
1326         /* if need DTMF, cant native bridge */
1327         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
1328                 return -2;
1329         ast_mutex_lock(&c0->lock);
1330         while(ast_mutex_trylock(&c1->lock)) {
1331                 ast_mutex_unlock(&c0->lock);
1332                 usleep(1);
1333                 ast_mutex_lock(&c0->lock);
1334         }
1335         pr0 = get_proto(c0);
1336         pr1 = get_proto(c1);
1337         if (!pr0) {
1338                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1339                 ast_mutex_unlock(&c0->lock);
1340                 ast_mutex_unlock(&c1->lock);
1341                 return -1;
1342         }
1343         if (!pr1) {
1344                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1345                 ast_mutex_unlock(&c0->lock);
1346                 ast_mutex_unlock(&c1->lock);
1347                 return -1;
1348         }
1349         pvt0 = c0->pvt->pvt;
1350         pvt1 = c1->pvt->pvt;
1351         p0 = pr0->get_rtp_info(c0);
1352         if (pr0->get_vrtp_info)
1353                 vp0 = pr0->get_vrtp_info(c0);
1354         else
1355                 vp0 = NULL;
1356         p1 = pr1->get_rtp_info(c1);
1357         if (pr1->get_vrtp_info)
1358                 vp1 = pr1->get_vrtp_info(c1);
1359         else
1360                 vp1 = NULL;
1361         if (!p0 || !p1) {
1362                 /* Somebody doesn't want to play... */
1363                 ast_mutex_unlock(&c0->lock);
1364                 ast_mutex_unlock(&c1->lock);
1365                 return -2;
1366         }
1367         if (pr0->get_codec)
1368                 codec0 = pr0->get_codec(c0);
1369         else
1370                 codec0 = 0;
1371         if (pr1->get_codec)
1372                 codec1 = pr1->get_codec(c1);
1373         else
1374                 codec1 = 0;
1375         if (pr0->get_codec && pr1->get_codec) {
1376                 /* Hey, we can't do reinvite if both parties speak diffrent codecs */
1377                 if (!(codec0 & codec1)) {
1378                         ast_log(LOG_WARNING, "codec0 = %d is not codec1 = %d, cannot native bridge.\n",codec0,codec1);
1379                         ast_mutex_unlock(&c0->lock);
1380                         ast_mutex_unlock(&c1->lock);
1381                         return -2;
1382                 }
1383         }
1384         if (pr0->set_rtp_peer(c0, p1, vp1, codec1)) 
1385                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1386         else {
1387                 /* Store RTP peer */
1388                 ast_rtp_get_peer(p1, &ac1);
1389                 if (vp1)
1390                         ast_rtp_get_peer(vp1, &vac1);
1391         }
1392         if (pr1->set_rtp_peer(c1, p0, vp0, codec0))
1393                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1394         else {
1395                 /* Store RTP peer */
1396                 ast_rtp_get_peer(p0, &ac0);
1397                 if (vp0)
1398                         ast_rtp_get_peer(vp0, &vac0);
1399         }
1400         ast_mutex_unlock(&c0->lock);
1401         ast_mutex_unlock(&c1->lock);
1402         cs[0] = c0;
1403         cs[1] = c1;
1404         cs[2] = NULL;
1405         oldcodec0 = codec0;
1406         oldcodec1 = codec1;
1407         for (;;) {
1408                 if ((c0->pvt->pvt != pvt0)  ||
1409                         (c1->pvt->pvt != pvt1) ||
1410                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
1411                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
1412                                 if (c0->pvt->pvt == pvt0) {
1413                                         if (pr0->set_rtp_peer(c0, NULL, NULL, 0)) 
1414                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1415                                 }
1416                                 if (c1->pvt->pvt == pvt1) {
1417                                         if (pr1->set_rtp_peer(c1, NULL, NULL, 0)) 
1418                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1419                                 }
1420                                 /* Tell it to try again later */
1421                                 return -3;
1422                 }
1423                 to = -1;
1424                 ast_rtp_get_peer(p1, &t1);
1425                 ast_rtp_get_peer(p0, &t0);
1426                 if (pr0->get_codec)
1427                         codec0 = pr0->get_codec(c0);
1428                 if (pr1->get_codec)
1429                         codec1 = pr1->get_codec(c1);
1430                 if (vp1)
1431                         ast_rtp_get_peer(vp1, &vt1);
1432                 if (vp0)
1433                         ast_rtp_get_peer(vp0, &vt0);
1434                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1)) || (codec1 != oldcodec1)) {
1435                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
1436                                 c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t1.sin_addr), ntohs(t1.sin_port), codec1);
1437                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n", 
1438                                 c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vt1.sin_addr), ntohs(vt1.sin_port), codec1);
1439                         ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
1440                                 c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
1441                         ast_log(LOG_DEBUG, "Oooh, '%s' wasv %s:%d/(format %d)\n", 
1442                                 c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
1443                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, codec1)) 
1444                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
1445                         memcpy(&ac1, &t1, sizeof(ac1));
1446                         memcpy(&vac1, &vt1, sizeof(vac1));
1447                         oldcodec1 = codec1;
1448                 }
1449                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
1450                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
1451                                 c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t0.sin_addr), ntohs(t0.sin_port), codec0);
1452                         ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
1453                                 c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
1454                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, codec0))
1455                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1456                         memcpy(&ac0, &t0, sizeof(ac0));
1457                         memcpy(&vac0, &vt0, sizeof(vac0));
1458                         oldcodec0 = codec0;
1459                 }
1460                 who = ast_waitfor_n(cs, 2, &to);
1461                 if (!who) {
1462                         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1463                         /* check for hagnup / whentohangup */
1464                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
1465                                 break;
1466                         continue;
1467                 }
1468                 f = ast_read(who);
1469                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1470                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
1471                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1472                         *fo = f;
1473                         *rc = who;
1474                         ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1475                         if ((c0->pvt->pvt == pvt0) && (!c0->_softhangup)) {
1476                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0)) 
1477                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1478                         }
1479                         if ((c1->pvt->pvt == pvt1) && (!c1->_softhangup)) {
1480                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0)) 
1481                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1482                         }
1483                         /* That's all we needed */
1484                         return 0;
1485                 } else {
1486                         if ((f->frametype == AST_FRAME_DTMF) || 
1487                                 (f->frametype == AST_FRAME_VOICE) || 
1488                                 (f->frametype == AST_FRAME_VIDEO)) {
1489                                 /* Forward voice or DTMF frames if they happen upon us */
1490                                 if (who == c0) {
1491                                         ast_write(c1, f);
1492                                 } else if (who == c1) {
1493                                         ast_write(c0, f);
1494                                 }
1495                         }
1496                         ast_frfree(f);
1497                 }
1498                 /* Swap priority not that it's a big deal at this point */
1499                 cs[2] = cs[0];
1500                 cs[0] = cs[1];
1501                 cs[1] = cs[2];
1502                 
1503         }
1504         return -1;
1505 }
1506
1507 void ast_rtp_reload(void)
1508 {
1509         struct ast_config *cfg;
1510         char *s;
1511         rtpstart = 5000;
1512         rtpend = 31000;
1513 #ifdef SO_NO_CHECK
1514         checksums = 1;
1515 #endif
1516         cfg = ast_load("rtp.conf");
1517         if (cfg) {
1518                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
1519                         rtpstart = atoi(s);
1520                         if (rtpstart < 1024)
1521                                 rtpstart = 1024;
1522                         if (rtpstart > 65535)
1523                                 rtpstart = 65535;
1524                 }
1525                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
1526                         rtpend = atoi(s);
1527                         if (rtpend < 1024)
1528                                 rtpend = 1024;
1529                         if (rtpend > 65535)
1530                                 rtpend = 65535;
1531                 }
1532                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
1533 #ifdef SO_NO_CHECK
1534                         if (ast_true(s))
1535                                 checksums = 1;
1536                         else
1537                                 checksums = 0;
1538 #else
1539                         if (ast_true(s))
1540                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
1541 #endif
1542                 }
1543                 ast_destroy(cfg);
1544         }
1545         if (rtpstart >= rtpend) {
1546                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end\n");
1547                 rtpstart = 5000;
1548                 rtpend = 31000;
1549         }
1550         if (option_verbose > 1)
1551                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
1552 }
1553
1554 void ast_rtp_init(void)
1555 {
1556         ast_rtp_reload();
1557 }