German language improvements (bug #1606)
[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 pred;
922         int x;
923         char data[256];
924
925         if ((digit <= '9') && (digit >= '0'))
926                 digit -= '0';
927         else if (digit == '*')
928                 digit = 10;
929         else if (digit == '#')
930                 digit = 11;
931         else if ((digit >= 'A') && (digit <= 'D')) 
932                 digit = digit - 'A' + 12;
933         else if ((digit >= 'a') && (digit <= 'd')) 
934                 digit = digit - 'a' + 12;
935         else {
936                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
937                 return -1;
938         }
939         
940
941         /* If we have no peer, return immediately */    
942         if (!rtp->them.sin_addr.s_addr)
943                 return 0;
944
945         gettimeofday(&rtp->dtmfmute, NULL);
946         rtp->dtmfmute.tv_usec += (500 * 1000);
947         if (rtp->dtmfmute.tv_usec > 1000000) {
948                 rtp->dtmfmute.tv_usec -= 1000000;
949                 rtp->dtmfmute.tv_sec += 1;
950         }
951
952         ms = calc_txstamp(rtp, NULL);
953         /* Default prediction */
954         pred = rtp->lastts + ms * 8;
955         
956         /* Get a pointer to the header */
957         rtpheader = (unsigned int *)data;
958         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (101 << 16) | (rtp->seqno++));
959         rtpheader[1] = htonl(rtp->lastts);
960         rtpheader[2] = htonl(rtp->ssrc); 
961         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
962         for (x=0;x<4;x++) {
963                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
964                         res = sendto(rtp->s, (void *)rtpheader, hdrlen + 4, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
965                         if (res <0) 
966                                 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));
967         #if 0
968                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
969         #endif          
970                 }
971                 if (x ==0) {
972                         /* Clear marker bit and increment seqno */
973                         rtpheader[0] = htonl((2 << 30)  | (101 << 16) | (rtp->seqno++));
974                         /* Make duration 800 (100ms) */
975                         rtpheader[3] |= htonl((800));
976                         /* Set the End bit for the last 3 */
977                         rtpheader[3] |= htonl((1 << 23));
978                 }
979         }
980         return 0;
981 }
982
983 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
984 {
985         unsigned int *rtpheader;
986         int hdrlen = 12;
987         int res;
988         int ms;
989         int pred;
990         int mark = 0;
991
992         ms = calc_txstamp(rtp, &f->delivery);
993         /* Default prediction */
994         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
995                 pred = rtp->lastts + ms * 8;
996                 
997                 switch(f->subclass) {
998                 case AST_FORMAT_ULAW:
999                 case AST_FORMAT_ALAW:
1000                         /* If we're within +/- 20ms from when where we
1001                            predict we should be, use that */
1002                         pred = rtp->lastts + f->datalen;
1003                         break;
1004                 case AST_FORMAT_ADPCM:
1005                 case AST_FORMAT_G726:
1006                         /* If we're within +/- 20ms from when where we
1007                            predict we should be, use that */
1008                         pred = rtp->lastts + f->datalen * 2;
1009                         break;
1010                 case AST_FORMAT_G729A:
1011                         pred = rtp->lastts + f->datalen * 8;
1012                         break;
1013                 case AST_FORMAT_GSM:
1014                         pred = rtp->lastts + (f->datalen * 160 / 33);
1015                         break;
1016                 case AST_FORMAT_ILBC:
1017                         pred = rtp->lastts + (f->datalen * 240 / 50);
1018                         break;
1019                 case AST_FORMAT_G723_1:
1020                         pred = rtp->lastts + g723_samples(f->data, f->datalen);
1021                         break;
1022                 case AST_FORMAT_SPEEX:
1023                     pred = rtp->lastts + 160;
1024                         // assumes that the RTP packet contains one Speex frame
1025                         break;
1026                 default:
1027                         ast_log(LOG_WARNING, "Not sure about timestamp format for codec format %s\n", ast_getformatname(f->subclass));
1028                 }
1029                 /* Re-calculate last TS */
1030                 rtp->lastts = rtp->lastts + ms * 8;
1031                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1032                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
1033                            and if so, go with our prediction */
1034                         if (abs(rtp->lastts - pred) < 640)
1035                                 rtp->lastts = pred;
1036                         else {
1037                                 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1038                                 mark = 1;
1039                         }
1040                 }
1041         } else {
1042                 mark = f->subclass & 0x1;
1043                 pred = rtp->lastovidtimestamp + f->samples;
1044                 /* Re-calculate last TS */
1045                 rtp->lastts = rtp->lastts + ms * 90;
1046                 /* If it's close to our prediction, go for it */
1047                 if (abs(rtp->lastts - pred) < 7200) {
1048                         rtp->lastts = pred;
1049                         rtp->lastovidtimestamp += f->samples;
1050                 } else {
1051                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1052                         rtp->lastovidtimestamp = rtp->lastts;
1053                 }
1054         }
1055         /* Get a pointer to the header */
1056         rtpheader = (unsigned int *)(f->data - hdrlen);
1057         rtpheader[0] = htonl((2 << 30) | (codec << 16) | (rtp->seqno++) | (mark << 23));
1058         rtpheader[1] = htonl(rtp->lastts);
1059         rtpheader[2] = htonl(rtp->ssrc); 
1060         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1061                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1062                 if (res <0) 
1063                         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));
1064 #if 0
1065                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
1066 #endif          
1067         }
1068         return 0;
1069 }
1070
1071 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1072 {
1073         struct ast_frame *f;
1074         int codec;
1075         int hdrlen = 12;
1076         int subclass;
1077         
1078
1079         /* If we have no peer, return immediately */    
1080         if (!rtp->them.sin_addr.s_addr)
1081                 return 0;
1082
1083         /* If there is no data length, return immediately */
1084         if (!_f->datalen) 
1085                 return 0;
1086         
1087         /* Make sure we have enough space for RTP header */
1088         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1089                 ast_log(LOG_WARNING, "RTP can only send voice\n");
1090                 return -1;
1091         }
1092
1093         subclass = _f->subclass;
1094         if (_f->frametype == AST_FRAME_VIDEO)
1095                 subclass &= ~0x1;
1096
1097         codec = ast_rtp_lookup_code(rtp, 1, subclass);
1098         if (codec < 0) {
1099                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1100                 return -1;
1101         }
1102
1103         if (rtp->lasttxformat != subclass) {
1104                 /* New format, reset the smoother */
1105                 ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1106                 rtp->lasttxformat = subclass;
1107                 if (rtp->smoother)
1108                         ast_smoother_free(rtp->smoother);
1109                 rtp->smoother = NULL;
1110         }
1111
1112
1113         switch(subclass) {
1114         case AST_FORMAT_ULAW:
1115         case AST_FORMAT_ALAW:
1116                 if (!rtp->smoother) {
1117                         rtp->smoother = ast_smoother_new(160);
1118                 }
1119                 if (!rtp->smoother) {
1120                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1121                         return -1;
1122                 }
1123                 ast_smoother_feed(rtp->smoother, _f);
1124                 
1125                 while((f = ast_smoother_read(rtp->smoother)))
1126                         ast_rtp_raw_write(rtp, f, codec);
1127                 break;
1128         case AST_FORMAT_ADPCM:
1129         case AST_FORMAT_G726:
1130                 if (!rtp->smoother) {
1131                         rtp->smoother = ast_smoother_new(80);
1132                 }
1133                 if (!rtp->smoother) {
1134                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1135                         return -1;
1136                 }
1137                 ast_smoother_feed(rtp->smoother, _f);
1138                 
1139                 while((f = ast_smoother_read(rtp->smoother)))
1140                         ast_rtp_raw_write(rtp, f, codec);
1141                 break;
1142         case AST_FORMAT_G729A:
1143                 if (!rtp->smoother) {
1144                         rtp->smoother = ast_smoother_new(20);
1145                         if (rtp->smoother)
1146                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1147                 }
1148                 if (!rtp->smoother) {
1149                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1150                         return -1;
1151                 }
1152                 ast_smoother_feed(rtp->smoother, _f);
1153                 
1154                 while((f = ast_smoother_read(rtp->smoother)))
1155                         ast_rtp_raw_write(rtp, f, codec);
1156                 break;
1157         case AST_FORMAT_GSM:
1158                 if (!rtp->smoother) {
1159                         rtp->smoother = ast_smoother_new(33);
1160                 }
1161                 if (!rtp->smoother) {
1162                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1163                         return -1;
1164                 }
1165                 ast_smoother_feed(rtp->smoother, _f);
1166                 while((f = ast_smoother_read(rtp->smoother)))
1167                         ast_rtp_raw_write(rtp, f, codec);
1168                 break;
1169         case AST_FORMAT_ILBC:
1170                 if (!rtp->smoother) {
1171                         rtp->smoother = ast_smoother_new(50);
1172                 }
1173                 if (!rtp->smoother) {
1174                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1175                         return -1;
1176                 }
1177                 ast_smoother_feed(rtp->smoother, _f);
1178                 while((f = ast_smoother_read(rtp->smoother)))
1179                         ast_rtp_raw_write(rtp, f, codec);
1180                 break;
1181         default:        
1182                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1183                 // fall through to...
1184         case AST_FORMAT_H261:
1185         case AST_FORMAT_H263:
1186         case AST_FORMAT_G723_1:
1187         case AST_FORMAT_SPEEX:
1188                 // Don't buffer outgoing frames; send them one-per-packet:
1189                 if (_f->offset < hdrlen) {
1190                         f = ast_frdup(_f);
1191                 } else {
1192                         f = _f;
1193                 }
1194                 ast_rtp_raw_write(rtp, f, codec);
1195         }
1196                 
1197         return 0;
1198 }
1199
1200 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1201 {
1202         struct ast_rtp_protocol *cur, *prev;
1203         cur = protos;
1204         prev = NULL;
1205         while(cur) {
1206                 if (cur == proto) {
1207                         if (prev)
1208                                 prev->next = proto->next;
1209                         else
1210                                 protos = proto->next;
1211                         return;
1212                 }
1213                 prev = cur;
1214                 cur = cur->next;
1215         }
1216 }
1217
1218 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1219 {
1220         struct ast_rtp_protocol *cur;
1221         cur = protos;
1222         while(cur) {
1223                 if (cur->type == proto->type) {
1224                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1225                         return -1;
1226                 }
1227                 cur = cur->next;
1228         }
1229         proto->next = protos;
1230         protos = proto;
1231         return 0;
1232 }
1233
1234 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1235 {
1236         struct ast_rtp_protocol *cur;
1237         cur = protos;
1238         while(cur) {
1239                 if (cur->type == chan->type) {
1240                         return cur;
1241                 }
1242                 cur = cur->next;
1243         }
1244         return NULL;
1245 }
1246
1247 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
1248 {
1249         struct ast_frame *f;
1250         struct ast_channel *who, *cs[3];
1251         struct ast_rtp *p0, *p1;
1252         struct ast_rtp *vp0, *vp1;
1253         struct ast_rtp_protocol *pr0, *pr1;
1254         struct sockaddr_in ac0, ac1;
1255         struct sockaddr_in vac0, vac1;
1256         struct sockaddr_in t0, t1;
1257         struct sockaddr_in vt0, vt1;
1258         
1259         void *pvt0, *pvt1;
1260         int to;
1261         memset(&vt0, 0, sizeof(vt0));
1262         memset(&vt1, 0, sizeof(vt1));
1263         memset(&vac0, 0, sizeof(vac0));
1264         memset(&vac1, 0, sizeof(vac1));
1265
1266         /* XXX Wait a half a second for things to settle up 
1267                         this really should be fixed XXX */
1268         ast_autoservice_start(c0);
1269         ast_autoservice_start(c1);
1270         usleep(500000);
1271         ast_autoservice_stop(c0);
1272         ast_autoservice_stop(c1);
1273
1274         /* if need DTMF, cant native bridge */
1275         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
1276                 return -2;
1277         ast_mutex_lock(&c0->lock);
1278         ast_mutex_lock(&c1->lock);
1279         pr0 = get_proto(c0);
1280         pr1 = get_proto(c1);
1281         if (!pr0) {
1282                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1283                 ast_mutex_unlock(&c0->lock);
1284                 ast_mutex_unlock(&c1->lock);
1285                 return -1;
1286         }
1287         if (!pr1) {
1288                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1289                 ast_mutex_unlock(&c0->lock);
1290                 ast_mutex_unlock(&c1->lock);
1291                 return -1;
1292         }
1293         pvt0 = c0->pvt->pvt;
1294         pvt1 = c1->pvt->pvt;
1295         p0 = pr0->get_rtp_info(c0);
1296         if (pr0->get_vrtp_info)
1297                 vp0 = pr0->get_vrtp_info(c0);
1298         else
1299                 vp0 = NULL;
1300         p1 = pr1->get_rtp_info(c1);
1301         if (pr1->get_vrtp_info)
1302                 vp1 = pr1->get_vrtp_info(c1);
1303         else
1304                 vp1 = NULL;
1305         if (!p0 || !p1) {
1306                 /* Somebody doesn't want to play... */
1307                 ast_mutex_unlock(&c0->lock);
1308                 ast_mutex_unlock(&c1->lock);
1309                 return -2;
1310         }
1311         if (pr0->get_codec && pr1->get_codec) {
1312                 int codec0,codec1;
1313                 codec0 = pr0->get_codec(c0);
1314                 codec1 = pr1->get_codec(c1);
1315                 /* Hey, we can't do reinvite if both parties speak diffrent codecs */
1316                 if (!(codec0 & codec1)) {
1317                         ast_log(LOG_WARNING, "codec0 = %d is not codec1 = %d, cannot native bridge.\n",codec0,codec1);
1318                         ast_mutex_unlock(&c0->lock);
1319                         ast_mutex_unlock(&c1->lock);
1320                         return -2;
1321                 }
1322         }
1323         if (pr0->set_rtp_peer(c0, p1, vp1)) 
1324                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1325         else {
1326                 /* Store RTP peer */
1327                 ast_rtp_get_peer(p1, &ac1);
1328                 if (vp1)
1329                         ast_rtp_get_peer(p1, &vac1);
1330         }
1331         if (pr1->set_rtp_peer(c1, p0, vp0))
1332                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1333         else {
1334                 /* Store RTP peer */
1335                 ast_rtp_get_peer(p0, &ac0);
1336                 if (vp0)
1337                         ast_rtp_get_peer(p0, &vac0);
1338         }
1339         ast_mutex_unlock(&c0->lock);
1340         ast_mutex_unlock(&c1->lock);
1341         cs[0] = c0;
1342         cs[1] = c1;
1343         cs[2] = NULL;
1344         for (;;) {
1345                 if ((c0->pvt->pvt != pvt0)  ||
1346                         (c1->pvt->pvt != pvt1) ||
1347                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
1348                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
1349                                 if (c0->pvt->pvt == pvt0) {
1350                                         if (pr0->set_rtp_peer(c0, NULL, NULL)) 
1351                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1352                                 }
1353                                 if (c1->pvt->pvt == pvt1) {
1354                                         if (pr1->set_rtp_peer(c1, NULL, NULL)) 
1355                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1356                                 }
1357                                 /* Tell it to try again later */
1358                                 return -3;
1359                 }
1360                 to = -1;
1361                 ast_rtp_get_peer(p1, &t1);
1362                 ast_rtp_get_peer(p0, &t0);
1363                 if (vp1)
1364                         ast_rtp_get_peer(vp1, &vt1);
1365                 if (vp0)
1366                         ast_rtp_get_peer(vp0, &vt0);
1367                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1))) {
1368                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c1->name);
1369                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL)) 
1370                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
1371                         memcpy(&ac1, &t1, sizeof(ac1));
1372                         memcpy(&vac1, &vt1, sizeof(vac1));
1373                 }
1374                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
1375                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c0->name);
1376                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL))
1377                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1378                         memcpy(&ac0, &t0, sizeof(ac0));
1379                         memcpy(&vac0, &vt0, sizeof(vac0));
1380                 }
1381                 who = ast_waitfor_n(cs, 2, &to);
1382                 if (!who) {
1383                         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1384                         /* check for hagnup / whentohangup */
1385                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
1386                                 break;
1387                         continue;
1388                 }
1389                 f = ast_read(who);
1390                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1391                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
1392                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1393                         *fo = f;
1394                         *rc = who;
1395                         ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1396                         if ((c0->pvt->pvt == pvt0) && (!c0->_softhangup)) {
1397                                 if (pr0->set_rtp_peer(c0, NULL, NULL)) 
1398                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1399                         }
1400                         if ((c1->pvt->pvt == pvt1) && (!c1->_softhangup)) {
1401                                 if (pr1->set_rtp_peer(c1, NULL, NULL)) 
1402                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1403                         }
1404                         /* That's all we needed */
1405                         return 0;
1406                 } else {
1407                         if ((f->frametype == AST_FRAME_DTMF) || 
1408                                 (f->frametype == AST_FRAME_VOICE) || 
1409                                 (f->frametype == AST_FRAME_VIDEO)) {
1410                                 /* Forward voice or DTMF frames if they happen upon us */
1411                                 if (who == c0) {
1412                                         ast_write(c1, f);
1413                                 } else if (who == c1) {
1414                                         ast_write(c0, f);
1415                                 }
1416                         }
1417                         ast_frfree(f);
1418                 }
1419                 /* Swap priority not that it's a big deal at this point */
1420                 cs[2] = cs[0];
1421                 cs[0] = cs[1];
1422                 cs[1] = cs[2];
1423                 
1424         }
1425         return -1;
1426 }
1427
1428 void ast_rtp_reload(void)
1429 {
1430         struct ast_config *cfg;
1431         char *s;
1432         rtpstart = 5000;
1433         rtpend = 31000;
1434         cfg = ast_load("rtp.conf");
1435         if (cfg) {
1436                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
1437                         rtpstart = atoi(s);
1438                         if (rtpstart < 1024)
1439                                 rtpstart = 1024;
1440                         if (rtpstart > 65535)
1441                                 rtpstart = 65535;
1442                 }
1443                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
1444                         rtpend = atoi(s);
1445                         if (rtpend < 1024)
1446                                 rtpend = 1024;
1447                         if (rtpend > 65535)
1448                                 rtpend = 65535;
1449                 }
1450                 ast_destroy(cfg);
1451         }
1452         if (rtpstart >= rtpend) {
1453                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end\n");
1454                 rtpstart = 5000;
1455                 rtpend = 31000;
1456         }
1457         if (option_verbose > 1)
1458                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
1459 }
1460
1461 void ast_rtp_init(void)
1462 {
1463         ast_rtp_reload();
1464 }