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