b806995af7bc49b8d66bc394c6c2fb349b964c6e
[asterisk/asterisk.git] / frame.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Frame manipulation routines
22  *
23  * \author Mark Spencer <markster@digium.com> 
24  */
25
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <stdio.h>
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
35
36 #include "asterisk/lock.h"
37 #include "asterisk/frame.h"
38 #include "asterisk/logger.h"
39 #include "asterisk/options.h"
40 #include "asterisk/channel.h"
41 #include "asterisk/cli.h"
42 #include "asterisk/term.h"
43 #include "asterisk/utils.h"
44
45 #ifdef TRACE_FRAMES
46 static int headers = 0;
47 static struct ast_frame *headerlist = NULL;
48 AST_MUTEX_DEFINE_STATIC(framelock);
49 #endif
50
51 #define SMOOTHER_SIZE 8000
52
53 enum frame_type {
54         TYPE_HIGH,     /* 0x0 */
55         TYPE_LOW,      /* 0x1 */
56         TYPE_SILENCE,  /* 0x2 */
57         TYPE_DONTSEND  /* 0x3 */
58 };
59
60 #define TYPE_MASK 0x3
61
62 struct ast_smoother {
63         int size;
64         int format;
65         int readdata;
66         int optimizablestream;
67         int flags;
68         float samplesperbyte;
69         struct ast_frame f;
70         struct timeval delivery;
71         char data[SMOOTHER_SIZE];
72         char framedata[SMOOTHER_SIZE + AST_FRIENDLY_OFFSET];
73         struct ast_frame *opt;
74         int len;
75 };
76
77 /*! \brief Definition of supported media formats (codecs) */
78 static struct ast_format_list {
79         int visible;    /*!< Can we see this entry */
80         int bits;       /*!< bitmask value */
81         char *name;     /*!< short name */
82         char *desc;     /*!< Description */
83 } AST_FORMAT_LIST[] = {
84         { 1, AST_FORMAT_G723_1 , "g723" , "G.723.1"},   /*!< codec_g723_1.c */
85         { 1, AST_FORMAT_GSM, "gsm" , "GSM"},            /*!< codec_gsm.c */
86         { 1, AST_FORMAT_ULAW, "ulaw", "G.711 u-law" },  /*!< codec_ulaw.c */
87         { 1, AST_FORMAT_ALAW, "alaw", "G.711 A-law" },  /*!< codec_alaw.c */
88         { 1, AST_FORMAT_G726, "g726", "G.726" },        /*!< codec_g726.c */
89         { 1, AST_FORMAT_ADPCM, "adpcm" , "ADPCM"},      /*!< codec_adpcm.c */
90         { 1, AST_FORMAT_SLINEAR, "slin",  "16 bit Signed Linear PCM"},  /*!<  */
91         { 1, AST_FORMAT_LPC10, "lpc10", "LPC10" },      /*!< codec_lpc10.c */
92         { 1, AST_FORMAT_G729A, "g729", "G.729A" },      /*!< Binary commercial distribution */
93         { 1, AST_FORMAT_SPEEX, "speex", "SpeeX" },      /*!< codec_speex.c */
94         { 1, AST_FORMAT_ILBC, "ilbc", "iLBC"},  /*!< codec_ilbc.c */
95         { 0, 0, "nothing", "undefined" },
96         { 0, 0, "nothing", "undefined" },
97         { 0, 0, "nothing", "undefined" },
98         { 0, 0, "nothing", "undefined" },
99         { 0, AST_FORMAT_MAX_AUDIO, "maxaudio", "Maximum audio format" },
100         { 1, AST_FORMAT_JPEG, "jpeg", "JPEG image"},    /*!< See format_jpeg.c */
101         { 1, AST_FORMAT_PNG, "png", "PNG image"},       /*!< Image format */
102         { 1, AST_FORMAT_H261, "h261", "H.261 Video" },  /*!< Passthrough */
103         { 1, AST_FORMAT_H263, "h263", "H.263 Video" },  /*!< Passthrough support, see format_h263.c */
104         { 1, AST_FORMAT_H263_PLUS, "h263p", "H.263+ Video" },   /*!< See format_h263.c */
105         { 1, AST_FORMAT_H264, "h264", "H.264 Video" },  /*!< Passthrough support, see format_h263.c */
106         { 0, 0, "nothing", "undefined" },
107         { 0, 0, "nothing", "undefined" },
108         { 0, 0, "nothing", "undefined" },
109         { 0, AST_FORMAT_MAX_VIDEO, "maxvideo", "Maximum video format" },
110 };
111
112 struct ast_frame ast_null_frame = { AST_FRAME_NULL, };
113
114 void ast_smoother_reset(struct ast_smoother *s, int size)
115 {
116         memset(s, 0, sizeof(*s));
117         s->size = size;
118 }
119
120 struct ast_smoother *ast_smoother_new(int size)
121 {
122         struct ast_smoother *s;
123         if (size < 1)
124                 return NULL;
125         if ((s = ast_malloc(sizeof(*s))))
126                 ast_smoother_reset(s, size);
127         return s;
128 }
129
130 int ast_smoother_get_flags(struct ast_smoother *s)
131 {
132         return s->flags;
133 }
134
135 void ast_smoother_set_flags(struct ast_smoother *s, int flags)
136 {
137         s->flags = flags;
138 }
139
140 int __ast_smoother_feed(struct ast_smoother *s, struct ast_frame *f, int swap)
141 {
142         if (f->frametype != AST_FRAME_VOICE) {
143                 ast_log(LOG_WARNING, "Huh?  Can't smooth a non-voice frame!\n");
144                 return -1;
145         }
146         if (!s->format) {
147                 s->format = f->subclass;
148                 s->samplesperbyte = (float)f->samples / (float)f->datalen;
149         } else if (s->format != f->subclass) {
150                 ast_log(LOG_WARNING, "Smoother was working on %d format frames, now trying to feed %d?\n", s->format, f->subclass);
151                 return -1;
152         }
153         if (s->len + f->datalen > SMOOTHER_SIZE) {
154                 ast_log(LOG_WARNING, "Out of smoother space\n");
155                 return -1;
156         }
157         if (((f->datalen == s->size) || ((f->datalen < 10) && (s->flags & AST_SMOOTHER_FLAG_G729)))
158                                  && !s->opt && (f->offset >= AST_MIN_OFFSET)) {
159                 if (!s->len) {
160                         /* Optimize by sending the frame we just got
161                            on the next read, thus eliminating the douple
162                            copy */
163                         s->opt = f;
164                         return 0;
165                 } else {
166                         s->optimizablestream++;
167                         if (s->optimizablestream > 10) {
168                                 /* For the past 10 rounds, we have input and output
169                                    frames of the correct size for this smoother, yet
170                                    we were unable to optimize because there was still
171                                    some cruft left over.  Lets just drop the cruft so
172                                    we can move to a fully optimized path */
173                                 s->len = 0;
174                                 s->opt = f;
175                                 return 0;
176                         }
177                 }
178         } else 
179                 s->optimizablestream = 0;
180         if (s->flags & AST_SMOOTHER_FLAG_G729) {
181                 if (s->len % 10) {
182                         ast_log(LOG_NOTICE, "Dropping extra frame of G.729 since we already have a VAD frame at the end\n");
183                         return 0;
184                 }
185         }
186         if (swap)
187                 ast_swapcopy_samples(s->data+s->len, f->data, f->samples);
188         else
189                 memcpy(s->data + s->len, f->data, f->datalen);
190         /* If either side is empty, reset the delivery time */
191         if (!s->len || ast_tvzero(f->delivery) || ast_tvzero(s->delivery))      /* XXX really ? */
192                 s->delivery = f->delivery;
193         s->len += f->datalen;
194         return 0;
195 }
196
197 struct ast_frame *ast_smoother_read(struct ast_smoother *s)
198 {
199         struct ast_frame *opt;
200         int len;
201         /* IF we have an optimization frame, send it */
202         if (s->opt) {
203                 if (s->opt->offset < AST_FRIENDLY_OFFSET)
204                         ast_log(LOG_WARNING, "Returning a frame of inappropriate offset (%d).",
205                                                         s->opt->offset);
206                 opt = s->opt;
207                 s->opt = NULL;
208                 return opt;
209         }
210
211         /* Make sure we have enough data */
212         if (s->len < s->size) {
213                 /* Or, if this is a G.729 frame with VAD on it, send it immediately anyway */
214                 if (!((s->flags & AST_SMOOTHER_FLAG_G729) && (s->size % 10)))
215                         return NULL;
216         }
217         len = s->size;
218         if (len > s->len)
219                 len = s->len;
220         /* Make frame */
221         s->f.frametype = AST_FRAME_VOICE;
222         s->f.subclass = s->format;
223         s->f.data = s->framedata + AST_FRIENDLY_OFFSET;
224         s->f.offset = AST_FRIENDLY_OFFSET;
225         s->f.datalen = len;
226         /* Samples will be improper given VAD, but with VAD the concept really doesn't even exist */
227         s->f.samples = len * s->samplesperbyte; /* XXX rounding */
228         s->f.delivery = s->delivery;
229         /* Fill Data */
230         memcpy(s->f.data, s->data, len);
231         s->len -= len;
232         /* Move remaining data to the front if applicable */
233         if (s->len) {
234                 /* In principle this should all be fine because if we are sending
235                    G.729 VAD, the next timestamp will take over anyawy */
236                 memmove(s->data, s->data + len, s->len);
237                 if (!ast_tvzero(s->delivery)) {
238                         /* If we have delivery time, increment it, otherwise, leave it at 0 */
239                         s->delivery = ast_tvadd(s->delivery, ast_samp2tv(s->f.samples, 8000));
240                 }
241         }
242         /* Return frame */
243         return &s->f;
244 }
245
246 void ast_smoother_free(struct ast_smoother *s)
247 {
248         free(s);
249 }
250
251 static struct ast_frame *ast_frame_header_new(void)
252 {
253         struct ast_frame *f = ast_calloc(1, sizeof(*f));
254 #ifdef TRACE_FRAMES
255         if (f) {
256                 headers++;
257                 f->prev = NULL;
258                 ast_mutex_lock(&framelock);
259                 f->next = headerlist;
260                 if (headerlist)
261                         headerlist->prev = f;
262                 headerlist = f;
263                 ast_mutex_unlock(&framelock);
264         }
265 #endif  
266         return f;
267 }
268
269 /*!
270  * \todo Important: I should be made more efficient.  Frame headers should
271  * most definitely be cached
272  */
273 void ast_frfree(struct ast_frame *fr)
274 {
275         if (fr->mallocd & AST_MALLOCD_DATA) {
276                 if (fr->data) 
277                         free(fr->data - fr->offset);
278         }
279         if (fr->mallocd & AST_MALLOCD_SRC) {
280                 if (fr->src)
281                         free((char *)fr->src);
282         }
283         if (fr->mallocd & AST_MALLOCD_HDR) {
284 #ifdef TRACE_FRAMES
285                 headers--;
286                 ast_mutex_lock(&framelock);
287                 if (fr->next)
288                         fr->next->prev = fr->prev;
289                 if (fr->prev)
290                         fr->prev->next = fr->next;
291                 else
292                         headerlist = fr->next;
293                 ast_mutex_unlock(&framelock);
294 #endif                  
295                 free(fr);
296         }
297 }
298
299 /*!
300  * \brief 'isolates' a frame by duplicating non-malloc'ed components
301  * (header, src, data).
302  * On return all components are malloc'ed
303  */
304 struct ast_frame *ast_frisolate(struct ast_frame *fr)
305 {
306         struct ast_frame *out;
307         void *newdata;
308         
309         if (!(fr->mallocd & AST_MALLOCD_HDR)) {
310                 /* Allocate a new header if needed */
311                 if (!(out = ast_frame_header_new()))
312                         return NULL;
313                 out->frametype = fr->frametype;
314                 out->subclass = fr->subclass;
315                 out->datalen = fr->datalen;
316                 out->samples = fr->samples;
317                 out->offset = fr->offset;
318                 out->data = fr->data;
319                 /* Copy the timing data */
320                 out->has_timing_info = fr->has_timing_info;
321                 if (fr->has_timing_info) {
322                         out->ts = fr->ts;
323                         out->len = fr->len;
324                         out->seqno = fr->seqno;
325                 }
326         } else
327                 out = fr;
328         
329         if (!(fr->mallocd & AST_MALLOCD_SRC)) {
330                 if (fr->src)
331                         out->src = strdup(fr->src);
332         } else
333                 out->src = fr->src;
334         
335         if (!(fr->mallocd & AST_MALLOCD_DATA))  {
336                 if (!(newdata = ast_malloc(fr->datalen + AST_FRIENDLY_OFFSET))) {
337                         free(out);
338                         return NULL;
339                 }
340                 newdata += AST_FRIENDLY_OFFSET;
341                 out->offset = AST_FRIENDLY_OFFSET;
342                 out->datalen = fr->datalen;
343                 memcpy(newdata, fr->data, fr->datalen);
344                 out->data = newdata;
345         }
346
347         out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA;
348         
349         return out;
350 }
351
352 struct ast_frame *ast_frdup(struct ast_frame *f)
353 {
354         struct ast_frame *out;
355         int len, srclen = 0;
356         void *buf;
357         /* Start with standard stuff */
358         len = sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
359         /* If we have a source, add space for it */
360         /*
361          * XXX Watch out here - if we receive a src which is not terminated
362          * properly, we can be easily attacked. Should limit the size we deal with.
363          */
364         if (f->src)
365                 srclen = strlen(f->src);
366         if (srclen > 0)
367                 len += srclen + 1;
368         if (!(buf = ast_malloc(len)))
369                 return NULL;
370         out = buf;
371         /* Set us as having malloc'd header only, so it will eventually
372            get freed. */
373         out->frametype = f->frametype;
374         out->subclass = f->subclass;
375         out->datalen = f->datalen;
376         out->samples = f->samples;
377         out->delivery = f->delivery;
378         out->mallocd = AST_MALLOCD_HDR;
379         out->offset = AST_FRIENDLY_OFFSET;
380         out->data = buf + sizeof(*out) + AST_FRIENDLY_OFFSET;
381         if (srclen > 0) {
382                 out->src = out->data + f->datalen;
383                 /* Must have space since we allocated for it */
384                 strcpy((char *)out->src, f->src);
385         } else
386                 out->src = NULL;
387         out->prev = NULL;
388         out->next = NULL;
389         memcpy(out->data, f->data, out->datalen);       
390         out->has_timing_info = f->has_timing_info;
391         if (f->has_timing_info) {
392                 out->ts = f->ts;
393                 out->len = f->len;
394                 out->seqno = f->seqno;
395         }
396         return out;
397 }
398
399 #if 0
400 /*
401  * XXX
402  * This function is badly broken - it does not handle correctly
403  * partial reads on either header or body.
404  * However is it never used anywhere so we leave it commented out
405  */
406 struct ast_frame *ast_fr_fdread(int fd)
407 {
408         char buf[65536];
409         int res;        
410         struct ast_frame *f = (struct ast_frame *)buf;
411         int ttl = sizeof(*f);
412         /* Read a frame directly from there.  They're always in the
413            right format. */
414         
415         while(ttl) {
416                 res = read(fd, buf, ttl);
417                 if (res < 0) {
418                         ast_log(LOG_WARNING, "Bad read on %d: %s\n", fd, strerror(errno));
419                         return NULL;
420                 }
421                 ttl -= res;
422         }
423         
424         /* read the frame header */
425
426         /* Re-write data position */
427         f->data = buf + sizeof(*f);
428         f->offset = 0;
429         /* Forget about being mallocd */
430         f->mallocd = 0;
431         /* Re-write the source */
432         f->src = (char *)__FUNCTION__;
433         if (f->datalen > sizeof(buf) - sizeof(*f)) {
434                 /* Really bad read */
435                 ast_log(LOG_WARNING, "Strange read (%d bytes)\n", f->datalen);
436                 return NULL;
437         }
438         if (f->datalen) {
439                 if ((res = read(fd, f->data, f->datalen)) != f->datalen) {
440                         /* Bad read */
441                         ast_log(LOG_WARNING, "How very strange, expected %d, got %d\n", f->datalen, res);
442                         return NULL;
443                 }
444         }
445         if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
446                 return NULL;
447         }
448         return ast_frisolate(f);
449 }
450
451 /* Some convenient routines for sending frames to/from stream or datagram
452    sockets, pipes, etc (maybe even files) */
453
454 /*
455  * XXX this function is also partly broken because it does not handle
456  * partial writes. We comment it out too, and also the unique
457  * client it has, ast_fr_fdhangup()
458  */
459 int ast_fr_fdwrite(int fd, struct ast_frame *frame)
460 {
461         /* Write the frame exactly */
462         if (write(fd, frame, sizeof(*frame)) != sizeof(*frame)) {
463                 ast_log(LOG_WARNING, "Write error: %s\n", strerror(errno));
464                 return -1;
465         }
466         if (write(fd, frame->data, frame->datalen) != frame->datalen) {
467                 ast_log(LOG_WARNING, "Write error: %s\n", strerror(errno));
468                 return -1;
469         }
470         return 0;
471 }
472
473 int ast_fr_fdhangup(int fd)
474 {
475         struct ast_frame hangup = {
476                 AST_FRAME_CONTROL,
477                 AST_CONTROL_HANGUP
478         };
479         return ast_fr_fdwrite(fd, &hangup);
480 }
481
482 #endif /* unused functions */
483 void ast_swapcopy_samples(void *dst, const void *src, int samples)
484 {
485         int i;
486         unsigned short *dst_s = dst;
487         const unsigned short *src_s = src;
488
489         for (i=0; i<samples; i++)
490                 dst_s[i] = (src_s[i]<<8) | (src_s[i]>>8);
491 }
492
493
494 struct ast_format_list *ast_get_format_list_index(int index) 
495 {
496         return &AST_FORMAT_LIST[index];
497 }
498
499 struct ast_format_list *ast_get_format_list(size_t *size) 
500 {
501         *size = (sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]));
502         return AST_FORMAT_LIST;
503 }
504
505 char* ast_getformatname(int format)
506 {
507         int x;
508         char *ret = "unknown";
509         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
510                 if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == format) {
511                         ret = AST_FORMAT_LIST[x].name;
512                         break;
513                 }
514         }
515         return ret;
516 }
517
518 char *ast_getformatname_multiple(char *buf, size_t size, int format) {
519
520         int x;
521         unsigned len;
522         char *start, *end = buf;
523         if (!size) return buf;
524         snprintf(end, size, "0x%x (", format);
525         len = strlen(end);
526         end += len;
527         size -= len;
528         start = end;
529         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
530                 if (AST_FORMAT_LIST[x].visible && (AST_FORMAT_LIST[x].bits & format)) {
531                         snprintf(end, size,"%s|",AST_FORMAT_LIST[x].name);
532                         len = strlen(end);
533                         end += len;
534                         size -= len;
535                 }
536         }
537         if (start == end)
538                 snprintf(start, size, "nothing)");
539         else if (size > 1)
540                 *(end -1) = ')';
541         return buf;
542 }
543
544 static struct ast_codec_alias_table {
545         char *alias;
546         char *realname;
547
548 } ast_codec_alias_table[] = {
549         {"slinear","slin"},
550         {"g723.1","g723"},
551 };
552
553 static const char *ast_expand_codec_alias(const char *in) {
554         int x;
555
556         for (x = 0; x < sizeof(ast_codec_alias_table) / sizeof(ast_codec_alias_table[0]); x++) {
557                 if(!strcmp(in,ast_codec_alias_table[x].alias))
558                         return ast_codec_alias_table[x].realname;
559         }
560         return in;
561 }
562
563 int ast_getformatbyname(const char *name)
564 {
565         int x, all, format = 0;
566
567         all = strcasecmp(name, "all") ? 0 : 1;
568         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
569                 if(AST_FORMAT_LIST[x].visible && (all || 
570                                                                                   !strcasecmp(AST_FORMAT_LIST[x].name,name) ||
571                                                                                   !strcasecmp(AST_FORMAT_LIST[x].name,ast_expand_codec_alias(name)))) {
572                         format |= AST_FORMAT_LIST[x].bits;
573                         if(!all)
574                                 break;
575                 }
576         }
577
578         return format;
579 }
580
581 char *ast_codec2str(int codec) {
582         int x;
583         char *ret = "unknown";
584         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
585                 if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == codec) {
586                         ret = AST_FORMAT_LIST[x].desc;
587                         break;
588                 }
589         }
590         return ret;
591 }
592
593 static int show_codecs(int fd, int argc, char *argv[])
594 {
595         int i, found=0;
596         char hex[25];
597         
598         if ((argc < 2) || (argc > 3))
599                 return RESULT_SHOWUSAGE;
600
601         if (!ast_opt_dont_warn)
602                 ast_cli(fd, "Disclaimer: this command is for informational purposes only.\n"
603                                 "\tIt does not indicate anything about your configuration.\n");
604
605         ast_cli(fd, "%11s %9s %10s   TYPE   %5s   %s\n","INT","BINARY","HEX","NAME","DESC");
606         ast_cli(fd, "--------------------------------------------------------------------------------\n");
607         if ((argc == 2) || (!strcasecmp(argv[1],"audio"))) {
608                 found = 1;
609                 for (i=0;i<11;i++) {
610                         snprintf(hex,25,"(0x%x)",1<<i);
611                         ast_cli(fd, "%11u (1 << %2d) %10s  audio   %5s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
612                 }
613         }
614
615         if ((argc == 2) || (!strcasecmp(argv[1],"image"))) {
616                 found = 1;
617                 for (i=16;i<18;i++) {
618                         snprintf(hex,25,"(0x%x)",1<<i);
619                         ast_cli(fd, "%11u (1 << %2d) %10s  image   %5s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
620                 }
621         }
622
623         if ((argc == 2) || (!strcasecmp(argv[1],"video"))) {
624                 found = 1;
625                 for (i=18;i<21;i++) {
626                         snprintf(hex,25,"(0x%x)",1<<i);
627                         ast_cli(fd, "%11u (1 << %2d) %10s  video   %5s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
628                 }
629         }
630
631         if (! found)
632                 return RESULT_SHOWUSAGE;
633         else
634                 return RESULT_SUCCESS;
635 }
636
637 static char frame_show_codecs_usage[] =
638 "Usage: show [audio|video|image] codecs\n"
639 "       Displays codec mapping\n";
640
641 static int show_codec_n(int fd, int argc, char *argv[])
642 {
643         int codec, i, found=0;
644
645         if (argc != 3)
646                 return RESULT_SHOWUSAGE;
647
648         if (sscanf(argv[2],"%d",&codec) != 1)
649                 return RESULT_SHOWUSAGE;
650
651         for (i=0;i<32;i++)
652                 if (codec & (1 << i)) {
653                         found = 1;
654                         ast_cli(fd, "%11u (1 << %2d)  %s\n",1 << i,i,ast_codec2str(1<<i));
655                 }
656
657         if (! found)
658                 ast_cli(fd, "Codec %d not found\n", codec);
659
660         return RESULT_SUCCESS;
661 }
662
663 static char frame_show_codec_n_usage[] =
664 "Usage: show codec <number>\n"
665 "       Displays codec mapping\n";
666
667 /*! Dump a frame for debugging purposes */
668 void ast_frame_dump(const char *name, struct ast_frame *f, char *prefix)
669 {
670         const char noname[] = "unknown";
671         char ftype[40] = "Unknown Frametype";
672         char cft[80];
673         char subclass[40] = "Unknown Subclass";
674         char csub[80];
675         char moreinfo[40] = "";
676         char cn[60];
677         char cp[40];
678         char cmn[40];
679
680         if (!name)
681                 name = noname;
682
683
684         if (!f) {
685                 ast_verbose("%s [ %s (NULL) ] [%s]\n", 
686                         term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
687                         term_color(cft, "HANGUP", COLOR_BRRED, COLOR_BLACK, sizeof(cft)), 
688                         term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
689                 return;
690         }
691         /* XXX We should probably print one each of voice and video when the format changes XXX */
692         if (f->frametype == AST_FRAME_VOICE)
693                 return;
694         if (f->frametype == AST_FRAME_VIDEO)
695                 return;
696         switch(f->frametype) {
697         case AST_FRAME_DTMF:
698                 strcpy(ftype, "DTMF");
699                 subclass[0] = f->subclass;
700                 subclass[1] = '\0';
701                 break;
702         case AST_FRAME_CONTROL:
703                 strcpy(ftype, "Control");
704                 switch(f->subclass) {
705                 case AST_CONTROL_HANGUP:
706                         strcpy(subclass, "Hangup");
707                         break;
708                 case AST_CONTROL_RING:
709                         strcpy(subclass, "Ring");
710                         break;
711                 case AST_CONTROL_RINGING:
712                         strcpy(subclass, "Ringing");
713                         break;
714                 case AST_CONTROL_ANSWER:
715                         strcpy(subclass, "Answer");
716                         break;
717                 case AST_CONTROL_BUSY:
718                         strcpy(subclass, "Busy");
719                         break;
720                 case AST_CONTROL_TAKEOFFHOOK:
721                         strcpy(subclass, "Take Off Hook");
722                         break;
723                 case AST_CONTROL_OFFHOOK:
724                         strcpy(subclass, "Line Off Hook");
725                         break;
726                 case AST_CONTROL_CONGESTION:
727                         strcpy(subclass, "Congestion");
728                         break;
729                 case AST_CONTROL_FLASH:
730                         strcpy(subclass, "Flash");
731                         break;
732                 case AST_CONTROL_WINK:
733                         strcpy(subclass, "Wink");
734                         break;
735                 case AST_CONTROL_OPTION:
736                         strcpy(subclass, "Option");
737                         break;
738                 case AST_CONTROL_RADIO_KEY:
739                         strcpy(subclass, "Key Radio");
740                         break;
741                 case AST_CONTROL_RADIO_UNKEY:
742                         strcpy(subclass, "Unkey Radio");
743                         break;
744                 case -1:
745                         strcpy(subclass, "Stop generators");
746                         break;
747                 default:
748                         snprintf(subclass, sizeof(subclass), "Unknown control '%d'", f->subclass);
749                 }
750                 break;
751         case AST_FRAME_NULL:
752                 strcpy(ftype, "Null Frame");
753                 strcpy(subclass, "N/A");
754                 break;
755         case AST_FRAME_IAX:
756                 /* Should never happen */
757                 strcpy(ftype, "IAX Specific");
758                 snprintf(subclass, sizeof(subclass), "IAX Frametype %d", f->subclass);
759                 break;
760         case AST_FRAME_TEXT:
761                 strcpy(ftype, "Text");
762                 strcpy(subclass, "N/A");
763                 ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
764                 break;
765         case AST_FRAME_IMAGE:
766                 strcpy(ftype, "Image");
767                 snprintf(subclass, sizeof(subclass), "Image format %s\n", ast_getformatname(f->subclass));
768                 break;
769         case AST_FRAME_HTML:
770                 strcpy(ftype, "HTML");
771                 switch(f->subclass) {
772                 case AST_HTML_URL:
773                         strcpy(subclass, "URL");
774                         ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
775                         break;
776                 case AST_HTML_DATA:
777                         strcpy(subclass, "Data");
778                         break;
779                 case AST_HTML_BEGIN:
780                         strcpy(subclass, "Begin");
781                         break;
782                 case AST_HTML_END:
783                         strcpy(subclass, "End");
784                         break;
785                 case AST_HTML_LDCOMPLETE:
786                         strcpy(subclass, "Load Complete");
787                         break;
788                 case AST_HTML_NOSUPPORT:
789                         strcpy(subclass, "No Support");
790                         break;
791                 case AST_HTML_LINKURL:
792                         strcpy(subclass, "Link URL");
793                         ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
794                         break;
795                 case AST_HTML_UNLINK:
796                         strcpy(subclass, "Unlink");
797                         break;
798                 case AST_HTML_LINKREJECT:
799                         strcpy(subclass, "Link Reject");
800                         break;
801                 default:
802                         snprintf(subclass, sizeof(subclass), "Unknown HTML frame '%d'\n", f->subclass);
803                         break;
804                 }
805                 break;
806         default:
807                 snprintf(ftype, sizeof(ftype), "Unknown Frametype '%d'", f->frametype);
808         }
809         if (!ast_strlen_zero(moreinfo))
810                 ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) '%s' ] [%s]\n",  
811                             term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
812                             term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
813                             f->frametype, 
814                             term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
815                             f->subclass, 
816                             term_color(cmn, moreinfo, COLOR_BRGREEN, COLOR_BLACK, sizeof(cmn)),
817                             term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
818         else
819                 ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) ] [%s]\n",  
820                             term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
821                             term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
822                             f->frametype, 
823                             term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
824                             f->subclass, 
825                             term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
826 }
827
828
829 #ifdef TRACE_FRAMES
830 static int show_frame_stats(int fd, int argc, char *argv[])
831 {
832         struct ast_frame *f;
833         int x=1;
834         if (argc != 3)
835                 return RESULT_SHOWUSAGE;
836         ast_cli(fd, "     Framer Statistics     \n");
837         ast_cli(fd, "---------------------------\n");
838         ast_cli(fd, "Total allocated headers: %d\n", headers);
839         ast_cli(fd, "Queue Dump:\n");
840         ast_mutex_lock(&framelock);
841         for (f=headerlist; f; f = f->next) {
842                 ast_cli(fd, "%d.  Type %d, subclass %d from %s\n", x++, f->frametype, f->subclass, f->src ? f->src : "<Unknown>");
843         }
844         ast_mutex_unlock(&framelock);
845         return RESULT_SUCCESS;
846 }
847
848 static char frame_stats_usage[] =
849 "Usage: show frame stats\n"
850 "       Displays debugging statistics from framer\n";
851 #endif
852
853 /* Builtin Asterisk CLI-commands for debugging */
854 static struct ast_cli_entry my_clis[] = {
855 { { "show", "codecs", NULL }, show_codecs, "Shows codecs", frame_show_codecs_usage },
856 { { "show", "audio", "codecs", NULL }, show_codecs, "Shows audio codecs", frame_show_codecs_usage },
857 { { "show", "video", "codecs", NULL }, show_codecs, "Shows video codecs", frame_show_codecs_usage },
858 { { "show", "image", "codecs", NULL }, show_codecs, "Shows image codecs", frame_show_codecs_usage },
859 { { "show", "codec", NULL }, show_codec_n, "Shows a specific codec", frame_show_codec_n_usage },
860 #ifdef TRACE_FRAMES
861 { { "show", "frame", "stats", NULL }, show_frame_stats, "Shows frame statistics", frame_stats_usage },
862 #endif
863 };
864
865 int init_framer(void)
866 {
867         ast_cli_register_multiple(my_clis, sizeof(my_clis)/sizeof(my_clis[0]) );
868         return 0;       
869 }
870
871 void ast_codec_pref_convert(struct ast_codec_pref *pref, char *buf, size_t size, int right) 
872 {
873         int x, differential = (int) 'A', mem;
874         char *from, *to;
875
876         if(right) {
877                 from = pref->order;
878                 to = buf;
879                 mem = size;
880         } else {
881                 to = pref->order;
882                 from = buf;
883                 mem = 32;
884         }
885
886         memset(to, 0, mem);
887         for (x = 0; x < 32 ; x++) {
888                 if(!from[x])
889                         break;
890                 to[x] = right ? (from[x] + differential) : (from[x] - differential);
891         }
892 }
893
894 int ast_codec_pref_string(struct ast_codec_pref *pref, char *buf, size_t size) 
895 {
896         int x, codec; 
897         size_t total_len, slen;
898         char *formatname;
899         
900         memset(buf,0,size);
901         total_len = size;
902         buf[0] = '(';
903         total_len--;
904         for(x = 0; x < 32 ; x++) {
905                 if(total_len <= 0)
906                         break;
907                 if(!(codec = ast_codec_pref_index(pref,x)))
908                         break;
909                 if((formatname = ast_getformatname(codec))) {
910                         slen = strlen(formatname);
911                         if(slen > total_len)
912                                 break;
913                         strncat(buf,formatname,total_len);
914                         total_len -= slen;
915                 }
916                 if(total_len && x < 31 && ast_codec_pref_index(pref , x + 1)) {
917                         strncat(buf,"|",total_len);
918                         total_len--;
919                 }
920         }
921         if(total_len) {
922                 strncat(buf,")",total_len);
923                 total_len--;
924         }
925
926         return size - total_len;
927 }
928
929 int ast_codec_pref_index(struct ast_codec_pref *pref, int index) 
930 {
931         int slot = 0;
932
933         
934         if((index >= 0) && (index < sizeof(pref->order))) {
935                 slot = pref->order[index];
936         }
937
938         return slot ? AST_FORMAT_LIST[slot-1].bits : 0;
939 }
940
941 /*! \brief ast_codec_pref_remove: Remove codec from pref list */
942 void ast_codec_pref_remove(struct ast_codec_pref *pref, int format)
943 {
944         struct ast_codec_pref oldorder;
945         int x, y = 0;
946         int slot;
947
948         if(!pref->order[0])
949                 return;
950
951         memcpy(&oldorder, pref, sizeof(oldorder));
952         memset(pref, 0, sizeof(*pref));
953
954         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
955                 slot = oldorder.order[x];
956                 if(! slot)
957                         break;
958                 if(AST_FORMAT_LIST[slot-1].bits != format)
959                         pref->order[y++] = slot;
960         }
961         
962 }
963
964 /*! \brief ast_codec_pref_append: Append codec to list */
965 int ast_codec_pref_append(struct ast_codec_pref *pref, int format)
966 {
967         int x, newindex = -1;
968
969         ast_codec_pref_remove(pref, format);
970
971         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
972                 if(AST_FORMAT_LIST[x].bits == format) {
973                         newindex = x + 1;
974                         break;
975                 }
976         }
977
978         if(newindex) {
979                 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
980                         if(!pref->order[x]) {
981                                 pref->order[x] = newindex;
982                                 break;
983                         }
984                 }
985         }
986
987         return x;
988 }
989
990
991 /*! \brief ast_codec_choose: Pick a codec */
992 int ast_codec_choose(struct ast_codec_pref *pref, int formats, int find_best)
993 {
994         int x, ret = 0, slot;
995
996         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
997                 slot = pref->order[x];
998
999                 if(!slot)
1000                         break;
1001                 if ( formats & AST_FORMAT_LIST[slot-1].bits ) {
1002                         ret = AST_FORMAT_LIST[slot-1].bits;
1003                         break;
1004                 }
1005         }
1006         if(ret)
1007                 return ret;
1008
1009         return find_best ? ast_best_codec(formats) : 0;
1010 }
1011
1012 void ast_parse_allow_disallow(struct ast_codec_pref *pref, int *mask, const char *list, int allowing) 
1013 {
1014         char *parse;
1015         char *this;
1016         int format;
1017
1018         parse = ast_strdupa(list);
1019         while ((this = strsep(&parse, ","))) {
1020                 if (!(format = ast_getformatbyname(this))) {
1021                         ast_log(LOG_WARNING, "Cannot %s unknown format '%s'\n", allowing ? "allow" : "disallow", this);
1022                         continue;
1023                 }
1024
1025                 if (mask) {
1026                         if (allowing)
1027                                 *mask |= format;
1028                         else
1029                                 *mask &= ~format;
1030                 }
1031
1032                 if (pref) {
1033                         if (strcasecmp(this, "all")) {
1034                                 if (allowing)
1035                                         ast_codec_pref_append(pref, format);
1036                                 else
1037                                         ast_codec_pref_remove(pref, format);
1038                         } else if (!allowing) {
1039                                 memset(pref, 0, sizeof(*pref));
1040                         }
1041                 }
1042         }
1043 }
1044
1045 static int g723_len(unsigned char buf)
1046 {
1047         enum frame_type type = buf & TYPE_MASK;
1048
1049         switch(type) {
1050         case TYPE_DONTSEND:
1051                 return 0;
1052                 break;
1053         case TYPE_SILENCE:
1054                 return 4;
1055                 break;
1056         case TYPE_HIGH:
1057                 return 24;
1058                 break;
1059         case TYPE_LOW:
1060                 return 20;
1061                 break;
1062         default:
1063                 ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", type);
1064         }
1065         return -1;
1066 }
1067
1068 static int g723_samples(unsigned char *buf, int maxlen)
1069 {
1070         int pos = 0;
1071         int samples = 0;
1072         int res;
1073         while(pos < maxlen) {
1074                 res = g723_len(buf[pos]);
1075                 if (res <= 0)
1076                         break;
1077                 samples += 240;
1078                 pos += res;
1079         }
1080         return samples;
1081 }
1082
1083 static unsigned char get_n_bits_at(unsigned char *data, int n, int bit)
1084 {
1085         int byte = bit / 8;       /* byte containing first bit */
1086         int rem = 8 - (bit % 8);  /* remaining bits in first byte */
1087         unsigned char ret = 0;
1088         
1089         if (n <= 0 || n > 8)
1090                 return 0;
1091
1092         if (rem < n) {
1093                 ret = (data[byte] << (n - rem));
1094                 ret |= (data[byte + 1] >> (8 - n + rem));
1095         } else {
1096                 ret = (data[byte] >> (rem - n));
1097         }
1098
1099         return (ret & (0xff >> (8 - n)));
1100 }
1101
1102 static int speex_get_wb_sz_at(unsigned char *data, int len, int bit)
1103 {
1104         static int SpeexWBSubModeSz[] = {
1105                 0, 36, 112, 192,
1106                 352, 0, 0, 0 };
1107         int off = bit;
1108         unsigned char c;
1109
1110         /* skip up to two wideband frames */
1111         if (((len * 8 - off) >= 5) && 
1112                 get_n_bits_at(data, 1, off)) {
1113                 c = get_n_bits_at(data, 3, off + 1);
1114                 off += SpeexWBSubModeSz[c];
1115
1116                 if (((len * 8 - off) >= 5) && 
1117                         get_n_bits_at(data, 1, off)) {
1118                         c = get_n_bits_at(data, 3, off + 1);
1119                         off += SpeexWBSubModeSz[c];
1120
1121                         if (((len * 8 - off) >= 5) && 
1122                                 get_n_bits_at(data, 1, off)) {
1123                                 ast_log(LOG_WARNING, "Encountered corrupt speex frame; too many wideband frames in a row.\n");
1124                                 return -1;
1125                         }
1126                 }
1127
1128         }
1129         return off - bit;
1130 }
1131
1132 static int speex_samples(unsigned char *data, int len)
1133 {
1134         static int SpeexSubModeSz[] = {
1135                5, 43, 119, 160,
1136                 220, 300, 364, 492, 
1137                 79, 0, 0, 0,
1138                 0, 0, 0, 0 };
1139         static int SpeexInBandSz[] = { 
1140                 1, 1, 4, 4,
1141                 4, 4, 4, 4,
1142                 8, 8, 16, 16,
1143                 32, 32, 64, 64 };
1144         int bit = 0;
1145         int cnt = 0;
1146         int off;
1147         unsigned char c;
1148
1149         while ((len * 8 - bit) >= 5) {
1150                 /* skip wideband frames */
1151                 off = speex_get_wb_sz_at(data, len, bit);
1152                 if (off < 0)  {
1153                         ast_log(LOG_WARNING, "Had error while reading wideband frames for speex samples\n");
1154                         break;
1155                 }
1156                 bit += off;
1157
1158                 if ((len * 8 - bit) < 5) {
1159                         ast_log(LOG_WARNING, "Not enough bits remaining after wide band for speex samples.\n");
1160                         break;
1161                 }
1162
1163                 /* get control bits */
1164                 c = get_n_bits_at(data, 5, bit);
1165                 bit += 5;
1166
1167                 if (c == 15) { 
1168                         /* terminator */
1169                         break; 
1170                 } else if (c == 14) {
1171                         /* in-band signal; next 4 bits contain signal id */
1172                         c = get_n_bits_at(data, 4, bit);
1173                         bit += 4;
1174                         bit += SpeexInBandSz[c];
1175                 } else if (c == 13) {
1176                         /* user in-band; next 5 bits contain msg len */
1177                         c = get_n_bits_at(data, 5, bit);
1178                         bit += 5;
1179                         bit += c * 8;
1180                 } else if (c > 8) {
1181                         /* unknown */
1182                         break;
1183                 } else {
1184                         /* skip number bits for submode (less the 5 control bits) */
1185                         bit += SpeexSubModeSz[c] - 5;
1186                         cnt += 160; /* new frame */
1187                 }
1188         }
1189         return cnt;
1190 }
1191
1192 int ast_codec_get_samples(struct ast_frame *f)
1193 {
1194         int samples=0;
1195         switch(f->subclass) {
1196         case AST_FORMAT_SPEEX:
1197                 samples = speex_samples(f->data, f->datalen);
1198                 break;
1199         case AST_FORMAT_G723_1:
1200                 samples = g723_samples(f->data, f->datalen);
1201                 break;
1202         case AST_FORMAT_ILBC:
1203                 samples = 240 * (f->datalen / 50);
1204                 break;
1205         case AST_FORMAT_GSM:
1206                 samples = 160 * (f->datalen / 33);
1207                 break;
1208         case AST_FORMAT_G729A:
1209                 samples = f->datalen * 8;
1210                 break;
1211         case AST_FORMAT_SLINEAR:
1212                 samples = f->datalen / 2;
1213                 break;
1214         case AST_FORMAT_LPC10:
1215                 /* assumes that the RTP packet contains one LPC10 frame */
1216                 samples = 22 * 8;
1217                 samples += (((char *)(f->data))[7] & 0x1) * 8;
1218                 break;
1219         case AST_FORMAT_ULAW:
1220         case AST_FORMAT_ALAW:
1221                 samples = f->datalen;
1222                 break;
1223         case AST_FORMAT_ADPCM:
1224         case AST_FORMAT_G726:
1225                 samples = f->datalen * 2;
1226                 break;
1227         default:
1228                 ast_log(LOG_WARNING, "Unable to calculate samples for format %s\n", ast_getformatname(f->subclass));
1229         }
1230         return samples;
1231 }
1232
1233 int ast_codec_get_len(int format, int samples)
1234 {
1235         int len = 0;
1236
1237         /* XXX Still need speex, g723, and lpc10 XXX */ 
1238         switch(format) {
1239         case AST_FORMAT_ILBC:
1240                 len = (samples / 240) * 50;
1241                 break;
1242         case AST_FORMAT_GSM:
1243                 len = (samples / 160) * 33;
1244                 break;
1245         case AST_FORMAT_G729A:
1246                 len = samples / 8;
1247                 break;
1248         case AST_FORMAT_SLINEAR:
1249                 len = samples * 2;
1250                 break;
1251         case AST_FORMAT_ULAW:
1252         case AST_FORMAT_ALAW:
1253                 len = samples;
1254                 break;
1255         case AST_FORMAT_ADPCM:
1256         case AST_FORMAT_G726:
1257                 len = samples / 2;
1258                 break;
1259         default:
1260                 ast_log(LOG_WARNING, "Unable to calculate sample length for format %s\n", ast_getformatname(format));
1261         }
1262
1263         return len;
1264 }
1265
1266 int ast_frame_adjust_volume(struct ast_frame *f, int adjustment)
1267 {
1268         int count;
1269         short *fdata = f->data;
1270         short adjust_value = abs(adjustment);
1271
1272         if ((f->frametype != AST_FRAME_VOICE) || (f->subclass != AST_FORMAT_SLINEAR))
1273                 return -1;
1274
1275         if (!adjustment)
1276                 return 0;
1277
1278         for (count = 0; count < f->samples; count++) {
1279                 if (adjustment > 0) {
1280                         ast_slinear_saturated_multiply(&fdata[count], &adjust_value);
1281                 } else if (adjustment < 0) {
1282                         ast_slinear_saturated_divide(&fdata[count], &adjust_value);
1283                 }
1284         }
1285
1286         return 0;
1287 }
1288
1289 int ast_frame_slinear_sum(struct ast_frame *f1, struct ast_frame *f2)
1290 {
1291         int count;
1292         short *data1, *data2;
1293
1294         if ((f1->frametype != AST_FRAME_VOICE) || (f1->subclass != AST_FORMAT_SLINEAR))
1295                 return -1;
1296
1297         if ((f2->frametype != AST_FRAME_VOICE) || (f2->subclass != AST_FORMAT_SLINEAR))
1298                 return -1;
1299
1300         if (f1->samples != f2->samples)
1301                 return -1;
1302
1303         for (count = 0, data1 = f1->data, data2 = f2->data;
1304              count < f1->samples;
1305              count++, data1++, data2++)
1306                 ast_slinear_saturated_add(data1, data2);
1307
1308         return 0;
1309 }
1310
1311 struct ast_frame *ast_frame_enqueue(struct ast_frame *head, struct ast_frame *f, int maxlen, int dupe)
1312 {
1313         struct ast_frame *cur, *oldhead;
1314         int len=0;
1315         if (f && dupe)
1316                 f = ast_frdup(f);
1317         if (!f)
1318                 return head;
1319
1320         f->next = NULL;
1321         if (!head) 
1322                 return f;
1323         cur = head;
1324         while(cur->next) {
1325                 cur = cur->next;
1326                 len++;
1327                 if (len >= maxlen) {
1328                         oldhead = head;
1329                         head = head->next;
1330                         ast_frfree(oldhead);
1331                 }
1332         }
1333         return head;
1334 }