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