Sat Aug 6 00:39:56 2011

Asterisk developer's documentation


frame.c File Reference

Frame and codec manipulation routines. More...

#include "asterisk.h"
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#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 "asterisk/threadstorage.h"
#include "asterisk/linkedlists.h"
#include "asterisk/translate.h"
#include "asterisk/dsp.h"
#include "asterisk/file.h"

Go to the source code of this file.

Data Structures

struct  ast_codec_alias_table
struct  ast_frame_cache
struct  ast_frames
 This is just so ast_frames, a list head struct for holding a list of ast_frame structures, is defined. More...
struct  ast_smoother

Defines

#define FRAME_CACHE_MAX_SIZE   10
 Maximum ast_frame cache size.
#define SMOOTHER_SIZE   8000
#define TYPE_MASK   0x3

Enumerations

enum  frame_type { TYPE_HIGH, TYPE_LOW, TYPE_SILENCE, TYPE_DONTSEND }

Functions

int __ast_smoother_feed (struct ast_smoother *s, struct ast_frame *f, int swap)
static void __frame_free (struct ast_frame *fr, int cache)
char * ast_codec2str (int codec)
 Get a name from a format Gets a name from a format.
int ast_codec_choose (struct ast_codec_pref *pref, int formats, int find_best)
 Select the best audio format according to preference list from supplied options. If "find_best" is non-zero then if nothing is found, the "Best" format of the format list is selected, otherwise 0 is returned.
int ast_codec_get_len (int format, int samples)
 Returns the number of bytes for the number of samples of the given format.
int ast_codec_get_samples (struct ast_frame *f)
 Returns the number of samples contained in the frame.
int ast_codec_pref_append (struct ast_codec_pref *pref, int format)
 Append a audio codec to a preference list, removing it first if it was already there.
void ast_codec_pref_convert (struct ast_codec_pref *pref, char *buf, size_t size, int right)
 Shift an audio codec preference list up or down 65 bytes so that it becomes an ASCII string.
ast_format_list ast_codec_pref_getsize (struct ast_codec_pref *pref, int format)
 Get packet size for codec.
int ast_codec_pref_index (struct ast_codec_pref *pref, int index)
 Codec located at a particular place in the preference index See Audio Codec Preferences.
void ast_codec_pref_prepend (struct ast_codec_pref *pref, int format, int only_if_existing)
 Prepend an audio codec to a preference list, removing it first if it was already there.
void ast_codec_pref_remove (struct ast_codec_pref *pref, int format)
 Remove audio a codec from a preference list.
int ast_codec_pref_setsize (struct ast_codec_pref *pref, int format, int framems)
 Set packet size for codec.
int ast_codec_pref_string (struct ast_codec_pref *pref, char *buf, size_t size)
 Dump audio codec preference list into a string.
static const char * ast_expand_codec_alias (const char *in)
int ast_frame_adjust_volume (struct ast_frame *f, int adjustment)
 Adjusts the volume of the audio samples contained in a frame.
void ast_frame_dump (const char *name, struct ast_frame *f, char *prefix)
void ast_frame_free (struct ast_frame *frame, int cache)
 Requests a frame to be allocated Frees a frame or list of frames.
static struct ast_frameast_frame_header_new (void)
int ast_frame_slinear_sum (struct ast_frame *f1, struct ast_frame *f2)
 Sums two frames of audio samples.
ast_frameast_frdup (const struct ast_frame *f)
 Copies a frame.
ast_frameast_frisolate (struct ast_frame *fr)
 Makes a frame independent of any static storage.
ast_format_listast_get_format_list (size_t *size)
ast_format_listast_get_format_list_index (int index)
int ast_getformatbyname (const char *name)
 Gets a format from a name.
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.
void ast_parse_allow_disallow (struct ast_codec_pref *pref, int *mask, const char *list, int allowing)
 Parse an "allow" or "deny" line in a channel or device configuration and update the capabilities mask and pref if provided. Video codecs are not added to codec preference lists, since we can not transcode.
void ast_smoother_free (struct ast_smoother *s)
int ast_smoother_get_flags (struct ast_smoother *s)
ast_smootherast_smoother_new (int size)
ast_frameast_smoother_read (struct ast_smoother *s)
void ast_smoother_reconfigure (struct ast_smoother *s, int bytes)
 Reconfigure an existing smoother to output a different number of bytes per frame.
void ast_smoother_reset (struct ast_smoother *s, int bytes)
void ast_smoother_set_flags (struct ast_smoother *s, int flags)
int ast_smoother_test_flag (struct ast_smoother *s, int flag)
void ast_swapcopy_samples (void *dst, const void *src, int samples)
static void frame_cache_cleanup (void *data)
static void frame_cache_init (void)
 A per-thread cache of frame headers.
static int g723_len (unsigned char buf)
static int g723_samples (unsigned char *buf, int maxlen)
static unsigned char get_n_bits_at (unsigned char *data, int n, int bit)
int init_framer (void)
static int show_codec_n (int fd, int argc, char *argv[])
static int show_codec_n_deprecated (int fd, int argc, char *argv[])
static int show_codecs (int fd, int argc, char *argv[])
static int show_codecs_deprecated (int fd, int argc, char *argv[])
static int smoother_frame_feed (struct ast_smoother *s, struct ast_frame *f, int swap)
static int speex_get_wb_sz_at (unsigned char *data, int len, int bit)
static int speex_samples (unsigned char *data, int len)

Variables

static struct ast_format_list AST_FORMAT_LIST []
 Definition of supported media formats (codecs).
ast_frame ast_null_frame = { AST_FRAME_NULL, }
static struct ast_cli_entry cli_show_audio_codecs
static struct ast_cli_entry cli_show_codec
static struct ast_cli_entry cli_show_codecs
static struct ast_cli_entry cli_show_image_codecs
static struct ast_cli_entry cli_show_video_codecs
static struct ast_threadstorage frame_cache = { .once = PTHREAD_ONCE_INIT , .key_init = frame_cache_init , }
static char frame_show_codec_n_usage []
static char frame_show_codecs_usage []
static struct ast_cli_entry my_clis []


Detailed Description

Frame and codec manipulation routines.

Author:
Mark Spencer <markster@digium.com>

Definition in file frame.c.


Define Documentation

#define FRAME_CACHE_MAX_SIZE   10

Maximum ast_frame cache size.

In most cases where the frame header cache will be useful, the size of the cache will stay very small. However, it is not always the case that the same thread that allocates the frame will be the one freeing them, so sometimes a thread will never have any frames in its cache, or the cache will never be pulled from. For the latter case, we limit the maximum size.

Definition at line 65 of file frame.c.

Referenced by __frame_free(), and iax_frame_free().

#define SMOOTHER_SIZE   8000

Definition at line 77 of file frame.c.

Referenced by __ast_smoother_feed().

#define TYPE_MASK   0x3

Definition at line 86 of file frame.c.

Referenced by g723_len().


Enumeration Type Documentation

enum frame_type

Enumerator:
TYPE_HIGH 
TYPE_LOW 
TYPE_SILENCE 
TYPE_DONTSEND 

Definition at line 79 of file frame.c.

00079                 {
00080    TYPE_HIGH,     /* 0x0 */
00081    TYPE_LOW,      /* 0x1 */
00082    TYPE_SILENCE,  /* 0x2 */
00083    TYPE_DONTSEND  /* 0x3 */
00084 };


Function Documentation

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

Definition at line 211 of file frame.c.

References AST_FRAME_VOICE, ast_log(), AST_MIN_OFFSET, AST_SMOOTHER_FLAG_G729, ast_swapcopy_samples(), f, LOG_WARNING, s, smoother_frame_feed(), and SMOOTHER_SIZE.

00212 {
00213    if (f->frametype != AST_FRAME_VOICE) {
00214       ast_log(LOG_WARNING, "Huh?  Can't smooth a non-voice frame!\n");
00215       return -1;
00216    }
00217    if (!s->format) {
00218       s->format = f->subclass;
00219       s->samplesperbyte = (float)f->samples / (float)f->datalen;
00220    } else if (s->format != f->subclass) {
00221       ast_log(LOG_WARNING, "Smoother was working on %d format frames, now trying to feed %d?\n", s->format, f->subclass);
00222       return -1;
00223    }
00224    if (s->len + f->datalen > SMOOTHER_SIZE) {
00225       ast_log(LOG_WARNING, "Out of smoother space\n");
00226       return -1;
00227    }
00228    if (((f->datalen == s->size) ||
00229         ((f->datalen < 10) && (s->flags & AST_SMOOTHER_FLAG_G729))) &&
00230        !s->opt &&
00231        !s->len &&
00232        (f->offset >= AST_MIN_OFFSET)) {
00233       /* Optimize by sending the frame we just got
00234          on the next read, thus eliminating the douple
00235          copy */
00236       if (swap)
00237          ast_swapcopy_samples(f->data, f->data, f->samples);
00238       s->opt = f;
00239       s->opt_needs_swap = swap ? 1 : 0;
00240       return 0;
00241    }
00242 
00243    return smoother_frame_feed(s, f, swap);
00244 }

static void __frame_free ( struct ast_frame fr,
int  cache 
) [static]

Definition at line 343 of file frame.c.

References AST_LIST_INSERT_HEAD, AST_MALLOCD_DATA, AST_MALLOCD_HDR, AST_MALLOCD_SRC, ast_threadstorage_get(), ast_frame::data, frame_cache, FRAME_CACHE_MAX_SIZE, frames, free, ast_frame::mallocd, ast_frame::offset, and ast_frame::src.

