frame.c File Reference

#include <asterisk/lock.h>
#include <asterisk/frame.h>
#include <asterisk/logger.h>
#include <asterisk/options.h>
#include <asterisk/channel.h>
#include <asterisk/cli.h>
#include <asterisk/term.h>
#include <asterisk/utils.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include "asterisk.h"

Go to the source code of this file.

Data Structures
struct	ast_format_list
struct	ast_smoother
struct	ast_codec_alias_table
Defines
#define	SMOOTHER_SIZE   8000
Functions
void	ast_smoother_reset (struct ast_smoother *s, int size)
ast_smoother *	ast_smoother_new (int size)
int	ast_smoother_get_flags (struct ast_smoother *s)
void	ast_smoother_set_flags (struct ast_smoother *s, int flags)
int	__ast_smoother_feed (struct ast_smoother *s, struct ast_frame *f, int swap)
ast_frame *	ast_smoother_read (struct ast_smoother *s)
void	ast_smoother_free (struct ast_smoother *s)
void	ast_frfree (struct ast_frame *fr)
	Frees a frame.
ast_frame *	ast_frisolate (struct ast_frame *fr)
	Copies a frame.
ast_frame *	ast_frdup (struct ast_frame *f)
	Copies a frame.
ast_frame *	ast_fr_fdread (int fd)
	Reads a frame from an fd.
int	ast_fr_fdwrite (int fd, struct ast_frame *frame)
	Writes a frame to an fd.
int	ast_fr_fdhangup (int fd)
	Sends a hangup to an fd.
void	ast_memcpy_byteswap (void *dst, void *src, int samples)
ast_format_list *	ast_get_format_list_index (int index)
ast_format_list *	ast_get_format_list (size_t *size)
char *	ast_getformatname (int format)
	Get the name of a format.
char *	ast_getformatname_multiple (char *buf, size_t size, int format)
	Get the names of a set of formats.
int	ast_getformatbyname (char *name)
char *	ast_codec2str (int codec)
	Get a name from a format.
void	ast_frame_dump (char *name, struct ast_frame *f, char *prefix)
int	init_framer (void)
void	ast_codec_pref_shift (struct ast_codec_pref *pref, char *buf, size_t size, int right)
int	ast_codec_pref_string (struct ast_codec_pref *pref, char *buf, size_t size)
int	ast_codec_pref_index (struct ast_codec_pref *pref, int index)
void	ast_codec_pref_remove (struct ast_codec_pref *pref, int format)
int	ast_codec_pref_append (struct ast_codec_pref *pref, int format)
int	ast_codec_choose (struct ast_codec_pref *pref, int formats, int find_best)
void	ast_parse_allow_disallow (struct ast_codec_pref *pref, int *mask, char *list, int allowing)
Variables
ast_cli_entry	cli_show_codecs
ast_cli_entry	cli_show_codecs_audio
ast_cli_entry	cli_show_codecs_video
ast_cli_entry	cli_show_codecs_image
ast_cli_entry	cli_show_codec_n

---

Define Documentation

#define SMOOTHER_SIZE   8000

Definition at line 35 of file frame.c. Referenced by __ast_smoother_feed().

---

Function Documentation

int __ast_smoother_feed (  struct ast_smoother *  s, struct ast_frame *  f, int  swap )

