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