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