ast_rtp_pt_lookups must be done against static set
[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_pvt.h>
35
36 #define TYPE_SILENCE     0x2
37 #define TYPE_HIGH        0x0
38 #define TYPE_LOW         0x1
39 #define TYPE_MASK        0x3
40
41 static int dtmftimeout = 300;   /* 300 samples */
42
43 // The value of each payload format mapping:
44 struct rtpPayloadType {
45   int isAstFormat; // whether the following code is an AST_FORMAT
46   int code;
47 };
48
49 #define MAX_RTP_PT 256
50
51 struct ast_rtp {
52         int s;
53         char resp;
54         struct ast_frame f;
55         unsigned char rawdata[1024 + AST_FRIENDLY_OFFSET];
56         unsigned int ssrc;
57         unsigned int lastts;
58         unsigned int lastrxts;
59         int lasttxformat;
60         int lastrxformat;
61         int dtmfcount;
62         int nat;
63         struct sockaddr_in us;
64         struct sockaddr_in them;
65         struct timeval rxcore;
66         struct timeval txcore;
67         struct ast_smoother *smoother;
68         int *ioid;
69         unsigned short seqno;
70         struct sched_context *sched;
71         struct io_context *io;
72         void *data;
73         ast_rtp_callback callback;
74     struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
75     // a cache for the result of rtp_lookup_code():
76     int rtp_lookup_code_cache_isAstFormat;
77     int rtp_lookup_code_cache_code;
78     int rtp_lookup_code_cache_result;
79 };
80
81 static struct ast_rtp_protocol *protos = NULL;
82
83 int ast_rtp_fd(struct ast_rtp *rtp)
84 {
85         return rtp->s;
86 }
87
88 static int g723_len(unsigned char buf)
89 {
90         switch(buf & TYPE_MASK) {
91         case TYPE_MASK:
92         case TYPE_SILENCE:
93                 return 4;
94                 break;
95         case TYPE_HIGH:
96                 return 24;
97                 break;
98         case TYPE_LOW:
99                 return 20;
100                 break;
101         default:
102                 ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", buf & TYPE_MASK);
103         }
104         return -1;
105 }
106
107 static int g723_samples(unsigned char *buf, int maxlen)
108 {
109         int pos = 0;
110         int samples = 0;
111         int res;
112         while(pos < maxlen) {
113                 res = g723_len(buf[pos]);
114                 if (res < 0)
115                         break;
116                 samples += 240;
117                 pos += res;
118         }
119         return samples;
120 }
121
122 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
123 {
124         rtp->data = data;
125 }
126
127 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
128 {
129         rtp->callback = callback;
130 }
131
132 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
133 {
134         rtp->nat = nat;
135 }
136
137 static struct ast_frame *send_dtmf(struct ast_rtp *rtp)
138 {
139         ast_log(LOG_DEBUG, "Sending dtmf: %d (%c)\n", rtp->resp, rtp->resp);
140         rtp->f.frametype = AST_FRAME_DTMF;
141         rtp->f.subclass = rtp->resp;
142         rtp->f.datalen = 0;
143         rtp->f.samples = 0;
144         rtp->f.mallocd = 0;
145         rtp->f.src = "RTP";
146         rtp->resp = 0;
147         return &rtp->f;
148         
149 }
150
151 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len)
152 {
153         unsigned int event;
154         char resp = 0;
155         struct ast_frame *f = NULL;
156         event = ntohl(*((unsigned int *)(data)));
157         event >>= 24;
158 #if 0
159         printf("Event: %08x (len = %d)\n", event, len);
160 #endif  
161         if (event < 10) {
162                 resp = '0' + event;
163         } else if (event < 11) {
164                 resp = '*';
165         } else if (event < 12) {
166                 resp = '#';
167         } else if (event < 16) {
168                 resp = 'A' + (event - 12);
169         }
170         if (rtp->resp && (rtp->resp != resp)) {
171                 f = send_dtmf(rtp);
172         }
173         rtp->resp = resp;
174         rtp->dtmfcount = dtmftimeout;
175         return f;
176 }
177
178 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
179 {
180         struct ast_frame *f = NULL;
181         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
182            totally help us out becuase we don't have an engine to keep it going and we are not
183            guaranteed to have it every 20ms or anything */
184 #if 0
185         printf("RFC3389: %d bytes, format is %d\n", len, rtp->lastrxformat);
186 #endif  
187         ast_log(LOG_NOTICE, "RFC3389 support incomplete.  Turn off on client if possible\n");
188         if (!rtp->lastrxformat)
189                 return  NULL;
190         switch(rtp->lastrxformat) {
191         case AST_FORMAT_ULAW:
192                 rtp->f.frametype = AST_FRAME_VOICE;
193                 rtp->f.subclass = AST_FORMAT_ULAW;
194                 rtp->f.datalen = 160;
195                 rtp->f.samples = 160;
196                 memset(rtp->f.data, 0x7f, rtp->f.datalen);
197                 f = &rtp->f;
198                 break;
199         case AST_FORMAT_ALAW:
200                 rtp->f.frametype = AST_FRAME_VOICE;
201                 rtp->f.subclass = AST_FORMAT_ALAW;
202                 rtp->f.datalen = 160;
203                 rtp->f.samples = 160;
204                 memset(rtp->f.data, 0x7e, rtp->f.datalen); /* XXX Is this right? XXX */
205                 f = &rtp->f;
206                 break;
207         case AST_FORMAT_SLINEAR:
208                 rtp->f.frametype = AST_FRAME_VOICE;
209                 rtp->f.subclass = AST_FORMAT_SLINEAR;
210                 rtp->f.datalen = 320;
211                 rtp->f.samples = 160;
212                 memset(rtp->f.data, 0x00, rtp->f.datalen);
213                 f = &rtp->f;
214                 break;
215         default:
216                 ast_log(LOG_NOTICE, "Don't know how to handle RFC3389 for receive codec %d\n", rtp->lastrxformat);
217         }
218         return f;
219 }
220
221 static int rtpread(int *id, int fd, short events, void *cbdata)
222 {
223         struct ast_rtp *rtp = cbdata;
224         struct ast_frame *f;
225         f = ast_rtp_read(rtp);
226         if (f) {
227                 if (rtp->callback)
228                         rtp->callback(rtp, f, rtp->data);
229         }
230         return 1;
231 }
232
233 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
234 {
235         int res;
236         struct sockaddr_in sin;
237         int len;
238         unsigned int seqno;
239         int payloadtype;
240         int hdrlen = 12;
241         unsigned int timestamp;
242         unsigned int *rtpheader;
243         static struct ast_frame *f, null_frame = { AST_FRAME_NULL, };
244         struct rtpPayloadType rtpPT;
245         
246         len = sizeof(sin);
247         
248         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
249                                         0, (struct sockaddr *)&sin, &len);
250
251
252         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
253         if (res < 0) {
254                 ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
255                 if (errno == EBADF)
256                         CRASH;
257                 return &null_frame;
258         }
259         if (res < hdrlen) {
260                 ast_log(LOG_WARNING, "RTP Read too short\n");
261                 return &null_frame;
262         }
263         if (rtp->nat) {
264                 /* Send to whoever sent to us */
265                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
266                     (rtp->them.sin_port != sin.sin_port)) {
267                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
268                         ast_log(LOG_DEBUG, "RTP NAT: Using address %s:%d\n", inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
269                 }
270         }
271         /* Get fields */
272         seqno = ntohl(rtpheader[0]);
273         payloadtype = (seqno & 0x7f0000) >> 16;
274         seqno &= 0xffff;
275         timestamp = ntohl(rtpheader[1]);
276 #if 0
277         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);
278 #endif  
279         rtp->f.frametype = AST_FRAME_VOICE;
280         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
281         if (!rtpPT.isAstFormat) {
282           // This is special in-band data that's not one of our codecs
283           if (rtpPT.code == AST_RTP_DTMF) {
284             /* It's special -- rfc2833 process it */
285             f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
286             if (f) return f; else return &null_frame;
287           } else if (rtpPT.code == AST_RTP_CN) {
288             /* Comfort Noise */
289             f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
290             if (f) return f; else return &null_frame;
291           } else {
292             ast_log(LOG_NOTICE, "Unknown RTP codec %d received\n", payloadtype);
293             return &null_frame;
294           }
295         }
296         rtp->f.subclass = rtpPT.code;
297         rtp->lastrxformat = rtp->f.subclass;
298
299         if (!rtp->lastrxts)
300                 rtp->lastrxts = timestamp;
301
302         if (rtp->dtmfcount) {
303 #if 0
304                 printf("dtmfcount was %d\n", rtp->dtmfcount);
305 #endif          
306                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
307                 if (rtp->dtmfcount < 0)
308                         rtp->dtmfcount = 0;
309 #if 0
310                 if (dtmftimeout != rtp->dtmfcount)
311                         printf("dtmfcount is %d\n", rtp->dtmfcount);
312 #endif
313         }
314         rtp->lastrxts = timestamp;
315
316         /* Send any pending DTMF */
317         if (rtp->resp && !rtp->dtmfcount) {
318                 ast_log(LOG_DEBUG, "Sending pending DTMF\n");
319                 return send_dtmf(rtp);
320         }
321         rtp->f.mallocd = 0;
322         rtp->f.datalen = res - hdrlen;
323         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
324         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
325         switch(rtp->f.subclass) {
326         case AST_FORMAT_ULAW:
327         case AST_FORMAT_ALAW:
328                 rtp->f.samples = rtp->f.datalen;
329                 break;
330         case AST_FORMAT_SLINEAR:
331                 rtp->f.samples = rtp->f.datalen / 2;
332                 break;
333         case AST_FORMAT_GSM:
334                 rtp->f.samples = 160 * (rtp->f.datalen / 33);
335                 break;
336         case AST_FORMAT_ILBC:
337                 rtp->f.samples = 240 * (rtp->f.datalen / 50);
338                 break;
339         case AST_FORMAT_ADPCM:
340                 rtp->f.samples = rtp->f.datalen * 2;
341                 break;
342         case AST_FORMAT_G729A:
343                 rtp->f.samples = rtp->f.datalen * 8;
344                 break;
345         case AST_FORMAT_G723_1:
346                 rtp->f.samples = g723_samples(rtp->f.data, rtp->f.datalen);
347                 break;
348         case AST_FORMAT_SPEEX:
349                 rtp->f.samples = 160;
350                 // assumes that the RTP packet contained one Speex frame
351                 break;
352         default:
353                 ast_log(LOG_NOTICE, "Unable to calculate samples for format %d\n", rtp->f.subclass);
354                 break;
355         }
356         rtp->f.src = "RTP";
357         return &rtp->f;
358 }
359
360 // The following array defines the MIME type (and subtype) for each
361 // of our codecs, or RTP-specific data type.
362 static struct {
363   struct rtpPayloadType payloadType;
364   char* type;
365   char* subtype;
366 } mimeTypes[] = {
367   {{1, AST_FORMAT_G723_1}, "audio", "G723"},
368   {{1, AST_FORMAT_GSM}, "audio", "GSM"},
369   {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
370   {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
371   {{1, AST_FORMAT_MP3}, "audio", "MPA"},
372   {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
373   {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
374   {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
375   {{1, AST_FORMAT_G729A}, "audio", "G729"},
376   {{1, AST_FORMAT_SPEEX}, "audio", "SPEEX"},
377   {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
378   {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
379   {{0, AST_RTP_CN}, "audio", "CN"},
380   {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
381   {{1, AST_FORMAT_PNG}, "video", "PNG"},
382   {{1, AST_FORMAT_H261}, "video", "H261"},
383   {{1, AST_FORMAT_H263}, "video", "H263"},
384 };
385
386 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
387    also, our own choices for dynamic payload types.  This is our master
388    table for transmission */
389 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
390   [0] = {1, AST_FORMAT_ULAW},
391   [3] = {1, AST_FORMAT_GSM},
392   [4] = {1, AST_FORMAT_G723_1},
393   [5] = {1, AST_FORMAT_ADPCM}, // 8 kHz
394   [6] = {1, AST_FORMAT_ADPCM}, // 16 kHz
395   [7] = {1, AST_FORMAT_LPC10},
396   [8] = {1, AST_FORMAT_ALAW},
397   [10] = {1, AST_FORMAT_SLINEAR}, // 2 channels
398   [11] = {1, AST_FORMAT_SLINEAR}, // 1 channel
399   [13] = {0, AST_RTP_CN},
400   [14] = {1, AST_FORMAT_MP3},
401   [16] = {1, AST_FORMAT_ADPCM}, // 11.025 kHz
402   [17] = {1, AST_FORMAT_ADPCM}, // 22.050 kHz
403   [18] = {1, AST_FORMAT_G729A},
404   [26] = {1, AST_FORMAT_JPEG},
405   [31] = {1, AST_FORMAT_H261},
406   [34] = {1, AST_FORMAT_H263},
407   [97] = {1, AST_FORMAT_ILBC},
408   [101] = {0, AST_RTP_DTMF},
409   [110] = {1, AST_FORMAT_SPEEX},
410 };
411
412 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
413 {
414   int i;
415
416   for (i = 0; i < MAX_RTP_PT; ++i) {
417     rtp->current_RTP_PT[i].isAstFormat = 0;
418     rtp->current_RTP_PT[i].code = 0;
419   }
420
421   rtp->rtp_lookup_code_cache_isAstFormat = 0;
422   rtp->rtp_lookup_code_cache_code = 0;
423   rtp->rtp_lookup_code_cache_result = 0;
424 }
425
426 void ast_rtp_pt_default(struct ast_rtp* rtp) 
427 {
428   int i;
429   /* Initialize to default payload types */
430   for (i = 0; i < MAX_RTP_PT; ++i) {
431     rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
432     rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
433   }
434
435   rtp->rtp_lookup_code_cache_isAstFormat = 0;
436   rtp->rtp_lookup_code_cache_code = 0;
437   rtp->rtp_lookup_code_cache_result = 0;
438 }
439
440 // Make a note of a RTP payload type that was seen in a SDP "m=" line.
441 // By default, use the well-known value for this type (although it may
442 // still be set to a different value by a subsequent "a=rtpmap:" line):
443 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) {
444   if (pt < 0 || pt > MAX_RTP_PT) return; // bogus payload type
445
446   if (static_RTP_PT[pt].code != 0) {
447     rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
448   }
449
450
451 // Make a note of a RTP payload type (with MIME type) that was seen in
452 // a SDP "a=rtpmap:" line.
453 void ast_rtp_set_rtpmap_type(struct ast_rtp* rtp, int pt,
454                          char* mimeType, char* mimeSubtype) {
455   int i;
456
457   if (pt < 0 || pt > MAX_RTP_PT) return; // bogus payload type
458
459   for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
460     if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
461         strcasecmp(mimeType, mimeTypes[i].type) == 0) {
462       rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
463       return;
464     }
465   }
466
467
468 // Return the union of all of the codecs that were set by rtp_set...() calls
469 // They're returned as two distinct sets: AST_FORMATs, and AST_RTPs
470 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
471                              int* astFormats, int* nonAstFormats) {
472   int pt;
473
474   *astFormats = *nonAstFormats = 0;
475   for (pt = 0; pt < MAX_RTP_PT; ++pt) {
476     if (rtp->current_RTP_PT[pt].isAstFormat) {
477       *astFormats |= rtp->current_RTP_PT[pt].code;
478     } else {
479       *nonAstFormats |= rtp->current_RTP_PT[pt].code;
480     }
481   }
482 }
483
484 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) {
485   if (pt < 0 || pt > MAX_RTP_PT) {
486     struct rtpPayloadType result;
487     result.isAstFormat = result.code = 0;
488     return result; // bogus payload type
489   }
490   /* Gotta use our static one, since that's what we sent against */
491   return static_RTP_PT[pt];
492 }
493
494 int ast_rtp_lookup_code(struct ast_rtp* rtp, int isAstFormat, int code) {
495   int pt;
496
497   /* Looks up an RTP code out of our *static* outbound list */
498
499   if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
500       code == rtp->rtp_lookup_code_cache_code) {
501     // Use our cached mapping, to avoid the overhead of the loop below
502     return rtp->rtp_lookup_code_cache_result;
503   }
504
505   for (pt = 0; pt < MAX_RTP_PT; ++pt) {
506     if (static_RTP_PT[pt].code == code &&
507                 static_RTP_PT[pt].isAstFormat == isAstFormat) {
508       rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
509       rtp->rtp_lookup_code_cache_code = code;
510       rtp->rtp_lookup_code_cache_result = pt;
511       return pt;
512     }
513   }
514   return -1;
515 }
516
517 char* ast_rtp_lookup_mime_subtype(int isAstFormat, int code) {
518   int i;
519
520   for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
521     if (mimeTypes[i].payloadType.code == code &&
522         mimeTypes[i].payloadType.isAstFormat == isAstFormat) {
523       return mimeTypes[i].subtype;
524     }
525   }
526   return "";
527 }
528
529 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io)
530 {
531         struct ast_rtp *rtp;
532         int x;
533         int flags;
534         rtp = malloc(sizeof(struct ast_rtp));
535         if (!rtp)
536                 return NULL;
537         memset(rtp, 0, sizeof(struct ast_rtp));
538         rtp->them.sin_family = AF_INET;
539         rtp->us.sin_family = AF_INET;
540         rtp->s = socket(AF_INET, SOCK_DGRAM, 0);
541         rtp->ssrc = rand();
542         rtp->seqno = rand() & 0xffff;
543         if (rtp->s < 0) {
544                 free(rtp);
545                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
546                 return NULL;
547         }
548         flags = fcntl(rtp->s, F_GETFL);
549         fcntl(rtp->s, F_SETFL, flags | O_NONBLOCK);
550         for (;;) {
551                 /* Find us a place */
552                 x = (rand() % (65000-1025)) + 1025;
553                 /* Must be an even port number by RTP spec */
554                 x = x & ~1;
555                 rtp->us.sin_port = htons(x);
556                 if (!bind(rtp->s, &rtp->us, sizeof(rtp->us)))
557                         break;
558                 if (errno != EADDRINUSE) {
559                         ast_log(LOG_WARNING, "Unexpected bind error: %s\n", strerror(errno));
560                         close(rtp->s);
561                         free(rtp);
562                         return NULL;
563                 }
564         }
565         if (io && sched) {
566                 /* Operate this one in a callback mode */
567                 rtp->sched = sched;
568                 rtp->io = io;
569                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
570         }
571         ast_rtp_pt_default(rtp);
572         return rtp;
573 }
574
575 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
576 {
577         int res;
578         if ((res = setsockopt(rtp->s, SOL_IP, IP_TOS, &tos, sizeof(tos)))) 
579                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
580         return res;
581 }
582
583 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
584 {
585         rtp->them.sin_port = them->sin_port;
586         rtp->them.sin_addr = them->sin_addr;
587 }
588
589 void ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
590 {
591         them->sin_family = AF_INET;
592         them->sin_port = rtp->them.sin_port;
593         them->sin_addr = rtp->them.sin_addr;
594 }
595
596 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
597 {
598         memcpy(us, &rtp->us, sizeof(rtp->us));
599 }
600
601 void ast_rtp_stop(struct ast_rtp *rtp)
602 {
603         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
604         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
605 }
606
607 void ast_rtp_destroy(struct ast_rtp *rtp)
608 {
609         if (rtp->smoother)
610                 ast_smoother_free(rtp->smoother);
611         if (rtp->ioid)
612                 ast_io_remove(rtp->io, rtp->ioid);
613         if (rtp->s > -1)
614                 close(rtp->s);
615         free(rtp);
616 }
617
618 static unsigned int calc_txstamp(struct ast_rtp *rtp)
619 {
620         struct timeval now;
621         unsigned int ms;
622         if (!rtp->txcore.tv_sec && !rtp->txcore.tv_usec) {
623                 gettimeofday(&rtp->txcore, NULL);
624         }
625         gettimeofday(&now, NULL);
626         ms = (now.tv_sec - rtp->txcore.tv_sec) * 1000;
627         ms += (now.tv_usec - rtp->txcore.tv_usec) / 1000;
628         /* Use what we just got for next time */
629         rtp->txcore.tv_sec = now.tv_sec;
630         rtp->txcore.tv_usec = now.tv_usec;
631         return ms;
632 }
633
634 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
635 {
636         unsigned int *rtpheader;
637         int hdrlen = 12;
638         int res;
639         int ms;
640         int pred;
641         int x;
642         char data[256];
643
644         if ((digit <= '9') && (digit >= '0'))
645                 digit -= '0';
646         else if (digit == '*')
647                 digit = 10;
648         else if (digit == '#')
649                 digit = 11;
650         else if ((digit >= 'A') && (digit <= 'D')) 
651                 digit = digit - 'A' + 12;
652         else if ((digit >= 'a') && (digit <= 'd')) 
653                 digit = digit - 'a' + 12;
654         else {
655                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
656                 return -1;
657         }
658         
659
660         /* If we have no peer, return immediately */    
661         if (!rtp->them.sin_addr.s_addr)
662                 return 0;
663
664         ms = calc_txstamp(rtp);
665         /* Default prediction */
666         pred = rtp->lastts + ms * 8;
667         
668         /* Get a pointer to the header */
669         rtpheader = (unsigned int *)data;
670         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (101 << 16) | (rtp->seqno++));
671         rtpheader[1] = htonl(rtp->lastts);
672         rtpheader[2] = htonl(rtp->ssrc); 
673         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
674         for (x=0;x<4;x++) {
675                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
676                         res = sendto(rtp->s, (void *)rtpheader, hdrlen + 4, 0, &rtp->them, sizeof(rtp->them));
677                         if (res <0) 
678                                 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));
679         #if 0
680                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
681         #endif          
682                 }
683                 if (x ==0) {
684                         /* Clear marker bit and increment seqno */
685                         rtpheader[0] = htonl((2 << 30)  | (101 << 16) | (rtp->seqno++));
686                         /* Make duration 240 */
687                         rtpheader[3] |= htonl((240));
688                         /* Set the End bit for the last 3 */
689                         rtpheader[3] |= htonl((1 << 23));
690                 }
691         }
692         return 0;
693 }
694
695 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
696 {
697         unsigned int *rtpheader;
698         int hdrlen = 12;
699         int res;
700         int ms;
701         int pred;
702
703         ms = calc_txstamp(rtp);
704         /* Default prediction */
705         pred = rtp->lastts + ms * 8;
706         
707         switch(f->subclass) {
708         case AST_FORMAT_ULAW:
709         case AST_FORMAT_ALAW:
710                 /* If we're within +/- 20ms from when where we
711                    predict we should be, use that */
712                 pred = rtp->lastts + f->datalen;
713                 break;
714         case AST_FORMAT_G729A:
715                 pred = rtp->lastts + f->datalen * 8;
716                 break;
717         case AST_FORMAT_GSM:
718                 pred = rtp->lastts + (f->datalen * 160 / 33);
719                 break;
720         case AST_FORMAT_ILBC:
721                 pred = rtp->lastts + (f->datalen * 240 / 50);
722                 break;
723         case AST_FORMAT_G723_1:
724                 pred = rtp->lastts + g723_samples(f->data, f->datalen);
725                 break;
726         case AST_FORMAT_SPEEX:
727                 pred = rtp->lastts + 160;
728                 // assumes that the RTP packet contains one Speex frame
729                 break;
730         default:
731                 ast_log(LOG_WARNING, "Not sure about timestamp format for codec format %d\n", f->subclass);
732         }
733
734         /* Re-calculate last TS */
735         rtp->lastts = rtp->lastts + ms * 8;
736         /* If it's close to ou prediction, go for it */
737         if (abs(rtp->lastts - pred) < 640)
738                 rtp->lastts = pred;
739         else
740                 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
741         /* Get a pointer to the header */
742         rtpheader = (unsigned int *)(f->data - hdrlen);
743         rtpheader[0] = htonl((2 << 30) | (codec << 16) | (rtp->seqno++));
744         rtpheader[1] = htonl(rtp->lastts);
745         rtpheader[2] = htonl(rtp->ssrc); 
746         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
747                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, &rtp->them, sizeof(rtp->them));
748                 if (res <0) 
749                         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));
750 #if 0
751                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
752 #endif          
753         }
754         return 0;
755 }
756
757 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
758 {
759         struct ast_frame *f;
760         int codec;
761         int hdrlen = 12;
762         
763
764         /* If we have no peer, return immediately */    
765         if (!rtp->them.sin_addr.s_addr)
766                 return 0;
767
768         /* If there is no data length, return immediately */
769         if (!_f->datalen) 
770                 return 0;
771         
772         /* Make sure we have enough space for RTP header */
773         if (_f->frametype != AST_FRAME_VOICE) {
774                 ast_log(LOG_WARNING, "RTP can only send voice\n");
775                 return -1;
776         }
777
778
779         codec = ast_rtp_lookup_code(rtp, 1, _f->subclass);
780         if (codec < 0) {
781                 ast_log(LOG_WARNING, "Don't know how to send format %d packets with RTP\n", _f->subclass);
782                 return -1;
783         }
784
785         if (rtp->lasttxformat !=  _f->subclass) {
786                 /* New format, reset the smoother */
787                 ast_log(LOG_DEBUG, "Ooh, format changed from %d to %d\n", rtp->lasttxformat, _f->subclass);
788                 rtp->lasttxformat = _f->subclass;
789                 if (rtp->smoother)
790                         ast_smoother_free(rtp->smoother);
791                 rtp->smoother = NULL;
792         }
793
794
795         switch(_f->subclass) {
796         case AST_FORMAT_ULAW:
797         case AST_FORMAT_ALAW:
798                 if (!rtp->smoother) {
799                         rtp->smoother = ast_smoother_new(160);
800                 }
801                 if (!rtp->smoother) {
802                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
803                         return -1;
804                 }
805                 ast_smoother_feed(rtp->smoother, _f);
806                 
807                 while((f = ast_smoother_read(rtp->smoother)))
808                         ast_rtp_raw_write(rtp, f, codec);
809                 break;
810         case AST_FORMAT_G729A:
811                 if (!rtp->smoother) {
812                         rtp->smoother = ast_smoother_new(20);
813                 }
814                 if (!rtp->smoother) {
815                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
816                         return -1;
817                 }
818                 ast_smoother_feed(rtp->smoother, _f);
819                 
820                 while((f = ast_smoother_read(rtp->smoother)))
821                         ast_rtp_raw_write(rtp, f, codec);
822                 break;
823         case AST_FORMAT_GSM:
824                 if (!rtp->smoother) {
825                         rtp->smoother = ast_smoother_new(33);
826                 }
827                 if (!rtp->smoother) {
828                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
829                         return -1;
830                 }
831                 ast_smoother_feed(rtp->smoother, _f);
832                 while((f = ast_smoother_read(rtp->smoother)))
833                         ast_rtp_raw_write(rtp, f, codec);
834                 break;
835         case AST_FORMAT_ILBC:
836                 if (!rtp->smoother) {
837                         rtp->smoother = ast_smoother_new(50);
838                 }
839                 if (!rtp->smoother) {
840                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
841                         return -1;
842                 }
843                 ast_smoother_feed(rtp->smoother, _f);
844                 while((f = ast_smoother_read(rtp->smoother)))
845                         ast_rtp_raw_write(rtp, f, codec);
846                 break;
847         default:        
848                 ast_log(LOG_WARNING, "Not sure about sending format %d packets\n", _f->subclass);
849                 // fall through to...
850         case AST_FORMAT_SPEEX:
851                 // Don't buffer outgoing frames; send them one-per-packet:
852                 if (_f->offset < hdrlen) {
853                         f = ast_frdup(_f);
854                 } else {
855                         f = _f;
856                 }
857                 ast_rtp_raw_write(rtp, f, codec);
858         }
859                 
860         return 0;
861 }
862
863 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
864 {
865         struct ast_rtp_protocol *cur, *prev;
866         cur = protos;
867         prev = NULL;
868         while(cur) {
869                 if (cur == proto) {
870                         if (prev)
871                                 prev->next = proto->next;
872                         else
873                                 protos = proto->next;
874                         return;
875                 }
876                 prev = cur;
877                 cur = cur->next;
878         }
879 }
880
881 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
882 {
883         struct ast_rtp_protocol *cur;
884         cur = protos;
885         while(cur) {
886                 if (cur->type == proto->type) {
887                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
888                         return -1;
889                 }
890                 cur = cur->next;
891         }
892         proto->next = protos;
893         protos = proto;
894         return 0;
895 }
896
897 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
898 {
899         struct ast_rtp_protocol *cur;
900         cur = protos;
901         while(cur) {
902                 if (cur->type == chan->type) {
903                         return cur;
904                 }
905                 cur = cur->next;
906         }
907         return NULL;
908 }
909
910 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
911 {
912         struct ast_frame *f;
913         struct ast_channel *who, *cs[3];
914         struct ast_rtp *p0, *p1;
915         struct ast_rtp_protocol *pr0, *pr1;
916         struct sockaddr_in ac0, ac1;
917         struct sockaddr_in t0, t1;
918         
919         void *pvt0, *pvt1;
920         int to;
921
922         /* XXX Wait a half a second for things to settle up 
923                         this really should be fixed XXX */
924         ast_autoservice_start(c0);
925         ast_autoservice_start(c1);
926         usleep(500000);
927         ast_autoservice_stop(c0);
928         ast_autoservice_stop(c1);
929
930         /* if need DTMF, cant native bridge */
931         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
932                 return -2;
933         ast_pthread_mutex_lock(&c0->lock);
934         ast_pthread_mutex_lock(&c1->lock);
935         pr0 = get_proto(c0);
936         pr1 = get_proto(c1);
937         if (!pr0) {
938                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
939                 ast_pthread_mutex_unlock(&c0->lock);
940                 ast_pthread_mutex_unlock(&c1->lock);
941                 return -1;
942         }
943         if (!pr1) {
944                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
945                 ast_pthread_mutex_unlock(&c0->lock);
946                 ast_pthread_mutex_unlock(&c1->lock);
947                 return -1;
948         }
949         pvt0 = c0->pvt->pvt;
950         pvt1 = c1->pvt->pvt;
951         p0 = pr0->get_rtp_info(c0);
952         p1 = pr1->get_rtp_info(c1);
953         if (!p0 || !p1) {
954                 /* Somebody doesn't want to play... */
955                 ast_pthread_mutex_unlock(&c0->lock);
956                 ast_pthread_mutex_unlock(&c1->lock);
957                 return -2;
958         }
959         if (pr0->set_rtp_peer(c0, p1)) 
960                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
961         else {
962                 /* Store RTP peer */
963                 ast_rtp_get_peer(p1, &ac1);
964         }
965         if (pr1->set_rtp_peer(c1, p0))
966                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
967         else {
968                 /* Store RTP peer */
969                 ast_rtp_get_peer(p0, &ac0);
970         }
971         ast_pthread_mutex_unlock(&c0->lock);
972         ast_pthread_mutex_unlock(&c1->lock);
973         cs[0] = c0;
974         cs[1] = c1;
975         cs[2] = NULL;
976         for (;;) {
977                 if ((c0->pvt->pvt != pvt0)  ||
978                         (c1->pvt->pvt != pvt1) ||
979                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
980                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
981                                 if (c0->pvt->pvt == pvt0) {
982                                         if (pr0->set_rtp_peer(c0, NULL)) 
983                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
984                                 }
985                                 if (c1->pvt->pvt == pvt1) {
986                                         if (pr1->set_rtp_peer(c1, NULL)) 
987                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
988                                 }
989                                 /* Tell it to try again later */
990                                 return -3;
991                 }
992                 to = -1;
993                 ast_rtp_get_peer(p1, &t1);
994                 ast_rtp_get_peer(p0, &t0);
995                 if (inaddrcmp(&t1, &ac1)) {
996                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c1->name);
997                         if (pr0->set_rtp_peer(c0, p1)) 
998                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
999                         memcpy(&ac1, &t1, sizeof(ac1));
1000                 }
1001                 if (inaddrcmp(&t0, &ac0)) {
1002                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c0->name);
1003                         if (pr1->set_rtp_peer(c1, p0))
1004                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1005                         memcpy(&ac0, &t0, sizeof(ac0));
1006                 }
1007                 who = ast_waitfor_n(cs, 2, &to);
1008                 if (!who) {
1009                         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1010                         continue;
1011                 }
1012                 f = ast_read(who);
1013                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1014                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
1015                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1016                         *fo = f;
1017                         *rc = who;
1018                         ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1019                         if ((c0->pvt->pvt == pvt0) && (!c0->_softhangup)) {
1020                                 if (pr0->set_rtp_peer(c0, NULL)) 
1021                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1022                         }
1023                         if ((c1->pvt->pvt == pvt1) && (!c1->_softhangup)) {
1024                                 if (pr1->set_rtp_peer(c1, NULL)) 
1025                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1026                         }
1027                         /* That's all we needed */
1028                         return 0;
1029                 } else {
1030                         if ((f->frametype == AST_FRAME_DTMF) || (f->frametype == AST_FRAME_VOICE)) {
1031                                 /* Forward voice or DTMF frames if they happen upon us */
1032                                 if (who == c0) {
1033                                         ast_write(c1, f);
1034                                 } else if (who == c1) {
1035                                         ast_write(c0, f);
1036                                 }
1037                         }
1038                         ast_frfree(f);
1039                 }
1040                 /* Swap priority not that it's a big deal at this point */
1041                 cs[2] = cs[0];
1042                 cs[0] = cs[1];
1043                 cs[1] = cs[2];
1044                 
1045         }
1046         return -1;
1047 }