Asterisk - The Open Source Telephony Project  18.5.0
format_ogg_vorbis.c
Go to the documentation of this file.
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2005, Jeff Ollie
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  */
16 
17 /*! \file
18  *
19  * \brief OGG/Vorbis streams.
20  * \arg File name extension: ogg
21  * \ingroup formats
22  */
23 
24 /* the order of these dependencies is important... it also specifies
25  the link order of the libraries during linking
26 */
27 
28 /*** MODULEINFO
29  <depend>vorbis</depend>
30  <depend>ogg</depend>
31  <support_level>core</support_level>
32  ***/
33 
34 #include "asterisk.h"
35 
36 #include <ogg/ogg.h>
37 #include <vorbis/codec.h>
38 #include <vorbis/vorbisenc.h>
39 #include <vorbis/vorbisfile.h>
40 
41 #ifdef _WIN32
42 #include <io.h>
43 #endif
44 
45 #include "asterisk/mod_format.h"
46 #include "asterisk/module.h"
47 #include "asterisk/format_cache.h"
48 
49 /*
50  * this is the number of samples we deal with. Samples are converted
51  * to SLINEAR so each one uses 2 bytes in the buffer.
52  */
53 #define SAMPLES_MAX 512
54 #define BUF_SIZE (2*SAMPLES_MAX)
55 
56 #define BLOCK_SIZE 4096 /* used internally in the vorbis routines */
57 
58 struct ogg_vorbis_desc { /* format specific parameters */
59  /* OggVorbis_File structure for libvorbisfile interface */
60  OggVorbis_File ov_f;
61 
62  /* structures for handling the Ogg container */
63  ogg_stream_state os;
64  ogg_page og;
65  ogg_packet op;
66 
67  /* structures for handling Vorbis audio data */
68  vorbis_info vi;
69  vorbis_comment vc;
70  vorbis_dsp_state vd;
71  vorbis_block vb;
72 
73  /*! \brief Indicates whether this filestream is set up for reading or writing. */
74  int writing;
75 
76  /*! \brief Stores the current pcm position to support tell() on writing mode. */
78 
79  /*! \brief Indicates whether an End of Stream condition has been detected. */
80  int eos;
81 };
82 
83 #if !defined(HAVE_VORBIS_OPEN_CALLBACKS)
84 /*
85  * Declared for backward compatibility with vorbisfile v1.1.2.
86  * Code taken from vorbisfile.h v1.2.0.
87  */
88 static int _ov_header_fseek_wrap(FILE *f, ogg_int64_t off, int whence)
89 {
90  if (f == NULL) {
91  return -1;
92  }
93  return fseek(f, off, whence);
94 }
95 
96 static ov_callbacks OV_CALLBACKS_NOCLOSE = {
97  (size_t (*)(void *, size_t, size_t, void *)) fread,
98  (int (*)(void *, ogg_int64_t, int)) _ov_header_fseek_wrap,
99  (int (*)(void *)) NULL,
100  (long (*)(void *)) ftell
101 };
102 #endif /* !defined(HAVE_VORBIS_OPEN_CALLBACKS) */
103 
104 /*!
105  * \brief Create a new OGG/Vorbis filestream and set it up for reading.
106  * \param s File that points to on disk storage of the OGG/Vorbis data.
107  * \return The new filestream.
108  */
109 static int ogg_vorbis_open(struct ast_filestream *s)
110 {
111  int result;
112  struct ogg_vorbis_desc *desc = (struct ogg_vorbis_desc *) s->_private;
113 
114  /* initialize private description block */
115  memset(desc, 0, sizeof(struct ogg_vorbis_desc));
116  desc->writing = 0;
117 
118  /* actually open file */
119  result = ov_open_callbacks(s->f, &desc->ov_f, NULL, 0, OV_CALLBACKS_NOCLOSE);
120  if (result != 0) {
121  ast_log(LOG_ERROR, "Error opening Ogg/Vorbis file stream.\n");
122  return -1;
123  }
124 
125  /* check stream(s) type */
126  if (desc->ov_f.vi->channels != 1) {
127  ast_log(LOG_ERROR, "Only monophonic OGG/Vorbis files are currently supported!\n");
128  ov_clear(&desc->ov_f);
129  return -1;
130  }
131 
132  if (desc->ov_f.vi->rate != DEFAULT_SAMPLE_RATE) {
133  ast_log(LOG_ERROR, "Only 8000Hz OGG/Vorbis files are currently supported!\n");
134  ov_clear(&desc->ov_f);
135  return -1;
136  }
137 
138  return 0;
139 }
140 
141 /*!
142  * \brief Create a new OGG/Vorbis filestream and set it up for writing.
143  * \param s File pointer that points to on-disk storage.
144  * \param comment Comment that should be embedded in the OGG/Vorbis file.
145  * \return A new filestream.
146  */
147 static int ogg_vorbis_rewrite(struct ast_filestream *s,
148  const char *comment)
149 {
150  ogg_packet header;
151  ogg_packet header_comm;
152  ogg_packet header_code;
153  struct ogg_vorbis_desc *tmp = (struct ogg_vorbis_desc *) s->_private;
154 
155  tmp->writing = 1;
156  tmp->writing_pcm_pos = 0;
157 
158  vorbis_info_init(&tmp->vi);
159 
160  if (vorbis_encode_init_vbr(&tmp->vi, 1, DEFAULT_SAMPLE_RATE, 0.4)) {
161  ast_log(LOG_ERROR, "Unable to initialize Vorbis encoder!\n");
162  vorbis_info_clear(&tmp->vi);
163  return -1;
164  }
165 
166  vorbis_comment_init(&tmp->vc);
167  vorbis_comment_add_tag(&tmp->vc, "ENCODER", "Asterisk PBX");
168  if (comment)
169  vorbis_comment_add_tag(&tmp->vc, "COMMENT", (char *) comment);
170 
171  vorbis_analysis_init(&tmp->vd, &tmp->vi);
172  vorbis_block_init(&tmp->vd, &tmp->vb);
173 
174  ogg_stream_init(&tmp->os, ast_random());
175 
176  vorbis_analysis_headerout(&tmp->vd, &tmp->vc, &header, &header_comm,
177  &header_code);
178  ogg_stream_packetin(&tmp->os, &header);
179  ogg_stream_packetin(&tmp->os, &header_comm);
180  ogg_stream_packetin(&tmp->os, &header_code);
181 
182  while (!tmp->eos) {
183  if (ogg_stream_flush(&tmp->os, &tmp->og) == 0)
184  break;
185  if (fwrite(tmp->og.header, 1, tmp->og.header_len, s->f) != tmp->og.header_len) {
186  ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
187  }
188  if (fwrite(tmp->og.body, 1, tmp->og.body_len, s->f) != tmp->og.body_len) {
189  ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
190  }
191  if (ogg_page_eos(&tmp->og))
192  tmp->eos = 1;
193  }
194 
195  return 0;
196 }
197 
198 /*!
199  * \brief Write out any pending encoded data.
200  * \param s An OGG/Vorbis filestream.
201  * \param f The file to write to.
202  */
203 static void write_stream(struct ogg_vorbis_desc *s, FILE *f)
204 {
205  while (vorbis_analysis_blockout(&s->vd, &s->vb) == 1) {
206  vorbis_analysis(&s->vb, NULL);
207  vorbis_bitrate_addblock(&s->vb);
208 
209  while (vorbis_bitrate_flushpacket(&s->vd, &s->op)) {
210  ogg_stream_packetin(&s->os, &s->op);
211  while (!s->eos) {
212  if (ogg_stream_pageout(&s->os, &s->og) == 0) {
213  break;
214  }
215  if (fwrite(s->og.header, 1, s->og.header_len, f) != s->og.header_len) {
216  ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
217  }
218  if (fwrite(s->og.body, 1, s->og.body_len, f) != s->og.body_len) {
219  ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
220  }
221  if (ogg_page_eos(&s->og)) {
222  s->eos = 1;
223  }
224  }
225  }
226  }
227 }
228 
229 /*!
230  * \brief Write audio data from a frame to an OGG/Vorbis filestream.
231  * \param fs An OGG/Vorbis filestream.
232  * \param f A frame containing audio to be written to the filestream.
233  * \return -1 if there was an error, 0 on success.
234  */
235 static int ogg_vorbis_write(struct ast_filestream *fs, struct ast_frame *f)
236 {
237  int i;
238  float **buffer;
239  short *data;
240  struct ogg_vorbis_desc *s = (struct ogg_vorbis_desc *) fs->_private;
241 
242  if (!s->writing) {
243  ast_log(LOG_ERROR, "This stream is not set up for writing!\n");
244  return -1;
245  }
246  if (!f->datalen)
247  return -1;
248 
249  data = (short *) f->data.ptr;
250 
251  buffer = vorbis_analysis_buffer(&s->vd, f->samples);
252 
253  for (i = 0; i < f->samples; i++)
254  buffer[0][i] = (double)data[i] / 32768.0;
255 
256  vorbis_analysis_wrote(&s->vd, f->samples);
257 
258  write_stream(s, fs->f);
259 
260  s->writing_pcm_pos += f->samples;
261 
262  return 0;
263 }
264 
265 /*!
266  * \brief Close a OGG/Vorbis filestream.
267  * \param fs A OGG/Vorbis filestream.
268  */
269 static void ogg_vorbis_close(struct ast_filestream *fs)
270 {
271  struct ogg_vorbis_desc *s = (struct ogg_vorbis_desc *) fs->_private;
272 
273  if (s->writing) {
274  /* Tell the Vorbis encoder that the stream is finished
275  * and write out the rest of the data */
276  vorbis_analysis_wrote(&s->vd, 0);
277  write_stream(s, fs->f);
278 
279  /* Cleanup */
280  ogg_stream_clear(&s->os);
281  vorbis_block_clear(&s->vb);
282  vorbis_dsp_clear(&s->vd);
283  vorbis_comment_clear(&s->vc);
284  vorbis_info_clear(&s->vi);
285  } else {
286  /* clear OggVorbis_File handle */
287  ov_clear(&s->ov_f);
288  }
289 }
290 
291 /*!
292  * \brief Read a frame full of audio data from the filestream.
293  * \param fs The filestream.
294  * \param whennext Number of sample times to schedule the next call.
295  * \return A pointer to a frame containing audio data or NULL ifthere is no more audio data.
296  */
297 static struct ast_frame *ogg_vorbis_read(struct ast_filestream *fs,
298  int *whennext)
299 {
300  struct ogg_vorbis_desc *desc = (struct ogg_vorbis_desc *) fs->_private;
301  int current_bitstream = -10;
302  char *out_buf;
303  long bytes_read;
304 
305  if (desc->writing) {
306  ast_log(LOG_WARNING, "Reading is not supported on OGG/Vorbis on write files.\n");
307  return NULL;
308  }
309 
310  /* initialize frame */
312  out_buf = (char *) (fs->fr.data.ptr); /* SLIN data buffer */
313 
314  /* read samples from OV interface */
315  bytes_read = ov_read(
316  &desc->ov_f,
317  out_buf, /* Buffer to write data */
318  BUF_SIZE, /* Size of buffer */
319  (__BYTE_ORDER == __BIG_ENDIAN), /* Endianes (0 for little) */
320  2, /* 1 = 8bit, 2 = 16bit */
321  1, /* 0 = unsigned, 1 = signed */
322  &current_bitstream /* Returns the current bitstream section */
323  );
324 
325  /* check returned data */
326  if (bytes_read <= 0) {
327  /* End of stream */
328  return NULL;
329  }
330 
331  /* Return decoded bytes */
332  fs->fr.datalen = bytes_read;
333  fs->fr.samples = bytes_read / 2;
334  *whennext = fs->fr.samples;
335  return &fs->fr;
336 }
337 
338 /*!
339  * \brief Trucate an OGG/Vorbis filestream.
340  * \param fs The filestream to truncate.
341  * \return 0 on success, -1 on failure.
342  */
343 
344 static int ogg_vorbis_trunc(struct ast_filestream *fs)
345 {
346  ast_log(LOG_WARNING, "Truncation is not supported on OGG/Vorbis streams!\n");
347  return -1;
348 }
349 
350 /*!
351  * \brief Tell the current position in OGG/Vorbis filestream measured in pcms.
352  * \param fs The filestream to take action on.
353  * \return 0 or greater with the position measured in samples, or -1 for false.
354  */
355 static off_t ogg_vorbis_tell(struct ast_filestream *fs)
356 {
357  off_t pos;
358  struct ogg_vorbis_desc *desc = (struct ogg_vorbis_desc *) fs->_private;
359 
360  if (desc->writing) {
361  return desc->writing_pcm_pos;
362  }
363 
364  if ((pos = ov_pcm_tell(&desc->ov_f)) < 0) {
365  return -1;
366  }
367  return pos;
368 }
369 
370 /*!
371  * \brief Seek to a specific position in an OGG/Vorbis filestream.
372  * \param fs The filestream to take action on.
373  * \param sample_offset New position for the filestream, measured in 8KHz samples.
374  * \param whence Location to measure
375  * \return 0 on success, -1 on failure.
376  */
377 static int ogg_vorbis_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
378 {
379  int seek_result = -1;
380  off_t relative_pcm_pos;
381  struct ogg_vorbis_desc *desc = (struct ogg_vorbis_desc *) fs->_private;
382 
383  if (desc->writing) {
384  ast_log(LOG_WARNING, "Seeking is not supported on OGG/Vorbis streams in writing mode!\n");
385  return -1;
386  }
387 
388  /* ov_pcm_seek support seeking only from begining (SEEK_SET), the rest must be emulated */
389  switch (whence) {
390  case SEEK_SET:
391  seek_result = ov_pcm_seek(&desc->ov_f, sample_offset);
392  break;
393  case SEEK_CUR:
394  if ((relative_pcm_pos = ogg_vorbis_tell(fs)) < 0) {
395  seek_result = -1;
396  break;
397  }
398  seek_result = ov_pcm_seek(&desc->ov_f, relative_pcm_pos + sample_offset);
399  break;
400  case SEEK_END:
401  if ((relative_pcm_pos = ov_pcm_total(&desc->ov_f, -1)) < 0) {
402  seek_result = -1;
403  break;
404  }
405  seek_result = ov_pcm_seek(&desc->ov_f, relative_pcm_pos - sample_offset);
406  break;
407  default:
408  ast_log(LOG_WARNING, "Unknown *whence* to seek on OGG/Vorbis streams!\n");
409  break;
410  }
411 
412  /* normalize error value to -1,0 */
413  return (seek_result == 0) ? 0 : -1;
414 }
415 
416 static struct ast_format_def vorbis_f = {
417  .name = "ogg_vorbis",
418  .exts = "ogg",
419  .open = ogg_vorbis_open,
420  .rewrite = ogg_vorbis_rewrite,
421  .write = ogg_vorbis_write,
422  .seek = ogg_vorbis_seek,
423  .trunc = ogg_vorbis_trunc,
424  .tell = ogg_vorbis_tell,
425  .read = ogg_vorbis_read,
426  .close = ogg_vorbis_close,
427  .buf_size = BUF_SIZE + AST_FRIENDLY_OFFSET,
428  .desc_size = sizeof(struct ogg_vorbis_desc),
429 };
430 
431 static int load_module(void)
432 {
433  vorbis_f.format = ast_format_slin;
434  if (ast_format_def_register(&vorbis_f))
437 }
438 
439 static int unload_module(void)
440 {
441  return ast_format_def_unregister(vorbis_f.name);
442 }
443 
445  .support_level = AST_MODULE_SUPPORT_CORE,
446  .load = load_module,
447  .unload = unload_module,
448  .load_pri = AST_MODPRI_APP_DEPEND
449 );
Asterisk main include file. File version handling, generic pbx functions.
int eos
Indicates whether an End of Stream condition has been detected.
#define DEFAULT_SAMPLE_RATE
Definition: asterisk.h:46
static struct ast_frame * ogg_vorbis_read(struct ast_filestream *fs, int *whennext)
Read a frame full of audio data from the filestream.
static int ogg_vorbis_rewrite(struct ast_filestream *s, const char *comment)
Create a new OGG/Vorbis filestream and set it up for writing.
#define LOG_WARNING
Definition: logger.h:274
static int tmp()
Definition: bt_open.c:389
static int unload_module(void)
static void write_stream(struct ogg_vorbis_desc *s, FILE *f)
Write out any pending encoded data.
static const char desc[]
Definition: cdr_mysql.c:73
if(!yyg->yy_init)
Definition: ast_expr2f.c:868
vorbis_comment vc
static void ogg_vorbis_close(struct ast_filestream *fs)
Close a OGG/Vorbis filestream.
static int load_module(void)
#define BUF_SIZE
#define NULL
Definition: resample.c:96
I/O Management (derived from Cheops-NG)
Each supported file format is described by the following structure.
Definition: mod_format.h:43
static int ogg_vorbis_open(struct ast_filestream *s)
Create a new OGG/Vorbis filestream and set it up for reading.
Header for providers of file and format handling routines. Clients of these routines should include "...
int ast_format_def_unregister(const char *name)
Unregisters a file format.
Definition: file.c:162
#define ast_log
Definition: astobj2.c:42
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.
#define __BYTE_ORDER
static int ogg_vorbis_trunc(struct ast_filestream *fs)
Trucate an OGG/Vorbis filestream.
#define AST_FRIENDLY_OFFSET
Offset into a frame&#39;s data buffer.
off_t writing_pcm_pos
Stores the current pcm position to support tell() on writing mode.
static int ogg_vorbis_write(struct ast_filestream *fs, struct ast_frame *f)
Write audio data from a frame to an OGG/Vorbis filestream.
#define ast_format_def_register(f)
Definition: mod_format.h:136
long int ast_random(void)
Definition: main/utils.c:2064
struct ast_frame fr
frame produced by read, typically
Definition: mod_format.h:122
struct ast_format * format
Definition: mod_format.h:48
vorbis_dsp_state vd
void * _private
Definition: mod_format.h:124
#define LOG_ERROR
Definition: logger.h:285
#define AST_FRAME_SET_BUFFER(fr, _base, _ofs, _datalen)
int errno
#define comment
Definition: ael_lex.c:976
static off_t ogg_vorbis_tell(struct ast_filestream *fs)
Tell the current position in OGG/Vorbis filestream measured in pcms.
char name[80]
Definition: mod_format.h:44
OggVorbis_File ov_f
#define __BIG_ENDIAN
Definition: endian.h:49
static struct ast_format_def vorbis_f
Module has failed to load, may be in an inconsistent state.
Definition: module.h:78
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS|AST_MODFLAG_LOAD_ORDER, "HTTP Phone Provisioning",.support_level=AST_MODULE_SUPPORT_EXTENDED,.load=load_module,.unload=unload_module,.reload=reload,.load_pri=AST_MODPRI_CHANNEL_DEPEND,.requires="http",)
This structure is allocated by file.c in one chunk, together with buf_size and desc_size bytes of mem...
Definition: mod_format.h:101
static PGresult * result
Definition: cel_pgsql.c:88
Data structure associated with a single frame of data.
int writing
Indicates whether this filestream is set up for reading or writing.
union ast_frame::@263 data
#define ASTERISK_GPL_KEY
The text the key() function should return.
Definition: module.h:46
struct ast_format * ast_format_slin
Built-in cached signed linear 8kHz format.
Definition: format_cache.c:41
Asterisk module definitions.
ogg_stream_state os
Media Format Cache API.