Definition at line 86 of file frame.c. References AST_FRAME_VOICE, ast_log(), ast_memcpy_byteswap(), AST_MIN_OFFSET, AST_SMOOTHER_FLAG_G729, ast_smoother::data, ast_frame::data, ast_frame::datalen, ast_frame::delivery, ast_smoother::delivery, ast_smoother::flags, ast_smoother::format, ast_frame::frametype, ast_smoother::len, LOG_NOTICE, LOG_WARNING, ast_frame::offset, ast_smoother::opt, ast_smoother::optimizablestream, ast_frame::samples, ast_smoother::samplesperbyte, ast_smoother::size, SMOOTHER_SIZE, and ast_frame::subclass. { if (f->frametype != AST_FRAME_VOICE) { ast_log(LOG_WARNING, "Huh? Can't smooth a non-voice frame!\n"); return -1; } if (!s->format) { s->format = f->subclass; s->samplesperbyte = (float)f->samples / (float)f->datalen; } else if (s->format != f->subclass) { ast_log(LOG_WARNING, "Smoother was working on %d format frames, now trying to feed %d?\n", s->format, f->subclass); return -1; } if (s->len + f->datalen > SMOOTHER_SIZE) { ast_log(LOG_WARNING, "Out of smoother space\n"); return -1; } if (((f->datalen == s->size) || ((f->datalen < 10) && (s->flags & AST_SMOOTHER_FLAG_G729))) && !s->opt && (f->offset >= AST_MIN_OFFSET)) { if (!s->len) { /* Optimize by sending the frame we just got on the next read, thus eliminating the douple copy */ s->opt = f; return 0; } else { s->optimizablestream++; if (s->optimizablestream > 10) { /* For the past 10 rounds, we have input and output frames of the correct size for this smoother, yet we were unable to optimize because there was still some cruft left over. Lets just drop the cruft so we can move to a fully optimized path */ s->len = 0; s->opt = f; return 0; } } } else s->optimizablestream = 0; if (s->flags & AST_SMOOTHER_FLAG_G729) { if (s->len % 10) { ast_log(LOG_NOTICE, "Dropping extra frame of G.729 since we already have a VAD frame at the end\n"); return 0; } } if (swap) ast_memcpy_byteswap(s->data+s->len, f->data, f->samples); else memcpy(s->data + s->len, f->data, f->datalen); /* If either side is empty, reset the delivery time */ if (!s->len || (!f->delivery.tv_sec && !f->delivery.tv_usec) || (!s->delivery.tv_sec && !s->delivery.tv_usec)) s->delivery = f->delivery; s->len += f->datalen; return 0; }

char* ast_codec2str (  int  codec  )

Get a name from a format. Parameters: codec  codec number (1,2,4,8,16,etc.) Gets a name from a format This returns a static string identifying the format on success, 0 on error. Definition at line 529 of file frame.c. { int x = 0; char *ret = "unknown"; for (x = 0 ; x < sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list) ; x++) { if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == codec) { ret = AST_FORMAT_LIST[x].desc; break; } } return ret; }

int ast_codec_choose (  struct ast_codec_pref *  pref, int  formats, int  find_best )

Definition at line 952 of file frame.c. References ast_best_codec(), ast_format_list::bits, and ast_codec_pref::order. { size_t size = 0; int x = 0, ret = 0, slot = 0; size = sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list); for (x = 0; x < size; x++) { slot = pref->order[x]; if(!slot) break; if ( formats & AST_FORMAT_LIST[slot-1].bits ) { ret = AST_FORMAT_LIST[slot-1].bits; break; } } if(ret) return ret; return find_best ? ast_best_codec(formats) : 0; }

int ast_codec_pref_append (  struct ast_codec_pref *  pref, int  format )

Definition at line 923 of file frame.c. References ast_codec_pref_remove(), ast_format_list::bits, and ast_codec_pref::order. Referenced by ast_parse_allow_disallow(). { size_t size = 0; int x = 0, newindex = -1; ast_codec_pref_remove(pref, format); size = sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list); for (x = 0; x < size; x++) { if(AST_FORMAT_LIST[x].bits == format) { newindex = x + 1; break; } } if(newindex) { for (x = 0; x < size; x++) { if(!pref->order[x]) { pref->order[x] = newindex; break; } } } return x; }

int ast_codec_pref_index (  struct ast_codec_pref *  pref, int  index )

Definition at line 884 of file frame.c. References ast_format_list::bits, and ast_codec_pref::order. Referenced by ast_codec_pref_string(). { int slot = 0; if((index >= 0) && (index < sizeof(pref->order))) { slot = pref->order[index]; } return slot ? AST_FORMAT_LIST[slot-1].bits : 0; }

void ast_codec_pref_remove (  struct ast_codec_pref *  pref, int  format )

Definition at line 897 of file frame.c. References ast_format_list::bits, and ast_codec_pref::order. Referenced by ast_codec_pref_append(), and ast_parse_allow_disallow(). { struct ast_codec_pref oldorder; int x=0, y=0; size_t size = 0; int slot = 0; if(!pref->order[0]) return; size = sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list); memcpy(&oldorder,pref,sizeof(struct ast_codec_pref)); memset(pref,0,sizeof(struct ast_codec_pref)); for (x = 0; x < size; x++) { slot = oldorder.order[x]; if(! slot) break; if(AST_FORMAT_LIST[slot-1].bits != format) pref->order[y++] = slot; } }