Referenced by ast_frame_free().

00344 {
00345    if (!fr->mallocd)
00346       return;
00347 
00348 #if !defined(LOW_MEMORY)
00349    if (cache && fr->mallocd == AST_MALLOCD_HDR) {
00350       /* Cool, only the header is malloc'd, let's just cache those for now 
00351        * to keep things simple... */
00352       struct ast_frame_cache *frames;
00353 
00354       if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames))) &&
00355           (frames->size < FRAME_CACHE_MAX_SIZE)) {
00356          AST_LIST_INSERT_HEAD(&frames->list, fr, frame_list);
00357          frames->size++;
00358          return;
00359       }
00360    }
00361 #endif
00362    
00363    if (fr->mallocd & AST_MALLOCD_DATA) {
00364       if (fr->data) 
00365          free(fr->data - fr->offset);
00366    }
00367    if (fr->mallocd & AST_MALLOCD_SRC) {
00368       if (fr->src)
00369          free((void *) fr->src);
00370    }
00371    if (fr->mallocd & AST_MALLOCD_HDR) {
00372       free(fr);
00373    }
00374 }

char* ast_codec2str ( int  codec  ) 

Get a name from a format Gets a name from a format.

Parameters:
codec codec number (1,2,4,8,16,etc.)
Returns:
This returns a static string identifying the format on success, 0 on error.

Definition at line 645 of file frame.c.

References AST_FORMAT_LIST, and desc.

Referenced by moh_alloc(), show_codec_n(), show_codec_n_deprecated(), show_codecs(), and show_codecs_deprecated().

00646 {
00647    int x;
00648    char *ret = "unknown";
00649    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
00650       if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == codec) {
00651          ret = AST_FORMAT_LIST[x].desc;
00652          break;
00653       }
00654    }
00655    return ret;
00656 }

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

Select the best audio format according to preference list from supplied options. If "find_best" is non-zero then if nothing is found, the "Best" format of the format list is selected, otherwise 0 is returned.

Definition at line 1284 of file frame.c.

References ast_best_codec(), AST_FORMAT_AUDIO_MASK, AST_FORMAT_LIST, ast_log(), ast_format_list::bits, LOG_DEBUG, option_debug, and ast_codec_pref::order.

Referenced by __oh323_new(), gtalk_new(), process_sdp(), sip_new(), and socket_process().

01285 {
01286    int x, ret = 0, slot;
01287 
01288    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01289       slot = pref->order[x];
01290 
01291       if (!slot)
01292          break;
01293       if (formats & AST_FORMAT_LIST[slot-1].bits) {
01294          ret = AST_FORMAT_LIST[slot-1].bits;
01295          break;
01296       }
01297    }
01298    if(ret & AST_FORMAT_AUDIO_MASK)
01299       return ret;
01300 
01301    if (option_debug > 3)
01302       ast_log(LOG_DEBUG, "Could not find preferred codec - %s\n", find_best ? "Going for the best codec" : "Returning zero codec");
01303 
01304       return find_best ? ast_best_codec(formats) : 0;
01305 }

int ast_codec_get_len ( int  format,
int  samples 
)

Returns the number of bytes for the number of samples of the given format.

Definition at line 1545 of file frame.c.

References AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_G722, AST_FORMAT_G726, AST_FORMAT_G726_AAL2, AST_FORMAT_G729A, AST_FORMAT_GSM, AST_FORMAT_ILBC, AST_FORMAT_SLINEAR, AST_FORMAT_ULAW, ast_getformatname(), ast_log(), len(), and LOG_WARNING.

Referenced by moh_generate(), and monmp3thread().

01546 {
01547    int len = 0;
01548 
01549    /* XXX Still need speex, g723, and lpc10 XXX */ 
01550    switch(format) {
01551    case AST_FORMAT_ILBC:
01552       len = (samples / 240) * 50;
01553       break;
01554    case AST_FORMAT_GSM:
01555       len = (samples / 160) * 33;
01556       break;
01557    case AST_FORMAT_G729A:
01558       len = samples / 8;
01559       break;
01560    case AST_FORMAT_SLINEAR:
01561       len = samples * 2;
01562       break;
01563    case AST_FORMAT_ULAW:
01564    case AST_FORMAT_ALAW:
01565       len = samples;
01566       break;
01567    case AST_FORMAT_G722:
01568    case AST_FORMAT_ADPCM:
01569    case AST_FORMAT_G726:
01570    case AST_FORMAT_G726_AAL2:
01571       len = samples / 2;
01572       break;
01573    default:
01574       ast_log(LOG_WARNING, "Unable to calculate sample length for format %s\n", ast_getformatname(format));
01575    }
01576 
01577    return len;
01578 }

int ast_codec_get_samples ( struct ast_frame f  ) 

Returns the number of samples contained in the frame.

Definition at line 1502 of file frame.c.

References AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_G722, AST_FORMAT_G723_1, AST_FORMAT_G726, AST_FORMAT_G726_AAL2, AST_FORMAT_G729A, AST_FORMAT_GSM, AST_FORMAT_ILBC, AST_FORMAT_LPC10, AST_FORMAT_SLINEAR, AST_FORMAT_SPEEX, AST_FORMAT_ULAW, ast_getformatname(), ast_log(), f, g723_samples(), LOG_WARNING, and speex_samples().

Referenced by ast_rtp_read(), isAnsweringMachine(), moh_generate(), schedule_delivery(), and socket_process().

01503 {
01504    int samples=0;
01505    switch(f->subclass) {
01506    case AST_FORMAT_SPEEX:
01507       samples = speex_samples(f->data, f->datalen);
01508       break;
01509    case AST_FORMAT_G723_1:
01510                 samples = g723_samples(f->data, f->datalen);
01511       break;
01512    case AST_FORMAT_ILBC:
01513       samples = 240 * (f->datalen / 50);
01514       break;
01515    case AST_FORMAT_GSM:
01516       samples = 160 * (f->datalen / 33);
01517       break;
01518    case AST_FORMAT_G729A:
01519       samples = f->datalen * 8;
01520       break;
01521    case AST_FORMAT_SLINEAR:
01522       samples = f->datalen / 2;
01523       break;
01524    case AST_FORMAT_LPC10:
01525                 /* assumes that the RTP packet contains one LPC10 frame */
01526       samples = 22 * 8;
01527       samples += (((char *)(f->data))[7] & 0x1) * 8;
01528       break;
01529    case AST_FORMAT_ULAW:
01530    case AST_FORMAT_ALAW:
01531       samples = f->datalen;
01532       break;
01533    case AST_FORMAT_G722:
01534    case AST_FORMAT_ADPCM:
01535    case AST_FORMAT_G726:
01536    case AST_FORMAT_G726_AAL2:
01537       samples = f->datalen * 2;
01538       break;
01539    default:
01540       ast_log(LOG_WARNING, "Unable to calculate samples for format %s\n", ast_getformatname(f->subclass));
01541    }
01542    return samples;
01543 }

int ast_codec_pref_append ( struct ast_codec_pref pref,
int  format 
)

Append a audio codec to a preference list, removing it first if it was already there.

Definition at line 1143 of file frame.c.

References ast_codec_pref_remove(), AST_FORMAT_LIST, and ast_codec_pref::order.

Referenced by ast_parse_allow_disallow().

01144 {
01145    int x, newindex = 0;
01146 
01147    ast_codec_pref_remove(pref, format);
01148 
01149    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01150       if(AST_FORMAT_LIST[x].bits == format) {
01151          newindex = x + 1;
01152          break;
01153       }
01154    }
01155 
01156    if(newindex) {
01157       for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01158          if(!pref->order[x]) {
01159             pref->order[x] = newindex;
01160             break;
01161          }
01162       }
01163    }
01164 
01165    return x;
01166 }

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

Shift an audio codec preference list up or down 65 bytes so that it becomes an ASCII string.

Note:
Due to a misunderstanding in how codec preferences are stored, this list starts at 'B', not 'A'. For backwards compatibility reasons, this cannot change.
Parameters:
pref A codec preference list structure
buf A string denoting codec preference, appropriate for use in line transmission
size Size of buf
right Boolean: if 0, convert from buf to pref; if 1, convert from pref to buf.

Definition at line 1045 of file frame.c.

References ast_codec_pref::order.

Referenced by check_access(), create_addr(), dump_prefs(), and socket_process().

01046 {
01047    int x, differential = (int) 'A', mem;
01048    char *from, *to;
01049 
01050    if(right) {
01051       from = pref->order;
01052       to = buf;
01053       mem = size;
01054    } else {
01055       to = pref->order;
01056       from = buf;
01057       mem = 32;
01058    }
01059 
01060    memset(to, 0, mem);
01061    for (x = 0; x < 32 ; x++) {
01062       if(!from[x])
01063          break;
01064       to[x] = right ? (from[x] + differential) : (from[x] - differential);
01065    }
01066 }

struct ast_format_list ast_codec_pref_getsize ( struct ast_codec_pref pref,
int  format 
)

Get packet size for codec.

Definition at line 1245 of file frame.c.

References AST_FORMAT_LIST, ast_format_list::bits, and format.

Referenced by add_codec_to_sdp(), ast_rtp_bridge(), ast_rtp_codec_setpref(), ast_rtp_write(), handle_open_receive_channel_ack_message(), and transmit_connect().

