Mon Mar 12 2012 21:39:39

Asterisk developer's documentation

Defines | Functions | Variables
format_pcm.c File Reference
Module: Media File Formats

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 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_frame * pcm_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, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND }
static struct ast_format alaw_f
static char alaw_silence [BUF_SIZE]
static struct ast_module_info * ast_module_info = &__mod_info
static struct ast_format au_f
static struct ast_format g722_f
static struct ast_format pcm_f
static char ulaw_silence [BUF_SIZE]

Detailed Description

Flat, binary, ulaw PCM file format.

  • File name extension: alaw, al, alw, pcm, ulaw, ul, mu, ulw, g722, au

Definition in file format_pcm.c.

Define Documentation

#define AU_ENC_8BIT_ULAW   1

Definition at line 235 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_CHANNELS_OFF   5

Definition at line 233 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_DATA_SIZE_OFF   2

Definition at line 230 of file format_pcm.c.

Referenced by update_header(), and write_header().

#define AU_HDR_ENCODING_OFF   3

Definition at line 231 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_HDR_SIZE_OFF   1

Definition at line 229 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_MAGIC_OFF   0

Definition at line 228 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_SAMPLE_RATE_OFF   4

Definition at line 232 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HEADER (   var)    uint32_t var[6]

Definition at line 226 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HEADER_SIZE   24

Definition at line 225 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 237 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define BUF_SIZE   160

Definition at line 41 of file format_pcm.c.

Referenced by pcm_read(), and pcm_seek().

Function Documentation

static void __reg_module ( void  ) [static]

Definition at line 505 of file format_pcm.c.

static void __unreg_module ( void  ) [static]

Definition at line 505 of file format_pcm.c.

static int au_open ( struct ast_filestream *  s) [static]

Definition at line 360 of file format_pcm.c.

References check_header(), and ast_filestream::f.

{
   if (check_header(s->f) < 0)
      return -1;
   return 0;
}
static int au_rewrite ( struct ast_filestream *  s,
const char *  comment 
) [static]

Definition at line 367 of file format_pcm.c.

References ast_filestream::f, and write_header().

{
   if (write_header(s->f))
      return -1;
   return 0;
}
static int au_seek ( struct ast_filestream *  fs,
off_t  sample_offset,
int  whence 
) [static]

Definition at line 375 of file format_pcm.c.

References AST_FORMAT_G722, AU_HEADER_SIZE, ast_filestream::f, ast_filestream::fmt, ast_format::format, and SEEK_FORCECUR.

{
   off_t min, max, cur;
   long offset = 0, bytes;

   if (fs->fmt->format == AST_FORMAT_G722)
      bytes = sample_offset / 2;
   else
      bytes = sample_offset;

   min = AU_HEADER_SIZE;
   cur = ftello(fs->f);
   fseek(fs->f, 0, SEEK_END);
   max = ftello(fs->f);

   if (whence == SEEK_SET)
      offset = bytes + min;
   else if (whence == SEEK_CUR || whence == SEEK_FORCECUR)
      offset = bytes + cur;
   else if (whence == SEEK_END)
      offset = max - bytes;

   if (whence != SEEK_FORCECUR) {
      offset = (offset > max) ? max : offset;
   }

   /* always protect the header space. */
   offset = (offset < min) ? min : offset;

   return fseeko(fs->f, offset, SEEK_SET);
}
static off_t au_tell ( struct ast_filestream *  fs) [static]

Definition at line 414 of file format_pcm.c.

References AU_HEADER_SIZE, and ast_filestream::f.

{
   off_t offset = ftello(fs->f);
   return offset - AU_HEADER_SIZE;
}
static int au_trunc ( struct ast_filestream *  fs) [static]

Definition at line 407 of file format_pcm.c.

References ast_filestream::f, and update_header().

{
   if (ftruncate(fileno(fs->f), ftell(fs->f)))
      return -1;
   return update_header(fs->f);
}
static int check_header ( FILE *  f) [static]

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

