Thu May 24 14:22:35 2007

Asterisk developer's documentation


frame.c File Reference

Frame manipulation routines. More...

#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include "asterisk.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 dependency graph for frame.c:

Go to the source code of this file.

Data Structures

struct  ast_codec_alias_table
struct  ast_format_list
struct  ast_smoother

Defines

#define SMOOTHER_SIZE   8000
#define TYPE_DONTSEND   0x3
#define TYPE_HIGH   0x0
#define TYPE_LOW   0x1
#define TYPE_MASK   0x3
#define TYPE_SILENCE   0x2

Functions

int __ast_smoother_feed (struct ast_smoother *s, struct ast_frame *f, int swap)
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 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 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 a codec preference list up or down 65 bytes so that it becomes an ASCII string.
int ast_codec_pref_index (struct ast_codec_pref *pref, int index)
 Codec located at a particular place in the preference index.
void ast_codec_pref_remove (struct ast_codec_pref *pref, int format)
 Remove a codec from a preference list.
int ast_codec_pref_string (struct ast_codec_pref *pref, char *buf, size_t size)
 Dump codec preference list into a string.
static char * ast_expand_codec_alias (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 (char *name, struct ast_frame *f, char *prefix)
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 (struct ast_frame *f)
 Copies a frame.
void ast_frfree (struct ast_frame *fr)
 Requests a frame to be allocated Frees a frame.
ast_frameast_frisolate (struct ast_frame *fr)
 Copies a frame.
ast_format_listast_get_format_list (size_t *size)
ast_format_listast_get_format_list_index (int index)
int ast_getformatbyname (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 and update the mask and pref if provided.
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_reset (struct ast_smoother *s, int size)
void ast_smoother_set_flags (struct ast_smoother *s, int flags)
void ast_swapcopy_samples (void *dst, const void *src, int samples)
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_codecs (int fd, int argc, char *argv[])
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).
static char frame_show_codec_n_usage []
static char frame_show_codecs_usage []
static struct ast_cli_entry my_clis []


Detailed Description

Frame manipulation routines.

Definition in file frame.c.


Define Documentation

#define SMOOTHER_SIZE   8000

Definition at line 50 of file frame.c.

Referenced by __ast_smoother_feed().

#define TYPE_DONTSEND   0x3

Definition at line 55 of file frame.c.

Referenced by g723_len().

#define TYPE_HIGH   0x0

Definition at line 52 of file frame.c.

Referenced by g723_len().

#define TYPE_LOW   0x1

Definition at line 53 of file frame.c.

Referenced by g723_len().

#define TYPE_MASK   0x3

Definition at line 56 of file frame.c.

Referenced by g723_len().

#define TYPE_SILENCE   0x2

Definition at line 54 of file frame.c.

Referenced by g723_len().


Function Documentation

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

Definition at line 137 of file frame.c.

References AST_FRAME_VOICE, ast_log(), AST_MIN_OFFSET, AST_SMOOTHER_FLAG_G729, ast_swapcopy_samples(), ast_frame::data, ast_frame::datalen, ast_frame::delivery, ast_smoother::f, ast_frame::frametype, LOG_NOTICE, LOG_WARNING, ast_frame::offset, s, ast_frame::samples, SMOOTHER_SIZE, and ast_frame::subclass.

00138 {
00139    if (f->frametype != AST_FRAME_VOICE) {
00140       ast_log(LOG_WARNING, "Huh?  Can't smooth a non-voice frame!\n");
00141       return -1;
00142    }
00143    if (!s->format) {
00144       s->format = f->subclass;
00145       s->samplesperbyte = (float)f->samples / (float)f->datalen;
00146    } else if (s->format != f->subclass) {
00147       ast_log(LOG_WARNING, "Smoother was working on %d format frames, now trying to feed %d?\n", s->format, f->subclass);
00148       return -1;
00149    }
00150    if (s->len + f->datalen > SMOOTHER_SIZE) {
00151       ast_log(LOG_WARNING, "Out of smoother space\n");
00152       return -1;
00153    }
00154    if (((f->datalen == s->size) || ((f->datalen < 10) && (s->flags & AST_SMOOTHER_FLAG_G729)))
00155              && !s->opt && (f->offset >= AST_MIN_OFFSET)) {
00156       if (!s->len) {
00157          /* Optimize by sending the frame we just got
00158             on the next read, thus eliminating the douple
00159             copy */
00160          s->opt = f;
00161          return 0;
00162       } else {
00163          s->optimizablestream++;
00164          if (s->optimizablestream > 10) {
00165             /* For the past 10 rounds, we have input and output
00166                frames of the correct size for this smoother, yet
00167                we were unable to optimize because there was still
00168                some cruft left over.  Lets just drop the cruft so
00169                we can move to a fully optimized path */
00170             s->len = 0;
00171             s->opt = f;
00172             return 0;
00173          }
00174       }
00175    } else 
00176       s->optimizablestream = 0;
00177    if (s->flags & AST_SMOOTHER_FLAG_G729) {
00178       if (s->len % 10) {
00179          ast_log(LOG_NOTICE, "Dropping extra frame of G.729 since we already have a VAD frame at the end\n");
00180          return 0;
00181       }
00182    }
00183    if (swap)
00184       ast_swapcopy_samples(s->data+s->len, f->data, f->samples);
00185    else
00186       memcpy(s->data + s->len, f->data, f->datalen);
00187    /* If either side is empty, reset the delivery time */
00188    if (!s->len || ast_tvzero(f->delivery) || ast_tvzero(s->delivery))   /* XXX really ? */
00189       s->delivery = f->delivery;
00190    s->len += f->datalen;
00191    return 0;
00192 }

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

References AST_FORMAT_LIST, and desc.

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

00585                                {
00586    int x = 0;
00587    char *ret = "unknown";
00588    for (x = 0 ; x < sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list) ; x++) {
00589       if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == codec) {
00590          ret = AST_FORMAT_LIST[x].desc;
00591          break;
00592       }
00593    }
00594    return ret;
00595 }

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