01246 {
01247    int x, index = -1, framems = 0;
01248    struct ast_format_list fmt = {0};
01249 
01250    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01251       if(AST_FORMAT_LIST[x].bits == format) {
01252          fmt = AST_FORMAT_LIST[x];
01253          index = x;
01254          break;
01255       }
01256    }
01257 
01258    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01259       if(pref->order[x] == (index + 1)) {
01260          framems = pref->framing[x];
01261          break;
01262       }
01263    }
01264 
01265    /* size validation */
01266    if(!framems)
01267       framems = AST_FORMAT_LIST[index].def_ms;
01268 
01269    if(AST_FORMAT_LIST[index].inc_ms && framems % AST_FORMAT_LIST[index].inc_ms) /* avoid division by zero */
01270       framems -= framems % AST_FORMAT_LIST[index].inc_ms;
01271 
01272    if(framems < AST_FORMAT_LIST[index].min_ms)
01273       framems = AST_FORMAT_LIST[index].min_ms;
01274 
01275    if(framems > AST_FORMAT_LIST[index].max_ms)
01276       framems = AST_FORMAT_LIST[index].max_ms;
01277 
01278    fmt.cur_ms = framems;
01279 
01280    return fmt;
01281 }

int ast_codec_pref_index ( struct ast_codec_pref pref,
int  index 
)

Codec located at a particular place in the preference index See Audio Codec Preferences.

Definition at line 1103 of file frame.c.

References AST_FORMAT_LIST, ast_format_list::bits, and ast_codec_pref::order.

Referenced by _sip_show_peer(), add_sdp(), ast_codec_pref_string(), function_iaxpeer(), function_sippeer(), gtalk_invite(), iax2_show_peer(), print_codec_to_cli(), and socket_process().

01104 {
01105    int slot = 0;
01106 
01107    
01108    if((index >= 0) && (index < sizeof(pref->order))) {
01109       slot = pref->order[index];
01110    }
01111 
01112    return slot ? AST_FORMAT_LIST[slot-1].bits : 0;
01113 }

void ast_codec_pref_prepend ( struct ast_codec_pref pref,
int  format,
int  only_if_existing 
)

Prepend an audio codec to a preference list, removing it first if it was already there.

Definition at line 1169 of file frame.c.

References ARRAY_LEN, AST_FORMAT_LIST, ast_codec_pref::framing, and ast_codec_pref::order.

Referenced by create_addr().

01170 {
01171    int x, newindex = 0;
01172 
01173    /* First step is to get the codecs "index number" */
01174    for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
01175       if (AST_FORMAT_LIST[x].bits == format) {
01176          newindex = x + 1;
01177          break;
01178       }
01179    }
01180    /* Done if its unknown */
01181    if (!newindex)
01182       return;
01183 
01184    /* Now find any existing occurrence, or the end */
01185    for (x = 0; x < 32; x++) {
01186       if (!pref->order[x] || pref->order[x] == newindex)
01187          break;
01188    }
01189 
01190    if (only_if_existing && !pref->order[x])
01191       return;
01192 
01193    /* Move down to make space to insert - either all the way to the end,
01194       or as far as the existing location (which will be overwritten) */
01195    for (; x > 0; x--) {
01196       pref->order[x] = pref->order[x - 1];
01197       pref->framing[x] = pref->framing[x - 1];
01198    }
01199 
01200    /* And insert the new entry */
01201    pref->order[0] = newindex;
01202    pref->framing[0] = 0; /* ? */
01203 }

void ast_codec_pref_remove ( struct ast_codec_pref pref,
int  format 
)

Remove audio a codec from a preference list.

Definition at line 1116 of file frame.c.

References AST_FORMAT_LIST, and ast_codec_pref::order.

Referenced by ast_codec_pref_append(), and ast_parse_allow_disallow().

01117 {
01118    struct ast_codec_pref oldorder;
01119    int x, y = 0;
01120    int slot;
01121    int size;
01122 
01123    if(!pref->order[0])
01124       return;
01125 
01126    memcpy(&oldorder, pref, sizeof(oldorder));
01127    memset(pref, 0, sizeof(*pref));
01128 
01129    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01130       slot = oldorder.order[x];
01131       size = oldorder.framing[x];
01132       if(! slot)
01133          break;
01134       if(AST_FORMAT_LIST[slot-1].bits != format) {
01135          pref->order[y] = slot;
01136          pref->framing[y++] = size;
01137       }
01138    }
01139    
01140 }

int ast_codec_pref_setsize ( struct ast_codec_pref pref,
int  format,
int  framems 
)

Set packet size for codec.

Definition at line 1206 of file frame.c.

References AST_FORMAT_LIST, ast_codec_pref::framing, and ast_codec_pref::order.

Referenced by ast_parse_allow_disallow(), and process_sdp_a_audio().

01207 {
01208    int x, index = -1;
01209 
01210    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01211       if(AST_FORMAT_LIST[x].bits == format) {
01212          index = x;
01213          break;
01214       }
01215    }
01216 
01217    if(index < 0)
01218       return -1;
01219 
01220    /* size validation */
01221    if(!framems)
01222       framems = AST_FORMAT_LIST[index].def_ms;
01223 
01224    if(AST_FORMAT_LIST[index].inc_ms && framems % AST_FORMAT_LIST[index].inc_ms) /* avoid division by zero */
01225       framems -= framems % AST_FORMAT_LIST[index].inc_ms;
01226 
01227    if(framems < AST_FORMAT_LIST[index].min_ms)
01228       framems = AST_FORMAT_LIST[index].min_ms;
01229 
01230    if(framems > AST_FORMAT_LIST[index].max_ms)
01231       framems = AST_FORMAT_LIST[index].max_ms;
01232 
01233 
01234    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
01235       if(pref->order[x] == (index + 1)) {
01236          pref->framing[x] = framems;
01237          break;
01238       }
01239    }
01240 
01241    return x;
01242 }

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

Dump audio codec preference list into a string.

Definition at line 1068 of file frame.c.

References ast_codec_pref_index(), and ast_getformatname().

Referenced by dump_prefs(), and socket_process().

01069 {
01070    int x, codec; 
01071    size_t total_len, slen;
01072    char *formatname;
01073    
01074    memset(buf,0,size);
01075    total_len = size;
01076    buf[0] = '(';
01077    total_len--;
01078    for(x = 0; x < 32 ; x++) {
01079       if(total_len <= 0)
01080          break;
01081       if(!(codec = ast_codec_pref_index(pref,x)))
01082          break;
01083       if((formatname = ast_getformatname(codec))) {
01084          slen = strlen(formatname);
01085          if(slen > total_len)
01086             break;
01087          strncat(buf, formatname, total_len - 1); /* safe */
01088          total_len -= slen;
01089       }
01090       if(total_len && x < 31 && ast_codec_pref_index(pref , x + 1)) {
01091          strncat(buf, "|", total_len - 1); /* safe */
01092          total_len--;
01093       }
01094    }
01095    if(total_len) {
01096       strncat(buf, ")", total_len - 1); /* safe */
01097       total_len--;
01098    }
01099 
01100    return size - total_len;
01101 }

static const char* ast_expand_codec_alias ( const char *  in  )  [static]

Definition at line 616 of file frame.c.

Referenced by ast_getformatbyname().

00617 {
00618    int x;
00619 
00620    for (x = 0; x < sizeof(ast_codec_alias_table) / sizeof(ast_codec_alias_table[0]); x++) {
00621       if(!strcmp(in,ast_codec_alias_table[x].alias))
00622          return ast_codec_alias_table[x].realname;
00623    }
00624    return in;
00625 }

int ast_frame_adjust_volume ( struct ast_frame f,
int  adjustment 
)

Adjusts the volume of the audio samples contained in a frame.

Parameters:
f The frame containing the samples (must be AST_FRAME_VOICE and AST_FORMAT_SLINEAR)
adjustment The number of dB to adjust up or down.
Returns:
0 for success, non-zero for an error

Definition at line 1580 of file frame.c.

References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_slinear_saturated_divide(), ast_slinear_saturated_multiply(), and f.

Referenced by audiohook_read_frame_single(), and conf_run().

01581 {
01582    int count;
01583    short *fdata = f->data;
01584    short adjust_value = abs(adjustment);
01585 
01586    if ((f->frametype != AST_FRAME_VOICE) || (f->subclass != AST_FORMAT_SLINEAR))
01587       return -1;
01588 
01589    if (!adjustment)
01590       return 0;
01591 
01592    for (count = 0; count < f->samples; count++) {
01593       if (adjustment > 0) {
01594          ast_slinear_saturated_multiply(&fdata[count], &adjust_value);
01595       } else if (adjustment < 0) {
01596          ast_slinear_saturated_divide(&fdata[count], &adjust_value);
01597       }
01598    }
01599 
01600    return 0;
01601 }

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

Dump a frame for debugging purposes

Definition at line 799 of file frame.c.

References AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_FLASH, AST_CONTROL_HANGUP, AST_CONTROL_HOLD, AST_CONTROL_OFFHOOK, AST_CONTROL_OPTION, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RADIO_KEY, AST_CONTROL_RADIO_UNKEY, AST_CONTROL_RING, AST_CONTROL_RINGING, AST_CONTROL_TAKEOFFHOOK, AST_CONTROL_UNHOLD, AST_CONTROL_WINK, ast_copy_string(), AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_HTML, AST_FRAME_IAX, AST_FRAME_IMAGE, AST_FRAME_MODEM, 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_MODEM_T38, AST_MODEM_V150, ast_strlen_zero(), ast_verbose(), COLOR_BLACK, COLOR_BRCYAN, COLOR_BRGREEN, COLOR_BRMAGENTA, COLOR_BRRED, COLOR_YELLOW, f, and term_color().

