format_pcm.c File Reference

Flat, binary, ulaw PCM file format. More...

#include "asterisk.h"
#include "asterisk/mod_format.h"
#include "asterisk/module.h"
#include "asterisk/endian.h"
#include "asterisk/ulaw.h"
#include "asterisk/alaw.h"
#include "asterisk/format_cache.h"

Include dependency graph for format_pcm.c:

Go to the source code of this file.

Defines

#define AU_ENC_8BIT_ULAW   1
#define AU_HDR_CHANNELS_OFF   5
#define AU_HDR_DATA_SIZE_OFF   2
#define AU_HDR_ENCODING_OFF   3
#define AU_HDR_HDR_SIZE_OFF   1
#define AU_HDR_MAGIC_OFF   0
#define AU_HDR_SAMPLE_RATE_OFF   4
#define AU_HEADER(var)   uint32_t var[6]
#define AU_HEADER_SIZE   24
#define AU_MAGIC   0x2e736e64
#define BUF_SIZE   160

Functions

static void __reg_module (void)
static void __unreg_module (void)
static int au_open (struct ast_filestream *s)
static int au_rewrite (struct ast_filestream *s, const char *comment)
static int au_seek (struct ast_filestream *fs, off_t sample_offset, int whence)
static off_t au_tell (struct ast_filestream *fs)
static int au_trunc (struct ast_filestream *fs)
static int check_header (FILE *f)
static int load_module (void)
static struct ast_framepcm_read (struct ast_filestream *s, int *whennext)
static int pcm_seek (struct ast_filestream *fs, off_t sample_offset, int whence)
static off_t pcm_tell (struct ast_filestream *fs)
static int pcm_trunc (struct ast_filestream *fs)
static int pcm_write (struct ast_filestream *fs, struct ast_frame *f)
static int unload_module (void)
static int update_header (FILE *f)
static int write_header (FILE *f)

Variables

static struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Raw/Sun uLaw/ALaw 8KHz (PCM,PCMA,AU), G.722 16Khz" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND }
static struct ast_format_def alaw_f
static char alaw_silence [BUF_SIZE]
static struct ast_module_infoast_module_info = &__mod_info
static struct ast_format_def au_f
static struct ast_format_def g722_f
static struct ast_format_def pcm_f
static char ulaw_silence [BUF_SIZE]


Detailed Description

Flat, binary, ulaw PCM file format.

Definition in file format_pcm.c.


Define Documentation

#define AU_ENC_8BIT_ULAW   1

Definition at line 246 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_CHANNELS_OFF   5

Definition at line 244 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_DATA_SIZE_OFF   2

Definition at line 241 of file format_pcm.c.

Referenced by update_header(), and write_header().

#define AU_HDR_ENCODING_OFF   3

Definition at line 242 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_HDR_SIZE_OFF   1

Definition at line 240 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_MAGIC_OFF   0

Definition at line 239 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_SAMPLE_RATE_OFF   4

Definition at line 243 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HEADER ( var   )     uint32_t var[6]

Definition at line 237 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HEADER_SIZE   24

Definition at line 236 of file format_pcm.c.

Referenced by au_seek(), au_tell(), check_header(), update_header(), and write_header().

#define AU_MAGIC   0x2e736e64

Definition at line 248 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define BUF_SIZE   160

Definition at line 42 of file format_pcm.c.


Function Documentation

static void __reg_module ( void   )  [static]

Definition at line 540 of file format_pcm.c.

static void __unreg_module ( void   )  [static]

Definition at line 540 of file format_pcm.c.

static int au_open ( struct ast_filestream s  )  [static]

Definition at line 371 of file format_pcm.c.

References check_header(), and ast_filestream::f.

00372 {
00373    if (check_header(s->f) < 0)
00374       return -1;
00375    return 0;
00376 }

static int au_rewrite ( struct ast_filestream s,
const char *  comment 
) [static]

Definition at line 378 of file format_pcm.c.

References ast_filestream::f, and write_header().

00379 {
00380    if (write_header(s->f))
00381       return -1;
00382    return 0;
00383 }

static int au_seek ( struct ast_filestream fs,
off_t  sample_offset,
int  whence 
) [static]

Definition at line 386 of file format_pcm.c.

References ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_g722, ast_log, AST_LOG_WARNING, AU_HEADER_SIZE, errno, ast_filestream::f, ast_filestream::fmt, ast_format_def::format, max, min, and SEEK_FORCECUR.