Select the best 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 999 of file frame.c.

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

Referenced by process_sdp(), sip_new(), and socket_read().

01000 {
01001    size_t size = 0;
01002    int x = 0, ret = 0, slot = 0;
01003 
01004    size = sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list);
01005    for (x = 0; x < size; x++) {
01006       slot = pref->order[x];
01007 
01008       if(!slot)
01009          break;
01010       if ( formats & AST_FORMAT_LIST[slot-1].bits ) {
01011          ret = AST_FORMAT_LIST[slot-1].bits;
01012          break;
01013       }
01014    }
01015    if(ret)
01016       return ret;
01017 
01018       return find_best ? ast_best_codec(formats) : 0;
01019 }

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

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

Referenced by ast_channel_spy_read_frame(), copy_data_from_queue(), moh_generate(), and monmp3thread().

01241 {
01242    int len = 0;
01243 
01244    /* XXX Still need speex, g723, and lpc10 XXX */ 
01245    switch(format) {
01246    case AST_FORMAT_ILBC:
01247       len = (samples / 240) * 50;
01248       break;
01249    case AST_FORMAT_GSM:
01250       len = (samples / 160) * 33;
01251       break;
01252    case AST_FORMAT_G729A:
01253       len = samples / 8;
01254       break;
01255    case AST_FORMAT_SLINEAR:
01256       len = samples * 2;
01257       break;
01258    case AST_FORMAT_ULAW:
01259    case AST_FORMAT_ALAW:
01260       len = samples;
01261       break;
01262    case AST_FORMAT_ADPCM:
01263    case AST_FORMAT_G726:
01264       len = samples / 2;
01265       break;
01266    default:
01267       ast_log(LOG_WARNING, "Unable to calculate sample length for format %s\n", ast_getformatname(format));
01268    }
01269 
01270    return len;
01271 }

int ast_codec_get_samples ( struct ast_frame f  ) 

Returns the number of samples contained in the frame.

Definition at line 1199 of file frame.c.

References AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_G723_1, AST_FORMAT_G726, 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(), ast_frame::data, ast_frame::datalen, g723_samples(), LOG_WARNING, speex_samples(), and ast_frame::subclass.

Referenced by ast_rtp_read(), moh_generate(), and socket_read().

01200 {
01201    int samples=0;
01202    switch(f->subclass) {
01203    case AST_FORMAT_SPEEX:
01204       samples = speex_samples(f->data, f->datalen);
01205       break;
01206    case AST_FORMAT_G723_1:
01207                 samples = g723_samples(f->data, f->datalen);
01208       break;
01209    case AST_FORMAT_ILBC:
01210       samples = 240 * (f->datalen / 50);
01211       break;
01212    case AST_FORMAT_GSM:
01213       samples = 160 * (f->datalen / 33);
01214       break;
01215    case AST_FORMAT_G729A:
01216       samples = f->datalen * 8;
01217       break;
01218    case AST_FORMAT_SLINEAR:
01219       samples = f->datalen / 2;
01220       break;
01221    case AST_FORMAT_LPC10:
01222                 /* assumes that the RTP packet contains one LPC10 frame */
01223       samples = 22 * 8;
01224       samples += (((char *)(f->data))[7] & 0x1) * 8;
01225       break;
01226    case AST_FORMAT_ULAW:
01227    case AST_FORMAT_ALAW:
01228       samples = f->datalen;
01229       break;
01230    case AST_FORMAT_ADPCM:
01231    case AST_FORMAT_G726:
01232       samples = f->datalen * 2;
01233       break;
01234    default:
01235       ast_log(LOG_WARNING, "Unable to calculate samples for format %s\n", ast_getformatname(f->subclass));
01236    }
01237    return samples;
01238 }

int ast_codec_pref_append ( struct ast_codec_pref pref,
int  format 
)

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

Definition at line 970 of file frame.c.

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

Referenced by ast_parse_allow_disallow().

00971 {
00972    size_t size = 0;
00973    int x = 0, newindex = -1;
00974 
00975    ast_codec_pref_remove(pref, format);
00976    size = sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list);
00977 
00978    for (x = 0; x < size; x++) {
00979       if(AST_FORMAT_LIST[x].bits == format) {
00980          newindex = x + 1;
00981          break;
00982       }
00983    }
00984 
00985    if(newindex) {
00986       for (x = 0; x < size; x++) {
00987          if(!pref->order[x]) {
00988             pref->order[x] = newindex;
00989             break;
00990          }
00991       }
00992    }
00993 
00994    return x;
00995 }

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

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

Definition at line 873 of file frame.c.

References ast_codec_pref::order.

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

00874 {
00875    int x = 0, differential = (int) 'A', mem = 0;
00876    char *from = NULL, *to = NULL;
00877 
00878    if(right) {
00879       from = pref->order;
00880       to = buf;
00881       mem = size;
00882    } else {
00883       to = pref->order;
00884       from = buf;
00885       mem = 32;
00886    }
00887 
00888    memset(to, 0, mem);
00889    for (x = 0; x < 32 ; x++) {
00890       if(!from[x])
00891          break;
00892       to[x] = right ? (from[x] + differential) : (from[x] - differential);
00893    }
00894 }

int ast_codec_pref_index ( struct ast_codec_pref pref,
int  index 
)

Codec located at a particular place in the preference index.

Definition at line 931 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(), iax2_show_peer(), print_codec_to_cli(), sip_show_user(), and socket_read().

00932 {
00933    int slot = 0;
00934 
00935    
00936    if((index >= 0) && (index < sizeof(pref->order))) {
00937       slot = pref->order[index];
00938    }
00939 
00940    return slot ? AST_FORMAT_LIST[slot-1].bits : 0;
00941 }

void ast_codec_pref_remove ( struct ast_codec_pref pref,
int  format 
)

Remove a codec from a preference list.

Definition at line 944 of file frame.c.

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

