format_ogg_vorbis.c File Reference

OGG/Vorbis streams. More...

#include "asterisk.h"
#include <ogg/ogg.h>
#include <vorbis/codec.h>
#include <vorbis/vorbisenc.h>
#include <vorbis/vorbisfile.h>
#include "asterisk/mod_format.h"
#include "asterisk/module.h"
#include "asterisk/format_cache.h"

Include dependency graph for format_ogg_vorbis.c:

Go to the source code of this file.

Data Structures
struct	ogg_vorbis_desc

Macros
#define	BLOCK_SIZE   4096 /* used internally in the vorbis routines */
#define	BUF_SIZE   (2*SAMPLES_MAX)
#define	SAMPLES_MAX   512

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	_ov_header_fseek_wrap (FILE *f, ogg_int64_t off, int whence)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	load_module (void)
static void	ogg_vorbis_close (struct ast_filestream *fs)
	Close a OGG/Vorbis filestream. More...
static int	ogg_vorbis_open (struct ast_filestream *s)
	Create a new OGG/Vorbis filestream and set it up for reading. More...
static struct ast_frame *	ogg_vorbis_read (struct ast_filestream *fs, int *whennext)
	Read a frame full of audio data from the filestream. More...
static int	ogg_vorbis_rewrite (struct ast_filestream *s, const char *comment)
	Create a new OGG/Vorbis filestream and set it up for writing. More...
static int	ogg_vorbis_seek (struct ast_filestream *fs, off_t sample_offset, int whence)
	Seek to a specific position in an OGG/Vorbis filestream. More...
static off_t	ogg_vorbis_tell (struct ast_filestream *fs)
	Tell the current position in OGG/Vorbis filestream measured in pcms. More...
static int	ogg_vorbis_trunc (struct ast_filestream *fs)
	Truncate an OGG/Vorbis filestream. More...
static int	ogg_vorbis_write (struct ast_filestream *fs, struct ast_frame *f)
	Write audio data from a frame to an OGG/Vorbis filestream. More...
static int	unload_module (void)
static void	write_stream (struct ogg_vorbis_desc *s, FILE *f)
	Write out any pending encoded data. More...

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "OGG/Vorbis audio" , .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 const struct ast_module_info *	ast_module_info = &__mod_info
static ov_callbacks	OV_CALLBACKS_NOCLOSE
static struct ast_format_def	vorbis_f

Detailed Description

OGG/Vorbis streams.

• File name extension: ogg

Definition in file format_ogg_vorbis.c.

Macro Definition Documentation

BLOCK_SIZE

#define BLOCK_SIZE   4096 /* used internally in the vorbis routines */

Definition at line 56 of file format_ogg_vorbis.c.

BUF_SIZE

#define BUF_SIZE   (2*SAMPLES_MAX)

Definition at line 54 of file format_ogg_vorbis.c.

SAMPLES_MAX

#define SAMPLES_MAX   512

Definition at line 53 of file format_ogg_vorbis.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 449 of file format_ogg_vorbis.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 449 of file format_ogg_vorbis.c.

_ov_header_fseek_wrap()

static int _ov_header_fseek_wrap ( FILE *  f, ogg_int64_t  off, int  whence  )

static

Definition at line 88 of file format_ogg_vorbis.c.

{
    if (f == NULL) {
        return -1;
    }
    return fseek(f, off, whence);
}

References NULL.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 449 of file format_ogg_vorbis.c.

load_module()

static int load_module ( void  )

static

Definition at line 431 of file format_ogg_vorbis.c.