Referenced by __ast_read(), and ast_write().

00800 {
00801    const char noname[] = "unknown";
00802    char ftype[40] = "Unknown Frametype";
00803    char cft[80];
00804    char subclass[40] = "Unknown Subclass";
00805    char csub[80];
00806    char moreinfo[40] = "";
00807    char cn[60];
00808    char cp[40];
00809    char cmn[40];
00810 
00811    if (!name)
00812       name = noname;
00813 
00814 
00815    if (!f) {
00816       ast_verbose("%s [ %s (NULL) ] [%s]\n", 
00817          term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00818          term_color(cft, "HANGUP", COLOR_BRRED, COLOR_BLACK, sizeof(cft)), 
00819          term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00820       return;
00821    }
00822    /* XXX We should probably print one each of voice and video when the format changes XXX */
00823    if (f->frametype == AST_FRAME_VOICE)
00824       return;
00825    if (f->frametype == AST_FRAME_VIDEO)
00826       return;
00827    switch(f->frametype) {
00828    case AST_FRAME_DTMF_BEGIN:
00829       strcpy(ftype, "DTMF Begin");
00830       subclass[0] = f->subclass;
00831       subclass[1] = '\0';
00832       break;
00833    case AST_FRAME_DTMF_END:
00834       strcpy(ftype, "DTMF End");
00835       subclass[0] = f->subclass;
00836       subclass[1] = '\0';
00837       break;
00838    case AST_FRAME_CONTROL:
00839       strcpy(ftype, "Control");
00840       switch(f->subclass) {
00841       case AST_CONTROL_HANGUP:
00842          strcpy(subclass, "Hangup");
00843          break;
00844       case AST_CONTROL_RING:
00845          strcpy(subclass, "Ring");
00846          break;
00847       case AST_CONTROL_RINGING:
00848          strcpy(subclass, "Ringing");
00849          break;
00850       case AST_CONTROL_ANSWER:
00851          strcpy(subclass, "Answer");
00852          break;
00853       case AST_CONTROL_BUSY:
00854          strcpy(subclass, "Busy");
00855          break;
00856       case AST_CONTROL_TAKEOFFHOOK:
00857          strcpy(subclass, "Take Off Hook");
00858          break;
00859       case AST_CONTROL_OFFHOOK:
00860          strcpy(subclass, "Line Off Hook");
00861          break;
00862       case AST_CONTROL_CONGESTION:
00863          strcpy(subclass, "Congestion");
00864          break;
00865       case AST_CONTROL_FLASH:
00866          strcpy(subclass, "Flash");
00867          break;
00868       case AST_CONTROL_WINK:
00869          strcpy(subclass, "Wink");
00870          break;
00871       case AST_CONTROL_OPTION:
00872          strcpy(subclass, "Option");
00873          break;
00874       case AST_CONTROL_RADIO_KEY:
00875          strcpy(subclass, "Key Radio");
00876          break;
00877       case AST_CONTROL_RADIO_UNKEY:
00878          strcpy(subclass, "Unkey Radio");
00879          break;
00880       case AST_CONTROL_PROGRESS:
00881          strcpy(subclass, "Call Progress");
00882          break;
00883       case AST_CONTROL_PROCEEDING:
00884          strcpy(subclass, "Proceeding");
00885          break;
00886       case AST_CONTROL_HOLD:
00887         strcpy(subclass, "Hold");
00888         break;
00889       case AST_CONTROL_UNHOLD:
00890         strcpy(subclass, "UnHold");
00891         break;
00892       case -1:
00893          strcpy(subclass, "Stop generators");
00894          break;
00895       default:
00896          snprintf(subclass, sizeof(subclass), "Unknown control '%d'", f->subclass);
00897       }
00898       break;
00899    case AST_FRAME_NULL:
00900       strcpy(ftype, "Null Frame");
00901       strcpy(subclass, "N/A");
00902       break;
00903    case AST_FRAME_IAX:
00904       /* Should never happen */
00905       strcpy(ftype, "IAX Specific");
00906       snprintf(subclass, sizeof(subclass), "IAX Frametype %d", f->subclass);
00907       break;
00908    case AST_FRAME_TEXT:
00909       strcpy(ftype, "Text");
00910       strcpy(subclass, "N/A");
00911       ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
00912       break;
00913    case AST_FRAME_IMAGE:
00914       strcpy(ftype, "Image");
00915       snprintf(subclass, sizeof(subclass), "Image format %s\n", ast_getformatname(f->subclass));
00916       break;
00917    case AST_FRAME_HTML:
00918       strcpy(ftype, "HTML");
00919       switch(f->subclass) {
00920       case AST_HTML_URL:
00921          strcpy(subclass, "URL");
00922          ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
00923          break;
00924       case AST_HTML_DATA:
00925          strcpy(subclass, "Data");
00926          break;
00927       case AST_HTML_BEGIN:
00928          strcpy(subclass, "Begin");
00929          break;
00930       case AST_HTML_END:
00931          strcpy(subclass, "End");
00932          break;
00933       case AST_HTML_LDCOMPLETE:
00934          strcpy(subclass, "Load Complete");
00935          break;
00936       case AST_HTML_NOSUPPORT:
00937          strcpy(subclass, "No Support");
00938          break;
00939       case AST_HTML_LINKURL:
00940          strcpy(subclass, "Link URL");
00941          ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
00942          break;
00943       case AST_HTML_UNLINK:
00944          strcpy(subclass, "Unlink");
00945          break;
00946       case AST_HTML_LINKREJECT:
00947          strcpy(subclass, "Link Reject");
00948          break;
00949       default:
00950          snprintf(subclass, sizeof(subclass), "Unknown HTML frame '%d'\n", f->subclass);
00951          break;
00952       }
00953       break;
00954    case AST_FRAME_MODEM:
00955       strcpy(ftype, "Modem");
00956       switch (f->subclass) {
00957       case AST_MODEM_T38:
00958          strcpy(subclass, "T.38");
00959          break;
00960       case AST_MODEM_V150:
00961          strcpy(subclass, "V.150");
00962          break;
00963       default:
00964          snprintf(subclass, sizeof(subclass), "Unknown MODEM frame '%d'\n", f->subclass);
00965          break;
00966       }
00967       break;
00968    default:
00969       snprintf(ftype, sizeof(ftype), "Unknown Frametype '%d'", f->frametype);
00970    }
00971    if (!ast_strlen_zero(moreinfo))
00972       ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) '%s' ] [%s]\n",  
00973              term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00974              term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
00975              f->frametype, 
00976              term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
00977              f->subclass, 
00978              term_color(cmn, moreinfo, COLOR_BRGREEN, COLOR_BLACK, sizeof(cmn)),
00979              term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00980    else
00981       ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) ] [%s]\n",  
00982              term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00983              term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
00984              f->frametype, 
00985              term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
00986              f->subclass, 
00987              term_color(cn, name, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00988 }

void ast_frame_free ( struct ast_frame fr,
int  cache 
)

Requests a frame to be allocated Frees a frame or list of frames.

Parameters:
fr Frame to free, or head of list to free
cache Whether to consider this frame for frame caching

Definition at line 377 of file frame.c.

References __frame_free(), AST_LIST_NEXT, and ast_frame::next.

Referenced by mixmonitor_thread().

00378 {
00379    struct ast_frame *next;
00380 
00381    for (next = AST_LIST_NEXT(frame, frame_list);
00382         frame;
00383         frame = next, next = frame ? AST_LIST_NEXT(frame, frame_list) : NULL) {
00384       __frame_free(frame, cache);
00385    }
00386 }

static struct ast_frame* ast_frame_header_new ( void   )  [static]

Definition at line 301 of file frame.c.

References ast_calloc, ast_calloc_cache, AST_LIST_REMOVE_HEAD, AST_MALLOCD_HDR, ast_threadstorage_get(), f, frame_cache, and frames.

Referenced by ast_frisolate().

00302 {
00303    struct ast_frame *f;
00304 
00305 #if !defined(LOW_MEMORY)
00306    struct ast_frame_cache *frames;
00307 
00308    if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) {
00309       if ((f = AST_LIST_REMOVE_HEAD(&frames->list, frame_list))) {
00310          size_t mallocd_len = f->mallocd_hdr_len;
00311          memset(f, 0, sizeof(*f));
00312          f->mallocd_hdr_len = mallocd_len;
00313          f->mallocd = AST_MALLOCD_HDR;
00314          frames->size--;
00315          return f;
00316       }
00317    }
00318    if (!(f = ast_calloc_cache(1, sizeof(*f))))
00319       return NULL;
00320 #else
00321    if (!(f = ast_calloc(1, sizeof(*f))))
00322       return NULL;
00323 #endif
00324 
00325    f->mallocd_hdr_len = sizeof(*f);
00326    
00327    return f;
00328 }

int ast_frame_slinear_sum ( struct ast_frame f1,
struct ast_frame f2 
)

Sums two frames of audio samples.

Parameters:
f1 The first frame (which will contain the result)
f2 The second frame
Returns:
0 for success, non-zero for an error
The frames must be AST_FRAME_VOICE and must contain AST_FORMAT_SLINEAR samples, and must contain the same number of samples.