void ast_codec_pref_shift (  struct ast_codec_pref *  pref, char *  buf, size_t  size, int  right )

Definition at line 826 of file frame.c. References ast_codec_pref::order. { int x = 0, differential = 65, mem = 0; char *from = NULL, *to = NULL; if(right) { from = pref->order; to = buf; mem = size; } else { to = pref->order; from = buf; mem = 32; } memset(to, 0, mem); for (x = 0; x < 32 ; x++) { if(!from[x]) break; to[x] = right ? (from[x] + differential) : (from[x] - differential); } }

int ast_codec_pref_string (  struct ast_codec_pref *  pref, char *  buf, size_t  size )

Definition at line 849 of file frame.c. References ast_codec_pref_index(), and ast_getformatname(). { int x = 0, codec = 0; size_t total_len = 0, slen = 0; char *formatname = 0; memset(buf,0,size); total_len = size; buf[0] = '('; total_len--; for(x = 0; x < 32 ; x++) { if(total_len <= 0) break; if(!(codec = ast_codec_pref_index(pref,x))) break; if((formatname = ast_getformatname(codec))) { slen = strlen(formatname); if(slen > total_len) break; strncat(buf,formatname,total_len); total_len -= slen; } if(total_len && x < 31 && ast_codec_pref_index(pref , x + 1)) { strncat(buf,"|",total_len); total_len--; } } if(total_len) { strncat(buf,")",total_len); total_len--; } return size - total_len; }

int ast_fr_fdhangup (  int  fd  )

Sends a hangup to an fd. Parameters: fd  fd to write to Send a hangup (NULL equivalent) on an fd Returns 0 on success, -1 on failure Definition at line 396 of file frame.c. References AST_CONTROL_HANGUP, ast_fr_fdwrite(), and AST_FRAME_CONTROL. { struct ast_frame hangup = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP }; return ast_fr_fdwrite(fd, &hangup); }

struct ast_frame* ast_fr_fdread (  int  fd  )

Reads a frame from an fd. Parameters: fd  an opened fd to read from Read a frame from a stream or packet fd, as written by fd_write returns a frame on success, NULL on error Definition at line 334 of file frame.c. References AST_CONTROL_HANGUP, AST_FRAME_CONTROL, ast_frisolate(), ast_log(), ast_frame::data, ast_frame::datalen, ast_frame::frametype, LOG_WARNING, ast_frame::mallocd, ast_frame::offset, ast_frame::src, and ast_frame::subclass. { char buf[65536]; int res; int ttl = sizeof(struct ast_frame); struct ast_frame *f = (struct ast_frame *)buf; /* Read a frame directly from there. They're always in the right format. */ while(ttl) { res = read(fd, buf, ttl); if (res < 0) { ast_log(LOG_WARNING, "Bad read on %d: %s\n", fd, strerror(errno)); return NULL; } ttl -= res; } /* read the frame header */ f->mallocd = 0; /* Re-write data position */ f->data = buf + sizeof(struct ast_frame); f->offset = 0; /* Forget about being mallocd */ f->mallocd = 0; /* Re-write the source */ f->src = (char *)__FUNCTION__; if (f->datalen > sizeof(buf) - sizeof(struct ast_frame)) { /* Really bad read */ ast_log(LOG_WARNING, "Strange read (%d bytes)\n", f->datalen); return NULL; } if (f->datalen) { if ((res = read(fd, f->data, f->datalen)) != f->datalen) { /* Bad read */ ast_log(LOG_WARNING, "How very strange, expected %d, got %d\n", f->datalen, res); return NULL; } } if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) { return NULL; } return ast_frisolate(f); }

int ast_fr_fdwrite (  int  fd, struct ast_frame *  frame )

Writes a frame to an fd. Parameters: fd  Which fd to write to frame  frame to write to the fd Write a frame to an fd Returns 0 on success, -1 on failure Definition at line 382 of file frame.c. References ast_log(), ast_frame::data, ast_frame::datalen, and LOG_WARNING. Referenced by ast_fr_fdhangup(). { /* Write the frame exactly */ if (write(fd, frame, sizeof(struct ast_frame)) != sizeof(struct ast_frame)) { ast_log(LOG_WARNING, "Write error: %s\n", strerror(errno)); return -1; } if (write(fd, frame->data, frame->datalen) != frame->datalen) { ast_log(LOG_WARNING, "Write error: %s\n", strerror(errno)); return -1; } return 0; }

