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