Definition at line 1603 of file frame.c.

References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_slinear_saturated_add(), ast_frame::data, ast_frame::frametype, ast_frame::samples, and ast_frame::subclass.

01604 {
01605    int count;
01606    short *data1, *data2;
01607 
01608    if ((f1->frametype != AST_FRAME_VOICE) || (f1->subclass != AST_FORMAT_SLINEAR))
01609       return -1;
01610 
01611    if ((f2->frametype != AST_FRAME_VOICE) || (f2->subclass != AST_FORMAT_SLINEAR))
01612       return -1;
01613 
01614    if (f1->samples != f2->samples)
01615       return -1;
01616 
01617    for (count = 0, data1 = f1->data, data2 = f2->data;
01618         count < f1->samples;
01619         count++, data1++, data2++)
01620       ast_slinear_saturated_add(data1, data2);
01621 
01622    return 0;
01623 }

struct ast_frame* ast_frdup ( const struct ast_frame fr  ) 

Copies a frame.

Parameters:
fr frame to copy Duplicates a frame -- should only rarely be used, typically frisolate is good enough
Returns:
Returns a frame on success, NULL on error

Definition at line 471 of file frame.c.

References ast_calloc_cache, ast_copy_flags, AST_FRFLAG_HAS_TIMING_INFO, AST_FRIENDLY_OFFSET, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_MALLOCD_HDR, ast_threadstorage_get(), ast_frame::data, ast_frame::datalen, ast_frame::delivery, f, frame_cache, frames, ast_frame::frametype, len(), ast_frame::len, ast_frame::mallocd, ast_frame::mallocd_hdr_len, ast_frame::offset, ast_frame::samples, ast_frame::seqno, ast_frame::src, ast_frame::subclass, and ast_frame::ts.

Referenced by __ast_queue_frame(), ast_frisolate(), ast_jb_put(), ast_rtp_write(), ast_slinfactory_feed(), audiohook_read_frame_single(), autoservice_run(), process_rfc2833(), recordthread(), and rpt().

00472 {
00473    struct ast_frame *out = NULL;
00474    int len, srclen = 0;
00475    void *buf = NULL;
00476 
00477 #if !defined(LOW_MEMORY)
00478    struct ast_frame_cache *frames;
00479 #endif
00480 
00481    /* Start with standard stuff */
00482    len = sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
00483    /* If we have a source, add space for it */
00484    /*
00485     * XXX Watch out here - if we receive a src which is not terminated
00486     * properly, we can be easily attacked. Should limit the size we deal with.
00487     */
00488    if (f->src)
00489       srclen = strlen(f->src);
00490    if (srclen > 0)
00491       len += srclen + 1;
00492    
00493 #if !defined(LOW_MEMORY)
00494    if ((frames = ast_threadstorage_get(&frame_cache, sizeof(*frames)))) {
00495       AST_LIST_TRAVERSE_SAFE_BEGIN(&frames->list, out, frame_list) {
00496          if (out->mallocd_hdr_len >= len) {
00497             size_t mallocd_len = out->mallocd_hdr_len;
00498             AST_LIST_REMOVE_CURRENT(&frames->list, frame_list);
00499             memset(out, 0, sizeof(*out));
00500             out->mallocd_hdr_len = mallocd_len;
00501             buf = out;
00502             frames->size--;
00503             break;
00504          }
00505       }
00506       AST_LIST_TRAVERSE_SAFE_END;
00507    }
00508 #endif
00509 
00510    if (!buf) {
00511       if (!(buf = ast_calloc_cache(1, len)))
00512          return NULL;
00513       out = buf;
00514       out->mallocd_hdr_len = len;
00515    }
00516 
00517    out->frametype = f->frametype;
00518    out->subclass = f->subclass;
00519    out->datalen = f->datalen;
00520    out->samples = f->samples;
00521    out->delivery = f->delivery;
00522    /* Set us as having malloc'd header only, so it will eventually
00523       get freed. */
00524    out->mallocd = AST_MALLOCD_HDR;
00525    out->offset = AST_FRIENDLY_OFFSET;
00526    if (out->datalen) {
00527       out->data = buf + sizeof(*out) + AST_FRIENDLY_OFFSET;
00528       memcpy(out->data, f->data, out->datalen); 
00529    }
00530    if (srclen > 0) {
00531       /* This may seem a little strange, but it's to avoid a gcc (4.2.4) compiler warning */
00532       char *src;
00533       out->src = buf + sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
00534       src = (char *) out->src;
00535       /* Must have space since we allocated for it */
00536       strcpy(src, f->src);
00537    }
00538    ast_copy_flags(out, f, AST_FRFLAG_HAS_TIMING_INFO);
00539    out->ts = f->ts;
00540    out->len = f->len;
00541    out->seqno = f->seqno;
00542    return out;
00543 }

struct ast_frame* ast_frisolate ( struct ast_frame fr  ) 

Makes a frame independent of any static storage.

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:
Returns a frame on success, NULL on error
Note:
This function may modify the frame passed to it, so you must not assume the frame will be intact after the isolated frame has been produced. In other words, calling this function on a frame should be the last operation you do with that frame before freeing it (or exiting the block, if the frame is on the stack.)

Definition at line 393 of file frame.c.

References ast_copy_flags, ast_frame_header_new(), ast_frdup(), AST_FRFLAG_HAS_TIMING_INFO, AST_FRIENDLY_OFFSET, ast_malloc, AST_MALLOCD_DATA, AST_MALLOCD_HDR, AST_MALLOCD_SRC, ast_strdup, ast_test_flag, ast_frame::data, ast_frame::datalen, ast_frame::frametype, free, ast_frame::len, ast_frame::mallocd, ast_frame::offset, ast_frame::samples, ast_frame::seqno, ast_frame::src, ast_frame::subclass, and ast_frame::ts.

Referenced by ast_dsp_process(), ast_rtp_read(), ast_safe_sleep_conditional(), ast_slinfactory_feed(), ast_trans_frameout(), ast_write(), autoservice_run(), dahdi_decoder_frameout(), dahdi_encoder_frameout(), feature_request_and_dial(), jpeg_read_image(), and read_frame().

00394 {
00395    struct ast_frame *out;
00396    void *newdata;
00397 
00398    /* if none of the existing frame is malloc'd, let ast_frdup() do it
00399       since it is more efficient
00400    */
00401    if (fr->mallocd == 0) {
00402       return ast_frdup(fr);
00403    }
00404 
00405    /* if everything is already malloc'd, we are done */
00406    if ((fr->mallocd & (AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA)) ==
00407        (AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA)) {
00408       return fr;
00409    }
00410 
00411    if (!(fr->mallocd & AST_MALLOCD_HDR)) {
00412       /* Allocate a new header if needed */
00413       if (!(out = ast_frame_header_new())) {
00414          return NULL;
00415       }
00416       out->frametype = fr->frametype;
00417       out->subclass = fr->subclass;
00418       out->datalen = fr->datalen;
00419       out->samples = fr->samples;
00420       out->offset = fr->offset;
00421       /* Copy the timing data */
00422       ast_copy_flags(out, fr, AST_FRFLAG_HAS_TIMING_INFO);
00423       if (ast_test_flag(fr, AST_FRFLAG_HAS_TIMING_INFO)) {
00424          out->ts = fr->ts;
00425          out->len = fr->len;
00426          out->seqno = fr->seqno;
00427       }
00428    } else {
00429       out = fr;
00430    }
00431    
00432    if (!(fr->mallocd & AST_MALLOCD_SRC) && fr->src) {
00433       if (!(out->src = ast_strdup(fr->src))) {
00434          if (out != fr) {
00435             free(out);
00436          }
00437          return NULL;
00438       }
00439    } else {
00440       out->src = fr->src;
00441       fr->src = NULL;
00442       fr->mallocd &= ~AST_MALLOCD_SRC;
00443    }
00444    
00445    if (!(fr->mallocd & AST_MALLOCD_DATA))  {
00446       if (!(newdata = ast_malloc(fr->datalen + AST_FRIENDLY_OFFSET))) {
00447          if (out->src != fr->src) {
00448             free((void *) out->src);
00449          }
00450          if (out != fr) {
00451             free(out);
00452          }
00453          return NULL;
00454       }
00455       newdata += AST_FRIENDLY_OFFSET;
00456       out->offset = AST_FRIENDLY_OFFSET;
00457       out->datalen = fr->datalen;
00458       memcpy(newdata, fr->data, fr->datalen);
00459       out->data = newdata;
00460    } else {
00461       out->data = fr->data;
00462       fr->data = NULL;
00463       fr->mallocd &= ~AST_MALLOCD_DATA;
00464    }
00465 
00466    out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA;
00467    
00468    return out;
00469 }

struct ast_format_list* ast_get_format_list ( size_t *  size  ) 

Definition at line 561 of file frame.c.

References AST_FORMAT_LIST.

00562 {
00563    *size = (sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]));
00564    return AST_FORMAT_LIST;
00565 }

struct ast_format_list* ast_get_format_list_index ( int  index  ) 

Definition at line 556 of file frame.c.

References AST_FORMAT_LIST.

00557 {
00558    return &AST_FORMAT_LIST[index];
00559 }

int ast_getformatbyname ( const char *  name  ) 

Gets a format from a name.

Parameters:
name string of format
Returns:
This returns the form of the format in binary on success, 0 on error.

Definition at line 627 of file frame.c.

