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