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