Sun Mar 9 07:00:01 CET 2003
[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/channel_pvt.h>
34
35 #define TYPE_SILENCE     0x2
36 #define TYPE_HIGH        0x0
37 #define TYPE_LOW         0x1
38 #define TYPE_MASK        0x3
39
40 static int dtmftimeout = 300;   /* 300 samples */
41
42 struct ast_rtp {
43         int s;
44         char resp;
45         struct ast_frame f;
46         unsigned char rawdata[1024 + AST_FRIENDLY_OFFSET];
47         unsigned int ssrc;
48         unsigned int lastts;
49         unsigned int lastrxts;
50         int lasttxformat;
51         int lastrxformat;
52         int dtmfcount;
53         int nat;
54         struct sockaddr_in us;
55         struct sockaddr_in them;
56         struct timeval rxcore;
57         struct timeval txcore;
58         struct ast_smoother *smoother;
59         int *ioid;
60         unsigned short seqno;
61         struct sched_context *sched;
62         struct io_context *io;
63         void *data;
64         ast_rtp_callback callback;
65 };
66
67 static struct ast_rtp_protocol *protos = NULL;
68
69 int ast_rtp_fd(struct ast_rtp *rtp)
70 {
71         return rtp->s;
72 }
73
74 static int g723_len(unsigned char buf)
75 {
76         switch(buf & TYPE_MASK) {
77         case TYPE_MASK:
78         case TYPE_SILENCE:
79                 return 4;
80                 break;
81         case TYPE_HIGH:
82                 return 24;
83                 break;
84         case TYPE_LOW:
85                 return 20;
86                 break;
87         default:
88                 ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", buf & TYPE_MASK);
89         }
90         return -1;
91 }
92
93 static int g723_samples(unsigned char *buf, int maxlen)
94 {
95         int pos = 0;
96         int samples = 0;
97         int res;
98         while(pos < maxlen) {
99                 res = g723_len(buf[pos]);
100                 if (res < 0)
101                         break;
102                 samples += 240;
103                 pos += res;
104         }
105         return samples;
106 }
107
108 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
109 {
110         rtp->data = data;
111 }
112
113 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
114 {
115         rtp->callback = callback;
116 }
117
118 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
119 {
120         rtp->nat = nat;
121 }
122
123 static struct ast_frame *send_dtmf(struct ast_rtp *rtp)
124 {
125         ast_log(LOG_DEBUG, "Sending dtmf: %d (%c)\n", rtp->resp, rtp->resp);
126         rtp->f.frametype = AST_FRAME_DTMF;
127         rtp->f.subclass = rtp->resp;
128         rtp->f.datalen = 0;
129         rtp->f.samples = 0;
130         rtp->f.mallocd = 0;
131         rtp->f.src = "RTP";
132         rtp->resp = 0;
133         return &rtp->f;
134         
135 }
136
137 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len)
138 {
139         unsigned int event;
140         char resp = 0;
141         struct ast_frame *f = NULL;
142         event = ntohl(*((unsigned int *)(data)));
143         event >>= 24;
144 #if 0
145         printf("Event: %08x (len = %d)\n", event, len);
146 #endif  
147         if (event < 10) {
148                 resp = '0' + event;
149         } else if (event < 11) {
150                 resp = '*';
151         } else if (event < 12) {
152                 resp = '#';
153         } else if (event < 16) {
154                 resp = 'A' + (event - 12);
155         }
156         if (rtp->resp && (rtp->resp != resp)) {
157                 f = send_dtmf(rtp);
158         }
159         rtp->resp = resp;
160         rtp->dtmfcount = dtmftimeout;
161         return f;
162 }
163
164 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
165 {
166         struct ast_frame *f = NULL;
167         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
168            totally help us out becuase we don't have an engine to keep it going and we are not
169            guaranteed to have it every 20ms or anything */
170 #if 0
171         printf("RFC3389: %d bytes, format is %d\n", len, rtp->lastrxformat);
172 #endif  
173         ast_log(LOG_NOTICE, "RFC3389 support incomplete.  Turn off on client if possible\n");
174         if (!rtp->lastrxformat)
175                 return  NULL;
176         switch(rtp->lastrxformat) {
177         case AST_FORMAT_ULAW:
178                 rtp->f.frametype = AST_FRAME_VOICE;
179                 rtp->f.subclass = AST_FORMAT_ULAW;
180                 rtp->f.datalen = 160;
181                 rtp->f.samples = 160;
182                 memset(rtp->f.data, 0x7f, rtp->f.datalen);
183                 f = &rtp->f;
184                 break;
185         case AST_FORMAT_ALAW:
186                 rtp->f.frametype = AST_FRAME_VOICE;
187                 rtp->f.subclass = AST_FORMAT_ALAW;
188                 rtp->f.datalen = 160;
189                 rtp->f.samples = 160;
190                 memset(rtp->f.data, 0x7e, rtp->f.datalen); /* XXX Is this right? XXX */
191                 f = &rtp->f;
192                 break;
193         case AST_FORMAT_SLINEAR:
194                 rtp->f.frametype = AST_FRAME_VOICE;
195                 rtp->f.subclass = AST_FORMAT_SLINEAR;
196                 rtp->f.datalen = 320;
197                 rtp->f.samples = 160;
198                 memset(rtp->f.data, 0x00, rtp->f.datalen);
199                 f = &rtp->f;
200                 break;
201         default:
202                 ast_log(LOG_NOTICE, "Don't know how to handle RFC3389 for receive codec %d\n", rtp->lastrxformat);
203         }
204         return f;
205 }
206
207 static struct ast_frame *process_type121(struct ast_rtp *rtp, unsigned char *data, int len)
208 {
209         char resp = 0;
210         struct ast_frame *f = NULL;
211         unsigned char b0,b1,b2,b3,b4,b5,b6,b7;
212         
213         b0=*(data+0);b1=*(data+1);b2=*(data+2);b3=*(data+3);
214         b4=*(data+4);b5=*(data+5);b6=*(data+6);b7=*(data+7);
215 //      printf("%u %u %u %u %u %u %u %u\n",b0,b1,b2,b3,b4,b5,b6,b7);
216         if (b2==32) {
217 //              printf("Start %d\n",b3);
218                 if (b4==0) {
219 //                      printf("Detection point for DTMF %d\n",b3);
220                         if (b3<10) {
221                                 resp='0'+b3;
222                         } else if (b3<11) {
223                                 resp='*';
224                         } else if (b3<12) {
225                                 resp='#';
226                         } else if (b3<16) {
227                                 resp='A'+(b3-12);
228                         }
229                         rtp->resp=resp;
230                         f = send_dtmf(rtp);
231                 }
232         }
233         if (b2==3) {
234 //              printf("Stop(3) %d\n",b3);
235         }
236         if (b2==0) {
237 //              printf("Stop(0) %d\n",b3);
238         }
239         return f;
240 }
241
242 static int rtpread(int *id, int fd, short events, void *cbdata)
243 {
244         struct ast_rtp *rtp = cbdata;
245         struct ast_frame *f;
246         f = ast_rtp_read(rtp);
247         if (f) {
248                 if (rtp->callback)
249                         rtp->callback(rtp, f, rtp->data);
250         }
251         return 1;
252 }
253
254 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
255 {
256         int res;
257         struct sockaddr_in sin;
258         int len;
259         unsigned int seqno;
260         int payloadtype;
261         int hdrlen = 12;
262         unsigned int timestamp;
263         unsigned int *rtpheader;
264         static struct ast_frame *f, null_frame = { AST_FRAME_NULL, };
265         
266         len = sizeof(sin);
267         
268         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
269                                         0, (struct sockaddr *)&sin, &len);
270
271
272         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
273         if (res < 0) {
274                 ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
275                 if (errno == EBADF)
276                         CRASH;
277                 return &null_frame;
278         }
279         if (res < hdrlen) {
280                 ast_log(LOG_WARNING, "RTP Read too short\n");
281                 return &null_frame;
282         }
283         if (rtp->nat) {
284                 /* Send to whoever sent to us */
285                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
286                     (rtp->them.sin_port != sin.sin_port)) {
287                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
288                         ast_log(LOG_DEBUG, "RTP NAT: Using address %s:%d\n", inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
289                 }
290         }
291         /* Get fields */
292         seqno = ntohl(rtpheader[0]);
293         payloadtype = (seqno & 0x7f0000) >> 16;
294         seqno &= 0xffff;
295         timestamp = ntohl(rtpheader[1]);
296 #if 0
297         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);
298 #endif  
299         rtp->f.frametype = AST_FRAME_VOICE;
300         rtp->f.subclass = rtp2ast(payloadtype);
301         if (rtp->f.subclass < 0) {
302                 f = NULL;
303                 if (payloadtype == 101) {
304                         /* It's special -- rfc2833 process it */
305                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
306                 } else if (payloadtype == 121) {
307                         /* CISCO proprietary DTMF bridge */
308                         f = process_type121(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
309                 } else if (payloadtype == 100) {
310                         /* CISCO's notso proprietary DTMF bridge */
311                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
312                 } else if (payloadtype == 13) {
313                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
314                 } else {
315                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received\n", payloadtype);
316                 }
317                 if (f)
318                         return f;
319                 else
320                         return &null_frame;
321         } else
322                 rtp->lastrxformat = rtp->f.subclass;
323
324         if (!rtp->lastrxts)
325                 rtp->lastrxts = timestamp;
326
327         if (rtp->dtmfcount) {
328 #if 0
329                 printf("dtmfcount was %d\n", rtp->dtmfcount);
330 #endif          
331                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
332                 if (rtp->dtmfcount < 0)
333                         rtp->dtmfcount = 0;
334 #if 0
335                 if (dtmftimeout != rtp->dtmfcount)
336                         printf("dtmfcount is %d\n", rtp->dtmfcount);
337 #endif
338         }
339         rtp->lastrxts = timestamp;
340
341         /* Send any pending DTMF */
342         if (rtp->resp && !rtp->dtmfcount) {
343                 ast_log(LOG_DEBUG, "Sending pending DTMF\n");
344                 return send_dtmf(rtp);
345         }
346         rtp->f.mallocd = 0;
347         rtp->f.datalen = res - hdrlen;
348         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
349         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
350         switch(rtp->f.subclass) {
351         case AST_FORMAT_ULAW:
352         case AST_FORMAT_ALAW:
353                 rtp->f.samples = rtp->f.datalen;
354                 break;
355         case AST_FORMAT_SLINEAR:
356                 rtp->f.samples = rtp->f.datalen / 2;
357                 break;
358         case AST_FORMAT_GSM:
359                 rtp->f.samples = 160 * (rtp->f.datalen / 33);
360                 break;
361         case AST_FORMAT_ADPCM:
362                 rtp->f.samples = rtp->f.datalen * 2;
363                 break;
364         case AST_FORMAT_G729A:
365                 rtp->f.samples = rtp->f.datalen * 8;
366                 break;
367         case AST_FORMAT_G723_1:
368                 rtp->f.samples = g723_samples(rtp->f.data, rtp->f.datalen);
369                 break;
370         default:
371                 ast_log(LOG_NOTICE, "Unable to calculate samples for format %d\n", rtp->f.subclass);
372                 break;
373         }
374         rtp->f.src = "RTP";
375         return &rtp->f;
376 }
377
378 static struct {
379         int rtp;
380         int ast;
381         char *label;
382 } cmap[] = {
383         { 0, AST_FORMAT_ULAW, "PCMU" },
384         { 3, AST_FORMAT_GSM, "GSM" },
385         { 4, AST_FORMAT_G723_1, "G723" },
386         { 5, AST_FORMAT_ADPCM, "ADPCM" },
387         { 8, AST_FORMAT_ALAW, "PCMA" },
388         { 18, AST_FORMAT_G729A, "G729" },
389 };
390
391 int rtp2ast(int id)
392 {
393         int x;
394         for (x=0;x<sizeof(cmap) / sizeof(cmap[0]); x++) {
395                 if (cmap[x].rtp == id)
396                         return cmap[x].ast;
397         }
398         return -1;
399 }
400
401 int ast2rtp(int id)
402 {
403         int x;
404         for (x=0;x<sizeof(cmap) / sizeof(cmap[0]); x++) {
405                 if (cmap[x].ast == id)
406                         return cmap[x].rtp;
407         }
408         return -1;
409 }
410
411 char *ast2rtpn(int id)
412 {
413         int x;
414         for (x=0;x<sizeof(cmap) / sizeof(cmap[0]); x++) {
415                 if (cmap[x].ast == id)
416                         return cmap[x].label;
417         }
418         return "";
419 }
420 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io)
421 {
422         struct ast_rtp *rtp;
423         int x;
424         int flags;
425         rtp = malloc(sizeof(struct ast_rtp));
426         if (!rtp)
427                 return NULL;
428         memset(rtp, 0, sizeof(struct ast_rtp));
429         rtp->them.sin_family = AF_INET;
430         rtp->us.sin_family = AF_INET;
431         rtp->s = socket(AF_INET, SOCK_DGRAM, 0);
432         rtp->ssrc = rand();
433         rtp->seqno = rand() & 0xffff;
434         if (rtp->s < 0) {
435                 free(rtp);
436                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
437                 return NULL;
438         }
439         flags = fcntl(rtp->s, F_GETFL);
440         fcntl(rtp->s, F_SETFL, flags | O_NONBLOCK);
441         for (;;) {
442                 /* Find us a place */
443                 x = (rand() % (65000-1025)) + 1025;
444                 /* Must be an even port number by RTP spec */
445                 x = x & ~1;
446                 rtp->us.sin_port = htons(x);
447                 if (!bind(rtp->s, &rtp->us, sizeof(rtp->us)))
448                         break;
449                 if (errno != EADDRINUSE) {
450                         ast_log(LOG_WARNING, "Unexpected bind error: %s\n", strerror(errno));
451                         close(rtp->s);
452                         free(rtp);
453                         return NULL;
454                 }
455         }
456         if (io && sched) {
457                 /* Operate this one in a callback mode */
458                 rtp->sched = sched;
459                 rtp->io = io;
460                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
461         }
462         return rtp;
463 }
464
465 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
466 {
467         int res;
468         if ((res = setsockopt(rtp->s, SOL_IP, IP_TOS, &tos, sizeof(tos)))) 
469                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
470         return res;
471 }
472
473 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
474 {
475         rtp->them.sin_port = them->sin_port;
476         rtp->them.sin_addr = them->sin_addr;
477 }
478
479 void ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
480 {
481         them->sin_family = AF_INET;
482         them->sin_port = rtp->them.sin_port;
483         them->sin_addr = rtp->them.sin_addr;
484 }
485
486 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
487 {
488         memcpy(us, &rtp->us, sizeof(rtp->us));
489 }
490
491 void ast_rtp_destroy(struct ast_rtp *rtp)
492 {
493         if (rtp->smoother)
494                 ast_smoother_free(rtp->smoother);
495         if (rtp->ioid)
496                 ast_io_remove(rtp->io, rtp->ioid);
497         if (rtp->s > -1)
498                 close(rtp->s);
499         free(rtp);
500 }
501
502 static unsigned int calc_txstamp(struct ast_rtp *rtp)
503 {
504         struct timeval now;
505         unsigned int ms;
506         if (!rtp->txcore.tv_sec && !rtp->txcore.tv_usec) {
507                 gettimeofday(&rtp->txcore, NULL);
508         }
509         gettimeofday(&now, NULL);
510         ms = (now.tv_sec - rtp->txcore.tv_sec) * 1000;
511         ms += (now.tv_usec - rtp->txcore.tv_usec) / 1000;
512         /* Use what we just got for next time */
513         rtp->txcore.tv_sec = now.tv_sec;
514         rtp->txcore.tv_usec = now.tv_usec;
515         return ms;
516 }
517
518 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
519 {
520         unsigned int *rtpheader;
521         int hdrlen = 12;
522         int res;
523         int ms;
524         int pred;
525         int x;
526         char data[256];
527
528         if ((digit <= '9') && (digit >= '0'))
529                 digit -= '0';
530         else if (digit == '*')
531                 digit = 10;
532         else if (digit == '#')
533                 digit = 11;
534         else if ((digit >= 'A') && (digit <= 'D')) 
535                 digit = digit - 'A' + 12;
536         else if ((digit >= 'a') && (digit <= 'd')) 
537                 digit = digit - 'a' + 12;
538         else {
539                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
540                 return -1;
541         }
542         
543
544         /* If we have no peer, return immediately */    
545         if (!rtp->them.sin_addr.s_addr)
546                 return 0;
547
548         ms = calc_txstamp(rtp);
549         /* Default prediction */
550         pred = rtp->lastts + ms * 8;
551         
552         /* Get a pointer to the header */
553         rtpheader = (unsigned int *)data;
554         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (101 << 16) | (rtp->seqno++));
555         rtpheader[1] = htonl(rtp->lastts);
556         rtpheader[2] = htonl(rtp->ssrc); 
557         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
558         for (x=0;x<4;x++) {
559                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
560                         res = sendto(rtp->s, (void *)rtpheader, hdrlen + 4, 0, &rtp->them, sizeof(rtp->them));
561                         if (res <0) 
562                                 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));
563         #if 0
564                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
565         #endif          
566                 }
567                 if (x ==0) {
568                         /* Clear marker bit and increment seqno */
569                         rtpheader[0] = htonl((2 << 30)  | (101 << 16) | (rtp->seqno++));
570                         /* Make duration 240 */
571                         rtpheader[3] |= htonl((240));
572                         /* Set the End bit for the last 3 */
573                         rtpheader[3] |= htonl((1 << 23));
574                 }
575         }
576         return 0;
577 }
578
579 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
580 {
581         unsigned int *rtpheader;
582         int hdrlen = 12;
583         int res;
584         int ms;
585         int pred;
586
587         ms = calc_txstamp(rtp);
588         /* Default prediction */
589         pred = rtp->lastts + ms * 8;
590         
591         switch(f->subclass) {
592         case AST_FORMAT_ULAW:
593         case AST_FORMAT_ALAW:
594                 /* If we're within +/- 20ms from when where we
595                    predict we should be, use that */
596                 pred = rtp->lastts + f->datalen;
597                 break;
598         case AST_FORMAT_G729A:
599                 pred = rtp->lastts + f->datalen * 8;
600                 break;
601         case AST_FORMAT_GSM:
602                 pred = rtp->lastts + (f->datalen * 160 / 33);
603                 break;
604         case AST_FORMAT_G723_1:
605                 pred = rtp->lastts + g723_samples(f->data, f->datalen);
606                 break;
607         default:
608                 ast_log(LOG_WARNING, "Not sure about timestamp format for codec format %d\n", f->subclass);
609         }
610
611         /* Re-calculate last TS */
612         rtp->lastts = rtp->lastts + ms * 8;
613         /* If it's close to ou prediction, go for it */
614         if (abs(rtp->lastts - pred) < 640)
615                 rtp->lastts = pred;
616         else
617                 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
618         /* Get a pointer to the header */
619         rtpheader = (unsigned int *)(f->data - hdrlen);
620         rtpheader[0] = htonl((2 << 30) | (codec << 16) | (rtp->seqno++));
621         rtpheader[1] = htonl(rtp->lastts);
622         rtpheader[2] = htonl(rtp->ssrc); 
623         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
624                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, &rtp->them, sizeof(rtp->them));
625                 if (res <0) 
626                         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));
627 #if 0
628                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
629 #endif          
630         }
631         return 0;
632 }
633
634 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
635 {
636         struct ast_frame *f;
637         int codec;
638         int hdrlen = 12;
639         
640
641         /* If we have no peer, return immediately */    
642         if (!rtp->them.sin_addr.s_addr)
643                 return 0;
644         
645         /* Make sure we have enough space for RTP header */
646         if (_f->frametype != AST_FRAME_VOICE) {
647                 ast_log(LOG_WARNING, "RTP can only send voice\n");
648                 return -1;
649         }
650
651         codec = ast2rtp(_f->subclass);
652         if (codec < 0) {
653                 ast_log(LOG_WARNING, "Don't know how to send format %d packets with RTP\n", _f->subclass);
654                 return -1;
655         }
656
657         if (rtp->lasttxformat !=  _f->subclass) {
658                 /* New format, reset the smoother */
659                 ast_log(LOG_DEBUG, "Ooh, format changed from %d to %d\n", rtp->lasttxformat, _f->subclass);
660                 rtp->lasttxformat = _f->subclass;
661                 if (rtp->smoother)
662                         ast_smoother_free(rtp->smoother);
663                 rtp->smoother = NULL;
664         }
665
666
667         switch(_f->subclass) {
668         case AST_FORMAT_ULAW:
669         case AST_FORMAT_ALAW:
670                 if (!rtp->smoother) {
671                         rtp->smoother = ast_smoother_new(160);
672                 }
673                 if (!rtp->smoother) {
674                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
675                         return -1;
676                 }
677                 ast_smoother_feed(rtp->smoother, _f);
678                 
679                 while((f = ast_smoother_read(rtp->smoother)))
680                         ast_rtp_raw_write(rtp, f, codec);
681                 break;
682         case AST_FORMAT_G729A:
683                 if (!rtp->smoother) {
684                         rtp->smoother = ast_smoother_new(20);
685                 }
686                 if (!rtp->smoother) {
687                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
688                         return -1;
689                 }
690                 ast_smoother_feed(rtp->smoother, _f);
691                 
692                 while((f = ast_smoother_read(rtp->smoother)))
693                         ast_rtp_raw_write(rtp, f, codec);
694                 break;
695         case AST_FORMAT_GSM:
696                 if (!rtp->smoother) {
697                         rtp->smoother = ast_smoother_new(33);
698                 }
699                 if (!rtp->smoother) {
700                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
701                         return -1;
702                 }
703                 ast_smoother_feed(rtp->smoother, _f);
704                 while((f = ast_smoother_read(rtp->smoother)))
705                         ast_rtp_raw_write(rtp, f, codec);
706                 break;
707         default:        
708                 ast_log(LOG_WARNING, "Not sure about sending format %d packets\n", _f->subclass);
709                 if (_f->offset < hdrlen) {
710                         f = ast_frdup(_f);
711                 } else {
712                         f = _f;
713                 }
714                 ast_rtp_raw_write(rtp, f, codec);
715         }
716                 
717         return 0;
718 }
719
720 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
721 {
722         struct ast_rtp_protocol *cur, *prev;
723         cur = protos;
724         prev = NULL;
725         while(cur) {
726                 if (cur == proto) {
727                         if (prev)
728                                 prev->next = proto->next;
729                         else
730                                 protos = proto->next;
731                         return;
732                 }
733                 prev = cur;
734                 cur = cur->next;
735         }
736 }
737
738 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
739 {
740         struct ast_rtp_protocol *cur;
741         cur = protos;
742         while(cur) {
743                 if (cur->type == proto->type) {
744                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
745                         return -1;
746                 }
747                 cur = cur->next;
748         }
749         proto->next = protos;
750         protos = proto;
751         return 0;
752 }
753
754 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
755 {
756         struct ast_rtp_protocol *cur;
757         cur = protos;
758         while(cur) {
759                 if (cur->type == chan->type) {
760                         return cur;
761                 }
762                 cur = cur->next;
763         }
764         return NULL;
765 }
766
767 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
768 {
769         struct ast_frame *f;
770         struct ast_channel *who, *cs[3];
771         struct ast_rtp *p0, *p1;
772         struct ast_rtp_protocol *pr0, *pr1;
773         void *pvt0, *pvt1;
774         int to;
775
776         /* XXX Wait a half a second for things to settle up 
777                         this really should be fixed XXX */
778         ast_autoservice_start(c0);
779         ast_autoservice_start(c1);
780         usleep(500000);
781         ast_autoservice_stop(c0);
782         ast_autoservice_stop(c1);
783
784         /* if need DTMF, cant native bridge */
785         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
786                 return -2;
787         ast_pthread_mutex_lock(&c0->lock);
788         ast_pthread_mutex_lock(&c1->lock);
789         pr0 = get_proto(c0);
790         pr1 = get_proto(c1);
791         if (!pr0) {
792                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
793                 ast_pthread_mutex_unlock(&c0->lock);
794                 ast_pthread_mutex_unlock(&c1->lock);
795                 return -1;
796         }
797         if (!pr1) {
798                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
799                 ast_pthread_mutex_unlock(&c0->lock);
800                 ast_pthread_mutex_unlock(&c1->lock);
801                 return -1;
802         }
803         pvt0 = c0->pvt->pvt;
804         pvt1 = c1->pvt->pvt;
805         p0 = pr0->get_rtp_info(c0);
806         p1 = pr1->get_rtp_info(c1);
807         if (!p0 || !p1) {
808                 /* Somebody doesn't want to play... */
809                 ast_pthread_mutex_unlock(&c0->lock);
810                 ast_pthread_mutex_unlock(&c1->lock);
811                 return -2;
812         }
813         if (pr0->set_rtp_peer(c0, p1)) 
814                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
815         if (pr1->set_rtp_peer(c1, p0)) 
816                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
817         ast_pthread_mutex_unlock(&c0->lock);
818         ast_pthread_mutex_unlock(&c1->lock);
819         cs[0] = c0;
820         cs[1] = c1;
821         cs[2] = NULL;
822         for (;;) {
823                 if ((c0->pvt->pvt != pvt0)  ||
824                         (c1->pvt->pvt != pvt1) ||
825                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
826                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
827                                 if (c0->pvt->pvt == pvt0) {
828                                         if (pr0->set_rtp_peer(c0, NULL)) 
829                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
830                                 }
831                                 if (c1->pvt->pvt == pvt1) {
832                                         if (pr1->set_rtp_peer(c1, NULL)) 
833                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
834                                 }
835                                 /* Tell it to try again later */
836                                 return -3;
837                 }
838                 to = -1;
839                 who = ast_waitfor_n(cs, 2, &to);
840                 if (!who) {
841                         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
842                         continue;
843                 }
844                 f = ast_read(who);
845                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
846                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
847                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
848                         *fo = f;
849                         *rc = who;
850                         ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
851                         if ((c0->pvt->pvt == pvt0) && (!c0->_softhangup)) {
852                                 if (pr0->set_rtp_peer(c0, NULL)) 
853                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
854                         }
855                         if ((c1->pvt->pvt == pvt1) && (!c1->_softhangup)) {
856                                 if (pr1->set_rtp_peer(c1, NULL)) 
857                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
858                         }
859                         /* That's all we needed */
860                         return 0;
861                 } else 
862                         ast_frfree(f);
863                 /* Swap priority not that it's a big deal at this point */
864                 cs[2] = cs[0];
865                 cs[0] = cs[1];
866                 cs[1] = cs[2];
867                 
868         }
869         return -1;
870 }