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