00387 {
00388    off_t min = AU_HEADER_SIZE, max, cur;
00389    long offset = 0, bytes;
00390 
00391    if (ast_format_cmp(fs->fmt->format, ast_format_g722) == AST_FORMAT_CMP_EQUAL)
00392       bytes = sample_offset / 2;
00393    else
00394       bytes = sample_offset;
00395 
00396    if ((cur = ftello(fs->f)) < 0) {
00397       ast_log(AST_LOG_WARNING, "Unable to determine current position in au filestream %p: %s\n", fs, strerror(errno));
00398       return -1;
00399    }
00400 
00401    if (fseeko(fs->f, 0, SEEK_END) < 0) {
00402       ast_log(AST_LOG_WARNING, "Unable to seek to end of au filestream %p: %s\n", fs, strerror(errno));
00403       return -1;
00404    }
00405 
00406    if ((max = ftello(fs->f)) < 0) {
00407       ast_log(AST_LOG_WARNING, "Unable to determine max position in au filestream %p: %s\n", fs, strerror(errno));
00408       return -1;
00409    }
00410 
00411    if (whence == SEEK_SET)
00412       offset = bytes + min;
00413    else if (whence == SEEK_CUR || whence == SEEK_FORCECUR)
00414       offset = bytes + cur;
00415    else if (whence == SEEK_END)
00416       offset = max - bytes;
00417 
00418    if (whence != SEEK_FORCECUR) {
00419       offset = (offset > max) ? max : offset;
00420    }
00421 
00422    /* always protect the header space. */
00423    offset = (offset < min) ? min : offset;
00424 
00425    return fseeko(fs->f, offset, SEEK_SET);
00426 }

static off_t au_tell ( struct ast_filestream fs  )  [static]

Definition at line 448 of file format_pcm.c.

References AU_HEADER_SIZE, and ast_filestream::f.

00449 {
00450    off_t offset = ftello(fs->f);
00451    return offset - AU_HEADER_SIZE;
00452 }

static int au_trunc ( struct ast_filestream fs  )  [static]

Definition at line 428 of file format_pcm.c.

References ast_log, AST_LOG_WARNING, errno, ast_filestream::f, and update_header().

00429 {
00430    int fd;
00431    off_t cur;
00432 
00433    if ((fd = fileno(fs->f)) < 0) {
00434       ast_log(AST_LOG_WARNING, "Unable to determine file descriptor for au filestream %p: %s\n", fs, strerror(errno));
00435       return -1;
00436    }
00437    if ((cur = ftello(fs->f)) < 0) {
00438       ast_log(AST_LOG_WARNING, "Unable to determine current position in au filestream %p: %s\n", fs, strerror(errno));
00439       return -1;
00440    }
00441    /* Truncate file to current length */
00442    if (ftruncate(fd, cur)) {
00443       return -1;
00444    }
00445    return update_header(fs->f);
00446 }

static int check_header ( FILE *  f  )  [static]

Definition at line 271 of file format_pcm.c.

References ast_log, AU_ENC_8BIT_ULAW, AU_HDR_CHANNELS_OFF, AU_HDR_ENCODING_OFF, AU_HDR_HDR_SIZE_OFF, AU_HDR_MAGIC_OFF, AU_HDR_SAMPLE_RATE_OFF, AU_HEADER, AU_HEADER_SIZE, AU_MAGIC, channels, DEFAULT_SAMPLE_RATE, encoding, and LOG_WARNING.

Referenced by au_open(), and wav_open().

00272 {
00273    AU_HEADER(header);
00274    uint32_t magic;
00275    uint32_t hdr_size;
00276    uint32_t data_size;
00277    uint32_t encoding;
00278    uint32_t sample_rate;
00279    uint32_t channels;
00280 
00281    if (fread(header, 1, AU_HEADER_SIZE, f) != AU_HEADER_SIZE) {
00282       ast_log(LOG_WARNING, "Read failed (header)\n");
00283       return -1;
00284    }
00285    magic = ltohl(header[AU_HDR_MAGIC_OFF]);
00286    if (magic != (uint32_t) AU_MAGIC) {
00287       ast_log(LOG_WARNING, "Bad magic: 0x%x\n", magic);
00288    }
00289    hdr_size = ltohl(header[AU_HDR_HDR_SIZE_OFF]);
00290    if (hdr_size < AU_HEADER_SIZE) {
00291       hdr_size = AU_HEADER_SIZE;
00292    }
00293 /* data_size = ltohl(header[AU_HDR_DATA_SIZE_OFF]); */
00294    encoding = ltohl(header[AU_HDR_ENCODING_OFF]);
00295    if (encoding != AU_ENC_8BIT_ULAW) {
00296       ast_log(LOG_WARNING, "Unexpected format: %u. Only 8bit ULAW allowed (%d)\n", encoding, AU_ENC_8BIT_ULAW);
00297       return -1;
00298    }
00299    sample_rate = ltohl(header[AU_HDR_SAMPLE_RATE_OFF]);
00300    if (sample_rate != DEFAULT_SAMPLE_RATE) {
00301       ast_log(LOG_WARNING, "Sample rate can only be 8000 not %u\n", sample_rate);
00302       return -1;
00303    }
00304    channels = ltohl(header[AU_HDR_CHANNELS_OFF]);
00305    if (channels != 1) {
00306       ast_log(LOG_WARNING, "Not in mono: channels=%u\n", channels);
00307       return -1;
00308    }
00309    /* Skip to data */
00310    fseek(f, 0, SEEK_END);
00311    data_size = ftell(f) - hdr_size;
00312    if (fseek(f, hdr_size, SEEK_SET) == -1 ) {
00313       ast_log(LOG_WARNING, "Failed to skip to data: %u\n", hdr_size);
00314       return -1;
00315    }
00316    return data_size;
00317 }

