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