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