{
    vorbis_f.format = ast_format_slin;
    if (ast_format_def_register(&vorbis_f))
        return AST_MODULE_LOAD_DECLINE;
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_format_def_register, ast_format_slin, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_format_def::format, and vorbis_f.

ogg_vorbis_close()

static void ogg_vorbis_close ( struct ast_filestream *  fs )

static

Close a OGG/Vorbis filestream.

Parameters

fs	A OGG/Vorbis filestream.

Definition at line 269 of file format_ogg_vorbis.c.

{
    struct ogg_vorbis_desc *s = (struct ogg_vorbis_desc *) fs->_private;
 
    if (s->writing) {
        /* Tell the Vorbis encoder that the stream is finished
         * and write out the rest of the data */
        vorbis_analysis_wrote(&s->vd, 0);
        write_stream(s, fs->f);
 
        /* Cleanup */
        ogg_stream_clear(&s->os);
        vorbis_block_clear(&s->vb);
        vorbis_dsp_clear(&s->vd);
        vorbis_comment_clear(&s->vc);
        vorbis_info_clear(&s->vi);
    } else {
        /* clear OggVorbis_File handle */
        ov_clear(&s->ov_f);
    }
}

References ast_filestream::_private, ast_filestream::f, if(), ogg_vorbis_desc::os, ogg_vorbis_desc::ov_f, ogg_vorbis_desc::vb, ogg_vorbis_desc::vc, ogg_vorbis_desc::vd, ogg_vorbis_desc::vi, write_stream(), and ogg_vorbis_desc::writing.

ogg_vorbis_open()

static int ogg_vorbis_open ( struct ast_filestream *  s )

static

Create a new OGG/Vorbis filestream and set it up for reading.

Parameters

s	File that points to on disk storage of the OGG/Vorbis data.

Returns

The new filestream.

Definition at line 109 of file format_ogg_vorbis.c.

{
    int result;
    struct ogg_vorbis_desc *desc = (struct ogg_vorbis_desc *) s->_private;
 
    /* initialize private description block */
    memset(desc, 0, sizeof(struct ogg_vorbis_desc));
    desc->writing = 0;
 
    /* actually open file */
    result = ov_open_callbacks(s->f, &desc->ov_f, NULL, 0, OV_CALLBACKS_NOCLOSE);
    if (result != 0) {
        ast_log(LOG_ERROR, "Error opening Ogg/Vorbis file stream.\n");
        return -1;
    }
 
    /* check stream(s) type */
    if (desc->ov_f.vi->channels != 1) {
        ast_log(LOG_ERROR, "Only monophonic OGG/Vorbis files are currently supported!\n");
        ov_clear(&desc->ov_f);
        return -1;
    }
 
    if (desc->ov_f.vi->rate != DEFAULT_SAMPLE_RATE) {
        ast_log(LOG_ERROR, "Only 8000Hz OGG/Vorbis files are currently supported!\n");
        ov_clear(&desc->ov_f);
        return -1;
    }
 
    return 0;
}

References ast_filestream::_private, ast_log, DEFAULT_SAMPLE_RATE, desc, ast_filestream::f, LOG_ERROR, NULL, OV_CALLBACKS_NOCLOSE, and result.

ogg_vorbis_read()

static struct ast_frame * ogg_vorbis_read ( struct ast_filestream *  fs, int *  whennext  )

static

Read a frame full of audio data from the filestream.

Parameters

fs	The filestream.
whennext	Number of sample times to schedule the next call.

Returns

A pointer to a frame containing audio data or NULL ifthere is no more audio data.

Definition at line 297 of file format_ogg_vorbis.c.

{
    struct ogg_vorbis_desc *desc = (struct ogg_vorbis_desc *) fs->_private;
    int current_bitstream = -10;
    char *out_buf;
    long bytes_read;
 
    if (desc->writing) {
        ast_log(LOG_WARNING, "Reading is not supported on OGG/Vorbis on write files.\n");
        return NULL;
    }
 
    /* initialize frame */
    AST_FRAME_SET_BUFFER(&fs->fr, fs->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
    out_buf = (char *) (fs->fr.data.ptr);   /* SLIN data buffer */
 
    /* read samples from OV interface */
    bytes_read = ov_read(
        &desc->ov_f,
        out_buf,                        /* Buffer to write data */
        BUF_SIZE,                       /* Size of buffer */
        (__BYTE_ORDER == __BIG_ENDIAN), /* Endianes (0 for little) */
        2,                              /* 1 = 8bit, 2 = 16bit */
        1,                              /* 0 = unsigned, 1 = signed */
        &current_bitstream              /* Returns the current bitstream section */
    );
 
    /* check returned data */
    if (bytes_read <= 0) {
        /* End of stream */
        return NULL;
    }
 
    /* Return decoded bytes */
    fs->fr.datalen = bytes_read;
    fs->fr.samples = bytes_read / 2;
    *whennext = fs->fr.samples;
    return &fs->fr;
}

References __BIG_ENDIAN, __BYTE_ORDER, ast_filestream::_private, AST_FRAME_SET_BUFFER, AST_FRIENDLY_OFFSET, ast_log, ast_filestream::buf, BUF_SIZE, ast_frame::data, ast_frame::datalen, desc, ast_filestream::fr, if(), LOG_WARNING, NULL, ast_frame::ptr, and ast_frame::samples.

ogg_vorbis_rewrite()

static int ogg_vorbis_rewrite ( struct ast_filestream *  s, const char *  comment  )

static

Create a new OGG/Vorbis filestream and set it up for writing.

Parameters

s	File pointer that points to on-disk storage.
comment	Comment that should be embedded in the OGG/Vorbis file.

Returns

A new filestream.

Definition at line 147 of file format_ogg_vorbis.c.

{
    ogg_packet header;
    ogg_packet header_comm;
    ogg_packet header_code;
    struct ogg_vorbis_desc *tmp = (struct ogg_vorbis_desc *) s->_private;
 
    tmp->writing = 1;
    tmp->writing_pcm_pos = 0;
 
    vorbis_info_init(&tmp->vi);
 
    if (vorbis_encode_init_vbr(&tmp->vi, 1, DEFAULT_SAMPLE_RATE, 0.4)) {
        ast_log(LOG_ERROR, "Unable to initialize Vorbis encoder!\n");
        vorbis_info_clear(&tmp->vi);
        return -1;
    }
 
    vorbis_comment_init(&tmp->vc);
    vorbis_comment_add_tag(&tmp->vc, "ENCODER", "Asterisk PBX");
    if (comment)
        vorbis_comment_add_tag(&tmp->vc, "COMMENT", (char *) comment);
 
    vorbis_analysis_init(&tmp->vd, &tmp->vi);
    vorbis_block_init(&tmp->vd, &tmp->vb);
 
    ogg_stream_init(&tmp->os, ast_random());
 
    vorbis_analysis_headerout(&tmp->vd, &tmp->vc, &header, &header_comm,
                  &header_code);
    ogg_stream_packetin(&tmp->os, &header);
    ogg_stream_packetin(&tmp->os, &header_comm);
    ogg_stream_packetin(&tmp->os, &header_code);
 
    while (!tmp->eos) {
        if (ogg_stream_flush(&tmp->os, &tmp->og) == 0)
            break;
        if (fwrite(tmp->og.header, 1, tmp->og.header_len, s->f) != tmp->og.header_len) {
            ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
        }
        if (fwrite(tmp->og.body, 1, tmp->og.body_len, s->f) != tmp->og.body_len) {
            ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
        }
        if (ogg_page_eos(&tmp->og))
            tmp->eos = 1;
    }
 
    return 0;
}

References ast_filestream::_private, ast_log, ast_random(), comment, DEFAULT_SAMPLE_RATE, errno, ast_filestream::f, LOG_ERROR, LOG_WARNING, and tmp().

ogg_vorbis_seek()

static int ogg_vorbis_seek ( struct ast_filestream *  fs, off_t  sample_offset, int  whence  )

static

Seek to a specific position in an OGG/Vorbis filestream.

Parameters

fs	The filestream to take action on.
sample_offset	New position for the filestream, measured in 8KHz samples.
whence	Location to measure

Returns

0 on success, -1 on failure.

Definition at line 377 of file format_ogg_vorbis.c.

{
    int seek_result = -1;
    off_t relative_pcm_pos;
    struct ogg_vorbis_desc *desc = (struct ogg_vorbis_desc *) fs->_private;
 
    if (desc->writing) {
        ast_log(LOG_WARNING, "Seeking is not supported on OGG/Vorbis streams in writing mode!\n");
        return -1;
    }
 
    /* ov_pcm_seek support seeking only from begining (SEEK_SET), the rest must be emulated */
    switch (whence) {
    case SEEK_SET:
        seek_result = ov_pcm_seek(&desc->ov_f, sample_offset);
        break;
    case SEEK_CUR:
        if ((relative_pcm_pos = ogg_vorbis_tell(fs)) < 0) {
            seek_result = -1;
            break;
        }
        seek_result = ov_pcm_seek(&desc->ov_f, relative_pcm_pos + sample_offset);
        break;
    case SEEK_END:
        if ((relative_pcm_pos = ov_pcm_total(&desc->ov_f, -1)) < 0) {
            seek_result = -1;
            break;
        }
        seek_result = ov_pcm_seek(&desc->ov_f, relative_pcm_pos - sample_offset);
        break;
    default:
        ast_log(LOG_WARNING, "Unknown *whence* to seek on OGG/Vorbis streams!\n");
        break;
    }
 
    /* normalize error value to -1,0 */
    return (seek_result == 0) ? 0 : -1;
}

References ast_filestream::_private, ast_log, desc, if(), LOG_WARNING, and ogg_vorbis_tell().

ogg_vorbis_tell()

static off_t ogg_vorbis_tell ( struct ast_filestream *  fs )

static

Tell the current position in OGG/Vorbis filestream measured in pcms.

Parameters

fs	The filestream to take action on.

Returns

0 or greater with the position measured in samples, or -1 for false.

Definition at line 355 of file format_ogg_vorbis.c.

{
    off_t pos;
    struct ogg_vorbis_desc *desc = (struct ogg_vorbis_desc *) fs->_private;
 
    if (desc->writing) {
        return desc->writing_pcm_pos;
    }
 
    if ((pos = ov_pcm_tell(&desc->ov_f)) < 0) {
        return -1;
    }
    return pos;
}

References ast_filestream::_private, desc, and if().

Referenced by ogg_vorbis_seek().

ogg_vorbis_trunc()

static int ogg_vorbis_trunc ( struct ast_filestream *  fs )

static

Truncate an OGG/Vorbis filestream.

Parameters

fs	The filestream to truncate.

Returns

0 on success, -1 on failure.

Definition at line 344 of file format_ogg_vorbis.c.

{
    ast_log(LOG_WARNING, "Truncation is not supported on OGG/Vorbis streams!\n");
    return -1;
}

References ast_log, and LOG_WARNING.

ogg_vorbis_write()

static int ogg_vorbis_write ( struct ast_filestream *  fs, struct ast_frame *  f  )

static

Write audio data from a frame to an OGG/Vorbis filestream.

Parameters

fs	An OGG/Vorbis filestream.
f	A frame containing audio to be written to the filestream.

Returns

-1 if there was an error, 0 on success.

Definition at line 235 of file format_ogg_vorbis.c.

{
    int i;
    float **buffer;
    short *data;
    struct ogg_vorbis_desc *s = (struct ogg_vorbis_desc *) fs->_private;
 
    if (!s->writing) {
        ast_log(LOG_ERROR, "This stream is not set up for writing!\n");
        return -1;
    }
    if (!f->datalen)
        return -1;
 
    data = (short *) f->data.ptr;
 
    buffer = vorbis_analysis_buffer(&s->vd, f->samples);
 
    for (i = 0; i < f->samples; i++)
        buffer[0][i] = (double)data[i] / 32768.0;
 
    vorbis_analysis_wrote(&s->vd, f->samples);
 
    write_stream(s, fs->f);
 
    s->writing_pcm_pos +=  f->samples;
 
    return 0;
}

References ast_filestream::_private, ast_log, ast_frame::data, ast_frame::datalen, ast_filestream::f, if(), LOG_ERROR, ast_frame::ptr, ast_frame::samples, ogg_vorbis_desc::vd, write_stream(), ogg_vorbis_desc::writing, and ogg_vorbis_desc::writing_pcm_pos.

unload_module()

static int unload_module ( void  )

static

Definition at line 439 of file format_ogg_vorbis.c.

{
    return ast_format_def_unregister(vorbis_f.name);
}

References ast_format_def_unregister(), ast_format_def::name, and vorbis_f.

write_stream()

static void write_stream ( struct ogg_vorbis_desc *  s, FILE *  f  )

static

Write out any pending encoded data.

Parameters

s	An OGG/Vorbis filestream.
f	The file to write to.

Definition at line 203 of file format_ogg_vorbis.c.

{
    while (vorbis_analysis_blockout(&s->vd, &s->vb) == 1) {
        vorbis_analysis(&s->vb, NULL);
        vorbis_bitrate_addblock(&s->vb);
 
        while (vorbis_bitrate_flushpacket(&s->vd, &s->op)) {
            ogg_stream_packetin(&s->os, &s->op);
            while (!s->eos) {
                if (ogg_stream_pageout(&s->os, &s->og) == 0) {
                    break;
                }
                if (fwrite(s->og.header, 1, s->og.header_len, f) != s->og.header_len) {
                    ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
                }
                if (fwrite(s->og.body, 1, s->og.body_len, f) != s->og.body_len) {
                    ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
                }
                if (ogg_page_eos(&s->og)) {
                    s->eos = 1;
                }
            }
        }
    }
}

References ast_log, ogg_vorbis_desc::eos, errno, LOG_WARNING, NULL, ogg_vorbis_desc::og, ogg_vorbis_desc::op, ogg_vorbis_desc::os, ogg_vorbis_desc::vb, and ogg_vorbis_desc::vd.

Referenced by ast_write_stream(), ogg_vorbis_close(), ogg_vorbis_write(), and tech_write().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "OGG/Vorbis audio" , .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 449 of file format_ogg_vorbis.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 449 of file format_ogg_vorbis.c.

OV_CALLBACKS_NOCLOSE

ov_callbacks OV_CALLBACKS_NOCLOSE

static

Definition at line 96 of file format_ogg_vorbis.c.

Referenced by ogg_vorbis_open().

vorbis_f

struct ast_format_def vorbis_f

static

Definition at line 416 of file format_ogg_vorbis.c.

Referenced by load_module(), and unload_module().