References ast_expand_codec_alias(), AST_FORMAT_LIST, and format.

Referenced by ast_parse_allow_disallow(), iax_template_parse(), reload_config(), and try_suggested_sip_codec().

00628 {
00629    int x, all, format = 0;
00630 
00631    all = strcasecmp(name, "all") ? 0 : 1;
00632    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
00633       if(AST_FORMAT_LIST[x].visible && (all || 
00634            !strcasecmp(AST_FORMAT_LIST[x].name,name) ||
00635            !strcasecmp(AST_FORMAT_LIST[x].name,ast_expand_codec_alias(name)))) {
00636          format |= AST_FORMAT_LIST[x].bits;
00637          if(!all)
00638             break;
00639       }
00640    }
00641 
00642    return format;
00643 }

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 "unknown" if unknown.

Definition at line 567 of file frame.c.

References AST_FORMAT_LIST, ast_format_list::bits, name, and ast_format_list::visible.

Referenced by __ast_play_and_record(), __ast_read(), __ast_register_translator(), __login_exec(), _sip_show_peer(), add_codec_to_answer(), add_codec_to_sdp(), agent_call(), ast_codec_get_len(), ast_codec_get_samples(), ast_codec_pref_string(), ast_dsp_process(), ast_frame_dump(), ast_openvstream(), ast_rtp_write(), ast_slinfactory_feed(), ast_streamfile(), ast_translator_build_path(), ast_unregister_translator(), ast_writestream(), background_detect_exec(), dahdi_read(), do_waiting(), eagi_exec(), func_channel_read(), function_iaxpeer(), function_sippeer(), gtalk_show_channels(), iax2_request(), iax2_show_channels(), iax2_show_peer(), iax_show_provisioning(), moh_classes_show(), moh_release(), oh323_rtp_read(), phone_setup(), print_codec_to_cli(), rebuild_matrix(), register_translator(), set_format(), set_local_capabilities(), set_peer_capabilities(), show_codecs(), show_codecs_deprecated(), show_file_formats(), show_file_formats_deprecated(), show_image_formats(), show_image_formats_deprecated(), show_translation(), show_translation_deprecated(), sip_request_call(), sip_rtp_read(), and socket_process().

00568 {
00569    int x;
00570    char *ret = "unknown";
00571    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
00572       if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == format) {
00573          ret = AST_FORMAT_LIST[x].name;
00574          break;
00575       }
00576    }
00577    return ret;
00578 }

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
size 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 580 of file frame.c.

References AST_FORMAT_LIST, ast_format_list::bits, len(), name, and ast_format_list::visible.

Referenced by __ast_read(), __sip_show_channels(), _sip_show_peer(), add_sdp(), ast_streamfile(), function_iaxpeer(), function_sippeer(), gtalk_is_answered(), gtalk_newcall(), handle_showchan(), handle_showchan_deprecated(), iax2_show_peer(), process_sdp(), serialize_showchan(), set_format(), sip_new(), sip_request_call(), sip_show_channel(), sip_show_settings(), and sip_write().

00581 {
00582    int x;
00583    unsigned len;
00584    char *start, *end = buf;
00585 
00586    if (!size)
00587       return buf;
00588    snprintf(end, size, "0x%x (", format);
00589    len = strlen(end);
00590    end += len;
00591    size -= len;
00592    start = end;
00593    for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
00594       if (AST_FORMAT_LIST[x].visible && (AST_FORMAT_LIST[x].bits & format)) {
00595          snprintf(end, size,"%s|",AST_FORMAT_LIST[x].name);
00596          len = strlen(end);
00597          end += len;
00598          size -= len;
00599       }
00600    }
00601    if (start == end)
00602       snprintf(start, size, "nothing)");
00603    else if (size > 1)
00604       *(end -1) = ')';
00605    return buf;
00606 }

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

Parse an "allow" or "deny" line in a channel or device configuration and update the capabilities mask and pref if provided. Video codecs are not added to codec preference lists, since we can not transcode.

Definition at line 1307 of file frame.c.

References ast_codec_pref_append(), ast_codec_pref_remove(), ast_codec_pref_setsize(), AST_FORMAT_AUDIO_MASK, ast_getformatbyname(), ast_log(), ast_strdupa, format, LOG_DEBUG, LOG_WARNING, option_debug, and parse().

Referenced by action_originate(), apply_outgoing(), build_device(), build_peer(), build_user(), gtalk_create_member(), gtalk_load_config(), reload_config(), set_config(), and update_common_options().

01308 {
01309    char *parse = NULL, *this = NULL, *psize = NULL;
01310    int format = 0, framems = 0;
01311 
01312    parse = ast_strdupa(list);
01313    while ((this = strsep(&parse, ","))) {
01314       framems = 0;
01315       if ((psize = strrchr(this, ':'))) {
01316          *psize++ = '\0';
01317          if (option_debug)
01318             ast_log(LOG_DEBUG,"Packetization for codec: %s is %s\n", this, psize);
01319          framems = atoi(psize);
01320          if (framems < 0)
01321             framems = 0;
01322       }
01323       if (!(format = ast_getformatbyname(this))) {
01324          ast_log(LOG_WARNING, "Cannot %s unknown format '%s'\n", allowing ? "allow" : "disallow", this);
01325          continue;
01326       }
01327 
01328       if (mask) {
01329          if (allowing)
01330             *mask |= format;
01331          else
01332             *mask &= ~format;
01333       }
01334 
01335       /* Set up a preference list for audio. Do not include video in preferences 
01336          since we can not transcode video and have to use whatever is offered
01337        */
01338       if (pref && (format & AST_FORMAT_AUDIO_MASK)) {
01339          if (strcasecmp(this, "all")) {
01340             if (allowing) {
01341                ast_codec_pref_append(pref, format);
01342                ast_codec_pref_setsize(pref, format, framems);
01343             }
01344             else
01345                ast_codec_pref_remove(pref, format);
01346          } else if (!allowing) {
01347             memset(pref, 0, sizeof(*pref));
01348          }
01349       }
01350    }
01351 }

void ast_smoother_free ( struct ast_smoother s  ) 

Definition at line 296 of file frame.c.

References free, and s.

Referenced by ast_rtp_destroy(), and ast_rtp_write().

00297 {
00298    free(s);
00299 }

int ast_smoother_get_flags ( struct ast_smoother s  ) 

Definition at line 196 of file frame.c.

References s.

00197 {
00198    return s->flags;
00199 }

struct ast_smoother* ast_smoother_new ( int  size  ) 

Definition at line 186 of file frame.c.

References ast_malloc, ast_smoother_reset(), and s.

Referenced by ast_rtp_codec_setpref(), and ast_rtp_write().

00187 {
00188    struct ast_smoother *s;
00189    if (size < 1)
00190       return NULL;
00191    if ((s = ast_malloc(sizeof(*s))))
00192       ast_smoother_reset(s, size);
00193    return s;
00194 }

struct ast_frame* ast_smoother_read ( struct ast_smoother s  ) 

Definition at line 246 of file frame.c.

References AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), ast_samp2tv(), AST_SMOOTHER_FLAG_G729, ast_tvadd(), ast_tvzero(), len(), LOG_WARNING, and s.

Referenced by ast_rtp_write().

00247 {
00248    struct ast_frame *opt;
00249    int len;
00250 
00251    /* IF we have an optimization frame, send it */
00252    if (s->opt) {
00253       if (s->opt->offset < AST_FRIENDLY_OFFSET)
00254          ast_log(LOG_WARNING, "Returning a frame of inappropriate offset (%d).\n",
00255                      s->opt->offset);
00256       opt = s->opt;
00257       s->opt = NULL;
00258       return opt;
00259    }
00260 
00261    /* Make sure we have enough data */
00262    if (s->len < s->size) {
00263       /* Or, if this is a G.729 frame with VAD on it, send it immediately anyway */
00264       if (!((s->flags & AST_SMOOTHER_FLAG_G729) && (s->len % 10)))
00265          return NULL;
00266    }
00267    len = s->size;
00268    if (len > s->len)
00269       len = s->len;
00270    /* Make frame */
00271    s->f.frametype = AST_FRAME_VOICE;
00272    s->f.subclass = s->format;
00273    s->f.data = s->framedata + AST_FRIENDLY_OFFSET;
00274    s->f.offset = AST_FRIENDLY_OFFSET;
00275    s->f.datalen = len;
00276    /* Samples will be improper given VAD, but with VAD the concept really doesn't even exist */
00277    s->f.samples = len * s->samplesperbyte;   /* XXX rounding */
00278    s->f.delivery = s->delivery;
00279    /* Fill Data */
00280    memcpy(s->f.data, s->data, len);
00281    s->len -= len;
00282    /* Move remaining data to the front if applicable */
00283    if (s->len) {
00284       /* In principle this should all be fine because if we are sending
00285          G.729 VAD, the next timestamp will take over anyawy */
00286       memmove(s->data, s->data + len, s->len);
00287       if (!ast_tvzero(s->delivery)) {
00288          /* If we have delivery time, increment it, otherwise, leave it at 0 */
00289          s->delivery = ast_tvadd(s->delivery, ast_samp2tv(s->f.samples, 8000));
00290       }
00291    }
00292    /* Return frame */
00293    return &s->f;
00294 }

void ast_smoother_reconfigure ( struct ast_smoother s,
int  bytes 
)

Reconfigure an existing smoother to output a different number of bytes per frame.

