--- /dev/null
+/*
+** Copyright (C) 2002-2011 Erik de Castro Lopo <erikd@mega-nerd.com>
+** Copyright (C) 2002-2005 Michael Smith <msmith@xiph.org>
+** Copyright (C) 2007 John ffitch
+**
+** This program is free software ; you can redistribute it and/or modify
+** it under the terms of the GNU Lesser General Public License as published by
+** the Free Software Foundation ; either version 2.1 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY ; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU Lesser General Public License for more details.
+**
+** You should have received a copy of the GNU Lesser General Public License
+** along with this program ; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
+/*
+** Much of this code is based on the examples in libvorbis from the
+** XIPHOPHORUS Company http://www.xiph.org/ which has a BSD-style Licence
+** Copyright (c) 2002, Xiph.org Foundation
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** - Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+**
+** - Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in the
+** documentation and/or other materials provided with the distribution.
+**
+** - Neither the name of the Xiph.org Foundation nor the names of its
+** contributors may be used to endorse or promote products derived from
+** this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION
+** OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES ; LOSS OF USE,
+** DATA, OR PROFITS ; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "sfconfig.h"
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include <math.h>
+
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "sndfile.h"
+#include "sfendian.h"
+#include "common.h"
+
+#if HAVE_EXTERNAL_LIBS
+
+#include <ogg/ogg.h>
+#include <vorbis/codec.h>
+#include <vorbis/vorbisenc.h>
+
+#include "ogg.h"
+
+typedef int convert_func (int, void *, int, int, float **) ;
+
+static int vorbis_read_header (SF_PRIVATE *psf, int log_data) ;
+static int vorbis_write_header (SF_PRIVATE *psf, int calc_length) ;
+static int vorbis_close (SF_PRIVATE *psf) ;
+static int vorbis_command (SF_PRIVATE *psf, int command, void *data, int datasize) ;
+static sf_count_t vorbis_seek (SF_PRIVATE *psf, int mode, sf_count_t offset) ;
+static sf_count_t vorbis_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
+static sf_count_t vorbis_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
+static sf_count_t vorbis_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
+static sf_count_t vorbis_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
+static sf_count_t vorbis_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
+static sf_count_t vorbis_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
+static sf_count_t vorbis_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
+static sf_count_t vorbis_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
+static sf_count_t vorbis_read_sample (SF_PRIVATE *psf, void *ptr, sf_count_t lens, convert_func *transfn) ;
+static sf_count_t vorbis_length (SF_PRIVATE *psf) ;
+
+typedef struct
+{ int id ;
+ const char *name ;
+} STR_PAIRS ;
+
+static STR_PAIRS vorbis_metatypes [] =
+{ { SF_STR_TITLE, "Title" },
+ { SF_STR_COPYRIGHT, "Copyright" },
+ { SF_STR_SOFTWARE, "Software" },
+ { SF_STR_ARTIST, "Artist" },
+ { SF_STR_COMMENT, "Comment" },
+ { SF_STR_DATE, "Date" },
+ { SF_STR_ALBUM, "Album" },
+ { SF_STR_LICENSE, "License" },
+} ;
+
+typedef struct
+{ /* Count current location */
+ sf_count_t loc ;
+ /* Struct that stores all the static vorbis bitstream settings */
+ vorbis_info vinfo ;
+ /* Struct that stores all the bitstream user comments */
+ vorbis_comment vcomment ;
+ /* Ventral working state for the packet->PCM decoder */
+ vorbis_dsp_state vdsp ;
+ /* Local working space for packet->PCM decode */
+ vorbis_block vblock ;
+
+ /* Encoding quality in range [0.0, 1.0]. */
+ double quality ;
+} VORBIS_PRIVATE ;
+
+static int
+vorbis_read_header (SF_PRIVATE *psf, int log_data)
+{
+ OGG_PRIVATE *odata = (OGG_PRIVATE *) psf->container_data ;
+ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
+ char *buffer ;
+ int bytes ;
+ int i, nn ;
+
+ odata->eos = 0 ;
+
+ /* Weird stuff happens if these aren't called. */
+ ogg_stream_reset (&odata->ostream) ;
+ ogg_sync_reset (&odata->osync) ;
+
+ /*
+ ** Grab some data at the head of the stream. We want the first page
+ ** (which is guaranteed to be small and only contain the Vorbis
+ ** stream initial header) We need the first page to get the stream
+ ** serialno.
+ */
+
+ /* Expose the buffer */
+ buffer = ogg_sync_buffer (&odata->osync, 4096L) ;
+
+ /* Grab the part of the header that has already been read. */
+ memcpy (buffer, psf->header, psf->headindex) ;
+ bytes = psf->headindex ;
+
+ /* Submit a 4k block to libvorbis' Ogg layer */
+ bytes += psf_fread (buffer + psf->headindex, 1, 4096 - psf->headindex, psf) ;
+ ogg_sync_wrote (&odata->osync, bytes) ;
+
+ /* Get the first page. */
+ if ((nn = ogg_sync_pageout (&odata->osync, &odata->opage)) != 1)
+ {
+ /* Have we simply run out of data? If so, we're done. */
+ if (bytes < 4096)
+ return 0 ;
+
+ /* Error case. Must not be Vorbis data */
+ psf_log_printf (psf, "Input does not appear to be an Ogg bitstream.\n") ;
+ return SFE_MALFORMED_FILE ;
+ } ;
+
+ /*
+ ** Get the serial number and set up the rest of decode.
+ ** Serialno first ; use it to set up a logical stream.
+ */
+ ogg_stream_clear (&odata->ostream) ;
+ ogg_stream_init (&odata->ostream, ogg_page_serialno (&odata->opage)) ;
+
+ if (ogg_stream_pagein (&odata->ostream, &odata->opage) < 0)
+ { /* Error ; stream version mismatch perhaps. */
+ psf_log_printf (psf, "Error reading first page of Ogg bitstream data\n") ;
+ return SFE_MALFORMED_FILE ;
+ } ;
+
+ if (ogg_stream_packetout (&odata->ostream, &odata->opacket) != 1)
+ { /* No page? must not be vorbis. */
+ psf_log_printf (psf, "Error reading initial header packet.\n") ;
+ return SFE_MALFORMED_FILE ;
+ } ;
+
+ /*
+ ** This function (vorbis_read_header) gets called multiple times, so the OGG
+ ** and vorbis structs have to be cleared every time we pass through to
+ ** prevent memory leaks.
+ */
+ vorbis_block_clear (&vdata->vblock) ;
+ vorbis_dsp_clear (&vdata->vdsp) ;
+ vorbis_comment_clear (&vdata->vcomment) ;
+ vorbis_info_clear (&vdata->vinfo) ;
+
+ /*
+ ** Extract the initial header from the first page and verify that the
+ ** Ogg bitstream is in fact Vorbis data.
+ **
+ ** I handle the initial header first instead of just having the code
+ ** read all three Vorbis headers at once because reading the initial
+ ** header is an easy way to identify a Vorbis bitstream and it's
+ ** useful to see that functionality seperated out.
+ */
+ vorbis_info_init (&vdata->vinfo) ;
+ vorbis_comment_init (&vdata->vcomment) ;
+
+ if (vorbis_synthesis_headerin (&vdata->vinfo, &vdata->vcomment, &odata->opacket) < 0)
+ { /* Error case ; not a vorbis header. */
+ psf_log_printf (psf, "Found Vorbis in stream header, but vorbis_synthesis_headerin failed.\n") ;
+ return SFE_MALFORMED_FILE ;
+ } ;
+
+ /*
+ ** Common Ogg metadata fields?
+ ** TITLE, VERSION, ALBUM, TRACKNUMBER, ARTIST, PERFORMER, COPYRIGHT, LICENSE,
+ ** ORGANIZATION, DESCRIPTION, GENRE, DATE, LOCATION, CONTACT, ISRC,
+ */
+
+ if (log_data)
+ { int k ;
+
+ for (k = 0 ; k < ARRAY_LEN (vorbis_metatypes) ; k++)
+ { char *dd ;
+
+ dd = vorbis_comment_query (&vdata->vcomment, vorbis_metatypes [k].name, 0) ;
+ if (dd == NULL)
+ continue ;
+ psf_store_string (psf, vorbis_metatypes [k].id, dd) ;
+ } ;
+ } ;
+
+ /*
+ ** At this point, we're sure we're Vorbis. We've set up the logical (Ogg)
+ ** bitstream decoder. Get the comment and codebook headers and set up the
+ ** Vorbis decoder.
+ **
+ ** The next two packets in order are the comment and codebook headers.
+ ** They're likely large and may span multiple pages. Thus we reead
+ ** and submit data until we get our two pacakets, watching that no
+ ** pages are missing. If a page is missing, error out ; losing a
+ ** header page is the only place where missing data is fatal.
+ */
+
+ i = 0 ; /* Count of number of packets read */
+ while (i < 2)
+ { int result = ogg_sync_pageout (&odata->osync, &odata->opage) ;
+ if (result == 0)
+ { /* Need more data */
+ buffer = ogg_sync_buffer (&odata->osync, 4096) ;
+ bytes = psf_fread (buffer, 1, 4096, psf) ;
+
+ if (bytes == 0 && i < 2)
+ { psf_log_printf (psf, "End of file before finding all Vorbis headers!\n") ;
+ return SFE_MALFORMED_FILE ;
+ } ;
+ nn = ogg_sync_wrote (&odata->osync, bytes) ;
+ }
+ else if (result == 1)
+ { /*
+ ** Don't complain about missing or corrupt data yet. We'll
+ ** catch it at the packet output phase.
+ **
+ ** We can ignore any errors here as they'll also become apparent
+ ** at packetout.
+ */
+ nn = ogg_stream_pagein (&odata->ostream, &odata->opage) ;
+ while (i < 2)
+ { result = ogg_stream_packetout (&odata->ostream, &odata->opacket) ;
+ if (result == 0)
+ break ;
+ if (result < 0)
+ { /* Uh oh ; data at some point was corrupted or missing!
+ ** We can't tolerate that in a header. Die. */
+ psf_log_printf (psf, "Corrupt secondary header. Exiting.\n") ;
+ return SFE_MALFORMED_FILE ;
+ } ;
+
+ vorbis_synthesis_headerin (&vdata->vinfo, &vdata->vcomment, &odata->opacket) ;
+ i++ ;
+ } ;
+ } ;
+ } ;
+
+ if (log_data)
+ { int printed_metadata_msg = 0 ;
+ int k ;
+
+ psf_log_printf (psf, "Bitstream is %d channel, %D Hz\n", vdata->vinfo.channels, vdata->vinfo.rate) ;
+ psf_log_printf (psf, "Encoded by : %s\n", vdata->vcomment.vendor) ;
+
+ /* Throw the comments plus a few lines about the bitstream we're decoding. */
+ for (k = 0 ; k < ARRAY_LEN (vorbis_metatypes) ; k++)
+ { char *dd ;
+
+ dd = vorbis_comment_query (&vdata->vcomment, vorbis_metatypes [k].name, 0) ;
+ if (dd == NULL)
+ continue ;
+
+ if (printed_metadata_msg == 0)
+ { psf_log_printf (psf, "Metadata :\n") ;
+ printed_metadata_msg = 1 ;
+ } ;
+
+ psf_store_string (psf, vorbis_metatypes [k].id, dd) ;
+ psf_log_printf (psf, " %-10s : %s\n", vorbis_metatypes [k].name, dd) ;
+ } ;
+
+ psf_log_printf (psf, "End\n") ;
+ } ;
+
+ psf->sf.samplerate = vdata->vinfo.rate ;
+ psf->sf.channels = vdata->vinfo.channels ;
+ psf->sf.format = SF_FORMAT_OGG | SF_FORMAT_VORBIS ;
+
+ /* OK, got and parsed all three headers. Initialize the Vorbis
+ ** packet->PCM decoder.
+ ** Central decode state. */
+ vorbis_synthesis_init (&vdata->vdsp, &vdata->vinfo) ;
+
+ /* Local state for most of the decode so multiple block decodes can
+ ** proceed in parallel. We could init multiple vorbis_block structures
+ ** for vd here. */
+ vorbis_block_init (&vdata->vdsp, &vdata->vblock) ;
+
+ vdata->loc = 0 ;
+
+ return 0 ;
+} /* vorbis_read_header */
+
+static int
+vorbis_write_header (SF_PRIVATE *psf, int UNUSED (calc_length))
+{
+ OGG_PRIVATE *odata = (OGG_PRIVATE *) psf->container_data ;
+ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
+ int k, ret ;
+
+ vorbis_info_init (&vdata->vinfo) ;
+
+ /* The style of encoding should be selectable here, VBR quality mode. */
+ ret = vorbis_encode_init_vbr (&vdata->vinfo, psf->sf.channels, psf->sf.samplerate, vdata->quality) ;
+
+#if 0
+ ret = vorbis_encode_init (&vdata->vinfo, psf->sf.channels, psf->sf.samplerate, -1, 128000, -1) ; /* average bitrate mode */
+ ret = ( vorbis_encode_setup_managed (&vdata->vinfo, psf->sf.channels,
+ psf->sf.samplerate, -1, 128000, -1) ||
+ vorbis_encode_ctl (&vdata->vinfo, OV_ECTL_RATEMANAGE_AVG, NULL) ||
+ vorbis_encode_setup_init (&vdata->vinfo)) ;
+#endif
+ if (ret)
+ return SFE_BAD_OPEN_FORMAT ;
+
+ vdata->loc = 0 ;
+
+ /* add a comment */
+ vorbis_comment_init (&vdata->vcomment) ;
+
+ vorbis_comment_add_tag (&vdata->vcomment, "ENCODER", "libsndfile") ;
+ for (k = 0 ; k < SF_MAX_STRINGS ; k++)
+ { const char * name ;
+
+ if (psf->strings [k].type == 0)
+ break ;
+
+ switch (psf->strings [k].type)
+ { case SF_STR_TITLE : name = "TITLE" ; break ;
+ case SF_STR_COPYRIGHT : name = "COPYRIGHT" ; break ;
+ case SF_STR_SOFTWARE : name = "SOFTWARE" ; break ;
+ case SF_STR_ARTIST : name = "ARTIST" ; break ;
+ case SF_STR_COMMENT : name = "COMMENT" ; break ;
+ case SF_STR_DATE : name = "DATE" ; break ;
+ case SF_STR_ALBUM : name = "ALBUM" ; break ;
+ case SF_STR_LICENSE : name = "LICENSE" ; break ;
+ default : continue ;
+ } ;
+
+ vorbis_comment_add_tag (&vdata->vcomment, name, psf->strings [k].str) ;
+ } ;
+
+ /* set up the analysis state and auxiliary encoding storage */
+ vorbis_analysis_init (&vdata->vdsp, &vdata->vinfo) ;
+ vorbis_block_init (&vdata->vdsp, &vdata->vblock) ;
+
+ /*
+ ** Set up our packet->stream encoder.
+ ** Pick a random serial number ; that way we can more likely build
+ ** chained streams just by concatenation.
+ */
+
+ ogg_stream_init (&odata->ostream, psf_rand_int32 ()) ;
+
+ /* Vorbis streams begin with three headers ; the initial header (with
+ most of the codec setup parameters) which is mandated by the Ogg
+ bitstream spec. The second header holds any comment fields. The
+ third header holds the bitstream codebook. We merely need to
+ make the headers, then pass them to libvorbis one at a time ;
+ libvorbis handles the additional Ogg bitstream constraints */
+
+ { ogg_packet header ;
+ ogg_packet header_comm ;
+ ogg_packet header_code ;
+ int result ;
+
+ vorbis_analysis_headerout (&vdata->vdsp, &vdata->vcomment, &header, &header_comm, &header_code) ;
+ ogg_stream_packetin (&odata->ostream, &header) ; /* automatically placed in its own page */
+ ogg_stream_packetin (&odata->ostream, &header_comm) ;
+ ogg_stream_packetin (&odata->ostream, &header_code) ;
+
+ /* This ensures the actual
+ * audio data will start on a new page, as per spec
+ */
+ while ((result = ogg_stream_flush (&odata->ostream, &odata->opage)) != 0)
+ { psf_fwrite (odata->opage.header, 1, odata->opage.header_len, psf) ;
+ psf_fwrite (odata->opage.body, 1, odata->opage.body_len, psf) ;
+ } ;
+ }
+
+ return 0 ;
+} /* vorbis_write_header */
+
+static int
+vorbis_close (SF_PRIVATE *psf)
+{ OGG_PRIVATE* odata = psf->container_data ;
+ VORBIS_PRIVATE *vdata = psf->codec_data ;
+
+ if (odata == NULL || vdata == NULL)
+ return 0 ;
+
+ /* Clean up this logical bitstream ; before exit we shuld see if we're
+ ** followed by another [chained]. */
+
+ if (psf->file.mode == SFM_WRITE)
+ {
+ if (psf->write_current <= 0)
+ vorbis_write_header (psf, 0) ;
+
+ vorbis_analysis_wrote (&vdata->vdsp, 0) ;
+ while (vorbis_analysis_blockout (&vdata->vdsp, &vdata->vblock) == 1)
+ {
+
+ /* analysis, assume we want to use bitrate management */
+ vorbis_analysis (&vdata->vblock, NULL) ;
+ vorbis_bitrate_addblock (&vdata->vblock) ;
+
+ while (vorbis_bitrate_flushpacket (&vdata->vdsp, &odata->opacket))
+ { /* weld the packet into the bitstream */
+ ogg_stream_packetin (&odata->ostream, &odata->opacket) ;
+
+ /* write out pages (if any) */
+ while (!odata->eos)
+ { int result = ogg_stream_pageout (&odata->ostream, &odata->opage) ;
+ if (result == 0) break ;
+ psf_fwrite (odata->opage.header, 1, odata->opage.header_len, psf) ;
+ psf_fwrite (odata->opage.body, 1, odata->opage.body_len, psf) ;
+
+ /* this could be set above, but for illustrative purposes, I do
+ it here (to show that vorbis does know where the stream ends) */
+
+ if (ogg_page_eos (&odata->opage)) odata->eos = 1 ;
+ }
+ }
+ }
+ }
+
+ /* ogg_page and ogg_packet structs always point to storage in
+ libvorbis. They are never freed or manipulated directly */
+
+ vorbis_block_clear (&vdata->vblock) ;
+ vorbis_dsp_clear (&vdata->vdsp) ;
+ vorbis_comment_clear (&vdata->vcomment) ;
+ vorbis_info_clear (&vdata->vinfo) ;
+
+ return 0 ;
+} /* vorbis_close */
+
+int
+ogg_vorbis_open (SF_PRIVATE *psf)
+{ OGG_PRIVATE* odata = psf->container_data ;
+ VORBIS_PRIVATE* vdata = calloc (1, sizeof (VORBIS_PRIVATE)) ;
+ int error = 0 ;
+
+ if (odata == NULL)
+ { psf_log_printf (psf, "%s : odata is NULL???\n", __func__) ;
+ return SFE_INTERNAL ;
+ } ;
+
+ psf->codec_data = vdata ;
+
+ if (psf->file.mode == SFM_RDWR)
+ return SFE_BAD_MODE_RW ;
+
+ psf_log_printf (psf, "Vorbis library version : %s\n", vorbis_version_string ()) ;
+
+ if (psf->file.mode == SFM_READ)
+ { /* Call this here so it only gets called once, so no memory is leaked. */
+ ogg_sync_init (&odata->osync) ;
+
+ if ((error = vorbis_read_header (psf, 1)))
+ return error ;
+
+ psf->read_short = vorbis_read_s ;
+ psf->read_int = vorbis_read_i ;
+ psf->read_float = vorbis_read_f ;
+ psf->read_double = vorbis_read_d ;
+ psf->sf.frames = vorbis_length (psf) ;
+ } ;
+
+ psf->codec_close = vorbis_close ;
+ if (psf->file.mode == SFM_WRITE)
+ {
+ /* Set the default vorbis quality here. */
+ vdata->quality = 0.4 ;
+
+ psf->write_header = vorbis_write_header ;
+ psf->write_short = vorbis_write_s ;
+ psf->write_int = vorbis_write_i ;
+ psf->write_float = vorbis_write_f ;
+ psf->write_double = vorbis_write_d ;
+
+ psf->sf.frames = SF_COUNT_MAX ; /* Unknown really */
+ psf->str_flags = SF_STR_ALLOW_START ;
+ } ;
+
+ psf->bytewidth = 1 ;
+ psf->blockwidth = psf->bytewidth * psf->sf.channels ;
+
+ psf->seek = vorbis_seek ;
+ psf->command = vorbis_command ;
+
+ /* FIXME, FIXME, FIXME : Hack these here for now and correct later. */
+ psf->sf.format = SF_FORMAT_OGG | SF_FORMAT_VORBIS ;
+ psf->sf.sections = 1 ;
+
+ psf->datalength = 1 ;
+ psf->dataoffset = 0 ;
+ /* End FIXME. */
+
+ return error ;
+} /* ogg_vorbis_open */
+
+static int
+vorbis_command (SF_PRIVATE *psf, int command, void * data, int datasize)
+{ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
+
+ switch (command)
+ { case SFC_SET_VBR_ENCODING_QUALITY :
+ if (data == NULL || datasize != sizeof (double))
+ return SF_FALSE ;
+
+ if (psf->have_written)
+ return SF_FALSE ;
+
+ vdata->quality = *((double *) data) ;
+
+ /* Clip range. */
+ vdata->quality = SF_MAX (0.0, SF_MIN (1.0, vdata->quality)) ;
+
+ psf_log_printf (psf, "%s : Setting SFC_SET_VBR_ENCODING_QUALITY to %f.\n", __func__, vdata->quality) ;
+ return SF_TRUE ;
+
+ default :
+ return SF_FALSE ;
+ } ;
+
+ return SF_FALSE ;
+} /* vorbis_command */
+
+static int
+vorbis_rnull (int samples, void *UNUSED (vptr), int UNUSED (off) , int channels, float **UNUSED (pcm))
+{
+ return samples * channels ;
+} /* vorbis_rnull */
+
+static int
+vorbis_rshort (int samples, void *vptr, int off, int channels, float **pcm)
+{
+ short *ptr = (short*) vptr + off ;
+ int i = 0, j, n ;
+ for (j = 0 ; j < samples ; j++)
+ for (n = 0 ; n < channels ; n++)
+ ptr [i++] = lrintf (pcm [n][j] * 32767.0f) ;
+ return i ;
+} /* vorbis_rshort */
+
+static int
+vorbis_rint (int samples, void *vptr, int off, int channels, float **pcm)
+{
+ int *ptr = (int*) vptr + off ;
+ int i = 0, j, n ;
+
+ for (j = 0 ; j < samples ; j++)
+ for (n = 0 ; n < channels ; n++)
+ ptr [i++] = lrintf (pcm [n][j] * 2147483647.0f) ;
+ return i ;
+} /* vorbis_rint */
+
+static int
+vorbis_rfloat (int samples, void *vptr, int off, int channels, float **pcm)
+{
+ float *ptr = (float*) vptr + off ;
+ int i = 0, j, n ;
+ for (j = 0 ; j < samples ; j++)
+ for (n = 0 ; n < channels ; n++)
+ ptr [i++] = pcm [n][j] ;
+ return i ;
+} /* vorbis_rfloat */
+
+static int
+vorbis_rdouble (int samples, void *vptr, int off, int channels, float **pcm)
+{
+ double *ptr = (double*) vptr + off ;
+ int i = 0, j, n ;
+ for (j = 0 ; j < samples ; j++)
+ for (n = 0 ; n < channels ; n++)
+ ptr [i++] = pcm [n][j] ;
+ return i ;
+} /* vorbis_rdouble */
+
+
+static sf_count_t
+vorbis_read_sample (SF_PRIVATE *psf, void *ptr, sf_count_t lens, convert_func *transfn)
+{
+ VORBIS_PRIVATE *vdata = psf->codec_data ;
+ OGG_PRIVATE *odata = psf->container_data ;
+ int len, samples, i = 0 ;
+ float **pcm ;
+
+ len = lens / psf->sf.channels ;
+
+ while ((samples = vorbis_synthesis_pcmout (&vdata->vdsp, &pcm)) > 0)
+ { if (samples > len) samples = len ;
+ i += transfn (samples, ptr, i, psf->sf.channels, pcm) ;
+ len -= samples ;
+ /* tell libvorbis how many samples we actually consumed */
+ vorbis_synthesis_read (&vdata->vdsp, samples) ;
+ vdata->loc += samples ;
+ if (len == 0)
+ return i ; /* Is this necessary */
+ }
+ goto start0 ; /* Jump into the nasty nest */
+ while (len > 0 && !odata->eos)
+ {
+ while (len > 0 && !odata->eos)
+ { int result = ogg_sync_pageout (&odata->osync, &odata->opage) ;
+ if (result == 0) break ; /* need more data */
+ if (result < 0)
+ { /* missing or corrupt data at this page position */
+ psf_log_printf (psf, "Corrupt or missing data in bitstream ; continuing...\n") ;
+ }
+ else
+ { /* can safely ignore errors at this point */
+ ogg_stream_pagein (&odata->ostream, &odata->opage) ;
+ start0:
+ while (1)
+ { result = ogg_stream_packetout (&odata->ostream, &odata->opacket) ;
+ if (result == 0)
+ break ; /* need more data */
+ if (result < 0)
+ { /* missing or corrupt data at this page position */
+ /* no reason to complain ; already complained above */
+ }
+ else
+ { /* we have a packet. Decode it */
+ if (vorbis_synthesis (&vdata->vblock, &odata->opacket) == 0) /* test for success! */
+ vorbis_synthesis_blockin (&vdata->vdsp, &vdata->vblock) ;
+ /*
+ **pcm is a multichannel float vector. In stereo, for
+ example, pcm [0] is left, and pcm [1] is right. samples is
+ the size of each channel. Convert the float values
+ (-1.<=range<=1.) to whatever PCM format and write it out */
+
+ while ((samples = vorbis_synthesis_pcmout (&vdata->vdsp, &pcm)) > 0)
+ { if (samples>len) samples = len ;
+ i += transfn (samples, ptr, i, psf->sf.channels, pcm) ;
+ len -= samples ;
+ /* tell libvorbis how many samples we actually consumed */
+ vorbis_synthesis_read (&vdata->vdsp, samples) ;
+ vdata->loc += samples ;
+ if (len == 0)
+ return i ; /* Is this necessary */
+ } ;
+ }
+ }
+ if (ogg_page_eos (&odata->opage)) odata->eos = 1 ;
+ }
+ }
+ if (!odata->eos)
+ { char *buffer ;
+ int bytes ;
+ buffer = ogg_sync_buffer (&odata->osync, 4096) ;
+ bytes = psf_fread (buffer, 1, 4096, psf) ;
+ ogg_sync_wrote (&odata->osync, bytes) ;
+ if (bytes == 0) odata->eos = 1 ;
+ }
+ }
+ return i ;
+} /* vorbis_read_sample */
+
+static sf_count_t
+vorbis_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t lens)
+{ return vorbis_read_sample (psf, (void*) ptr, lens, vorbis_rshort) ;
+} /* vorbis_read_s */
+
+static sf_count_t
+vorbis_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t lens)
+{ return vorbis_read_sample (psf, (void*) ptr, lens, vorbis_rint) ;
+} /* vorbis_read_i */
+
+static sf_count_t
+vorbis_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t lens)
+{ return vorbis_read_sample (psf, (void*) ptr, lens, vorbis_rfloat) ;
+} /* vorbis_read_f */
+
+static sf_count_t
+vorbis_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t lens)
+{ return vorbis_read_sample (psf, (void*) ptr, lens, vorbis_rdouble) ;
+} /* vorbis_read_d */
+
+/*==============================================================================
+*/
+
+static void
+vorbis_write_samples (SF_PRIVATE *psf, OGG_PRIVATE *odata, VORBIS_PRIVATE *vdata, int in_frames)
+{
+ vorbis_analysis_wrote (&vdata->vdsp, in_frames) ;
+
+ /*
+ ** Vorbis does some data preanalysis, then divvies up blocks for
+ ** more involved (potentially parallel) processing. Get a single
+ ** block for encoding now.
+ */
+ while (vorbis_analysis_blockout (&vdata->vdsp, &vdata->vblock) == 1)
+ {
+ /* analysis, assume we want to use bitrate management */
+ vorbis_analysis (&vdata->vblock, NULL) ;
+ vorbis_bitrate_addblock (&vdata->vblock) ;
+
+ while (vorbis_bitrate_flushpacket (&vdata->vdsp, &odata->opacket))
+ {
+ /* weld the packet into the bitstream */
+ ogg_stream_packetin (&odata->ostream, &odata->opacket) ;
+
+ /* write out pages (if any) */
+ while (!odata->eos)
+ { int result = ogg_stream_pageout (&odata->ostream, &odata->opage) ;
+ if (result == 0)
+ break ;
+ psf_fwrite (odata->opage.header, 1, odata->opage.header_len, psf) ;
+ psf_fwrite (odata->opage.body, 1, odata->opage.body_len, psf) ;
+
+ /* This could be set above, but for illustrative purposes, I do
+ ** it here (to show that vorbis does know where the stream ends) */
+ if (ogg_page_eos (&odata->opage))
+ odata->eos = 1 ;
+ } ;
+ } ;
+ } ;
+
+ vdata->loc += in_frames ;
+} /* vorbis_write_data */
+
+
+static sf_count_t
+vorbis_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t lens)
+{
+ int i, m, j = 0 ;
+ OGG_PRIVATE *odata = (OGG_PRIVATE *) psf->container_data ;
+ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
+ int in_frames = lens / psf->sf.channels ;
+ float **buffer = vorbis_analysis_buffer (&vdata->vdsp, in_frames) ;
+ for (i = 0 ; i < in_frames ; i++)
+ for (m = 0 ; m < psf->sf.channels ; m++)
+ buffer [m][i] = (float) (ptr [j++]) / 32767.0f ;
+
+ vorbis_write_samples (psf, odata, vdata, in_frames) ;
+
+ return lens ;
+} /* vorbis_write_s */
+
+static sf_count_t
+vorbis_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t lens)
+{ int i, m, j = 0 ;
+ OGG_PRIVATE *odata = (OGG_PRIVATE *) psf->container_data ;
+ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
+ int in_frames = lens / psf->sf.channels ;
+ float **buffer = vorbis_analysis_buffer (&vdata->vdsp, in_frames) ;
+ for (i = 0 ; i < in_frames ; i++)
+ for (m = 0 ; m < psf->sf.channels ; m++)
+ buffer [m][i] = (float) (ptr [j++]) / 2147483647.0f ;
+
+ vorbis_write_samples (psf, odata, vdata, in_frames) ;
+
+ return lens ;
+} /* vorbis_write_i */
+
+static sf_count_t
+vorbis_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t lens)
+{ int i, m, j = 0 ;
+ OGG_PRIVATE *odata = (OGG_PRIVATE *) psf->container_data ;
+ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
+ int in_frames = lens / psf->sf.channels ;
+ float **buffer = vorbis_analysis_buffer (&vdata->vdsp, in_frames) ;
+ for (i = 0 ; i < in_frames ; i++)
+ for (m = 0 ; m < psf->sf.channels ; m++)
+ buffer [m][i] = ptr [j++] ;
+
+ vorbis_write_samples (psf, odata, vdata, in_frames) ;
+
+ return lens ;
+} /* vorbis_write_f */
+
+static sf_count_t
+vorbis_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t lens)
+{ int i, m, j = 0 ;
+ OGG_PRIVATE *odata = (OGG_PRIVATE *) psf->container_data ;
+ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
+ int in_frames = lens / psf->sf.channels ;
+ float **buffer = vorbis_analysis_buffer (&vdata->vdsp, in_frames) ;
+ for (i = 0 ; i < in_frames ; i++)
+ for (m = 0 ; m < psf->sf.channels ; m++)
+ buffer [m][i] = (float) ptr [j++] ;
+
+ vorbis_write_samples (psf, odata, vdata, in_frames) ;
+
+ return lens ;
+} /* vorbis_write_d */
+
+static sf_count_t
+vorbis_seek (SF_PRIVATE *psf, int UNUSED (mode), sf_count_t offset)
+{
+ OGG_PRIVATE *odata = (OGG_PRIVATE *) psf->container_data ;
+ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
+
+ if (odata == NULL || vdata == NULL)
+ return 0 ;
+
+ if (offset < 0)
+ { psf->error = SFE_BAD_SEEK ;
+ return ((sf_count_t) -1) ;
+ } ;
+
+ if (psf->file.mode == SFM_READ)
+ { sf_count_t target = offset - vdata->loc ;
+
+ if (target < 0)
+ { /* 12 to allow for OggS bit */
+ psf_fseek (psf, 12, SEEK_SET) ;
+ vorbis_read_header (psf, 0) ; /* Reset state */
+ target = offset ;
+ } ;
+
+ while (target > 0)
+ { sf_count_t m = target > 4096 ? 4096 : target ;
+
+ /*
+ ** Need to multiply by channels here because the seek is done in
+ ** terms of frames and the read function is done in terms of
+ ** samples.
+ */
+ vorbis_read_sample (psf, (void *) NULL, m * psf->sf.channels, vorbis_rnull) ;
+
+ target -= m ;
+ } ;
+
+ return vdata->loc ;
+ } ;
+
+ return 0 ;
+} /* vorbis_seek */
+
+/*==============================================================================
+** Most of the following code was snipped from Mike Smith's ogginfo utility
+** which is part of vorbis-tools.
+** Vorbis tools is released under the GPL but Mike has kindly allowed the
+** following to be relicensed as LGPL for libsndfile.
+*/
+
+typedef struct
+{
+ int isillegal ;
+ int shownillegal ;
+ int isnew ;
+ int end ;
+
+ uint32_t serial ; /* must be 32 bit unsigned */
+ ogg_stream_state ostream ;
+
+ vorbis_info vinfo ;
+ vorbis_comment vcomment ;
+ sf_count_t lastgranulepos ;
+ int doneheaders ;
+} stream_processor ;
+
+typedef struct
+{
+ stream_processor *streams ;
+ int allocated ;
+ int used ;
+ int in_headers ;
+} stream_set ;
+
+static stream_set *
+create_stream_set (void)
+{ stream_set *set = calloc (1, sizeof (stream_set)) ;
+
+ set->streams = calloc (5, sizeof (stream_processor)) ;
+ set->allocated = 5 ;
+ set->used = 0 ;
+
+ return set ;
+} /* create_stream_set */
+
+static void
+vorbis_end (stream_processor *stream, sf_count_t * len)
+{ *len += stream->lastgranulepos ;
+ vorbis_comment_clear (&stream->vcomment) ;
+ vorbis_info_clear (&stream->vinfo) ;
+} /* vorbis_end */
+
+static void
+free_stream_set (stream_set *set, sf_count_t * len)
+{ int i ;
+
+ for (i = 0 ; i < set->used ; i++)
+ { if (!set->streams [i].end)
+ vorbis_end (&set->streams [i], len) ;
+ ogg_stream_clear (&set->streams [i].ostream) ;
+ } ;
+
+ free (set->streams) ;
+ free (set) ;
+} /* free_stream_set */
+
+static int
+streams_open (stream_set *set)
+{ int i, res = 0 ;
+
+ for (i = 0 ; i < set->used ; i++)
+ if (!set->streams [i].end)
+ res ++ ;
+ return res ;
+} /* streams_open */
+
+static stream_processor *
+find_stream_processor (stream_set *set, ogg_page *page)
+{ uint32_t serial = ogg_page_serialno (page) ;
+ int i, invalid = 0 ;
+
+ stream_processor *stream ;
+
+ for (i = 0 ; i < set->used ; i++)
+ {
+ if (serial == set->streams [i].serial)
+ { /* We have a match! */
+ stream = & (set->streams [i]) ;
+
+ set->in_headers = 0 ;
+ /* if we have detected EOS, then this can't occur here. */
+ if (stream->end)
+ { stream->isillegal = 1 ;
+ return stream ;
+ }
+
+ stream->isnew = 0 ;
+ stream->end = ogg_page_eos (page) ;
+ stream->serial = serial ;
+ return stream ;
+ } ;
+ } ;
+
+ /* If there are streams open, and we've reached the end of the
+ ** headers, then we can't be starting a new stream.
+ ** XXX: might this sometimes catch ok streams if EOS flag is missing,
+ ** but the stream is otherwise ok?
+ */
+ if (streams_open (set) && !set->in_headers)
+ invalid = 1 ;
+
+ set->in_headers = 1 ;
+
+ if (set->allocated < set->used)
+ stream = &set->streams [set->used] ;
+ else
+ { set->allocated += 5 ;
+ set->streams = realloc (set->streams, sizeof (stream_processor) * set->allocated) ;
+ stream = &set->streams [set->used] ;
+ } ;
+
+ set->used++ ;
+
+ stream->isnew = 1 ;
+ stream->isillegal = invalid ;
+
+ {
+ int res ;
+ ogg_packet packet ;
+
+ /* We end up processing the header page twice, but that's ok. */
+ ogg_stream_init (&stream->ostream, serial) ;
+ ogg_stream_pagein (&stream->ostream, page) ;
+ res = ogg_stream_packetout (&stream->ostream, &packet) ;
+ if (res <= 0)
+ return NULL ;
+ else if (packet.bytes >= 7 && memcmp (packet.packet, "\x01vorbis", 7) == 0)
+ {
+ stream->lastgranulepos = 0 ;
+ vorbis_comment_init (&stream->vcomment) ;
+ vorbis_info_init (&stream->vinfo) ;
+ } ;
+
+ res = ogg_stream_packetout (&stream->ostream, &packet) ;
+
+ /* re-init, ready for processing */
+ ogg_stream_clear (&stream->ostream) ;
+ ogg_stream_init (&stream->ostream, serial) ;
+ }
+
+ stream->end = ogg_page_eos (page) ;
+ stream->serial = serial ;
+
+ return stream ;
+} /* find_stream_processor */
+
+static int
+vorbis_length_get_next_page (SF_PRIVATE *psf, ogg_sync_state * osync, ogg_page *page)
+{ static const int CHUNK_SIZE = 4500 ;
+
+ while (ogg_sync_pageout (osync, page) <= 0)
+ { char * buffer = ogg_sync_buffer (osync, CHUNK_SIZE) ;
+ int bytes = psf_fread (buffer, 1, 4096, psf) ;
+
+ if (bytes <= 0)
+ { ogg_sync_wrote (osync, 0) ;
+ return 0 ;
+ } ;
+
+ ogg_sync_wrote (osync, bytes) ;
+ } ;
+
+ return 1 ;
+} /* vorbis_length_get_next_page */
+
+static sf_count_t
+vorbis_length_aux (SF_PRIVATE * psf)
+{
+ ogg_sync_state osync ;
+ ogg_page page ;
+ sf_count_t len = 0 ;
+ stream_set *processors ;
+
+ processors = create_stream_set () ;
+ if (processors == NULL)
+ return 0 ; // out of memory?
+
+ ogg_sync_init (&osync) ;
+
+ while (vorbis_length_get_next_page (psf, &osync, &page))
+ {
+ stream_processor *p = find_stream_processor (processors, &page) ;
+
+ if (!p)
+ { len = 0 ;
+ break ;
+ } ;
+
+ if (p->isillegal && !p->shownillegal)
+ {
+ p->shownillegal = 1 ;
+ /* If it's a new stream, we want to continue processing this page
+ ** anyway to suppress additional spurious errors
+ */
+ if (!p->isnew) continue ;
+ } ;
+
+ if (!p->isillegal)
+ { ogg_packet packet ;
+ int header = 0 ;
+
+ ogg_stream_pagein (&p->ostream, &page) ;
+ if (p->doneheaders < 3)
+ header = 1 ;
+
+ while (ogg_stream_packetout (&p->ostream, &packet) > 0)
+ {
+ if (p->doneheaders < 3)
+ { if (vorbis_synthesis_headerin (&p->vinfo, &p->vcomment, &packet) < 0)
+ continue ;
+ p->doneheaders ++ ;
+ } ;
+ } ;
+ if (!header)
+ { sf_count_t gp = ogg_page_granulepos (&page) ;
+ if (gp > 0) p->lastgranulepos = gp ;
+ } ;
+ if (p->end)
+ { vorbis_end (p, &len) ;
+ p->isillegal = 1 ;
+ } ;
+ } ;
+ } ;
+
+ ogg_sync_clear (&osync) ;
+ free_stream_set (processors, &len) ;
+
+ return len ;
+} /* vorbis_length_aux */
+
+static sf_count_t
+vorbis_length (SF_PRIVATE *psf)
+{ sf_count_t length ;
+ int error ;
+
+ if (psf->sf.seekable == 0)
+ return SF_COUNT_MAX ;
+
+ psf_fseek (psf, 0, SEEK_SET) ;
+ length = vorbis_length_aux (psf) ;
+
+ psf_fseek (psf, 12, SEEK_SET) ;
+ if ((error = vorbis_read_header (psf, 0)) != 0)
+ psf->error = error ;
+
+ return length ;
+} /* vorbis_length */
+
+#else /* HAVE_EXTERNAL_LIBS */
+
+int
+ogg_vorbis_open (SF_PRIVATE *psf)
+{
+ psf_log_printf (psf, "This version of libsndfile was compiled without Ogg/Vorbis support.\n") ;
+ return SFE_UNIMPLEMENTED ;
+} /* ogg_vorbis_open */
+
+#endif
projects / Faustine.git / blobdiff