{
   AU_HEADER(header);
   uint32_t magic;
   uint32_t hdr_size;
   uint32_t data_size;
   uint32_t encoding;
   uint32_t sample_rate;
   uint32_t channels;

   if (fread(header, 1, AU_HEADER_SIZE, f) != AU_HEADER_SIZE) {
      ast_log(LOG_WARNING, "Read failed (header)\n");
      return -1;
   }
   magic = ltohl(header[AU_HDR_MAGIC_OFF]);
   if (magic != (uint32_t) AU_MAGIC) {
      ast_log(LOG_WARNING, "Bad magic: 0x%x\n", magic);
   }
   hdr_size = ltohl(header[AU_HDR_HDR_SIZE_OFF]);
   if (hdr_size < AU_HEADER_SIZE) {
      hdr_size = AU_HEADER_SIZE;
   }
/* data_size = ltohl(header[AU_HDR_DATA_SIZE_OFF]); */
   encoding = ltohl(header[AU_HDR_ENCODING_OFF]);
   if (encoding != AU_ENC_8BIT_ULAW) {
      ast_log(LOG_WARNING, "Unexpected format: %d. Only 8bit ULAW allowed (%d)\n", encoding, AU_ENC_8BIT_ULAW);
      return -1;
   }
   sample_rate = ltohl(header[AU_HDR_SAMPLE_RATE_OFF]);
   if (sample_rate != DEFAULT_SAMPLE_RATE) {
      ast_log(LOG_WARNING, "Sample rate can only be 8000 not %d\n", sample_rate);
      return -1;
   }
   channels = ltohl(header[AU_HDR_CHANNELS_OFF]);
   if (channels != 1) {
      ast_log(LOG_WARNING, "Not in mono: channels=%d\n", channels);
      return -1;
   }
   /* Skip to data */
   fseek(f, 0, SEEK_END);
   data_size = ftell(f) - hdr_size;
   if (fseek(f, hdr_size, SEEK_SET) == -1 ) {
      ast_log(LOG_WARNING, "Failed to skip to data: %d\n", hdr_size);
      return -1;
   }
   return data_size;
}
static int load_module ( void  ) [static]

Definition at line 475 of file format_pcm.c.

References ARRAY_LEN, ast_format_register, AST_LIN2A, AST_LIN2MU, AST_MODULE_LOAD_FAILURE, and AST_MODULE_LOAD_SUCCESS.

{
   int i;

   /* XXX better init ? */
   for (i = 0; i < ARRAY_LEN(ulaw_silence); i++)
      ulaw_silence[i] = AST_LIN2MU(0);
   for (i = 0; i < ARRAY_LEN(alaw_silence); i++)
      alaw_silence[i] = AST_LIN2A(0);

   if ( ast_format_register(&pcm_f)
      || ast_format_register(&alaw_f)
      || ast_format_register(&au_f)
      || ast_format_register(&g722_f) )
      return AST_MODULE_LOAD_FAILURE;
   return AST_MODULE_LOAD_SUCCESS;
}
static struct ast_frame* pcm_read ( struct ast_filestream *  s,
int *  whennext 
) [static, read]

Definition at line 80 of file format_pcm.c.

References AST_FORMAT_G722, AST_FRAME_SET_BUFFER, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), ast_filestream::buf, BUF_SIZE, ast_frame_subclass::codec, ast_frame::data, ast_frame::datalen, errno, ast_filestream::f, ast_filestream::fmt, ast_format::format, ast_filestream::fr, ast_frame::frametype, LOG_WARNING, ast_frame::mallocd, ast_frame::ptr, ast_frame::samples, and ast_frame::subclass.

{
   int res;
   
   /* Send a frame from the file to the appropriate channel */

   s->fr.frametype = AST_FRAME_VOICE;
   s->fr.subclass.codec = s->fmt->format;
   s->fr.mallocd = 0;
   AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
   if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) < 1) {
      if (res)
         ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
      return NULL;
   }
   s->fr.datalen = res;
   if (s->fmt->format == AST_FORMAT_G722)
      *whennext = s->fr.samples = res * 2;
   else
      *whennext = s->fr.samples = res;
   return &s->fr;
}
static int pcm_seek ( struct ast_filestream *  fs,
off_t  sample_offset,
int  whence 
) [static]

