/* libSoX Ogg Vorbis sound format handler * Copyright 2001, Stan Seibert <indigo@aztec.asu.edu> * * Portions from oggenc, (c) Michael Smith <msmith@labyrinth.net.au>, * ogg123, (c) Kenneth Arnold <kcarnold@yahoo.com>, and * libvorbisfile (c) Xiphophorus Company * * May 9, 2001 - Stan Seibert (indigo@aztec.asu.edu) * Ogg Vorbis handler initially written. * * July 5, 1991 - Skeleton file * Copyright 1991 Lance Norskog And Sundry Contributors * This source code is freely redistributable and may be used for * any purpose.  This copyright notice must be maintained. * Lance Norskog And Sundry Contributors are not responsible for * the consequences of using this software. */ #include "sox_i.h" #include <stdio.h>#include <string.h>#include <errno.h> #include <ogg/ogg.h>#include <vorbis/codec.h>#include <vorbis/vorbisfile.h>#include <vorbis/vorbisenc.h> #define DEF_BUF_LEN 4096 #define BUF_ERROR -1#define BUF_EOF  0#define BUF_DATA 1 #define HEADER_ERROR 0#define HEADER_OK   1 /* Private data for Ogg Vorbis file */typedef struct {  ogg_stream_state os;  ogg_page og;  ogg_packet op;   vorbis_dsp_state vd;  vorbis_block vb;  vorbis_info vi;} vorbis_enc_t; typedef struct {  /* Decoding data */  OggVorbis_File *vf;  char *buf;  size_t buf_len;  size_t start;  size_t end;     /* Unsent data samples in buf[start] through buf[end-1] */  int current_section;  int eof;   vorbis_enc_t *vorbis_enc_data;} priv_t; /******** Callback functions used in ov_open_callbacks ************/ static size_t callback_read(void* ptr, size_t size, size_t nmemb, void* ft_data){  sox_format_t* ft = (sox_format_t*)ft_data;  size_t ret = lsx_readbuf(ft, ptr, size * nmemb);  return ret / size;} static int callback_seek(void* ft_data, ogg_int64_t off, int whence){  sox_format_t* ft = (sox_format_t*)ft_data;  int ret = ft->seekable ? lsx_seeki(ft, (off_t)off, whence) : -1;   if (ret == EBADF)    ret = -1;  return ret;} static int callback_close(void* ft_data UNUSED){  /* Do nothing so sox can close the file for us */  return 0;} static long callback_tell(void* ft_data){  sox_format_t* ft = (sox_format_t*)ft_data;  return lsx_tell(ft);} /********************* End callbacks *****************************/  /* * Do anything required before you start reading samples. * Read file header. *      Find out sampling rate, *      size and encoding of samples, *      mono/stereo/quad. */static int startread(sox_format_t * ft){  priv_t * vb = (priv_t *) ft->priv;  vorbis_info *vi;  vorbis_comment *vc;  int i;   ov_callbacks callbacks = {    callback_read,    callback_seek,    callback_close,    callback_tell  };   /* Allocate space for decoding structure */  vb->vf = lsx_malloc(sizeof(OggVorbis_File));   /* Init the decoder */  if (ov_open_callbacks(ft, vb->vf, NULL, (size_t) 0, callbacks) < 0) {    lsx_fail_errno(ft, SOX_EHDR, "Input not an Ogg Vorbis audio stream");    return (SOX_EOF);  }   /* Get info about the Ogg Vorbis stream */  vi = ov_info(vb->vf, -1);  vc = ov_comment(vb->vf, -1);   /* Record audio info */  ft->signal.rate = vi->rate;  ft->encoding.encoding = SOX_ENCODING_VORBIS;  ft->signal.channels = vi->channels;   /* ov_pcm_total doesn't work on non-seekable files so   * skip that step in that case.  Also, it reports   * "frame"-ish results so we must * channels.   */  if (ft->seekable)    ft->signal.length = ov_pcm_total(vb->vf, -1) * ft->signal.channels;   /* Record comments */  for (i = 0; i < vc->comments; i++)    sox_append_comment(&ft->oob.comments, vc->user_comments[i]);   /* Setup buffer */  vb->buf_len = DEF_BUF_LEN;  vb->buf_len -= vb->buf_len % (vi->channels*2); /* 2 bytes per sample */  vb->buf = lsx_calloc(vb->buf_len, sizeof(char));  vb->start = vb->end = 0;   /* Fill in other info */  vb->eof = 0;  vb->current_section = -1;   return (SOX_SUCCESS);}  /* Refill the buffer with samples.  Returns BUF_EOF if the end of the * vorbis data was reached while the buffer was being filled, * BUF_ERROR is something bad happens, and BUF_DATA otherwise */static int refill_buffer(priv_t * vb){  int num_read;   if (vb->start == vb->end)     /* Samples all played */    vb->start = vb->end = 0;   while (vb->end < vb->buf_len) {    num_read = ov_read(vb->vf, vb->buf + vb->end,        (int) (vb->buf_len - vb->end), 0, 2, 1, &vb->current_section);    if (num_read == 0)      return (BUF_EOF);    else if (num_read == OV_HOLE)      lsx_warn("Warning: hole in stream; probably harmless");    else if (num_read < 0)      return (BUF_ERROR);    else      vb->end += num_read;  }  return (BUF_DATA);}  /* * Read up to len samples from file. * Convert to signed longs. * Place in buf[]. * Return number of samples read. */ static size_t read_samples(sox_format_t * ft, sox_sample_t * buf, size_t len){  priv_t * vb = (priv_t *) ft->priv;  size_t i;  int ret;  sox_sample_t l;    for (i = 0; i < len; i++) {    if (vb->start == vb->end) {      if (vb->eof)        break;      ret = refill_buffer(vb);      if (ret == BUF_EOF || ret == BUF_ERROR) {        vb->eof = 1;        if (vb->end == 0)          break;      }    }     l = (vb->buf[vb->start + 1] << 24)        | (0xffffff & (vb->buf[vb->start] << 16));    *(buf + i) = l;    vb->start += 2;  }  return i;} /* * Do anything required when you stop reading samples. * Don't close input file! */static int stopread(sox_format_t * ft){  priv_t * vb = (priv_t *) ft->priv;   free(vb->buf);  ov_clear(vb->vf);   return (SOX_SUCCESS);} /* Write a page of ogg data to a file.  Taken directly from encode.c in * oggenc.   Returns the number of bytes written. */static int oe_write_page(ogg_page * page, sox_format_t * ft){  int written;   written = lsx_writebuf(ft, page->header, (size_t) page->header_len);  written += lsx_writebuf(ft, page->body, (size_t) page->body_len);   return written;} /* Write out the header packets.  Derived mostly from encode.c in oggenc. * Returns HEADER_OK if the header can be written, HEADER_ERROR otherwise. */static int write_vorbis_header(sox_format_t * ft, vorbis_enc_t * ve){  ogg_packet header_main;  ogg_packet header_comments;  ogg_packet header_codebooks;  vorbis_comment vc;  int i, ret = HEADER_OK;   memset(&vc, 0, sizeof(vc));  vc.comments = sox_num_comments(ft->oob.comments);  if (vc.comments) {     /* Make the comment structure */    vc.comment_lengths = lsx_calloc((size_t)vc.comments, sizeof(*vc.comment_lengths));    vc.user_comments = lsx_calloc((size_t)vc.comments, sizeof(*vc.user_comments));    for (i = 0; i < vc.comments; ++i) {      static const char prepend[] = "Comment=";      char * text = lsx_calloc(strlen(prepend) + strlen(ft->oob.comments[i]) + 1, sizeof(*text));      /* Prepend `Comment=' if no field-name already in the comment */      if (!strchr(ft->oob.comments[i], '='))        strcpy(text, prepend);      vc.user_comments[i] = strcat(text, ft->oob.comments[i]);      vc.comment_lengths[i] = strlen(text);    }  }  if (vorbis_analysis_headerout(    /* Build the packets */      &ve->vd, &vc, &header_main, &header_comments, &header_codebooks) < 0) {      ret = HEADER_ERROR;      goto cleanup;  }   ogg_stream_packetin(&ve->os, &header_main);   /* And stream them out */  ogg_stream_packetin(&ve->os, &header_comments);  ogg_stream_packetin(&ve->os, &header_codebooks);   while (ogg_stream_flush(&ve->os, &ve->og) && ret == HEADER_OK)    if (!oe_write_page(&ve->og, ft))      ret = HEADER_ERROR;cleanup:  for (i = 0; i < vc.comments; ++i)    free(vc.user_comments[i]);  free(vc.user_comments);  free(vc.comment_lengths);  return ret;} static int startwrite(sox_format_t * ft){  priv_t * vb = (priv_t *) ft->priv;  vorbis_enc_t *ve;  long rate;  double quality = 3;           /* Default compression quality gives ~112kbps */   ft->encoding.encoding = SOX_ENCODING_VORBIS;   /* Allocate memory for all of the structures */  ve = vb->vorbis_enc_data = lsx_malloc(sizeof(vorbis_enc_t));   vorbis_info_init(&ve->vi);   /* TODO */  rate = ft->signal.rate;  if (rate)    lsx_fail_errno(ft, SOX_EHDR,      "Error setting-up Ogg Vorbis encoder; check sample-rate & # of channels");   /* Use encoding to average bit rate of VBR as specified by the -C option */  if (ft->encoding.compression != HUGE_VAL) {    if (ft->encoding.compression < -1 || ft->encoding.compression > 10) {      lsx_fail_errno(ft, SOX_EINVAL,                     "Vorbis compression quality nust be between -1 and 10");      return SOX_EOF;    }    quality = ft->encoding.compression;  }   if (vorbis_encode_init_vbr(&ve->vi, ft->signal.channels, ft->signal.rate + .5, quality / 10))  {    lsx_fail_errno(ft, SOX_EFMT, "libVorbis cannot encode this sample-rate or # of channels");    return SOX_EOF;  }   vorbis_analysis_init(&ve->vd, &ve->vi);  vorbis_block_init(&ve->vd, &ve->vb);   ogg_stream_init(&ve->os, INT_MAX & (int)RANQD1);  /* Random serial number */   if (write_vorbis_header(ft, ve) == HEADER_ERROR) {    lsx_fail_errno(ft, SOX_EHDR,                   "Error writing header for Ogg Vorbis audio stream");    return (SOX_EOF);  }   return (SOX_SUCCESS);} static size_t write_samples(sox_format_t * ft, const sox_sample_t * buf,                        size_t len){  priv_t * vb = (priv_t *) ft->priv;  vorbis_enc_t *ve = vb->vorbis_enc_data;  size_t samples = len / ft->signal.channels;  float **buffer = vorbis_analysis_buffer(&ve->vd, (int) samples);  size_t i, j;  int ret;  int eos = 0;   /* Copy samples into vorbis buffer */  for (i = 0; i < samples; i++)    for (j = 0; j < ft->signal.channels; j++)      buffer[j][i] = buf[i * ft->signal.channels + j]          / ((float) SOX_SAMPLE_MAX);   vorbis_analysis_wrote(&ve->vd, (int) samples);   while (vorbis_analysis_blockout(&ve->vd, &ve->vb) == 1) {    /* Do the main analysis, creating a packet */    vorbis_analysis(&ve->vb, &ve->op);    vorbis_bitrate_addblock(&ve->vb);     /* Add packet to bitstream */    while (vorbis_bitrate_flushpacket(&ve->vd, &ve->op)) {      ogg_stream_packetin(&ve->os, &ve->op);       /* If we've gone over a page boundary, we can do actual       * output, so do so (for however many pages are available)       */       while (!eos) {        int result = ogg_stream_pageout(&ve->os, &ve->og);         if (!result)          break;         ret = oe_write_page(&ve->og, ft);        if (!ret)          return 0;         if (ogg_page_eos(&ve->og))          eos = 1;      }    }  }   return (len);} static int stopwrite(sox_format_t * ft){  priv_t * vb = (priv_t *) ft->priv;  vorbis_enc_t *ve = vb->vorbis_enc_data;   /* Close out the remaining data */  write_samples(ft, NULL, (size_t) 0);   ogg_stream_clear(&ve->os);  vorbis_block_clear(&ve->vb);  vorbis_dsp_clear(&ve->vd);  vorbis_info_clear(&ve->vi);   return (SOX_SUCCESS);} static int seek(sox_format_t * ft, uint64_t offset){  priv_t * vb = (priv_t *) ft->priv;   return ov_pcm_seek(vb->vf, (ogg_int64_t)(offset / ft->signal.channels))? SOX_EOF:SOX_SUCCESS;} LSX_FORMAT_HANDLER(vorbis){  static const char *names[] = {"vorbis", "ogg", NULL};  static const unsigned encodings[] = {SOX_ENCODING_VORBIS, 0, 0};  static sox_format_handler_t handler = {SOX_LIB_VERSION_CODE,    "Xiph.org's ogg-vorbis lossy compression", names, 0,    startread, read_samples, stopread,    startwrite, write_samples, stopwrite,    seek, encodings, NULL, sizeof(priv_t)  };  return &handler;}