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