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