Referenced by ast_codec_pref_append(), and ast_parse_allow_disallow().

00945 {
00946    struct ast_codec_pref oldorder;
00947    int x=0, y=0;
00948    size_t size = 0;
00949    int slot = 0;
00950 
00951    if(!pref->order[0])
00952       return;
00953 
00954    size = sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list);
00955 
00956    memcpy(&oldorder,pref,sizeof(struct ast_codec_pref));
00957    memset(pref,0,sizeof(struct ast_codec_pref));
00958 
00959    for (x = 0; x < size; x++) {
00960       slot = oldorder.order[x];
00961       if(! slot)
00962          break;
00963       if(AST_FORMAT_LIST[slot-1].bits != format)
00964          pref->order[y++] = slot;
00965    }
00966    
00967 }

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

Dump codec preference list into a string.

Definition at line 896 of file frame.c.

References ast_codec_pref_index(), and ast_getformatname().

Referenced by dump_prefs(), and socket_read().

00897 {
00898    int x = 0, codec = 0; 
00899    size_t total_len = 0, slen = 0;
00900    char *formatname = 0;
00901    
00902    memset(buf,0,size);
00903    total_len = size;
00904    buf[0] = '(';
00905    total_len--;
00906    for(x = 0; x < 32 ; x++) {
00907       if(total_len <= 0)
00908          break;
00909       if(!(codec = ast_codec_pref_index(pref,x)))
00910          break;
00911       if((formatname = ast_getformatname(codec))) {
00912          slen = strlen(formatname);
00913          if(slen > total_len)
00914             break;
00915          strncat(buf,formatname,total_len);
00916          total_len -= slen;
00917       }
00918       if(total_len && x < 31 && ast_codec_pref_index(pref , x + 1)) {
00919          strncat(buf,"|",total_len);
00920          total_len--;
00921       }
00922    }
00923    if(total_len) {
00924       strncat(buf,")",total_len);
00925       total_len--;
00926    }
00927 
00928    return size - total_len;
00929 }

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

Definition at line 557 of file frame.c.

Referenced by ast_getformatbyname().

00557                                               {
00558    int x = 0;
00559 
00560    for (x = 0; x < sizeof(ast_codec_alias_table) / sizeof(struct ast_codec_alias_table) ; x++) {
00561       if(!strcmp(in,ast_codec_alias_table[x].alias))
00562          return ast_codec_alias_table[x].realname;
00563    }
00564    return in;
00565 }

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

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

Referenced by ast_channel_spy_read_frame(), and conf_run().

01274 {
01275    int count;
01276    short *fdata = f->data;
01277    short adjust_value = abs(adjustment);
01278 
01279    if ((f->frametype != AST_FRAME_VOICE) || (f->subclass != AST_FORMAT_SLINEAR))
01280       return -1;
01281 
01282    if (!adjustment)
01283       return 0;
01284 
01285    for (count = 0; count < f->samples; count++) {
01286       if (adjustment > 0) {
01287          ast_slinear_saturated_multiply(&fdata[count], &adjust_value);
01288       } else if (adjustment < 0) {
01289          ast_slinear_saturated_divide(&fdata[count], &adjust_value);
01290       }
01291    }
01292 
01293    return 0;
01294 }

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

Dump a frame for debugging purposes

Definition at line 672 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_strlen_zero(), ast_verbose(), COLOR_BLACK, COLOR_BRCYAN, COLOR_BRGREEN, COLOR_BRMAGENTA, COLOR_BRRED, COLOR_YELLOW, ast_frame::data, ast_frame::frametype, n, ast_frame::subclass, and term_color().

Referenced by ast_read(), and ast_write().

