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