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