Make ADPCM frames standard
[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;
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_ADPCM:
1039         case AST_FORMAT_G726:
1040                 if (!rtp->smoother) {
1041                         rtp->smoother = ast_smoother_new(80);
1042                 }
1043                 if (!rtp->smoother) {
1044                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1045                         return -1;
1046                 }
1047                 ast_smoother_feed(rtp->smoother, _f);
1048                 
1049                 while((f = ast_smoother_read(rtp->smoother)))
1050                         ast_rtp_raw_write(rtp, f, codec);
1051                 break;
1052         case AST_FORMAT_G729A:
1053                 if (!rtp->smoother) {
1054                         rtp->smoother = ast_smoother_new(20);
1055                 }
1056                 if (!rtp->smoother) {
1057                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1058                         return -1;
1059                 }
1060                 ast_smoother_feed(rtp->smoother, _f);
1061                 
1062                 while((f = ast_smoother_read(rtp->smoother)))
1063                         ast_rtp_raw_write(rtp, f, codec);
1064                 break;
1065         case AST_FORMAT_GSM:
1066                 if (!rtp->smoother) {
1067                         rtp->smoother = ast_smoother_new(33);
1068                 }
1069                 if (!rtp->smoother) {
1070                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1071                         return -1;
1072                 }
1073                 ast_smoother_feed(rtp->smoother, _f);
1074                 while((f = ast_smoother_read(rtp->smoother)))
1075                         ast_rtp_raw_write(rtp, f, codec);
1076                 break;
1077         case AST_FORMAT_ILBC:
1078                 if (!rtp->smoother) {
1079                         rtp->smoother = ast_smoother_new(50);
1080                 }
1081                 if (!rtp->smoother) {
1082                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1083                         return -1;
1084                 }
1085                 ast_smoother_feed(rtp->smoother, _f);
1086                 while((f = ast_smoother_read(rtp->smoother)))
1087                         ast_rtp_raw_write(rtp, f, codec);
1088                 break;
1089         default:        
1090                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1091                 // fall through to...
1092         case AST_FORMAT_H261:
1093         case AST_FORMAT_H263:
1094         case AST_FORMAT_G723_1:
1095         case AST_FORMAT_SPEEX:
1096                 // Don't buffer outgoing frames; send them one-per-packet:
1097                 if (_f->offset < hdrlen) {
1098                         f = ast_frdup(_f);
1099                 } else {
1100                         f = _f;
1101                 }
1102                 ast_rtp_raw_write(rtp, f, codec);
1103         }
1104                 
1105         return 0;
1106 }
1107
1108 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1109 {
1110         struct ast_rtp_protocol *cur, *prev;
1111         cur = protos;
1112         prev = NULL;
1113         while(cur) {
1114                 if (cur == proto) {
1115                         if (prev)
1116                                 prev->next = proto->next;
1117                         else
1118                                 protos = proto->next;
1119                         return;
1120                 }
1121                 prev = cur;
1122                 cur = cur->next;
1123         }
1124 }
1125
1126 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1127 {
1128         struct ast_rtp_protocol *cur;
1129         cur = protos;
1130         while(cur) {
1131                 if (cur->type == proto->type) {
1132                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1133                         return -1;
1134                 }
1135                 cur = cur->next;
1136         }
1137         proto->next = protos;
1138         protos = proto;
1139         return 0;
1140 }
1141
1142 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1143 {
1144         struct ast_rtp_protocol *cur;
1145         cur = protos;
1146         while(cur) {
1147                 if (cur->type == chan->type) {
1148                         return cur;
1149                 }
1150                 cur = cur->next;
1151         }
1152         return NULL;
1153 }
1154
1155 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
1156 {
1157         struct ast_frame *f;
1158         struct ast_channel *who, *cs[3];
1159         struct ast_rtp *p0, *p1;
1160         struct ast_rtp *vp0, *vp1;
1161         struct ast_rtp_protocol *pr0, *pr1;
1162         struct sockaddr_in ac0, ac1;
1163         struct sockaddr_in vac0, vac1;
1164         struct sockaddr_in t0, t1;
1165         struct sockaddr_in vt0, vt1;
1166         
1167         void *pvt0, *pvt1;
1168         int to;
1169         memset(&vt0, 0, sizeof(vt0));
1170         memset(&vt1, 0, sizeof(vt1));
1171         memset(&vac0, 0, sizeof(vac0));
1172         memset(&vac1, 0, sizeof(vac1));
1173
1174         /* XXX Wait a half a second for things to settle up 
1175                         this really should be fixed XXX */
1176         ast_autoservice_start(c0);
1177         ast_autoservice_start(c1);
1178         usleep(500000);
1179         ast_autoservice_stop(c0);
1180         ast_autoservice_stop(c1);
1181
1182         /* if need DTMF, cant native bridge */
1183         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
1184                 return -2;
1185         ast_mutex_lock(&c0->lock);
1186         ast_mutex_lock(&c1->lock);
1187         pr0 = get_proto(c0);
1188         pr1 = get_proto(c1);
1189         if (!pr0) {
1190                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1191                 ast_mutex_unlock(&c0->lock);
1192                 ast_mutex_unlock(&c1->lock);
1193                 return -1;
1194         }
1195         if (!pr1) {
1196                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1197                 ast_mutex_unlock(&c0->lock);
1198                 ast_mutex_unlock(&c1->lock);
1199                 return -1;
1200         }
1201         pvt0 = c0->pvt->pvt;
1202         pvt1 = c1->pvt->pvt;
1203         p0 = pr0->get_rtp_info(c0);
1204         if (pr0->get_vrtp_info)
1205                 vp0 = pr0->get_vrtp_info(c0);
1206         else
1207                 vp0 = NULL;
1208         p1 = pr1->get_rtp_info(c1);
1209         if (pr1->get_vrtp_info)
1210                 vp1 = pr1->get_vrtp_info(c1);
1211         else
1212                 vp1 = NULL;
1213         if (!p0 || !p1) {
1214                 /* Somebody doesn't want to play... */
1215                 ast_mutex_unlock(&c0->lock);
1216                 ast_mutex_unlock(&c1->lock);
1217                 return -2;
1218         }
1219         if (pr0->get_codec && pr1->get_codec) {
1220                 int codec0,codec1;
1221                 codec0 = pr0->get_codec(c0);
1222                 codec1 = pr1->get_codec(c1);
1223                 /* Hey, we can't do reinvite if both parties speak diffrent codecs */
1224                 if (!(codec0 & codec1)) {
1225                         ast_log(LOG_WARNING, "codec0 = %d is not codec1 = %d, cannot native bridge.\n",codec0,codec1);
1226                         ast_mutex_unlock(&c0->lock);
1227                         ast_mutex_unlock(&c1->lock);
1228                         return -2;
1229                 }
1230         }
1231         if (pr0->set_rtp_peer(c0, p1, vp1)) 
1232                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1233         else {
1234                 /* Store RTP peer */
1235                 ast_rtp_get_peer(p1, &ac1);
1236                 if (vp1)
1237                         ast_rtp_get_peer(p1, &vac1);
1238         }
1239         if (pr1->set_rtp_peer(c1, p0, vp0))
1240                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1241         else {
1242                 /* Store RTP peer */
1243                 ast_rtp_get_peer(p0, &ac0);
1244                 if (vp0)
1245                         ast_rtp_get_peer(p0, &vac0);
1246         }
1247         ast_mutex_unlock(&c0->lock);
1248         ast_mutex_unlock(&c1->lock);
1249         cs[0] = c0;
1250         cs[1] = c1;
1251         cs[2] = NULL;
1252         for (;;) {
1253                 if ((c0->pvt->pvt != pvt0)  ||
1254                         (c1->pvt->pvt != pvt1) ||
1255                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
1256                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
1257                                 if (c0->pvt->pvt == pvt0) {
1258                                         if (pr0->set_rtp_peer(c0, NULL, NULL)) 
1259                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1260                                 }
1261                                 if (c1->pvt->pvt == pvt1) {
1262                                         if (pr1->set_rtp_peer(c1, NULL, NULL)) 
1263                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1264                                 }
1265                                 /* Tell it to try again later */
1266                                 return -3;
1267                 }
1268                 to = -1;
1269                 ast_rtp_get_peer(p1, &t1);
1270                 ast_rtp_get_peer(p0, &t0);
1271                 if (vp1)
1272                         ast_rtp_get_peer(vp1, &vt1);
1273                 if (vp0)
1274                         ast_rtp_get_peer(vp0, &vt0);
1275                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1))) {
1276                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c1->name);
1277                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL)) 
1278                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
1279                         memcpy(&ac1, &t1, sizeof(ac1));
1280                         memcpy(&vac1, &vt1, sizeof(vac1));
1281                 }
1282                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
1283                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c0->name);
1284                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL))
1285                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1286                         memcpy(&ac0, &t0, sizeof(ac0));
1287                         memcpy(&vac0, &vt0, sizeof(vac0));
1288                 }
1289                 who = ast_waitfor_n(cs, 2, &to);
1290                 if (!who) {
1291                         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1292                         /* check for hagnup / whentohangup */
1293                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
1294                                 break;
1295                         continue;
1296                 }
1297                 f = ast_read(who);
1298                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1299                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
1300                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1301                         *fo = f;
1302                         *rc = who;
1303                         ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1304                         if ((c0->pvt->pvt == pvt0) && (!c0->_softhangup)) {
1305                                 if (pr0->set_rtp_peer(c0, NULL, NULL)) 
1306                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1307                         }
1308                         if ((c1->pvt->pvt == pvt1) && (!c1->_softhangup)) {
1309                                 if (pr1->set_rtp_peer(c1, NULL, NULL)) 
1310                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1311                         }
1312                         /* That's all we needed */
1313                         return 0;
1314                 } else {
1315                         if ((f->frametype == AST_FRAME_DTMF) || 
1316                                 (f->frametype == AST_FRAME_VOICE) || 
1317                                 (f->frametype == AST_FRAME_VIDEO)) {
1318                                 /* Forward voice or DTMF frames if they happen upon us */
1319                                 if (who == c0) {
1320                                         ast_write(c1, f);
1321                                 } else if (who == c1) {
1322                                         ast_write(c0, f);
1323                                 }
1324                         }
1325                         ast_frfree(f);
1326                 }
1327                 /* Swap priority not that it's a big deal at this point */
1328                 cs[2] = cs[0];
1329                 cs[0] = cs[1];
1330                 cs[1] = cs[2];
1331                 
1332         }
1333         return -1;
1334 }
1335
1336 void ast_rtp_reload(void)
1337 {
1338         struct ast_config *cfg;
1339         char *s;
1340         rtpstart = 5000;
1341         rtpend = 31000;
1342         cfg = ast_load("rtp.conf");
1343         if (cfg) {
1344                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
1345                         rtpstart = atoi(s);
1346                         if (rtpstart < 1024)
1347                                 rtpstart = 1024;
1348                         if (rtpstart > 65535)
1349                                 rtpstart = 65535;
1350                 }
1351                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
1352                         rtpend = atoi(s);
1353                         if (rtpend < 1024)
1354                                 rtpend = 1024;
1355                         if (rtpend > 65535)
1356                                 rtpend = 65535;
1357                 }
1358                 ast_destroy(cfg);
1359         }
1360         if (rtpstart >= rtpend) {
1361                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end\n");
1362                 rtpstart = 5000;
1363                 rtpend = 31000;
1364         }
1365         if (option_verbose > 1)
1366                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
1367 }
1368
1369 void ast_rtp_init(void)
1370 {
1371         ast_rtp_reload();
1372 }