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
#define	htoll(b) (b)
#define	htols(b) (b)
#define	ltohl(b) (b)
#define	ltohs(b) (b)
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 __MODULE_INFO_SECTION	__mod_info = { __MODULE_INFO_GLOBALS .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Raw/Sun uLaw/ALaw 8KHz (PCM,PCMA,AU), G.722 16Khz" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = 10, }
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: pcm, ulaw, ul, mu

Definition in file format_pcm.c.

Define Documentation

#define AU_ENC_8BIT_ULAW 1

Definition at line 231 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_CHANNELS_OFF 5

Definition at line 229 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_DATA_SIZE_OFF 2

Definition at line 226 of file format_pcm.c.

Referenced by update_header(), and write_header().

#define AU_HDR_ENCODING_OFF 3

Definition at line 227 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_HDR_SIZE_OFF 1

Definition at line 225 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_MAGIC_OFF 0

Definition at line 224 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HDR_SAMPLE_RATE_OFF 4

Definition at line 228 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HEADER ( var ) uint32_t var[6]

Definition at line 222 of file format_pcm.c.

Referenced by check_header(), and write_header().

#define AU_HEADER_SIZE 24

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

Referenced by check_header(), and write_header().

#define BUF_SIZE 160

Definition at line 37 of file format_pcm.c.

Referenced by pcm_read(), and pcm_seek().

#define htoll ( b ) (b)

Definition at line 235 of file format_pcm.c.

Referenced by update_header(), and write_header().

#define htols ( b ) (b)

Definition at line 236 of file format_pcm.c.

#define ltohl ( b ) (b)

Definition at line 237 of file format_pcm.c.

Referenced by check_header().

#define ltohs ( b ) (b)

Definition at line 238 of file format_pcm.c.

Function Documentation

static void __reg_module ( void ) [static]

Definition at line 501 of file format_pcm.c.

static void __unreg_module ( void ) [static]

Definition at line 501 of file format_pcm.c.

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

Definition at line 356 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 363 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 371 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 410 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 403 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 256 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, LOG_WARNING, and ltohl.

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 471 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 76 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::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 = 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 99 of file format_pcm.c.

References AST_FORMAT_ALAW, ast_log(), BUF_SIZE, ast_filestream::f, ast_filestream::fmt, ast_format::format, fwrite, 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 153 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 148 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 158 of file format_pcm.c.

References ast_filestream::_private, AST_FORMAT_ALAW, AST_FRAME_VOICE, ast_log(), buf, ast_frame::data, ast_frame::datalen, errno, ast_filestream::f, ast_filestream::fmt, ast_format::format, ast_frame::frametype, fwrite, 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 != fs->fmt->format) {
      ast_log(LOG_WARNING, "Asked to write incompatible format frame (%d)!\n", f->subclass);
      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 489 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 304 of file format_pcm.c.

References ast_log(), AU_HDR_DATA_SIZE_OFF, AU_HEADER_SIZE, fwrite, htoll, 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 336 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, fwrite, htoll, 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 __MODULE_INFO_SECTION __mod_info = { __MODULE_INFO_GLOBALS .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Raw/Sun uLaw/ALaw 8KHz (PCM,PCMA,AU), G.722 16Khz" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = 10, } [static]

Definition at line 501 of file format_pcm.c.

struct ast_format alaw_f [static]

Definition at line 416 of file format_pcm.c.

char alaw_silence[BUF_SIZE] [static]

Definition at line 40 of file format_pcm.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 501 of file format_pcm.c.

struct ast_format au_f [static]

Definition at line 457 of file format_pcm.c.

struct ast_format g722_f [static]

Definition at line 445 of file format_pcm.c.

struct ast_format pcm_f [static]

Definition at line 433 of file format_pcm.c.

char ulaw_silence[BUF_SIZE] [static]

Definition at line 39 of file format_pcm.c.

Asterisk developer's documentation

format_pcm.c File Reference
Module: Media File Formats

Defines

Functions

Variables

Detailed Description

Define Documentation

Function Documentation

Variable Documentation

Asterisk developer's documentation

format_pcm.c File ReferenceModule: Media File Formats

Defines

Functions

Variables

Detailed Description

Define Documentation

Function Documentation

Variable Documentation

format_pcm.c File Reference
Module: Media File Formats