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