void ast_frame_dump (  char *  name, struct ast_frame *  f, char *  prefix )

Definition at line 627 of file frame.c. References AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_FLASH, AST_CONTROL_HANGUP, AST_CONTROL_OFFHOOK, AST_CONTROL_OPTION, AST_CONTROL_RADIO_KEY, AST_CONTROL_RADIO_UNKEY, AST_CONTROL_RING, AST_CONTROL_RINGING, AST_CONTROL_TAKEOFFHOOK, AST_CONTROL_WINK, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_HTML, AST_FRAME_IAX, AST_FRAME_IMAGE, AST_FRAME_NULL, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_getformatname(), AST_HTML_BEGIN, AST_HTML_DATA, AST_HTML_END, AST_HTML_LDCOMPLETE, AST_HTML_LINKREJECT, AST_HTML_LINKURL, AST_HTML_NOSUPPORT, AST_HTML_UNLINK, AST_HTML_URL, ast_verbose(), COLOR_BLACK, COLOR_BRCYAN, COLOR_BRGREEN, COLOR_BRMAGENTA, COLOR_BRRED, COLOR_YELLOW, ast_frame::data, ast_frame::frametype, ast_frame::subclass, and term_color(). Referenced by ast_read(), and ast_write(). { char *n = "unknown"; char ftype[40] = "Unknown Frametype"; char cft[80]; char subclass[40] = "Unknown Subclass"; char csub[80]; char moreinfo[40] = ""; char cn[60]; char cp[40]; char cmn[40]; if (name) n = name; if (!f) { ast_verbose("%s [ %s (NULL) ] [%s]\n", term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)), term_color(cft, "HANGUP", COLOR_BRRED, COLOR_BLACK, sizeof(cft)), term_color(cn, n, COLOR_YELLOW, COLOR_BLACK, sizeof(cn))); return; } /* XXX We should probably print one each of voice and video when the format changes XXX */ if (f->frametype == AST_FRAME_VOICE) return; if (f->frametype == AST_FRAME_VIDEO) return; switch(f->frametype) { case AST_FRAME_DTMF: strcpy(ftype, "DTMF"); subclass[0] = f->subclass; subclass[1] = '\0'; break; case AST_FRAME_CONTROL: strcpy(ftype, "Control"); switch(f->subclass) { case AST_CONTROL_HANGUP: strcpy(subclass, "Hangup"); break; case AST_CONTROL_RING: strcpy(subclass, "Ring"); break; case AST_CONTROL_RINGING: strcpy(subclass, "Ringing"); break; case AST_CONTROL_ANSWER: strcpy(subclass, "Answer"); break; case AST_CONTROL_BUSY: strcpy(subclass, "Busy"); break; case AST_CONTROL_TAKEOFFHOOK: strcpy(subclass, "Take Off Hook"); break; case AST_CONTROL_OFFHOOK: strcpy(subclass, "Line Off Hook"); break; case AST_CONTROL_CONGESTION: strcpy(subclass, "Congestion"); break; case AST_CONTROL_FLASH: strcpy(subclass, "Flash"); break; case AST_CONTROL_WINK: strcpy(subclass, "Wink"); break; case AST_CONTROL_OPTION: strcpy(subclass, "Option"); break; case AST_CONTROL_RADIO_KEY: strcpy(subclass, "Key Radio"); break; case AST_CONTROL_RADIO_UNKEY: strcpy(subclass, "Unkey Radio"); break; case -1: strcpy(subclass, "Stop generators"); break; default: snprintf(subclass, sizeof(subclass), "Unknown control '%d'", f->subclass); } break; case AST_FRAME_NULL: strcpy(ftype, "Null Frame"); strcpy(subclass, "N/A"); break; case AST_FRAME_IAX: /* Should never happen */ strcpy(ftype, "IAX Specific"); snprintf(subclass, sizeof(subclass), "IAX Frametype %d", f->subclass); break; case AST_FRAME_TEXT: strcpy(ftype, "Text"); strcpy(subclass, "N/A"); strncpy(moreinfo, f->data, sizeof(moreinfo) - 1); break; case AST_FRAME_IMAGE: strcpy(ftype, "Image"); snprintf(subclass, sizeof(subclass), "Image format %s\n", ast_getformatname(f->subclass)); break; case AST_FRAME_HTML: strcpy(ftype, "HTML"); switch(f->subclass) { case AST_HTML_URL: strcpy(subclass, "URL"); strncpy(moreinfo, f->data, sizeof(moreinfo) - 1); break; case AST_HTML_DATA: strcpy(subclass, "Data"); break; case AST_HTML_BEGIN: strcpy(subclass, "Begin"); break; case AST_HTML_END: strcpy(subclass, "End"); break; case AST_HTML_LDCOMPLETE: strcpy(subclass, "Load Complete"); break; case AST_HTML_NOSUPPORT: strcpy(subclass, "No Support"); break; case AST_HTML_LINKURL: strcpy(subclass, "Link URL"); strncpy(moreinfo, f->data, sizeof(moreinfo) - 1); break; case AST_HTML_UNLINK: strcpy(subclass, "Unlink"); break; case AST_HTML_LINKREJECT: strcpy(subclass, "Link Reject"); break; default: snprintf(subclass, sizeof(subclass), "Unknown HTML frame '%d'\n", f->subclass); break; } break; default: snprintf(ftype, sizeof(ftype), "Unknown Frametype '%d'", f->frametype); } if (!ast_strlen_zero(moreinfo)) ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) '%s' ] [%s]\n", term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)), term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)), f->frametype, term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)), f->subclass, term_color(cmn, moreinfo, COLOR_BRGREEN, COLOR_BLACK, sizeof(cmn)), term_color(cn, n, COLOR_YELLOW, COLOR_BLACK, sizeof(cn))); else ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) ] [%s]\n", term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)), term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)), f->frametype, term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)), f->subclass, term_color(cn, n, COLOR_YELLOW, COLOR_BLACK, sizeof(cn))); }

