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