Documentation / whitespace fix.
[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         if (!(fr->mallocd & AST_MALLOCD_HDR)) {
308                 /* Allocate a new header if needed */
309                 if (!(out = ast_frame_header_new())) {
310                         return NULL;
311                 }
312                 out->frametype = fr->frametype;
313                 out->subclass = fr->subclass;
314                 out->datalen = fr->datalen;
315                 out->samples = fr->samples;
316                 out->offset = fr->offset;
317                 out->src = NULL;
318                 out->data = fr->data;
319         } else {
320                 out = fr;
321         }
322         if (!(fr->mallocd & AST_MALLOCD_SRC)) {
323                 if (fr->src)
324                         out->src = strdup(fr->src);
325         } else
326                 out->src = fr->src;
327         if (!(fr->mallocd & AST_MALLOCD_DATA))  {
328                 if (!(out->data = ast_malloc(fr->datalen + AST_FRIENDLY_OFFSET))) {
329                         free(out);
330                         return NULL;
331                 }
332                 out->data += AST_FRIENDLY_OFFSET;
333                 out->offset = AST_FRIENDLY_OFFSET;
334                 out->datalen = fr->datalen;
335                 memcpy(out->data, fr->data, fr->datalen);
336         }
337         out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA;
338         return out;
339 }
340
341 struct ast_frame *ast_frdup(struct ast_frame *f)
342 {
343         struct ast_frame *out;
344         int len, srclen = 0;
345         void *buf;
346         /* Start with standard stuff */
347         len = sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
348         /* If we have a source, add space for it */
349         /*
350          * XXX Watch out here - if we receive a src which is not terminated
351          * properly, we can be easily attacked. Should limit the size we deal with.
352          */
353         if (f->src)
354                 srclen = strlen(f->src);
355         if (srclen > 0)
356                 len += srclen + 1;
357         if (!(buf = ast_malloc(len)))
358                 return NULL;
359         out = buf;
360         /* Set us as having malloc'd header only, so it will eventually
361            get freed. */
362         out->frametype = f->frametype;
363         out->subclass = f->subclass;
364         out->datalen = f->datalen;
365         out->samples = f->samples;
366         out->delivery = f->delivery;
367         out->mallocd = AST_MALLOCD_HDR;
368         out->offset = AST_FRIENDLY_OFFSET;
369         out->data = buf + sizeof(*out) + AST_FRIENDLY_OFFSET;
370         if (srclen > 0) {
371                 out->src = out->data + f->datalen;
372                 /* Must have space since we allocated for it */
373                 strcpy((char *)out->src, f->src);
374         } else
375                 out->src = NULL;
376         out->prev = NULL;
377         out->next = NULL;
378         memcpy(out->data, f->data, out->datalen);       
379         return out;
380 }
381
382 #if 0
383 /*
384  * XXX
385  * This function is badly broken - it does not handle correctly
386  * partial reads on either header or body.
387  * However is it never used anywhere so we leave it commented out
388  */
389 struct ast_frame *ast_fr_fdread(int fd)
390 {
391         char buf[65536];
392         int res;        
393         struct ast_frame *f = (struct ast_frame *)buf;
394         int ttl = sizeof(*f);
395         /* Read a frame directly from there.  They're always in the
396            right format. */
397         
398         while(ttl) {
399                 res = read(fd, buf, ttl);
400                 if (res < 0) {
401                         ast_log(LOG_WARNING, "Bad read on %d: %s\n", fd, strerror(errno));
402                         return NULL;
403                 }
404                 ttl -= res;
405         }
406         
407         /* read the frame header */
408
409         /* Re-write data position */
410         f->data = buf + sizeof(*f);
411         f->offset = 0;
412         /* Forget about being mallocd */
413         f->mallocd = 0;
414         /* Re-write the source */
415         f->src = (char *)__FUNCTION__;
416         if (f->datalen > sizeof(buf) - sizeof(*f)) {
417                 /* Really bad read */
418                 ast_log(LOG_WARNING, "Strange read (%d bytes)\n", f->datalen);
419                 return NULL;
420         }
421         if (f->datalen) {
422                 if ((res = read(fd, f->data, f->datalen)) != f->datalen) {
423                         /* Bad read */
424                         ast_log(LOG_WARNING, "How very strange, expected %d, got %d\n", f->datalen, res);
425                         return NULL;
426                 }
427         }
428         if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
429                 return NULL;
430         }
431         return ast_frisolate(f);
432 }
433
434 /* Some convenient routines for sending frames to/from stream or datagram
435    sockets, pipes, etc (maybe even files) */
436
437 /*
438  * XXX this function is also partly broken because it does not handle
439  * partial writes. We comment it out too, and also the unique
440  * client it has, ast_fr_fdhangup()
441  */
442 int ast_fr_fdwrite(int fd, struct ast_frame *frame)
443 {
444         /* Write the frame exactly */
445         if (write(fd, frame, sizeof(*frame)) != sizeof(*frame)) {
446                 ast_log(LOG_WARNING, "Write error: %s\n", strerror(errno));
447                 return -1;
448         }
449         if (write(fd, frame->data, frame->datalen) != frame->datalen) {
450                 ast_log(LOG_WARNING, "Write error: %s\n", strerror(errno));
451                 return -1;
452         }
453         return 0;
454 }
455
456 int ast_fr_fdhangup(int fd)
457 {
458         struct ast_frame hangup = {
459                 AST_FRAME_CONTROL,
460                 AST_CONTROL_HANGUP
461         };
462         return ast_fr_fdwrite(fd, &hangup);
463 }
464
465 #endif /* unused functions */
466 void ast_swapcopy_samples(void *dst, const void *src, int samples)
467 {
468         int i;
469         unsigned short *dst_s = dst;
470         const unsigned short *src_s = src;
471
472         for (i=0; i<samples; i++)
473                 dst_s[i] = (src_s[i]<<8) | (src_s[i]>>8);
474 }
475
476
477 struct ast_format_list *ast_get_format_list_index(int index) 
478 {
479         return &AST_FORMAT_LIST[index];
480 }
481
482 struct ast_format_list *ast_get_format_list(size_t *size) 
483 {
484         *size = (sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]));
485         return AST_FORMAT_LIST;
486 }
487
488 char* ast_getformatname(int format)
489 {
490         int x;
491         char *ret = "unknown";
492         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
493                 if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == format) {
494                         ret = AST_FORMAT_LIST[x].name;
495                         break;
496                 }
497         }
498         return ret;
499 }
500
501 char *ast_getformatname_multiple(char *buf, size_t size, int format) {
502
503         int x;
504         unsigned len;
505         char *start, *end = buf;
506         if (!size) return buf;
507         snprintf(end, size, "0x%x (", format);
508         len = strlen(end);
509         end += len;
510         size -= len;
511         start = end;
512         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
513                 if (AST_FORMAT_LIST[x].visible && (AST_FORMAT_LIST[x].bits & format)) {
514                         snprintf(end, size,"%s|",AST_FORMAT_LIST[x].name);
515                         len = strlen(end);
516                         end += len;
517                         size -= len;
518                 }
519         }
520         if (start == end)
521                 snprintf(start, size, "nothing)");
522         else if (size > 1)
523                 *(end -1) = ')';
524         return buf;
525 }
526
527 static struct ast_codec_alias_table {
528         char *alias;
529         char *realname;
530
531 } ast_codec_alias_table[] = {
532         {"slinear","slin"},
533         {"g723.1","g723"},
534 };
535
536 static const char *ast_expand_codec_alias(const char *in) {
537         int x;
538
539         for (x = 0; x < sizeof(ast_codec_alias_table) / sizeof(ast_codec_alias_table[0]); x++) {
540                 if(!strcmp(in,ast_codec_alias_table[x].alias))
541                         return ast_codec_alias_table[x].realname;
542         }
543         return in;
544 }
545
546 int ast_getformatbyname(const char *name)
547 {
548         int x, all, format = 0;
549
550         all = strcasecmp(name, "all") ? 0 : 1;
551         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
552                 if(AST_FORMAT_LIST[x].visible && (all || 
553                                                                                   !strcasecmp(AST_FORMAT_LIST[x].name,name) ||
554                                                                                   !strcasecmp(AST_FORMAT_LIST[x].name,ast_expand_codec_alias(name)))) {
555                         format |= AST_FORMAT_LIST[x].bits;
556                         if(!all)
557                                 break;
558                 }
559         }
560
561         return format;
562 }
563
564 char *ast_codec2str(int codec) {
565         int x;
566         char *ret = "unknown";
567         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
568                 if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == codec) {
569                         ret = AST_FORMAT_LIST[x].desc;
570                         break;
571                 }
572         }
573         return ret;
574 }
575
576 static int show_codecs(int fd, int argc, char *argv[])
577 {
578         int i, found=0;
579         char hex[25];
580         
581         if ((argc < 2) || (argc > 3))
582                 return RESULT_SHOWUSAGE;
583
584         if (!ast_opt_dont_warn)
585                 ast_cli(fd, "Disclaimer: this command is for informational purposes only.\n"
586                                 "\tIt does not indicate anything about your configuration.\n");
587
588         ast_cli(fd, "%11s %9s %10s   TYPE   %5s   %s\n","INT","BINARY","HEX","NAME","DESC");
589         ast_cli(fd, "--------------------------------------------------------------------------------\n");
590         if ((argc == 2) || (!strcasecmp(argv[1],"audio"))) {
591                 found = 1;
592                 for (i=0;i<11;i++) {
593                         snprintf(hex,25,"(0x%x)",1<<i);
594                         ast_cli(fd, "%11u (1 << %2d) %10s  audio   %5s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
595                 }
596         }
597
598         if ((argc == 2) || (!strcasecmp(argv[1],"image"))) {
599                 found = 1;
600                 for (i=16;i<18;i++) {
601                         snprintf(hex,25,"(0x%x)",1<<i);
602                         ast_cli(fd, "%11u (1 << %2d) %10s  image   %5s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
603                 }
604         }
605
606         if ((argc == 2) || (!strcasecmp(argv[1],"video"))) {
607                 found = 1;
608                 for (i=18;i<21;i++) {
609                         snprintf(hex,25,"(0x%x)",1<<i);
610                         ast_cli(fd, "%11u (1 << %2d) %10s  video   %5s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
611                 }
612         }
613
614         if (! found)
615                 return RESULT_SHOWUSAGE;
616         else
617                 return RESULT_SUCCESS;
618 }
619
620 static char frame_show_codecs_usage[] =
621 "Usage: show [audio|video|image] codecs\n"
622 "       Displays codec mapping\n";
623
624 static int show_codec_n(int fd, int argc, char *argv[])
625 {
626         int codec, i, found=0;
627
628         if (argc != 3)
629                 return RESULT_SHOWUSAGE;
630
631         if (sscanf(argv[2],"%d",&codec) != 1)
632                 return RESULT_SHOWUSAGE;
633
634         for (i=0;i<32;i++)
635                 if (codec & (1 << i)) {
636                         found = 1;
637                         ast_cli(fd, "%11u (1 << %2d)  %s\n",1 << i,i,ast_codec2str(1<<i));
638                 }
639
640         if (! found)
641                 ast_cli(fd, "Codec %d not found\n", codec);
642
643         return RESULT_SUCCESS;
644 }
645
646 static char frame_show_codec_n_usage[] =
647 "Usage: show codec <number>\n"
648 "       Displays codec mapping\n";
649
650 /*! Dump a frame for debugging purposes */
651 void ast_frame_dump(const char *name, struct ast_frame *f, char *prefix)
652 {
653         const char noname[] = "unknown";
654         char ftype[40] = "Unknown Frametype";
655         char cft[80];
656         char subclass[40] = "Unknown Subclass";
657         char csub[80];
658         char moreinfo[40] = "";
659         char cn[60];
660         char cp[40];
661         char cmn[40];
662
663         if (!name)
664                 name = noname;
665
666
667         if (!f) {
668                 ast_verbose("%s [ %s (NULL) ] [%s]\n", 
669                         term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
670                         term_color(cft, "HANGUP", COLOR_BRRED, COLOR_BLACK, sizeof(cft)), 
671                         term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
672                 return;
673         }
674         /* XXX We should probably print one each of voice and video when the format changes XXX */
675         if (f->frametype == AST_FRAME_VOICE)
676                 return;
677         if (f->frametype == AST_FRAME_VIDEO)
678                 return;
679         switch(f->frametype) {
680         case AST_FRAME_DTMF:
681                 strcpy(ftype, "DTMF");
682                 subclass[0] = f->subclass;
683                 subclass[1] = '\0';
684                 break;
685         case AST_FRAME_CONTROL:
686                 strcpy(ftype, "Control");
687                 switch(f->subclass) {
688                 case AST_CONTROL_HANGUP:
689                         strcpy(subclass, "Hangup");
690                         break;
691                 case AST_CONTROL_RING:
692                         strcpy(subclass, "Ring");
693                         break;
694                 case AST_CONTROL_RINGING:
695                         strcpy(subclass, "Ringing");
696                         break;
697                 case AST_CONTROL_ANSWER:
698                         strcpy(subclass, "Answer");
699                         break;
700                 case AST_CONTROL_BUSY:
701                         strcpy(subclass, "Busy");
702                         break;
703                 case AST_CONTROL_TAKEOFFHOOK:
704                         strcpy(subclass, "Take Off Hook");
705                         break;
706                 case AST_CONTROL_OFFHOOK:
707                         strcpy(subclass, "Line Off Hook");
708                         break;
709                 case AST_CONTROL_CONGESTION:
710                         strcpy(subclass, "Congestion");
711                         break;
712                 case AST_CONTROL_FLASH:
713                         strcpy(subclass, "Flash");
714                         break;
715                 case AST_CONTROL_WINK:
716                         strcpy(subclass, "Wink");
717                         break;
718                 case AST_CONTROL_OPTION:
719                         strcpy(subclass, "Option");
720                         break;
721                 case AST_CONTROL_RADIO_KEY:
722                         strcpy(subclass, "Key Radio");
723                         break;
724                 case AST_CONTROL_RADIO_UNKEY:
725                         strcpy(subclass, "Unkey Radio");
726                         break;
727                 case -1:
728                         strcpy(subclass, "Stop generators");
729                         break;
730                 default:
731                         snprintf(subclass, sizeof(subclass), "Unknown control '%d'", f->subclass);
732                 }
733                 break;
734         case AST_FRAME_NULL:
735                 strcpy(ftype, "Null Frame");
736                 strcpy(subclass, "N/A");
737                 break;
738         case AST_FRAME_IAX:
739                 /* Should never happen */
740                 strcpy(ftype, "IAX Specific");
741                 snprintf(subclass, sizeof(subclass), "IAX Frametype %d", f->subclass);
742                 break;
743         case AST_FRAME_TEXT:
744                 strcpy(ftype, "Text");
745                 strcpy(subclass, "N/A");
746                 ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
747                 break;
748         case AST_FRAME_IMAGE:
749                 strcpy(ftype, "Image");
750                 snprintf(subclass, sizeof(subclass), "Image format %s\n", ast_getformatname(f->subclass));
751                 break;
752         case AST_FRAME_HTML:
753                 strcpy(ftype, "HTML");
754                 switch(f->subclass) {
755                 case AST_HTML_URL:
756                         strcpy(subclass, "URL");
757                         ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
758                         break;
759                 case AST_HTML_DATA:
760                         strcpy(subclass, "Data");
761                         break;
762                 case AST_HTML_BEGIN:
763                         strcpy(subclass, "Begin");
764                         break;
765                 case AST_HTML_END:
766                         strcpy(subclass, "End");
767                         break;
768                 case AST_HTML_LDCOMPLETE:
769                         strcpy(subclass, "Load Complete");
770                         break;
771                 case AST_HTML_NOSUPPORT:
772                         strcpy(subclass, "No Support");
773                         break;
774                 case AST_HTML_LINKURL:
775                         strcpy(subclass, "Link URL");
776                         ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
777                         break;
778                 case AST_HTML_UNLINK:
779                         strcpy(subclass, "Unlink");
780                         break;
781                 case AST_HTML_LINKREJECT:
782                         strcpy(subclass, "Link Reject");
783                         break;
784                 default:
785                         snprintf(subclass, sizeof(subclass), "Unknown HTML frame '%d'\n", f->subclass);
786                         break;
787                 }
788                 break;
789         default:
790                 snprintf(ftype, sizeof(ftype), "Unknown Frametype '%d'", f->frametype);
791         }
792         if (!ast_strlen_zero(moreinfo))
793                 ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) '%s' ] [%s]\n",  
794                             term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
795                             term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
796                             f->frametype, 
797                             term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
798                             f->subclass, 
799                             term_color(cmn, moreinfo, COLOR_BRGREEN, COLOR_BLACK, sizeof(cmn)),
800                             term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
801         else
802                 ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) ] [%s]\n",  
803                             term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
804                             term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
805                             f->frametype, 
806                             term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
807                             f->subclass, 
808                             term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
809 }
810
811
812 #ifdef TRACE_FRAMES
813 static int show_frame_stats(int fd, int argc, char *argv[])
814 {
815         struct ast_frame *f;
816         int x=1;
817         if (argc != 3)
818                 return RESULT_SHOWUSAGE;
819         ast_cli(fd, "     Framer Statistics     \n");
820         ast_cli(fd, "---------------------------\n");
821         ast_cli(fd, "Total allocated headers: %d\n", headers);
822         ast_cli(fd, "Queue Dump:\n");
823         ast_mutex_lock(&framelock);
824         for (f=headerlist; f; f = f->next) {
825                 ast_cli(fd, "%d.  Type %d, subclass %d from %s\n", x++, f->frametype, f->subclass, f->src ? f->src : "<Unknown>");
826         }
827         ast_mutex_unlock(&framelock);
828         return RESULT_SUCCESS;
829 }
830
831 static char frame_stats_usage[] =
832 "Usage: show frame stats\n"
833 "       Displays debugging statistics from framer\n";
834 #endif
835
836 /* Builtin Asterisk CLI-commands for debugging */
837 static struct ast_cli_entry my_clis[] = {
838 { { "show", "codecs", NULL }, show_codecs, "Shows codecs", frame_show_codecs_usage },
839 { { "show", "audio", "codecs", NULL }, show_codecs, "Shows audio codecs", frame_show_codecs_usage },
840 { { "show", "video", "codecs", NULL }, show_codecs, "Shows video codecs", frame_show_codecs_usage },
841 { { "show", "image", "codecs", NULL }, show_codecs, "Shows image codecs", frame_show_codecs_usage },
842 { { "show", "codec", NULL }, show_codec_n, "Shows a specific codec", frame_show_codec_n_usage },
843 #ifdef TRACE_FRAMES
844 { { "show", "frame", "stats", NULL }, show_frame_stats, "Shows frame statistics", frame_stats_usage },
845 #endif
846 };
847
848 int init_framer(void)
849 {
850         ast_cli_register_multiple(my_clis, sizeof(my_clis)/sizeof(my_clis[0]) );
851         return 0;       
852 }
853
854 void ast_codec_pref_convert(struct ast_codec_pref *pref, char *buf, size_t size, int right) 
855 {
856         int x, differential = (int) 'A', mem;
857         char *from, *to;
858
859         if(right) {
860                 from = pref->order;
861                 to = buf;
862                 mem = size;
863         } else {
864                 to = pref->order;
865                 from = buf;
866                 mem = 32;
867         }
868
869         memset(to, 0, mem);
870         for (x = 0; x < 32 ; x++) {
871                 if(!from[x])
872                         break;
873                 to[x] = right ? (from[x] + differential) : (from[x] - differential);
874         }
875 }
876
877 int ast_codec_pref_string(struct ast_codec_pref *pref, char *buf, size_t size) 
878 {
879         int x, codec; 
880         size_t total_len, slen;
881         char *formatname;
882         
883         memset(buf,0,size);
884         total_len = size;
885         buf[0] = '(';
886         total_len--;
887         for(x = 0; x < 32 ; x++) {
888                 if(total_len <= 0)
889                         break;
890                 if(!(codec = ast_codec_pref_index(pref,x)))
891                         break;
892                 if((formatname = ast_getformatname(codec))) {
893                         slen = strlen(formatname);
894                         if(slen > total_len)
895                                 break;
896                         strncat(buf,formatname,total_len);
897                         total_len -= slen;
898                 }
899                 if(total_len && x < 31 && ast_codec_pref_index(pref , x + 1)) {
900                         strncat(buf,"|",total_len);
901                         total_len--;
902                 }
903         }
904         if(total_len) {
905                 strncat(buf,")",total_len);
906                 total_len--;
907         }
908
909         return size - total_len;
910 }
911
912 int ast_codec_pref_index(struct ast_codec_pref *pref, int index) 
913 {
914         int slot = 0;
915
916         
917         if((index >= 0) && (index < sizeof(pref->order))) {
918                 slot = pref->order[index];
919         }
920
921         return slot ? AST_FORMAT_LIST[slot-1].bits : 0;
922 }
923
924 /*! \brief ast_codec_pref_remove: Remove codec from pref list ---*/
925 void ast_codec_pref_remove(struct ast_codec_pref *pref, int format)
926 {
927         struct ast_codec_pref oldorder;
928         int x, y = 0;
929         int slot;
930
931         if(!pref->order[0])
932                 return;
933
934         memcpy(&oldorder, pref, sizeof(oldorder));
935         memset(pref, 0, sizeof(*pref));
936
937         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
938                 slot = oldorder.order[x];
939                 if(! slot)
940                         break;
941                 if(AST_FORMAT_LIST[slot-1].bits != format)
942                         pref->order[y++] = slot;
943         }
944         
945 }
946
947 /*! \brief ast_codec_pref_append: Append codec to list ---*/
948 int ast_codec_pref_append(struct ast_codec_pref *pref, int format)
949 {
950         int x, newindex = -1;
951
952         ast_codec_pref_remove(pref, format);
953
954         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
955                 if(AST_FORMAT_LIST[x].bits == format) {
956                         newindex = x + 1;
957                         break;
958                 }
959         }
960
961         if(newindex) {
962                 for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
963                         if(!pref->order[x]) {
964                                 pref->order[x] = newindex;
965                                 break;
966                         }
967                 }
968         }
969
970         return x;
971 }
972
973
974 /*! \brief ast_codec_choose: Pick a codec ---*/
975 int ast_codec_choose(struct ast_codec_pref *pref, int formats, int find_best)
976 {
977         int x, ret = 0, slot;
978
979         for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
980                 slot = pref->order[x];
981
982                 if(!slot)
983                         break;
984                 if ( formats & AST_FORMAT_LIST[slot-1].bits ) {
985                         ret = AST_FORMAT_LIST[slot-1].bits;
986                         break;
987                 }
988         }
989         if(ret)
990                 return ret;
991
992         return find_best ? ast_best_codec(formats) : 0;
993 }
994
995 void ast_parse_allow_disallow(struct ast_codec_pref *pref, int *mask, const char *list, int allowing) 
996 {
997         char *parse;
998         char *this;
999         int format;
1000
1001         parse = ast_strdupa(list);
1002         while ((this = strsep(&parse, ","))) {
1003                 if (!(format = ast_getformatbyname(this))) {
1004                         ast_log(LOG_WARNING, "Cannot %s unknown format '%s'\n", allowing ? "allow" : "disallow", this);
1005                         continue;
1006                 }
1007
1008                 if (mask) {
1009                         if (allowing)
1010                                 *mask |= format;
1011                         else
1012                                 *mask &= ~format;
1013                 }
1014
1015                 if (pref) {
1016                         if (strcasecmp(this, "all")) {
1017                                 if (allowing)
1018                                         ast_codec_pref_append(pref, format);
1019                                 else
1020                                         ast_codec_pref_remove(pref, format);
1021                         } else if (!allowing) {
1022                                 memset(pref, 0, sizeof(*pref));
1023                         }
1024                 }
1025         }
1026 }
1027
1028 static int g723_len(unsigned char buf)
1029 {
1030         enum frame_type type = buf & TYPE_MASK;
1031
1032         switch(type) {
1033         case TYPE_DONTSEND:
1034                 return 0;
1035                 break;
1036         case TYPE_SILENCE:
1037                 return 4;
1038                 break;
1039         case TYPE_HIGH:
1040                 return 24;
1041                 break;
1042         case TYPE_LOW:
1043                 return 20;
1044                 break;
1045         default:
1046                 ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", type);
1047         }
1048         return -1;
1049 }
1050
1051 static int g723_samples(unsigned char *buf, int maxlen)
1052 {
1053         int pos = 0;
1054         int samples = 0;
1055         int res;
1056         while(pos < maxlen) {
1057                 res = g723_len(buf[pos]);
1058                 if (res <= 0)
1059                         break;
1060                 samples += 240;
1061                 pos += res;
1062         }
1063         return samples;
1064 }
1065
1066 static unsigned char get_n_bits_at(unsigned char *data, int n, int bit)
1067 {
1068         int byte = bit / 8;       /* byte containing first bit */
1069         int rem = 8 - (bit % 8);  /* remaining bits in first byte */
1070         unsigned char ret = 0;
1071         
1072         if (n <= 0 || n > 8)
1073                 return 0;
1074
1075         if (rem < n) {
1076                 ret = (data[byte] << (n - rem));
1077                 ret |= (data[byte + 1] >> (8 - n + rem));
1078         } else {
1079                 ret = (data[byte] >> (rem - n));
1080         }
1081
1082         return (ret & (0xff >> (8 - n)));
1083 }
1084
1085 static int speex_get_wb_sz_at(unsigned char *data, int len, int bit)
1086 {
1087         static int SpeexWBSubModeSz[] = {
1088                 0, 36, 112, 192,
1089                 352, 0, 0, 0 };
1090         int off = bit;
1091         unsigned char c;
1092
1093         /* skip up to two wideband frames */
1094         if (((len * 8 - off) >= 5) && 
1095                 get_n_bits_at(data, 1, off)) {
1096                 c = get_n_bits_at(data, 3, off + 1);
1097                 off += SpeexWBSubModeSz[c];
1098
1099                 if (((len * 8 - off) >= 5) && 
1100                         get_n_bits_at(data, 1, off)) {
1101                         c = get_n_bits_at(data, 3, off + 1);
1102                         off += SpeexWBSubModeSz[c];
1103
1104                         if (((len * 8 - off) >= 5) && 
1105                                 get_n_bits_at(data, 1, off)) {
1106                                 ast_log(LOG_WARNING, "Encountered corrupt speex frame; too many wideband frames in a row.\n");
1107                                 return -1;
1108                         }
1109                 }
1110
1111         }
1112         return off - bit;
1113 }
1114
1115 static int speex_samples(unsigned char *data, int len)
1116 {
1117         static int SpeexSubModeSz[] = {
1118                5, 43, 119, 160,
1119                 220, 300, 364, 492, 
1120                 79, 0, 0, 0,
1121                 0, 0, 0, 0 };
1122         static int SpeexInBandSz[] = { 
1123                 1, 1, 4, 4,
1124                 4, 4, 4, 4,
1125                 8, 8, 16, 16,
1126                 32, 32, 64, 64 };
1127         int bit = 0;
1128         int cnt = 0;
1129         int off;
1130         unsigned char c;
1131
1132         while ((len * 8 - bit) >= 5) {
1133                 /* skip wideband frames */
1134                 off = speex_get_wb_sz_at(data, len, bit);
1135                 if (off < 0)  {
1136                         ast_log(LOG_WARNING, "Had error while reading wideband frames for speex samples\n");
1137                         break;
1138                 }
1139                 bit += off;
1140
1141                 if ((len * 8 - bit) < 5) {
1142                         ast_log(LOG_WARNING, "Not enough bits remaining after wide band for speex samples.\n");
1143                         break;
1144                 }
1145
1146                 /* get control bits */
1147                 c = get_n_bits_at(data, 5, bit);
1148                 bit += 5;
1149
1150                 if (c == 15) { 
1151                         /* terminator */
1152                         break; 
1153                 } else if (c == 14) {
1154                         /* in-band signal; next 4 bits contain signal id */
1155                         c = get_n_bits_at(data, 4, bit);
1156                         bit += 4;
1157                         bit += SpeexInBandSz[c];
1158                 } else if (c == 13) {
1159                         /* user in-band; next 5 bits contain msg len */
1160                         c = get_n_bits_at(data, 5, bit);
1161                         bit += 5;
1162                         bit += c * 8;
1163                 } else if (c > 8) {
1164                         /* unknown */
1165                         break;
1166                 } else {
1167                         /* skip number bits for submode (less the 5 control bits) */
1168                         bit += SpeexSubModeSz[c] - 5;
1169                         cnt += 160; /* new frame */
1170                 }
1171         }
1172         return cnt;
1173 }
1174
1175 int ast_codec_get_samples(struct ast_frame *f)
1176 {
1177         int samples=0;
1178         switch(f->subclass) {
1179         case AST_FORMAT_SPEEX:
1180                 samples = speex_samples(f->data, f->datalen);
1181                 break;
1182         case AST_FORMAT_G723_1:
1183                 samples = g723_samples(f->data, f->datalen);
1184                 break;
1185         case AST_FORMAT_ILBC:
1186                 samples = 240 * (f->datalen / 50);
1187                 break;
1188         case AST_FORMAT_GSM:
1189                 samples = 160 * (f->datalen / 33);
1190                 break;
1191         case AST_FORMAT_G729A:
1192                 samples = f->datalen * 8;
1193                 break;
1194         case AST_FORMAT_SLINEAR:
1195                 samples = f->datalen / 2;
1196                 break;
1197         case AST_FORMAT_LPC10:
1198                 /* assumes that the RTP packet contains one LPC10 frame */
1199                 samples = 22 * 8;
1200                 samples += (((char *)(f->data))[7] & 0x1) * 8;
1201                 break;
1202         case AST_FORMAT_ULAW:
1203         case AST_FORMAT_ALAW:
1204                 samples = f->datalen;
1205                 break;
1206         case AST_FORMAT_ADPCM:
1207         case AST_FORMAT_G726:
1208                 samples = f->datalen * 2;
1209                 break;
1210         default:
1211                 ast_log(LOG_WARNING, "Unable to calculate samples for format %s\n", ast_getformatname(f->subclass));
1212         }
1213         return samples;
1214 }
1215
1216 int ast_codec_get_len(int format, int samples)
1217 {
1218         int len = 0;
1219
1220         /* XXX Still need speex, g723, and lpc10 XXX */ 
1221         switch(format) {
1222         case AST_FORMAT_ILBC:
1223                 len = (samples / 240) * 50;
1224                 break;
1225         case AST_FORMAT_GSM:
1226                 len = (samples / 160) * 33;
1227                 break;
1228         case AST_FORMAT_G729A:
1229                 len = samples / 8;
1230                 break;
1231         case AST_FORMAT_SLINEAR:
1232                 len = samples * 2;
1233                 break;
1234         case AST_FORMAT_ULAW:
1235         case AST_FORMAT_ALAW:
1236                 len = samples;
1237                 break;
1238         case AST_FORMAT_ADPCM:
1239         case AST_FORMAT_G726:
1240                 len = samples / 2;
1241                 break;
1242         default:
1243                 ast_log(LOG_WARNING, "Unable to calculate sample length for format %s\n", ast_getformatname(format));
1244         }
1245
1246         return len;
1247 }
1248
1249 int ast_frame_adjust_volume(struct ast_frame *f, int adjustment)
1250 {
1251         int count;
1252         short *fdata = f->data;
1253         short adjust_value = abs(adjustment);
1254
1255         if ((f->frametype != AST_FRAME_VOICE) || (f->subclass != AST_FORMAT_SLINEAR))
1256                 return -1;
1257
1258         if (!adjustment)
1259                 return 0;
1260
1261         for (count = 0; count < f->samples; count++) {
1262                 if (adjustment > 0) {
1263                         ast_slinear_saturated_multiply(&fdata[count], &adjust_value);
1264                 } else if (adjustment < 0) {
1265                         ast_slinear_saturated_divide(&fdata[count], &adjust_value);
1266                 }
1267         }
1268
1269         return 0;
1270 }
1271
1272 int ast_frame_slinear_sum(struct ast_frame *f1, struct ast_frame *f2)
1273 {
1274         int count;
1275         short *data1, *data2;
1276
1277         if ((f1->frametype != AST_FRAME_VOICE) || (f1->subclass != AST_FORMAT_SLINEAR))
1278                 return -1;
1279
1280         if ((f2->frametype != AST_FRAME_VOICE) || (f2->subclass != AST_FORMAT_SLINEAR))
1281                 return -1;
1282
1283         if (f1->samples != f2->samples)
1284                 return -1;
1285
1286         for (count = 0, data1 = f1->data, data2 = f2->data;
1287              count < f1->samples;
1288              count++, data1++, data2++)
1289                 ast_slinear_saturated_add(data1, data2);
1290
1291         return 0;
1292 }
1293
1294 struct ast_frame *ast_frame_enqueue(struct ast_frame *head, struct ast_frame *f, int maxlen, int dupe)
1295 {
1296         struct ast_frame *cur, *oldhead;
1297         int len=0;
1298         if (f && dupe)
1299                 f = ast_frdup(f);
1300         if (!f)
1301                 return head;
1302
1303         f->next = NULL;
1304         if (!head) 
1305                 return f;
1306         cur = head;
1307         while(cur->next) {
1308                 cur = cur->next;
1309                 len++;
1310                 if (len >= maxlen) {
1311                         oldhead = head;
1312                         head = head->next;
1313                         ast_frfree(oldhead);
1314                 }
1315         }
1316         return head;
1317 }