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