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