struct ast_frame* ast_frdup (  struct ast_frame *  fr  )

Copies a frame. Parameters: fr  frame to copy Dupliates a frame -- should only rarely be used, typically frisolate is good enough Returns a frame on success, NULL on error Definition at line 296 of file frame.c. References AST_MALLOCD_HDR, ast_frame::data, ast_frame::datalen, ast_frame::delivery, ast_frame::frametype, malloc, ast_frame::mallocd, ast_frame::next, ast_frame::offset, ast_frame::prev, ast_frame::samples, ast_frame::src, and ast_frame::subclass. Referenced by ast_queue_frame(), and ast_rtp_write(). { struct ast_frame *out; int len, srclen = 0; void *buf; /* Start with standard stuff */ len = sizeof(struct ast_frame) + AST_FRIENDLY_OFFSET + f->datalen; /* If we have a source, add space for it */ if (f->src) srclen = strlen(f->src); if (srclen > 0) len += srclen + 1; buf = malloc(len); if (!buf) return NULL; out = buf; /* Set us as having malloc'd header only, so it will eventually get freed. */ out->frametype = f->frametype; out->subclass = f->subclass; out->datalen = f->datalen; out->samples = f->samples; out->delivery = f->delivery; out->mallocd = AST_MALLOCD_HDR; out->offset = AST_FRIENDLY_OFFSET; out->data = buf + sizeof(struct ast_frame) + AST_FRIENDLY_OFFSET; if (srclen > 0) { out->src = out->data + f->datalen; /* Must have space since we allocated for it */ strcpy(out->src, f->src); } else out->src = NULL; out->prev = NULL; out->next = NULL; memcpy(out->data, f->data, out->datalen); return out; }

void ast_frfree (  struct ast_frame *  fr  )