static int load_module ( void   )  [static]

Definition at line 505 of file format_pcm.c.

References ARRAY_LEN, ast_format_alaw, ast_format_def_register, ast_format_g722, ast_format_ulaw, AST_LIN2A, AST_LIN2MU, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, and ast_format_def::format.

00506 {
00507    int i;
00508 
00509    /* XXX better init ? */
00510    for (i = 0; i < ARRAY_LEN(ulaw_silence); i++)
00511       ulaw_silence[i] = AST_LIN2MU(0);
00512    for (i = 0; i < ARRAY_LEN(alaw_silence); i++)
00513       alaw_silence[i] = AST_LIN2A(0);
00514 
00515    pcm_f.format = ast_format_ulaw;
00516    alaw_f.format = ast_format_alaw;
00517    au_f.format = ast_format_ulaw;
00518    g722_f.format = ast_format_g722;
00519    if ( ast_format_def_register(&pcm_f)
00520       || ast_format_def_register(&alaw_f)
00521       || ast_format_def_register(&au_f)
00522       || ast_format_def_register(&g722_f) )
00523       return AST_MODULE_LOAD_FAILURE;
00524    return AST_MODULE_LOAD_SUCCESS;
00525 }

static struct ast_frame* pcm_read ( struct ast_filestream s,
int *  whennext 
) [static, read]

Definition at line 81 of file format_pcm.c.

References ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_g722, AST_FRAME_SET_BUFFER, AST_FRIENDLY_OFFSET, ast_log, ast_filestream::buf, BUF_SIZE, ast_frame::data, ast_frame::datalen, errno, ast_filestream::f, ast_filestream::fmt, ast_format_def::format, ast_filestream::fr, LOG_WARNING, NULL, ast_frame::ptr, and ast_frame::samples.

00082 {
00083    int res;
00084    
00085    /* Send a frame from the file to the appropriate channel */
00086 
00087    AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
00088    if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) < 1) {
00089       if (res)
00090          ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
00091       return NULL;
00092    }
00093    s->fr.datalen = res;
00094    if (ast_format_cmp(s->fmt->format, ast_format_g722) == AST_FORMAT_CMP_EQUAL)
00095       *whennext = s->fr.samples = res * 2;
00096    else
00097       *whennext = s->fr.samples = res;
00098    return &s->fr;
00099 }

static int pcm_seek ( struct ast_filestream fs,
off_t  sample_offset,
int  whence 
) [static]

Definition at line 101 of file format_pcm.c.

References ast_format_alaw, ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_log, AST_LOG_WARNING, BUF_SIZE, errno, ast_filestream::f, ast_filestream::fmt, ast_format_def::format, LOG_WARNING, max, ast_frame::offset, SEEK_FORCECUR, and ast_frame::src.