Definition at line 103 of file format_pcm.c.

References AST_FORMAT_ALAW, ast_log(), BUF_SIZE, ast_filestream::f, ast_filestream::fmt, ast_format::format, LOG_WARNING, ast_frame::offset, SEEK_FORCECUR, and ast_frame::src.

{
   off_t cur, max, offset = 0;
   int ret = -1;  /* assume error */

   cur = ftello(fs->f);
   fseeko(fs->f, 0, SEEK_END);
   max = ftello(fs->f);

   switch (whence) {
   case SEEK_SET:
      offset = sample_offset;
      break;
   case SEEK_END:
      offset = max - sample_offset;
      break;
   case SEEK_CUR:
   case SEEK_FORCECUR:
      offset = cur + sample_offset;
      break;
   default:
      ast_log(LOG_WARNING, "invalid whence %d, assuming SEEK_SET\n", whence);
      offset = sample_offset;
   }
   if (offset < 0) {
      ast_log(LOG_WARNING, "negative offset %ld, resetting to 0\n", (long) offset);
      offset = 0;
   }
   if (whence == SEEK_FORCECUR && offset > max) { /* extend the file */
      size_t left = offset - max;
      const char *src = (fs->fmt->format == AST_FORMAT_ALAW) ? alaw_silence : ulaw_silence;

      while (left) {
         size_t written = fwrite(src, 1, (left > BUF_SIZE) ? BUF_SIZE : left, fs->f);
         if (written == -1)
            break;   /* error */
         left -= written;
      }
      ret = 0; /* successful */
   } else {
      if (offset > max) {
         ast_log(LOG_WARNING, "offset too large %ld, truncating to %ld\n", (long) offset, (long) max);
         offset = max;
      }
      ret = fseeko(fs->f, offset, SEEK_SET);
   }
   return ret;
}
static off_t pcm_tell ( struct ast_filestream *  fs) [static]

Definition at line 157 of file format_pcm.c.

References ast_filestream::f.

{
   return ftello(fs->f);
}
static int pcm_trunc ( struct ast_filestream *  fs) [static]

Definition at line 152 of file format_pcm.c.

References ast_filestream::f.

{
   return ftruncate(fileno(fs->f), ftello(fs->f));
}
static int pcm_write ( struct ast_filestream *  fs,
struct ast_frame *  f 
) [static]

Definition at line 162 of file format_pcm.c.

References ast_filestream::_private, AST_FORMAT_ALAW, AST_FRAME_VOICE, ast_getformatname(), ast_log(), ast_frame_subclass::codec, ast_frame::data, ast_frame::datalen, errno, ast_filestream::f, ast_filestream::fmt, ast_format::format, ast_frame::frametype, LOG_WARNING, pd, ast_frame::ptr, and ast_frame::subclass.

{
   int res;

   if (f->frametype != AST_FRAME_VOICE) {
      ast_log(LOG_WARNING, "Asked to write non-voice frame!\n");
      return -1;
   }
   if (f->subclass.codec != fs->fmt->format) {
      ast_log(LOG_WARNING, "Asked to write incompatible format frame (%s)!\n", ast_getformatname(f->subclass.codec));
      return -1;
   }

#ifdef REALTIME_WRITE
   if (s->fmt->format == AST_FORMAT_ALAW) {
      struct pcm_desc *pd = (struct pcm_desc *)fs->_private;
      struct stat stat_buf;
      unsigned long cur_time = get_time();
      unsigned long fpos = ( cur_time - pd->start_time ) * 8;  /* 8 bytes per msec */
      /* Check if we have written to this position yet. If we have, then increment pos by one frame
      *  for some degree of protection against receiving packets in the same clock tick.
      */
      
      fstat(fileno(fs->f), &stat_buf );
      if (stat_buf.st_size > fpos )
         fpos += f->datalen;  /* Incrementing with the size of this current frame */

      if (stat_buf.st_size < fpos) {
         /* fill the gap with 0x55 rather than 0. */
         char buf[1024];
         unsigned long cur, to_write;

         cur = stat_buf.st_size;
         if (fseek(fs->f, cur, SEEK_SET) < 0) {
            ast_log( LOG_WARNING, "Cannot seek in file: %s\n", strerror(errno) );
            return -1;
         }
         memset(buf, 0x55, 512);
         while (cur < fpos) {
            to_write = fpos - cur;
            if (to_write > sizeof(buf))
               to_write = sizeof(buf);
            fwrite(buf, 1, to_write, fs->f);
            cur += to_write;
         }
      }

      if (fseek(s->f, fpos, SEEK_SET) < 0) {
         ast_log( LOG_WARNING, "Cannot seek in file: %s\n", strerror(errno) );
         return -1;
      }
   }
#endif   /* REALTIME_WRITE */
   
   if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen) {
      ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
      return -1;
   }
   return 0;
}
static int unload_module ( void  ) [static]