Frees a frame. Parameters: fr  Frame to free Free a frame, and the memory it used if applicable no return. Definition at line 229 of file frame.c. References AST_MALLOCD_DATA, AST_MALLOCD_HDR, AST_MALLOCD_SRC, ast_mutex_lock, ast_mutex_unlock, ast_frame::data, free, ast_frame::mallocd, ast_frame::next, ast_frame::offset, ast_frame::prev, and ast_frame::src. Referenced by __ast_request_and_dial(), ast_app_getvoice(), ast_channel_bridge(), ast_channel_free(), ast_dsp_process(), ast_play_and_prepend(), ast_play_and_record(), ast_queue_frame(), ast_read(), ast_recvchar(), ast_rtp_bridge(), ast_safe_sleep(), ast_safe_sleep_conditional(), ast_send_image(), ast_tonepair(), ast_translate(), ast_waitfordigit(), ast_waitfordigit_full(), ast_waitstream(), ast_waitstream_fr(), ast_waitstream_full(), and ast_write(). { if (fr->mallocd & AST_MALLOCD_DATA) { if (fr->data) free(fr->data - fr->offset); } if (fr->mallocd & AST_MALLOCD_SRC) { if (fr->src) free(fr->src); } if (fr->mallocd & AST_MALLOCD_HDR) { #ifdef TRACE_FRAMES headers--; ast_mutex_lock(&framelock); if (fr->next) fr->next->prev = fr->prev; if (fr->prev) fr->prev->next = fr->next; else headerlist = fr->next; ast_mutex_unlock(&framelock); #endif free(fr); } }

struct ast_frame* ast_frisolate (  struct ast_frame *  fr  )

Copies a frame. Parameters: fr  frame to act upon Take a frame, and if it's not been malloc'd, make a malloc'd copy and if the data hasn't been malloced then make the data malloc'd. If you need to store frames, say for queueing, then you should call this function. Returns a frame on success, NULL on error Definition at line 255 of file frame.c. References AST_FRIENDLY_OFFSET, ast_log(), AST_MALLOCD_DATA, AST_MALLOCD_HDR, AST_MALLOCD_SRC, ast_frame::data, ast_frame::datalen, ast_frame::frametype, free, LOG_WARNING, malloc, ast_frame::mallocd, ast_frame::offset, ast_frame::samples, ast_frame::src, strdup, and ast_frame::subclass. Referenced by ast_fr_fdread(). { struct ast_frame *out; if (!(fr->mallocd & AST_MALLOCD_HDR)) { /* Allocate a new header if needed */ out = ast_frame_header_new(); if (!out) { ast_log(LOG_WARNING, "Out of memory\n"); return NULL; } out->frametype = fr->frametype; out->subclass = fr->subclass; out->datalen = 0; out->samples = fr->samples; out->offset = 0; out->src = NULL; out->data = NULL; } else { out = fr; } if (!(fr->mallocd & AST_MALLOCD_SRC)) { if (fr->src) out->src = strdup(fr->src); } else out->src = fr->src; if (!(fr->mallocd & AST_MALLOCD_DATA)) { out->data = malloc(fr->datalen + AST_FRIENDLY_OFFSET); if (!out->data) { free(out); ast_log(LOG_WARNING, "Out of memory\n"); return NULL; } out->data += AST_FRIENDLY_OFFSET; out->offset = AST_FRIENDLY_OFFSET; out->datalen = fr->datalen; memcpy(out->data, fr->data, fr->datalen); } out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA; return out; }

struct ast_format_list* ast_get_format_list (  size_t *  size  )

Definition at line 447 of file frame.c. { *size = (sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list)); return AST_FORMAT_LIST; }

struct ast_format_list* ast_get_format_list_index (  int  index  )

Definition at line 443 of file frame.c. { return &AST_FORMAT_LIST[index]; }

int ast_getformatbyname (  char *  name  )

Parameters: name  string of format Gets a format from a name. This returns the form of the format in binary on success, 0 on error. Definition at line 511 of file frame.c. Referenced by ast_parse_allow_disallow(). { int x = 0, all = 0, format = 0; all = strcasecmp(name, "all") ? 0 : 1; for (x = 0 ; x < sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list) ; x++) { if(AST_FORMAT_LIST[x].visible && (all || !strcasecmp(AST_FORMAT_LIST[x].name,name) || !strcasecmp(AST_FORMAT_LIST[x].name,ast_expand_codec_alias(name)))) { format |= AST_FORMAT_LIST[x].bits; if(!all) break; } } return format; }

char* ast_getformatname (  int  format  )