00102 {
00103    off_t cur, max, offset = 0;
00104    int ret = -1;  /* assume error */
00105 
00106    if ((cur = ftello(fs->f)) < 0) {
00107       ast_log(AST_LOG_WARNING, "Unable to determine current position in pcm filestream %p: %s\n", fs, strerror(errno));
00108       return -1;
00109    }
00110 
00111    if (fseeko(fs->f, 0, SEEK_END) < 0) {
00112       ast_log(AST_LOG_WARNING, "Unable to seek to end of pcm filestream %p: %s\n", fs, strerror(errno));
00113       return -1;
00114    }
00115 
00116    if ((max = ftello(fs->f)) < 0) {
00117       ast_log(AST_LOG_WARNING, "Unable to determine max position in pcm filestream %p: %s\n", fs, strerror(errno));
00118       return -1;
00119    }
00120 
00121    switch (whence) {
00122    case SEEK_SET:
00123       offset = sample_offset;
00124       break;
00125    case SEEK_END:
00126       offset = max - sample_offset;
00127       break;
00128    case SEEK_CUR:
00129    case SEEK_FORCECUR:
00130       offset = cur + sample_offset;
00131       break;
00132    default:
00133       ast_log(LOG_WARNING, "invalid whence %d, assuming SEEK_SET\n", whence);
00134       offset = sample_offset;
00135    }
00136    if (offset < 0) {
00137       ast_log(LOG_WARNING, "negative offset %ld, resetting to 0\n", (long) offset);
00138       offset = 0;
00139    }
00140    if (whence == SEEK_FORCECUR && offset > max) { /* extend the file */
00141       size_t left = offset - max;
00142       const char *src = (ast_format_cmp(fs->fmt->format, ast_format_alaw) == AST_FORMAT_CMP_EQUAL) ? alaw_silence : ulaw_silence;
00143 
00144       while (left) {
00145          size_t written = fwrite(src, 1, (left > BUF_SIZE) ? BUF_SIZE : left, fs->f);
00146          if (written == -1)
00147             break;   /* error */
00148          left -= written;
00149       }
00150       ret = 0; /* successful */
00151    } else {
00152       if (offset > max) {
00153          ast_log(LOG_WARNING, "offset too large %ld, truncating to %ld\n", (long) offset, (long) max);
00154          offset = max;
00155       }
00156       ret = fseeko(fs->f, offset, SEEK_SET);
00157    }
00158    return ret;
00159 }

static off_t pcm_tell ( struct ast_filestream fs  )  [static]

Definition at line 177 of file format_pcm.c.

References ast_filestream::f.

00178 {
00179    return ftello(fs->f);
00180 }

static int pcm_trunc ( struct ast_filestream fs  )  [static]

Definition at line 161 of file format_pcm.c.

References ast_log, AST_LOG_WARNING, errno, and ast_filestream::f.

00162 {
00163    int cur, fd;
00164 
00165    if ((fd = fileno(fs->f)) < 0) {
00166       ast_log(AST_LOG_WARNING, "Unable to determine file descriptor for pcm filestream %p: %s\n", fs, strerror(errno));
00167       return -1;
00168    }
00169    if ((cur = ftello(fs->f)) < 0) {
00170       ast_log(AST_LOG_WARNING, "Unable to determine current position in pcm filestream %p: %s\n", fs, strerror(errno));
00171       return -1;
00172    }
00173    /* Truncate file to current length */
00174    return ftruncate(fd, cur);
00175 }

static int pcm_write ( struct ast_filestream fs,
struct ast_frame f 
) [static]

Definition at line 182 of file format_pcm.c.

References ast_filestream::_private, ast_format_alaw, ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_log, buf, ast_frame::data, ast_frame::datalen, errno, ast_filestream::f, ast_filestream::fmt, ast_format_def::format, LOG_WARNING, and ast_frame::ptr.

00183 {
00184    int res;
00185 
00186 #ifdef REALTIME_WRITE
00187    if (ast_format_cmp(s->fmt->format, ast_format_alaw) == AST_FORMAT_CMP_EQUAL) {
00188       struct pcm_desc *pd = (struct pcm_desc *)fs->_private;
00189       struct stat stat_buf;
00190       unsigned long cur_time = get_time();
00191       unsigned long fpos = ( cur_time - pd->start_time ) * 8;  /* 8 bytes per msec */
00192       /* Check if we have written to this position yet. If we have, then increment pos by one frame
00193       *  for some degree of protection against receiving packets in the same clock tick.
00194       */
00195       
00196       fstat(fileno(fs->f), &stat_buf );
00197       if (stat_buf.st_size > fpos )
00198          fpos += f->datalen;  /* Incrementing with the size of this current frame */
00199 
00200       if (stat_buf.st_size < fpos) {
00201          /* fill the gap with 0x55 rather than 0. */
00202          char buf[1024];
00203          unsigned long cur, to_write;
00204 
00205          cur = stat_buf.st_size;
00206          if (fseek(fs->f, cur, SEEK_SET) < 0) {
00207             ast_log( LOG_WARNING, "Cannot seek in file: %s\n", strerror(errno) );
00208             return -1;
00209          }
00210          memset(buf, 0x55, 512);
00211          while (cur < fpos) {
00212             to_write = fpos - cur;
00213             if (to_write > sizeof(buf))
00214                to_write = sizeof(buf);
00215             fwrite(buf, 1, to_write, fs->f);
00216             cur += to_write;
00217          }
00218       }
00219 
00220       if (fseek(s->f, fpos, SEEK_SET) < 0) {
00221          ast_log( LOG_WARNING, "Cannot seek in file: %s\n", strerror(errno) );
00222          return -1;
00223       }
00224    }
00225 #endif   /* REALTIME_WRITE */
00226    
00227    if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen) {
00228       ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
00229       return -1;
00230    }
00231    return 0;
00232 }