00673 {
00674    char *n = "unknown";
00675    char ftype[40] = "Unknown Frametype";
00676    char cft[80];
00677    char subclass[40] = "Unknown Subclass";
00678    char csub[80];
00679    char moreinfo[40] = "";
00680    char cn[60];
00681    char cp[40];
00682    char cmn[40];
00683    if (name)
00684       n = name;
00685    if (!f) {
00686       ast_verbose("%s [ %s (NULL) ] [%s]\n", 
00687          term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00688          term_color(cft, "HANGUP", COLOR_BRRED, COLOR_BLACK, sizeof(cft)), 
00689          term_color(cn, n, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00690       return;
00691    }
00692    /* XXX We should probably print one each of voice and video when the format changes XXX */
00693    if (f->frametype == AST_FRAME_VOICE)
00694       return;
00695    if (f->frametype == AST_FRAME_VIDEO)
00696       return;
00697    switch(f->frametype) {
00698    case AST_FRAME_DTMF:
00699       strcpy(ftype, "DTMF");
00700       subclass[0] = f->subclass;
00701       subclass[1] = '\0';
00702       break;
00703    case AST_FRAME_CONTROL:
00704       strcpy(ftype, "Control");
00705       switch(f->subclass) {
00706       case AST_CONTROL_HANGUP:
00707          strcpy(subclass, "Hangup");
00708          break;
00709       case AST_CONTROL_RING:
00710          strcpy(subclass, "Ring");
00711          break;
00712       case AST_CONTROL_RINGING:
00713          strcpy(subclass, "Ringing");
00714          break;
00715       case AST_CONTROL_ANSWER:
00716          strcpy(subclass, "Answer");
00717          break;
00718       case AST_CONTROL_BUSY:
00719          strcpy(subclass, "Busy");
00720          break;
00721       case AST_CONTROL_TAKEOFFHOOK:
00722          strcpy(subclass, "Take Off Hook");
00723          break;
00724       case AST_CONTROL_OFFHOOK:
00725          strcpy(subclass, "Line Off Hook");
00726          break;
00727       case AST_CONTROL_CONGESTION:
00728          strcpy(subclass, "Congestion");
00729          break;
00730       case AST_CONTROL_FLASH:
00731          strcpy(subclass, "Flash");
00732          break;
00733       case AST_CONTROL_WINK:
00734          strcpy(subclass, "Wink");
00735          break;
00736       case AST_CONTROL_OPTION:
00737          strcpy(subclass, "Option");
00738          break;
00739       case AST_CONTROL_RADIO_KEY:
00740          strcpy(subclass, "Key Radio");
00741          break;
00742       case AST_CONTROL_RADIO_UNKEY:
00743          strcpy(subclass, "Unkey Radio");
00744          break;
00745       case -1:
00746          strcpy(subclass, "Stop generators");
00747          break;
00748       default:
00749          snprintf(subclass, sizeof(subclass), "Unknown control '%d'", f->subclass);
00750       }
00751       break;
00752    case AST_FRAME_NULL:
00753       strcpy(ftype, "Null Frame");
00754       strcpy(subclass, "N/A");
00755       break;
00756    case AST_FRAME_IAX:
00757       /* Should never happen */
00758       strcpy(ftype, "IAX Specific");
00759       snprintf(subclass, sizeof(subclass), "IAX Frametype %d", f->subclass);
00760       break;
00761    case AST_FRAME_TEXT:
00762       strcpy(ftype, "Text");
00763       strcpy(subclass, "N/A");
00764       ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
00765       break;
00766    case AST_FRAME_IMAGE:
00767       strcpy(ftype, "Image");
00768       snprintf(subclass, sizeof(subclass), "Image format %s\n", ast_getformatname(f->subclass));
00769       break;
00770    case AST_FRAME_HTML:
00771       strcpy(ftype, "HTML");
00772       switch(f->subclass) {
00773       case AST_HTML_URL:
00774          strcpy(subclass, "URL");
00775          ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
00776          break;
00777       case AST_HTML_DATA:
00778          strcpy(subclass, "Data");
00779          break;
00780       case AST_HTML_BEGIN:
00781          strcpy(subclass, "Begin");
00782          break;
00783       case AST_HTML_END:
00784          strcpy(subclass, "End");
00785          break;
00786       case AST_HTML_LDCOMPLETE:
00787          strcpy(subclass, "Load Complete");
00788          break;
00789       case AST_HTML_NOSUPPORT:
00790          strcpy(subclass, "No Support");
00791          break;
00792       case AST_HTML_LINKURL:
00793          strcpy(subclass, "Link URL");
00794          ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
00795          break;
00796       case AST_HTML_UNLINK:
00797          strcpy(subclass, "Unlink");
00798          break;
00799       case AST_HTML_LINKREJECT:
00800          strcpy(subclass, "Link Reject");
00801          break;
00802       default:
00803          snprintf(subclass, sizeof(subclass), "Unknown HTML frame '%d'\n", f->subclass);
00804          break;
00805       }
00806       break;
00807    default:
00808       snprintf(ftype, sizeof(ftype), "Unknown Frametype '%d'", f->frametype);
00809    }
00810    if (!ast_strlen_zero(moreinfo))
00811       ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) '%s' ] [%s]\n",  
00812          term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00813          term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
00814          f->frametype, 
00815          term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
00816          f->subclass, 
00817          term_color(cmn, moreinfo, COLOR_BRGREEN, COLOR_BLACK, sizeof(cmn)),
00818          term_color(cn, n, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00819    else
00820       ast_verbose("%s [ TYPE: %s (%d) SUBCLASS: %s (%d) ] [%s]\n",  
00821          term_color(cp, prefix, COLOR_BRMAGENTA, COLOR_BLACK, sizeof(cp)),
00822          term_color(cft, ftype, COLOR_BRRED, COLOR_BLACK, sizeof(cft)),
00823          f->frametype, 
00824          term_color(csub, subclass, COLOR_BRCYAN, COLOR_BLACK, sizeof(csub)),
00825          f->subclass, 
00826          term_color(cn, n, COLOR_YELLOW, COLOR_BLACK, sizeof(cn)));
00827 
00828 }

static struct ast_frame* ast_frame_header_new ( void   )  [static]

Definition at line 248 of file frame.c.

References ast_mutex_lock(), ast_mutex_unlock(), malloc, and ast_frame::prev.

Referenced by ast_frisolate().

00249 {
00250    struct ast_frame *f;
00251    f = malloc(sizeof(struct ast_frame));
00252    if (f)
00253       memset(f, 0, sizeof(struct ast_frame));
00254 #ifdef TRACE_FRAMES
00255    if (f) {
00256       f->prev = NULL;
00257       ast_mutex_lock(&framelock);
00258       headers++;
00259       f->next = headerlist;
00260       if (headerlist)
00261          headerlist->prev = f;
00262       headerlist = f;
00263       ast_mutex_unlock(&framelock);
00264    }
00265 #endif   
00266    return f;
00267 }

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 1296 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.

Referenced by ast_channel_spy_read_frame().

01297 {
01298    int count;
01299    short *data1, *data2;
01300 
01301    if ((f1->frametype != AST_FRAME_VOICE) || (f1->subclass != AST_FORMAT_SLINEAR))
01302       return -1;
01303 
01304    if ((f2->frametype != AST_FRAME_VOICE) || (f2->subclass != AST_FORMAT_SLINEAR))
01305       return -1;
01306 
01307    if (f1->samples != f2->samples)
01308       return -1;
01309 
01310    for (count = 0, data1 = f1->data, data2 = f2->data;
01311         count < f1->samples;
01312         count++, data1++, data2++)
01313       ast_slinear_saturated_add(data1, data2);
01314 
01315    return 0;
01316 }

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:
Returns a frame on success, NULL on error

Definition at line 361 of file frame.c.

References AST_FRIENDLY_OFFSET, AST_MALLOCD_HDR, calloc, ast_frame::data, ast_frame::datalen, ast_frame::delivery, ast_frame::frametype, ast_frame::mallocd, ast_frame::offset, ast_frame::samples, ast_frame::src, and ast_frame::subclass.

Referenced by ast_channel_spy_read_frame(), ast_queue_frame(), ast_rtp_write(), ast_slinfactory_feed(), and queue_frame_to_spies().

00362 {
00363    struct ast_frame *out;
00364    int len, srclen = 0;
00365    void *buf;
00366    /* Start with standard stuff */
00367    len = sizeof(struct ast_frame) + AST_FRIENDLY_OFFSET + f->datalen;
00368    /* If we have a source, add space for it */
00369    /*
00370     * XXX Watch out here - if we receive a src which is not terminated
00371     * properly, we can be easily attacked. Should limit the size we deal with.
00372     */
00373    if (f->src)
00374       srclen = strlen(f->src);
00375    if (srclen > 0)
00376       len += srclen + 1;
00377    buf = calloc(1, len);
00378    if (!buf)
00379       return NULL;
00380    out = buf;
00381    /* Set us as having malloc'd header only, so it will eventually
00382       get freed. */
00383    out->frametype = f->frametype;
00384    out->subclass = f->subclass;
00385    out->datalen = f->datalen;
00386    out->samples = f->samples;
00387    out->delivery = f->delivery;
00388    out->mallocd = AST_MALLOCD_HDR;
00389    out->offset = AST_FRIENDLY_OFFSET;
00390    if (out->datalen) {
00391       out->data = buf + sizeof(struct ast_frame) + AST_FRIENDLY_OFFSET;
00392       memcpy(out->data, f->data, out->datalen); 
00393    }
00394    if (srclen > 0) {
00395       out->src = buf + sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
00396       /* Must have space since we allocated for it */
00397       strcpy((char *)out->src, f->src);
00398    }
00399    return out;
00400 }

void ast_frfree ( struct ast_frame fr  ) 

Requests a frame to be allocated Frees a frame.

Todo:
Important: I should be made more efficient. Frame headers should most definitely be cached

Definition at line 273 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 __adsi_transmit_messages(), __ast_request_and_dial(), adsi_careful_send(), agent_ack_sleep(), agent_read(), app_exec(), ast_app_getvoice(), ast_bridge_call(), ast_channel_free(), ast_channel_spy_free(), ast_channel_spy_read_frame(), ast_dsp_process(), ast_feature_request_and_dial(), ast_masq_park_call(), ast_play_and_prepend(), ast_play_and_record_full(), ast_queue_frame(), ast_read(), ast_recvtext(), ast_safe_sleep(), ast_safe_sleep_conditional(), ast_send_image(), ast_slinfactory_destroy(), ast_slinfactory_read(), ast_tonepair(), ast_translate(), ast_waitfordigit(), ast_waitfordigit_full(), ast_waitstream(), ast_waitstream_exten(), ast_waitstream_fr(), ast_waitstream_full(), ast_write(), async_wait(), autoservice_run(), background_detect_exec(), builtin_atxfer(), calc_cost(), channel_spy(), check_goto_on_transfer(), conf_exec(), conf_flush(), conf_run(), copy_data_from_queue(), dictate_exec(), disa_exec(), do_parking_thread(), do_waiting(), echo_exec(), find_cache(), gen_generate(), handle_recordfile(), iax_park_thread(), ices_exec(), measurenoise(), mixmonitor_thread(), moh_files_generator(), mp3_exec(), NBScat_exec(), queue_frame_to_spies(), receive_dtmf_digits(), recordthread(), rpt(), run_agi(), send_tone_burst(), send_waveform_to_channel(), sendurl_exec(), spy_generate(), ss_thread(), vpb_bridge(), wait_for_answer(), wait_for_hangup(), waitforring_exec(), and zt_bridge().

00274 {
00275    if (fr->mallocd & AST_MALLOCD_DATA) {
00276       if (fr->data) 
00277          free(fr->data - fr->offset);
00278    }
00279    if (fr->mallocd & AST_MALLOCD_SRC) {
00280       if (fr->src)
00281          free((char *)fr->src);
00282    }
00283    if (fr->mallocd & AST_MALLOCD_HDR) {
00284 #ifdef TRACE_FRAMES
00285       ast_mutex_lock(&framelock);
00286       headers--;
00287       if (fr->next)
00288          fr->next->prev = fr->prev;
00289       if (fr->prev)
00290          fr->prev->next = fr->next;
00291       else
00292          headerlist = fr->next;
00293       ast_mutex_unlock(&framelock);
00294 #endif         
00295       free(fr);
00296    }
00297 }

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:
Returns a frame on success, NULL on error

Definition at line 304 of file frame.c.

References ast_frame_header_new(), 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 jpeg_read_image(), and monitor_handle_owned().

00305 {
00306    struct ast_frame *out;
00307    void *newdata;
00308 
00309    if (!(fr->mallocd & AST_MALLOCD_HDR)) {
00310       /* Allocate a new header if needed */
00311       out = ast_frame_header_new();
00312       if (!out) {
00313          ast_log(LOG_WARNING, "Out of memory\n");
00314          return NULL;
00315       }
00316       out->frametype = fr->frametype;
00317       out->subclass = fr->subclass;
00318       out->datalen = fr->datalen;
00319       out->samples = fr->samples;
00320       out->offset = fr->offset;
00321       out->src = NULL;
00322       out->data = fr->data;
00323    } else
00324       out = fr;
00325    
00326    if (!(fr->mallocd & AST_MALLOCD_SRC)) {
00327       if (fr->src) {
00328          out->src = strdup(fr->src);
00329          if (!out->src) {
00330             if (out != fr)
00331                free(out);
00332             ast_log(LOG_WARNING, "Out of memory\n");
00333             return NULL;
00334          }
00335       }
00336    } else
00337       out->src = fr->src;
00338    
00339    if (!(fr->mallocd & AST_MALLOCD_DATA))  {
00340       newdata = malloc(fr->datalen + AST_FRIENDLY_OFFSET);
00341       if (!newdata) {
00342          if (out->src != fr->src)
00343             free((void *) out->src);
00344          if (out != fr)
00345             free(out);
00346          ast_log(LOG_WARNING, "Out of memory\n");
00347          return NULL;
00348       }
00349       newdata += AST_FRIENDLY_OFFSET;
00350       out->offset = AST_FRIENDLY_OFFSET;
00351       out->datalen = fr->datalen;
00352       memcpy(newdata, fr->data, fr->datalen);
00353       out->data = newdata;
00354    }
00355 
00356    out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA;
00357    
00358    return out;
00359 }

struct ast_format_list* ast_get_format_list ( size_t *  size  ) 

Definition at line 502 of file frame.c.

References AST_FORMAT_LIST.

00503 {
00504    *size = (sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list));
00505    return AST_FORMAT_LIST;
00506 }

