Update of /usr/cvsroot/asterisk/formats
In directory mongoose.digium.com:/tmp/cvs-serv19882/formats
Modified Files:
Makefile
Added Files:
format_ogg_vorbis.c
Log Message:
add OGG/Vorbis file format support (bug #4296)
--- NEW FILE: format_ogg_vorbis.c ---
/*
* Asterisk -- A telephony toolkit for Linux.
*
* OGG/Vorbis streams.
*
* This program is free software, distributed under the terms of
* the GNU General Public License
*/
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <vorbis/codec.h>
#include <vorbis/vorbisenc.h>
#ifdef _WIN32
#include <io.h>
#include <fcntl.h>
#endif
#include "asterisk.h"
ASTERISK_FILE_VERSION(__FILE__, "$Revision: 1.1 $")
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#define SAMPLES_MAX 160
#define BLOCK_SIZE 4096
struct ast_filestream {
void *reserved[AST_RESERVED_POINTERS];
int fd;
/* structures for handling the Ogg container */
ogg_sync_state oy;
ogg_stream_state os;
ogg_page og;
ogg_packet op;
/* structures for handling Vorbis audio data */
vorbis_info vi;
vorbis_comment vc;
vorbis_dsp_state vd;
vorbis_block vb;
/*! \brief Indicates whether this filestream is set up for reading or
writing. */
int writing;
/*! \brief Indicates whether an End of Stream condition has been
detected. */
int eos;
/*! \brief Buffer to hold audio data. */
short buffer[SAMPLES_MAX];
/*! \brief Asterisk frame object. */
struct ast_frame fr;
char waste[AST_FRIENDLY_OFFSET];
char empty;
};
AST_MUTEX_DEFINE_STATIC(ogg_vorbis_lock);
static int glistcnt = 0;
static char *name = "ogg_vorbis";
static char *desc = "OGG/Vorbis audio";
static char *exts = "ogg";
/*!
* \brief Create a new OGG/Vorbis filestream and set it up for reading.
* \param fd Descriptor that points to on disk storage of the OGG/Vorbis data.
* \return The new filestream.
*/
static struct ast_filestream *ogg_vorbis_open(int fd)
{
int i;
int bytes;
int result;
char **ptr;
char *buffer;
struct ast_filestream *tmp;
if((tmp = malloc(sizeof(struct ast_filestream)))) {
memset(tmp, 0, sizeof(struct ast_filestream));
tmp->writing = 0;
tmp->fd = fd;
ogg_sync_init(&tmp->oy);
buffer = ogg_sync_buffer(&tmp->oy, BLOCK_SIZE);
bytes = read(tmp->fd, buffer, BLOCK_SIZE);
ogg_sync_wrote(&tmp->oy, bytes);
result = ogg_sync_pageout(&tmp->oy, &tmp->og);
if(result != 1) {
if(bytes < BLOCK_SIZE) {
ast_log(LOG_ERROR, "Run out of data...\n");
} else {
ast_log(LOG_ERROR, "Input does not appear to be
an Ogg bitstream.\n");
}
close(fd);
ogg_sync_clear(&tmp->oy);
free(tmp);
return NULL;
}
ogg_stream_init(&tmp->os, ogg_page_serialno(&tmp->og));
vorbis_info_init(&tmp->vi);
vorbis_comment_init(&tmp->vc);
if(ogg_stream_pagein(&tmp->os, &tmp->og) < 0) {
ast_log(LOG_ERROR, "Error reading first page of Ogg
bitstream data.\n");
close(fd);
ogg_stream_clear(&tmp->os);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
ogg_sync_clear(&tmp->oy);
free(tmp);
return NULL;
}
if(ogg_stream_packetout(&tmp->os, &tmp->op) != 1) {
ast_log(LOG_ERROR, "Error reading initial header
packet.\n");
close(fd);
ogg_stream_clear(&tmp->os);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
ogg_sync_clear(&tmp->oy);
free(tmp);
return NULL;
}
if(vorbis_synthesis_headerin(&tmp->vi, &tmp->vc, &tmp->op) < 0)
{
ast_log(LOG_ERROR, "This Ogg bitstream does not contain
Vorbis audio data.\n");
close(fd);
ogg_stream_clear(&tmp->os);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
ogg_sync_clear(&tmp->oy);
free(tmp);
return NULL;
}
i = 0;
while(i < 2) {
while(i < 2){
result = ogg_sync_pageout(&tmp->oy, &tmp->og);
if(result == 0)
break;
if(result == 1) {
ogg_stream_pagein(&tmp->os, &tmp->og);
while(i < 2) {
result =
ogg_stream_packetout(&tmp->os,&tmp->op);
if(result == 0)
break;
if(result < 0) {
ast_log(LOG_ERROR,
"Corrupt secondary header. Exiting.\n");
close(fd);
ogg_stream_clear(&tmp->os);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
ogg_sync_clear(&tmp->oy);
free(tmp);
return NULL;
}
vorbis_synthesis_headerin(&tmp->vi, &tmp->vc, &tmp->op);
i++;
}
}
}
buffer = ogg_sync_buffer(&tmp->oy, BLOCK_SIZE);
bytes = read(tmp->fd, buffer, BLOCK_SIZE);
if(bytes == 0 && i < 2) {
ast_log(LOG_ERROR, "End of file before finding
all Vorbis headers!\n");
close(fd);
ogg_stream_clear(&tmp->os);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
ogg_sync_clear(&tmp->oy);
free(tmp);
return NULL;
}
ogg_sync_wrote(&tmp->oy, bytes);
}
ptr = tmp->vc.user_comments;
while(*ptr){
ast_log(LOG_DEBUG, "OGG/Vorbis comment: %s\n", *ptr);
++ptr;
}
ast_log(LOG_DEBUG, "OGG/Vorbis bitstream is %d channel,
%ldHz\n", tmp->vi.channels, tmp->vi.rate);
ast_log(LOG_DEBUG, "OGG/Vorbis file encoded by: %s\n",
tmp->vc.vendor);
if(tmp->vi.channels != 1) {
ast_log(LOG_ERROR, "Only monophonic OGG/Vorbis files
are currently supported!\n");
ogg_stream_clear(&tmp->os);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
ogg_sync_clear(&tmp->oy);
free(tmp);
return NULL;
}
if(tmp->vi.rate != 8000) {
ast_log(LOG_ERROR, "Only 8000Hz OGG/Vorbis files are
currently supported!\n");
close(fd);
ogg_stream_clear(&tmp->os);
vorbis_block_clear(&tmp->vb);
vorbis_dsp_clear(&tmp->vd);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
ogg_sync_clear(&tmp->oy);
free(tmp);
return NULL;
}
vorbis_synthesis_init(&tmp->vd, &tmp->vi);
vorbis_block_init(&tmp->vd, &tmp->vb);
if(ast_mutex_lock(&ogg_vorbis_lock)) {
ast_log(LOG_WARNING, "Unable to lock ogg_vorbis
list\n");
close(fd);
ogg_stream_clear(&tmp->os);
vorbis_block_clear(&tmp->vb);
vorbis_dsp_clear(&tmp->vd);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
ogg_sync_clear(&tmp->oy);
free(tmp);
return NULL;
}
glistcnt++;
ast_mutex_unlock(&ogg_vorbis_lock);
ast_update_use_count();
}
return tmp;
}
/*!
* \brief Create a new OGG/Vorbis filestream and set it up for writing.
* \param fd File descriptor that points to on-disk storage.
* \param comment Comment that should be embedded in the OGG/Vorbis file.
* \return A new filestream.
*/
static struct ast_filestream *ogg_vorbis_rewrite(int fd, const char *comment)
{
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
struct ast_filestream *tmp;
if((tmp = malloc(sizeof(struct ast_filestream)))) {
memset(tmp, 0, sizeof(struct ast_filestream));
tmp->writing = 1;
tmp->fd = fd;
vorbis_info_init(&tmp->vi);
if(vorbis_encode_init_vbr(&tmp->vi, 1, 8000, 0.4)) {
ast_log(LOG_ERROR, "Unable to initialize Vorbis
encoder!\n");
free(tmp);
return NULL;
}
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, rand());
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;
write(tmp->fd, tmp->og.header, tmp->og.header_len);
write(tmp->fd, tmp->og.body, tmp->og.body_len);
if(ogg_page_eos(&tmp->og))
tmp->eos = 1;
}
if(ast_mutex_lock(&ogg_vorbis_lock)) {
ast_log(LOG_WARNING, "Unable to lock ogg_vorbis
list\n");
close(fd);
ogg_stream_clear(&tmp->os);
vorbis_block_clear(&tmp->vb);
vorbis_dsp_clear(&tmp->vd);
vorbis_comment_clear(&tmp->vc);
vorbis_info_clear(&tmp->vi);
free(tmp);
return NULL;
}
glistcnt++;
ast_mutex_unlock(&ogg_vorbis_lock);
ast_update_use_count();
}
return tmp;
}
/*!
* \brief Write out any pending encoded data.
* \param s A OGG/Vorbis filestream.
*/
static void write_stream(struct ast_filestream *s)
{
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;
}
write(s->fd, s->og.header, s->og.header_len);
write(s->fd, s->og.body, s->og.body_len);
if(ogg_page_eos(&s->og)) {
s->eos = 1;
}
}
}
}
}
/*!
* \brief Write audio data from a frame to an OGG/Vorbis filestream.
* \param s A OGG/Vorbis filestream.
* \param f An frame containing audio to be written to the filestream.
* \return -1 ifthere was an error, 0 on success.
*/
static int ogg_vorbis_write(struct ast_filestream *s, struct ast_frame *f)
{
int i;
float **buffer;
short *data;
if(!s->writing) {
ast_log(LOG_ERROR, "This stream is not set up for writing!\n");
return -1;
}
if(f->frametype != AST_FRAME_VOICE) {
ast_log(LOG_WARNING, "Asked to write non-voice frame!\n");
return -1;
}
if(f->subclass != AST_FORMAT_SLINEAR) {
ast_log(LOG_WARNING, "Asked to write non-SLINEAR frame
(%d)!\n", f->subclass);
return -1;
}
if(!f->datalen)
return -1;
data = (short *) f->data;
buffer = vorbis_analysis_buffer(&s->vd, f->samples);
for (i = 0; i < f->samples; i++) {
buffer[0][i] = data[i]/32768.f;
}
vorbis_analysis_wrote(&s->vd, f->samples);
write_stream(s);
return 0;
}
/*!
* \brief Close a OGG/Vorbis filestream.
* \param s A OGG/Vorbis filestream.
*/
static void ogg_vorbis_close(struct ast_filestream *s)
{
if(ast_mutex_lock(&ogg_vorbis_lock)) {
ast_log(LOG_WARNING, "Unable to lock ogg_vorbis list\n");
return;
}
glistcnt--;
ast_mutex_unlock(&ogg_vorbis_lock);
ast_update_use_count();
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);
}
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);
if(s->writing) {
ogg_sync_clear(&s->oy);
}
close(s->fd);
free(s);
}
/*!
* \brief Get audio data.
* \param s An OGG/Vorbis filestream.
* \param pcm Pointer to a buffere to store audio data in.
*/
static int read_samples(struct ast_filestream *s, float ***pcm)
{
int samples_in;
int result;
char *buffer;
int bytes;
while (1) {
samples_in = vorbis_synthesis_pcmout(&s->vd, pcm);
if(samples_in > 0) {
return samples_in;
}
/* The Vorbis decoder needs more data... */
/* See ifOGG has any packets in the current page for the Vorbis
decoder. */
result = ogg_stream_packetout(&s->os, &s->op);
if(result > 0) {
/* Yes OGG had some more packets for the Vorbis
decoder. */
if(vorbis_synthesis(&s->vb, &s->op) == 0) {
vorbis_synthesis_blockin(&s->vd, &s->vb);
}
continue;
}
if(result < 0)
ast_log(LOG_WARNING, "Corrupt or missing data at this
page position; continuing...\n");
/* No more packets left in the current page... */
if(s->eos) {
/* No more pages left in the stream */
return -1;
}
while (!s->eos) {
/* See ifOGG has any pages in it's internal buffers */
result = ogg_sync_pageout(&s->oy, &s->og);
if(result > 0) {
/* Yes, OGG has more pages in it's internal
buffers,
add the page to the stream state */
result = ogg_stream_pagein(&s->os, &s->og);
if(result == 0) {
/* Yes, got a new,valid page */
if(ogg_page_eos(&s->og)) {
s->eos = 1;
}
break;
}
ast_log(LOG_WARNING, "Invalid page in the
bitstream; continuing...\n");
}
if(result < 0)
ast_log(LOG_WARNING, "Corrupt or missing data
in bitstream; continuing...\n");
/* No, we need to read more data from the file
descrptor */
/* get a buffer from OGG to read the data into */
buffer = ogg_sync_buffer(&s->oy, BLOCK_SIZE);
/* read more data from the file descriptor */
bytes = read(s->fd, buffer, BLOCK_SIZE);
/* Tell OGG how many bytes we actually read into the
buffer */
ogg_sync_wrote(&s->oy, bytes);
if(bytes == 0) {
s->eos = 1;
}
}
}
}
/*!
* \brief Read a frame full of audio data from the filestream.
* \param s The filestream.
* \param whennext Number of sample times to schedule the next call.
* \return A pointer to a frame containing audio data or NULL ifthere is no
more audio data.
*/
static struct ast_frame *ogg_vorbis_read(struct ast_filestream *s, int
*whennext)
{
int clipflag = 0;
int i;
int j;
float **pcm;
float *mono;
double accumulator[SAMPLES_MAX];
int val;
int samples_in;
int samples_out = 0;
while (1) {
/* See ifwe have filled up an audio frame yet */
if(samples_out == SAMPLES_MAX)
break;
/* See ifVorbis decoder has some audio data for us ... */
samples_in = read_samples(s, &pcm);
if(samples_in <= 0)
break;
/* Got some audio data from Vorbis... */
/* Convert the float audio data to 16-bit signed linear */
clipflag = 0;
samples_in = samples_in < (SAMPLES_MAX - samples_out) ?
samples_in : (SAMPLES_MAX - samples_out);
for(j = 0; j < samples_in; j++)
accumulator[j] = 0.0;
for(i = 0; i < s->vi.channels; i++) {
mono = pcm[i];
for (j = 0; j < samples_in; j++) {
accumulator[j] += mono[j];
}
}
for (j = 0; j < samples_in; j++) {
val = accumulator[j] * 32767.0 / s->vi.channels;
if(val > 32767) {
val = 32767;
clipflag = 1;
}
if(val < -32768) {
val = -32768;
clipflag = 1;
}
s->buffer[samples_out + j] = val;
}
if(clipflag)
ast_log(LOG_WARNING, "Clipping in frame %ld\n",
(long)(s->vd.sequence));
/* Tell the Vorbis decoder how many samples we actually used. */
vorbis_synthesis_read(&s->vd, samples_in);
samples_out += samples_in;
}
if(samples_out > 0) {
s->fr.frametype = AST_FRAME_VOICE;
s->fr.subclass = AST_FORMAT_SLINEAR;
s->fr.offset = AST_FRIENDLY_OFFSET;
s->fr.datalen = samples_out * 2;
s->fr.data = s->buffer;
s->fr.src = name;
s->fr.mallocd = 0;
s->fr.samples = samples_out;
*whennext = samples_out;
return &s->fr;
} else {
return NULL;
}
}
/*!
* \brief Trucate an OGG/Vorbis filestream.
* \param s The filestream to truncate.
* \return 0 on success, -1 on failure.
*/
static int ogg_vorbis_trunc(struct ast_filestream *s)
{
ast_log(LOG_WARNING, "Truncation is not supported on OGG/Vorbis
streams!\n");
return -1;
}
/*!
* \brief Seek to a specific position in an OGG/Vorbis filestream.
* \param s The filestream to truncate.
* \param sample_offset New position for the filestream, measured in 8KHz
samples.
* \param whence Location to measure
* \return 0 on success, -1 on failure.
*/
static int ogg_vorbis_seek(struct ast_filestream *s, long sample_offset, int
whence) {
ast_log(LOG_WARNING, "Seeking is not supported on OGG/Vorbis
streams!\n");
return -1;
}
static long ogg_vorbis_tell(struct ast_filestream *s) {
ast_log(LOG_WARNING, "Telling is not supported on OGG/Vorbis
streams!\n");
return -1;
}
static char *ogg_vorbis_getcomment(struct ast_filestream *s) {
ast_log(LOG_WARNING, "Getting comments is not supported on OGG/Vorbis
streams!\n");
return NULL;
}
int load_module()
{
return ast_format_register(name, exts, AST_FORMAT_SLINEAR,
ogg_vorbis_open,
ogg_vorbis_rewrite,
ogg_vorbis_write,
ogg_vorbis_seek,
ogg_vorbis_trunc,
ogg_vorbis_tell,
ogg_vorbis_read,
ogg_vorbis_close,
ogg_vorbis_getcomment);
}
int unload_module()
{
return ast_format_unregister(name);
}
int usecount()
{
return glistcnt;
}
char *description()
{
return desc;
}
char *key()
{
return ASTERISK_GPL_KEY;
}
/*
Local Variables:
mode: C
c-file-style: "linux"
indent-tabs-mode: t
End:
*/
Index: Makefile
===================================================================
RCS file: /usr/cvsroot/asterisk/formats/Makefile,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -d -r1.21 -r1.22
--- Makefile 20 Jun 2005 17:26:07 -0000 1.21
+++ Makefile 20 Jul 2005 00:25:54 -0000 1.22
@@ -21,6 +21,11 @@
#
FORMAT_LIBS+=format_g723.so
+#
+# OGG/Vorbis format
+#
+FORMAT_LIBS+=$(shell if [ -f
$(CROSS_COMPILE_TARGET)/usr/include/vorbis/codec.h ]; then echo
"format_ogg_vorbis.so" ; fi)
+
GSMLIB=../codecs/gsm/lib/libgsm.a
CFLAGS+=-fPIC
@@ -40,6 +45,9 @@
format_mp3.so : format_mp3.o
$(CC) $(SOLINK) -o $@ $< -lm
+format_ogg_vorbis.so : format_ogg_vorbis.o
+ $(CC) $(SOLINK) -o $@ $< -logg -lvorbis -lvorbisenc -lm
+
install: all
for x in $(FORMAT_LIBS); do $(INSTALL) -m 755 $$x
$(DESTDIR)$(MODULES_DIR) ; done
_______________________________________________
Asterisk-Cvs mailing list
[email protected]
http://lists.digium.com/mailman/listinfo/asterisk-cvs