Get the name of a format. Parameters: format  id of format Returns: A static string containing the name of the format or "UNKN" if unknown. Definition at line 452 of file frame.c. Referenced by ast_codec_pref_string(), ast_dsp_process(), ast_frame_dump(), ast_play_and_prepend(), ast_play_and_record(), ast_read(), ast_register_translator(), ast_rtp_read(), ast_rtp_write(), ast_set_read_format(), ast_set_write_format(), ast_streamfile(), ast_translator_build_path(), ast_unregister_translator(), and ast_writestream(). { int x = 0; char *ret = "unknown"; for (x = 0 ; x < sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list) ; x++) { if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == format) { ret = AST_FORMAT_LIST[x].name; break; } } return ret; }

char* ast_getformatname_multiple (  char *  buf, size_t  size, int  format )

Get the names of a set of formats. Parameters: buf  a buffer for the output string n  size of buf (bytes) format  the format (combined IDs of codecs) Prints a list of readable codec names corresponding to "format". ex: for format=AST_FORMAT_GSM|AST_FORMAT_SPEEX|AST_FORMAT_ILBC it will return "0x602 (GSM|SPEEX|ILBC)" Returns: The return value is buf. Definition at line 465 of file frame.c. References ast_format_list::bits, ast_format_list::name, and ast_format_list::visible. { int x = 0; unsigned len; char *end = buf; char *start = buf; if (!size) return buf; snprintf(end, size, "0x%x (", format); len = strlen(end); end += len; size -= len; start = end; for (x = 0 ; x < sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list) ; x++) { if (AST_FORMAT_LIST[x].visible && (AST_FORMAT_LIST[x].bits & format)) { snprintf(end, size,"%s|",AST_FORMAT_LIST[x].name); len = strlen(end); end += len; size -= len; } } if (start == end) snprintf(start, size, "nothing)"); else if (size > 1) *(end -1) = ')'; return buf; }

void ast_memcpy_byteswap (  void *  dst, void *  src, int  samples )

Definition at line 405 of file frame.c. Referenced by __ast_smoother_feed(). { int i; unsigned short *dst_s = dst; unsigned short *src_s = src; for (i=0; i<samples; i++) dst_s[i] = (src_s[i]<<8)|(src_s[i]>>8); }

void ast_parse_allow_disallow (  struct ast_codec_pref *  pref, int *  mask, char *  list, int  allowing )

Definition at line 974 of file frame.c. References ast_codec_pref_append(), ast_codec_pref_remove(), ast_getformatbyname(), ast_log(), and LOG_WARNING. { int format_i = 0; char *next_format = NULL, *last_format = NULL; last_format = ast_strdupa(list); while(last_format) { if((next_format = strchr(last_format, ','))) { *next_format = '\0'; next_format++; } if ((format_i = ast_getformatbyname(last_format)) > 0) { if (mask) { if (allowing) (*mask) |= format_i; else (*mask) &= ~format_i; } /* can't consider 'all' a prefered codec*/ if(pref && strcasecmp(last_format, "all")) { if(allowing) ast_codec_pref_append(pref, format_i); else ast_codec_pref_remove(pref, format_i); } else if(!allowing) /* disallow all must clear your prefs or it makes no sense */ memset(pref, 0, sizeof(struct ast_codec_pref)); } else ast_log(LOG_WARNING, "Cannot %s unknown format '%s'\n", allowing ? "allow" : "disallow", last_format); last_format = next_format; } }

void ast_smoother_free (  struct ast_smoother *  s  )

Definition at line 198 of file frame.c. References free. Referenced by ast_rtp_destroy(), and ast_rtp_write(). { free(s); }

int ast_smoother_get_flags (  struct ast_smoother *  s  )

Definition at line 76 of file frame.c. References ast_smoother::flags. { return s->flags; }

struct ast_smoother* ast_smoother_new (  int  size  )

Definition at line 65 of file frame.c. References ast_smoother_reset(), malloc, and s. Referenced by ast_rtp_write(). { struct ast_smoother *s; if (size < 1) return NULL; s = malloc(sizeof(struct ast_smoother)); if (s) ast_smoother_reset(s, size); return s; }

struct ast_frame* ast_smoother_read (  struct ast_smoother *  s  )