struct ast_format_list* ast_get_format_list_index ( int  index  ) 

Definition at line 497 of file frame.c.

References AST_FORMAT_LIST.

00498 {
00499    return &AST_FORMAT_LIST[index];
00500 }

int ast_getformatbyname ( 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 567 of file frame.c.

References ast_expand_codec_alias(), AST_FORMAT_LIST, and format.

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

00568 {
00569    int x = 0, all = 0, format = 0;
00570 
00571    all = strcasecmp(name, "all") ? 0 : 1;
00572    for (x = 0 ; x < sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list) ; x++) {
00573       if(AST_FORMAT_LIST[x].visible && (all || 
00574                                 !strcasecmp(AST_FORMAT_LIST[x].name,name) ||
00575                                 !strcasecmp(AST_FORMAT_LIST[x].name,ast_expand_codec_alias(name)))) {
00576          format |= AST_FORMAT_LIST[x].bits;
00577          if(!all)
00578             break;
00579       }
00580    }
00581 
00582    return format;
00583 }

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

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

Referenced by __login_exec(), __sip_show_channels(), _sip_show_peer(), add_codec_to_sdp(), agent_call(), ast_channel_spy_add(), ast_codec_get_len(), ast_codec_get_samples(), ast_codec_pref_string(), ast_dsp_process(), ast_frame_dump(), ast_play_and_prepend(), ast_play_and_record_full(), ast_read(), ast_register_translator(), ast_rtp_write(), ast_slinfactory_feed(), ast_streamfile(), ast_translator_build_path(), ast_unregister_translator(), ast_writestream(), background_detect_exec(), do_waiting(), eagi_exec(), function_iaxpeer(), function_sippeer(), iax2_request(), iax2_show_channels(), iax2_show_peer(), iax_show_provisioning(), modem_request(), moh_classes_show(), moh_release(), phone_setup(), print_codec_to_cli(), queue_frame_to_spies(), set_format(), show_codecs(), show_file_formats(), show_image_formats(), show_translation(), sip_request_call(), sip_show_channel(), sip_show_user(), socket_read(), and zt_read().

