Use 97 for ILBC type
[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 / 52);
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   return rtp->current_RTP_PT[pt];
491 }
492
493 int ast_rtp_lookup_code(struct ast_rtp* rtp, int isAstFormat, int code) {
494   int pt;
495
496   /* Looks up an RTP code out of our *static* outbound list */
497
498   if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
499       code == rtp->rtp_lookup_code_cache_code) {
500     // Use our cached mapping, to avoid the overhead of the loop below
501     return rtp->rtp_lookup_code_cache_result;
502   }
503
504   for (pt = 0; pt < MAX_RTP_PT; ++pt) {
505     if (static_RTP_PT[pt].code == code &&
506                 static_RTP_PT[pt].isAstFormat == isAstFormat) {
507       rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
508       rtp->rtp_lookup_code_cache_code = code;
509       rtp->rtp_lookup_code_cache_result = pt;
510       return pt;
511     }
512   }
513   return -1;
514 }
515
516 char* ast_rtp_lookup_mime_subtype(int isAstFormat, int code) {
517   int i;
518
519   for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
520     if (mimeTypes[i].payloadType.code == code &&
521         mimeTypes[i].payloadType.isAstFormat == isAstFormat) {
522       return mimeTypes[i].subtype;
523     }
524   }
525   return "";
526 }
527
528 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io)
529 {
530         struct ast_rtp *rtp;
531         int x;
532         int flags;
533         rtp = malloc(sizeof(struct ast_rtp));
534         if (!rtp)
535                 return NULL;
536         memset(rtp, 0, sizeof(struct ast_rtp));
537         rtp->them.sin_family = AF_INET;
538         rtp->us.sin_family = AF_INET;
539         rtp->s = socket(AF_INET, SOCK_DGRAM, 0);
540         rtp->ssrc = rand();
541         rtp->seqno = rand() & 0xffff;
542         if (rtp->s < 0) {
543                 free(rtp);
544                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
545                 return NULL;
546         }
547         flags = fcntl(rtp->s, F_GETFL);
548         fcntl(rtp->s, F_SETFL, flags | O_NONBLOCK);
549         for (;;) {
550                 /* Find us a place */
551                 x = (rand() % (65000-1025)) + 1025;
552                 /* Must be an even port number by RTP spec */
553                 x = x & ~1;
554                 rtp->us.sin_port = htons(x);
555                 if (!bind(rtp->s, &rtp->us, sizeof(rtp->us)))
556                         break;
557                 if (errno != EADDRINUSE) {
558                         ast_log(LOG_WARNING, "Unexpected bind error: %s\n", strerror(errno));
559                         close(rtp->s);
560                         free(rtp);
561                         return NULL;
562                 }
563         }
564         if (io && sched) {
565                 /* Operate this one in a callback mode */
566                 rtp->sched = sched;
567                 rtp->io = io;
568                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
569         }
570         ast_rtp_pt_default(rtp);
571         return rtp;
572 }
573
574 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
575 {
576         int res;
577         if ((res = setsockopt(rtp->s, SOL_IP, IP_TOS, &tos, sizeof(tos)))) 
578                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
579         return res;
580 }
581
582 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
583 {
584         rtp->them.sin_port = them->sin_port;
585         rtp->them.sin_addr = them->sin_addr;
586 }
587
588 void ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
589 {
590         them->sin_family = AF_INET;
591         them->sin_port = rtp->them.sin_port;
592         them->sin_addr = rtp->them.sin_addr;
593 }
594
595 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
596 {
597         memcpy(us, &rtp->us, sizeof(rtp->us));
598 }
599
600 void ast_rtp_stop(struct ast_rtp *rtp)
601 {
602         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
603         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
604 }
605
606 void ast_rtp_destroy(struct ast_rtp *rtp)
607 {
608         if (rtp->smoother)
609                 ast_smoother_free(rtp->smoother);
610         if (rtp->ioid)
611                 ast_io_remove(rtp->io, rtp->ioid);
612         if (rtp->s > -1)
613                 close(rtp->s);
614         free(rtp);
615 }
616
617 static unsigned int calc_txstamp(struct ast_rtp *rtp)
618 {
619         struct timeval now;
620         unsigned int ms;
621         if (!rtp->txcore.tv_sec && !rtp->txcore.tv_usec) {
622                 gettimeofday(&rtp->txcore, NULL);
623         }
624         gettimeofday(&now, NULL);
625         ms = (now.tv_sec - rtp->txcore.tv_sec) * 1000;
626         ms += (now.tv_usec - rtp->txcore.tv_usec) / 1000;
627         /* Use what we just got for next time */
628         rtp->txcore.tv_sec = now.tv_sec;
629         rtp->txcore.tv_usec = now.tv_usec;
630         return ms;
631 }
632
633 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
634 {
635         unsigned int *rtpheader;
636         int hdrlen = 12;
637         int res;
638         int ms;
639         int pred;
640         int x;
641         char data[256];
642
643         if ((digit <= '9') && (digit >= '0'))
644                 digit -= '0';
645         else if (digit == '*')
646                 digit = 10;
647         else if (digit == '#')
648                 digit = 11;
649         else if ((digit >= 'A') && (digit <= 'D')) 
650                 digit = digit - 'A' + 12;
651         else if ((digit >= 'a') && (digit <= 'd')) 
652                 digit = digit - 'a' + 12;
653         else {
654                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
655                 return -1;
656         }
657         
658
659         /* If we have no peer, return immediately */    
660         if (!rtp->them.sin_addr.s_addr)
661                 return 0;
662
663         ms = calc_txstamp(rtp);
664         /* Default prediction */
665         pred = rtp->lastts + ms * 8;
666         
667         /* Get a pointer to the header */
668         rtpheader = (unsigned int *)data;
669         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (101 << 16) | (rtp->seqno++));
670         rtpheader[1] = htonl(rtp->lastts);
671         rtpheader[2] = htonl(rtp->ssrc); 
672         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
673         for (x=0;x<4;x++) {
674                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
675                         res = sendto(rtp->s, (void *)rtpheader, hdrlen + 4, 0, &rtp->them, sizeof(rtp->them));
676                         if (res <0) 
677                                 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));
678         #if 0
679                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
680         #endif          
681                 }
682                 if (x ==0) {
683                         /* Clear marker bit and increment seqno */
684                         rtpheader[0] = htonl((2 << 30)  | (101 << 16) | (rtp->seqno++));
685                         /* Make duration 240 */
686                         rtpheader[3] |= htonl((240));
687                         /* Set the End bit for the last 3 */
688                         rtpheader[3] |= htonl((1 << 23));
689                 }
690         }
691         return 0;
692 }
693
694 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
695 {
696         unsigned int *rtpheader;
697         int hdrlen = 12;
698         int res;
699         int ms;
700         int pred;
701
702         ms = calc_txstamp(rtp);
703         /* Default prediction */
704         pred = rtp->lastts + ms * 8;
705         
706         switch(f->subclass) {
707         case AST_FORMAT_ULAW:
708         case AST_FORMAT_ALAW:
709                 /* If we're within +/- 20ms from when where we
710                    predict we should be, use that */
711                 pred = rtp->lastts + f->datalen;
712                 break;
713         case AST_FORMAT_G729A:
714                 pred = rtp->lastts + f->datalen * 8;
715                 break;
716         case AST_FORMAT_GSM:
717                 pred = rtp->lastts + (f->datalen * 160 / 33);
718                 break;
719         case AST_FORMAT_ILBC:
720                 pred = rtp->lastts + (f->datalen * 240 / 52);
721                 break;
722         case AST_FORMAT_G723_1:
723                 pred = rtp->lastts + g723_samples(f->data, f->datalen);
724                 break;
725         case AST_FORMAT_SPEEX:
726                 pred = rtp->lastts + 160;
727                 // assumes that the RTP packet contains one Speex frame
728                 break;
729         default:
730                 ast_log(LOG_WARNING, "Not sure about timestamp format for codec format %d\n", f->subclass);
731         }
732
733         /* Re-calculate last TS */
734         rtp->lastts = rtp->lastts + ms * 8;
735         /* If it's close to ou prediction, go for it */
736         if (abs(rtp->lastts - pred) < 640)
737                 rtp->lastts = pred;
738         else
739                 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
740         /* Get a pointer to the header */
741         rtpheader = (unsigned int *)(f->data - hdrlen);
742         rtpheader[0] = htonl((2 << 30) | (codec << 16) | (rtp->seqno++));
743         rtpheader[1] = htonl(rtp->lastts);
744         rtpheader[2] = htonl(rtp->ssrc); 
745         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
746                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, &rtp->them, sizeof(rtp->them));
747                 if (res <0) 
748                         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));
749 #if 0
750                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
751 #endif          
752         }
753         return 0;
754 }
755
756 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
757 {
758         struct ast_frame *f;
759         int codec;
760         int hdrlen = 12;
761         
762
763         /* If we have no peer, return immediately */    
764         if (!rtp->them.sin_addr.s_addr)
765                 return 0;
766
767         /* If there is no data length, return immediately */
768         if (!_f->datalen) 
769                 return 0;
770         
771         /* Make sure we have enough space for RTP header */
772         if (_f->frametype != AST_FRAME_VOICE) {
773                 ast_log(LOG_WARNING, "RTP can only send voice\n");
774                 return -1;
775         }
776
777
778         codec = ast_rtp_lookup_code(rtp, 1, _f->subclass);
779         if (codec < 0) {
780                 ast_log(LOG_WARNING, "Don't know how to send format %d packets with RTP\n", _f->subclass);
781                 return -1;
782         }
783
784         if (rtp->lasttxformat !=  _f->subclass) {
785                 /* New format, reset the smoother */
786                 ast_log(LOG_DEBUG, "Ooh, format changed from %d to %d\n", rtp->lasttxformat, _f->subclass);
787                 rtp->lasttxformat = _f->subclass;
788                 if (rtp->smoother)
789                         ast_smoother_free(rtp->smoother);
790                 rtp->smoother = NULL;
791         }
792
793
794         switch(_f->subclass) {
795         case AST_FORMAT_ULAW:
796         case AST_FORMAT_ALAW:
797                 if (!rtp->smoother) {
798                         rtp->smoother = ast_smoother_new(160);
799                 }
800                 if (!rtp->smoother) {
801                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
802                         return -1;
803                 }
804                 ast_smoother_feed(rtp->smoother, _f);
805                 
806                 while((f = ast_smoother_read(rtp->smoother)))
807                         ast_rtp_raw_write(rtp, f, codec);
808                 break;
809         case AST_FORMAT_G729A:
810                 if (!rtp->smoother) {
811                         rtp->smoother = ast_smoother_new(20);
812                 }
813                 if (!rtp->smoother) {
814                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
815                         return -1;
816                 }
817                 ast_smoother_feed(rtp->smoother, _f);
818                 
819                 while((f = ast_smoother_read(rtp->smoother)))
820                         ast_rtp_raw_write(rtp, f, codec);
821                 break;
822         case AST_FORMAT_GSM:
823                 if (!rtp->smoother) {
824                         rtp->smoother = ast_smoother_new(33);
825                 }
826                 if (!rtp->smoother) {
827                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
828                         return -1;
829                 }
830                 ast_smoother_feed(rtp->smoother, _f);
831                 while((f = ast_smoother_read(rtp->smoother)))
832                         ast_rtp_raw_write(rtp, f, codec);
833                 break;
834         case AST_FORMAT_ILBC:
835                 if (!rtp->smoother) {
836                         rtp->smoother = ast_smoother_new(52);
837                 }
838                 if (!rtp->smoother) {
839                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
840                         return -1;
841                 }
842                 ast_smoother_feed(rtp->smoother, _f);
843                 while((f = ast_smoother_read(rtp->smoother)))
844                         ast_rtp_raw_write(rtp, f, codec);
845                 break;
846         default:        
847                 ast_log(LOG_WARNING, "Not sure about sending format %d packets\n", _f->subclass);
848                 // fall through to...
849         case AST_FORMAT_SPEEX:
850                 // Don't buffer outgoing frames; send them one-per-packet:
851                 if (_f->offset < hdrlen) {
852                         f = ast_frdup(_f);
853                 } else {
854                         f = _f;
855                 }
856                 ast_rtp_raw_write(rtp, f, codec);
857         }
858                 
859         return 0;
860 }
861
862 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
863 {
864         struct ast_rtp_protocol *cur, *prev;
865         cur = protos;
866         prev = NULL;
867         while(cur) {
868                 if (cur == proto) {
869                         if (prev)
870                                 prev->next = proto->next;
871                         else
872                                 protos = proto->next;
873                         return;
874                 }
875                 prev = cur;
876                 cur = cur->next;
877         }
878 }
879
880 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
881 {
882         struct ast_rtp_protocol *cur;
883         cur = protos;
884         while(cur) {
885                 if (cur->type == proto->type) {
886                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
887                         return -1;
888                 }
889                 cur = cur->next;
890         }
891         proto->next = protos;
892         protos = proto;
893         return 0;
894 }
895
896 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
897 {
898         struct ast_rtp_protocol *cur;
899         cur = protos;
900         while(cur) {
901                 if (cur->type == chan->type) {
902                         return cur;
903                 }
904                 cur = cur->next;
905         }
906         return NULL;
907 }
908
909 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
910 {
911         struct ast_frame *f;
912         struct ast_channel *who, *cs[3];
913         struct ast_rtp *p0, *p1;
914         struct ast_rtp_protocol *pr0, *pr1;
915         struct sockaddr_in ac0, ac1;
916         struct sockaddr_in t0, t1;
917         
918         void *pvt0, *pvt1;
919         int to;
920
921         /* XXX Wait a half a second for things to settle up 
922                         this really should be fixed XXX */
923         ast_autoservice_start(c0);
924         ast_autoservice_start(c1);
925         usleep(500000);
926         ast_autoservice_stop(c0);
927         ast_autoservice_stop(c1);
928
929         /* if need DTMF, cant native bridge */
930         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
931                 return -2;
932         ast_pthread_mutex_lock(&c0->lock);
933         ast_pthread_mutex_lock(&c1->lock);
934         pr0 = get_proto(c0);
935         pr1 = get_proto(c1);
936         if (!pr0) {
937                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
938                 ast_pthread_mutex_unlock(&c0->lock);
939                 ast_pthread_mutex_unlock(&c1->lock);
940                 return -1;
941         }
942         if (!pr1) {
943                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
944                 ast_pthread_mutex_unlock(&c0->lock);
945                 ast_pthread_mutex_unlock(&c1->lock);
946                 return -1;
947         }
948         pvt0 = c0->pvt->pvt;
949         pvt1 = c1->pvt->pvt;
950         p0 = pr0->get_rtp_info(c0);
951         p1 = pr1->get_rtp_info(c1);
952         if (!p0 || !p1) {
953                 /* Somebody doesn't want to play... */
954                 ast_pthread_mutex_unlock(&c0->lock);
955                 ast_pthread_mutex_unlock(&c1->lock);
956                 return -2;
957         }
958         if (pr0->set_rtp_peer(c0, p1)) 
959                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
960         else {
961                 /* Store RTP peer */
962                 ast_rtp_get_peer(p1, &ac1);
963         }
964         if (pr1->set_rtp_peer(c1, p0))
965                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
966         else {
967                 /* Store RTP peer */
968                 ast_rtp_get_peer(p0, &ac0);
969         }
970         ast_pthread_mutex_unlock(&c0->lock);
971         ast_pthread_mutex_unlock(&c1->lock);
972         cs[0] = c0;
973         cs[1] = c1;
974         cs[2] = NULL;
975         for (;;) {
976                 if ((c0->pvt->pvt != pvt0)  ||
977                         (c1->pvt->pvt != pvt1) ||
978                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
979                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
980                                 if (c0->pvt->pvt == pvt0) {
981                                         if (pr0->set_rtp_peer(c0, NULL)) 
982                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
983                                 }
984                                 if (c1->pvt->pvt == pvt1) {
985                                         if (pr1->set_rtp_peer(c1, NULL)) 
986                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
987                                 }
988                                 /* Tell it to try again later */
989                                 return -3;
990                 }
991                 to = -1;
992                 ast_rtp_get_peer(p1, &t1);
993                 ast_rtp_get_peer(p0, &t0);
994                 if (inaddrcmp(&t1, &ac1)) {
995                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c1->name);
996                         if (pr0->set_rtp_peer(c0, p1)) 
997                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
998                         memcpy(&ac1, &t1, sizeof(ac1));
999                 }
1000                 if (inaddrcmp(&t0, &ac0)) {
1001                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c0->name);
1002                         if (pr1->set_rtp_peer(c1, p0))
1003                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1004                         memcpy(&ac0, &t0, sizeof(ac0));
1005                 }
1006                 who = ast_waitfor_n(cs, 2, &to);
1007                 if (!who) {
1008                         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1009                         continue;
1010                 }
1011                 f = ast_read(who);
1012                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1013                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
1014                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1015                         *fo = f;
1016                         *rc = who;
1017                         ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1018                         if ((c0->pvt->pvt == pvt0) && (!c0->_softhangup)) {
1019                                 if (pr0->set_rtp_peer(c0, NULL)) 
1020                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1021                         }
1022                         if ((c1->pvt->pvt == pvt1) && (!c1->_softhangup)) {
1023                                 if (pr1->set_rtp_peer(c1, NULL)) 
1024                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1025                         }
1026                         /* That's all we needed */
1027                         return 0;
1028                 } else {
1029                         if ((f->frametype == AST_FRAME_DTMF) || (f->frametype == AST_FRAME_VOICE)) {
1030                                 /* Forward voice or DTMF frames if they happen upon us */
1031                                 if (who == c0) {
1032                                         ast_write(c1, f);
1033                                 } else if (who == c1) {
1034                                         ast_write(c0, f);
1035                                 }
1036                         }
1037                         ast_frfree(f);
1038                 }
1039                 /* Swap priority not that it's a big deal at this point */
1040                 cs[2] = cs[0];
1041                 cs[0] = cs[1];
1042                 cs[1] = cs[2];
1043                 
1044         }
1045         return -1;
1046 }