Parameters:
s the smoother to reconfigure
bytes the desired number of bytes per output frame
Returns:
nothing

Definition at line 164 of file frame.c.

References s, and smoother_frame_feed().

Referenced by ast_rtp_codec_setpref().

00165 {
00166    /* if there is no change, then nothing to do */
00167    if (s->size == bytes) {
00168       return;
00169    }
00170    /* set the new desired output size */
00171    s->size = bytes;
00172    /* if there is no 'optimized' frame in the smoother,
00173     *   then there is nothing left to do
00174     */
00175    if (!s->opt) {
00176       return;
00177    }
00178    /* there is an 'optimized' frame here at the old size,
00179     * but it must now be put into the buffer so the data
00180     * can be extracted at the new size
00181     */
00182    smoother_frame_feed(s, s->opt, s->opt_needs_swap);
00183    s->opt = NULL;
00184 }

void ast_smoother_reset ( struct ast_smoother s,
int  bytes 
)

Definition at line 158 of file frame.c.

References s.

Referenced by ast_smoother_new().

00159 {
00160    memset(s, 0, sizeof(*s));
00161    s->size = bytes;
00162 }

void ast_smoother_set_flags ( struct ast_smoother s,
int  flags 
)

Definition at line 201 of file frame.c.

References s.

Referenced by ast_rtp_codec_setpref(), and ast_rtp_write().

00202 {
00203    s->flags = flags;
00204 }

int ast_smoother_test_flag ( struct ast_smoother s,
int  flag 
)

Definition at line 206 of file frame.c.

References s.

Referenced by ast_rtp_write().

00207 {
00208    return (s->flags & flag);
00209 }

void ast_swapcopy_samples ( void *  dst,
const void *  src,
int  samples 
)

Definition at line 545 of file frame.c.

Referenced by __ast_smoother_feed(), iax_frame_wrap(), phone_write_buf(), and smoother_frame_feed().

00546 {
00547    int i;
00548    unsigned short *dst_s = dst;
00549    const unsigned short *src_s = src;
00550 
00551    for (i = 0; i < samples; i++)
00552       dst_s[i] = (src_s[i]<<8) | (src_s[i]>>8);
00553 }

static void frame_cache_cleanup ( void *  data  )  [static]

Definition at line 331 of file frame.c.

References AST_LIST_REMOVE_HEAD, f, frames, and free.

00332 {
00333    struct ast_frame_cache *frames = data;
00334    struct ast_frame *f;
00335 
00336    while ((f = AST_LIST_REMOVE_HEAD(&frames->list, frame_list)))
00337       free(f);
00338    
00339    free(frames);
00340 }

static void frame_cache_init ( void   )  [static]

A per-thread cache of frame headers.

Definition at line 54 of file frame.c.