00509 {
00510    int x = 0;
00511    char *ret = "unknown";
00512    for (x = 0 ; x < sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list) ; x++) {
00513       if(AST_FORMAT_LIST[x].visible && AST_FORMAT_LIST[x].bits == format) {
00514          ret = AST_FORMAT_LIST[x].name;
00515          break;
00516       }
00517    }
00518    return ret;
00519 }

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

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

Referenced by _sip_show_peer(), function_iaxpeer(), function_sippeer(), iax2_show_peer(), and process_sdp().

00521                                                                      {
00522 
00523    int x = 0;
00524    unsigned len;
00525    char *end = buf;
00526    char *start = buf;
00527    if (!size) return buf;
00528    snprintf(end, size, "0x%x (", format);
00529    len = strlen(end);
00530    end += len;
00531    size -= len;
00532    start = end;
00533    for (x = 0 ; x < sizeof(AST_FORMAT_LIST) / sizeof(struct ast_format_list) ; x++) {
00534       if (AST_FORMAT_LIST[x].visible && (AST_FORMAT_LIST[x].bits & format)) {
00535          snprintf(end, size,"%s|",AST_FORMAT_LIST[x].name);
00536          len = strlen(end);
00537          end += len;
00538          size -= len;
00539       }
00540    }
00541    if (start == end)
00542       snprintf(start, size, "nothing)");
00543    else if (size > 1)
00544       *(end -1) = ')';
00545    return buf;
00546 }

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

Parse an "allow" or "deny" line and update the mask and pref if provided.

Definition at line 1021 of file frame.c.

References ast_codec_pref_append(), ast_codec_pref_remove(), ast_getformatbyname(), ast_log(), ast_strdupa, format, LOG_WARNING, parse(), and strsep().

Referenced by build_peer(), build_user(), reload_config(), and set_config().

01022 {
01023    char *parse;
01024    char *this;
01025    int format;
01026 
01027    parse = ast_strdupa(list);
01028    while ((this = strsep(&parse, ","))) {
01029       if (!(format = ast_getformatbyname(this))) {
01030          ast_log(LOG_WARNING, "Cannot %s unknown format '%s'\n", allowing ? "allow" : "disallow", this);
01031          continue;
01032       }
01033 
01034       if (mask) {
01035          if (allowing)
01036             *mask |= format;
01037          else
01038             *mask &= ~format;
01039       }
01040 
01041       if (pref) {
01042          if (strcasecmp(this, "all")) {
01043             if (allowing)
01044                ast_codec_pref_append(pref, format);
01045             else
01046                ast_codec_pref_remove(pref, format);
01047          } else if (!allowing) {
01048             memset(pref, 0, sizeof(*pref));
01049          }
01050       }
01051    }
01052 }

void ast_smoother_free ( struct ast_smoother s  ) 

Definition at line 243 of file frame.c.

References free, and s.

Referenced by ast_rtp_destroy(), and ast_rtp_write().

00244 {
00245    free(s);
00246 }

int ast_smoother_get_flags ( struct ast_smoother s  ) 

Definition at line 127 of file frame.c.

References s.

00128 {
00129    return s->flags;
00130 }

struct ast_smoother* ast_smoother_new ( int  size  ) 

Definition at line 116 of file frame.c.

References ast_smoother_reset(), malloc, and s.