Definition at line 493 of file format_pcm.c.

References ast_format_unregister(), and ast_format::name.

{
   return ast_format_unregister(pcm_f.name)
      || ast_format_unregister(alaw_f.name)
      || ast_format_unregister(au_f.name)
      || ast_format_unregister(g722_f.name);
}
static int update_header ( FILE *  f) [static]

Definition at line 308 of file format_pcm.c.

References ast_log(), AU_HDR_DATA_SIZE_OFF, AU_HEADER_SIZE, and LOG_WARNING.

Referenced by au_trunc().

{
   off_t cur, end;
   uint32_t datalen;
   int bytes;

   cur = ftell(f);
   fseek(f, 0, SEEK_END);
   end = ftell(f);
   /* data starts 24 bytes in */
   bytes = end - AU_HEADER_SIZE;
   datalen = htoll(bytes);

   if (cur < 0) {
      ast_log(LOG_WARNING, "Unable to find our position\n");
      return -1;
   }
   if (fseek(f, AU_HDR_DATA_SIZE_OFF * sizeof(uint32_t), SEEK_SET)) {
      ast_log(LOG_WARNING, "Unable to set our position\n");
      return -1;
   }
   if (fwrite(&datalen, 1, sizeof(datalen), f) != sizeof(datalen)) {
      ast_log(LOG_WARNING, "Unable to set write file size\n");
      return -1;
   }
   if (fseek(f, cur, SEEK_SET)) {
      ast_log(LOG_WARNING, "Unable to return to position\n");
      return -1;
   }
   return 0;
}
static int write_header ( FILE *  f) [static]

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

{
   AU_HEADER(header);

   header[AU_HDR_MAGIC_OFF] = htoll((uint32_t) AU_MAGIC);
   header[AU_HDR_HDR_SIZE_OFF] = htoll(AU_HEADER_SIZE);
   header[AU_HDR_DATA_SIZE_OFF] = 0;
   header[AU_HDR_ENCODING_OFF] = htoll(AU_ENC_8BIT_ULAW);
   header[AU_HDR_SAMPLE_RATE_OFF] = htoll(DEFAULT_SAMPLE_RATE);
   header[AU_HDR_CHANNELS_OFF] = htoll(1);

   /* Write an au header, ignoring sizes which will be filled in later */
   fseek(f, 0, SEEK_SET);
   if (fwrite(header, 1, AU_HEADER_SIZE, f) != AU_HEADER_SIZE) {
      ast_log(LOG_WARNING, "Unable to write header\n");
      return -1;
   }
   return 0;
}

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, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND } [static]

Definition at line 505 of file format_pcm.c.

struct ast_format alaw_f [static]

Definition at line 420 of file format_pcm.c.

char alaw_silence[BUF_SIZE] [static]

Definition at line 44 of file format_pcm.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 505 of file format_pcm.c.

struct ast_format au_f [static]

Definition at line 461 of file format_pcm.c.

struct ast_format g722_f [static]

Definition at line 449 of file format_pcm.c.

struct ast_format pcm_f [static]

Definition at line 437 of file format_pcm.c.

char ulaw_silence[BUF_SIZE] [static]

Definition at line 43 of file format_pcm.c.