00071 {

static int g723_len ( unsigned char  buf  )  [static]

Definition at line 1353 of file frame.c.

References ast_log(), LOG_WARNING, type, TYPE_DONTSEND, TYPE_HIGH, TYPE_LOW, TYPE_MASK, and TYPE_SILENCE.

Referenced by g723_samples().

01354 {
01355    enum frame_type type = buf & TYPE_MASK;
01356 
01357    switch(type) {
01358    case TYPE_DONTSEND:
01359       return 0;
01360       break;
01361    case TYPE_SILENCE:
01362       return 4;
01363       break;
01364    case TYPE_HIGH:
01365       return 24;
01366       break;
01367    case TYPE_LOW:
01368       return 20;
01369       break;
01370    default:
01371       ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", type);
01372    }
01373    return -1;
01374 }

static int g723_samples ( unsigned char *  buf,
int  maxlen 
) [static]

Definition at line 1376 of file frame.c.

References g723_len().

Referenced by ast_codec_get_samples().

01377 {
01378    int pos = 0;
01379    int samples = 0;
01380    int res;
01381    while(pos < maxlen) {
01382       res = g723_len(buf[pos]);
01383       if (res <= 0)
01384          break;
01385       samples += 240;
01386       pos += res;
01387    }
01388    return samples;
01389 }

static unsigned char get_n_bits_at ( unsigned char *  data,
int  n,
int  bit 
) [static]

Definition at line 1391 of file frame.c.

Referenced by speex_get_wb_sz_at(), and speex_samples().

01392 {
01393    int byte = bit / 8;       /* byte containing first bit */
01394    int rem = 8 - (bit % 8);  /* remaining bits in first byte */
01395    unsigned char ret = 0;
01396    
01397    if (n <= 0 || n > 8)
01398       return 0;
01399 
01400    if (rem < n) {
01401       ret = (data[byte] << (n - rem));
01402       ret |= (data[byte + 1] >> (8 - n + rem));
01403    } else {
01404       ret = (data[byte] >> (rem - n));
01405    }
01406 
01407    return (ret & (0xff >> (8 - n)));
01408 }

int init_framer ( void   ) 

Provided by frame.c

Definition at line 1039 of file frame.c.

References ast_cli_register_multiple(), and my_clis.

Referenced by main().

01040 {
01041    ast_cli_register_multiple(my_clis, sizeof(my_clis) / sizeof(struct ast_cli_entry));
01042    return 0;   
01043 }

static int show_codec_n ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 772 of file frame.c.

References ast_cli(), ast_codec2str(), RESULT_SHOWUSAGE, and RESULT_SUCCESS.

00773 {
00774    int codec, i, found=0;
00775 
00776    if (argc != 4)
00777       return RESULT_SHOWUSAGE;
00778 
00779    if (sscanf(argv[3],"%30d",&codec) != 1)
00780       return RESULT_SHOWUSAGE;
00781 
00782    for (i = 0; i < 32; i++)
00783       if (codec & (1 << i)) {
00784          found = 1;
00785          ast_cli(fd, "%11u (1 << %2d)  %s\n",1 << i,i,ast_codec2str(1<<i));
00786       }
00787 
00788    if (!found)
00789       ast_cli(fd, "Codec %d not found\n", codec);
00790 
00791    return RESULT_SUCCESS;
00792 }

static int show_codec_n_deprecated ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 750 of file frame.c.

References ast_cli(), ast_codec2str(), RESULT_SHOWUSAGE, and RESULT_SUCCESS.

00751 {
00752    int codec, i, found=0;
00753 
00754    if (argc != 3)
00755       return RESULT_SHOWUSAGE;
00756 
00757    if (sscanf(argv[2],"%30d",&codec) != 1)
00758       return RESULT_SHOWUSAGE;
00759 
00760    for (i = 0; i < 32; i++)
00761       if (codec & (1 << i)) {
00762          found = 1;
00763          ast_cli(fd, "%11u (1 << %2d)  %s\n",1 << i,i,ast_codec2str(1<<i));
00764       }
00765 
00766    if (!found)
00767       ast_cli(fd, "Codec %d not found\n", codec);
00768 
00769    return RESULT_SUCCESS;
00770 }

static int show_codecs ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 702 of file frame.c.

References ast_cli(), ast_codec2str(), ast_getformatname(), ast_opt_dont_warn, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

00703 {
00704    int i, found=0;
00705    char hex[25];
00706    
00707    if ((argc < 3) || (argc > 4))
00708       return RESULT_SHOWUSAGE;
00709 
00710    if (!ast_opt_dont_warn)
00711       ast_cli(fd, "Disclaimer: this command is for informational purposes only.\n"
00712             "\tIt does not indicate anything about your configuration.\n");
00713 
00714    ast_cli(fd, "%11s %9s %10s   TYPE   %8s   %s\n","INT","BINARY","HEX","NAME","DESC");
00715    ast_cli(fd, "--------------------------------------------------------------------------------\n");
00716    if ((argc == 3) || (!strcasecmp(argv[3],"audio"))) {
00717       found = 1;
00718       for (i=0;i<13;i++) {
00719          snprintf(hex,25,"(0x%x)",1<<i);
00720          ast_cli(fd, "%11u (1 << %2d) %10s  audio   %8s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00721       }
00722    }
00723 
00724    if ((argc == 3) || (!strcasecmp(argv[3],"image"))) {
00725       found = 1;
00726       for (i=16;i<18;i++) {
00727          snprintf(hex,25,"(0x%x)",1<<i);
00728          ast_cli(fd, "%11u (1 << %2d) %10s  image   %8s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00729       }
00730    }
00731 
00732    if ((argc == 3) || (!strcasecmp(argv[3],"video"))) {
00733       found = 1;
00734       for (i=18;i<22;i++) {
00735          snprintf(hex,25,"(0x%x)",1<<i);
00736          ast_cli(fd, "%11u (1 << %2d) %10s  video   %8s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00737       }
00738    }
00739 
00740    if (! found)
00741       return RESULT_SHOWUSAGE;
00742    else
00743       return RESULT_SUCCESS;
00744 }

static int show_codecs_deprecated ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 658 of file frame.c.

References ast_cli(), ast_codec2str(), ast_getformatname(), ast_opt_dont_warn, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

00659 {
00660    int i, found=0;
00661    char hex[25];
00662    
00663    if ((argc < 2) || (argc > 3))
00664       return RESULT_SHOWUSAGE;
00665 
00666    if (!ast_opt_dont_warn)
00667       ast_cli(fd, "Disclaimer: this command is for informational purposes only.\n"
00668             "\tIt does not indicate anything about your configuration.\n");
00669 
00670    ast_cli(fd, "%11s %9s %10s   TYPE   %8s   %s\n","INT","BINARY","HEX","NAME","DESC");
00671    ast_cli(fd, "--------------------------------------------------------------------------------\n");
00672    if ((argc == 2) || (!strcasecmp(argv[1],"audio"))) {
00673       found = 1;
00674       for (i=0;i<13;i++) {
00675          snprintf(hex,25,"(0x%x)",1<<i);
00676          ast_cli(fd, "%11u (1 << %2d) %10s  audio   %8s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00677       }
00678    }
00679 
00680    if ((argc == 2) || (!strcasecmp(argv[1],"image"))) {
00681       found = 1;
00682       for (i=16;i<18;i++) {
00683          snprintf(hex,25,"(0x%x)",1<<i);
00684          ast_cli(fd, "%11u (1 << %2d) %10s  image   %8s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00685       }
00686    }
00687 
00688    if ((argc == 2) || (!strcasecmp(argv[1],"video"))) {
00689       found = 1;
00690       for (i=18;i<22;i++) {
00691          snprintf(hex,25,"(0x%x)",1<<i);
00692          ast_cli(fd, "%11u (1 << %2d) %10s  video   %8s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00693       }
00694    }
00695 
00696    if (! found)
00697       return RESULT_SHOWUSAGE;
00698    else
00699       return RESULT_SUCCESS;
00700 }

static int smoother_frame_feed ( struct ast_smoother s,
struct ast_frame f,
int  swap 
) [static]

Definition at line 136 of file frame.c.

References ast_log(), AST_SMOOTHER_FLAG_G729, ast_swapcopy_samples(), ast_tvzero(), f, LOG_NOTICE, and s.

Referenced by __ast_smoother_feed(), and ast_smoother_reconfigure().

00137 {
00138    if (s->flags & AST_SMOOTHER_FLAG_G729) {
00139       if (s->len % 10) {
00140          ast_log(LOG_NOTICE, "Dropping extra frame of G.729 since we already have a VAD frame at the end\n");
00141          return 0;
00142       }
00143    }
00144    if (swap) {
00145       ast_swapcopy_samples(s->data + s->len, f->data, f->samples);
00146    } else {
00147       memcpy(s->data + s->len, f->data, f->datalen);
00148    }
00149    /* If either side is empty, reset the delivery time */
00150    if (!s->len || ast_tvzero(f->delivery) || ast_tvzero(s->delivery)) { /* XXX really ? */
00151       s->delivery = f->delivery;
00152    }
00153    s->len += f->datalen;
00154 
00155    return 0;
00156 }

static int speex_get_wb_sz_at ( unsigned char *  data,
int  len,
int  bit 
) [static]

Definition at line 1410 of file frame.c.

References ast_log(), get_n_bits_at(), and LOG_WARNING.

Referenced by speex_samples().

01411 {
01412    static int SpeexWBSubModeSz[] = {
01413       0, 36, 112, 192,
01414       352, 0, 0, 0 };
01415    int off = bit;
01416    unsigned char c;
01417 
01418    /* skip up to two wideband frames */
01419    if (((len * 8 - off) >= 5) && 
01420       get_n_bits_at(data, 1, off)) {
01421       c = get_n_bits_at(data, 3, off + 1);
01422       off += SpeexWBSubModeSz[c];
01423 
01424       if (((len * 8 - off) >= 5) && 
01425          get_n_bits_at(data, 1, off)) {
01426          c = get_n_bits_at(data, 3, off + 1);
01427          off += SpeexWBSubModeSz[c];
01428 
01429          if (((len * 8 - off) >= 5) && 
01430             get_n_bits_at(data, 1, off)) {
01431             ast_log(LOG_WARNING, "Encountered corrupt speex frame; too many wideband frames in a row.\n");
01432             return -1;
01433          }
01434       }
01435 
01436    }
01437    return off - bit;
01438 }

static int speex_samples ( unsigned char *  data,
int  len 
) [static]

Definition at line 1440 of file frame.c.

References ast_log(), get_n_bits_at(), LOG_WARNING, and speex_get_wb_sz_at().

Referenced by ast_codec_get_samples().

01441 {
01442    static int SpeexSubModeSz[] = {
01443                5, 43, 119, 160,
01444       220, 300, 364, 492, 
01445       79, 0, 0, 0,
01446       0, 0, 0, 0 };
01447    static int SpeexInBandSz[] = { 
01448       1, 1, 4, 4,
01449       4, 4, 4, 4,
01450       8, 8, 16, 16,
01451       32, 32, 64, 64 };
01452    int bit = 0;
01453    int cnt = 0;
01454    int off;
01455    unsigned char c;
01456 
01457    while ((len * 8 - bit) >= 5) {
01458       /* skip wideband frames */
01459       off = speex_get_wb_sz_at(data, len, bit);
01460       if (off < 0)  {
01461          ast_log(LOG_WARNING, "Had error while reading wideband frames for speex samples\n");
01462          break;
01463       }
01464       bit += off;
01465 
01466       if ((len * 8 - bit) == 0) {
01467          break;
01468       } else if ((len * 8 - bit) < 5) {
01469          ast_log(LOG_WARNING, "Not enough bits remaining after wide band for speex samples.\n");
01470          break;
01471       }
01472 
01473       /* get control bits */
01474       c = get_n_bits_at(data, 5, bit);
01475       bit += 5;
01476 
01477       if (c == 15) { 
01478          /* terminator */
01479          break; 
01480       } else if (c == 14) {
01481          /* in-band signal; next 4 bits contain signal id */
01482          c = get_n_bits_at(data, 4, bit);
01483          bit += 4;
01484          bit += SpeexInBandSz[c];
01485       } else if (c == 13) {
01486          /* user in-band; next 5 bits contain msg len */
01487          c = get_n_bits_at(data, 5, bit);
01488          bit += 5;
01489          bit += c * 8;
01490       } else if (c > 8) {
01491          /* unknown */
01492          break;
01493       } else {
01494          /* skip number bits for submode (less the 5 control bits) */
01495          bit += SpeexSubModeSz[c] - 5;
01496          cnt += 160; /* new frame */
01497       }
01498    }
01499    return cnt;
01500 }


Variable Documentation

struct ast_format_list AST_FORMAT_LIST[] [static]

Definition of supported media formats (codecs).

Definition at line 103 of file frame.c.

Referenced by ast_codec2str(), ast_codec_choose(), ast_codec_pref_append(), ast_codec_pref_getsize(), ast_codec_pref_index(), ast_codec_pref_prepend(), ast_codec_pref_remove(), ast_codec_pref_setsize(), ast_get_format_list(), ast_get_format_list_index(), ast_getformatbyname(), ast_getformatname(), and ast_getformatname_multiple().

struct ast_frame ast_null_frame = { AST_FRAME_NULL, }

Queueing a null frame is fairly common, so we declare a global null frame object for this purpose instead of having to declare one on the stack

Definition at line 134 of file frame.c.

Referenced by __ast_read(), __oh323_rtp_create(), __oh323_update_info(), agent_read(), agent_request(), ast_channel_masquerade(), ast_channel_setwhentohangup(), ast_do_masquerade(), ast_rtcp_read(), ast_rtp_read(), ast_softhangup_nolock(), ast_udptl_read(), conf_run(), create_dtmf_frame(), dahdi_handle_event(), features_read(), gtalk_rtp_read(), handle_request_invite(), handle_response_invite(), local_read(), mgcp_rtp_read(), oh323_read(), oh323_rtp_read(), process_sdp(), sip_read(), sip_rtp_read(), skinny_rtp_read(), and wakeup_sub().

struct ast_cli_entry cli_show_audio_codecs [static]

Initial value:

 {
   { "show", "audio", "codecs", NULL },
   show_codecs_deprecated, NULL,
   NULL }

Definition at line 997 of file frame.c.

struct ast_cli_entry cli_show_codec [static]

Initial value:

 {
   { "show", "codec", NULL },
   show_codec_n_deprecated, NULL,
   NULL }

Definition at line 1012 of file frame.c.

struct ast_cli_entry cli_show_codecs [static]

Initial value:

 {
   { "show", "codecs", NULL },
   show_codecs_deprecated, NULL,
   NULL }

Definition at line 992 of file frame.c.

struct ast_cli_entry cli_show_image_codecs [static]

Initial value:

 {
   { "show", "image", "codecs", NULL },
   show_codecs_deprecated, NULL,
   NULL }

Definition at line 1007 of file frame.c.

struct ast_cli_entry cli_show_video_codecs [static]

Initial value:

 {
   { "show", "video", "codecs", NULL },
   show_codecs_deprecated, NULL,
   NULL }

Definition at line 1002 of file frame.c.

struct ast_threadstorage frame_cache = { .once = PTHREAD_ONCE_INIT , .key_init = frame_cache_init , } [static]

Definition at line 54 of file frame.c.

Referenced by __frame_free(), ast_frame_header_new(), ast_frdup(), iax_frame_free(), and iax_frame_new().

char frame_show_codec_n_usage[] [static]

Initial value:

"Usage: core show codec <number>\n"
"       Displays codec mapping\n"

Definition at line 794 of file frame.c.

char frame_show_codecs_usage[] [static]

Initial value:

"Usage: core show codecs [audio|video|image]\n"
"       Displays codec mapping\n"

Definition at line 746 of file frame.c.

struct ast_cli_entry my_clis[] [static]

Definition at line 1017 of file frame.c.

Referenced by init_framer().


Generated on Sat Aug 6 00:39:56 2011 for Asterisk - the Open Source PBX by  doxygen 1.4.7