Referenced by ast_rtp_write().

00117 {
00118    struct ast_smoother *s;
00119    if (size < 1)
00120       return NULL;
00121    s = malloc(sizeof(struct ast_smoother));
00122    if (s)
00123       ast_smoother_reset(s, size);
00124    return s;
00125 }

struct ast_frame* ast_smoother_read ( struct ast_smoother s  ) 

Definition at line 194 of file frame.c.

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

Referenced by ast_rtp_write().

00195 {
00196    struct ast_frame *opt;
00197    int len;
00198    /* IF we have an optimization frame, send it */
00199    if (s->opt) {
00200       if (s->opt->offset < AST_FRIENDLY_OFFSET)
00201          ast_log(LOG_WARNING, "Returning a frame of inappropriate offset (%d).",
00202                      s->opt->offset);
00203       opt = s->opt;
00204       s->opt = NULL;
00205       return opt;
00206    }
00207 
00208    /* Make sure we have enough data */
00209    if (s->len < s->size) {
00210       /* Or, if this is a G.729 frame with VAD on it, send it immediately anyway */
00211       if (!((s->flags & AST_SMOOTHER_FLAG_G729) && (s->size % 10)))
00212          return NULL;
00213    }
00214    len = s->size;
00215    if (len > s->len)
00216       len = s->len;
00217    /* Make frame */
00218    s->f.frametype = AST_FRAME_VOICE;
00219    s->f.subclass = s->format;
00220    s->f.data = s->framedata + AST_FRIENDLY_OFFSET;
00221    s->f.offset = AST_FRIENDLY_OFFSET;
00222    s->f.datalen = len;
00223    /* Samples will be improper given VAD, but with VAD the concept really doesn't even exist */
00224    s->f.samples = len * s->samplesperbyte;   /* XXX rounding */
00225    s->f.delivery = s->delivery;
00226    /* Fill Data */
00227    memcpy(s->f.data, s->data, len);
00228    s->len -= len;
00229    /* Move remaining data to the front if applicable */
00230    if (s->len) {
00231       /* In principle this should all be fine because if we are sending
00232          G.729 VAD, the next timestamp will take over anyawy */
00233       memmove(s->data, s->data + len, s->len);
00234       if (!ast_tvzero(s->delivery)) {
00235          /* If we have delivery time, increment it, otherwise, leave it at 0 */
00236          s->delivery = ast_tvadd(s->delivery, ast_samp2tv(s->f.samples, 8000));
00237       }
00238    }
00239    /* Return frame */
00240    return &s->f;
00241 }

void ast_smoother_reset ( struct ast_smoother s,
int  size 
)

Definition at line 110 of file frame.c.

References s.

Referenced by ast_smoother_new().

00111 {
00112    memset(s, 0, sizeof(struct ast_smoother));
00113    s->size = size;
00114 }

void ast_smoother_set_flags ( struct ast_smoother s,
int  flags 
)

Definition at line 132 of file frame.c.

References s.

Referenced by ast_rtp_write().

00133 {
00134    s->flags = flags;
00135 }

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

Definition at line 486 of file frame.c.

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

00487 {
00488    int i;
00489    unsigned short *dst_s = dst;
00490    const unsigned short *src_s = src;
00491 
00492    for (i=0; i<samples; i++)
00493       dst_s[i] = (src_s[i]<<8) | (src_s[i]>>8);
00494 }

static int g723_len ( unsigned char  buf  )  [static]

Definition at line 1054 of file frame.c.

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

Referenced by g723_samples(), g723tolin_framein(), and lintog723_frameout().

01055 {
01056    switch(buf & TYPE_MASK) {
01057    case TYPE_DONTSEND:
01058       return 0;
01059       break;
01060    case TYPE_SILENCE:
01061       return 4;
01062       break;
01063    case TYPE_HIGH:
01064       return 24;
01065       break;
01066    case TYPE_LOW:
01067       return 20;
01068       break;
01069    default:
01070       ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", buf & TYPE_MASK);
01071    }
01072    return -1;
01073 }

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

Definition at line 1075 of file frame.c.

References g723_len().

Referenced by ast_codec_get_samples().

01076 {
01077    int pos = 0;
01078    int samples = 0;
01079    int res;
01080    while(pos < maxlen) {
01081       res = g723_len(buf[pos]);
01082       if (res <= 0)
01083          break;
01084       samples += 240;
01085       pos += res;
01086    }
01087    return samples;
01088 }

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

Definition at line 1090 of file frame.c.

Referenced by speex_get_wb_sz_at(), and speex_samples().

01091 {
01092    int byte = bit / 8;       /* byte containing first bit */
01093    int rem = 8 - (bit % 8);  /* remaining bits in first byte */
01094    unsigned char ret = 0;
01095    
01096    if (n <= 0 || n > 8)
01097       return 0;
01098 
01099    if (rem < n) {
01100       ret = (data[byte] << (n - rem));
01101       ret |= (data[byte + 1] >> (8 - n + rem));
01102    } else {
01103       ret = (data[byte] >> (rem - n));
01104    }
01105 
01106    return (ret & (0xff >> (8 - n)));
01107 }

int init_framer ( void   ) 

Definition at line 867 of file frame.c.

References ast_cli_register_multiple(), and my_clis.

Referenced by main().

00868 {
00869    ast_cli_register_multiple(my_clis, sizeof(my_clis)/sizeof(my_clis[0]) );
00870    return 0;   
00871 }

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

Definition at line 645 of file frame.c.

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

00646 {
00647    int codec, i, found=0;
00648 
00649    if (argc != 3)
00650       return RESULT_SHOWUSAGE;
00651 
00652    if (sscanf(argv[2],"%d",&codec) != 1)
00653       return RESULT_SHOWUSAGE;
00654 
00655    for (i=0;i<32;i++)
00656       if (codec & (1 << i)) {
00657          found = 1;
00658          ast_cli(fd, "%11u (1 << %2d)  %s\n",1 << i,i,ast_codec2str(1<<i));
00659       }
00660 
00661    if (! found)
00662       ast_cli(fd, "Codec %d not found\n", codec);
00663 
00664    return RESULT_SUCCESS;
00665 }

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