static int unload_module ( void   )  [static]

static int update_header ( FILE *  f  )  [static]

Definition at line 319 of file format_pcm.c.

References ast_log, AU_HDR_DATA_SIZE_OFF, AU_HEADER_SIZE, end, and LOG_WARNING.

Referenced by au_trunc(), func_write_header(), wav_close(), and wav_trunc().

00320 {
00321    off_t cur, end;
00322    uint32_t datalen;
00323    int bytes;
00324 
00325    cur = ftell(f);
00326    fseek(f, 0, SEEK_END);
00327    end = ftell(f);
00328    /* data starts 24 bytes in */
00329    bytes = end - AU_HEADER_SIZE;
00330    datalen = htoll(bytes);
00331 
00332    if (cur < 0) {
00333       ast_log(LOG_WARNING, "Unable to find our position\n");
00334       return -1;
00335    }
00336    if (fseek(f, AU_HDR_DATA_SIZE_OFF * sizeof(uint32_t), SEEK_SET)) {
00337       ast_log(LOG_WARNING, "Unable to set our position\n");
00338       return -1;
00339    }
00340    if (fwrite(&datalen, 1, sizeof(datalen), f) != sizeof(datalen)) {
00341       ast_log(LOG_WARNING, "Unable to set write file size\n");
00342       return -1;
00343    }
00344    if (fseek(f, cur, SEEK_SET)) {
00345       ast_log(LOG_WARNING, "Unable to return to position\n");
00346       return -1;
00347    }
00348    return 0;
00349 }

static int write_header ( FILE *  f  )  [static]

Definition at line 351 of file format_pcm.c.

References ast_log, AU_ENC_8BIT_ULAW, AU_HDR_CHANNELS_OFF, AU_HDR_DATA_SIZE_OFF, AU_HDR_ENCODING_OFF, AU_HDR_HDR_SIZE_OFF, AU_HDR_MAGIC_OFF, AU_HDR_SAMPLE_RATE_OFF, AU_HEADER, AU_HEADER_SIZE, AU_MAGIC, DEFAULT_SAMPLE_RATE, and LOG_WARNING.

Referenced by au_rewrite(), and wav_rewrite().

00352 {
00353    AU_HEADER(header);
00354 
00355    header[AU_HDR_MAGIC_OFF] = htoll((uint32_t) AU_MAGIC);
00356    header[AU_HDR_HDR_SIZE_OFF] = htoll(AU_HEADER_SIZE);
00357    header[AU_HDR_DATA_SIZE_OFF] = 0;
00358    header[AU_HDR_ENCODING_OFF] = htoll(AU_ENC_8BIT_ULAW);
00359    header[AU_HDR_SAMPLE_RATE_OFF] = htoll(DEFAULT_SAMPLE_RATE);
00360    header[AU_HDR_CHANNELS_OFF] = htoll(1);
00361 
00362    /* Write an au header, ignoring sizes which will be filled in later */
00363    fseek(f, 0, SEEK_SET);
00364    if (fwrite(header, 1, AU_HEADER_SIZE, f) != AU_HEADER_SIZE) {
00365       ast_log(LOG_WARNING, "Unable to write header\n");
00366       return -1;
00367    }
00368    return 0;
00369 }


Variable Documentation

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Raw/Sun uLaw/ALaw 8KHz (PCM,PCMA,AU), G.722 16Khz" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND } [static]

Definition at line 540 of file format_pcm.c.

struct ast_format_def alaw_f [static]

Definition at line 454 of file format_pcm.c.

char alaw_silence[BUF_SIZE] [static]

Definition at line 45 of file format_pcm.c.

Definition at line 540 of file format_pcm.c.

struct ast_format_def au_f [static]

Definition at line 492 of file format_pcm.c.

struct ast_format_def g722_f [static]

Definition at line 481 of file format_pcm.c.

struct ast_format_def pcm_f [static]

Definition at line 470 of file format_pcm.c.

char ulaw_silence[BUF_SIZE] [static]

Definition at line 44 of file format_pcm.c.


Generated on Thu Apr 16 06:31:07 2015 for Asterisk - The Open Source Telephony Project by  doxygen 1.5.6