Definition at line 144 of file frame.c. References AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), AST_SMOOTHER_FLAG_G729, ast_frame::data, ast_smoother::data, ast_frame::datalen, ast_frame::delivery, ast_smoother::delivery, ast_smoother::f, ast_smoother::flags, ast_smoother::format, ast_smoother::framedata, ast_frame::frametype, ast_smoother::len, LOG_WARNING, ast_frame::offset, ast_smoother::opt, ast_frame::samples, ast_smoother::samplesperbyte, ast_smoother::size, and ast_frame::subclass. Referenced by ast_rtp_write(). { struct ast_frame *opt; int len; /* IF we have an optimization frame, send it */ if (s->opt) { if (s->opt->offset < AST_FRIENDLY_OFFSET) ast_log(LOG_WARNING, "Returning a frame of inappropriate offset (%d).", s->opt->offset); opt = s->opt; s->opt = NULL; return opt; } /* Make sure we have enough data */ if (s->len < s->size) { /* Or, if this is a G.729 frame with VAD on it, send it immediately anyway */ if (!((s->flags & AST_SMOOTHER_FLAG_G729) && (s->size % 10))) return NULL; } len = s->size; if (len > s->len) len = s->len; /* Make frame */ s->f.frametype = AST_FRAME_VOICE; s->f.subclass = s->format; s->f.data = s->framedata + AST_FRIENDLY_OFFSET; s->f.offset = AST_FRIENDLY_OFFSET; s->f.datalen = len; /* Samples will be improper given VAD, but with VAD the concept really doesn't even exist */ s->f.samples = len * s->samplesperbyte; s->f.delivery = s->delivery; /* Fill Data */ memcpy(s->f.data, s->data, len); s->len -= len; /* Move remaining data to the front if applicable */ if (s->len) { /* In principle this should all be fine because if we are sending G.729 VAD, the next timestamp will take over anyawy */ memmove(s->data, s->data + len, s->len); if (s->delivery.tv_sec || s->delivery.tv_usec) { /* If we have delivery time, increment it, otherwise, leave it at 0 */ s->delivery.tv_sec += (len * s->samplesperbyte) / 8000.0; s->delivery.tv_usec += (((int)(len * s->samplesperbyte)) % 8000) * 125; if (s->delivery.tv_usec > 1000000) { s->delivery.tv_usec -= 1000000; s->delivery.tv_sec += 1; } } } /* Return frame */ return &s->f; }

void ast_smoother_reset (  struct ast_smoother *  s, int  size )

Definition at line 59 of file frame.c. References ast_smoother::size. Referenced by ast_smoother_new(). { memset(s, 0, sizeof(struct ast_smoother)); s->size = size; }

void ast_smoother_set_flags (  struct ast_smoother *  s, int  flags )

Definition at line 81 of file frame.c. References ast_smoother::flags. Referenced by ast_rtp_write(). { s->flags = flags; }

int init_framer (  void   )

Definition at line 813 of file frame.c. References ast_cli_register(). Referenced by main(). { #ifdef TRACE_FRAMES ast_cli_register(&cli_frame_stats); #endif ast_cli_register(&cli_show_codecs); ast_cli_register(&cli_show_codecs_audio); ast_cli_register(&cli_show_codecs_video); ast_cli_register(&cli_show_codecs_image); ast_cli_register(&cli_show_codec_n); return 0; }

---

Variable Documentation

struct ast_cli_entry cli_show_codec_n

Initial value: { { "show", "codec", NULL }, show_codec_n, "Shows a specific codec", frame_show_codec_n_usage } Definition at line 624 of file frame.c.

struct ast_cli_entry cli_show_codecs

Initial value: { { "show", "codecs", NULL }, show_codecs, "Shows codecs", frame_show_codecs_usage } Definition at line 589 of file frame.c.

struct ast_cli_entry cli_show_codecs_audio

Initial value: { { "show", "audio", "codecs", NULL }, show_codecs, "Shows audio codecs", frame_show_codecs_usage } Definition at line 591 of file frame.c.

struct ast_cli_entry cli_show_codecs_image

Initial value: { { "show", "image", "codecs", NULL }, show_codecs, "Shows image codecs", frame_show_codecs_usage } Definition at line 595 of file frame.c.

struct ast_cli_entry cli_show_codecs_video

Initial value: { { "show", "video", "codecs", NULL }, show_codecs, "Shows video codecs", frame_show_codecs_usage } Definition at line 593 of file frame.c.

---