Fri Mar 7 07:00:00 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                 memcpy(&rtp->them, &sin, sizeof(rtp->them));
286         }
287         /* Get fields */
288         seqno = ntohl(rtpheader[0]);
289         payloadtype = (seqno & 0x7f0000) >> 16;
290         seqno &= 0xffff;
291         timestamp = ntohl(rtpheader[1]);
292 #if 0
293         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);
294 #endif  
295         rtp->f.frametype = AST_FRAME_VOICE;
296         rtp->f.subclass = rtp2ast(payloadtype);
297         if (rtp->f.subclass < 0) {
298                 f = NULL;
299                 if (payloadtype == 101) {
300                         /* It's special -- rfc2833 process it */
301                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
302                 } else if (payloadtype == 121) {
303                         /* CISCO proprietary DTMF bridge */
304                         f = process_type121(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
305                 } else if (payloadtype == 100) {
306                         /* CISCO's notso proprietary DTMF bridge */
307                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
308                 } else if (payloadtype == 13) {
309                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
310                 } else {
311                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received\n", payloadtype);
312                 }
313                 if (f)
314                         return f;
315                 else
316                         return &null_frame;
317         } else
318                 rtp->lastrxformat = rtp->f.subclass;
319
320         if (!rtp->lastrxts)
321                 rtp->lastrxts = timestamp;
322
323         if (rtp->dtmfcount) {
324 #if 0
325                 printf("dtmfcount was %d\n", rtp->dtmfcount);
326 #endif          
327                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
328                 if (rtp->dtmfcount < 0)
329                         rtp->dtmfcount = 0;
330 #if 0
331                 if (dtmftimeout != rtp->dtmfcount)
332                         printf("dtmfcount is %d\n", rtp->dtmfcount);
333 #endif
334         }
335         rtp->lastrxts = timestamp;
336
337         /* Send any pending DTMF */
338         if (rtp->resp && !rtp->dtmfcount) {
339                 ast_log(LOG_DEBUG, "Sending pending DTMF\n");
340                 return send_dtmf(rtp);
341         }
342         rtp->f.mallocd = 0;
343         rtp->f.datalen = res - hdrlen;
344         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
345         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
346         switch(rtp->f.subclass) {
347         case AST_FORMAT_ULAW:
348         case AST_FORMAT_ALAW:
349                 rtp->f.samples = rtp->f.datalen;
350                 break;
351         case AST_FORMAT_SLINEAR:
352                 rtp->f.samples = rtp->f.datalen / 2;
353                 break;
354         case AST_FORMAT_GSM:
355                 rtp->f.samples = 160 * (rtp->f.datalen / 33);
356                 break;
357         case AST_FORMAT_ADPCM:
358                 rtp->f.samples = rtp->f.datalen * 2;
359                 break;
360         case AST_FORMAT_G729A:
361                 rtp->f.samples = rtp->f.datalen * 8;
362                 break;
363         case AST_FORMAT_G723_1:
364                 rtp->f.samples = g723_samples(rtp->f.data, rtp->f.datalen);
365                 break;
366         default:
367                 ast_log(LOG_NOTICE, "Unable to calculate samples for format %d\n", rtp->f.subclass);
368                 break;
369         }
370         rtp->f.src = "RTP";
371         return &rtp->f;
372 }
373
374 static struct {
375         int rtp;
376         int ast;
377         char *label;
378 } cmap[] = {
379         { 0, AST_FORMAT_ULAW, "PCMU" },
380         { 3, AST_FORMAT_GSM, "GSM" },
381         { 4, AST_FORMAT_G723_1, "G723" },
382         { 5, AST_FORMAT_ADPCM, "ADPCM" },
383         { 8, AST_FORMAT_ALAW, "PCMA" },
384         { 18, AST_FORMAT_G729A, "G729" },
385 };
386
387 int rtp2ast(int id)
388 {
389         int x;
390         for (x=0;x<sizeof(cmap) / sizeof(cmap[0]); x++) {
391                 if (cmap[x].rtp == id)
392                         return cmap[x].ast;
393         }
394         return -1;
395 }
396
397 int ast2rtp(int id)
398 {
399         int x;
400         for (x=0;x<sizeof(cmap) / sizeof(cmap[0]); x++) {
401                 if (cmap[x].ast == id)
402                         return cmap[x].rtp;
403         }
404         return -1;
405 }
406
407 char *ast2rtpn(int id)
408 {
409         int x;
410         for (x=0;x<sizeof(cmap) / sizeof(cmap[0]); x++) {
411                 if (cmap[x].ast == id)
412                         return cmap[x].label;
413         }
414         return "";
415 }
416 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io)
417 {
418         struct ast_rtp *rtp;
419         int x;
420         int flags;
421         rtp = malloc(sizeof(struct ast_rtp));
422         if (!rtp)
423                 return NULL;
424         memset(rtp, 0, sizeof(struct ast_rtp));
425         rtp->them.sin_family = AF_INET;
426         rtp->us.sin_family = AF_INET;
427         rtp->s = socket(AF_INET, SOCK_DGRAM, 0);
428         rtp->ssrc = rand();
429         rtp->seqno = rand() & 0xffff;
430         if (rtp->s < 0) {
431                 free(rtp);
432                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
433                 return NULL;
434         }
435         flags = fcntl(rtp->s, F_GETFL);
436         fcntl(rtp->s, F_SETFL, flags | O_NONBLOCK);
437         for (;;) {
438                 /* Find us a place */
439                 x = (rand() % (65000-1025)) + 1025;
440                 /* Must be an even port number by RTP spec */
441                 x = x & ~1;
442                 rtp->us.sin_port = htons(x);
443                 if (!bind(rtp->s, &rtp->us, sizeof(rtp->us)))
444                         break;
445                 if (errno != EADDRINUSE) {
446                         ast_log(LOG_WARNING, "Unexpected bind error: %s\n", strerror(errno));
447                         close(rtp->s);
448                         free(rtp);
449                         return NULL;
450                 }
451         }
452         if (io && sched) {
453                 /* Operate this one in a callback mode */
454                 rtp->sched = sched;
455                 rtp->io = io;
456                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
457         }
458         return rtp;
459 }
460
461 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
462 {
463         int res;
464         if ((res = setsockopt(rtp->s, SOL_IP, IP_TOS, &tos, sizeof(tos)))) 
465                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
466         return res;
467 }
468
469 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
470 {
471         rtp->them.sin_port = them->sin_port;
472         rtp->them.sin_addr = them->sin_addr;
473 }
474
475 void ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
476 {
477         them->sin_family = AF_INET;
478         them->sin_port = rtp->them.sin_port;
479         them->sin_addr = rtp->them.sin_addr;
480 }
481
482 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
483 {
484         memcpy(us, &rtp->us, sizeof(rtp->us));
485 }
486
487 void ast_rtp_destroy(struct ast_rtp *rtp)
488 {
489         if (rtp->smoother)
490                 ast_smoother_free(rtp->smoother);
491         if (rtp->ioid)
492                 ast_io_remove(rtp->io, rtp->ioid);
493         if (rtp->s > -1)
494                 close(rtp->s);
495         free(rtp);
496 }
497
498 static unsigned int calc_txstamp(struct ast_rtp *rtp)
499 {
500         struct timeval now;
501         unsigned int ms;
502         if (!rtp->txcore.tv_sec && !rtp->txcore.tv_usec) {
503                 gettimeofday(&rtp->txcore, NULL);
504         }
505         gettimeofday(&now, NULL);
506         ms = (now.tv_sec - rtp->txcore.tv_sec) * 1000;
507         ms += (now.tv_usec - rtp->txcore.tv_usec) / 1000;
508         /* Use what we just got for next time */
509         rtp->txcore.tv_sec = now.tv_sec;
510         rtp->txcore.tv_usec = now.tv_usec;
511         return ms;
512 }
513
514 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
515 {
516         unsigned int *rtpheader;
517         int hdrlen = 12;
518         int res;
519         int ms;
520         int pred;
521         int x;
522         char data[256];
523
524         if ((digit <= '9') && (digit >= '0'))
525                 digit -= '0';
526         else if (digit == '*')
527                 digit = 10;
528         else if (digit == '#')
529                 digit = 11;
530         else if ((digit >= 'A') && (digit <= 'D')) 
531                 digit = digit - 'A' + 12;
532         else if ((digit >= 'a') && (digit <= 'd')) 
533                 digit = digit - 'a' + 12;
534         else {
535                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
536                 return -1;
537         }
538         
539
540         /* If we have no peer, return immediately */    
541         if (!rtp->them.sin_addr.s_addr)
542                 return 0;
543
544         ms = calc_txstamp(rtp);
545         /* Default prediction */
546         pred = rtp->lastts + ms * 8;
547         
548         /* Get a pointer to the header */
549         rtpheader = (unsigned int *)data;
550         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (101 << 16) | (rtp->seqno++));
551         rtpheader[1] = htonl(rtp->lastts);
552         rtpheader[2] = htonl(rtp->ssrc); 
553         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
554         for (x=0;x<4;x++) {
555                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
556                         res = sendto(rtp->s, (void *)rtpheader, hdrlen + 4, 0, &rtp->them, sizeof(rtp->them));
557                         if (res <0) 
558                                 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));
559         #if 0
560                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
561         #endif          
562                 }
563                 if (x ==0) {
564                         /* Clear marker bit and increment seqno */
565                         rtpheader[0] = htonl((2 << 30)  | (101 << 16) | (rtp->seqno++));
566                         /* Make duration 240 */
567                         rtpheader[3] |= htonl((240));
568                         /* Set the End bit for the last 3 */
569                         rtpheader[3] |= htonl((1 << 23));
570                 }
571         }
572         return 0;
573 }
574
575 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
576 {
577         unsigned int *rtpheader;
578         int hdrlen = 12;
579         int res;
580         int ms;
581         int pred;
582
583         ms = calc_txstamp(rtp);
584         /* Default prediction */
585         pred = rtp->lastts + ms * 8;
586         
587         switch(f->subclass) {
588         case AST_FORMAT_ULAW:
589         case AST_FORMAT_ALAW:
590                 /* If we're within +/- 20ms from when where we
591                    predict we should be, use that */
592                 pred = rtp->lastts + f->datalen;
593                 break;
594         case AST_FORMAT_G729A:
595                 pred = rtp->lastts + f->datalen * 8;
596                 break;
597         case AST_FORMAT_GSM:
598                 pred = rtp->lastts + (f->datalen * 160 / 33);
599                 break;
600         case AST_FORMAT_G723_1:
601                 pred = rtp->lastts + g723_samples(f->data, f->datalen);
602                 break;
603         default:
604                 ast_log(LOG_WARNING, "Not sure about timestamp format for codec format %d\n", f->subclass);
605         }
606
607         /* Re-calculate last TS */
608         rtp->lastts = rtp->lastts + ms * 8;
609         /* If it's close to ou prediction, go for it */
610         if (abs(rtp->lastts - pred) < 640)
611                 rtp->lastts = pred;
612         else
613                 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
614         /* Get a pointer to the header */
615         rtpheader = (unsigned int *)(f->data - hdrlen);
616         rtpheader[0] = htonl((2 << 30) | (codec << 16) | (rtp->seqno++));
617         rtpheader[1] = htonl(rtp->lastts);
618         rtpheader[2] = htonl(rtp->ssrc); 
619         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
620                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, &rtp->them, sizeof(rtp->them));
621                 if (res <0) 
622                         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));
623 #if 0
624                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
625 #endif          
626         }
627         return 0;
628 }
629
630 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
631 {
632         struct ast_frame *f;
633         int codec;
634         int hdrlen = 12;
635         
636
637         /* If we have no peer, return immediately */    
638         if (!rtp->them.sin_addr.s_addr)
639                 return 0;
640         
641         /* Make sure we have enough space for RTP header */
642         if (_f->frametype != AST_FRAME_VOICE) {
643                 ast_log(LOG_WARNING, "RTP can only send voice\n");
644                 return -1;
645         }
646
647         codec = ast2rtp(_f->subclass);
648         if (codec < 0) {
649                 ast_log(LOG_WARNING, "Don't know how to send format %d packets with RTP\n", _f->subclass);
650                 return -1;
651         }
652
653         if (rtp->lasttxformat !=  _f->subclass) {
654                 /* New format, reset the smoother */
655                 ast_log(LOG_DEBUG, "Ooh, format changed from %d to %d\n", rtp->lasttxformat, _f->subclass);
656                 rtp->lasttxformat = _f->subclass;
657                 if (rtp->smoother)
658                         ast_smoother_free(rtp->smoother);
659                 rtp->smoother = NULL;
660         }
661
662
663         switch(_f->subclass) {
664         case AST_FORMAT_ULAW:
665         case AST_FORMAT_ALAW:
666                 if (!rtp->smoother) {
667                         rtp->smoother = ast_smoother_new(160);
668                 }
669                 if (!rtp->smoother) {
670                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
671                         return -1;
672                 }
673                 ast_smoother_feed(rtp->smoother, _f);
674                 
675                 while((f = ast_smoother_read(rtp->smoother)))
676                         ast_rtp_raw_write(rtp, f, codec);
677                 break;
678         case AST_FORMAT_G729A:
679                 if (!rtp->smoother) {
680                         rtp->smoother = ast_smoother_new(20);
681                 }
682                 if (!rtp->smoother) {
683                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
684                         return -1;
685                 }
686                 ast_smoother_feed(rtp->smoother, _f);
687                 
688                 while((f = ast_smoother_read(rtp->smoother)))
689                         ast_rtp_raw_write(rtp, f, codec);
690                 break;
691         case AST_FORMAT_GSM:
692                 if (!rtp->smoother) {
693                         rtp->smoother = ast_smoother_new(33);
694                 }
695                 if (!rtp->smoother) {
696                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
697                         return -1;
698                 }
699                 ast_smoother_feed(rtp->smoother, _f);
700                 while((f = ast_smoother_read(rtp->smoother)))
701                         ast_rtp_raw_write(rtp, f, codec);
702                 break;
703         default:        
704                 ast_log(LOG_WARNING, "Not sure about sending format %d packets\n", _f->subclass);
705                 if (_f->offset < hdrlen) {
706                         f = ast_frdup(_f);
707                 } else {
708                         f = _f;
709                 }
710                 ast_rtp_raw_write(rtp, f, codec);
711         }
712                 
713         return 0;
714 }
715
716 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
717 {
718         struct ast_rtp_protocol *cur, *prev;
719         cur = protos;
720         prev = NULL;
721         while(cur) {
722                 if (cur == proto) {
723                         if (prev)
724                                 prev->next = proto->next;
725                         else
726                                 protos = proto->next;
727                         return;
728                 }
729                 prev = cur;
730                 cur = cur->next;
731         }
732 }
733
734 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
735 {
736         struct ast_rtp_protocol *cur;
737         cur = protos;
738         while(cur) {
739                 if (cur->type == proto->type) {
740                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
741                         return -1;
742                 }
743                 cur = cur->next;
744         }
745         proto->next = protos;
746         protos = proto;
747         return 0;
748 }
749
750 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
751 {
752         struct ast_rtp_protocol *cur;
753         cur = protos;
754         while(cur) {
755                 if (cur->type == chan->type) {
756                         return cur;
757                 }
758                 cur = cur->next;
759         }
760         return NULL;
761 }
762
763 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
764 {
765         struct ast_frame *f;
766         struct ast_channel *who, *cs[3];
767         struct ast_rtp *p0, *p1;
768         struct ast_rtp_protocol *pr0, *pr1;
769         void *pvt0, *pvt1;
770         int to;
771
772         /* XXX Wait a half a second for things to settle up 
773                         this really should be fixed XXX */
774         ast_autoservice_start(c0);
775         ast_autoservice_start(c1);
776         usleep(500000);
777         ast_autoservice_stop(c0);
778         ast_autoservice_stop(c1);
779
780         /* if need DTMF, cant native bridge */
781         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
782                 return -2;
783         ast_pthread_mutex_lock(&c0->lock);
784         ast_pthread_mutex_lock(&c1->lock);
785         pr0 = get_proto(c0);
786         pr1 = get_proto(c1);
787         if (!pr0) {
788                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
789                 ast_pthread_mutex_unlock(&c0->lock);
790                 ast_pthread_mutex_unlock(&c1->lock);
791                 return -1;
792         }
793         if (!pr1) {
794                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
795                 ast_pthread_mutex_unlock(&c0->lock);
796                 ast_pthread_mutex_unlock(&c1->lock);
797                 return -1;
798         }
799         pvt0 = c0->pvt->pvt;
800         pvt1 = c1->pvt->pvt;
801         p0 = pr0->get_rtp_info(c0);
802         p1 = pr1->get_rtp_info(c1);
803         if (!p0 || !p1) {
804                 /* Somebody doesn't want to play... */
805                 ast_pthread_mutex_unlock(&c0->lock);
806                 ast_pthread_mutex_unlock(&c1->lock);
807                 return -2;
808         }
809         if (pr0->set_rtp_peer(c0, p1)) 
810                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
811         if (pr1->set_rtp_peer(c1, p0)) 
812                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
813         ast_pthread_mutex_unlock(&c0->lock);
814         ast_pthread_mutex_unlock(&c1->lock);
815         cs[0] = c0;
816         cs[1] = c1;
817         cs[2] = NULL;
818         for (;;) {
819                 if ((c0->pvt->pvt != pvt0)  ||
820                         (c1->pvt->pvt != pvt1) ||
821                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
822                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
823                                 if (c0->pvt->pvt == pvt0) {
824                                         if (pr0->set_rtp_peer(c0, NULL)) 
825                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
826                                 }
827                                 if (c1->pvt->pvt == pvt1) {
828                                         if (pr1->set_rtp_peer(c1, NULL)) 
829                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
830                                 }
831                                 /* Tell it to try again later */
832                                 return -3;
833                 }
834                 to = -1;
835                 who = ast_waitfor_n(cs, 2, &to);
836                 if (!who) {
837                         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
838                         continue;
839                 }
840                 f = ast_read(who);
841                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
842                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
843                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
844                         *fo = f;
845                         *rc = who;
846                         ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
847                         if ((c0->pvt->pvt == pvt0) && (!c0->_softhangup)) {
848                                 if (pr0->set_rtp_peer(c0, NULL)) 
849                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
850                         }
851                         if ((c1->pvt->pvt == pvt1) && (!c1->_softhangup)) {
852                                 if (pr1->set_rtp_peer(c1, NULL)) 
853                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
854                         }
855                         /* That's all we needed */
856                         return 0;
857                 } else 
858                         ast_frfree(f);
859                 /* Swap priority not that it's a big deal at this point */
860                 cs[2] = cs[0];
861                 cs[0] = cs[1];
862                 cs[1] = cs[2];
863                 
864         }
865         return -1;
866 }