Definition at line 597 of file frame.c.

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

00598 {
00599    int i, found=0;
00600    char hex[25];
00601    
00602    if ((argc < 2) || (argc > 3))
00603       return RESULT_SHOWUSAGE;
00604 
00605    if (!option_dontwarn)
00606       ast_cli(fd, "Disclaimer: this command is for informational purposes only.\n"
00607             "\tIt does not indicate anything about your configuration.\n");
00608 
00609    ast_cli(fd, "%11s %9s %10s   TYPE   %5s   %s\n","INT","BINARY","HEX","NAME","DESC");
00610    ast_cli(fd, "--------------------------------------------------------------------------------\n");
00611    if ((argc == 2) || (!strcasecmp(argv[1],"audio"))) {
00612       found = 1;
00613       for (i=0;i<11;i++) {
00614          snprintf(hex,25,"(0x%x)",1<<i);
00615          ast_cli(fd, "%11u (1 << %2d) %10s  audio   %5s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00616       }
00617    }
00618 
00619    if ((argc == 2) || (!strcasecmp(argv[1],"image"))) {
00620       found = 1;
00621       for (i=16;i<18;i++) {
00622          snprintf(hex,25,"(0x%x)",1<<i);
00623          ast_cli(fd, "%11u (1 << %2d) %10s  image   %5s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00624       }
00625    }
00626 
00627    if ((argc == 2) || (!strcasecmp(argv[1],"video"))) {
00628       found = 1;
00629       for (i=18;i<21;i++) {
00630          snprintf(hex,25,"(0x%x)",1<<i);
00631          ast_cli(fd, "%11u (1 << %2d) %10s  video   %5s   (%s)\n",1 << i,i,hex,ast_getformatname(1<<i),ast_codec2str(1<<i));
00632       }
00633    }
00634 
00635    if (! found)
00636       return RESULT_SHOWUSAGE;
00637    else
00638       return RESULT_SUCCESS;
00639 }

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

Definition at line 1109 of file frame.c.

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

Referenced by speex_samples().

01110 {
01111    static int SpeexWBSubModeSz[] = {
01112       0, 36, 112, 192,
01113       352, 0, 0, 0 };
01114    int off = bit;
01115    unsigned char c;
01116 
01117    /* skip up to two wideband frames */
01118    if (((len * 8 - off) >= 5) && 
01119       get_n_bits_at(data, 1, off)) {
01120       c = get_n_bits_at(data, 3, off + 1);
01121       off += SpeexWBSubModeSz[c];
01122 
01123       if (((len * 8 - off) >= 5) && 
01124          get_n_bits_at(data, 1, off)) {
01125          c = get_n_bits_at(data, 3, off + 1);
01126          off += SpeexWBSubModeSz[c];
01127 
01128          if (((len * 8 - off) >= 5) && 
01129             get_n_bits_at(data, 1, off)) {
01130             ast_log(LOG_WARNING, "Encountered corrupt speex frame; too many wideband frames in a row.\n");
01131             return -1;
01132          }
01133       }
01134 
01135    }
01136    return off - bit;
01137 }

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

Definition at line 1139 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().

01140 {
01141    static int SpeexSubModeSz[] = {
01142                5, 43, 119, 160,
01143       220, 300, 364, 492, 
01144       79, 0, 0, 0,
01145       0, 0, 0, 0 };
01146    static int SpeexInBandSz[] = { 
01147       1, 1, 4, 4,
01148       4, 4, 4, 4,
01149       8, 8, 16, 16,
01150       32, 32, 64, 64 };
01151    int bit = 0;
01152    int cnt = 0;
01153    int off = 0;
01154    unsigned char c;
01155 
01156    while ((len * 8 - bit) >= 5) {
01157       /* skip wideband frames */
01158       off = speex_get_wb_sz_at(data, len, bit);
01159       if (off < 0)  {
01160          ast_log(LOG_WARNING, "Had error while reading wideband frames for speex samples\n");
01161          break;
01162       }
01163       bit += off;
01164 
01165       if ((len * 8 - bit) < 5) {
01166          ast_log(LOG_WARNING, "Not enough bits remaining after wide band for speex samples.\n");
01167          break;
01168       }
01169 
01170       /* get control bits */
01171       c = get_n_bits_at(data, 5, bit);
01172       bit += 5;
01173 
01174       if (c == 15) { 
01175          /* terminator */
01176          break; 
01177       } else if (c == 14) {
01178          /* in-band signal; next 4 bits contain signal id */
01179          c = get_n_bits_at(data, 4, bit);
01180          bit += 4;
01181          bit += SpeexInBandSz[c];
01182       } else if (c == 13) {
01183          /* user in-band; next 5 bits contain msg len */
01184          c = get_n_bits_at(data, 5, bit);
01185          bit += 5;
01186          bit += c * 8;
01187       } else if (c > 8) {
01188          /* unknown */
01189          break;
01190       } else {
01191          /* skip number bits for submode (less the 5 control bits) */
01192          bit += SpeexSubModeSz[c] - 5;
01193          cnt += 160; /* new frame */
01194       }
01195    }
01196    return cnt;
01197 }


Variable Documentation

struct ast_format_list AST_FORMAT_LIST[] [static]

Definition of supported media formats (codecs).

Definition at line 81 of file frame.c.

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

char frame_show_codec_n_usage[] [static]

Initial value:

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

Definition at line 667 of file frame.c.

char frame_show_codecs_usage[] [static]

Initial value:

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

Definition at line 641 of file frame.c.

struct ast_cli_entry my_clis[] [static]

Definition at line 856 of file frame.c.

Referenced by init_framer(), load_module(), and unload_module().


Generated on Thu May 24 14:22:35 2007 for Asterisk - the Open Source PBX by  doxygen 1.4.7