From 82a6dadd70dc7706b5c719bfee4abd95278357eb Mon Sep 17 00:00:00 2001 From: sezero Date: Sun, 21 Jul 2013 14:02:06 +0000 Subject: [PATCH] added flac music support. it is not enabled by default, edit the Makefile for USE_CODEC_FLAC, or add USE_CODEC_FLAC=1 to your make command line arguments. Xcode project file still needs updating for this. git-svn-id: svn+ssh://svn.code.sf.net/p/quakespasm/code/trunk@857 af15c1b1-3010-417e-b628-4374ebc0bcbd --- quakespasm/Linux/CodeBlocks/QuakeSpasm.cbp | 4 + quakespasm/MacOSX/codecs/include/FLAC/all.h | 371 +++ .../MacOSX/codecs/include/FLAC/assert.h | 46 + .../MacOSX/codecs/include/FLAC/callback.h | 185 ++ .../MacOSX/codecs/include/FLAC/export.h | 97 + .../MacOSX/codecs/include/FLAC/format.h | 1023 ++++++++ .../MacOSX/codecs/include/FLAC/metadata.h | 2182 +++++++++++++++++ .../MacOSX/codecs/include/FLAC/ordinals.h | 86 + .../codecs/include/FLAC/stream_decoder.h | 1560 ++++++++++++ .../codecs/include/FLAC/stream_encoder.h | 1769 +++++++++++++ quakespasm/MacOSX/codecs/lib/libFLAC.dylib | Bin 0 -> 935632 bytes quakespasm/Quake/Makefile | 6 + quakespasm/Quake/Makefile.darwin | 8 + quakespasm/Quake/Makefile.w32 | 6 + quakespasm/Quake/Makefile.w64 | 6 + quakespasm/Quake/snd_codec.c | 4 + quakespasm/Quake/snd_flac.c | 392 +++ quakespasm/Quake/snd_flac.h | 13 + quakespasm/Windows/CodeBlocks/QuakeSpasm.cbp | 6 + .../Windows/VisualStudio/quakespasm.vcproj | 24 +- quakespasm/Windows/codecs/include/FLAC/all.h | 371 +++ .../Windows/codecs/include/FLAC/assert.h | 46 + .../Windows/codecs/include/FLAC/callback.h | 185 ++ .../Windows/codecs/include/FLAC/export.h | 97 + .../Windows/codecs/include/FLAC/format.h | 1023 ++++++++ .../Windows/codecs/include/FLAC/metadata.h | 2182 +++++++++++++++++ .../Windows/codecs/include/FLAC/ordinals.h | 86 + .../codecs/include/FLAC/stream_decoder.h | 1560 ++++++++++++ .../codecs/include/FLAC/stream_encoder.h | 1769 +++++++++++++ quakespasm/Windows/codecs/x64/libFLAC-8.dll | Bin 0 -> 315392 bytes quakespasm/Windows/codecs/x64/libFLAC.dll.a | Bin 0 -> 215910 bytes quakespasm/Windows/codecs/x64/libFLAC.lib | Bin 0 -> 87890 bytes quakespasm/Windows/codecs/x86/libFLAC-8.dll | Bin 0 -> 275968 bytes quakespasm/Windows/codecs/x86/libFLAC.dll.a | Bin 0 -> 215134 bytes quakespasm/Windows/codecs/x86/libFLAC.lib | Bin 0 -> 89154 bytes 35 files changed, 15099 insertions(+), 8 deletions(-) create mode 100644 quakespasm/MacOSX/codecs/include/FLAC/all.h create mode 100644 quakespasm/MacOSX/codecs/include/FLAC/assert.h create mode 100644 quakespasm/MacOSX/codecs/include/FLAC/callback.h create mode 100644 quakespasm/MacOSX/codecs/include/FLAC/export.h create mode 100644 quakespasm/MacOSX/codecs/include/FLAC/format.h create mode 100644 quakespasm/MacOSX/codecs/include/FLAC/metadata.h create mode 100644 quakespasm/MacOSX/codecs/include/FLAC/ordinals.h create mode 100644 quakespasm/MacOSX/codecs/include/FLAC/stream_decoder.h create mode 100644 quakespasm/MacOSX/codecs/include/FLAC/stream_encoder.h create mode 100755 quakespasm/MacOSX/codecs/lib/libFLAC.dylib create mode 100644 quakespasm/Quake/snd_flac.c create mode 100644 quakespasm/Quake/snd_flac.h create mode 100644 quakespasm/Windows/codecs/include/FLAC/all.h create mode 100644 quakespasm/Windows/codecs/include/FLAC/assert.h create mode 100644 quakespasm/Windows/codecs/include/FLAC/callback.h create mode 100644 quakespasm/Windows/codecs/include/FLAC/export.h create mode 100644 quakespasm/Windows/codecs/include/FLAC/format.h create mode 100644 quakespasm/Windows/codecs/include/FLAC/metadata.h create mode 100644 quakespasm/Windows/codecs/include/FLAC/ordinals.h create mode 100644 quakespasm/Windows/codecs/include/FLAC/stream_decoder.h create mode 100644 quakespasm/Windows/codecs/include/FLAC/stream_encoder.h create mode 100644 quakespasm/Windows/codecs/x64/libFLAC-8.dll create mode 100644 quakespasm/Windows/codecs/x64/libFLAC.dll.a create mode 100644 quakespasm/Windows/codecs/x64/libFLAC.lib create mode 100644 quakespasm/Windows/codecs/x86/libFLAC-8.dll create mode 100644 quakespasm/Windows/codecs/x86/libFLAC.dll.a create mode 100644 quakespasm/Windows/codecs/x86/libFLAC.lib diff --git a/quakespasm/Linux/CodeBlocks/QuakeSpasm.cbp b/quakespasm/Linux/CodeBlocks/QuakeSpasm.cbp index 5d9a3987..a66a2644 100644 --- a/quakespasm/Linux/CodeBlocks/QuakeSpasm.cbp +++ b/quakespasm/Linux/CodeBlocks/QuakeSpasm.cbp @@ -253,6 +253,10 @@ + + + diff --git a/quakespasm/MacOSX/codecs/include/FLAC/all.h b/quakespasm/MacOSX/codecs/include/FLAC/all.h new file mode 100644 index 00000000..9e288528 --- /dev/null +++ b/quakespasm/MacOSX/codecs/include/FLAC/all.h @@ -0,0 +1,371 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__ALL_H +#define FLAC__ALL_H + +#include "export.h" + +#include "assert.h" +#include "callback.h" +#include "format.h" +#include "metadata.h" +#include "ordinals.h" +#include "stream_decoder.h" +#include "stream_encoder.h" + +/** \mainpage + * + * \section intro Introduction + * + * This is the documentation for the FLAC C and C++ APIs. It is + * highly interconnected; this introduction should give you a top + * level idea of the structure and how to find the information you + * need. As a prerequisite you should have at least a basic + * knowledge of the FLAC format, documented + * here. + * + * \section c_api FLAC C API + * + * The FLAC C API is the interface to libFLAC, a set of structures + * describing the components of FLAC streams, and functions for + * encoding and decoding streams, as well as manipulating FLAC + * metadata in files. The public include files will be installed + * in your include area (for example /usr/include/FLAC/...). + * + * By writing a little code and linking against libFLAC, it is + * relatively easy to add FLAC support to another program. The + * library is licensed under Xiph's BSD license. + * Complete source code of libFLAC as well as the command-line + * encoder and plugins is available and is a useful source of + * examples. + * + * Aside from encoders and decoders, libFLAC provides a powerful + * metadata interface for manipulating metadata in FLAC files. It + * allows the user to add, delete, and modify FLAC metadata blocks + * and it can automatically take advantage of PADDING blocks to avoid + * rewriting the entire FLAC file when changing the size of the + * metadata. + * + * libFLAC usually only requires the standard C library and C math + * library. In particular, threading is not used so there is no + * dependency on a thread library. However, libFLAC does not use + * global variables and should be thread-safe. + * + * libFLAC also supports encoding to and decoding from Ogg FLAC. + * However the metadata editing interfaces currently have limited + * read-only support for Ogg FLAC files. + * + * \section cpp_api FLAC C++ API + * + * The FLAC C++ API is a set of classes that encapsulate the + * structures and functions in libFLAC. They provide slightly more + * functionality with respect to metadata but are otherwise + * equivalent. For the most part, they share the same usage as + * their counterparts in libFLAC, and the FLAC C API documentation + * can be used as a supplement. The public include files + * for the C++ API will be installed in your include area (for + * example /usr/include/FLAC++/...). + * + * libFLAC++ is also licensed under + * Xiph's BSD license. + * + * \section getting_started Getting Started + * + * A good starting point for learning the API is to browse through + * the modules. Modules are logical + * groupings of related functions or classes, which correspond roughly + * to header files or sections of header files. Each module includes a + * detailed description of the general usage of its functions or + * classes. + * + * From there you can go on to look at the documentation of + * individual functions. You can see different views of the individual + * functions through the links in top bar across this page. + * + * If you prefer a more hands-on approach, you can jump right to some + * example code. + * + * \section porting_guide Porting Guide + * + * Starting with FLAC 1.1.3 a \link porting Porting Guide \endlink + * has been introduced which gives detailed instructions on how to + * port your code to newer versions of FLAC. + * + * \section embedded_developers Embedded Developers + * + * libFLAC has grown larger over time as more functionality has been + * included, but much of it may be unnecessary for a particular embedded + * implementation. Unused parts may be pruned by some simple editing of + * src/libFLAC/Makefile.am. In general, the decoders, encoders, and + * metadata interface are all independent from each other. + * + * It is easiest to just describe the dependencies: + * + * - All modules depend on the \link flac_format Format \endlink module. + * - The decoders and encoders depend on the bitbuffer. + * - The decoder is independent of the encoder. The encoder uses the + * decoder because of the verify feature, but this can be removed if + * not needed. + * - Parts of the metadata interface require the stream decoder (but not + * the encoder). + * - Ogg support is selectable through the compile time macro + * \c FLAC__HAS_OGG. + * + * For example, if your application only requires the stream decoder, no + * encoder, and no metadata interface, you can remove the stream encoder + * and the metadata interface, which will greatly reduce the size of the + * library. + * + * Also, there are several places in the libFLAC code with comments marked + * with "OPT:" where a #define can be changed to enable code that might be + * faster on a specific platform. Experimenting with these can yield faster + * binaries. + */ + +/** \defgroup porting Porting Guide for New Versions + * + * This module describes differences in the library interfaces from + * version to version. It assists in the porting of code that uses + * the libraries to newer versions of FLAC. + * + * One simple facility for making porting easier that has been added + * in FLAC 1.1.3 is a set of \c #defines in \c export.h of each + * library's includes (e.g. \c include/FLAC/export.h). The + * \c #defines mirror the libraries' + * libtool version numbers, + * e.g. in libFLAC there are \c FLAC_API_VERSION_CURRENT, + * \c FLAC_API_VERSION_REVISION, and \c FLAC_API_VERSION_AGE. + * These can be used to support multiple versions of an API during the + * transition phase, e.g. + * + * \code + * #if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7 + * legacy code + * #else + * new code + * #endif + * \endcode + * + * The the source will work for multiple versions and the legacy code can + * easily be removed when the transition is complete. + * + * Another available symbol is FLAC_API_SUPPORTS_OGG_FLAC (defined in + * include/FLAC/export.h), which can be used to determine whether or not + * the library has been compiled with support for Ogg FLAC. This is + * simpler than trying to call an Ogg init function and catching the + * error. + */ + +/** \defgroup porting_1_1_2_to_1_1_3 Porting from FLAC 1.1.2 to 1.1.3 + * \ingroup porting + * + * \brief + * This module describes porting from FLAC 1.1.2 to FLAC 1.1.3. + * + * The main change between the APIs in 1.1.2 and 1.1.3 is that they have + * been simplified. First, libOggFLAC has been merged into libFLAC and + * libOggFLAC++ has been merged into libFLAC++. Second, both the three + * decoding layers and three encoding layers have been merged into a + * single stream decoder and stream encoder. That is, the functionality + * of FLAC__SeekableStreamDecoder and FLAC__FileDecoder has been merged + * into FLAC__StreamDecoder, and FLAC__SeekableStreamEncoder and + * FLAC__FileEncoder into FLAC__StreamEncoder. Only the + * FLAC__StreamDecoder and FLAC__StreamEncoder remain. What this means + * is there is now a single API that can be used to encode or decode + * streams to/from native FLAC or Ogg FLAC and the single API can work + * on both seekable and non-seekable streams. + * + * Instead of creating an encoder or decoder of a certain layer, now the + * client will always create a FLAC__StreamEncoder or + * FLAC__StreamDecoder. The old layers are now differentiated by the + * initialization function. For example, for the decoder, + * FLAC__stream_decoder_init() has been replaced by + * FLAC__stream_decoder_init_stream(). This init function takes + * callbacks for the I/O, and the seeking callbacks are optional. This + * allows the client to use the same object for seekable and + * non-seekable streams. For decoding a FLAC file directly, the client + * can use FLAC__stream_decoder_init_file() and pass just a filename + * and fewer callbacks; most of the other callbacks are supplied + * internally. For situations where fopen()ing by filename is not + * possible (e.g. Unicode filenames on Windows) the client can instead + * open the file itself and supply the FILE* to + * FLAC__stream_decoder_init_FILE(). The init functions now returns a + * FLAC__StreamDecoderInitStatus instead of FLAC__StreamDecoderState. + * Since the callbacks and client data are now passed to the init + * function, the FLAC__stream_decoder_set_*_callback() functions and + * FLAC__stream_decoder_set_client_data() are no longer needed. The + * rest of the calls to the decoder are the same as before. + * + * There are counterpart init functions for Ogg FLAC, e.g. + * FLAC__stream_decoder_init_ogg_stream(). All the rest of the calls + * and callbacks are the same as for native FLAC. + * + * As an example, in FLAC 1.1.2 a seekable stream decoder would have + * been set up like so: + * + * \code + * FLAC__SeekableStreamDecoder *decoder = FLAC__seekable_stream_decoder_new(); + * if(decoder == NULL) do_something; + * FLAC__seekable_stream_decoder_set_md5_checking(decoder, true); + * [... other settings ...] + * FLAC__seekable_stream_decoder_set_read_callback(decoder, my_read_callback); + * FLAC__seekable_stream_decoder_set_seek_callback(decoder, my_seek_callback); + * FLAC__seekable_stream_decoder_set_tell_callback(decoder, my_tell_callback); + * FLAC__seekable_stream_decoder_set_length_callback(decoder, my_length_callback); + * FLAC__seekable_stream_decoder_set_eof_callback(decoder, my_eof_callback); + * FLAC__seekable_stream_decoder_set_write_callback(decoder, my_write_callback); + * FLAC__seekable_stream_decoder_set_metadata_callback(decoder, my_metadata_callback); + * FLAC__seekable_stream_decoder_set_error_callback(decoder, my_error_callback); + * FLAC__seekable_stream_decoder_set_client_data(decoder, my_client_data); + * if(FLAC__seekable_stream_decoder_init(decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK) do_something; + * \endcode + * + * In FLAC 1.1.3 it is like this: + * + * \code + * FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new(); + * if(decoder == NULL) do_something; + * FLAC__stream_decoder_set_md5_checking(decoder, true); + * [... other settings ...] + * if(FLAC__stream_decoder_init_stream( + * decoder, + * my_read_callback, + * my_seek_callback, // or NULL + * my_tell_callback, // or NULL + * my_length_callback, // or NULL + * my_eof_callback, // or NULL + * my_write_callback, + * my_metadata_callback, // or NULL + * my_error_callback, + * my_client_data + * ) != FLAC__STREAM_DECODER_INIT_STATUS_OK) do_something; + * \endcode + * + * or you could do; + * + * \code + * [...] + * FILE *file = fopen("somefile.flac","rb"); + * if(file == NULL) do_somthing; + * if(FLAC__stream_decoder_init_FILE( + * decoder, + * file, + * my_write_callback, + * my_metadata_callback, // or NULL + * my_error_callback, + * my_client_data + * ) != FLAC__STREAM_DECODER_INIT_STATUS_OK) do_something; + * \endcode + * + * or just: + * + * \code + * [...] + * if(FLAC__stream_decoder_init_file( + * decoder, + * "somefile.flac", + * my_write_callback, + * my_metadata_callback, // or NULL + * my_error_callback, + * my_client_data + * ) != FLAC__STREAM_DECODER_INIT_STATUS_OK) do_something; + * \endcode + * + * Another small change to the decoder is in how it handles unparseable + * streams. Before, when the decoder found an unparseable stream + * (reserved for when the decoder encounters a stream from a future + * encoder that it can't parse), it changed the state to + * \c FLAC__STREAM_DECODER_UNPARSEABLE_STREAM. Now the decoder instead + * drops sync and calls the error callback with a new error code + * \c FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM. This is + * more robust. If your error callback does not discriminate on the the + * error state, your code does not need to be changed. + * + * The encoder now has a new setting: + * FLAC__stream_encoder_set_apodization(). This is for setting the + * method used to window the data before LPC analysis. You only need to + * add a call to this function if the default is not suitable. There + * are also two new convenience functions that may be useful: + * FLAC__metadata_object_cuesheet_calculate_cddb_id() and + * FLAC__metadata_get_cuesheet(). + * + * The \a bytes parameter to FLAC__StreamDecoderReadCallback, + * FLAC__StreamEncoderReadCallback, and FLAC__StreamEncoderWriteCallback + * is now \c size_t instead of \c unsigned. + */ + +/** \defgroup porting_1_1_3_to_1_1_4 Porting from FLAC 1.1.3 to 1.1.4 + * \ingroup porting + * + * \brief + * This module describes porting from FLAC 1.1.3 to FLAC 1.1.4. + * + * There were no changes to any of the interfaces from 1.1.3 to 1.1.4. + * There was a slight change in the implementation of + * FLAC__stream_encoder_set_metadata(); the function now makes a copy + * of the \a metadata array of pointers so the client no longer needs + * to maintain it after the call. The objects themselves that are + * pointed to by the array are still not copied though and must be + * maintained until the call to FLAC__stream_encoder_finish(). + */ + +/** \defgroup porting_1_1_4_to_1_2_0 Porting from FLAC 1.1.4 to 1.2.0 + * \ingroup porting + * + * \brief + * This module describes porting from FLAC 1.1.4 to FLAC 1.2.0. + * + * There were only very minor changes to the interfaces from 1.1.4 to 1.2.0. + * In libFLAC, \c FLAC__format_sample_rate_is_subset() was added. + * In libFLAC++, \c FLAC::Decoder::Stream::get_decode_position() was added. + * + * Finally, value of the constant \c FLAC__FRAME_HEADER_RESERVED_LEN + * has changed to reflect the conversion of one of the reserved bits + * into active use. It used to be \c 2 and now is \c 1. However the + * FLAC frame header length has not changed, so to skip the proper + * number of bits, use \c FLAC__FRAME_HEADER_RESERVED_LEN + + * \c FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN + */ + +/** \defgroup flac FLAC C API + * + * The FLAC C API is the interface to libFLAC, a set of structures + * describing the components of FLAC streams, and functions for + * encoding and decoding streams, as well as manipulating FLAC + * metadata in files. + * + * You should start with the format components as all other modules + * are dependent on it. + */ + +#endif diff --git a/quakespasm/MacOSX/codecs/include/FLAC/assert.h b/quakespasm/MacOSX/codecs/include/FLAC/assert.h new file mode 100644 index 00000000..787cea91 --- /dev/null +++ b/quakespasm/MacOSX/codecs/include/FLAC/assert.h @@ -0,0 +1,46 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2001-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__ASSERT_H +#define FLAC__ASSERT_H + +/* we need this since some compilers (like MSVC) leave assert()s on release code (and we don't want to use their ASSERT) */ +#ifdef DEBUG +#include +#define FLAC__ASSERT(x) assert(x) +#define FLAC__ASSERT_DECLARATION(x) x +#else +#define FLAC__ASSERT(x) +#define FLAC__ASSERT_DECLARATION(x) +#endif + +#endif diff --git a/quakespasm/MacOSX/codecs/include/FLAC/callback.h b/quakespasm/MacOSX/codecs/include/FLAC/callback.h new file mode 100644 index 00000000..71bbaec6 --- /dev/null +++ b/quakespasm/MacOSX/codecs/include/FLAC/callback.h @@ -0,0 +1,185 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2004-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__CALLBACK_H +#define FLAC__CALLBACK_H + +#include "ordinals.h" +#include /* for size_t */ + +/** \file include/FLAC/callback.h + * + * \brief + * This module defines the structures for describing I/O callbacks + * to the other FLAC interfaces. + * + * See the detailed documentation for callbacks in the + * \link flac_callbacks callbacks \endlink module. + */ + +/** \defgroup flac_callbacks FLAC/callback.h: I/O callback structures + * \ingroup flac + * + * \brief + * This module defines the structures for describing I/O callbacks + * to the other FLAC interfaces. + * + * The purpose of the I/O callback functions is to create a common way + * for the metadata interfaces to handle I/O. + * + * Originally the metadata interfaces required filenames as the way of + * specifying FLAC files to operate on. This is problematic in some + * environments so there is an additional option to specify a set of + * callbacks for doing I/O on the FLAC file, instead of the filename. + * + * In addition to the callbacks, a FLAC__IOHandle type is defined as an + * opaque structure for a data source. + * + * The callback function prototypes are similar (but not identical) to the + * stdio functions fread, fwrite, fseek, ftell, feof, and fclose. If you use + * stdio streams to implement the callbacks, you can pass fread, fwrite, and + * fclose anywhere a FLAC__IOCallback_Read, FLAC__IOCallback_Write, or + * FLAC__IOCallback_Close is required, and a FILE* anywhere a FLAC__IOHandle + * is required. \warning You generally CANNOT directly use fseek or ftell + * for FLAC__IOCallback_Seek or FLAC__IOCallback_Tell since on most systems + * these use 32-bit offsets and FLAC requires 64-bit offsets to deal with + * large files. You will have to find an equivalent function (e.g. ftello), + * or write a wrapper. The same is true for feof() since this is usually + * implemented as a macro, not as a function whose address can be taken. + * + * \{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** This is the opaque handle type used by the callbacks. Typically + * this is a \c FILE* or address of a file descriptor. + */ +typedef void* FLAC__IOHandle; + +/** Signature for the read callback. + * The signature and semantics match POSIX fread() implementations + * and can generally be used interchangeably. + * + * \param ptr The address of the read buffer. + * \param size The size of the records to be read. + * \param nmemb The number of records to be read. + * \param handle The handle to the data source. + * \retval size_t + * The number of records read. + */ +typedef size_t (*FLAC__IOCallback_Read) (void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle); + +/** Signature for the write callback. + * The signature and semantics match POSIX fwrite() implementations + * and can generally be used interchangeably. + * + * \param ptr The address of the write buffer. + * \param size The size of the records to be written. + * \param nmemb The number of records to be written. + * \param handle The handle to the data source. + * \retval size_t + * The number of records written. + */ +typedef size_t (*FLAC__IOCallback_Write) (const void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle); + +/** Signature for the seek callback. + * The signature and semantics mostly match POSIX fseek() WITH ONE IMPORTANT + * EXCEPTION: the offset is a 64-bit type whereas fseek() is generally 'long' + * and 32-bits wide. + * + * \param handle The handle to the data source. + * \param offset The new position, relative to \a whence + * \param whence \c SEEK_SET, \c SEEK_CUR, or \c SEEK_END + * \retval int + * \c 0 on success, \c -1 on error. + */ +typedef int (*FLAC__IOCallback_Seek) (FLAC__IOHandle handle, FLAC__int64 offset, int whence); + +/** Signature for the tell callback. + * The signature and semantics mostly match POSIX ftell() WITH ONE IMPORTANT + * EXCEPTION: the offset is a 64-bit type whereas ftell() is generally 'long' + * and 32-bits wide. + * + * \param handle The handle to the data source. + * \retval FLAC__int64 + * The current position on success, \c -1 on error. + */ +typedef FLAC__int64 (*FLAC__IOCallback_Tell) (FLAC__IOHandle handle); + +/** Signature for the EOF callback. + * The signature and semantics mostly match POSIX feof() but WATCHOUT: + * on many systems, feof() is a macro, so in this case a wrapper function + * must be provided instead. + * + * \param handle The handle to the data source. + * \retval int + * \c 0 if not at end of file, nonzero if at end of file. + */ +typedef int (*FLAC__IOCallback_Eof) (FLAC__IOHandle handle); + +/** Signature for the close callback. + * The signature and semantics match POSIX fclose() implementations + * and can generally be used interchangeably. + * + * \param handle The handle to the data source. + * \retval int + * \c 0 on success, \c EOF on error. + */ +typedef int (*FLAC__IOCallback_Close) (FLAC__IOHandle handle); + +/** A structure for holding a set of callbacks. + * Each FLAC interface that requires a FLAC__IOCallbacks structure will + * describe which of the callbacks are required. The ones that are not + * required may be set to NULL. + * + * If the seek requirement for an interface is optional, you can signify that + * a data sorce is not seekable by setting the \a seek field to \c NULL. + */ +typedef struct { + FLAC__IOCallback_Read read; + FLAC__IOCallback_Write write; + FLAC__IOCallback_Seek seek; + FLAC__IOCallback_Tell tell; + FLAC__IOCallback_Eof eof; + FLAC__IOCallback_Close close; +} FLAC__IOCallbacks; + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/MacOSX/codecs/include/FLAC/export.h b/quakespasm/MacOSX/codecs/include/FLAC/export.h new file mode 100644 index 00000000..2232b410 --- /dev/null +++ b/quakespasm/MacOSX/codecs/include/FLAC/export.h @@ -0,0 +1,97 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__EXPORT_H +#define FLAC__EXPORT_H + +/** \file include/FLAC/export.h + * + * \brief + * This module contains #defines and symbols for exporting function + * calls, and providing version information and compiled-in features. + * + * See the \link flac_export export \endlink module. + */ + +/** \defgroup flac_export FLAC/export.h: export symbols + * \ingroup flac + * + * \brief + * This module contains #defines and symbols for exporting function + * calls, and providing version information and compiled-in features. + * + * If you are compiling with MSVC and will link to the static library + * (libFLAC.lib) you should define FLAC__NO_DLL in your project to + * make sure the symbols are exported properly. + * + * \{ + */ + +#if defined(FLAC__NO_DLL) +#define FLAC_API + +#elif defined(_MSC_VER) +#ifdef FLAC_API_EXPORTS +#define FLAC_API _declspec(dllexport) +#else +#define FLAC_API _declspec(dllimport) +#endif + +#elif defined(FLAC__USE_VISIBILITY_ATTR) +#define FLAC_API __attribute__ ((visibility ("default"))) + +#else +#define FLAC_API + +#endif + +/** These #defines will mirror the libtool-based library version number, see + * http://www.gnu.org/software/libtool/manual/libtool.html#Libtool-versioning + */ +#define FLAC_API_VERSION_CURRENT 11 +#define FLAC_API_VERSION_REVISION 0 /**< see above */ +#define FLAC_API_VERSION_AGE 3 /**< see above */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** \c 1 if the library has been compiled with support for Ogg FLAC, else \c 0. */ +extern FLAC_API int FLAC_API_SUPPORTS_OGG_FLAC; + +#ifdef __cplusplus +} +#endif + +/* \} */ + +#endif diff --git a/quakespasm/MacOSX/codecs/include/FLAC/format.h b/quakespasm/MacOSX/codecs/include/FLAC/format.h new file mode 100644 index 00000000..e4c1c1a6 --- /dev/null +++ b/quakespasm/MacOSX/codecs/include/FLAC/format.h @@ -0,0 +1,1023 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__FORMAT_H +#define FLAC__FORMAT_H + +#include "export.h" +#include "ordinals.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** \file include/FLAC/format.h + * + * \brief + * This module contains structure definitions for the representation + * of FLAC format components in memory. These are the basic + * structures used by the rest of the interfaces. + * + * See the detailed documentation in the + * \link flac_format format \endlink module. + */ + +/** \defgroup flac_format FLAC/format.h: format components + * \ingroup flac + * + * \brief + * This module contains structure definitions for the representation + * of FLAC format components in memory. These are the basic + * structures used by the rest of the interfaces. + * + * First, you should be familiar with the + * FLAC format. Many of the values here + * follow directly from the specification. As a user of libFLAC, the + * interesting parts really are the structures that describe the frame + * header and metadata blocks. + * + * The format structures here are very primitive, designed to store + * information in an efficient way. Reading information from the + * structures is easy but creating or modifying them directly is + * more complex. For the most part, as a user of a library, editing + * is not necessary; however, for metadata blocks it is, so there are + * convenience functions provided in the \link flac_metadata metadata + * module \endlink to simplify the manipulation of metadata blocks. + * + * \note + * It's not the best convention, but symbols ending in _LEN are in bits + * and _LENGTH are in bytes. _LENGTH symbols are \#defines instead of + * global variables because they are usually used when declaring byte + * arrays and some compilers require compile-time knowledge of array + * sizes when declared on the stack. + * + * \{ + */ + + +/* + Most of the values described in this file are defined by the FLAC + format specification. There is nothing to tune here. +*/ + +/** The largest legal metadata type code. */ +#define FLAC__MAX_METADATA_TYPE_CODE (126u) + +/** The minimum block size, in samples, permitted by the format. */ +#define FLAC__MIN_BLOCK_SIZE (16u) + +/** The maximum block size, in samples, permitted by the format. */ +#define FLAC__MAX_BLOCK_SIZE (65535u) + +/** The maximum block size, in samples, permitted by the FLAC subset for + * sample rates up to 48kHz. */ +#define FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ (4608u) + +/** The maximum number of channels permitted by the format. */ +#define FLAC__MAX_CHANNELS (8u) + +/** The minimum sample resolution permitted by the format. */ +#define FLAC__MIN_BITS_PER_SAMPLE (4u) + +/** The maximum sample resolution permitted by the format. */ +#define FLAC__MAX_BITS_PER_SAMPLE (32u) + +/** The maximum sample resolution permitted by libFLAC. + * + * \warning + * FLAC__MAX_BITS_PER_SAMPLE is the limit of the FLAC format. However, + * the reference encoder/decoder is currently limited to 24 bits because + * of prevalent 32-bit math, so make sure and use this value when + * appropriate. + */ +#define FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE (24u) + +/** The maximum sample rate permitted by the format. The value is + * ((2 ^ 16) - 1) * 10; see FLAC format + * as to why. + */ +#define FLAC__MAX_SAMPLE_RATE (655350u) + +/** The maximum LPC order permitted by the format. */ +#define FLAC__MAX_LPC_ORDER (32u) + +/** The maximum LPC order permitted by the FLAC subset for sample rates + * up to 48kHz. */ +#define FLAC__SUBSET_MAX_LPC_ORDER_48000HZ (12u) + +/** The minimum quantized linear predictor coefficient precision + * permitted by the format. + */ +#define FLAC__MIN_QLP_COEFF_PRECISION (5u) + +/** The maximum quantized linear predictor coefficient precision + * permitted by the format. + */ +#define FLAC__MAX_QLP_COEFF_PRECISION (15u) + +/** The maximum order of the fixed predictors permitted by the format. */ +#define FLAC__MAX_FIXED_ORDER (4u) + +/** The maximum Rice partition order permitted by the format. */ +#define FLAC__MAX_RICE_PARTITION_ORDER (15u) + +/** The maximum Rice partition order permitted by the FLAC Subset. */ +#define FLAC__SUBSET_MAX_RICE_PARTITION_ORDER (8u) + +/** The version string of the release, stamped onto the libraries and binaries. + * + * \note + * This does not correspond to the shared library version number, which + * is used to determine binary compatibility. + */ +extern FLAC_API const char *FLAC__VERSION_STRING; + +/** The vendor string inserted by the encoder into the VORBIS_COMMENT block. + * This is a NUL-terminated ASCII string; when inserted into the + * VORBIS_COMMENT the trailing null is stripped. + */ +extern FLAC_API const char *FLAC__VENDOR_STRING; + +/** The byte string representation of the beginning of a FLAC stream. */ +extern FLAC_API const FLAC__byte FLAC__STREAM_SYNC_STRING[4]; /* = "fLaC" */ + +/** The 32-bit integer big-endian representation of the beginning of + * a FLAC stream. + */ +extern FLAC_API const unsigned FLAC__STREAM_SYNC; /* = 0x664C6143 */ + +/** The length of the FLAC signature in bits. */ +extern FLAC_API const unsigned FLAC__STREAM_SYNC_LEN; /* = 32 bits */ + +/** The length of the FLAC signature in bytes. */ +#define FLAC__STREAM_SYNC_LENGTH (4u) + + +/***************************************************************************** + * + * Subframe structures + * + *****************************************************************************/ + +/*****************************************************************************/ + +/** An enumeration of the available entropy coding methods. */ +typedef enum { + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE = 0, + /**< Residual is coded by partitioning into contexts, each with it's own + * 4-bit Rice parameter. */ + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 = 1 + /**< Residual is coded by partitioning into contexts, each with it's own + * 5-bit Rice parameter. */ +} FLAC__EntropyCodingMethodType; + +/** Maps a FLAC__EntropyCodingMethodType to a C string. + * + * Using a FLAC__EntropyCodingMethodType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__EntropyCodingMethodTypeString[]; + + +/** Contents of a Rice partitioned residual + */ +typedef struct { + + unsigned *parameters; + /**< The Rice parameters for each context. */ + + unsigned *raw_bits; + /**< Widths for escape-coded partitions. Will be non-zero for escaped + * partitions and zero for unescaped partitions. + */ + + unsigned capacity_by_order; + /**< The capacity of the \a parameters and \a raw_bits arrays + * specified as an order, i.e. the number of array elements + * allocated is 2 ^ \a capacity_by_order. + */ +} FLAC__EntropyCodingMethod_PartitionedRiceContents; + +/** Header for a Rice partitioned residual. (c.f. format specification) + */ +typedef struct { + + unsigned order; + /**< The partition order, i.e. # of contexts = 2 ^ \a order. */ + + const FLAC__EntropyCodingMethod_PartitionedRiceContents *contents; + /**< The context's Rice parameters and/or raw bits. */ + +} FLAC__EntropyCodingMethod_PartitionedRice; + +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN; /**< == 5 (bits) */ +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN; /**< == 5 (bits) */ + +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; +/**< == (1<format specification) + */ +typedef struct { + FLAC__EntropyCodingMethodType type; + union { + FLAC__EntropyCodingMethod_PartitionedRice partitioned_rice; + } data; +} FLAC__EntropyCodingMethod; + +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_TYPE_LEN; /**< == 2 (bits) */ + +/*****************************************************************************/ + +/** An enumeration of the available subframe types. */ +typedef enum { + FLAC__SUBFRAME_TYPE_CONSTANT = 0, /**< constant signal */ + FLAC__SUBFRAME_TYPE_VERBATIM = 1, /**< uncompressed signal */ + FLAC__SUBFRAME_TYPE_FIXED = 2, /**< fixed polynomial prediction */ + FLAC__SUBFRAME_TYPE_LPC = 3 /**< linear prediction */ +} FLAC__SubframeType; + +/** Maps a FLAC__SubframeType to a C string. + * + * Using a FLAC__SubframeType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__SubframeTypeString[]; + + +/** CONSTANT subframe. (c.f. format specification) + */ +typedef struct { + FLAC__int32 value; /**< The constant signal value. */ +} FLAC__Subframe_Constant; + + +/** VERBATIM subframe. (c.f. format specification) + */ +typedef struct { + const FLAC__int32 *data; /**< A pointer to verbatim signal. */ +} FLAC__Subframe_Verbatim; + + +/** FIXED subframe. (c.f. format specification) + */ +typedef struct { + FLAC__EntropyCodingMethod entropy_coding_method; + /**< The residual coding method. */ + + unsigned order; + /**< The polynomial order. */ + + FLAC__int32 warmup[FLAC__MAX_FIXED_ORDER]; + /**< Warmup samples to prime the predictor, length == order. */ + + const FLAC__int32 *residual; + /**< The residual signal, length == (blocksize minus order) samples. */ +} FLAC__Subframe_Fixed; + + +/** LPC subframe. (c.f. format specification) + */ +typedef struct { + FLAC__EntropyCodingMethod entropy_coding_method; + /**< The residual coding method. */ + + unsigned order; + /**< The FIR order. */ + + unsigned qlp_coeff_precision; + /**< Quantized FIR filter coefficient precision in bits. */ + + int quantization_level; + /**< The qlp coeff shift needed. */ + + FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; + /**< FIR filter coefficients. */ + + FLAC__int32 warmup[FLAC__MAX_LPC_ORDER]; + /**< Warmup samples to prime the predictor, length == order. */ + + const FLAC__int32 *residual; + /**< The residual signal, length == (blocksize minus order) samples. */ +} FLAC__Subframe_LPC; + +extern FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN; /**< == 5 (bits) */ + + +/** FLAC subframe structure. (c.f. format specification) + */ +typedef struct { + FLAC__SubframeType type; + union { + FLAC__Subframe_Constant constant; + FLAC__Subframe_Fixed fixed; + FLAC__Subframe_LPC lpc; + FLAC__Subframe_Verbatim verbatim; + } data; + unsigned wasted_bits; +} FLAC__Subframe; + +/** == 1 (bit) + * + * This used to be a zero-padding bit (hence the name + * FLAC__SUBFRAME_ZERO_PAD_LEN) but is now a reserved bit. It still has a + * mandatory value of \c 0 but in the future may take on the value \c 0 or \c 1 + * to mean something else. + */ +extern FLAC_API const unsigned FLAC__SUBFRAME_ZERO_PAD_LEN; +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LEN; /**< == 6 (bits) */ +extern FLAC_API const unsigned FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN; /**< == 1 (bit) */ + +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK; /**< = 0x00 */ +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK; /**< = 0x02 */ +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK; /**< = 0x10 */ +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK; /**< = 0x40 */ + +/*****************************************************************************/ + + +/***************************************************************************** + * + * Frame structures + * + *****************************************************************************/ + +/** An enumeration of the available channel assignments. */ +typedef enum { + FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT = 0, /**< independent channels */ + FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE = 1, /**< left+side stereo */ + FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE = 2, /**< right+side stereo */ + FLAC__CHANNEL_ASSIGNMENT_MID_SIDE = 3 /**< mid+side stereo */ +} FLAC__ChannelAssignment; + +/** Maps a FLAC__ChannelAssignment to a C string. + * + * Using a FLAC__ChannelAssignment as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__ChannelAssignmentString[]; + +/** An enumeration of the possible frame numbering methods. */ +typedef enum { + FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER, /**< number contains the frame number */ + FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER /**< number contains the sample number of first sample in frame */ +} FLAC__FrameNumberType; + +/** Maps a FLAC__FrameNumberType to a C string. + * + * Using a FLAC__FrameNumberType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__FrameNumberTypeString[]; + + +/** FLAC frame header structure. (c.f. format specification) + */ +typedef struct { + unsigned blocksize; + /**< The number of samples per subframe. */ + + unsigned sample_rate; + /**< The sample rate in Hz. */ + + unsigned channels; + /**< The number of channels (== number of subframes). */ + + FLAC__ChannelAssignment channel_assignment; + /**< The channel assignment for the frame. */ + + unsigned bits_per_sample; + /**< The sample resolution. */ + + FLAC__FrameNumberType number_type; + /**< The numbering scheme used for the frame. As a convenience, the + * decoder will always convert a frame number to a sample number because + * the rules are complex. */ + + union { + FLAC__uint32 frame_number; + FLAC__uint64 sample_number; + } number; + /**< The frame number or sample number of first sample in frame; + * use the \a number_type value to determine which to use. */ + + FLAC__uint8 crc; + /**< CRC-8 (polynomial = x^8 + x^2 + x^1 + x^0, initialized with 0) + * of the raw frame header bytes, meaning everything before the CRC byte + * including the sync code. + */ +} FLAC__FrameHeader; + +extern FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC; /**< == 0x3ffe; the frame header sync code */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC_LEN; /**< == 14 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_RESERVED_LEN; /**< == 1 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN; /**< == 1 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCK_SIZE_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_SAMPLE_RATE_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN; /**< == 3 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_ZERO_PAD_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_CRC_LEN; /**< == 8 (bits) */ + + +/** FLAC frame footer structure. (c.f. format specification) + */ +typedef struct { + FLAC__uint16 crc; + /**< CRC-16 (polynomial = x^16 + x^15 + x^2 + x^0, initialized with + * 0) of the bytes before the crc, back to and including the frame header + * sync code. + */ +} FLAC__FrameFooter; + +extern FLAC_API const unsigned FLAC__FRAME_FOOTER_CRC_LEN; /**< == 16 (bits) */ + + +/** FLAC frame structure. (c.f. format specification) + */ +typedef struct { + FLAC__FrameHeader header; + FLAC__Subframe subframes[FLAC__MAX_CHANNELS]; + FLAC__FrameFooter footer; +} FLAC__Frame; + +/*****************************************************************************/ + + +/***************************************************************************** + * + * Meta-data structures + * + *****************************************************************************/ + +/** An enumeration of the available metadata block types. */ +typedef enum { + + FLAC__METADATA_TYPE_STREAMINFO = 0, + /**< STREAMINFO block */ + + FLAC__METADATA_TYPE_PADDING = 1, + /**< PADDING block */ + + FLAC__METADATA_TYPE_APPLICATION = 2, + /**< APPLICATION block */ + + FLAC__METADATA_TYPE_SEEKTABLE = 3, + /**< SEEKTABLE block */ + + FLAC__METADATA_TYPE_VORBIS_COMMENT = 4, + /**< VORBISCOMMENT block (a.k.a. FLAC tags) */ + + FLAC__METADATA_TYPE_CUESHEET = 5, + /**< CUESHEET block */ + + FLAC__METADATA_TYPE_PICTURE = 6, + /**< PICTURE block */ + + FLAC__METADATA_TYPE_UNDEFINED = 7 + /**< marker to denote beginning of undefined type range; this number will increase as new metadata types are added */ + +} FLAC__MetadataType; + +/** Maps a FLAC__MetadataType to a C string. + * + * Using a FLAC__MetadataType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__MetadataTypeString[]; + + +/** FLAC STREAMINFO structure. (c.f. format specification) + */ +typedef struct { + unsigned min_blocksize, max_blocksize; + unsigned min_framesize, max_framesize; + unsigned sample_rate; + unsigned channels; + unsigned bits_per_sample; + FLAC__uint64 total_samples; + FLAC__byte md5sum[16]; +} FLAC__StreamMetadata_StreamInfo; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN; /**< == 16 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN; /**< == 16 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN; /**< == 24 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN; /**< == 24 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN; /**< == 20 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN; /**< == 3 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN; /**< == 5 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN; /**< == 36 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN; /**< == 128 (bits) */ + +/** The total stream length of the STREAMINFO block in bytes. */ +#define FLAC__STREAM_METADATA_STREAMINFO_LENGTH (34u) + +/** FLAC PADDING structure. (c.f. format specification) + */ +typedef struct { + int dummy; + /**< Conceptually this is an empty struct since we don't store the + * padding bytes. Empty structs are not allowed by some C compilers, + * hence the dummy. + */ +} FLAC__StreamMetadata_Padding; + + +/** FLAC APPLICATION structure. (c.f. format specification) + */ +typedef struct { + FLAC__byte id[4]; + FLAC__byte *data; +} FLAC__StreamMetadata_Application; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_APPLICATION_ID_LEN; /**< == 32 (bits) */ + +/** SeekPoint structure used in SEEKTABLE blocks. (c.f. format specification) + */ +typedef struct { + FLAC__uint64 sample_number; + /**< The sample number of the target frame. */ + + FLAC__uint64 stream_offset; + /**< The offset, in bytes, of the target frame with respect to + * beginning of the first frame. */ + + unsigned frame_samples; + /**< The number of samples in the target frame. */ +} FLAC__StreamMetadata_SeekPoint; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN; /**< == 16 (bits) */ + +/** The total stream length of a seek point in bytes. */ +#define FLAC__STREAM_METADATA_SEEKPOINT_LENGTH (18u) + +/** The value used in the \a sample_number field of + * FLAC__StreamMetadataSeekPoint used to indicate a placeholder + * point (== 0xffffffffffffffff). + */ +extern FLAC_API const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; + + +/** FLAC SEEKTABLE structure. (c.f. format specification) + * + * \note From the format specification: + * - The seek points must be sorted by ascending sample number. + * - Each seek point's sample number must be the first sample of the + * target frame. + * - Each seek point's sample number must be unique within the table. + * - Existence of a SEEKTABLE block implies a correct setting of + * total_samples in the stream_info block. + * - Behavior is undefined when more than one SEEKTABLE block is + * present in a stream. + */ +typedef struct { + unsigned num_points; + FLAC__StreamMetadata_SeekPoint *points; +} FLAC__StreamMetadata_SeekTable; + + +/** Vorbis comment entry structure used in VORBIS_COMMENT blocks. (c.f. format specification) + * + * For convenience, the APIs maintain a trailing NUL character at the end of + * \a entry which is not counted toward \a length, i.e. + * \code strlen(entry) == length \endcode + */ +typedef struct { + FLAC__uint32 length; + FLAC__byte *entry; +} FLAC__StreamMetadata_VorbisComment_Entry; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN; /**< == 32 (bits) */ + + +/** FLAC VORBIS_COMMENT structure. (c.f. format specification) + */ +typedef struct { + FLAC__StreamMetadata_VorbisComment_Entry vendor_string; + FLAC__uint32 num_comments; + FLAC__StreamMetadata_VorbisComment_Entry *comments; +} FLAC__StreamMetadata_VorbisComment; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN; /**< == 32 (bits) */ + + +/** FLAC CUESHEET track index structure. (See the + * format specification for + * the full description of each field.) + */ +typedef struct { + FLAC__uint64 offset; + /**< Offset in samples, relative to the track offset, of the index + * point. + */ + + FLAC__byte number; + /**< The index point number. */ +} FLAC__StreamMetadata_CueSheet_Index; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN; /**< == 8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN; /**< == 3*8 (bits) */ + + +/** FLAC CUESHEET track structure. (See the + * format specification for + * the full description of each field.) + */ +typedef struct { + FLAC__uint64 offset; + /**< Track offset in samples, relative to the beginning of the FLAC audio stream. */ + + FLAC__byte number; + /**< The track number. */ + + char isrc[13]; + /**< Track ISRC. This is a 12-digit alphanumeric code plus a trailing \c NUL byte */ + + unsigned type:1; + /**< The track type: 0 for audio, 1 for non-audio. */ + + unsigned pre_emphasis:1; + /**< The pre-emphasis flag: 0 for no pre-emphasis, 1 for pre-emphasis. */ + + FLAC__byte num_indices; + /**< The number of track index points. */ + + FLAC__StreamMetadata_CueSheet_Index *indices; + /**< NULL if num_indices == 0, else pointer to array of index points. */ + +} FLAC__StreamMetadata_CueSheet_Track; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN; /**< == 8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN; /**< == 12*8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN; /**< == 6+13*8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN; /**< == 8 (bits) */ + + +/** FLAC CUESHEET structure. (See the + * format specification + * for the full description of each field.) + */ +typedef struct { + char media_catalog_number[129]; + /**< Media catalog number, in ASCII printable characters 0x20-0x7e. In + * general, the media catalog number may be 0 to 128 bytes long; any + * unused characters should be right-padded with NUL characters. + */ + + FLAC__uint64 lead_in; + /**< The number of lead-in samples. */ + + FLAC__bool is_cd; + /**< \c true if CUESHEET corresponds to a Compact Disc, else \c false. */ + + unsigned num_tracks; + /**< The number of tracks. */ + + FLAC__StreamMetadata_CueSheet_Track *tracks; + /**< NULL if num_tracks == 0, else pointer to array of tracks. */ + +} FLAC__StreamMetadata_CueSheet; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN; /**< == 128*8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN; /**< == 7+258*8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN; /**< == 8 (bits) */ + + +/** An enumeration of the PICTURE types (see FLAC__StreamMetadataPicture and id3 v2.4 APIC tag). */ +typedef enum { + FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER = 0, /**< Other */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD = 1, /**< 32x32 pixels 'file icon' (PNG only) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON = 2, /**< Other file icon */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER = 3, /**< Cover (front) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_BACK_COVER = 4, /**< Cover (back) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_LEAFLET_PAGE = 5, /**< Leaflet page */ + FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA = 6, /**< Media (e.g. label side of CD) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_LEAD_ARTIST = 7, /**< Lead artist/lead performer/soloist */ + FLAC__STREAM_METADATA_PICTURE_TYPE_ARTIST = 8, /**< Artist/performer */ + FLAC__STREAM_METADATA_PICTURE_TYPE_CONDUCTOR = 9, /**< Conductor */ + FLAC__STREAM_METADATA_PICTURE_TYPE_BAND = 10, /**< Band/Orchestra */ + FLAC__STREAM_METADATA_PICTURE_TYPE_COMPOSER = 11, /**< Composer */ + FLAC__STREAM_METADATA_PICTURE_TYPE_LYRICIST = 12, /**< Lyricist/text writer */ + FLAC__STREAM_METADATA_PICTURE_TYPE_RECORDING_LOCATION = 13, /**< Recording Location */ + FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_RECORDING = 14, /**< During recording */ + FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_PERFORMANCE = 15, /**< During performance */ + FLAC__STREAM_METADATA_PICTURE_TYPE_VIDEO_SCREEN_CAPTURE = 16, /**< Movie/video screen capture */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FISH = 17, /**< A bright coloured fish */ + FLAC__STREAM_METADATA_PICTURE_TYPE_ILLUSTRATION = 18, /**< Illustration */ + FLAC__STREAM_METADATA_PICTURE_TYPE_BAND_LOGOTYPE = 19, /**< Band/artist logotype */ + FLAC__STREAM_METADATA_PICTURE_TYPE_PUBLISHER_LOGOTYPE = 20, /**< Publisher/Studio logotype */ + FLAC__STREAM_METADATA_PICTURE_TYPE_UNDEFINED +} FLAC__StreamMetadata_Picture_Type; + +/** Maps a FLAC__StreamMetadata_Picture_Type to a C string. + * + * Using a FLAC__StreamMetadata_Picture_Type as the index to this array + * will give the string equivalent. The contents should not be + * modified. + */ +extern FLAC_API const char * const FLAC__StreamMetadata_Picture_TypeString[]; + +/** FLAC PICTURE structure. (See the + * format specification + * for the full description of each field.) + */ +typedef struct { + FLAC__StreamMetadata_Picture_Type type; + /**< The kind of picture stored. */ + + char *mime_type; + /**< Picture data's MIME type, in ASCII printable characters + * 0x20-0x7e, NUL terminated. For best compatibility with players, + * use picture data of MIME type \c image/jpeg or \c image/png. A + * MIME type of '-->' is also allowed, in which case the picture + * data should be a complete URL. In file storage, the MIME type is + * stored as a 32-bit length followed by the ASCII string with no NUL + * terminator, but is converted to a plain C string in this structure + * for convenience. + */ + + FLAC__byte *description; + /**< Picture's description in UTF-8, NUL terminated. In file storage, + * the description is stored as a 32-bit length followed by the UTF-8 + * string with no NUL terminator, but is converted to a plain C string + * in this structure for convenience. + */ + + FLAC__uint32 width; + /**< Picture's width in pixels. */ + + FLAC__uint32 height; + /**< Picture's height in pixels. */ + + FLAC__uint32 depth; + /**< Picture's color depth in bits-per-pixel. */ + + FLAC__uint32 colors; + /**< For indexed palettes (like GIF), picture's number of colors (the + * number of palette entries), or \c 0 for non-indexed (i.e. 2^depth). + */ + + FLAC__uint32 data_length; + /**< Length of binary picture data in bytes. */ + + FLAC__byte *data; + /**< Binary picture data. */ + +} FLAC__StreamMetadata_Picture; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_TYPE_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_COLORS_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN; /**< == 32 (bits) */ + + +/** Structure that is used when a metadata block of unknown type is loaded. + * The contents are opaque. The structure is used only internally to + * correctly handle unknown metadata. + */ +typedef struct { + FLAC__byte *data; +} FLAC__StreamMetadata_Unknown; + + +/** FLAC metadata block structure. (c.f. format specification) + */ +typedef struct { + FLAC__MetadataType type; + /**< The type of the metadata block; used determine which member of the + * \a data union to dereference. If type >= FLAC__METADATA_TYPE_UNDEFINED + * then \a data.unknown must be used. */ + + FLAC__bool is_last; + /**< \c true if this metadata block is the last, else \a false */ + + unsigned length; + /**< Length, in bytes, of the block data as it appears in the stream. */ + + union { + FLAC__StreamMetadata_StreamInfo stream_info; + FLAC__StreamMetadata_Padding padding; + FLAC__StreamMetadata_Application application; + FLAC__StreamMetadata_SeekTable seek_table; + FLAC__StreamMetadata_VorbisComment vorbis_comment; + FLAC__StreamMetadata_CueSheet cue_sheet; + FLAC__StreamMetadata_Picture picture; + FLAC__StreamMetadata_Unknown unknown; + } data; + /**< Polymorphic block data; use the \a type value to determine which + * to use. */ +} FLAC__StreamMetadata; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_IS_LAST_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_TYPE_LEN; /**< == 7 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_LENGTH_LEN; /**< == 24 (bits) */ + +/** The total stream length of a metadata block header in bytes. */ +#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) + +/*****************************************************************************/ + + +/***************************************************************************** + * + * Utility functions + * + *****************************************************************************/ + +/** Tests that a sample rate is valid for FLAC. + * + * \param sample_rate The sample rate to test for compliance. + * \retval FLAC__bool + * \c true if the given sample rate conforms to the specification, else + * \c false. + */ +FLAC_API FLAC__bool FLAC__format_sample_rate_is_valid(unsigned sample_rate); + +/** Tests that a blocksize at the given sample rate is valid for the FLAC + * subset. + * + * \param blocksize The blocksize to test for compliance. + * \param sample_rate The sample rate is needed, since the valid subset + * blocksize depends on the sample rate. + * \retval FLAC__bool + * \c true if the given blocksize conforms to the specification for the + * subset at the given sample rate, else \c false. + */ +FLAC_API FLAC__bool FLAC__format_blocksize_is_subset(unsigned blocksize, unsigned sample_rate); + +/** Tests that a sample rate is valid for the FLAC subset. The subset rules + * for valid sample rates are slightly more complex since the rate has to + * be expressible completely in the frame header. + * + * \param sample_rate The sample rate to test for compliance. + * \retval FLAC__bool + * \c true if the given sample rate conforms to the specification for the + * subset, else \c false. + */ +FLAC_API FLAC__bool FLAC__format_sample_rate_is_subset(unsigned sample_rate); + +/** Check a Vorbis comment entry name to see if it conforms to the Vorbis + * comment specification. + * + * Vorbis comment names must be composed only of characters from + * [0x20-0x3C,0x3E-0x7D]. + * + * \param name A NUL-terminated string to be checked. + * \assert + * \code name != NULL \endcode + * \retval FLAC__bool + * \c false if entry name is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_name_is_legal(const char *name); + +/** Check a Vorbis comment entry value to see if it conforms to the Vorbis + * comment specification. + * + * Vorbis comment values must be valid UTF-8 sequences. + * + * \param value A string to be checked. + * \param length A the length of \a value in bytes. May be + * \c (unsigned)(-1) to indicate that \a value is a plain + * UTF-8 NUL-terminated string. + * \assert + * \code value != NULL \endcode + * \retval FLAC__bool + * \c false if entry name is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__byte *value, unsigned length); + +/** Check a Vorbis comment entry to see if it conforms to the Vorbis + * comment specification. + * + * Vorbis comment entries must be of the form 'name=value', and 'name' and + * 'value' must be legal according to + * FLAC__format_vorbiscomment_entry_name_is_legal() and + * FLAC__format_vorbiscomment_entry_value_is_legal() respectively. + * + * \param entry An entry to be checked. + * \param length The length of \a entry in bytes. + * \assert + * \code value != NULL \endcode + * \retval FLAC__bool + * \c false if entry name is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_is_legal(const FLAC__byte *entry, unsigned length); + +/** Check a seek table to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * seek table. + * + * \param seek_table A pointer to a seek table to be checked. + * \assert + * \code seek_table != NULL \endcode + * \retval FLAC__bool + * \c false if seek table is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_seektable_is_legal(const FLAC__StreamMetadata_SeekTable *seek_table); + +/** Sort a seek table's seek points according to the format specification. + * This includes a "unique-ification" step to remove duplicates, i.e. + * seek points with identical \a sample_number values. Duplicate seek + * points are converted into placeholder points and sorted to the end of + * the table. + * + * \param seek_table A pointer to a seek table to be sorted. + * \assert + * \code seek_table != NULL \endcode + * \retval unsigned + * The number of duplicate seek points converted into placeholders. + */ +FLAC_API unsigned FLAC__format_seektable_sort(FLAC__StreamMetadata_SeekTable *seek_table); + +/** Check a cue sheet to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * cue sheet. + * + * \param cue_sheet A pointer to an existing cue sheet to be checked. + * \param check_cd_da_subset If \c true, check CUESHEET against more + * stringent requirements for a CD-DA (audio) disc. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code cue_sheet != NULL \endcode + * \retval FLAC__bool + * \c false if cue sheet is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_cuesheet_is_legal(const FLAC__StreamMetadata_CueSheet *cue_sheet, FLAC__bool check_cd_da_subset, const char **violation); + +/** Check picture data to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * PICTURE block. + * + * \param picture A pointer to existing picture data to be checked. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code picture != NULL \endcode + * \retval FLAC__bool + * \c false if picture data is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_picture_is_legal(const FLAC__StreamMetadata_Picture *picture, const char **violation); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/MacOSX/codecs/include/FLAC/metadata.h b/quakespasm/MacOSX/codecs/include/FLAC/metadata.h new file mode 100644 index 00000000..fcc8ed95 --- /dev/null +++ b/quakespasm/MacOSX/codecs/include/FLAC/metadata.h @@ -0,0 +1,2182 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2001-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__METADATA_H +#define FLAC__METADATA_H + +#include /* for off_t */ +#include "export.h" +#include "callback.h" +#include "format.h" + +/* -------------------------------------------------------------------- + (For an example of how all these routines are used, see the source + code for the unit tests in src/test_libFLAC/metadata_*.c, or + metaflac in src/metaflac/) + ------------------------------------------------------------------*/ + +/** \file include/FLAC/metadata.h + * + * \brief + * This module provides functions for creating and manipulating FLAC + * metadata blocks in memory, and three progressively more powerful + * interfaces for traversing and editing metadata in FLAC files. + * + * See the detailed documentation for each interface in the + * \link flac_metadata metadata \endlink module. + */ + +/** \defgroup flac_metadata FLAC/metadata.h: metadata interfaces + * \ingroup flac + * + * \brief + * This module provides functions for creating and manipulating FLAC + * metadata blocks in memory, and three progressively more powerful + * interfaces for traversing and editing metadata in native FLAC files. + * Note that currently only the Chain interface (level 2) supports Ogg + * FLAC files, and it is read-only i.e. no writing back changed + * metadata to file. + * + * There are three metadata interfaces of increasing complexity: + * + * Level 0: + * Read-only access to the STREAMINFO, VORBIS_COMMENT, CUESHEET, and + * PICTURE blocks. + * + * Level 1: + * Read-write access to all metadata blocks. This level is write- + * efficient in most cases (more on this below), and uses less memory + * than level 2. + * + * Level 2: + * Read-write access to all metadata blocks. This level is write- + * efficient in all cases, but uses more memory since all metadata for + * the whole file is read into memory and manipulated before writing + * out again. + * + * What do we mean by efficient? Since FLAC metadata appears at the + * beginning of the file, when writing metadata back to a FLAC file + * it is possible to grow or shrink the metadata such that the entire + * file must be rewritten. However, if the size remains the same during + * changes or PADDING blocks are utilized, only the metadata needs to be + * overwritten, which is much faster. + * + * Efficient means the whole file is rewritten at most one time, and only + * when necessary. Level 1 is not efficient only in the case that you + * cause more than one metadata block to grow or shrink beyond what can + * be accomodated by padding. In this case you should probably use level + * 2, which allows you to edit all the metadata for a file in memory and + * write it out all at once. + * + * All levels know how to skip over and not disturb an ID3v2 tag at the + * front of the file. + * + * All levels access files via their filenames. In addition, level 2 + * has additional alternative read and write functions that take an I/O + * handle and callbacks, for situations where access by filename is not + * possible. + * + * In addition to the three interfaces, this module defines functions for + * creating and manipulating various metadata objects in memory. As we see + * from the Format module, FLAC metadata blocks in memory are very primitive + * structures for storing information in an efficient way. Reading + * information from the structures is easy but creating or modifying them + * directly is more complex. The metadata object routines here facilitate + * this by taking care of the consistency and memory management drudgery. + * + * Unless you will be using the level 1 or 2 interfaces to modify existing + * metadata however, you will not probably not need these. + * + * From a dependency standpoint, none of the encoders or decoders require + * the metadata module. This is so that embedded users can strip out the + * metadata module from libFLAC to reduce the size and complexity. + */ + +#ifdef __cplusplus +extern "C" { +#endif + + +/** \defgroup flac_metadata_level0 FLAC/metadata.h: metadata level 0 interface + * \ingroup flac_metadata + * + * \brief + * The level 0 interface consists of individual routines to read the + * STREAMINFO, VORBIS_COMMENT, CUESHEET, and PICTURE blocks, requiring + * only a filename. + * + * They try to skip any ID3v2 tag at the head of the file. + * + * \{ + */ + +/** Read the STREAMINFO metadata block of the given FLAC file. This function + * will try to skip any ID3v2 tag at the head of the file. + * + * \param filename The path to the FLAC file to read. + * \param streaminfo A pointer to space for the STREAMINFO block. Since + * FLAC__StreamMetadata is a simple structure with no + * memory allocation involved, you pass the address of + * an existing structure. It need not be initialized. + * \assert + * \code filename != NULL \endcode + * \code streaminfo != NULL \endcode + * \retval FLAC__bool + * \c true if a valid STREAMINFO block was read from \a filename. Returns + * \c false if there was a memory allocation error, a file decoder error, + * or the file contained no STREAMINFO block. (A memory allocation error + * is possible because this function must set up a file decoder.) + */ +FLAC_API FLAC__bool FLAC__metadata_get_streaminfo(const char *filename, FLAC__StreamMetadata *streaminfo); + +/** Read the VORBIS_COMMENT metadata block of the given FLAC file. This + * function will try to skip any ID3v2 tag at the head of the file. + * + * \param filename The path to the FLAC file to read. + * \param tags The address where the returned pointer will be + * stored. The \a tags object must be deleted by + * the caller using FLAC__metadata_object_delete(). + * \assert + * \code filename != NULL \endcode + * \code tags != NULL \endcode + * \retval FLAC__bool + * \c true if a valid VORBIS_COMMENT block was read from \a filename, + * and \a *tags will be set to the address of the metadata structure. + * Returns \c false if there was a memory allocation error, a file + * decoder error, or the file contained no VORBIS_COMMENT block, and + * \a *tags will be set to \c NULL. + */ +FLAC_API FLAC__bool FLAC__metadata_get_tags(const char *filename, FLAC__StreamMetadata **tags); + +/** Read the CUESHEET metadata block of the given FLAC file. This + * function will try to skip any ID3v2 tag at the head of the file. + * + * \param filename The path to the FLAC file to read. + * \param cuesheet The address where the returned pointer will be + * stored. The \a cuesheet object must be deleted by + * the caller using FLAC__metadata_object_delete(). + * \assert + * \code filename != NULL \endcode + * \code cuesheet != NULL \endcode + * \retval FLAC__bool + * \c true if a valid CUESHEET block was read from \a filename, + * and \a *cuesheet will be set to the address of the metadata + * structure. Returns \c false if there was a memory allocation + * error, a file decoder error, or the file contained no CUESHEET + * block, and \a *cuesheet will be set to \c NULL. + */ +FLAC_API FLAC__bool FLAC__metadata_get_cuesheet(const char *filename, FLAC__StreamMetadata **cuesheet); + +/** Read a PICTURE metadata block of the given FLAC file. This + * function will try to skip any ID3v2 tag at the head of the file. + * Since there can be more than one PICTURE block in a file, this + * function takes a number of parameters that act as constraints to + * the search. The PICTURE block with the largest area matching all + * the constraints will be returned, or \a *picture will be set to + * \c NULL if there was no such block. + * + * \param filename The path to the FLAC file to read. + * \param picture The address where the returned pointer will be + * stored. The \a picture object must be deleted by + * the caller using FLAC__metadata_object_delete(). + * \param type The desired picture type. Use \c -1 to mean + * "any type". + * \param mime_type The desired MIME type, e.g. "image/jpeg". The + * string will be matched exactly. Use \c NULL to + * mean "any MIME type". + * \param description The desired description. The string will be + * matched exactly. Use \c NULL to mean "any + * description". + * \param max_width The maximum width in pixels desired. Use + * \c (unsigned)(-1) to mean "any width". + * \param max_height The maximum height in pixels desired. Use + * \c (unsigned)(-1) to mean "any height". + * \param max_depth The maximum color depth in bits-per-pixel desired. + * Use \c (unsigned)(-1) to mean "any depth". + * \param max_colors The maximum number of colors desired. Use + * \c (unsigned)(-1) to mean "any number of colors". + * \assert + * \code filename != NULL \endcode + * \code picture != NULL \endcode + * \retval FLAC__bool + * \c true if a valid PICTURE block was read from \a filename, + * and \a *picture will be set to the address of the metadata + * structure. Returns \c false if there was a memory allocation + * error, a file decoder error, or the file contained no PICTURE + * block, and \a *picture will be set to \c NULL. + */ +FLAC_API FLAC__bool FLAC__metadata_get_picture(const char *filename, FLAC__StreamMetadata **picture, FLAC__StreamMetadata_Picture_Type type, const char *mime_type, const FLAC__byte *description, unsigned max_width, unsigned max_height, unsigned max_depth, unsigned max_colors); + +/* \} */ + + +/** \defgroup flac_metadata_level1 FLAC/metadata.h: metadata level 1 interface + * \ingroup flac_metadata + * + * \brief + * The level 1 interface provides read-write access to FLAC file metadata and + * operates directly on the FLAC file. + * + * The general usage of this interface is: + * + * - Create an iterator using FLAC__metadata_simple_iterator_new() + * - Attach it to a file using FLAC__metadata_simple_iterator_init() and check + * the exit code. Call FLAC__metadata_simple_iterator_is_writable() to + * see if the file is writable, or only read access is allowed. + * - Use FLAC__metadata_simple_iterator_next() and + * FLAC__metadata_simple_iterator_prev() to traverse the blocks. + * This is does not read the actual blocks themselves. + * FLAC__metadata_simple_iterator_next() is relatively fast. + * FLAC__metadata_simple_iterator_prev() is slower since it needs to search + * forward from the front of the file. + * - Use FLAC__metadata_simple_iterator_get_block_type() or + * FLAC__metadata_simple_iterator_get_block() to access the actual data at + * the current iterator position. The returned object is yours to modify + * and free. + * - Use FLAC__metadata_simple_iterator_set_block() to write a modified block + * back. You must have write permission to the original file. Make sure to + * read the whole comment to FLAC__metadata_simple_iterator_set_block() + * below. + * - Use FLAC__metadata_simple_iterator_insert_block_after() to add new blocks. + * Use the object creation functions from + * \link flac_metadata_object here \endlink to generate new objects. + * - Use FLAC__metadata_simple_iterator_delete_block() to remove the block + * currently referred to by the iterator, or replace it with padding. + * - Destroy the iterator with FLAC__metadata_simple_iterator_delete() when + * finished. + * + * \note + * The FLAC file remains open the whole time between + * FLAC__metadata_simple_iterator_init() and + * FLAC__metadata_simple_iterator_delete(), so make sure you are not altering + * the file during this time. + * + * \note + * Do not modify the \a is_last, \a length, or \a type fields of returned + * FLAC__StreamMetadata objects. These are managed automatically. + * + * \note + * If any of the modification functions + * (FLAC__metadata_simple_iterator_set_block(), + * FLAC__metadata_simple_iterator_delete_block(), + * FLAC__metadata_simple_iterator_insert_block_after(), etc.) return \c false, + * you should delete the iterator as it may no longer be valid. + * + * \{ + */ + +struct FLAC__Metadata_SimpleIterator; +/** The opaque structure definition for the level 1 iterator type. + * See the + * \link flac_metadata_level1 metadata level 1 module \endlink + * for a detailed description. + */ +typedef struct FLAC__Metadata_SimpleIterator FLAC__Metadata_SimpleIterator; + +/** Status type for FLAC__Metadata_SimpleIterator. + * + * The iterator's current status can be obtained by calling FLAC__metadata_simple_iterator_status(). + */ +typedef enum { + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK = 0, + /**< The iterator is in the normal OK state */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT, + /**< The data passed into a function violated the function's usage criteria */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE, + /**< The iterator could not open the target file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE, + /**< The iterator could not find the FLAC signature at the start of the file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE, + /**< The iterator tried to write to a file that was not writable */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_BAD_METADATA, + /**< The iterator encountered input that does not conform to the FLAC metadata specification */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR, + /**< The iterator encountered an error while reading the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR, + /**< The iterator encountered an error while seeking in the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR, + /**< The iterator encountered an error while writing the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR, + /**< The iterator encountered an error renaming the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR, + /**< The iterator encountered an error removing the temporary file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR, + /**< Memory allocation failed */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_INTERNAL_ERROR + /**< The caller violated an assertion or an unexpected error occurred */ + +} FLAC__Metadata_SimpleIteratorStatus; + +/** Maps a FLAC__Metadata_SimpleIteratorStatus to a C string. + * + * Using a FLAC__Metadata_SimpleIteratorStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__Metadata_SimpleIteratorStatusString[]; + + +/** Create a new iterator instance. + * + * \retval FLAC__Metadata_SimpleIterator* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__Metadata_SimpleIterator *FLAC__metadata_simple_iterator_new(void); + +/** Free an iterator instance. Deletes the object pointed to by \a iterator. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + */ +FLAC_API void FLAC__metadata_simple_iterator_delete(FLAC__Metadata_SimpleIterator *iterator); + +/** Get the current status of the iterator. Call this after a function + * returns \c false to get the reason for the error. Also resets the status + * to FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + * \retval FLAC__Metadata_SimpleIteratorStatus + * The current status of the iterator. + */ +FLAC_API FLAC__Metadata_SimpleIteratorStatus FLAC__metadata_simple_iterator_status(FLAC__Metadata_SimpleIterator *iterator); + +/** Initialize the iterator to point to the first metadata block in the + * given FLAC file. + * + * \param iterator A pointer to an existing iterator. + * \param filename The path to the FLAC file. + * \param read_only If \c true, the FLAC file will be opened + * in read-only mode; if \c false, the FLAC + * file will be opened for edit even if no + * edits are performed. + * \param preserve_file_stats If \c true, the owner and modification + * time will be preserved even if the FLAC + * file is written to. + * \assert + * \code iterator != NULL \endcode + * \code filename != NULL \endcode + * \retval FLAC__bool + * \c false if a memory allocation error occurs, the file can't be + * opened, or another error occurs, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_init(FLAC__Metadata_SimpleIterator *iterator, const char *filename, FLAC__bool read_only, FLAC__bool preserve_file_stats); + +/** Returns \c true if the FLAC file is writable. If \c false, calls to + * FLAC__metadata_simple_iterator_set_block() and + * FLAC__metadata_simple_iterator_insert_block_after() will fail. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + * \retval FLAC__bool + * See above. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_is_writable(const FLAC__Metadata_SimpleIterator *iterator); + +/** Moves the iterator forward one metadata block, returning \c false if + * already at the end. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c false if already at the last metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_next(FLAC__Metadata_SimpleIterator *iterator); + +/** Moves the iterator backward one metadata block, returning \c false if + * already at the beginning. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c false if already at the first metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_prev(FLAC__Metadata_SimpleIterator *iterator); + +/** Returns a flag telling if the current metadata block is the last. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c true if the current metadata block is the last in the file, + * else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_is_last(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the offset of the metadata block at the current position. This + * avoids reading the actual block data which can save time for large + * blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval off_t + * The offset of the metadata block at the current iterator position. + * This is the byte offset relative to the beginning of the file of + * the current metadata block's header. + */ +FLAC_API off_t FLAC__metadata_simple_iterator_get_block_offset(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the type of the metadata block at the current position. This + * avoids reading the actual block data which can save time for large + * blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__MetadataType + * The type of the metadata block at the current iterator position. + */ +FLAC_API FLAC__MetadataType FLAC__metadata_simple_iterator_get_block_type(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the length of the metadata block at the current position. This + * avoids reading the actual block data which can save time for large + * blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval unsigned + * The length of the metadata block at the current iterator position. + * The is same length as that in the + * metadata block header, + * i.e. the length of the metadata body that follows the header. + */ +FLAC_API unsigned FLAC__metadata_simple_iterator_get_block_length(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the application ID of the \c APPLICATION block at the current + * position. This avoids reading the actual block data which can save + * time for large blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \param id A pointer to a buffer of at least \c 4 bytes where + * the ID will be stored. + * \assert + * \code iterator != NULL \endcode + * \code id != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c true if the ID was successfully read, else \c false, in which + * case you should check FLAC__metadata_simple_iterator_status() to + * find out why. If the status is + * \c FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT, then the + * current metadata block is not an \c APPLICATION block. Otherwise + * if the status is + * \c FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR or + * \c FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR, an I/O error + * occurred and the iterator can no longer be used. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_get_application_id(FLAC__Metadata_SimpleIterator *iterator, FLAC__byte *id); + +/** Get the metadata block at the current position. You can modify the + * block but must use FLAC__metadata_simple_iterator_set_block() to + * write it back to the FLAC file. + * + * You must call FLAC__metadata_object_delete() on the returned object + * when you are finished with it. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__StreamMetadata* + * The current metadata block, or \c NULL if there was a memory + * allocation error. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_simple_iterator_get_block(FLAC__Metadata_SimpleIterator *iterator); + +/** Write a block back to the FLAC file. This function tries to be + * as efficient as possible; how the block is actually written is + * shown by the following: + * + * Existing block is a STREAMINFO block and the new block is a + * STREAMINFO block: the new block is written in place. Make sure + * you know what you're doing when changing the values of a + * STREAMINFO block. + * + * Existing block is a STREAMINFO block and the new block is a + * not a STREAMINFO block: this is an error since the first block + * must be a STREAMINFO block. Returns \c false without altering the + * file. + * + * Existing block is not a STREAMINFO block and the new block is a + * STREAMINFO block: this is an error since there may be only one + * STREAMINFO block. Returns \c false without altering the file. + * + * Existing block and new block are the same length: the existing + * block will be replaced by the new block, written in place. + * + * Existing block is longer than new block: if use_padding is \c true, + * the existing block will be overwritten in place with the new + * block followed by a PADDING block, if possible, to make the total + * size the same as the existing block. Remember that a padding + * block requires at least four bytes so if the difference in size + * between the new block and existing block is less than that, the + * entire file will have to be rewritten, using the new block's + * exact size. If use_padding is \c false, the entire file will be + * rewritten, replacing the existing block by the new block. + * + * Existing block is shorter than new block: if use_padding is \c true, + * the function will try and expand the new block into the following + * PADDING block, if it exists and doing so won't shrink the PADDING + * block to less than 4 bytes. If there is no following PADDING + * block, or it will shrink to less than 4 bytes, or use_padding is + * \c false, the entire file is rewritten, replacing the existing block + * with the new block. Note that in this case any following PADDING + * block is preserved as is. + * + * After writing the block, the iterator will remain in the same + * place, i.e. pointing to the new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block The block to set. + * \param use_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \code block != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_set_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding); + +/** This is similar to FLAC__metadata_simple_iterator_set_block() + * except that instead of writing over an existing block, it appends + * a block after the existing block. \a use_padding is again used to + * tell the function to try an expand into following padding in an + * attempt to avoid rewriting the entire file. + * + * This function will fail and return \c false if given a STREAMINFO + * block. + * + * After writing the block, the iterator will be pointing to the + * new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block The block to set. + * \param use_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \code block != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_insert_block_after(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding); + +/** Deletes the block at the current position. This will cause the + * entire FLAC file to be rewritten, unless \a use_padding is \c true, + * in which case the block will be replaced by an equal-sized PADDING + * block. The iterator will be left pointing to the block before the + * one just deleted. + * + * You may not delete the STREAMINFO block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param use_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_delete_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__bool use_padding); + +/* \} */ + + +/** \defgroup flac_metadata_level2 FLAC/metadata.h: metadata level 2 interface + * \ingroup flac_metadata + * + * \brief + * The level 2 interface provides read-write access to FLAC file metadata; + * all metadata is read into memory, operated on in memory, and then written + * to file, which is more efficient than level 1 when editing multiple blocks. + * + * Currently Ogg FLAC is supported for read only, via + * FLAC__metadata_chain_read_ogg() but a subsequent + * FLAC__metadata_chain_write() will fail. + * + * The general usage of this interface is: + * + * - Create a new chain using FLAC__metadata_chain_new(). A chain is a + * linked list of FLAC metadata blocks. + * - Read all metadata into the the chain from a FLAC file using + * FLAC__metadata_chain_read() or FLAC__metadata_chain_read_ogg() and + * check the status. + * - Optionally, consolidate the padding using + * FLAC__metadata_chain_merge_padding() or + * FLAC__metadata_chain_sort_padding(). + * - Create a new iterator using FLAC__metadata_iterator_new() + * - Initialize the iterator to point to the first element in the chain + * using FLAC__metadata_iterator_init() + * - Traverse the chain using FLAC__metadata_iterator_next and + * FLAC__metadata_iterator_prev(). + * - Get a block for reading or modification using + * FLAC__metadata_iterator_get_block(). The pointer to the object + * inside the chain is returned, so the block is yours to modify. + * Changes will be reflected in the FLAC file when you write the + * chain. You can also add and delete blocks (see functions below). + * - When done, write out the chain using FLAC__metadata_chain_write(). + * Make sure to read the whole comment to the function below. + * - Delete the chain using FLAC__metadata_chain_delete(). + * + * \note + * Even though the FLAC file is not open while the chain is being + * manipulated, you must not alter the file externally during + * this time. The chain assumes the FLAC file will not change + * between the time of FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg() + * and FLAC__metadata_chain_write(). + * + * \note + * Do not modify the is_last, length, or type fields of returned + * FLAC__StreamMetadata objects. These are managed automatically. + * + * \note + * The metadata objects returned by FLAC__metadata_iterator_get_block() + * are owned by the chain; do not FLAC__metadata_object_delete() them. + * In the same way, blocks passed to FLAC__metadata_iterator_set_block() + * become owned by the chain and they will be deleted when the chain is + * deleted. + * + * \{ + */ + +struct FLAC__Metadata_Chain; +/** The opaque structure definition for the level 2 chain type. + */ +typedef struct FLAC__Metadata_Chain FLAC__Metadata_Chain; + +struct FLAC__Metadata_Iterator; +/** The opaque structure definition for the level 2 iterator type. + */ +typedef struct FLAC__Metadata_Iterator FLAC__Metadata_Iterator; + +typedef enum { + FLAC__METADATA_CHAIN_STATUS_OK = 0, + /**< The chain is in the normal OK state */ + + FLAC__METADATA_CHAIN_STATUS_ILLEGAL_INPUT, + /**< The data passed into a function violated the function's usage criteria */ + + FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE, + /**< The chain could not open the target file */ + + FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE, + /**< The chain could not find the FLAC signature at the start of the file */ + + FLAC__METADATA_CHAIN_STATUS_NOT_WRITABLE, + /**< The chain tried to write to a file that was not writable */ + + FLAC__METADATA_CHAIN_STATUS_BAD_METADATA, + /**< The chain encountered input that does not conform to the FLAC metadata specification */ + + FLAC__METADATA_CHAIN_STATUS_READ_ERROR, + /**< The chain encountered an error while reading the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR, + /**< The chain encountered an error while seeking in the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR, + /**< The chain encountered an error while writing the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_RENAME_ERROR, + /**< The chain encountered an error renaming the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_UNLINK_ERROR, + /**< The chain encountered an error removing the temporary file */ + + FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR, + /**< Memory allocation failed */ + + FLAC__METADATA_CHAIN_STATUS_INTERNAL_ERROR, + /**< The caller violated an assertion or an unexpected error occurred */ + + FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS, + /**< One or more of the required callbacks was NULL */ + + FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH, + /**< FLAC__metadata_chain_write() was called on a chain read by + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(), + * or + * FLAC__metadata_chain_write_with_callbacks()/FLAC__metadata_chain_write_with_callbacks_and_tempfile() + * was called on a chain read by + * FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(). + * Matching read/write methods must always be used. */ + + FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL + /**< FLAC__metadata_chain_write_with_callbacks() was called when the + * chain write requires a tempfile; use + * FLAC__metadata_chain_write_with_callbacks_and_tempfile() instead. + * Or, FLAC__metadata_chain_write_with_callbacks_and_tempfile() was + * called when the chain write does not require a tempfile; use + * FLAC__metadata_chain_write_with_callbacks() instead. + * Always check FLAC__metadata_chain_check_if_tempfile_needed() + * before writing via callbacks. */ + +} FLAC__Metadata_ChainStatus; + +/** Maps a FLAC__Metadata_ChainStatus to a C string. + * + * Using a FLAC__Metadata_ChainStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__Metadata_ChainStatusString[]; + +/*********** FLAC__Metadata_Chain ***********/ + +/** Create a new chain instance. + * + * \retval FLAC__Metadata_Chain* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__Metadata_Chain *FLAC__metadata_chain_new(void); + +/** Free a chain instance. Deletes the object pointed to by \a chain. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_chain_delete(FLAC__Metadata_Chain *chain); + +/** Get the current status of the chain. Call this after a function + * returns \c false to get the reason for the error. Also resets the + * status to FLAC__METADATA_CHAIN_STATUS_OK. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__Metadata_ChainStatus + * The current status of the chain. + */ +FLAC_API FLAC__Metadata_ChainStatus FLAC__metadata_chain_status(FLAC__Metadata_Chain *chain); + +/** Read all metadata from a FLAC file into the chain. + * + * \param chain A pointer to an existing chain. + * \param filename The path to the FLAC file to read. + * \assert + * \code chain != NULL \endcode + * \code filename != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a filename, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read(FLAC__Metadata_Chain *chain, const char *filename); + +/** Read all metadata from an Ogg FLAC file into the chain. + * + * \note Ogg FLAC metadata data writing is not supported yet and + * FLAC__metadata_chain_write() will fail. + * + * \param chain A pointer to an existing chain. + * \param filename The path to the Ogg FLAC file to read. + * \assert + * \code chain != NULL \endcode + * \code filename != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a filename, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read_ogg(FLAC__Metadata_Chain *chain, const char *filename); + +/** Read all metadata from a FLAC stream into the chain via I/O callbacks. + * + * The \a handle need only be open for reading, but must be seekable. + * The equivalent minimum stdio fopen() file mode is \c "r" (or \c "rb" + * for Windows). + * + * \param chain A pointer to an existing chain. + * \param handle The I/O handle of the FLAC stream to read. The + * handle will NOT be closed after the metadata is read; + * that is the duty of the caller. + * \param callbacks + * A set of callbacks to use for I/O. The mandatory + * callbacks are \a read, \a seek, and \a tell. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a handle, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks); + +/** Read all metadata from an Ogg FLAC stream into the chain via I/O callbacks. + * + * The \a handle need only be open for reading, but must be seekable. + * The equivalent minimum stdio fopen() file mode is \c "r" (or \c "rb" + * for Windows). + * + * \note Ogg FLAC metadata data writing is not supported yet and + * FLAC__metadata_chain_write() will fail. + * + * \param chain A pointer to an existing chain. + * \param handle The I/O handle of the Ogg FLAC stream to read. The + * handle will NOT be closed after the metadata is read; + * that is the duty of the caller. + * \param callbacks + * A set of callbacks to use for I/O. The mandatory + * callbacks are \a read, \a seek, and \a tell. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a handle, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read_ogg_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks); + +/** Checks if writing the given chain would require the use of a + * temporary file, or if it could be written in place. + * + * Under certain conditions, padding can be utilized so that writing + * edited metadata back to the FLAC file does not require rewriting the + * entire file. If rewriting is required, then a temporary workfile is + * required. When writing metadata using callbacks, you must check + * this function to know whether to call + * FLAC__metadata_chain_write_with_callbacks() or + * FLAC__metadata_chain_write_with_callbacks_and_tempfile(). When + * writing with FLAC__metadata_chain_write(), the temporary file is + * handled internally. + * + * \param chain A pointer to an existing chain. + * \param use_padding + * Whether or not padding will be allowed to be used + * during the write. The value of \a use_padding given + * here must match the value later passed to + * FLAC__metadata_chain_write_with_callbacks() or + * FLAC__metadata_chain_write_with_callbacks_with_tempfile(). + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if writing the current chain would require a tempfile, or + * \c false if metadata can be written in place. + */ +FLAC_API FLAC__bool FLAC__metadata_chain_check_if_tempfile_needed(FLAC__Metadata_Chain *chain, FLAC__bool use_padding); + +/** Write all metadata out to the FLAC file. This function tries to be as + * efficient as possible; how the metadata is actually written is shown by + * the following: + * + * If the current chain is the same size as the existing metadata, the new + * data is written in place. + * + * If the current chain is longer than the existing metadata, and + * \a use_padding is \c true, and the last block is a PADDING block of + * sufficient length, the function will truncate the final padding block + * so that the overall size of the metadata is the same as the existing + * metadata, and then just rewrite the metadata. Otherwise, if not all of + * the above conditions are met, the entire FLAC file must be rewritten. + * If you want to use padding this way it is a good idea to call + * FLAC__metadata_chain_sort_padding() first so that you have the maximum + * amount of padding to work with, unless you need to preserve ordering + * of the PADDING blocks for some reason. + * + * If the current chain is shorter than the existing metadata, and + * \a use_padding is \c true, and the final block is a PADDING block, the padding + * is extended to make the overall size the same as the existing data. If + * \a use_padding is \c true and the last block is not a PADDING block, a new + * PADDING block is added to the end of the new data to make it the same + * size as the existing data (if possible, see the note to + * FLAC__metadata_simple_iterator_set_block() about the four byte limit) + * and the new data is written in place. If none of the above apply or + * \a use_padding is \c false, the entire FLAC file is rewritten. + * + * If \a preserve_file_stats is \c true, the owner and modification time will + * be preserved even if the FLAC file is written. + * + * For this write function to be used, the chain must have been read with + * FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(), not + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(). + * + * \param chain A pointer to an existing chain. + * \param use_padding See above. + * \param preserve_file_stats See above. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if the write succeeded, else \c false. On failure, + * check the status with FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_write(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__bool preserve_file_stats); + +/** Write all metadata out to a FLAC stream via callbacks. + * + * (See FLAC__metadata_chain_write() for the details on how padding is + * used to write metadata in place if possible.) + * + * The \a handle must be open for updating and be seekable. The + * equivalent minimum stdio fopen() file mode is \c "r+" (or \c "r+b" + * for Windows). + * + * For this write function to be used, the chain must have been read with + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(), + * not FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(). + * Also, FLAC__metadata_chain_check_if_tempfile_needed() must have returned + * \c false. + * + * \param chain A pointer to an existing chain. + * \param use_padding See FLAC__metadata_chain_write() + * \param handle The I/O handle of the FLAC stream to write. The + * handle will NOT be closed after the metadata is + * written; that is the duty of the caller. + * \param callbacks A set of callbacks to use for I/O. The mandatory + * callbacks are \a write and \a seek. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if the write succeeded, else \c false. On failure, + * check the status with FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks); + +/** Write all metadata out to a FLAC stream via callbacks. + * + * (See FLAC__metadata_chain_write() for the details on how padding is + * used to write metadata in place if possible.) + * + * This version of the write-with-callbacks function must be used when + * FLAC__metadata_chain_check_if_tempfile_needed() returns true. In + * this function, you must supply an I/O handle corresponding to the + * FLAC file to edit, and a temporary handle to which the new FLAC + * file will be written. It is the caller's job to move this temporary + * FLAC file on top of the original FLAC file to complete the metadata + * edit. + * + * The \a handle must be open for reading and be seekable. The + * equivalent minimum stdio fopen() file mode is \c "r" (or \c "rb" + * for Windows). + * + * The \a temp_handle must be open for writing. The + * equivalent minimum stdio fopen() file mode is \c "w" (or \c "wb" + * for Windows). It should be an empty stream, or at least positioned + * at the start-of-file (in which case it is the caller's duty to + * truncate it on return). + * + * For this write function to be used, the chain must have been read with + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(), + * not FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(). + * Also, FLAC__metadata_chain_check_if_tempfile_needed() must have returned + * \c true. + * + * \param chain A pointer to an existing chain. + * \param use_padding See FLAC__metadata_chain_write() + * \param handle The I/O handle of the original FLAC stream to read. + * The handle will NOT be closed after the metadata is + * written; that is the duty of the caller. + * \param callbacks A set of callbacks to use for I/O on \a handle. + * The mandatory callbacks are \a read, \a seek, and + * \a eof. + * \param temp_handle The I/O handle of the FLAC stream to write. The + * handle will NOT be closed after the metadata is + * written; that is the duty of the caller. + * \param temp_callbacks + * A set of callbacks to use for I/O on temp_handle. + * The only mandatory callback is \a write. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if the write succeeded, else \c false. On failure, + * check the status with FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks_and_tempfile(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks, FLAC__IOHandle temp_handle, FLAC__IOCallbacks temp_callbacks); + +/** Merge adjacent PADDING blocks into a single block. + * + * \note This function does not write to the FLAC file, it only + * modifies the chain. + * + * \warning Any iterator on the current chain will become invalid after this + * call. You should delete the iterator and get a new one. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_chain_merge_padding(FLAC__Metadata_Chain *chain); + +/** This function will move all PADDING blocks to the end on the metadata, + * then merge them into a single block. + * + * \note This function does not write to the FLAC file, it only + * modifies the chain. + * + * \warning Any iterator on the current chain will become invalid after this + * call. You should delete the iterator and get a new one. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_chain_sort_padding(FLAC__Metadata_Chain *chain); + + +/*********** FLAC__Metadata_Iterator ***********/ + +/** Create a new iterator instance. + * + * \retval FLAC__Metadata_Iterator* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__Metadata_Iterator *FLAC__metadata_iterator_new(void); + +/** Free an iterator instance. Deletes the object pointed to by \a iterator. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + */ +FLAC_API void FLAC__metadata_iterator_delete(FLAC__Metadata_Iterator *iterator); + +/** Initialize the iterator to point to the first metadata block in the + * given chain. + * + * \param iterator A pointer to an existing iterator. + * \param chain A pointer to an existing and initialized (read) chain. + * \assert + * \code iterator != NULL \endcode + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_iterator_init(FLAC__Metadata_Iterator *iterator, FLAC__Metadata_Chain *chain); + +/** Moves the iterator forward one metadata block, returning \c false if + * already at the end. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if already at the last metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_next(FLAC__Metadata_Iterator *iterator); + +/** Moves the iterator backward one metadata block, returning \c false if + * already at the beginning. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if already at the first metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_prev(FLAC__Metadata_Iterator *iterator); + +/** Get the type of the metadata block at the current position. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__MetadataType + * The type of the metadata block at the current iterator position. + */ +FLAC_API FLAC__MetadataType FLAC__metadata_iterator_get_block_type(const FLAC__Metadata_Iterator *iterator); + +/** Get the metadata block at the current position. You can modify + * the block in place but must write the chain before the changes + * are reflected to the FLAC file. You do not need to call + * FLAC__metadata_iterator_set_block() to reflect the changes; + * the pointer returned by FLAC__metadata_iterator_get_block() + * points directly into the chain. + * + * \warning + * Do not call FLAC__metadata_object_delete() on the returned object; + * to delete a block use FLAC__metadata_iterator_delete_block(). + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__StreamMetadata* + * The current metadata block. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_iterator_get_block(FLAC__Metadata_Iterator *iterator); + +/** Set the metadata block at the current position, replacing the existing + * block. The new block passed in becomes owned by the chain and it will be + * deleted when the chain is deleted. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block A pointer to a metadata block. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \code block != NULL \endcode + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, or + * a memory allocation error occurs, otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_set_block(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block); + +/** Removes the current block from the chain. If \a replace_with_padding is + * \c true, the block will instead be replaced with a padding block of equal + * size. You can not delete the STREAMINFO block. The iterator will be + * left pointing to the block before the one just "deleted", even if + * \a replace_with_padding is \c true. + * + * \param iterator A pointer to an existing initialized iterator. + * \param replace_with_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, + * otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_delete_block(FLAC__Metadata_Iterator *iterator, FLAC__bool replace_with_padding); + +/** Insert a new block before the current block. You cannot insert a block + * before the first STREAMINFO block. You cannot insert a STREAMINFO block + * as there can be only one, the one that already exists at the head when you + * read in a chain. The chain takes ownership of the new block and it will be + * deleted when the chain is deleted. The iterator will be left pointing to + * the new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block A pointer to a metadata block to insert. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, or + * a memory allocation error occurs, otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_before(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block); + +/** Insert a new block after the current block. You cannot insert a STREAMINFO + * block as there can be only one, the one that already exists at the head when + * you read in a chain. The chain takes ownership of the new block and it will + * be deleted when the chain is deleted. The iterator will be left pointing to + * the new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block A pointer to a metadata block to insert. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, or + * a memory allocation error occurs, otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_after(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block); + +/* \} */ + + +/** \defgroup flac_metadata_object FLAC/metadata.h: metadata object methods + * \ingroup flac_metadata + * + * \brief + * This module contains methods for manipulating FLAC metadata objects. + * + * Since many are variable length we have to be careful about the memory + * management. We decree that all pointers to data in the object are + * owned by the object and memory-managed by the object. + * + * Use the FLAC__metadata_object_new() and FLAC__metadata_object_delete() + * functions to create all instances. When using the + * FLAC__metadata_object_set_*() functions to set pointers to data, set + * \a copy to \c true to have the function make it's own copy of the data, or + * to \c false to give the object ownership of your data. In the latter case + * your pointer must be freeable by free() and will be free()d when the object + * is FLAC__metadata_object_delete()d. It is legal to pass a null pointer as + * the data pointer to a FLAC__metadata_object_set_*() function as long as + * the length argument is 0 and the \a copy argument is \c false. + * + * The FLAC__metadata_object_new() and FLAC__metadata_object_clone() function + * will return \c NULL in the case of a memory allocation error, otherwise a new + * object. The FLAC__metadata_object_set_*() functions return \c false in the + * case of a memory allocation error. + * + * We don't have the convenience of C++ here, so note that the library relies + * on you to keep the types straight. In other words, if you pass, for + * example, a FLAC__StreamMetadata* that represents a STREAMINFO block to + * FLAC__metadata_object_application_set_data(), you will get an assertion + * failure. + * + * For convenience the FLAC__metadata_object_vorbiscomment_*() functions + * maintain a trailing NUL on each Vorbis comment entry. This is not counted + * toward the length or stored in the stream, but it can make working with plain + * comments (those that don't contain embedded-NULs in the value) easier. + * Entries passed into these functions have trailing NULs added if missing, and + * returned entries are guaranteed to have a trailing NUL. + * + * The FLAC__metadata_object_vorbiscomment_*() functions that take a Vorbis + * comment entry/name/value will first validate that it complies with the Vorbis + * comment specification and return false if it does not. + * + * There is no need to recalculate the length field on metadata blocks you + * have modified. They will be calculated automatically before they are + * written back to a file. + * + * \{ + */ + + +/** Create a new metadata object instance of the given type. + * + * The object will be "empty"; i.e. values and data pointers will be \c 0, + * with the exception of FLAC__METADATA_TYPE_VORBIS_COMMENT, which will have + * the vendor string set (but zero comments). + * + * Do not pass in a value greater than or equal to + * \a FLAC__METADATA_TYPE_UNDEFINED unless you really know what you're + * doing. + * + * \param type Type of object to create + * \retval FLAC__StreamMetadata* + * \c NULL if there was an error allocating memory or the type code is + * greater than FLAC__MAX_METADATA_TYPE_CODE, else the new instance. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_new(FLAC__MetadataType type); + +/** Create a copy of an existing metadata object. + * + * The copy is a "deep" copy, i.e. dynamically allocated data within the + * object is also copied. The caller takes ownership of the new block and + * is responsible for freeing it with FLAC__metadata_object_delete(). + * + * \param object Pointer to object to copy. + * \assert + * \code object != NULL \endcode + * \retval FLAC__StreamMetadata* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_clone(const FLAC__StreamMetadata *object); + +/** Free a metadata object. Deletes the object pointed to by \a object. + * + * The delete is a "deep" delete, i.e. dynamically allocated data within the + * object is also deleted. + * + * \param object A pointer to an existing object. + * \assert + * \code object != NULL \endcode + */ +FLAC_API void FLAC__metadata_object_delete(FLAC__StreamMetadata *object); + +/** Compares two metadata objects. + * + * The compare is "deep", i.e. dynamically allocated data within the + * object is also compared. + * + * \param block1 A pointer to an existing object. + * \param block2 A pointer to an existing object. + * \assert + * \code block1 != NULL \endcode + * \code block2 != NULL \endcode + * \retval FLAC__bool + * \c true if objects are identical, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_object_is_equal(const FLAC__StreamMetadata *block1, const FLAC__StreamMetadata *block2); + +/** Sets the application data of an APPLICATION block. + * + * If \a copy is \c true, a copy of the data is stored; otherwise, the object + * takes ownership of the pointer. The existing data will be freed if this + * function is successful, otherwise the original data will remain if \a copy + * is \c true and malloc() fails. + * + * \note It is safe to pass a const pointer to \a data if \a copy is \c true. + * + * \param object A pointer to an existing APPLICATION object. + * \param data A pointer to the data to set. + * \param length The length of \a data in bytes. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_APPLICATION \endcode + * \code (data != NULL && length > 0) || + * (data == NULL && length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, unsigned length, FLAC__bool copy); + +/** Resize the seekpoint array. + * + * If the size shrinks, elements will truncated; if it grows, new placeholder + * points will be added to the end. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param new_num_points The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code (object->data.seek_table.points == NULL && object->data.seek_table.num_points == 0) || + * (object->data.seek_table.points != NULL && object->data.seek_table.num_points > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMetadata *object, unsigned new_num_points); + +/** Set a seekpoint in a seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param point_num Index into seekpoint array to set. + * \param point The point to set. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code object->data.seek_table.num_points > point_num \endcode + */ +FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point); + +/** Insert a seekpoint into a seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param point_num Index into seekpoint array to set. + * \param point The point to set. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code object->data.seek_table.num_points >= point_num \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point); + +/** Delete a seekpoint from a seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param point_num Index into seekpoint array to set. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code object->data.seek_table.num_points > point_num \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_delete_point(FLAC__StreamMetadata *object, unsigned point_num); + +/** Check a seektable to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if seek table is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_is_legal(const FLAC__StreamMetadata *object); + +/** Append a number of placeholder points to the end of a seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param num The number of placeholder points to append. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_placeholders(FLAC__StreamMetadata *object, unsigned num); + +/** Append a specific seek point template to the end of a seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param sample_number The sample number of the seek point template. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_point(FLAC__StreamMetadata *object, FLAC__uint64 sample_number); + +/** Append specific seek point templates to the end of a seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param sample_numbers An array of sample numbers for the seek points. + * \param num The number of seek point templates to append. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC__StreamMetadata *object, FLAC__uint64 sample_numbers[], unsigned num); + +/** Append a set of evenly-spaced seek point templates to the end of a + * seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param num The number of placeholder points to append. + * \param total_samples The total number of samples to be encoded; + * the seekpoints will be spaced approximately + * \a total_samples / \a num samples apart. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code total_samples > 0 \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points(FLAC__StreamMetadata *object, unsigned num, FLAC__uint64 total_samples); + +/** Append a set of evenly-spaced seek point templates to the end of a + * seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param samples The number of samples apart to space the placeholder + * points. The first point will be at sample \c 0, the + * second at sample \a samples, then 2*\a samples, and + * so on. As long as \a samples and \a total_samples + * are greater than \c 0, there will always be at least + * one seekpoint at sample \c 0. + * \param total_samples The total number of samples to be encoded; + * the seekpoints will be spaced + * \a samples samples apart. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code samples > 0 \endcode + * \code total_samples > 0 \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(FLAC__StreamMetadata *object, unsigned samples, FLAC__uint64 total_samples); + +/** Sort a seek table's seek points according to the format specification, + * removing duplicates. + * + * \param object A pointer to a seek table to be sorted. + * \param compact If \c false, behaves like FLAC__format_seektable_sort(). + * If \c true, duplicates are deleted and the seek table is + * shrunk appropriately; the number of placeholder points + * present in the seek table will be the same after the call + * as before. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_sort(FLAC__StreamMetadata *object, FLAC__bool compact); + +/** Sets the vendor string in a VORBIS_COMMENT block. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param entry The entry to set the vendor string to. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_vendor_string(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Resize the comment array. + * + * If the size shrinks, elements will truncated; if it grows, new empty + * fields will be added to the end. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param new_num_comments The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (object->data.vorbis_comment.comments == NULL && object->data.vorbis_comment.num_comments == 0) || + * (object->data.vorbis_comment.comments != NULL && object->data.vorbis_comment.num_comments > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__StreamMetadata *object, unsigned new_num_comments); + +/** Sets a comment in a VORBIS_COMMENT block. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param comment_num Index into comment array to set. + * \param entry The entry to set the comment to. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code comment_num < object->data.vorbis_comment.num_comments \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Insert a comment in a VORBIS_COMMENT block at the given index. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param comment_num The index at which to insert the comment. The comments + * at and after \a comment_num move right one position. + * To append a comment to the end, set \a comment_num to + * \c object->data.vorbis_comment.num_comments . + * \param entry The comment to insert. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code object->data.vorbis_comment.num_comments >= comment_num \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_insert_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Appends a comment to a VORBIS_COMMENT block. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param entry The comment to insert. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_append_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Replaces comments in a VORBIS_COMMENT block with a new one. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * Depending on the the value of \a all, either all or just the first comment + * whose field name(s) match the given entry's name will be replaced by the + * given entry. If no comments match, \a entry will simply be appended. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param entry The comment to insert. + * \param all If \c true, all comments whose field name matches + * \a entry's field name will be removed, and \a entry will + * be inserted at the position of the first matching + * comment. If \c false, only the first comment whose + * field name matches \a entry's field name will be + * replaced with \a entry. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_replace_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool all, FLAC__bool copy); + +/** Delete a comment in a VORBIS_COMMENT block at the given index. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param comment_num The index of the comment to delete. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code object->data.vorbis_comment.num_comments > comment_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_delete_comment(FLAC__StreamMetadata *object, unsigned comment_num); + +/** Creates a Vorbis comment entry from NUL-terminated name and value strings. + * + * On return, the filled-in \a entry->entry pointer will point to malloc()ed + * memory and shall be owned by the caller. For convenience the entry will + * have a terminating NUL. + * + * \param entry A pointer to a Vorbis comment entry. The entry's + * \c entry pointer should not point to allocated + * memory as it will be overwritten. + * \param field_name The field name in ASCII, \c NUL terminated. + * \param field_value The field value in UTF-8, \c NUL terminated. + * \assert + * \code entry != NULL \endcode + * \code field_name != NULL \endcode + * \code field_value != NULL \endcode + * \retval FLAC__bool + * \c false if malloc() fails, or if \a field_name or \a field_value does + * not comply with the Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field_name, const char *field_value); + +/** Splits a Vorbis comment entry into NUL-terminated name and value strings. + * + * The returned pointers to name and value will be allocated by malloc() + * and shall be owned by the caller. + * + * \param entry An existing Vorbis comment entry. + * \param field_name The address of where the returned pointer to the + * field name will be stored. + * \param field_value The address of where the returned pointer to the + * field value will be stored. + * \assert + * \code (entry.entry != NULL && entry.length > 0) \endcode + * \code memchr(entry.entry, '=', entry.length) != NULL \endcode + * \code field_name != NULL \endcode + * \code field_value != NULL \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(const FLAC__StreamMetadata_VorbisComment_Entry entry, char **field_name, char **field_value); + +/** Check if the given Vorbis comment entry's field name matches the given + * field name. + * + * \param entry An existing Vorbis comment entry. + * \param field_name The field name to check. + * \param field_name_length The length of \a field_name, not including the + * terminating \c NUL. + * \assert + * \code (entry.entry != NULL && entry.length > 0) \endcode + * \retval FLAC__bool + * \c true if the field names match, else \c false + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC__StreamMetadata_VorbisComment_Entry entry, const char *field_name, unsigned field_name_length); + +/** Find a Vorbis comment with the given field name. + * + * The search begins at entry number \a offset; use an offset of 0 to + * search from the beginning of the comment array. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param offset The offset into the comment array from where to start + * the search. + * \param field_name The field name of the comment to find. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code field_name != NULL \endcode + * \retval int + * The offset in the comment array of the first comment whose field + * name matches \a field_name, or \c -1 if no match was found. + */ +FLAC_API int FLAC__metadata_object_vorbiscomment_find_entry_from(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name); + +/** Remove first Vorbis comment matching the given field name. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param field_name The field name of comment to delete. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \retval int + * \c -1 for memory allocation error, \c 0 for no matching entries, + * \c 1 for one matching entry deleted. + */ +FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entry_matching(FLAC__StreamMetadata *object, const char *field_name); + +/** Remove all Vorbis comments matching the given field name. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param field_name The field name of comments to delete. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \retval int + * \c -1 for memory allocation error, \c 0 for no matching entries, + * else the number of matching entries deleted. + */ +FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entries_matching(FLAC__StreamMetadata *object, const char *field_name); + +/** Create a new CUESHEET track instance. + * + * The object will be "empty"; i.e. values and data pointers will be \c 0. + * + * \retval FLAC__StreamMetadata_CueSheet_Track* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_new(void); + +/** Create a copy of an existing CUESHEET track object. + * + * The copy is a "deep" copy, i.e. dynamically allocated data within the + * object is also copied. The caller takes ownership of the new object and + * is responsible for freeing it with + * FLAC__metadata_object_cuesheet_track_delete(). + * + * \param object Pointer to object to copy. + * \assert + * \code object != NULL \endcode + * \retval FLAC__StreamMetadata_CueSheet_Track* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_clone(const FLAC__StreamMetadata_CueSheet_Track *object); + +/** Delete a CUESHEET track object + * + * \param object A pointer to an existing CUESHEET track object. + * \assert + * \code object != NULL \endcode + */ +FLAC_API void FLAC__metadata_object_cuesheet_track_delete(FLAC__StreamMetadata_CueSheet_Track *object); + +/** Resize a track's index point array. + * + * If the size shrinks, elements will truncated; if it grows, new blank + * indices will be added to the end. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index of the track to modify. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param new_num_indices The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code (object->data.cue_sheet.tracks[track_num].indices == NULL && object->data.cue_sheet.tracks[track_num].num_indices == 0) || + * (object->data.cue_sheet.tracks[track_num].indices != NULL && object->data.cue_sheet.tracks[track_num].num_indices > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__StreamMetadata *object, unsigned track_num, unsigned new_num_indices); + +/** Insert an index point in a CUESHEET track at the given index. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index of the track to modify. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param index_num The index into the track's index array at which to + * insert the index point. NOTE: this is not necessarily + * the same as the index point's \a number field. The + * indices at and after \a index_num move right one + * position. To append an index point to the end, set + * \a index_num to + * \c object->data.cue_sheet.tracks[track_num].num_indices . + * \param index The index point to insert. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code object->data.cue_sheet.tracks[track_num].num_indices >= index_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num, FLAC__StreamMetadata_CueSheet_Index index); + +/** Insert a blank index point in a CUESHEET track at the given index. + * + * A blank index point is one in which all field values are zero. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index of the track to modify. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param index_num The index into the track's index array at which to + * insert the index point. NOTE: this is not necessarily + * the same as the index point's \a number field. The + * indices at and after \a index_num move right one + * position. To append an index point to the end, set + * \a index_num to + * \c object->data.cue_sheet.tracks[track_num].num_indices . + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code object->data.cue_sheet.tracks[track_num].num_indices >= index_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num); + +/** Delete an index point in a CUESHEET track at the given index. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index into the track array of the track to + * modify. NOTE: this is not necessarily the same + * as the track's \a number field. + * \param index_num The index into the track's index array of the index + * to delete. NOTE: this is not necessarily the same + * as the index's \a number field. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code object->data.cue_sheet.tracks[track_num].num_indices > index_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num); + +/** Resize the track array. + * + * If the size shrinks, elements will truncated; if it grows, new blank + * tracks will be added to the end. + * + * \param object A pointer to an existing CUESHEET object. + * \param new_num_tracks The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code (object->data.cue_sheet.tracks == NULL && object->data.cue_sheet.num_tracks == 0) || + * (object->data.cue_sheet.tracks != NULL && object->data.cue_sheet.num_tracks > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMetadata *object, unsigned new_num_tracks); + +/** Sets a track in a CUESHEET block. + * + * If \a copy is \c true, a copy of the track is stored; otherwise, the object + * takes ownership of the \a track pointer. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num Index into track array to set. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param track The track to set the track to. You may safely pass in + * a const pointer if \a copy is \c true. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code track_num < object->data.cue_sheet.num_tracks \endcode + * \code (track->indices != NULL && track->num_indices > 0) || + * (track->indices == NULL && track->num_indices == 0) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy); + +/** Insert a track in a CUESHEET block at the given index. + * + * If \a copy is \c true, a copy of the track is stored; otherwise, the object + * takes ownership of the \a track pointer. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index at which to insert the track. NOTE: this + * is not necessarily the same as the track's \a number + * field. The tracks at and after \a track_num move right + * one position. To append a track to the end, set + * \a track_num to \c object->data.cue_sheet.num_tracks . + * \param track The track to insert. You may safely pass in a const + * pointer if \a copy is \c true. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks >= track_num \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy); + +/** Insert a blank track in a CUESHEET block at the given index. + * + * A blank track is one in which all field values are zero. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index at which to insert the track. NOTE: this + * is not necessarily the same as the track's \a number + * field. The tracks at and after \a track_num move right + * one position. To append a track to the end, set + * \a track_num to \c object->data.cue_sheet.num_tracks . + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks >= track_num \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__StreamMetadata *object, unsigned track_num); + +/** Delete a track in a CUESHEET block at the given index. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index into the track array of the track to + * delete. NOTE: this is not necessarily the same + * as the track's \a number field. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_delete_track(FLAC__StreamMetadata *object, unsigned track_num); + +/** Check a cue sheet to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * cue sheet. + * + * \param object A pointer to an existing CUESHEET object. + * \param check_cd_da_subset If \c true, check CUESHEET against more + * stringent requirements for a CD-DA (audio) disc. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \retval FLAC__bool + * \c false if cue sheet is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_is_legal(const FLAC__StreamMetadata *object, FLAC__bool check_cd_da_subset, const char **violation); + +/** Calculate and return the CDDB/freedb ID for a cue sheet. The function + * assumes the cue sheet corresponds to a CD; the result is undefined + * if the cuesheet's is_cd bit is not set. + * + * \param object A pointer to an existing CUESHEET object. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \retval FLAC__uint32 + * The unsigned integer representation of the CDDB/freedb ID + */ +FLAC_API FLAC__uint32 FLAC__metadata_object_cuesheet_calculate_cddb_id(const FLAC__StreamMetadata *object); + +/** Sets the MIME type of a PICTURE block. + * + * If \a copy is \c true, a copy of the string is stored; otherwise, the object + * takes ownership of the pointer. The existing string will be freed if this + * function is successful, otherwise the original string will remain if \a copy + * is \c true and malloc() fails. + * + * \note It is safe to pass a const pointer to \a mime_type if \a copy is \c true. + * + * \param object A pointer to an existing PICTURE object. + * \param mime_type A pointer to the MIME type string. The string must be + * ASCII characters 0x20-0x7e, NUL-terminated. No validation + * is done. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \code (mime_type != NULL) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_set_mime_type(FLAC__StreamMetadata *object, char *mime_type, FLAC__bool copy); + +/** Sets the description of a PICTURE block. + * + * If \a copy is \c true, a copy of the string is stored; otherwise, the object + * takes ownership of the pointer. The existing string will be freed if this + * function is successful, otherwise the original string will remain if \a copy + * is \c true and malloc() fails. + * + * \note It is safe to pass a const pointer to \a description if \a copy is \c true. + * + * \param object A pointer to an existing PICTURE object. + * \param description A pointer to the description string. The string must be + * valid UTF-8, NUL-terminated. No validation is done. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \code (description != NULL) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_set_description(FLAC__StreamMetadata *object, FLAC__byte *description, FLAC__bool copy); + +/** Sets the picture data of a PICTURE block. + * + * If \a copy is \c true, a copy of the data is stored; otherwise, the object + * takes ownership of the pointer. Also sets the \a data_length field of the + * metadata object to what is passed in as the \a length parameter. The + * existing data will be freed if this function is successful, otherwise the + * original data and data_length will remain if \a copy is \c true and + * malloc() fails. + * + * \note It is safe to pass a const pointer to \a data if \a copy is \c true. + * + * \param object A pointer to an existing PICTURE object. + * \param data A pointer to the data to set. + * \param length The length of \a data in bytes. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \code (data != NULL && length > 0) || + * (data == NULL && length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, FLAC__uint32 length, FLAC__bool copy); + +/** Check a PICTURE block to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * PICTURE block. + * + * \param object A pointer to existing PICTURE block to be checked. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \retval FLAC__bool + * \c false if PICTURE block is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_is_legal(const FLAC__StreamMetadata *object, const char **violation); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/MacOSX/codecs/include/FLAC/ordinals.h b/quakespasm/MacOSX/codecs/include/FLAC/ordinals.h new file mode 100644 index 00000000..a0572997 --- /dev/null +++ b/quakespasm/MacOSX/codecs/include/FLAC/ordinals.h @@ -0,0 +1,86 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__ORDINALS_H +#define FLAC__ORDINALS_H + +#if defined(_MSC_VER) && _MSC_VER < 1600 + +/* Microsoft Visual Studio earlier than the 2010 version did not provide + * the 1999 ISO C Standard header file . + */ + +typedef __int8 FLAC__int8; +typedef unsigned __int8 FLAC__uint8; + +typedef __int16 FLAC__int16; +typedef __int32 FLAC__int32; +typedef __int64 FLAC__int64; +typedef unsigned __int16 FLAC__uint16; +typedef unsigned __int32 FLAC__uint32; +typedef unsigned __int64 FLAC__uint64; + +#else + +/* For MSVC 2010 and everything else which provides . */ + +#include + +typedef int8_t FLAC__int8; +typedef uint8_t FLAC__uint8; + +typedef int16_t FLAC__int16; +typedef int32_t FLAC__int32; +typedef int64_t FLAC__int64; +typedef uint16_t FLAC__uint16; +typedef uint32_t FLAC__uint32; +typedef uint64_t FLAC__uint64; + +#endif + +typedef int FLAC__bool; + +typedef FLAC__uint8 FLAC__byte; + + +#ifdef true +#undef true +#endif +#ifdef false +#undef false +#endif +#ifndef __cplusplus +#define true 1 +#define false 0 +#endif + +#endif diff --git a/quakespasm/MacOSX/codecs/include/FLAC/stream_decoder.h b/quakespasm/MacOSX/codecs/include/FLAC/stream_decoder.h new file mode 100644 index 00000000..152643fc --- /dev/null +++ b/quakespasm/MacOSX/codecs/include/FLAC/stream_decoder.h @@ -0,0 +1,1560 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__STREAM_DECODER_H +#define FLAC__STREAM_DECODER_H + +#include /* for FILE */ +#include "export.h" +#include "format.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** \file include/FLAC/stream_decoder.h + * + * \brief + * This module contains the functions which implement the stream + * decoder. + * + * See the detailed documentation in the + * \link flac_stream_decoder stream decoder \endlink module. + */ + +/** \defgroup flac_decoder FLAC/ \*_decoder.h: decoder interfaces + * \ingroup flac + * + * \brief + * This module describes the decoder layers provided by libFLAC. + * + * The stream decoder can be used to decode complete streams either from + * the client via callbacks, or directly from a file, depending on how + * it is initialized. When decoding via callbacks, the client provides + * callbacks for reading FLAC data and writing decoded samples, and + * handling metadata and errors. If the client also supplies seek-related + * callback, the decoder function for sample-accurate seeking within the + * FLAC input is also available. When decoding from a file, the client + * needs only supply a filename or open \c FILE* and write/metadata/error + * callbacks; the rest of the callbacks are supplied internally. For more + * info see the \link flac_stream_decoder stream decoder \endlink module. + */ + +/** \defgroup flac_stream_decoder FLAC/stream_decoder.h: stream decoder interface + * \ingroup flac_decoder + * + * \brief + * This module contains the functions which implement the stream + * decoder. + * + * The stream decoder can decode native FLAC, and optionally Ogg FLAC + * (check FLAC_API_SUPPORTS_OGG_FLAC) streams and files. + * + * The basic usage of this decoder is as follows: + * - The program creates an instance of a decoder using + * FLAC__stream_decoder_new(). + * - The program overrides the default settings using + * FLAC__stream_decoder_set_*() functions. + * - The program initializes the instance to validate the settings and + * prepare for decoding using + * - FLAC__stream_decoder_init_stream() or FLAC__stream_decoder_init_FILE() + * or FLAC__stream_decoder_init_file() for native FLAC, + * - FLAC__stream_decoder_init_ogg_stream() or FLAC__stream_decoder_init_ogg_FILE() + * or FLAC__stream_decoder_init_ogg_file() for Ogg FLAC + * - The program calls the FLAC__stream_decoder_process_*() functions + * to decode data, which subsequently calls the callbacks. + * - The program finishes the decoding with FLAC__stream_decoder_finish(), + * which flushes the input and output and resets the decoder to the + * uninitialized state. + * - The instance may be used again or deleted with + * FLAC__stream_decoder_delete(). + * + * In more detail, the program will create a new instance by calling + * FLAC__stream_decoder_new(), then call FLAC__stream_decoder_set_*() + * functions to override the default decoder options, and call + * one of the FLAC__stream_decoder_init_*() functions. + * + * There are three initialization functions for native FLAC, one for + * setting up the decoder to decode FLAC data from the client via + * callbacks, and two for decoding directly from a FLAC file. + * + * For decoding via callbacks, use FLAC__stream_decoder_init_stream(). + * You must also supply several callbacks for handling I/O. Some (like + * seeking) are optional, depending on the capabilities of the input. + * + * For decoding directly from a file, use FLAC__stream_decoder_init_FILE() + * or FLAC__stream_decoder_init_file(). Then you must only supply an open + * \c FILE* or filename and fewer callbacks; the decoder will handle + * the other callbacks internally. + * + * There are three similarly-named init functions for decoding from Ogg + * FLAC streams. Check \c FLAC_API_SUPPORTS_OGG_FLAC to find out if the + * library has been built with Ogg support. + * + * Once the decoder is initialized, your program will call one of several + * functions to start the decoding process: + * + * - FLAC__stream_decoder_process_single() - Tells the decoder to process at + * most one metadata block or audio frame and return, calling either the + * metadata callback or write callback, respectively, once. If the decoder + * loses sync it will return with only the error callback being called. + * - FLAC__stream_decoder_process_until_end_of_metadata() - Tells the decoder + * to process the stream from the current location and stop upon reaching + * the first audio frame. The client will get one metadata, write, or error + * callback per metadata block, audio frame, or sync error, respectively. + * - FLAC__stream_decoder_process_until_end_of_stream() - Tells the decoder + * to process the stream from the current location until the read callback + * returns FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM or + * FLAC__STREAM_DECODER_READ_STATUS_ABORT. The client will get one metadata, + * write, or error callback per metadata block, audio frame, or sync error, + * respectively. + * + * When the decoder has finished decoding (normally or through an abort), + * the instance is finished by calling FLAC__stream_decoder_finish(), which + * ensures the decoder is in the correct state and frees memory. Then the + * instance may be deleted with FLAC__stream_decoder_delete() or initialized + * again to decode another stream. + * + * Seeking is exposed through the FLAC__stream_decoder_seek_absolute() method. + * At any point after the stream decoder has been initialized, the client can + * call this function to seek to an exact sample within the stream. + * Subsequently, the first time the write callback is called it will be + * passed a (possibly partial) block starting at that sample. + * + * If the client cannot seek via the callback interface provided, but still + * has another way of seeking, it can flush the decoder using + * FLAC__stream_decoder_flush() and start feeding data from the new position + * through the read callback. + * + * The stream decoder also provides MD5 signature checking. If this is + * turned on before initialization, FLAC__stream_decoder_finish() will + * report when the decoded MD5 signature does not match the one stored + * in the STREAMINFO block. MD5 checking is automatically turned off + * (until the next FLAC__stream_decoder_reset()) if there is no signature + * in the STREAMINFO block or when a seek is attempted. + * + * The FLAC__stream_decoder_set_metadata_*() functions deserve special + * attention. By default, the decoder only calls the metadata_callback for + * the STREAMINFO block. These functions allow you to tell the decoder + * explicitly which blocks to parse and return via the metadata_callback + * and/or which to skip. Use a FLAC__stream_decoder_set_metadata_respond_all(), + * FLAC__stream_decoder_set_metadata_ignore() ... or FLAC__stream_decoder_set_metadata_ignore_all(), + * FLAC__stream_decoder_set_metadata_respond() ... sequence to exactly specify + * which blocks to return. Remember that metadata blocks can potentially + * be big (for example, cover art) so filtering out the ones you don't + * use can reduce the memory requirements of the decoder. Also note the + * special forms FLAC__stream_decoder_set_metadata_respond_application(id) + * and FLAC__stream_decoder_set_metadata_ignore_application(id) for + * filtering APPLICATION blocks based on the application ID. + * + * STREAMINFO and SEEKTABLE blocks are always parsed and used internally, but + * they still can legally be filtered from the metadata_callback. + * + * \note + * The "set" functions may only be called when the decoder is in the + * state FLAC__STREAM_DECODER_UNINITIALIZED, i.e. after + * FLAC__stream_decoder_new() or FLAC__stream_decoder_finish(), but + * before FLAC__stream_decoder_init_*(). If this is the case they will + * return \c true, otherwise \c false. + * + * \note + * FLAC__stream_decoder_finish() resets all settings to the constructor + * defaults, including the callbacks. + * + * \{ + */ + + +/** State values for a FLAC__StreamDecoder + * + * The decoder's state can be obtained by calling FLAC__stream_decoder_get_state(). + */ +typedef enum { + + FLAC__STREAM_DECODER_SEARCH_FOR_METADATA = 0, + /**< The decoder is ready to search for metadata. */ + + FLAC__STREAM_DECODER_READ_METADATA, + /**< The decoder is ready to or is in the process of reading metadata. */ + + FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC, + /**< The decoder is ready to or is in the process of searching for the + * frame sync code. + */ + + FLAC__STREAM_DECODER_READ_FRAME, + /**< The decoder is ready to or is in the process of reading a frame. */ + + FLAC__STREAM_DECODER_END_OF_STREAM, + /**< The decoder has reached the end of the stream. */ + + FLAC__STREAM_DECODER_OGG_ERROR, + /**< An error occurred in the underlying Ogg layer. */ + + FLAC__STREAM_DECODER_SEEK_ERROR, + /**< An error occurred while seeking. The decoder must be flushed + * with FLAC__stream_decoder_flush() or reset with + * FLAC__stream_decoder_reset() before decoding can continue. + */ + + FLAC__STREAM_DECODER_ABORTED, + /**< The decoder was aborted by the read callback. */ + + FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR, + /**< An error occurred allocating memory. The decoder is in an invalid + * state and can no longer be used. + */ + + FLAC__STREAM_DECODER_UNINITIALIZED + /**< The decoder is in the uninitialized state; one of the + * FLAC__stream_decoder_init_*() functions must be called before samples + * can be processed. + */ + +} FLAC__StreamDecoderState; + +/** Maps a FLAC__StreamDecoderState to a C string. + * + * Using a FLAC__StreamDecoderState as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderStateString[]; + + +/** Possible return values for the FLAC__stream_decoder_init_*() functions. + */ +typedef enum { + + FLAC__STREAM_DECODER_INIT_STATUS_OK = 0, + /**< Initialization was successful. */ + + FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER, + /**< The library was not compiled with support for the given container + * format. + */ + + FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS, + /**< A required callback was not supplied. */ + + FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR, + /**< An error occurred allocating memory. */ + + FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE, + /**< fopen() failed in FLAC__stream_decoder_init_file() or + * FLAC__stream_decoder_init_ogg_file(). */ + + FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED + /**< FLAC__stream_decoder_init_*() was called when the decoder was + * already initialized, usually because + * FLAC__stream_decoder_finish() was not called. + */ + +} FLAC__StreamDecoderInitStatus; + +/** Maps a FLAC__StreamDecoderInitStatus to a C string. + * + * Using a FLAC__StreamDecoderInitStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderInitStatusString[]; + + +/** Return values for the FLAC__StreamDecoder read callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_READ_STATUS_CONTINUE, + /**< The read was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM, + /**< The read was attempted while at the end of the stream. Note that + * the client must only return this value when the read callback was + * called when already at the end of the stream. Otherwise, if the read + * itself moves to the end of the stream, the client should still return + * the data and \c FLAC__STREAM_DECODER_READ_STATUS_CONTINUE, and then on + * the next read callback it should return + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM with a byte count + * of \c 0. + */ + + FLAC__STREAM_DECODER_READ_STATUS_ABORT + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + +} FLAC__StreamDecoderReadStatus; + +/** Maps a FLAC__StreamDecoderReadStatus to a C string. + * + * Using a FLAC__StreamDecoderReadStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderReadStatusString[]; + + +/** Return values for the FLAC__StreamDecoder seek callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_SEEK_STATUS_OK, + /**< The seek was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_SEEK_STATUS_ERROR, + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + + FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED + /**< Client does not support seeking. */ + +} FLAC__StreamDecoderSeekStatus; + +/** Maps a FLAC__StreamDecoderSeekStatus to a C string. + * + * Using a FLAC__StreamDecoderSeekStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderSeekStatusString[]; + + +/** Return values for the FLAC__StreamDecoder tell callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_TELL_STATUS_OK, + /**< The tell was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_TELL_STATUS_ERROR, + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + + FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED + /**< Client does not support telling the position. */ + +} FLAC__StreamDecoderTellStatus; + +/** Maps a FLAC__StreamDecoderTellStatus to a C string. + * + * Using a FLAC__StreamDecoderTellStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderTellStatusString[]; + + +/** Return values for the FLAC__StreamDecoder length callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_LENGTH_STATUS_OK, + /**< The length call was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR, + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + + FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED + /**< Client does not support reporting the length. */ + +} FLAC__StreamDecoderLengthStatus; + +/** Maps a FLAC__StreamDecoderLengthStatus to a C string. + * + * Using a FLAC__StreamDecoderLengthStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderLengthStatusString[]; + + +/** Return values for the FLAC__StreamDecoder write callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE, + /**< The write was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_WRITE_STATUS_ABORT + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + +} FLAC__StreamDecoderWriteStatus; + +/** Maps a FLAC__StreamDecoderWriteStatus to a C string. + * + * Using a FLAC__StreamDecoderWriteStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderWriteStatusString[]; + + +/** Possible values passed back to the FLAC__StreamDecoder error callback. + * \c FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC is the generic catch- + * all. The rest could be caused by bad sync (false synchronization on + * data that is not the start of a frame) or corrupted data. The error + * itself is the decoder's best guess at what happened assuming a correct + * sync. For example \c FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER + * could be caused by a correct sync on the start of a frame, but some + * data in the frame header was corrupted. Or it could be the result of + * syncing on a point the stream that looked like the starting of a frame + * but was not. \c FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM + * could be because the decoder encountered a valid frame made by a future + * version of the encoder which it cannot parse, or because of a false + * sync making it appear as though an encountered frame was generated by + * a future encoder. + */ +typedef enum { + + FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC, + /**< An error in the stream caused the decoder to lose synchronization. */ + + FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER, + /**< The decoder encountered a corrupted frame header. */ + + FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH, + /**< The frame's data did not match the CRC in the footer. */ + + FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM + /**< The decoder encountered reserved fields in use in the stream. */ + +} FLAC__StreamDecoderErrorStatus; + +/** Maps a FLAC__StreamDecoderErrorStatus to a C string. + * + * Using a FLAC__StreamDecoderErrorStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderErrorStatusString[]; + + +/*********************************************************************** + * + * class FLAC__StreamDecoder + * + ***********************************************************************/ + +struct FLAC__StreamDecoderProtected; +struct FLAC__StreamDecoderPrivate; +/** The opaque structure definition for the stream decoder type. + * See the \link flac_stream_decoder stream decoder module \endlink + * for a detailed description. + */ +typedef struct { + struct FLAC__StreamDecoderProtected *protected_; /* avoid the C++ keyword 'protected' */ + struct FLAC__StreamDecoderPrivate *private_; /* avoid the C++ keyword 'private' */ +} FLAC__StreamDecoder; + +/** Signature for the read callback. + * + * A function pointer matching this signature must be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder needs more input data. The address of the + * buffer to be filled is supplied, along with the number of bytes the + * buffer can hold. The callback may choose to supply less data and + * modify the byte count but must be careful not to overflow the buffer. + * The callback then returns a status code chosen from + * FLAC__StreamDecoderReadStatus. + * + * Here is an example of a read callback for stdio streams: + * \code + * FLAC__StreamDecoderReadStatus read_cb(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(*bytes > 0) { + * *bytes = fread(buffer, sizeof(FLAC__byte), *bytes, file); + * if(ferror(file)) + * return FLAC__STREAM_DECODER_READ_STATUS_ABORT; + * else if(*bytes == 0) + * return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM; + * else + * return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; + * } + * else + * return FLAC__STREAM_DECODER_READ_STATUS_ABORT; + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param buffer A pointer to a location for the callee to store + * data to be decoded. + * \param bytes A pointer to the size of the buffer. On entry + * to the callback, it contains the maximum number + * of bytes that may be stored in \a buffer. The + * callee must set it to the actual number of bytes + * stored (0 in case of error or end-of-stream) before + * returning. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderReadStatus + * The callee's return status. Note that the callback should return + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM if and only if + * zero bytes were read and there is no more data to be read. + */ +typedef FLAC__StreamDecoderReadStatus (*FLAC__StreamDecoderReadCallback)(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data); + +/** Signature for the seek callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder needs to seek the input stream. The decoder + * will pass the absolute byte offset to seek to, 0 meaning the + * beginning of the stream. + * + * Here is an example of a seek callback for stdio streams: + * \code + * FLAC__StreamDecoderSeekStatus seek_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(file == stdin) + * return FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED; + * else if(fseeko(file, (off_t)absolute_byte_offset, SEEK_SET) < 0) + * return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR; + * else + * return FLAC__STREAM_DECODER_SEEK_STATUS_OK; + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param absolute_byte_offset The offset from the beginning of the stream + * to seek to. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderSeekStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderSeekStatus (*FLAC__StreamDecoderSeekCallback)(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data); + +/** Signature for the tell callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder wants to know the current position of the + * stream. The callback should return the byte offset from the + * beginning of the stream. + * + * Here is an example of a tell callback for stdio streams: + * \code + * FLAC__StreamDecoderTellStatus tell_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * off_t pos; + * if(file == stdin) + * return FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED; + * else if((pos = ftello(file)) < 0) + * return FLAC__STREAM_DECODER_TELL_STATUS_ERROR; + * else { + * *absolute_byte_offset = (FLAC__uint64)pos; + * return FLAC__STREAM_DECODER_TELL_STATUS_OK; + * } + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param absolute_byte_offset A pointer to storage for the current offset + * from the beginning of the stream. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderTellStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderTellStatus (*FLAC__StreamDecoderTellCallback)(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data); + +/** Signature for the length callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder wants to know the total length of the stream + * in bytes. + * + * Here is an example of a length callback for stdio streams: + * \code + * FLAC__StreamDecoderLengthStatus length_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * struct stat filestats; + * + * if(file == stdin) + * return FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED; + * else if(fstat(fileno(file), &filestats) != 0) + * return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR; + * else { + * *stream_length = (FLAC__uint64)filestats.st_size; + * return FLAC__STREAM_DECODER_LENGTH_STATUS_OK; + * } + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param stream_length A pointer to storage for the length of the stream + * in bytes. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderLengthStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderLengthStatus (*FLAC__StreamDecoderLengthCallback)(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data); + +/** Signature for the EOF callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder needs to know if the end of the stream has + * been reached. + * + * Here is an example of a EOF callback for stdio streams: + * FLAC__bool eof_cb(const FLAC__StreamDecoder *decoder, void *client_data) + * \code + * { + * FILE *file = ((MyClientData*)client_data)->file; + * return feof(file)? true : false; + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__bool + * \c true if the currently at the end of the stream, else \c false. + */ +typedef FLAC__bool (*FLAC__StreamDecoderEofCallback)(const FLAC__StreamDecoder *decoder, void *client_data); + +/** Signature for the write callback. + * + * A function pointer matching this signature must be passed to one of + * the FLAC__stream_decoder_init_*() functions. + * The supplied function will be called when the decoder has decoded a + * single audio frame. The decoder will pass the frame metadata as well + * as an array of pointers (one for each channel) pointing to the + * decoded audio. + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param frame The description of the decoded frame. See + * FLAC__Frame. + * \param buffer An array of pointers to decoded channels of data. + * Each pointer will point to an array of signed + * samples of length \a frame->header.blocksize. + * Channels will be ordered according to the FLAC + * specification; see the documentation for the + * frame header. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderWriteStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderWriteStatus (*FLAC__StreamDecoderWriteCallback)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data); + +/** Signature for the metadata callback. + * + * A function pointer matching this signature must be passed to one of + * the FLAC__stream_decoder_init_*() functions. + * The supplied function will be called when the decoder has decoded a + * metadata block. In a valid FLAC file there will always be one + * \c STREAMINFO block, followed by zero or more other metadata blocks. + * These will be supplied by the decoder in the same order as they + * appear in the stream and always before the first audio frame (i.e. + * write callback). The metadata block that is passed in must not be + * modified, and it doesn't live beyond the callback, so you should make + * a copy of it with FLAC__metadata_object_clone() if you will need it + * elsewhere. Since metadata blocks can potentially be large, by + * default the decoder only calls the metadata callback for the + * \c STREAMINFO block; you can instruct the decoder to pass or filter + * other blocks with FLAC__stream_decoder_set_metadata_*() calls. + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param metadata The decoded metadata block. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + */ +typedef void (*FLAC__StreamDecoderMetadataCallback)(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data); + +/** Signature for the error callback. + * + * A function pointer matching this signature must be passed to one of + * the FLAC__stream_decoder_init_*() functions. + * The supplied function will be called whenever an error occurs during + * decoding. + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param status The error encountered by the decoder. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + */ +typedef void (*FLAC__StreamDecoderErrorCallback)(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data); + + +/*********************************************************************** + * + * Class constructor/destructor + * + ***********************************************************************/ + +/** Create a new stream decoder instance. The instance is created with + * default settings; see the individual FLAC__stream_decoder_set_*() + * functions for each setting's default. + * + * \retval FLAC__StreamDecoder* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamDecoder *FLAC__stream_decoder_new(void); + +/** Free a decoder instance. Deletes the object pointed to by \a decoder. + * + * \param decoder A pointer to an existing decoder. + * \assert + * \code decoder != NULL \endcode + */ +FLAC_API void FLAC__stream_decoder_delete(FLAC__StreamDecoder *decoder); + + +/*********************************************************************** + * + * Public class method prototypes + * + ***********************************************************************/ + +/** Set the serial number for the FLAC stream within the Ogg container. + * The default behavior is to use the serial number of the first Ogg + * page. Setting a serial number here will explicitly specify which + * stream is to be decoded. + * + * \note + * This does not need to be set for native FLAC decoding. + * + * \default \c use serial number of first page + * \param decoder A decoder instance to set. + * \param serial_number See above. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_ogg_serial_number(FLAC__StreamDecoder *decoder, long serial_number); + +/** Set the "MD5 signature checking" flag. If \c true, the decoder will + * compute the MD5 signature of the unencoded audio data while decoding + * and compare it to the signature from the STREAMINFO block, if it + * exists, during FLAC__stream_decoder_finish(). + * + * MD5 signature checking will be turned off (until the next + * FLAC__stream_decoder_reset()) if there is no signature in the + * STREAMINFO block or when a seek is attempted. + * + * Clients that do not use the MD5 check should leave this off to speed + * up decoding. + * + * \default \c false + * \param decoder A decoder instance to set. + * \param value Flag value (see above). + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_md5_checking(FLAC__StreamDecoder *decoder, FLAC__bool value); + +/** Direct the decoder to pass on all metadata blocks of type \a type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param type See above. + * \assert + * \code decoder != NULL \endcode + * \a type is valid + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond(FLAC__StreamDecoder *decoder, FLAC__MetadataType type); + +/** Direct the decoder to pass on all APPLICATION metadata blocks of the + * given \a id. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param id See above. + * \assert + * \code decoder != NULL \endcode + * \code id != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond_application(FLAC__StreamDecoder *decoder, const FLAC__byte id[4]); + +/** Direct the decoder to pass on all metadata blocks of any type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond_all(FLAC__StreamDecoder *decoder); + +/** Direct the decoder to filter out all metadata blocks of type \a type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param type See above. + * \assert + * \code decoder != NULL \endcode + * \a type is valid + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore(FLAC__StreamDecoder *decoder, FLAC__MetadataType type); + +/** Direct the decoder to filter out all APPLICATION metadata blocks of + * the given \a id. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param id See above. + * \assert + * \code decoder != NULL \endcode + * \code id != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore_application(FLAC__StreamDecoder *decoder, const FLAC__byte id[4]); + +/** Direct the decoder to filter out all metadata blocks of any type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore_all(FLAC__StreamDecoder *decoder); + +/** Get the current decoder state. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderState + * The current decoder state. + */ +FLAC_API FLAC__StreamDecoderState FLAC__stream_decoder_get_state(const FLAC__StreamDecoder *decoder); + +/** Get the current decoder state as a C string. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval const char * + * The decoder state as a C string. Do not modify the contents. + */ +FLAC_API const char *FLAC__stream_decoder_get_resolved_state_string(const FLAC__StreamDecoder *decoder); + +/** Get the "MD5 signature checking" flag. + * This is the value of the setting, not whether or not the decoder is + * currently checking the MD5 (remember, it can be turned off automatically + * by a seek). When the decoder is reset the flag will be restored to the + * value returned by this function. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * See above. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_get_md5_checking(const FLAC__StreamDecoder *decoder); + +/** Get the total number of samples in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the \c STREAMINFO block. A value of \c 0 means "unknown". + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API FLAC__uint64 FLAC__stream_decoder_get_total_samples(const FLAC__StreamDecoder *decoder); + +/** Get the current number of channels in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API unsigned FLAC__stream_decoder_get_channels(const FLAC__StreamDecoder *decoder); + +/** Get the current channel assignment in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__ChannelAssignment + * See above. + */ +FLAC_API FLAC__ChannelAssignment FLAC__stream_decoder_get_channel_assignment(const FLAC__StreamDecoder *decoder); + +/** Get the current sample resolution in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API unsigned FLAC__stream_decoder_get_bits_per_sample(const FLAC__StreamDecoder *decoder); + +/** Get the current sample rate in Hz of the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API unsigned FLAC__stream_decoder_get_sample_rate(const FLAC__StreamDecoder *decoder); + +/** Get the current blocksize of the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API unsigned FLAC__stream_decoder_get_blocksize(const FLAC__StreamDecoder *decoder); + +/** Returns the decoder's current read position within the stream. + * The position is the byte offset from the start of the stream. + * Bytes before this position have been fully decoded. Note that + * there may still be undecoded bytes in the decoder's read FIFO. + * The returned position is correct even after a seek. + * + * \warning This function currently only works for native FLAC, + * not Ogg FLAC streams. + * + * \param decoder A decoder instance to query. + * \param position Address at which to return the desired position. + * \assert + * \code decoder != NULL \endcode + * \code position != NULL \endcode + * \retval FLAC__bool + * \c true if successful, \c false if the stream is not native FLAC, + * or there was an error from the 'tell' callback or it returned + * \c FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_get_decode_position(const FLAC__StreamDecoder *decoder, FLAC__uint64 *position); + +/** Initialize the decoder instance to decode native FLAC streams. + * + * This flavor of initialization sets up the decoder to decode from a + * native FLAC stream. I/O is performed via callbacks to the client. + * For decoding from a plain file via filename or open FILE*, + * FLAC__stream_decoder_init_file() and FLAC__stream_decoder_init_FILE() + * provide a simpler interface. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \param decoder An uninitialized decoder instance. + * \param read_callback See FLAC__StreamDecoderReadCallback. This + * pointer must not be \c NULL. + * \param seek_callback See FLAC__StreamDecoderSeekCallback. This + * pointer may be \c NULL if seeking is not + * supported. If \a seek_callback is not \c NULL then a + * \a tell_callback, \a length_callback, and \a eof_callback must also be supplied. + * Alternatively, a dummy seek callback that just + * returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param tell_callback See FLAC__StreamDecoderTellCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a tell_callback must also be supplied. + * Alternatively, a dummy tell callback that just + * returns \c FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param length_callback See FLAC__StreamDecoderLengthCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a length_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param eof_callback See FLAC__StreamDecoderEofCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a eof_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c false + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_stream( + FLAC__StreamDecoder *decoder, + FLAC__StreamDecoderReadCallback read_callback, + FLAC__StreamDecoderSeekCallback seek_callback, + FLAC__StreamDecoderTellCallback tell_callback, + FLAC__StreamDecoderLengthCallback length_callback, + FLAC__StreamDecoderEofCallback eof_callback, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode Ogg FLAC streams. + * + * This flavor of initialization sets up the decoder to decode from a + * FLAC stream in an Ogg container. I/O is performed via callbacks to the + * client. For decoding from a plain file via filename or open FILE*, + * FLAC__stream_decoder_init_ogg_file() and FLAC__stream_decoder_init_ogg_FILE() + * provide a simpler interface. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \note Support for Ogg FLAC in the library is optional. If this + * library has been built without support for Ogg FLAC, this function + * will return \c FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER. + * + * \param decoder An uninitialized decoder instance. + * \param read_callback See FLAC__StreamDecoderReadCallback. This + * pointer must not be \c NULL. + * \param seek_callback See FLAC__StreamDecoderSeekCallback. This + * pointer may be \c NULL if seeking is not + * supported. If \a seek_callback is not \c NULL then a + * \a tell_callback, \a length_callback, and \a eof_callback must also be supplied. + * Alternatively, a dummy seek callback that just + * returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param tell_callback See FLAC__StreamDecoderTellCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a tell_callback must also be supplied. + * Alternatively, a dummy tell callback that just + * returns \c FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param length_callback See FLAC__StreamDecoderLengthCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a length_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param eof_callback See FLAC__StreamDecoderEofCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a eof_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c false + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_stream( + FLAC__StreamDecoder *decoder, + FLAC__StreamDecoderReadCallback read_callback, + FLAC__StreamDecoderSeekCallback seek_callback, + FLAC__StreamDecoderTellCallback tell_callback, + FLAC__StreamDecoderLengthCallback length_callback, + FLAC__StreamDecoderEofCallback eof_callback, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode native FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a + * plain native FLAC file. For non-stdio streams, you must use + * FLAC__stream_decoder_init_stream() and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \param decoder An uninitialized decoder instance. + * \param file An open FLAC file. The file should have been + * opened with mode \c "rb" and rewound. The file + * becomes owned by the decoder and should not be + * manipulated by the client while decoding. + * Unless \a file is \c stdin, it will be closed + * when FLAC__stream_decoder_finish() is called. + * Note however that seeking will not work when + * decoding from \c stdout since it is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \code file != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_FILE( + FLAC__StreamDecoder *decoder, + FILE *file, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode Ogg FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a + * plain Ogg FLAC file. For non-stdio streams, you must use + * FLAC__stream_decoder_init_ogg_stream() and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \note Support for Ogg FLAC in the library is optional. If this + * library has been built without support for Ogg FLAC, this function + * will return \c FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER. + * + * \param decoder An uninitialized decoder instance. + * \param file An open FLAC file. The file should have been + * opened with mode \c "rb" and rewound. The file + * becomes owned by the decoder and should not be + * manipulated by the client while decoding. + * Unless \a file is \c stdin, it will be closed + * when FLAC__stream_decoder_finish() is called. + * Note however that seeking will not work when + * decoding from \c stdout since it is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \code file != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_FILE( + FLAC__StreamDecoder *decoder, + FILE *file, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode native FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a plain + * native FLAC file. If POSIX fopen() semantics are not sufficient, (for + * example, with Unicode filenames on Windows), you must use + * FLAC__stream_decoder_init_FILE(), or FLAC__stream_decoder_init_stream() + * and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \param decoder An uninitialized decoder instance. + * \param filename The name of the file to decode from. The file will + * be opened with fopen(). Use \c NULL to decode from + * \c stdin. Note that \c stdin is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_file( + FLAC__StreamDecoder *decoder, + const char *filename, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode Ogg FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a plain + * Ogg FLAC file. If POSIX fopen() semantics are not sufficient, (for + * example, with Unicode filenames on Windows), you must use + * FLAC__stream_decoder_init_ogg_FILE(), or FLAC__stream_decoder_init_ogg_stream() + * and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \note Support for Ogg FLAC in the library is optional. If this + * library has been built without support for Ogg FLAC, this function + * will return \c FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER. + * + * \param decoder An uninitialized decoder instance. + * \param filename The name of the file to decode from. The file will + * be opened with fopen(). Use \c NULL to decode from + * \c stdin. Note that \c stdin is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_file( + FLAC__StreamDecoder *decoder, + const char *filename, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Finish the decoding process. + * Flushes the decoding buffer, releases resources, resets the decoder + * settings to their defaults, and returns the decoder state to + * FLAC__STREAM_DECODER_UNINITIALIZED. + * + * In the event of a prematurely-terminated decode, it is not strictly + * necessary to call this immediately before FLAC__stream_decoder_delete() + * but it is good practice to match every FLAC__stream_decoder_init_*() + * with a FLAC__stream_decoder_finish(). + * + * \param decoder An uninitialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if MD5 checking is on AND a STREAMINFO block was available + * AND the MD5 signature in the STREAMINFO block was non-zero AND the + * signature does not match the one computed by the decoder; else + * \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_finish(FLAC__StreamDecoder *decoder); + +/** Flush the stream input. + * The decoder's input buffer will be cleared and the state set to + * \c FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC. This will also turn + * off MD5 checking. + * + * \param decoder A decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false if a memory allocation + * error occurs (in which case the state will be set to + * \c FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder); + +/** Reset the decoding process. + * The decoder's input buffer will be cleared and the state set to + * \c FLAC__STREAM_DECODER_SEARCH_FOR_METADATA. This is similar to + * FLAC__stream_decoder_finish() except that the settings are + * preserved; there is no need to call FLAC__stream_decoder_init_*() + * before decoding again. MD5 checking will be restored to its original + * setting. + * + * If the decoder is seekable, or was initialized with + * FLAC__stream_decoder_init*_FILE() or FLAC__stream_decoder_init*_file(), + * the decoder will also attempt to seek to the beginning of the file. + * If this rewind fails, this function will return \c false. It follows + * that FLAC__stream_decoder_reset() cannot be used when decoding from + * \c stdin. + * + * If the decoder was initialized with FLAC__stream_encoder_init*_stream() + * and is not seekable (i.e. no seek callback was provided or the seek + * callback returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED), it + * is the duty of the client to start feeding data from the beginning of + * the stream on the next FLAC__stream_decoder_process() or + * FLAC__stream_decoder_process_interleaved() call. + * + * \param decoder A decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false if a memory allocation occurs + * (in which case the state will be set to + * \c FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR) or a seek error + * occurs (the state will be unchanged). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder); + +/** Decode one metadata block or audio frame. + * This version instructs the decoder to decode a either a single metadata + * block or a single frame and stop, unless the callbacks return a fatal + * error or the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM. + * + * As the decoder needs more input it will call the read callback. + * Depending on what was decoded, the metadata or write callback will be + * called with the decoded metadata block or audio frame. + * + * Unless there is a fatal read error or end of stream, this function + * will return once one whole frame is decoded. In other words, if the + * stream is not synchronized or points to a corrupt frame header, the + * decoder will continue to try and resync until it gets to a valid + * frame, then decode one frame, then return. If the decoder points to + * a frame whose frame CRC in the frame footer does not match the + * computed frame CRC, this function will issue a + * FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH error to the + * error callback, and return, having decoded one complete, although + * corrupt, frame. (Such corrupted frames are sent as silence of the + * correct length to the write callback.) + * + * \param decoder An initialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_process_single(FLAC__StreamDecoder *decoder); + +/** Decode until the end of the metadata. + * This version instructs the decoder to decode from the current position + * and continue until all the metadata has been read, or until the + * callbacks return a fatal error or the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM. + * + * As the decoder needs more input it will call the read callback. + * As each metadata block is decoded, the metadata callback will be called + * with the decoded metadata. + * + * \param decoder An initialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_process_until_end_of_metadata(FLAC__StreamDecoder *decoder); + +/** Decode until the end of the stream. + * This version instructs the decoder to decode from the current position + * and continue until the end of stream (the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM), or until the + * callbacks return a fatal error. + * + * As the decoder needs more input it will call the read callback. + * As each metadata block and frame is decoded, the metadata or write + * callback will be called with the decoded metadata or frame. + * + * \param decoder An initialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_process_until_end_of_stream(FLAC__StreamDecoder *decoder); + +/** Skip one audio frame. + * This version instructs the decoder to 'skip' a single frame and stop, + * unless the callbacks return a fatal error or the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM. + * + * The decoding flow is the same as what occurs when + * FLAC__stream_decoder_process_single() is called to process an audio + * frame, except that this function does not decode the parsed data into + * PCM or call the write callback. The integrity of the frame is still + * checked the same way as in the other process functions. + * + * This function will return once one whole frame is skipped, in the + * same way that FLAC__stream_decoder_process_single() will return once + * one whole frame is decoded. + * + * This function can be used in more quickly determining FLAC frame + * boundaries when decoding of the actual data is not needed, for + * example when an application is separating a FLAC stream into frames + * for editing or storing in a container. To do this, the application + * can use FLAC__stream_decoder_skip_single_frame() to quickly advance + * to the next frame, then use + * FLAC__stream_decoder_get_decode_position() to find the new frame + * boundary. + * + * This function should only be called when the stream has advanced + * past all the metadata, otherwise it will return \c false. + * + * \param decoder An initialized decoder instance not in a metadata + * state. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), or if the decoder + * is in the FLAC__STREAM_DECODER_SEARCH_FOR_METADATA or + * FLAC__STREAM_DECODER_READ_METADATA state, else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_skip_single_frame(FLAC__StreamDecoder *decoder); + +/** Flush the input and seek to an absolute sample. + * Decoding will resume at the given sample. Note that because of + * this, the next write callback may contain a partial block. The + * client must support seeking the input or this function will fail + * and return \c false. Furthermore, if the decoder state is + * \c FLAC__STREAM_DECODER_SEEK_ERROR, then the decoder must be flushed + * with FLAC__stream_decoder_flush() or reset with + * FLAC__stream_decoder_reset() before decoding can continue. + * + * \param decoder A decoder instance. + * \param sample The target sample number to seek to. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_seek_absolute(FLAC__StreamDecoder *decoder, FLAC__uint64 sample); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/MacOSX/codecs/include/FLAC/stream_encoder.h b/quakespasm/MacOSX/codecs/include/FLAC/stream_encoder.h new file mode 100644 index 00000000..6f7796bb --- /dev/null +++ b/quakespasm/MacOSX/codecs/include/FLAC/stream_encoder.h @@ -0,0 +1,1769 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__STREAM_ENCODER_H +#define FLAC__STREAM_ENCODER_H + +#include /* for FILE */ +#include "export.h" +#include "format.h" +#include "stream_decoder.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** \file include/FLAC/stream_encoder.h + * + * \brief + * This module contains the functions which implement the stream + * encoder. + * + * See the detailed documentation in the + * \link flac_stream_encoder stream encoder \endlink module. + */ + +/** \defgroup flac_encoder FLAC/ \*_encoder.h: encoder interfaces + * \ingroup flac + * + * \brief + * This module describes the encoder layers provided by libFLAC. + * + * The stream encoder can be used to encode complete streams either to the + * client via callbacks, or directly to a file, depending on how it is + * initialized. When encoding via callbacks, the client provides a write + * callback which will be called whenever FLAC data is ready to be written. + * If the client also supplies a seek callback, the encoder will also + * automatically handle the writing back of metadata discovered while + * encoding, like stream info, seek points offsets, etc. When encoding to + * a file, the client needs only supply a filename or open \c FILE* and an + * optional progress callback for periodic notification of progress; the + * write and seek callbacks are supplied internally. For more info see the + * \link flac_stream_encoder stream encoder \endlink module. + */ + +/** \defgroup flac_stream_encoder FLAC/stream_encoder.h: stream encoder interface + * \ingroup flac_encoder + * + * \brief + * This module contains the functions which implement the stream + * encoder. + * + * The stream encoder can encode to native FLAC, and optionally Ogg FLAC + * (check FLAC_API_SUPPORTS_OGG_FLAC) streams and files. + * + * The basic usage of this encoder is as follows: + * - The program creates an instance of an encoder using + * FLAC__stream_encoder_new(). + * - The program overrides the default settings using + * FLAC__stream_encoder_set_*() functions. At a minimum, the following + * functions should be called: + * - FLAC__stream_encoder_set_channels() + * - FLAC__stream_encoder_set_bits_per_sample() + * - FLAC__stream_encoder_set_sample_rate() + * - FLAC__stream_encoder_set_ogg_serial_number() (if encoding to Ogg FLAC) + * - FLAC__stream_encoder_set_total_samples_estimate() (if known) + * - If the application wants to control the compression level or set its own + * metadata, then the following should also be called: + * - FLAC__stream_encoder_set_compression_level() + * - FLAC__stream_encoder_set_verify() + * - FLAC__stream_encoder_set_metadata() + * - The rest of the set functions should only be called if the client needs + * exact control over how the audio is compressed; thorough understanding + * of the FLAC format is necessary to achieve good results. + * - The program initializes the instance to validate the settings and + * prepare for encoding using + * - FLAC__stream_encoder_init_stream() or FLAC__stream_encoder_init_FILE() + * or FLAC__stream_encoder_init_file() for native FLAC + * - FLAC__stream_encoder_init_ogg_stream() or FLAC__stream_encoder_init_ogg_FILE() + * or FLAC__stream_encoder_init_ogg_file() for Ogg FLAC + * - The program calls FLAC__stream_encoder_process() or + * FLAC__stream_encoder_process_interleaved() to encode data, which + * subsequently calls the callbacks when there is encoder data ready + * to be written. + * - The program finishes the encoding with FLAC__stream_encoder_finish(), + * which causes the encoder to encode any data still in its input pipe, + * update the metadata with the final encoding statistics if output + * seeking is possible, and finally reset the encoder to the + * uninitialized state. + * - The instance may be used again or deleted with + * FLAC__stream_encoder_delete(). + * + * In more detail, the stream encoder functions similarly to the + * \link flac_stream_decoder stream decoder \endlink, but has fewer + * callbacks and more options. Typically the client will create a new + * instance by calling FLAC__stream_encoder_new(), then set the necessary + * parameters with FLAC__stream_encoder_set_*(), and initialize it by + * calling one of the FLAC__stream_encoder_init_*() functions. + * + * Unlike the decoders, the stream encoder has many options that can + * affect the speed and compression ratio. When setting these parameters + * you should have some basic knowledge of the format (see the + * user-level documentation + * or the formal description). The + * FLAC__stream_encoder_set_*() functions themselves do not validate the + * values as many are interdependent. The FLAC__stream_encoder_init_*() + * functions will do this, so make sure to pay attention to the state + * returned by FLAC__stream_encoder_init_*() to make sure that it is + * FLAC__STREAM_ENCODER_INIT_STATUS_OK. Any parameters that are not set + * before FLAC__stream_encoder_init_*() will take on the defaults from + * the constructor. + * + * There are three initialization functions for native FLAC, one for + * setting up the encoder to encode FLAC data to the client via + * callbacks, and two for encoding directly to a file. + * + * For encoding via callbacks, use FLAC__stream_encoder_init_stream(). + * You must also supply a write callback which will be called anytime + * there is raw encoded data to write. If the client can seek the output + * it is best to also supply seek and tell callbacks, as this allows the + * encoder to go back after encoding is finished to write back + * information that was collected while encoding, like seek point offsets, + * frame sizes, etc. + * + * For encoding directly to a file, use FLAC__stream_encoder_init_FILE() + * or FLAC__stream_encoder_init_file(). Then you must only supply a + * filename or open \c FILE*; the encoder will handle all the callbacks + * internally. You may also supply a progress callback for periodic + * notification of the encoding progress. + * + * There are three similarly-named init functions for encoding to Ogg + * FLAC streams. Check \c FLAC_API_SUPPORTS_OGG_FLAC to find out if the + * library has been built with Ogg support. + * + * The call to FLAC__stream_encoder_init_*() currently will also immediately + * call the write callback several times, once with the \c fLaC signature, + * and once for each encoded metadata block. Note that for Ogg FLAC + * encoding you will usually get at least twice the number of callbacks than + * with native FLAC, one for the Ogg page header and one for the page body. + * + * After initializing the instance, the client may feed audio data to the + * encoder in one of two ways: + * + * - Channel separate, through FLAC__stream_encoder_process() - The client + * will pass an array of pointers to buffers, one for each channel, to + * the encoder, each of the same length. The samples need not be + * block-aligned, but each channel should have the same number of samples. + * - Channel interleaved, through + * FLAC__stream_encoder_process_interleaved() - The client will pass a single + * pointer to data that is channel-interleaved (i.e. channel0_sample0, + * channel1_sample0, ... , channelN_sample0, channel0_sample1, ...). + * Again, the samples need not be block-aligned but they must be + * sample-aligned, i.e. the first value should be channel0_sample0 and + * the last value channelN_sampleM. + * + * Note that for either process call, each sample in the buffers should be a + * signed integer, right-justified to the resolution set by + * FLAC__stream_encoder_set_bits_per_sample(). For example, if the resolution + * is 16 bits per sample, the samples should all be in the range [-32768,32767]. + * + * When the client is finished encoding data, it calls + * FLAC__stream_encoder_finish(), which causes the encoder to encode any + * data still in its input pipe, and call the metadata callback with the + * final encoding statistics. Then the instance may be deleted with + * FLAC__stream_encoder_delete() or initialized again to encode another + * stream. + * + * For programs that write their own metadata, but that do not know the + * actual metadata until after encoding, it is advantageous to instruct + * the encoder to write a PADDING block of the correct size, so that + * instead of rewriting the whole stream after encoding, the program can + * just overwrite the PADDING block. If only the maximum size of the + * metadata is known, the program can write a slightly larger padding + * block, then split it after encoding. + * + * Make sure you understand how lengths are calculated. All FLAC metadata + * blocks have a 4 byte header which contains the type and length. This + * length does not include the 4 bytes of the header. See the format page + * for the specification of metadata blocks and their lengths. + * + * \note + * If you are writing the FLAC data to a file via callbacks, make sure it + * is open for update (e.g. mode "w+" for stdio streams). This is because + * after the first encoding pass, the encoder will try to seek back to the + * beginning of the stream, to the STREAMINFO block, to write some data + * there. (If using FLAC__stream_encoder_init*_file() or + * FLAC__stream_encoder_init*_FILE(), the file is managed internally.) + * + * \note + * The "set" functions may only be called when the encoder is in the + * state FLAC__STREAM_ENCODER_UNINITIALIZED, i.e. after + * FLAC__stream_encoder_new() or FLAC__stream_encoder_finish(), but + * before FLAC__stream_encoder_init_*(). If this is the case they will + * return \c true, otherwise \c false. + * + * \note + * FLAC__stream_encoder_finish() resets all settings to the constructor + * defaults. + * + * \{ + */ + + +/** State values for a FLAC__StreamEncoder. + * + * The encoder's state can be obtained by calling FLAC__stream_encoder_get_state(). + * + * If the encoder gets into any other state besides \c FLAC__STREAM_ENCODER_OK + * or \c FLAC__STREAM_ENCODER_UNINITIALIZED, it becomes invalid for encoding and + * must be deleted with FLAC__stream_encoder_delete(). + */ +typedef enum { + + FLAC__STREAM_ENCODER_OK = 0, + /**< The encoder is in the normal OK state and samples can be processed. */ + + FLAC__STREAM_ENCODER_UNINITIALIZED, + /**< The encoder is in the uninitialized state; one of the + * FLAC__stream_encoder_init_*() functions must be called before samples + * can be processed. + */ + + FLAC__STREAM_ENCODER_OGG_ERROR, + /**< An error occurred in the underlying Ogg layer. */ + + FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR, + /**< An error occurred in the underlying verify stream decoder; + * check FLAC__stream_encoder_get_verify_decoder_state(). + */ + + FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA, + /**< The verify decoder detected a mismatch between the original + * audio signal and the decoded audio signal. + */ + + FLAC__STREAM_ENCODER_CLIENT_ERROR, + /**< One of the callbacks returned a fatal error. */ + + FLAC__STREAM_ENCODER_IO_ERROR, + /**< An I/O error occurred while opening/reading/writing a file. + * Check \c errno. + */ + + FLAC__STREAM_ENCODER_FRAMING_ERROR, + /**< An error occurred while writing the stream; usually, the + * write_callback returned an error. + */ + + FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR + /**< Memory allocation failed. */ + +} FLAC__StreamEncoderState; + +/** Maps a FLAC__StreamEncoderState to a C string. + * + * Using a FLAC__StreamEncoderState as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderStateString[]; + + +/** Possible return values for the FLAC__stream_encoder_init_*() functions. + */ +typedef enum { + + FLAC__STREAM_ENCODER_INIT_STATUS_OK = 0, + /**< Initialization was successful. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR, + /**< General failure to set up encoder; call FLAC__stream_encoder_get_state() for cause. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER, + /**< The library was not compiled with support for the given container + * format. + */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS, + /**< A required callback was not supplied. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS, + /**< The encoder has an invalid setting for number of channels. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE, + /**< The encoder has an invalid setting for bits-per-sample. + * FLAC supports 4-32 bps but the reference encoder currently supports + * only up to 24 bps. + */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE, + /**< The encoder has an invalid setting for the input sample rate. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE, + /**< The encoder has an invalid setting for the block size. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER, + /**< The encoder has an invalid setting for the maximum LPC order. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION, + /**< The encoder has an invalid setting for the precision of the quantized linear predictor coefficients. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER, + /**< The specified block size is less than the maximum LPC order. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE, + /**< The encoder is bound to the Subset but other settings violate it. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA, + /**< The metadata input to the encoder is invalid, in one of the following ways: + * - FLAC__stream_encoder_set_metadata() was called with a null pointer but a block count > 0 + * - One of the metadata blocks contains an undefined type + * - It contains an illegal CUESHEET as checked by FLAC__format_cuesheet_is_legal() + * - It contains an illegal SEEKTABLE as checked by FLAC__format_seektable_is_legal() + * - It contains more than one SEEKTABLE block or more than one VORBIS_COMMENT block + */ + + FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED + /**< FLAC__stream_encoder_init_*() was called when the encoder was + * already initialized, usually because + * FLAC__stream_encoder_finish() was not called. + */ + +} FLAC__StreamEncoderInitStatus; + +/** Maps a FLAC__StreamEncoderInitStatus to a C string. + * + * Using a FLAC__StreamEncoderInitStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderInitStatusString[]; + + +/** Return values for the FLAC__StreamEncoder read callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE, + /**< The read was OK and decoding can continue. */ + + FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM, + /**< The read was attempted at the end of the stream. */ + + FLAC__STREAM_ENCODER_READ_STATUS_ABORT, + /**< An unrecoverable error occurred. */ + + FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED + /**< Client does not support reading back from the output. */ + +} FLAC__StreamEncoderReadStatus; + +/** Maps a FLAC__StreamEncoderReadStatus to a C string. + * + * Using a FLAC__StreamEncoderReadStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderReadStatusString[]; + + +/** Return values for the FLAC__StreamEncoder write callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_WRITE_STATUS_OK = 0, + /**< The write was OK and encoding can continue. */ + + FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR + /**< An unrecoverable error occurred. The encoder will return from the process call. */ + +} FLAC__StreamEncoderWriteStatus; + +/** Maps a FLAC__StreamEncoderWriteStatus to a C string. + * + * Using a FLAC__StreamEncoderWriteStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderWriteStatusString[]; + + +/** Return values for the FLAC__StreamEncoder seek callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_SEEK_STATUS_OK, + /**< The seek was OK and encoding can continue. */ + + FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR, + /**< An unrecoverable error occurred. */ + + FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED + /**< Client does not support seeking. */ + +} FLAC__StreamEncoderSeekStatus; + +/** Maps a FLAC__StreamEncoderSeekStatus to a C string. + * + * Using a FLAC__StreamEncoderSeekStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderSeekStatusString[]; + + +/** Return values for the FLAC__StreamEncoder tell callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_TELL_STATUS_OK, + /**< The tell was OK and encoding can continue. */ + + FLAC__STREAM_ENCODER_TELL_STATUS_ERROR, + /**< An unrecoverable error occurred. */ + + FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED + /**< Client does not support seeking. */ + +} FLAC__StreamEncoderTellStatus; + +/** Maps a FLAC__StreamEncoderTellStatus to a C string. + * + * Using a FLAC__StreamEncoderTellStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderTellStatusString[]; + + +/*********************************************************************** + * + * class FLAC__StreamEncoder + * + ***********************************************************************/ + +struct FLAC__StreamEncoderProtected; +struct FLAC__StreamEncoderPrivate; +/** The opaque structure definition for the stream encoder type. + * See the \link flac_stream_encoder stream encoder module \endlink + * for a detailed description. + */ +typedef struct { + struct FLAC__StreamEncoderProtected *protected_; /* avoid the C++ keyword 'protected' */ + struct FLAC__StreamEncoderPrivate *private_; /* avoid the C++ keyword 'private' */ +} FLAC__StreamEncoder; + +/** Signature for the read callback. + * + * A function pointer matching this signature must be passed to + * FLAC__stream_encoder_init_ogg_stream() if seeking is supported. + * The supplied function will be called when the encoder needs to read back + * encoded data. This happens during the metadata callback, when the encoder + * has to read, modify, and rewrite the metadata (e.g. seekpoints) gathered + * while encoding. The address of the buffer to be filled is supplied, along + * with the number of bytes the buffer can hold. The callback may choose to + * supply less data and modify the byte count but must be careful not to + * overflow the buffer. The callback then returns a status code chosen from + * FLAC__StreamEncoderReadStatus. + * + * Here is an example of a read callback for stdio streams: + * \code + * FLAC__StreamEncoderReadStatus read_cb(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(*bytes > 0) { + * *bytes = fread(buffer, sizeof(FLAC__byte), *bytes, file); + * if(ferror(file)) + * return FLAC__STREAM_ENCODER_READ_STATUS_ABORT; + * else if(*bytes == 0) + * return FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM; + * else + * return FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE; + * } + * else + * return FLAC__STREAM_ENCODER_READ_STATUS_ABORT; + * } + * \endcode + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param buffer A pointer to a location for the callee to store + * data to be encoded. + * \param bytes A pointer to the size of the buffer. On entry + * to the callback, it contains the maximum number + * of bytes that may be stored in \a buffer. The + * callee must set it to the actual number of bytes + * stored (0 in case of error or end-of-stream) before + * returning. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_set_client_data(). + * \retval FLAC__StreamEncoderReadStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderReadStatus (*FLAC__StreamEncoderReadCallback)(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data); + +/** Signature for the write callback. + * + * A function pointer matching this signature must be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * by the encoder anytime there is raw encoded data ready to write. It may + * include metadata mixed with encoded audio frames and the data is not + * guaranteed to be aligned on frame or metadata block boundaries. + * + * The only duty of the callback is to write out the \a bytes worth of data + * in \a buffer to the current position in the output stream. The arguments + * \a samples and \a current_frame are purely informational. If \a samples + * is greater than \c 0, then \a current_frame will hold the current frame + * number that is being written; otherwise it indicates that the write + * callback is being called to write metadata. + * + * \note + * Unlike when writing to native FLAC, when writing to Ogg FLAC the + * write callback will be called twice when writing each audio + * frame; once for the page header, and once for the page body. + * When writing the page header, the \a samples argument to the + * write callback will be \c 0. + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param buffer An array of encoded data of length \a bytes. + * \param bytes The byte length of \a buffer. + * \param samples The number of samples encoded by \a buffer. + * \c 0 has a special meaning; see above. + * \param current_frame The number of the current frame being encoded. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + * \retval FLAC__StreamEncoderWriteStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderWriteStatus (*FLAC__StreamEncoderWriteCallback)(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data); + +/** Signature for the seek callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * when the encoder needs to seek the output stream. The encoder will pass + * the absolute byte offset to seek to, 0 meaning the beginning of the stream. + * + * Here is an example of a seek callback for stdio streams: + * \code + * FLAC__StreamEncoderSeekStatus seek_cb(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(file == stdin) + * return FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED; + * else if(fseeko(file, (off_t)absolute_byte_offset, SEEK_SET) < 0) + * return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR; + * else + * return FLAC__STREAM_ENCODER_SEEK_STATUS_OK; + * } + * \endcode + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param absolute_byte_offset The offset from the beginning of the stream + * to seek to. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + * \retval FLAC__StreamEncoderSeekStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderSeekStatus (*FLAC__StreamEncoderSeekCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data); + +/** Signature for the tell callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * when the encoder needs to know the current position of the output stream. + * + * \warning + * The callback must return the true current byte offset of the output to + * which the encoder is writing. If you are buffering the output, make + * sure and take this into account. If you are writing directly to a + * FILE* from your write callback, ftell() is sufficient. If you are + * writing directly to a file descriptor from your write callback, you + * can use lseek(fd, SEEK_CUR, 0). The encoder may later seek back to + * these points to rewrite metadata after encoding. + * + * Here is an example of a tell callback for stdio streams: + * \code + * FLAC__StreamEncoderTellStatus tell_cb(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * off_t pos; + * if(file == stdin) + * return FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED; + * else if((pos = ftello(file)) < 0) + * return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR; + * else { + * *absolute_byte_offset = (FLAC__uint64)pos; + * return FLAC__STREAM_ENCODER_TELL_STATUS_OK; + * } + * } + * \endcode + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param absolute_byte_offset The address at which to store the current + * position of the output. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + * \retval FLAC__StreamEncoderTellStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderTellStatus (*FLAC__StreamEncoderTellCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data); + +/** Signature for the metadata callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * once at the end of encoding with the populated STREAMINFO structure. This + * is so the client can seek back to the beginning of the file and write the + * STREAMINFO block with the correct statistics after encoding (like + * minimum/maximum frame size and total samples). + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param metadata The final populated STREAMINFO block. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + */ +typedef void (*FLAC__StreamEncoderMetadataCallback)(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data); + +/** Signature for the progress callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE(). + * The supplied function will be called when the encoder has finished + * writing a frame. The \c total_frames_estimate argument to the + * callback will be based on the value from + * FLAC__stream_encoder_set_total_samples_estimate(). + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param bytes_written Bytes written so far. + * \param samples_written Samples written so far. + * \param frames_written Frames written so far. + * \param total_frames_estimate The estimate of the total number of + * frames to be written. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + */ +typedef void (*FLAC__StreamEncoderProgressCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data); + + +/*********************************************************************** + * + * Class constructor/destructor + * + ***********************************************************************/ + +/** Create a new stream encoder instance. The instance is created with + * default settings; see the individual FLAC__stream_encoder_set_*() + * functions for each setting's default. + * + * \retval FLAC__StreamEncoder* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamEncoder *FLAC__stream_encoder_new(void); + +/** Free an encoder instance. Deletes the object pointed to by \a encoder. + * + * \param encoder A pointer to an existing encoder. + * \assert + * \code encoder != NULL \endcode + */ +FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder); + + +/*********************************************************************** + * + * Public class method prototypes + * + ***********************************************************************/ + +/** Set the serial number for the FLAC stream to use in the Ogg container. + * + * \note + * This does not need to be set for native FLAC encoding. + * + * \note + * It is recommended to set a serial number explicitly as the default of '0' + * may collide with other streams. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param serial_number See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder *encoder, long serial_number); + +/** Set the "verify" flag. If \c true, the encoder will verify it's own + * encoded output by feeding it through an internal decoder and comparing + * the original signal against the decoded signal. If a mismatch occurs, + * the process call will return \c false. Note that this will slow the + * encoding process by the extra time required for decoding and comparison. + * + * \default \c false + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Set the Subset flag. If \c true, + * the encoder will comply with the Subset and will check the + * settings during FLAC__stream_encoder_init_*() to see if all settings + * comply. If \c false, the settings may take advantage of the full + * range that the format allows. + * + * Make sure you know what it entails before setting this to \c false. + * + * \default \c true + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Set the number of channels to be encoded. + * + * \default \c 2 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the sample resolution of the input to be encoded. + * + * \warning + * Do not feed the encoder data that is wider than the value you + * set here or you will generate an invalid stream. + * + * \default \c 16 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the sample rate (in Hz) of the input to be encoded. + * + * \default \c 44100 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the compression level + * + * The compression level is roughly proportional to the amount of effort + * the encoder expends to compress the file. A higher level usually + * means more computation but higher compression. The default level is + * suitable for most applications. + * + * Currently the levels range from \c 0 (fastest, least compression) to + * \c 8 (slowest, most compression). A value larger than \c 8 will be + * treated as \c 8. + * + * This function automatically calls the following other \c _set_ + * functions with appropriate values, so the client does not need to + * unless it specifically wants to override them: + * - FLAC__stream_encoder_set_do_mid_side_stereo() + * - FLAC__stream_encoder_set_loose_mid_side_stereo() + * - FLAC__stream_encoder_set_apodization() + * - FLAC__stream_encoder_set_max_lpc_order() + * - FLAC__stream_encoder_set_qlp_coeff_precision() + * - FLAC__stream_encoder_set_do_qlp_coeff_prec_search() + * - FLAC__stream_encoder_set_do_escape_coding() + * - FLAC__stream_encoder_set_do_exhaustive_model_search() + * - FLAC__stream_encoder_set_min_residual_partition_order() + * - FLAC__stream_encoder_set_max_residual_partition_order() + * - FLAC__stream_encoder_set_rice_parameter_search_dist() + * + * The actual values set for each level are: + * + * + * + * + * + * + * + * + * + * + * + * + *
level + * do mid-side stereo + * loose mid-side stereo + * apodization + * max lpc order + * qlp coeff precision + * qlp coeff prec search + * escape coding + * exhaustive model search + * min residual partition order + * max residual partition order + * rice parameter search dist + *
0 false false tukey(0.5) 0 0 false false false 0 3 0
1 true true tukey(0.5) 0 0 false false false 0 3 0
2 true false tukey(0.5) 0 0 false false false 0 3 0
3 false false tukey(0.5) 6 0 false false false 0 4 0
4 true true tukey(0.5) 8 0 false false false 0 4 0
5 true false tukey(0.5) 8 0 false false false 0 5 0
6 true false tukey(0.5) 8 0 false false false 0 6 0
7 true false tukey(0.5) 8 0 false false true 0 6 0
8 true false tukey(0.5) 12 0 false false true 0 6 0
+ * + * \default \c 5 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the blocksize to use while encoding. + * + * The number of samples to use per frame. Use \c 0 to let the encoder + * estimate a blocksize; this is usually best. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set to \c true to enable mid-side encoding on stereo input. The + * number of channels must be 2 for this to have any effect. Set to + * \c false to use only independent channel coding. + * + * \default \c false + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Set to \c true to enable adaptive switching between mid-side and + * left-right encoding on stereo input. Set to \c false to use + * exhaustive searching. Setting this to \c true requires + * FLAC__stream_encoder_set_do_mid_side_stereo() to also be set to + * \c true in order to have any effect. + * + * \default \c false + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Sets the apodization function(s) the encoder will use when windowing + * audio data for LPC analysis. + * + * The \a specification is a plain ASCII string which specifies exactly + * which functions to use. There may be more than one (up to 32), + * separated by \c ';' characters. Some functions take one or more + * comma-separated arguments in parentheses. + * + * The available functions are \c bartlett, \c bartlett_hann, + * \c blackman, \c blackman_harris_4term_92db, \c connes, \c flattop, + * \c gauss(STDDEV), \c hamming, \c hann, \c kaiser_bessel, \c nuttall, + * \c rectangle, \c triangle, \c tukey(P), \c welch. + * + * For \c gauss(STDDEV), STDDEV specifies the standard deviation + * (0blocksize / (2 ^ order). + * + * Set both min and max values to \c 0 to force a single context, + * whose Rice parameter is based on the residual signal variance. + * Otherwise, set a min and max order, and the encoder will search + * all orders, using the mean of each context for its Rice parameter, + * and use the best. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the maximum partition order to search when coding the residual. + * This is used in tandem with + * FLAC__stream_encoder_set_min_residual_partition_order(). + * + * The partition order determines the context size in the residual. + * The context size will be approximately blocksize / (2 ^ order). + * + * Set both min and max values to \c 0 to force a single context, + * whose Rice parameter is based on the residual signal variance. + * Otherwise, set a min and max order, and the encoder will search + * all orders, using the mean of each context for its Rice parameter, + * and use the best. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value); + +/** Deprecated. Setting this value has no effect. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set an estimate of the total samples that will be encoded. + * This is merely an estimate and may be set to \c 0 if unknown. + * This value will be written to the STREAMINFO block before encoding, + * and can remove the need for the caller to rewrite the value later + * if the value is known before encoding. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value); + +/** Set the metadata blocks to be emitted to the stream before encoding. + * A value of \c NULL, \c 0 implies no metadata; otherwise, supply an + * array of pointers to metadata blocks. The array is non-const since + * the encoder may need to change the \a is_last flag inside them, and + * in some cases update seek point offsets. Otherwise, the encoder will + * not modify or free the blocks. It is up to the caller to free the + * metadata blocks after encoding finishes. + * + * \note + * The encoder stores only copies of the pointers in the \a metadata array; + * the metadata blocks themselves must survive at least until after + * FLAC__stream_encoder_finish() returns. Do not free the blocks until then. + * + * \note + * The STREAMINFO block is always written and no STREAMINFO block may + * occur in the supplied array. + * + * \note + * By default the encoder does not create a SEEKTABLE. If one is supplied + * in the \a metadata array, but the client has specified that it does not + * support seeking, then the SEEKTABLE will be written verbatim. However + * by itself this is not very useful as the client will not know the stream + * offsets for the seekpoints ahead of time. In order to get a proper + * seektable the client must support seeking. See next note. + * + * \note + * SEEKTABLE blocks are handled specially. Since you will not know + * the values for the seek point stream offsets, you should pass in + * a SEEKTABLE 'template', that is, a SEEKTABLE object with the + * required sample numbers (or placeholder points), with \c 0 for the + * \a frame_samples and \a stream_offset fields for each point. If the + * client has specified that it supports seeking by providing a seek + * callback to FLAC__stream_encoder_init_stream() or both seek AND read + * callback to FLAC__stream_encoder_init_ogg_stream() (or by using + * FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE()), + * then while it is encoding the encoder will fill the stream offsets in + * for you and when encoding is finished, it will seek back and write the + * real values into the SEEKTABLE block in the stream. There are helper + * routines for manipulating seektable template blocks; see metadata.h: + * FLAC__metadata_object_seektable_template_*(). If the client does + * not support seeking, the SEEKTABLE will have inaccurate offsets which + * will slow down or remove the ability to seek in the FLAC stream. + * + * \note + * The encoder instance \b will modify the first \c SEEKTABLE block + * as it transforms the template to a valid seektable while encoding, + * but it is still up to the caller to free all metadata blocks after + * encoding. + * + * \note + * A VORBIS_COMMENT block may be supplied. The vendor string in it + * will be ignored. libFLAC will use it's own vendor string. libFLAC + * will not modify the passed-in VORBIS_COMMENT's vendor string, it + * will simply write it's own into the stream. If no VORBIS_COMMENT + * block is present in the \a metadata array, libFLAC will write an + * empty one, containing only the vendor string. + * + * \note The Ogg FLAC mapping requires that the VORBIS_COMMENT block be + * the second metadata block of the stream. The encoder already supplies + * the STREAMINFO block automatically. If \a metadata does not contain a + * VORBIS_COMMENT block, the encoder will supply that too. Otherwise, if + * \a metadata does contain a VORBIS_COMMENT block and it is not the + * first, the init function will reorder \a metadata by moving the + * VORBIS_COMMENT block to the front; the relative ordering of the other + * blocks will remain as they were. + * + * \note The Ogg FLAC mapping limits the number of metadata blocks per + * stream to \c 65535. If \a num_blocks exceeds this the function will + * return \c false. + * + * \default \c NULL, 0 + * \param encoder An encoder instance to set. + * \param metadata See above. + * \param num_blocks See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + * \c false if the encoder is already initialized, or if + * \a num_blocks > 65535 if encoding to Ogg FLAC, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks); + +/** Get the current encoder state. + * + * \param encoder An encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__StreamEncoderState + * The current encoder state. + */ +FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder); + +/** Get the state of the verify stream decoder. + * Useful when the stream encoder state is + * \c FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR. + * + * \param encoder An encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__StreamDecoderState + * The verify stream decoder state. + */ +FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder); + +/** Get the current encoder state as a C string. + * This version automatically resolves + * \c FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR by getting the + * verify decoder's state. + * + * \param encoder A encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval const char * + * The encoder state as a C string. Do not modify the contents. + */ +FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder); + +/** Get relevant values about the nature of a verify decoder error. + * Useful when the stream encoder state is + * \c FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR. The arguments should + * be addresses in which the stats will be returned, or NULL if value + * is not desired. + * + * \param encoder An encoder instance to query. + * \param absolute_sample The absolute sample number of the mismatch. + * \param frame_number The number of the frame in which the mismatch occurred. + * \param channel The channel in which the mismatch occurred. + * \param sample The number of the sample (relative to the frame) in + * which the mismatch occurred. + * \param expected The expected value for the sample in question. + * \param got The actual value returned by the decoder. + * \assert + * \code encoder != NULL \endcode + */ +FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got); + +/** Get the "verify" flag. + * + * \param encoder An encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * See FLAC__stream_encoder_set_verify(). + */ +FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder); + +/** Get the frame header. + * + * \param encoder An initialized encoder instance in the OK state. + * \param buffer An array of pointers to each channel's signal. + * \param samples The number of samples in one channel. + * \assert + * \code encoder != NULL \endcode + * \code FLAC__stream_encoder_get_state(encoder) == FLAC__STREAM_ENCODER_OK \endcode + * \retval FLAC__bool + * \c true if successful, else \c false; in this case, check the + * encoder state with FLAC__stream_encoder_get_state() to see what + * went wrong. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples); + +/** Submit data for encoding. + * This version allows you to supply the input data where the channels + * are interleaved into a single array (i.e. channel0_sample0, + * channel1_sample0, ... , channelN_sample0, channel0_sample1, ...). + * The samples need not be block-aligned but they must be + * sample-aligned, i.e. the first value should be channel0_sample0 + * and the last value channelN_sampleM. Each sample should be a signed + * integer, right-justified to the resolution set by + * FLAC__stream_encoder_set_bits_per_sample(). For example, if the + * resolution is 16 bits per sample, the samples should all be in the + * range [-32768,32767]. + * + * For applications where channel order is important, channels must + * follow the order as described in the + * frame header. + * + * \param encoder An initialized encoder instance in the OK state. + * \param buffer An array of channel-interleaved data (see above). + * \param samples The number of samples in one channel, the same as for + * FLAC__stream_encoder_process(). For example, if + * encoding two channels, \c 1000 \a samples corresponds + * to a \a buffer of 2000 values. + * \assert + * \code encoder != NULL \endcode + * \code FLAC__stream_encoder_get_state(encoder) == FLAC__STREAM_ENCODER_OK \endcode + * \retval FLAC__bool + * \c true if successful, else \c false; in this case, check the + * encoder state with FLAC__stream_encoder_get_state() to see what + * went wrong. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/MacOSX/codecs/lib/libFLAC.dylib b/quakespasm/MacOSX/codecs/lib/libFLAC.dylib new file mode 100755 index 0000000000000000000000000000000000000000..1ba6f417275c724e53f92274dfff88d4c389f2f1 GIT binary patch literal 935632 zcmeFa4|rU~bvHcwN7mX_ngzDaCdg)OD7F4t=OLkVWFtVlO+rTOk;6ICGf{oo& zNt}L5a#wpL3y_TSzH;oOHb{;zh8p5hrzL#}*g^)E%HV#V`9gT@VyFmCBZ_I2;4}iS zbidzk?%dtG>y>R%+9vOVp66tX{qG_Si=LGXKskKW$jJ-X9hMA-o7?E+O>vPrzth*YdTy{-pU&H+*g5 z*PE|72ZlRu5Y-I|849NjhDZGltX|#nwT)k0_vJg(i*sRoOc&x)pA~L~X&Cn3fbpka z{#v>*=fb#Z5KW&g+zc~dAZq@tUcF)6#@oMo+lHVO&!VS${s>6DR>)BLVyvPm+N5BV zO$MVR3>fvo%`gKG`gY{s>eaWeUHzr6-u5TATk&i>7W5(|D%>(m(KIT=bhCu~51w!w zTfMrbDpF;8EBU~S-XvcjwERRu@)Y`W&21ZROXtsB-T@Y1`3(G1g#hEO4Qomla!RSK%F~DGGhe6(6OjxT|e|f|CVO*<&MxZ0Z z3>cIz4G&;s^Hp|R{%{yY%Y>U@1`I^aztyXozxFjNg792={E-i@E&rUoE$GA4AAbi| zudZMA`MT?CmPOQicL+av(4P!9KY@R2zrEbY5GP0b<$KnGCv#LTOpzGE(BaaZ5dl0-O+%3lte;JSYC)*+Z zUqpzhg||~oMU$ZMa^d}_cidq^Tb3(BS+>_Hnq1RJjRjx-+E>{|J~!RyfzL5?i!IxZAf}xg*}~dPFO5 zsraY;pV!@i_R`cD!0}ww`e`etiN(ie4XnN=41M{H;g1UxCftW$5fsuFN!1!svU@_04@7V-PME&@@| z$$I9)daLRX^;SI8E=q%;bh_5^dtV7w3rDEK7z;KFM|SxIn+yYW7ium3_mJms5P<+T6E4`sIPOuCe+&}d>Dkg=5=Cx>=T{D!Cp7xk@iAQ`+T`XR6 zQ%t*a&RwYQl!eoRPKig^H8srR*dAYUQ!GBaE;eh45b@cLo~&}67M>PvwF| zHqG{F2aCgzhrJ7HUCHb8Rl-B#pl7D=YAe0r9>hTduLV|-X%iF?;$+2)uC63 zpoA%w`!sQ>FETZMAR8Jfw*mkHiC^504j5fc(qyPZMrd{j85X^Ng*|AWU?~ z%Kn}uD8B^ou)>VcgU1()21HN0*wFK!Xze*9Huk(BVp|2yf(oa-2#b)v3i%yuhvtIZ0arVoTJz;G*-p@@#|eC#z{d$( zoC19$q?`}DVVnfL?xL(~y>ntVdG85zi1~osD&_i~IWg3KDeDNfOlY9H<0+N}O+f!K z@PS)@U3eAwXR?O3VA&!H;v^hz9}3i zzl?aAbs1~%yFlSQXtj@cqD{w9{)bGDO!b#jw^+Da?Lt~^ocly5)N9B2-+u!BFD1_L zMYUlI=kmG0(|N2UF}1cdK34=wr&6|;5${E;x8k61pzdIzdn8oVXKZJGDLPDJU#0u# z-#0SN{?4u&E&38(;?cKbY&-A^r)m1{*8#sM^I4Ci@6-#?_ZQzmxnhFRMPMs&5U-1*|lN(62K<4_9c{ zcvqb-$(hR z%qiU;Xh&Y?ZEyP=!0!u%BGul7iDzp|IKJr{gg?^aUi>s*5MFzW@CQ7?U%49Nco+D4 z&|SKzuO4Zon}3RPuNtH*qHcVDWsBdD-swa2~<<^?zf_sF2)>XnE{Cm6uezUHJZaGq43fKYSns^~n+Aw#@ z;uL(~-mo0)0RDlc$os6XH11)WKsWL1;)dxpC0h$%4~gY5j&<=$Q4(LjJk}6J8gRw9 zC*Nx;@P6*4v4+`rKM!T*qfGUUY1*`yw1G_5*BKL)zDFW8CxT(EaVRp^uw|PmB7)krvP&<8-9OAJo?S!xo&2A3uM&PL3-W zcM{LN8{=4n=e%R6H7-GK&1YNq$og(GPHP9|nd49V@|gBO_88=@gl=|hgPm3@+^tqw zh6{GdF|xAM37z<;W4j&~qVX`=Hc%Xu zg?%G!lIeCk$8`W{0_6e?bG!?sopUhT&bh^A=eV}8j`l^O0Qxn!={3-M2Ks`0UJYBP z+Ubid8y$#L=MQKzYr|UIWii&@vl8P5Z7e6!!Gf9x^z6m>)@Kwax<{d}oP!Ix*ha?| z$ZY_1h{hw3Z{*Rsy(Q4ku$R&HLJ=m7wCb8tt-~ACs@mbhHzDFohr$gT&n8=1$j54NQ)Xst@zC{?cgB`H%&w^=DK1`>p4go zI!5R9iYq`b(fBO-twZYB!ayNxVbWg*-7gnnTc6B(xaWcYv*~N2ZHlhw^P`rGn!GD& z+R3*sLKhZ`W8_!TDqaaWAiquzmz2+?t`*?h`W$>KH1-MUJ*!gD+1Z3XM_$kxedg0v zT1pby zEZd*y)L+tm-Z3Wz9Y*`uqrLivG3~C@d`+kBs58!f(wuuZM!EU`St`_T1%9(cFz6&L zE_s}70p4D|BWylj2?!lFcwu~TU96&?>5hKBw;rSq!sc9oFo1lKijZ(HU&G=l6M(e_ zahDm-Z$q5vZWSLuyaw?+6=(i3{;n9r6B1JpF9O_Q1>dXSJ5~P0#Gz`y(S&?DfAdMq zc`?TJk`8so`=4f;L%SRW$TPB`(khk{`j70(zkdavl?I zz+JoW*TT^__(ubckCtBB_(JKmiTj_F{sC=jU96#H%0PV4WwH3G%VU_cOWy(8M;P0l zg!~_uFp3aopB6HW59hz20s3@e3^rjG_)E9uZI+$Ru{iiC!?4pba(VtloiX+klb&J& z%I+n+1rLyyCbke?8Nc7ene%W9Z_ZC8&YPwTROsNfG~R~+C(LrzWA=}60QSadzDwh4 zjNsjIJ5IpodWBCR;P{!J+D^#tK_$N@A-~^D$#0J-zrViOqtvDH|!#f;nnR9{>G2ik7F5=Q#75{p}?GbTJP2c6r=@xLqFCB2IavzM(vF zz7(!NxvY9VW70}&Y@Y@B1D%lHls`o$!0-bW>Rfhhxx z&r<#dg|^B?dE1`KkG$JX$h?w1C_9O~8Gi8So|HakpDTSXWz9yX$c+4fI^$RC6s@8t zx6i82?E8s*2r=Jr_z-fwvk!ErWu66)Kg9*z7%Z87-6H{Qo^;KH2jGt`7RUw#GWkpcc zzS92!`e9-%;kPqQD({NidG(pLyvtPHQY&u|vKSGAzbEs|z&Hw+;Li`_&t-e(-7Nyr z=bhDF`1c~ghmB!VAOGTrs=rmWrxG**Z~Wp1>V1=b8_0w9f=&+U2L;i!mYZU*6Gcy4 z>enFYhca|+$hmm!_L0qkRdPOU^$p2Xr8 zV~L&c;q`%cX1XL#B>wJQ$kOPyOgtQ2iN!-10LAAp{FdEWiPh5AlmUge>kxan2+K6k;-1wUtSCT!DNj3n$_ zFZkj~HFpo{Ph-yfP1pmNx0mLb^LV*#fjPW6e}6NMdOX{n=Db~mw*ofe?)GnDjpE$7 zdk8YHAL#;ipEY+6p^mII3j5q$=!D;10X(WiD06)Rb9RwGz&e3<0o#YU`F!Yk%32ZH zu~yQEerIX({@XPsjU3yNR@_*g-?m_<%v&t;ecH5->x_S!YUUGO$PLG=0@9l@lxvKt z0H3DDDbzzhWMpQ3Tb=Q*hZLL|j1h{aMk{Dbf7}Q{j!%aXx)AmwbR*Od<{@lCI0YeX z1|P>R^qB+wcmS|!Gu!pA%KkAT(mzbTNVWN27ZC@nVFh!fsdXTuFh^RRDksiOd*>}P zZQ@jpw0}@(Lpjov{7>wYY4?wSUnekzPsB3Y^G>&d(V6xBE9(7*toN$@6OpX%5YSfEo5 z1^PVML%y*d^e6fuxd9>je+NSLKkc+K=Aqp}y99mA@n((0Atm3ZrT$0SNu+IHy_ReP zrpdo5FKzrfug{*B>o=GiAGPpj-bCLp+IALgPad|zsWaaG z31OJ{C65wL#YyB}W$K@*U1!a{Ott6jhs`>Z{mdI&g}l|NyiHlK?^1a;%DgLt%gPHJ z3xQ)XaRh#Dg`WrbnSGnC?>ZZP^O>LedcGU$gY+N3w}~;4>*zhuv0c>HTyJAvQWk@5 z^f3yx&V&x_aP46E#6xe}#`1rW?T6hNsW^%G;RB;0aq`_5;+6FCnLOc6@dC@kS4Dk% z8vZH|Vbd?E^s!&+<6bb(45^O?ncw6eQK=thx@jE1eAZERT0?_-b2t7D#^)17+UHx;b|BH~v-v7|M$$F)CYrtE6@UX9<*Dy@^G=`x!He}ZQ z&*LUeE?*4UgD%wISB9CZ0Su~LYgSeM=z z7fy`NZuILQ>qzO#Y#VmB+Iy3-VUPa^ z(A1ZO2x+tW@l@>MQ3O1azKPm|Na!+Ir>^st0t}|i1sa7~s>jCYHO#K3z$fr4LOQ2t_f$dkR z!&i*;t}@C~`E2+Aus+-aKPmMp_Feeqb&D&uE)u>_pG(KPLVXU~+X=}6ILjiOB<#|F@&7;QU7IM$OzrzbM#WPnbp zJ?(c`bi%r}*>+=c*C>pHAySE#!VZ)s&~AT zwmA18G~9vxVfTjU3u+}F$+grwM8Mn&&{P_)25(~NRC9*FpJM)n_>;T|TAh;p;R%Mh zmy_!sJ>$a1IR^1z-PZV6I^Fc^SaXWZ{TVOy=_^0z{tU53hyFr2%f}PEz+9pX`K`Hx z+@Ep2`2=+6Ab61D8OIS1_fJ{lnbkK8Q~tPr{6o2ah5jmSS9<>n=X{*+(Z;Fj$ScDd zv{&B*`=cwsJ&YXJq_? zodugAXkJ(j81Xy8CEy8bkBOzTY(b7V~e(Yp%3vudoxZEnzZwhcEpVj zX_$E3=__AOKbzs!RuzYlUb^iN{CCxc5yAG@NZphPt+22(aeou``M@50swu2ZKURvi zj*?!ab%WEpkaV+X7OxIc*VpFI^;;CpY8A~mzipCqs?MTQy^T)QS#-)s%c7H&R-J=R zDvfj^Pg}HtZM~gsh%aoyev4p9@KF&6?W$ZS%9-mUz(uP*R*G`K?Xnp5s7t)C z_ZE09PvHf<>c!YYJtxplKDL)M2%xQ;M`+V)ORIX58u6#>!aos#y;>Q-ek1tL-I87* ztOfUqG1>1cO<88Yqc1)2WnL*WX!8f!lhqKy7|*ebyv{vYcf4=zLjz9S(@9#GSVfhn)Wi!u>e0yMzsCCQzgzS3`Jnk;mgQsamw3Miq3IueKyZE$ z1^oGvZ{QzK>>LiA!;3Rz{~gAj7U`ET_4TjR{M4vr*>lQZJe2-I@TkiFLzCC!oZ@2g z-)-if7&$L|;9J%A-hn#fy_cDfyv_RH8+GTx32WQRKA-5Z=g*PXjl2$p!!%RH#N+0f_=whZR9r%`;gQ=4arZ|d-aZI0M0w+6Gl*n?c@5p5%QD7-*)zc z=RWwJPv&`(zb}`(Z=N^d858c6_2A*W%ESED{#a`-F5eM8BvxV zS=_S_bUbtyY)$KIMd{*yN}mUTOwtCMMqcJ#EYSRi%$xXg>>KG7d+^)ZquR+j+J5$Q zEP;9ee+Y1A!8Y}pb4F21{rlO3-23LxR(ZoH>y~*RIC_l!0glay-B^dM#`y~FCGNij z=PL$ZBMkbAs(Ov1)IG$7IFX*|w*FnArI)OCau3&cj}BQleQ^TkS)yVFV0P1H4(>d9 zjP+{+-jc|}AD_VcukgLZ32Em0Pw@TC=-QM%lzGJQQmcH$(}sb)%&^_<=UE0n-ChY; z&XIJ!gJ|Cj$iz(8`5A3|=DiGjW_n8!2SI}wq`_OD!80caD|opvZq=E` zANMXNy1|cqVuyC?FMZl_`RDEf=N9_dv6)-I^G#W-* zae+jrw7i-7sJsiIm))9kSqb$N=v9DtsxHsL>!n?6;CxutRFJeCH zvE#~jsLws?P7!G9|1r)xHHF _9&fjR%gGYPa6#(}rcgc!>w-R7PCm(~pPafu>Tx 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%0DWeZ<7AQ1$Q-+@J}Cok>($$Ai3 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

L9xTLa3KIT7}orTN5tX5~bNo9H~8=1~v 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 s=~sYy~;s)pAR-dyG;p2UIxyL#j|t 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 xxkF9 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 Y8;Eyz#ZhJl&~U}pmgfgb(h=nTF9)3RBLDyZ literal 0 HcmV?d00001 diff --git a/quakespasm/Quake/Makefile b/quakespasm/Quake/Makefile index 30aa36ec..4ff4099d 100644 --- a/quakespasm/Quake/Makefile +++ b/quakespasm/Quake/Makefile @@ -10,6 +10,7 @@ USE_QS_CONBACK=1 ### Enable/Disable codecs for streaming music support USE_CODEC_WAVE=1 +USE_CODEC_FLAC=0 USE_CODEC_MP3=1 USE_CODEC_VORBIS=1 USE_CODEC_OPUS=0 @@ -136,6 +137,10 @@ CODECLIBS := ifeq ($(USE_CODEC_WAVE),1) CFLAGS+= -DUSE_CODEC_WAVE endif +ifeq ($(USE_CODEC_FLAC),1) +CFLAGS+= -DUSE_CODEC_FLAC +CODECLIBS+= -lFLAC +endif ifeq ($(USE_CODEC_OPUS),1) # opus and opusfile put their *.h under /opus, # but they include the headers without the opus directory @@ -178,6 +183,7 @@ DEFAULT_TARGET := quakespasm MUSIC_OBJS:= bgmusic.o \ snd_codec.o \ + snd_flac.o \ snd_wave.o \ snd_vorbis.o \ snd_opus.o \ diff --git a/quakespasm/Quake/Makefile.darwin b/quakespasm/Quake/Makefile.darwin index 19686b1f..c66c85a5 100644 --- a/quakespasm/Quake/Makefile.darwin +++ b/quakespasm/Quake/Makefile.darwin @@ -11,6 +11,7 @@ USE_QS_CONBACK=1 ### Enable/Disable codecs for streaming music support USE_CODEC_WAVE=1 +USE_CODEC_FLAC=1 USE_CODEC_MP3=1 USE_CODEC_VORBIS=1 USE_CODEC_OPUS=1 @@ -124,6 +125,12 @@ CODECLIBS := ifeq ($(USE_CODEC_WAVE),1) CFLAGS+= -DUSE_CODEC_WAVE endif +ifeq ($(USE_CODEC_FLAC),1) +CFLAGS+= -DUSE_CODEC_FLAC +CODEC_INC = -I../MacOSX/codecs/include +CODEC_LINK= -L../MacOSX/codecs/lib +CODECLIBS+= -lFLAC +endif ifeq ($(USE_CODEC_OPUS),1) CFLAGS+= -DUSE_CODEC_OPUS CODEC_INC = -I../MacOSX/codecs/include @@ -173,6 +180,7 @@ DEFAULT_TARGET := quakespasm MUSIC_OBJS:= bgmusic.o \ snd_codec.o \ + snd_flac.o \ snd_wave.o \ snd_vorbis.o \ snd_opus.o \ diff --git a/quakespasm/Quake/Makefile.w32 b/quakespasm/Quake/Makefile.w32 index 27b3e173..521ddaaf 100644 --- a/quakespasm/Quake/Makefile.w32 +++ b/quakespasm/Quake/Makefile.w32 @@ -11,6 +11,7 @@ USE_QS_CONBACK=1 ### Enable/disable codecs for streaming music support USE_CODEC_WAVE=1 +USE_CODEC_FLAC=0 USE_CODEC_MP3=1 USE_CODEC_VORBIS=1 USE_CODEC_OPUS=0 @@ -129,8 +130,12 @@ endif CODECLIBS := ifeq ($(USE_CODEC_WAVE),1) CFLAGS+= -DUSE_CODEC_WAVE +endif +ifeq ($(USE_CODEC_FLAC),1) +CFLAGS+= -DUSE_CODEC_FLAC CODEC_INC = -I../Windows/codecs/include CODEC_LINK= -L../Windows/codecs/x86 +CODECLIBS+= -lFLAC endif ifeq ($(USE_CODEC_OPUS),1) CFLAGS+= -DUSE_CODEC_OPUS @@ -179,6 +184,7 @@ DEFAULT_TARGET := quakespasm.exe MUSIC_OBJS:= bgmusic.o \ snd_codec.o \ + snd_flac.o \ snd_wave.o \ snd_vorbis.o \ snd_opus.o \ diff --git a/quakespasm/Quake/Makefile.w64 b/quakespasm/Quake/Makefile.w64 index 69eb3794..6f822c86 100644 --- a/quakespasm/Quake/Makefile.w64 +++ b/quakespasm/Quake/Makefile.w64 @@ -11,6 +11,7 @@ USE_QS_CONBACK=1 ### Enable/disable codecs for streaming music support USE_CODEC_WAVE=1 +USE_CODEC_FLAC=0 USE_CODEC_MP3=1 USE_CODEC_VORBIS=1 USE_CODEC_OPUS=0 @@ -129,8 +130,12 @@ endif CODECLIBS := ifeq ($(USE_CODEC_WAVE),1) CFLAGS+= -DUSE_CODEC_WAVE +endif +ifeq ($(USE_CODEC_FLAC),1) +CFLAGS+= -DUSE_CODEC_FLAC CODEC_INC = -I../Windows/codecs/include CODEC_LINK= -L../Windows/codecs/x64 +CODECLIBS+= -lFLAC endif ifeq ($(USE_CODEC_OPUS),1) CFLAGS+= -DUSE_CODEC_OPUS @@ -179,6 +184,7 @@ DEFAULT_TARGET := quakespasm.exe MUSIC_OBJS:= bgmusic.o \ snd_codec.o \ + snd_flac.o \ snd_wave.o \ snd_vorbis.o \ snd_opus.o \ diff --git a/quakespasm/Quake/snd_codec.c b/quakespasm/Quake/snd_codec.c index 9132a185..abfe63cf 100644 --- a/quakespasm/Quake/snd_codec.c +++ b/quakespasm/Quake/snd_codec.c @@ -29,6 +29,7 @@ /* headers for individual codecs */ #include "snd_wave.h" +#include "snd_flac.h" #include "snd_mp3.h" #include "snd_vorbis.h" #include "snd_opus.h" @@ -62,6 +63,9 @@ void S_CodecInit (void) #ifdef USE_CODEC_WAVE S_CodecRegister(&wav_codec); #endif +#ifdef USE_CODEC_FLAC + S_CodecRegister(&flac_codec); +#endif #ifdef USE_CODEC_MP3 S_CodecRegister(&mp3_codec); #endif diff --git a/quakespasm/Quake/snd_flac.c b/quakespasm/Quake/snd_flac.c new file mode 100644 index 00000000..36500eb7 --- /dev/null +++ b/quakespasm/Quake/snd_flac.c @@ -0,0 +1,392 @@ +/* + * fLaC streaming music support, loosely based QuakeForge implementation + * with modifications. requires libFLAC >= 1.0.4 at compile and runtime. + * + * Copyright (C) 2005 Bill Currie + * Copyright (C) 2013 O.Sezer + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include "quakedef.h" + +#if defined(USE_CODEC_FLAC) +#include "snd_codec.h" +#include "snd_codeci.h" +#include "snd_flac.h" + +#undef LEGACY_FLAC +#include +/* FLAC 1.1.3 has FLAC_API_VERSION_CURRENT == 8 */ +#if !defined(FLAC_API_VERSION_CURRENT) || ((FLAC_API_VERSION_CURRENT+0) < 8) +#define LEGACY_FLAC +#include +#endif +#include + +#ifdef LEGACY_FLAC +#define FLAC__StreamDecoder FLAC__SeekableStreamDecoder +#define FLAC__StreamDecoderReadStatus FLAC__SeekableStreamDecoderReadStatus +#define FLAC__StreamDecoderSeekStatus FLAC__SeekableStreamDecoderSeekStatus +#define FLAC__StreamDecoderTellStatus FLAC__SeekableStreamDecoderTellStatus +#define FLAC__StreamDecoderLengthStatus FLAC__SeekableStreamDecoderLengthStatus + +#define FLAC__stream_decoder_new FLAC__seekable_stream_decoder_new +#define FLAC__stream_decoder_finish FLAC__seekable_stream_decoder_finish +#define FLAC__stream_decoder_delete FLAC__seekable_stream_decoder_delete +#define FLAC__stream_decoder_process_single FLAC__seekable_stream_decoder_process_single +#define FLAC__stream_decoder_seek_absolute FLAC__seekable_stream_decoder_seek_absolute +#define FLAC__stream_decoder_process_until_end_of_metadata FLAC__seekable_stream_decoder_process_until_end_of_metadata +#define FLAC__stream_decoder_get_state FLAC__seekable_stream_decoder_get_state + +#define FLAC__STREAM_DECODER_INIT_STATUS_OK FLAC__SEEKABLE_STREAM_DECODER_OK +#define FLAC__STREAM_DECODER_READ_STATUS_CONTINUE FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK +#define FLAC__STREAM_DECODER_READ_STATUS_ABORT FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR +#define FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK /* !!! */ +#define FLAC__STREAM_DECODER_WRITE_STATUS_ABORT FLAC__STREAM_DECODER_WRITE_STATUS_ABORT +#define FLAC__STREAM_DECODER_SEEK_STATUS_OK FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK +#define FLAC__STREAM_DECODER_SEEK_STATUS_ERROR FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR +#define FLAC__STREAM_DECODER_TELL_STATUS_OK FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK +#define FLAC__STREAM_DECODER_TELL_STATUS_ERROR FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR +#define FLAC__STREAM_DECODER_LENGTH_STATUS_OK FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK +#endif + +typedef struct { + FLAC__StreamDecoder *decoder; + fshandle_t *file; + FLAC__StreamMetadata_StreamInfo info; + byte *buffer; + int size, pos, error; +} flacfile_t; + +/* CALLBACK FUNCTIONS: */ +static void +flac_error_func (const FLAC__StreamDecoder *decoder, + FLAC__StreamDecoderErrorStatus status, void *client_data) +{ + flacfile_t *ff = (flacfile_t *) client_data; + ff->error = -1; + Con_Printf ("FLAC: decoder error %i\n", status); +} + +static FLAC__StreamDecoderReadStatus +flac_read_func (const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], + size_t *bytes, void *client_data) +{ + flacfile_t *ff = (flacfile_t *) client_data; + if (*bytes > 0) + { + *bytes = FS_fread(buffer, 1, *bytes, ff->file); + if (FS_ferror(ff->file)) + return FLAC__STREAM_DECODER_READ_STATUS_ABORT; + if (*bytes == 0) + return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM; + return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; + } + return FLAC__STREAM_DECODER_READ_STATUS_ABORT; +} + +static FLAC__StreamDecoderSeekStatus +flac_seek_func (const FLAC__StreamDecoder *decoder, + FLAC__uint64 absolute_byte_offset, void *client_data) +{ + flacfile_t *ff = (flacfile_t *) client_data; + if (FS_fseek(ff->file, (long)absolute_byte_offset, SEEK_SET) < 0) + return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR; + return FLAC__STREAM_DECODER_SEEK_STATUS_OK; +} + +static FLAC__StreamDecoderTellStatus +flac_tell_func (const FLAC__StreamDecoder *decoder, + FLAC__uint64 *absolute_byte_offset, void *client_data) +{ + flacfile_t *ff = (flacfile_t *) client_data; + long pos = FS_ftell (ff->file); + if (pos < 0) return FLAC__STREAM_DECODER_TELL_STATUS_ERROR; + *absolute_byte_offset = (FLAC__uint64) pos; + return FLAC__STREAM_DECODER_TELL_STATUS_OK; +} + +static FLAC__StreamDecoderLengthStatus +flac_length_func (const FLAC__StreamDecoder *decoder, + FLAC__uint64 *stream_length, void *client_data) +{ + flacfile_t *ff = (flacfile_t *) client_data; + *stream_length = (FLAC__uint64) ff->file->length; + return FLAC__STREAM_DECODER_LENGTH_STATUS_OK; +} + +static FLAC__bool +flac_eof_func (const FLAC__StreamDecoder *decoder, void *client_data) +{ + flacfile_t *ff = (flacfile_t *) client_data; + if (FS_feof (ff->file)) return true; + return false; +} + +static FLAC__StreamDecoderWriteStatus +flac_write_func (const FLAC__StreamDecoder *decoder, + const FLAC__Frame *frame, const FLAC__int32 * const buffer[], + void *client_data) +{ + flacfile_t *ff = (flacfile_t *) client_data; + int bps = ff->info.bits_per_sample / 8; + + if (!ff->buffer) { +#if 1 /*!defined(CODECS_USE_ZONE)*/ + ff->buffer = (byte *) malloc (ff->info.max_blocksize * ff->info.channels * bps); + if (!ff->buffer) { + ff->error = -1; /* needn't set this here, but... */ + Con_Printf("Insufficient memory for fLaC audio\n"); + return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; + } +#else + ff->buffer = (byte *) Z_Malloc (ff->info.max_blocksize * ff->info.channels * bps); +#endif + } + if (ff->info.channels == 1) + { + unsigned i; + const FLAC__int32 *in = buffer[0]; + + if (ff->info.bits_per_sample == 8) + { + byte *out = ff->buffer; + for (i = 0; i < frame->header.blocksize; i++) + *out++ = *in++ + 128; + } + else + { + short *out = (short *) ff->buffer; + for (i = 0; i < frame->header.blocksize; i++) + *out++ = *in++; + } + } + else + { + unsigned i; + const FLAC__int32 *li = buffer[0]; + const FLAC__int32 *ri = buffer[1]; + + if (ff->info.bits_per_sample == 8) + { + char *lo = (char *) ff->buffer + 0; + char *ro = (char *) ff->buffer + 1; + for (i = 0; i < frame->header.blocksize; i++, lo++, ro++) + { + *lo++ = *li++ + 128; + *ro++ = *ri++ + 128; + } + } + else + { + short *lo = (short *) ff->buffer + 0; + short *ro = (short *) ff->buffer + 1; + for (i = 0; i < frame->header.blocksize; i++, lo++, ro++) + { + *lo++ = LittleShort (*li++); + *ro++ = LittleShort (*ri++); + } + } + } + + ff->size = frame->header.blocksize * bps * ff->info.channels; + ff->pos = 0; + return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; +} + +static void +flac_meta_func (const FLAC__StreamDecoder *decoder, + const FLAC__StreamMetadata *metadata, void *client_data) +{ + flacfile_t *ff = (flacfile_t *) client_data; + if (metadata->type == FLAC__METADATA_TYPE_STREAMINFO) + ff->info = metadata->data.stream_info; +} + + +static qboolean S_FLAC_CodecInitialize (void) +{ + return true; +} + +static void S_FLAC_CodecShutdown (void) +{ +} + +static snd_stream_t *S_FLAC_CodecOpenStream (const char *filename) +{ + snd_stream_t *stream; + flacfile_t *ff; + int rc; + + stream = S_CodecUtilOpen(filename, &flac_codec); + if (!stream) + return NULL; + + ff = (flacfile_t *) Z_Malloc(sizeof(flacfile_t)); + + ff->decoder = FLAC__stream_decoder_new (); + if (ff->decoder == NULL) + { + Con_Printf("Unable to create fLaC decoder\n"); + goto _fail; + } + + stream->priv = ff; + ff->file = & stream->fh; + +#ifdef LEGACY_FLAC + FLAC__seekable_stream_decoder_set_error_callback (ff->decoder, flac_error_func); + FLAC__seekable_stream_decoder_set_read_callback (ff->decoder, flac_read_func); + FLAC__seekable_stream_decoder_set_seek_callback (ff->decoder, flac_seek_func); + FLAC__seekable_stream_decoder_set_tell_callback (ff->decoder, flac_tell_func); + FLAC__seekable_stream_decoder_set_length_callback (ff->decoder, flac_length_func); + FLAC__seekable_stream_decoder_set_eof_callback (ff->decoder, flac_eof_func); + FLAC__seekable_stream_decoder_set_write_callback (ff->decoder, flac_write_func); + FLAC__seekable_stream_decoder_set_metadata_callback (ff->decoder, flac_meta_func); + FLAC__seekable_stream_decoder_set_client_data (ff->decoder, ff); + rc = FLAC__seekable_stream_decoder_init (ff->decoder); +#else + rc = FLAC__stream_decoder_init_stream(ff->decoder, + flac_read_func, + flac_seek_func, + flac_tell_func, + flac_length_func, + flac_eof_func, + flac_write_func, + flac_meta_func, + flac_error_func, + ff); +#endif + if (rc != FLAC__STREAM_DECODER_INIT_STATUS_OK) /* unlikely */ + { + Con_Printf ("FLAC: decoder init error %i\n", rc); + goto _fail; + } + + rc = FLAC__stream_decoder_process_until_end_of_metadata (ff->decoder); + if (rc == false) + { + rc = FLAC__stream_decoder_get_state(ff->decoder); + Con_Printf("%s not a valid fLaC file? (error %i)\n", + filename, rc); + goto _fail; + } + if (ff->error) /* set by flac_error_func(). can we hit it here?? */ + goto _fail; + + if (ff->info.total_samples == 0) + { + Con_Printf("Zero sample count in %s\n", filename); + goto _fail; + } + if (ff->info.channels != 1 && ff->info.channels != 2) + { + Con_Printf("Unsupported number of channels %d in %s\n", + ff->info.channels, filename); + goto _fail; + } + + stream->info.rate = ff->info.sample_rate; + stream->info.width = ff->info.bits_per_sample / 8; + stream->info.channels = ff->info.channels; + + return stream; +_fail: + if (ff->decoder) + { + FLAC__stream_decoder_finish (ff->decoder); + FLAC__stream_decoder_delete (ff->decoder); + } + Z_Free(ff); + S_CodecUtilClose(&stream); + return NULL; +} + +static int S_FLAC_CodecReadStream (snd_stream_t *stream, int len, void *buffer) +{ + flacfile_t *ff = (flacfile_t *) stream->priv; + byte *buf = (byte *) buffer; + int count = 0; + + while (len) { + int res = 0; + if (ff->size == ff->pos) + FLAC__stream_decoder_process_single (ff->decoder); + if (ff->error) return -1; + res = ff->size - ff->pos; + if (res > len) + res = len; + if (res > 0) { + memcpy (buf, ff->buffer + ff->pos, res); + count += res; + len -= res; + buf += res; + ff->pos += res; + } else if (res < 0) { /* error */ + return -1; + } else { + Con_DPrintf ("FLAC: EOF\n"); + break; + } + } + return count; +} + +static void S_FLAC_CodecCloseStream (snd_stream_t *stream) +{ + flacfile_t *ff = (flacfile_t *) stream->priv; + + FLAC__stream_decoder_finish (ff->decoder); + FLAC__stream_decoder_delete (ff->decoder); + + if (ff->buffer) +#if 0 /*defined(CODECS_USE_ZONE)*/ + Z_Free(ff->buffer); +#else + free(ff->buffer); +#endif + Z_Free(ff); + + S_CodecUtilClose(&stream); +} + +static int S_FLAC_CodecRewindStream (snd_stream_t *stream) +{ + flacfile_t *ff = (flacfile_t *) stream->priv; + + ff->pos = ff->size = 0; + return FLAC__stream_decoder_seek_absolute (ff->decoder, 0); +} + +snd_codec_t flac_codec = +{ + CODECTYPE_FLAC, + true, /* always available. */ + "flac", + S_FLAC_CodecInitialize, + S_FLAC_CodecShutdown, + S_FLAC_CodecOpenStream, + S_FLAC_CodecReadStream, + S_FLAC_CodecRewindStream, + S_FLAC_CodecCloseStream, + NULL +}; + +#endif /* USE_CODEC_FLAC */ + diff --git a/quakespasm/Quake/snd_flac.h b/quakespasm/Quake/snd_flac.h new file mode 100644 index 00000000..4cedf824 --- /dev/null +++ b/quakespasm/Quake/snd_flac.h @@ -0,0 +1,13 @@ +/* fLaC streaming music support. */ + +#if !defined(_SND_FLAC_H_) +#define _SND_FLAC_H_ 1 + +#if defined(USE_CODEC_FLAC) + +extern snd_codec_t flac_codec; + +#endif /* USE_CODEC_FLAC */ + +#endif /* ! _SND_FLAC_H_ */ + diff --git a/quakespasm/Windows/CodeBlocks/QuakeSpasm.cbp b/quakespasm/Windows/CodeBlocks/QuakeSpasm.cbp index 7cb4c6ba..08fdc9ef 100644 --- a/quakespasm/Windows/CodeBlocks/QuakeSpasm.cbp +++ b/quakespasm/Windows/CodeBlocks/QuakeSpasm.cbp @@ -36,6 +36,7 @@ + @@ -47,6 +48,7 @@ + @@ -265,6 +267,10 @@ + + + diff --git a/quakespasm/Windows/VisualStudio/quakespasm.vcproj b/quakespasm/Windows/VisualStudio/quakespasm.vcproj index e456937c..32bb3506 100644 --- a/quakespasm/Windows/VisualStudio/quakespasm.vcproj +++ b/quakespasm/Windows/VisualStudio/quakespasm.vcproj @@ -41,7 +41,7 @@ Name="VCCLCompilerTool" Optimization="0" AdditionalIncludeDirectories="C:\SDL\include;..\codecs\include;..\..\Quake;.;.." - PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;USE_QS_CONBACK;USE_CODEC_MP3;USE_CODEC_VORBIS;USE_CODEC_WAVE;USE_CODEC_OPUS" + PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;USE_QS_CONBACK;USE_CODEC_MP3;USE_CODEC_VORBIS;USE_CODEC_WAVE;USE_CODEC_FLAC;USE_CODEC_OPUS" MinimalRebuild="true" BasicRuntimeChecks="3" RuntimeLibrary="3" @@ -61,7 +61,7 @@ /> + + @@ -819,6 +823,10 @@ RelativePath="..\..\Quake\snd_codeci.h" > + + diff --git a/quakespasm/Windows/codecs/include/FLAC/all.h b/quakespasm/Windows/codecs/include/FLAC/all.h new file mode 100644 index 00000000..9e288528 --- /dev/null +++ b/quakespasm/Windows/codecs/include/FLAC/all.h @@ -0,0 +1,371 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__ALL_H +#define FLAC__ALL_H + +#include "export.h" + +#include "assert.h" +#include "callback.h" +#include "format.h" +#include "metadata.h" +#include "ordinals.h" +#include "stream_decoder.h" +#include "stream_encoder.h" + +/** \mainpage + * + * \section intro Introduction + * + * This is the documentation for the FLAC C and C++ APIs. It is + * highly interconnected; this introduction should give you a top + * level idea of the structure and how to find the information you + * need. As a prerequisite you should have at least a basic + * knowledge of the FLAC format, documented + * here. + * + * \section c_api FLAC C API + * + * The FLAC C API is the interface to libFLAC, a set of structures + * describing the components of FLAC streams, and functions for + * encoding and decoding streams, as well as manipulating FLAC + * metadata in files. The public include files will be installed + * in your include area (for example /usr/include/FLAC/...). + * + * By writing a little code and linking against libFLAC, it is + * relatively easy to add FLAC support to another program. The + * library is licensed under Xiph's BSD license. + * Complete source code of libFLAC as well as the command-line + * encoder and plugins is available and is a useful source of + * examples. + * + * Aside from encoders and decoders, libFLAC provides a powerful + * metadata interface for manipulating metadata in FLAC files. It + * allows the user to add, delete, and modify FLAC metadata blocks + * and it can automatically take advantage of PADDING blocks to avoid + * rewriting the entire FLAC file when changing the size of the + * metadata. + * + * libFLAC usually only requires the standard C library and C math + * library. In particular, threading is not used so there is no + * dependency on a thread library. However, libFLAC does not use + * global variables and should be thread-safe. + * + * libFLAC also supports encoding to and decoding from Ogg FLAC. + * However the metadata editing interfaces currently have limited + * read-only support for Ogg FLAC files. + * + * \section cpp_api FLAC C++ API + * + * The FLAC C++ API is a set of classes that encapsulate the + * structures and functions in libFLAC. They provide slightly more + * functionality with respect to metadata but are otherwise + * equivalent. For the most part, they share the same usage as + * their counterparts in libFLAC, and the FLAC C API documentation + * can be used as a supplement. The public include files + * for the C++ API will be installed in your include area (for + * example /usr/include/FLAC++/...). + * + * libFLAC++ is also licensed under + * Xiph's BSD license. + * + * \section getting_started Getting Started + * + * A good starting point for learning the API is to browse through + * the modules. Modules are logical + * groupings of related functions or classes, which correspond roughly + * to header files or sections of header files. Each module includes a + * detailed description of the general usage of its functions or + * classes. + * + * From there you can go on to look at the documentation of + * individual functions. You can see different views of the individual + * functions through the links in top bar across this page. + * + * If you prefer a more hands-on approach, you can jump right to some + * example code. + * + * \section porting_guide Porting Guide + * + * Starting with FLAC 1.1.3 a \link porting Porting Guide \endlink + * has been introduced which gives detailed instructions on how to + * port your code to newer versions of FLAC. + * + * \section embedded_developers Embedded Developers + * + * libFLAC has grown larger over time as more functionality has been + * included, but much of it may be unnecessary for a particular embedded + * implementation. Unused parts may be pruned by some simple editing of + * src/libFLAC/Makefile.am. In general, the decoders, encoders, and + * metadata interface are all independent from each other. + * + * It is easiest to just describe the dependencies: + * + * - All modules depend on the \link flac_format Format \endlink module. + * - The decoders and encoders depend on the bitbuffer. + * - The decoder is independent of the encoder. The encoder uses the + * decoder because of the verify feature, but this can be removed if + * not needed. + * - Parts of the metadata interface require the stream decoder (but not + * the encoder). + * - Ogg support is selectable through the compile time macro + * \c FLAC__HAS_OGG. + * + * For example, if your application only requires the stream decoder, no + * encoder, and no metadata interface, you can remove the stream encoder + * and the metadata interface, which will greatly reduce the size of the + * library. + * + * Also, there are several places in the libFLAC code with comments marked + * with "OPT:" where a #define can be changed to enable code that might be + * faster on a specific platform. Experimenting with these can yield faster + * binaries. + */ + +/** \defgroup porting Porting Guide for New Versions + * + * This module describes differences in the library interfaces from + * version to version. It assists in the porting of code that uses + * the libraries to newer versions of FLAC. + * + * One simple facility for making porting easier that has been added + * in FLAC 1.1.3 is a set of \c #defines in \c export.h of each + * library's includes (e.g. \c include/FLAC/export.h). The + * \c #defines mirror the libraries' + * libtool version numbers, + * e.g. in libFLAC there are \c FLAC_API_VERSION_CURRENT, + * \c FLAC_API_VERSION_REVISION, and \c FLAC_API_VERSION_AGE. + * These can be used to support multiple versions of an API during the + * transition phase, e.g. + * + * \code + * #if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7 + * legacy code + * #else + * new code + * #endif + * \endcode + * + * The the source will work for multiple versions and the legacy code can + * easily be removed when the transition is complete. + * + * Another available symbol is FLAC_API_SUPPORTS_OGG_FLAC (defined in + * include/FLAC/export.h), which can be used to determine whether or not + * the library has been compiled with support for Ogg FLAC. This is + * simpler than trying to call an Ogg init function and catching the + * error. + */ + +/** \defgroup porting_1_1_2_to_1_1_3 Porting from FLAC 1.1.2 to 1.1.3 + * \ingroup porting + * + * \brief + * This module describes porting from FLAC 1.1.2 to FLAC 1.1.3. + * + * The main change between the APIs in 1.1.2 and 1.1.3 is that they have + * been simplified. First, libOggFLAC has been merged into libFLAC and + * libOggFLAC++ has been merged into libFLAC++. Second, both the three + * decoding layers and three encoding layers have been merged into a + * single stream decoder and stream encoder. That is, the functionality + * of FLAC__SeekableStreamDecoder and FLAC__FileDecoder has been merged + * into FLAC__StreamDecoder, and FLAC__SeekableStreamEncoder and + * FLAC__FileEncoder into FLAC__StreamEncoder. Only the + * FLAC__StreamDecoder and FLAC__StreamEncoder remain. What this means + * is there is now a single API that can be used to encode or decode + * streams to/from native FLAC or Ogg FLAC and the single API can work + * on both seekable and non-seekable streams. + * + * Instead of creating an encoder or decoder of a certain layer, now the + * client will always create a FLAC__StreamEncoder or + * FLAC__StreamDecoder. The old layers are now differentiated by the + * initialization function. For example, for the decoder, + * FLAC__stream_decoder_init() has been replaced by + * FLAC__stream_decoder_init_stream(). This init function takes + * callbacks for the I/O, and the seeking callbacks are optional. This + * allows the client to use the same object for seekable and + * non-seekable streams. For decoding a FLAC file directly, the client + * can use FLAC__stream_decoder_init_file() and pass just a filename + * and fewer callbacks; most of the other callbacks are supplied + * internally. For situations where fopen()ing by filename is not + * possible (e.g. Unicode filenames on Windows) the client can instead + * open the file itself and supply the FILE* to + * FLAC__stream_decoder_init_FILE(). The init functions now returns a + * FLAC__StreamDecoderInitStatus instead of FLAC__StreamDecoderState. + * Since the callbacks and client data are now passed to the init + * function, the FLAC__stream_decoder_set_*_callback() functions and + * FLAC__stream_decoder_set_client_data() are no longer needed. The + * rest of the calls to the decoder are the same as before. + * + * There are counterpart init functions for Ogg FLAC, e.g. + * FLAC__stream_decoder_init_ogg_stream(). All the rest of the calls + * and callbacks are the same as for native FLAC. + * + * As an example, in FLAC 1.1.2 a seekable stream decoder would have + * been set up like so: + * + * \code + * FLAC__SeekableStreamDecoder *decoder = FLAC__seekable_stream_decoder_new(); + * if(decoder == NULL) do_something; + * FLAC__seekable_stream_decoder_set_md5_checking(decoder, true); + * [... other settings ...] + * FLAC__seekable_stream_decoder_set_read_callback(decoder, my_read_callback); + * FLAC__seekable_stream_decoder_set_seek_callback(decoder, my_seek_callback); + * FLAC__seekable_stream_decoder_set_tell_callback(decoder, my_tell_callback); + * FLAC__seekable_stream_decoder_set_length_callback(decoder, my_length_callback); + * FLAC__seekable_stream_decoder_set_eof_callback(decoder, my_eof_callback); + * FLAC__seekable_stream_decoder_set_write_callback(decoder, my_write_callback); + * FLAC__seekable_stream_decoder_set_metadata_callback(decoder, my_metadata_callback); + * FLAC__seekable_stream_decoder_set_error_callback(decoder, my_error_callback); + * FLAC__seekable_stream_decoder_set_client_data(decoder, my_client_data); + * if(FLAC__seekable_stream_decoder_init(decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK) do_something; + * \endcode + * + * In FLAC 1.1.3 it is like this: + * + * \code + * FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new(); + * if(decoder == NULL) do_something; + * FLAC__stream_decoder_set_md5_checking(decoder, true); + * [... other settings ...] + * if(FLAC__stream_decoder_init_stream( + * decoder, + * my_read_callback, + * my_seek_callback, // or NULL + * my_tell_callback, // or NULL + * my_length_callback, // or NULL + * my_eof_callback, // or NULL + * my_write_callback, + * my_metadata_callback, // or NULL + * my_error_callback, + * my_client_data + * ) != FLAC__STREAM_DECODER_INIT_STATUS_OK) do_something; + * \endcode + * + * or you could do; + * + * \code + * [...] + * FILE *file = fopen("somefile.flac","rb"); + * if(file == NULL) do_somthing; + * if(FLAC__stream_decoder_init_FILE( + * decoder, + * file, + * my_write_callback, + * my_metadata_callback, // or NULL + * my_error_callback, + * my_client_data + * ) != FLAC__STREAM_DECODER_INIT_STATUS_OK) do_something; + * \endcode + * + * or just: + * + * \code + * [...] + * if(FLAC__stream_decoder_init_file( + * decoder, + * "somefile.flac", + * my_write_callback, + * my_metadata_callback, // or NULL + * my_error_callback, + * my_client_data + * ) != FLAC__STREAM_DECODER_INIT_STATUS_OK) do_something; + * \endcode + * + * Another small change to the decoder is in how it handles unparseable + * streams. Before, when the decoder found an unparseable stream + * (reserved for when the decoder encounters a stream from a future + * encoder that it can't parse), it changed the state to + * \c FLAC__STREAM_DECODER_UNPARSEABLE_STREAM. Now the decoder instead + * drops sync and calls the error callback with a new error code + * \c FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM. This is + * more robust. If your error callback does not discriminate on the the + * error state, your code does not need to be changed. + * + * The encoder now has a new setting: + * FLAC__stream_encoder_set_apodization(). This is for setting the + * method used to window the data before LPC analysis. You only need to + * add a call to this function if the default is not suitable. There + * are also two new convenience functions that may be useful: + * FLAC__metadata_object_cuesheet_calculate_cddb_id() and + * FLAC__metadata_get_cuesheet(). + * + * The \a bytes parameter to FLAC__StreamDecoderReadCallback, + * FLAC__StreamEncoderReadCallback, and FLAC__StreamEncoderWriteCallback + * is now \c size_t instead of \c unsigned. + */ + +/** \defgroup porting_1_1_3_to_1_1_4 Porting from FLAC 1.1.3 to 1.1.4 + * \ingroup porting + * + * \brief + * This module describes porting from FLAC 1.1.3 to FLAC 1.1.4. + * + * There were no changes to any of the interfaces from 1.1.3 to 1.1.4. + * There was a slight change in the implementation of + * FLAC__stream_encoder_set_metadata(); the function now makes a copy + * of the \a metadata array of pointers so the client no longer needs + * to maintain it after the call. The objects themselves that are + * pointed to by the array are still not copied though and must be + * maintained until the call to FLAC__stream_encoder_finish(). + */ + +/** \defgroup porting_1_1_4_to_1_2_0 Porting from FLAC 1.1.4 to 1.2.0 + * \ingroup porting + * + * \brief + * This module describes porting from FLAC 1.1.4 to FLAC 1.2.0. + * + * There were only very minor changes to the interfaces from 1.1.4 to 1.2.0. + * In libFLAC, \c FLAC__format_sample_rate_is_subset() was added. + * In libFLAC++, \c FLAC::Decoder::Stream::get_decode_position() was added. + * + * Finally, value of the constant \c FLAC__FRAME_HEADER_RESERVED_LEN + * has changed to reflect the conversion of one of the reserved bits + * into active use. It used to be \c 2 and now is \c 1. However the + * FLAC frame header length has not changed, so to skip the proper + * number of bits, use \c FLAC__FRAME_HEADER_RESERVED_LEN + + * \c FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN + */ + +/** \defgroup flac FLAC C API + * + * The FLAC C API is the interface to libFLAC, a set of structures + * describing the components of FLAC streams, and functions for + * encoding and decoding streams, as well as manipulating FLAC + * metadata in files. + * + * You should start with the format components as all other modules + * are dependent on it. + */ + +#endif diff --git a/quakespasm/Windows/codecs/include/FLAC/assert.h b/quakespasm/Windows/codecs/include/FLAC/assert.h new file mode 100644 index 00000000..787cea91 --- /dev/null +++ b/quakespasm/Windows/codecs/include/FLAC/assert.h @@ -0,0 +1,46 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2001-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__ASSERT_H +#define FLAC__ASSERT_H + +/* we need this since some compilers (like MSVC) leave assert()s on release code (and we don't want to use their ASSERT) */ +#ifdef DEBUG +#include +#define FLAC__ASSERT(x) assert(x) +#define FLAC__ASSERT_DECLARATION(x) x +#else +#define FLAC__ASSERT(x) +#define FLAC__ASSERT_DECLARATION(x) +#endif + +#endif diff --git a/quakespasm/Windows/codecs/include/FLAC/callback.h b/quakespasm/Windows/codecs/include/FLAC/callback.h new file mode 100644 index 00000000..71bbaec6 --- /dev/null +++ b/quakespasm/Windows/codecs/include/FLAC/callback.h @@ -0,0 +1,185 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2004-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__CALLBACK_H +#define FLAC__CALLBACK_H + +#include "ordinals.h" +#include /* for size_t */ + +/** \file include/FLAC/callback.h + * + * \brief + * This module defines the structures for describing I/O callbacks + * to the other FLAC interfaces. + * + * See the detailed documentation for callbacks in the + * \link flac_callbacks callbacks \endlink module. + */ + +/** \defgroup flac_callbacks FLAC/callback.h: I/O callback structures + * \ingroup flac + * + * \brief + * This module defines the structures for describing I/O callbacks + * to the other FLAC interfaces. + * + * The purpose of the I/O callback functions is to create a common way + * for the metadata interfaces to handle I/O. + * + * Originally the metadata interfaces required filenames as the way of + * specifying FLAC files to operate on. This is problematic in some + * environments so there is an additional option to specify a set of + * callbacks for doing I/O on the FLAC file, instead of the filename. + * + * In addition to the callbacks, a FLAC__IOHandle type is defined as an + * opaque structure for a data source. + * + * The callback function prototypes are similar (but not identical) to the + * stdio functions fread, fwrite, fseek, ftell, feof, and fclose. If you use + * stdio streams to implement the callbacks, you can pass fread, fwrite, and + * fclose anywhere a FLAC__IOCallback_Read, FLAC__IOCallback_Write, or + * FLAC__IOCallback_Close is required, and a FILE* anywhere a FLAC__IOHandle + * is required. \warning You generally CANNOT directly use fseek or ftell + * for FLAC__IOCallback_Seek or FLAC__IOCallback_Tell since on most systems + * these use 32-bit offsets and FLAC requires 64-bit offsets to deal with + * large files. You will have to find an equivalent function (e.g. ftello), + * or write a wrapper. The same is true for feof() since this is usually + * implemented as a macro, not as a function whose address can be taken. + * + * \{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** This is the opaque handle type used by the callbacks. Typically + * this is a \c FILE* or address of a file descriptor. + */ +typedef void* FLAC__IOHandle; + +/** Signature for the read callback. + * The signature and semantics match POSIX fread() implementations + * and can generally be used interchangeably. + * + * \param ptr The address of the read buffer. + * \param size The size of the records to be read. + * \param nmemb The number of records to be read. + * \param handle The handle to the data source. + * \retval size_t + * The number of records read. + */ +typedef size_t (*FLAC__IOCallback_Read) (void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle); + +/** Signature for the write callback. + * The signature and semantics match POSIX fwrite() implementations + * and can generally be used interchangeably. + * + * \param ptr The address of the write buffer. + * \param size The size of the records to be written. + * \param nmemb The number of records to be written. + * \param handle The handle to the data source. + * \retval size_t + * The number of records written. + */ +typedef size_t (*FLAC__IOCallback_Write) (const void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle); + +/** Signature for the seek callback. + * The signature and semantics mostly match POSIX fseek() WITH ONE IMPORTANT + * EXCEPTION: the offset is a 64-bit type whereas fseek() is generally 'long' + * and 32-bits wide. + * + * \param handle The handle to the data source. + * \param offset The new position, relative to \a whence + * \param whence \c SEEK_SET, \c SEEK_CUR, or \c SEEK_END + * \retval int + * \c 0 on success, \c -1 on error. + */ +typedef int (*FLAC__IOCallback_Seek) (FLAC__IOHandle handle, FLAC__int64 offset, int whence); + +/** Signature for the tell callback. + * The signature and semantics mostly match POSIX ftell() WITH ONE IMPORTANT + * EXCEPTION: the offset is a 64-bit type whereas ftell() is generally 'long' + * and 32-bits wide. + * + * \param handle The handle to the data source. + * \retval FLAC__int64 + * The current position on success, \c -1 on error. + */ +typedef FLAC__int64 (*FLAC__IOCallback_Tell) (FLAC__IOHandle handle); + +/** Signature for the EOF callback. + * The signature and semantics mostly match POSIX feof() but WATCHOUT: + * on many systems, feof() is a macro, so in this case a wrapper function + * must be provided instead. + * + * \param handle The handle to the data source. + * \retval int + * \c 0 if not at end of file, nonzero if at end of file. + */ +typedef int (*FLAC__IOCallback_Eof) (FLAC__IOHandle handle); + +/** Signature for the close callback. + * The signature and semantics match POSIX fclose() implementations + * and can generally be used interchangeably. + * + * \param handle The handle to the data source. + * \retval int + * \c 0 on success, \c EOF on error. + */ +typedef int (*FLAC__IOCallback_Close) (FLAC__IOHandle handle); + +/** A structure for holding a set of callbacks. + * Each FLAC interface that requires a FLAC__IOCallbacks structure will + * describe which of the callbacks are required. The ones that are not + * required may be set to NULL. + * + * If the seek requirement for an interface is optional, you can signify that + * a data sorce is not seekable by setting the \a seek field to \c NULL. + */ +typedef struct { + FLAC__IOCallback_Read read; + FLAC__IOCallback_Write write; + FLAC__IOCallback_Seek seek; + FLAC__IOCallback_Tell tell; + FLAC__IOCallback_Eof eof; + FLAC__IOCallback_Close close; +} FLAC__IOCallbacks; + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/Windows/codecs/include/FLAC/export.h b/quakespasm/Windows/codecs/include/FLAC/export.h new file mode 100644 index 00000000..2232b410 --- /dev/null +++ b/quakespasm/Windows/codecs/include/FLAC/export.h @@ -0,0 +1,97 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__EXPORT_H +#define FLAC__EXPORT_H + +/** \file include/FLAC/export.h + * + * \brief + * This module contains #defines and symbols for exporting function + * calls, and providing version information and compiled-in features. + * + * See the \link flac_export export \endlink module. + */ + +/** \defgroup flac_export FLAC/export.h: export symbols + * \ingroup flac + * + * \brief + * This module contains #defines and symbols for exporting function + * calls, and providing version information and compiled-in features. + * + * If you are compiling with MSVC and will link to the static library + * (libFLAC.lib) you should define FLAC__NO_DLL in your project to + * make sure the symbols are exported properly. + * + * \{ + */ + +#if defined(FLAC__NO_DLL) +#define FLAC_API + +#elif defined(_MSC_VER) +#ifdef FLAC_API_EXPORTS +#define FLAC_API _declspec(dllexport) +#else +#define FLAC_API _declspec(dllimport) +#endif + +#elif defined(FLAC__USE_VISIBILITY_ATTR) +#define FLAC_API __attribute__ ((visibility ("default"))) + +#else +#define FLAC_API + +#endif + +/** These #defines will mirror the libtool-based library version number, see + * http://www.gnu.org/software/libtool/manual/libtool.html#Libtool-versioning + */ +#define FLAC_API_VERSION_CURRENT 11 +#define FLAC_API_VERSION_REVISION 0 /**< see above */ +#define FLAC_API_VERSION_AGE 3 /**< see above */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** \c 1 if the library has been compiled with support for Ogg FLAC, else \c 0. */ +extern FLAC_API int FLAC_API_SUPPORTS_OGG_FLAC; + +#ifdef __cplusplus +} +#endif + +/* \} */ + +#endif diff --git a/quakespasm/Windows/codecs/include/FLAC/format.h b/quakespasm/Windows/codecs/include/FLAC/format.h new file mode 100644 index 00000000..e4c1c1a6 --- /dev/null +++ b/quakespasm/Windows/codecs/include/FLAC/format.h @@ -0,0 +1,1023 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__FORMAT_H +#define FLAC__FORMAT_H + +#include "export.h" +#include "ordinals.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** \file include/FLAC/format.h + * + * \brief + * This module contains structure definitions for the representation + * of FLAC format components in memory. These are the basic + * structures used by the rest of the interfaces. + * + * See the detailed documentation in the + * \link flac_format format \endlink module. + */ + +/** \defgroup flac_format FLAC/format.h: format components + * \ingroup flac + * + * \brief + * This module contains structure definitions for the representation + * of FLAC format components in memory. These are the basic + * structures used by the rest of the interfaces. + * + * First, you should be familiar with the + * FLAC format. Many of the values here + * follow directly from the specification. As a user of libFLAC, the + * interesting parts really are the structures that describe the frame + * header and metadata blocks. + * + * The format structures here are very primitive, designed to store + * information in an efficient way. Reading information from the + * structures is easy but creating or modifying them directly is + * more complex. For the most part, as a user of a library, editing + * is not necessary; however, for metadata blocks it is, so there are + * convenience functions provided in the \link flac_metadata metadata + * module \endlink to simplify the manipulation of metadata blocks. + * + * \note + * It's not the best convention, but symbols ending in _LEN are in bits + * and _LENGTH are in bytes. _LENGTH symbols are \#defines instead of + * global variables because they are usually used when declaring byte + * arrays and some compilers require compile-time knowledge of array + * sizes when declared on the stack. + * + * \{ + */ + + +/* + Most of the values described in this file are defined by the FLAC + format specification. There is nothing to tune here. +*/ + +/** The largest legal metadata type code. */ +#define FLAC__MAX_METADATA_TYPE_CODE (126u) + +/** The minimum block size, in samples, permitted by the format. */ +#define FLAC__MIN_BLOCK_SIZE (16u) + +/** The maximum block size, in samples, permitted by the format. */ +#define FLAC__MAX_BLOCK_SIZE (65535u) + +/** The maximum block size, in samples, permitted by the FLAC subset for + * sample rates up to 48kHz. */ +#define FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ (4608u) + +/** The maximum number of channels permitted by the format. */ +#define FLAC__MAX_CHANNELS (8u) + +/** The minimum sample resolution permitted by the format. */ +#define FLAC__MIN_BITS_PER_SAMPLE (4u) + +/** The maximum sample resolution permitted by the format. */ +#define FLAC__MAX_BITS_PER_SAMPLE (32u) + +/** The maximum sample resolution permitted by libFLAC. + * + * \warning + * FLAC__MAX_BITS_PER_SAMPLE is the limit of the FLAC format. However, + * the reference encoder/decoder is currently limited to 24 bits because + * of prevalent 32-bit math, so make sure and use this value when + * appropriate. + */ +#define FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE (24u) + +/** The maximum sample rate permitted by the format. The value is + * ((2 ^ 16) - 1) * 10; see FLAC format + * as to why. + */ +#define FLAC__MAX_SAMPLE_RATE (655350u) + +/** The maximum LPC order permitted by the format. */ +#define FLAC__MAX_LPC_ORDER (32u) + +/** The maximum LPC order permitted by the FLAC subset for sample rates + * up to 48kHz. */ +#define FLAC__SUBSET_MAX_LPC_ORDER_48000HZ (12u) + +/** The minimum quantized linear predictor coefficient precision + * permitted by the format. + */ +#define FLAC__MIN_QLP_COEFF_PRECISION (5u) + +/** The maximum quantized linear predictor coefficient precision + * permitted by the format. + */ +#define FLAC__MAX_QLP_COEFF_PRECISION (15u) + +/** The maximum order of the fixed predictors permitted by the format. */ +#define FLAC__MAX_FIXED_ORDER (4u) + +/** The maximum Rice partition order permitted by the format. */ +#define FLAC__MAX_RICE_PARTITION_ORDER (15u) + +/** The maximum Rice partition order permitted by the FLAC Subset. */ +#define FLAC__SUBSET_MAX_RICE_PARTITION_ORDER (8u) + +/** The version string of the release, stamped onto the libraries and binaries. + * + * \note + * This does not correspond to the shared library version number, which + * is used to determine binary compatibility. + */ +extern FLAC_API const char *FLAC__VERSION_STRING; + +/** The vendor string inserted by the encoder into the VORBIS_COMMENT block. + * This is a NUL-terminated ASCII string; when inserted into the + * VORBIS_COMMENT the trailing null is stripped. + */ +extern FLAC_API const char *FLAC__VENDOR_STRING; + +/** The byte string representation of the beginning of a FLAC stream. */ +extern FLAC_API const FLAC__byte FLAC__STREAM_SYNC_STRING[4]; /* = "fLaC" */ + +/** The 32-bit integer big-endian representation of the beginning of + * a FLAC stream. + */ +extern FLAC_API const unsigned FLAC__STREAM_SYNC; /* = 0x664C6143 */ + +/** The length of the FLAC signature in bits. */ +extern FLAC_API const unsigned FLAC__STREAM_SYNC_LEN; /* = 32 bits */ + +/** The length of the FLAC signature in bytes. */ +#define FLAC__STREAM_SYNC_LENGTH (4u) + + +/***************************************************************************** + * + * Subframe structures + * + *****************************************************************************/ + +/*****************************************************************************/ + +/** An enumeration of the available entropy coding methods. */ +typedef enum { + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE = 0, + /**< Residual is coded by partitioning into contexts, each with it's own + * 4-bit Rice parameter. */ + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 = 1 + /**< Residual is coded by partitioning into contexts, each with it's own + * 5-bit Rice parameter. */ +} FLAC__EntropyCodingMethodType; + +/** Maps a FLAC__EntropyCodingMethodType to a C string. + * + * Using a FLAC__EntropyCodingMethodType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__EntropyCodingMethodTypeString[]; + + +/** Contents of a Rice partitioned residual + */ +typedef struct { + + unsigned *parameters; + /**< The Rice parameters for each context. */ + + unsigned *raw_bits; + /**< Widths for escape-coded partitions. Will be non-zero for escaped + * partitions and zero for unescaped partitions. + */ + + unsigned capacity_by_order; + /**< The capacity of the \a parameters and \a raw_bits arrays + * specified as an order, i.e. the number of array elements + * allocated is 2 ^ \a capacity_by_order. + */ +} FLAC__EntropyCodingMethod_PartitionedRiceContents; + +/** Header for a Rice partitioned residual. (c.f. format specification) + */ +typedef struct { + + unsigned order; + /**< The partition order, i.e. # of contexts = 2 ^ \a order. */ + + const FLAC__EntropyCodingMethod_PartitionedRiceContents *contents; + /**< The context's Rice parameters and/or raw bits. */ + +} FLAC__EntropyCodingMethod_PartitionedRice; + +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN; /**< == 5 (bits) */ +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN; /**< == 5 (bits) */ + +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; +/**< == (1<format specification) + */ +typedef struct { + FLAC__EntropyCodingMethodType type; + union { + FLAC__EntropyCodingMethod_PartitionedRice partitioned_rice; + } data; +} FLAC__EntropyCodingMethod; + +extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_TYPE_LEN; /**< == 2 (bits) */ + +/*****************************************************************************/ + +/** An enumeration of the available subframe types. */ +typedef enum { + FLAC__SUBFRAME_TYPE_CONSTANT = 0, /**< constant signal */ + FLAC__SUBFRAME_TYPE_VERBATIM = 1, /**< uncompressed signal */ + FLAC__SUBFRAME_TYPE_FIXED = 2, /**< fixed polynomial prediction */ + FLAC__SUBFRAME_TYPE_LPC = 3 /**< linear prediction */ +} FLAC__SubframeType; + +/** Maps a FLAC__SubframeType to a C string. + * + * Using a FLAC__SubframeType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__SubframeTypeString[]; + + +/** CONSTANT subframe. (c.f. format specification) + */ +typedef struct { + FLAC__int32 value; /**< The constant signal value. */ +} FLAC__Subframe_Constant; + + +/** VERBATIM subframe. (c.f. format specification) + */ +typedef struct { + const FLAC__int32 *data; /**< A pointer to verbatim signal. */ +} FLAC__Subframe_Verbatim; + + +/** FIXED subframe. (c.f. format specification) + */ +typedef struct { + FLAC__EntropyCodingMethod entropy_coding_method; + /**< The residual coding method. */ + + unsigned order; + /**< The polynomial order. */ + + FLAC__int32 warmup[FLAC__MAX_FIXED_ORDER]; + /**< Warmup samples to prime the predictor, length == order. */ + + const FLAC__int32 *residual; + /**< The residual signal, length == (blocksize minus order) samples. */ +} FLAC__Subframe_Fixed; + + +/** LPC subframe. (c.f. format specification) + */ +typedef struct { + FLAC__EntropyCodingMethod entropy_coding_method; + /**< The residual coding method. */ + + unsigned order; + /**< The FIR order. */ + + unsigned qlp_coeff_precision; + /**< Quantized FIR filter coefficient precision in bits. */ + + int quantization_level; + /**< The qlp coeff shift needed. */ + + FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; + /**< FIR filter coefficients. */ + + FLAC__int32 warmup[FLAC__MAX_LPC_ORDER]; + /**< Warmup samples to prime the predictor, length == order. */ + + const FLAC__int32 *residual; + /**< The residual signal, length == (blocksize minus order) samples. */ +} FLAC__Subframe_LPC; + +extern FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN; /**< == 5 (bits) */ + + +/** FLAC subframe structure. (c.f. format specification) + */ +typedef struct { + FLAC__SubframeType type; + union { + FLAC__Subframe_Constant constant; + FLAC__Subframe_Fixed fixed; + FLAC__Subframe_LPC lpc; + FLAC__Subframe_Verbatim verbatim; + } data; + unsigned wasted_bits; +} FLAC__Subframe; + +/** == 1 (bit) + * + * This used to be a zero-padding bit (hence the name + * FLAC__SUBFRAME_ZERO_PAD_LEN) but is now a reserved bit. It still has a + * mandatory value of \c 0 but in the future may take on the value \c 0 or \c 1 + * to mean something else. + */ +extern FLAC_API const unsigned FLAC__SUBFRAME_ZERO_PAD_LEN; +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LEN; /**< == 6 (bits) */ +extern FLAC_API const unsigned FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN; /**< == 1 (bit) */ + +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK; /**< = 0x00 */ +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK; /**< = 0x02 */ +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK; /**< = 0x10 */ +extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK; /**< = 0x40 */ + +/*****************************************************************************/ + + +/***************************************************************************** + * + * Frame structures + * + *****************************************************************************/ + +/** An enumeration of the available channel assignments. */ +typedef enum { + FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT = 0, /**< independent channels */ + FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE = 1, /**< left+side stereo */ + FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE = 2, /**< right+side stereo */ + FLAC__CHANNEL_ASSIGNMENT_MID_SIDE = 3 /**< mid+side stereo */ +} FLAC__ChannelAssignment; + +/** Maps a FLAC__ChannelAssignment to a C string. + * + * Using a FLAC__ChannelAssignment as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__ChannelAssignmentString[]; + +/** An enumeration of the possible frame numbering methods. */ +typedef enum { + FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER, /**< number contains the frame number */ + FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER /**< number contains the sample number of first sample in frame */ +} FLAC__FrameNumberType; + +/** Maps a FLAC__FrameNumberType to a C string. + * + * Using a FLAC__FrameNumberType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__FrameNumberTypeString[]; + + +/** FLAC frame header structure. (c.f. format specification) + */ +typedef struct { + unsigned blocksize; + /**< The number of samples per subframe. */ + + unsigned sample_rate; + /**< The sample rate in Hz. */ + + unsigned channels; + /**< The number of channels (== number of subframes). */ + + FLAC__ChannelAssignment channel_assignment; + /**< The channel assignment for the frame. */ + + unsigned bits_per_sample; + /**< The sample resolution. */ + + FLAC__FrameNumberType number_type; + /**< The numbering scheme used for the frame. As a convenience, the + * decoder will always convert a frame number to a sample number because + * the rules are complex. */ + + union { + FLAC__uint32 frame_number; + FLAC__uint64 sample_number; + } number; + /**< The frame number or sample number of first sample in frame; + * use the \a number_type value to determine which to use. */ + + FLAC__uint8 crc; + /**< CRC-8 (polynomial = x^8 + x^2 + x^1 + x^0, initialized with 0) + * of the raw frame header bytes, meaning everything before the CRC byte + * including the sync code. + */ +} FLAC__FrameHeader; + +extern FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC; /**< == 0x3ffe; the frame header sync code */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC_LEN; /**< == 14 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_RESERVED_LEN; /**< == 1 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN; /**< == 1 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCK_SIZE_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_SAMPLE_RATE_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN; /**< == 4 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN; /**< == 3 (bits) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_ZERO_PAD_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__FRAME_HEADER_CRC_LEN; /**< == 8 (bits) */ + + +/** FLAC frame footer structure. (c.f. format specification) + */ +typedef struct { + FLAC__uint16 crc; + /**< CRC-16 (polynomial = x^16 + x^15 + x^2 + x^0, initialized with + * 0) of the bytes before the crc, back to and including the frame header + * sync code. + */ +} FLAC__FrameFooter; + +extern FLAC_API const unsigned FLAC__FRAME_FOOTER_CRC_LEN; /**< == 16 (bits) */ + + +/** FLAC frame structure. (c.f. format specification) + */ +typedef struct { + FLAC__FrameHeader header; + FLAC__Subframe subframes[FLAC__MAX_CHANNELS]; + FLAC__FrameFooter footer; +} FLAC__Frame; + +/*****************************************************************************/ + + +/***************************************************************************** + * + * Meta-data structures + * + *****************************************************************************/ + +/** An enumeration of the available metadata block types. */ +typedef enum { + + FLAC__METADATA_TYPE_STREAMINFO = 0, + /**< STREAMINFO block */ + + FLAC__METADATA_TYPE_PADDING = 1, + /**< PADDING block */ + + FLAC__METADATA_TYPE_APPLICATION = 2, + /**< APPLICATION block */ + + FLAC__METADATA_TYPE_SEEKTABLE = 3, + /**< SEEKTABLE block */ + + FLAC__METADATA_TYPE_VORBIS_COMMENT = 4, + /**< VORBISCOMMENT block (a.k.a. FLAC tags) */ + + FLAC__METADATA_TYPE_CUESHEET = 5, + /**< CUESHEET block */ + + FLAC__METADATA_TYPE_PICTURE = 6, + /**< PICTURE block */ + + FLAC__METADATA_TYPE_UNDEFINED = 7 + /**< marker to denote beginning of undefined type range; this number will increase as new metadata types are added */ + +} FLAC__MetadataType; + +/** Maps a FLAC__MetadataType to a C string. + * + * Using a FLAC__MetadataType as the index to this array will + * give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__MetadataTypeString[]; + + +/** FLAC STREAMINFO structure. (c.f. format specification) + */ +typedef struct { + unsigned min_blocksize, max_blocksize; + unsigned min_framesize, max_framesize; + unsigned sample_rate; + unsigned channels; + unsigned bits_per_sample; + FLAC__uint64 total_samples; + FLAC__byte md5sum[16]; +} FLAC__StreamMetadata_StreamInfo; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN; /**< == 16 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN; /**< == 16 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN; /**< == 24 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN; /**< == 24 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN; /**< == 20 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN; /**< == 3 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN; /**< == 5 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN; /**< == 36 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN; /**< == 128 (bits) */ + +/** The total stream length of the STREAMINFO block in bytes. */ +#define FLAC__STREAM_METADATA_STREAMINFO_LENGTH (34u) + +/** FLAC PADDING structure. (c.f. format specification) + */ +typedef struct { + int dummy; + /**< Conceptually this is an empty struct since we don't store the + * padding bytes. Empty structs are not allowed by some C compilers, + * hence the dummy. + */ +} FLAC__StreamMetadata_Padding; + + +/** FLAC APPLICATION structure. (c.f. format specification) + */ +typedef struct { + FLAC__byte id[4]; + FLAC__byte *data; +} FLAC__StreamMetadata_Application; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_APPLICATION_ID_LEN; /**< == 32 (bits) */ + +/** SeekPoint structure used in SEEKTABLE blocks. (c.f. format specification) + */ +typedef struct { + FLAC__uint64 sample_number; + /**< The sample number of the target frame. */ + + FLAC__uint64 stream_offset; + /**< The offset, in bytes, of the target frame with respect to + * beginning of the first frame. */ + + unsigned frame_samples; + /**< The number of samples in the target frame. */ +} FLAC__StreamMetadata_SeekPoint; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN; /**< == 16 (bits) */ + +/** The total stream length of a seek point in bytes. */ +#define FLAC__STREAM_METADATA_SEEKPOINT_LENGTH (18u) + +/** The value used in the \a sample_number field of + * FLAC__StreamMetadataSeekPoint used to indicate a placeholder + * point (== 0xffffffffffffffff). + */ +extern FLAC_API const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; + + +/** FLAC SEEKTABLE structure. (c.f. format specification) + * + * \note From the format specification: + * - The seek points must be sorted by ascending sample number. + * - Each seek point's sample number must be the first sample of the + * target frame. + * - Each seek point's sample number must be unique within the table. + * - Existence of a SEEKTABLE block implies a correct setting of + * total_samples in the stream_info block. + * - Behavior is undefined when more than one SEEKTABLE block is + * present in a stream. + */ +typedef struct { + unsigned num_points; + FLAC__StreamMetadata_SeekPoint *points; +} FLAC__StreamMetadata_SeekTable; + + +/** Vorbis comment entry structure used in VORBIS_COMMENT blocks. (c.f. format specification) + * + * For convenience, the APIs maintain a trailing NUL character at the end of + * \a entry which is not counted toward \a length, i.e. + * \code strlen(entry) == length \endcode + */ +typedef struct { + FLAC__uint32 length; + FLAC__byte *entry; +} FLAC__StreamMetadata_VorbisComment_Entry; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN; /**< == 32 (bits) */ + + +/** FLAC VORBIS_COMMENT structure. (c.f. format specification) + */ +typedef struct { + FLAC__StreamMetadata_VorbisComment_Entry vendor_string; + FLAC__uint32 num_comments; + FLAC__StreamMetadata_VorbisComment_Entry *comments; +} FLAC__StreamMetadata_VorbisComment; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN; /**< == 32 (bits) */ + + +/** FLAC CUESHEET track index structure. (See the + * format specification for + * the full description of each field.) + */ +typedef struct { + FLAC__uint64 offset; + /**< Offset in samples, relative to the track offset, of the index + * point. + */ + + FLAC__byte number; + /**< The index point number. */ +} FLAC__StreamMetadata_CueSheet_Index; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN; /**< == 8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN; /**< == 3*8 (bits) */ + + +/** FLAC CUESHEET track structure. (See the + * format specification for + * the full description of each field.) + */ +typedef struct { + FLAC__uint64 offset; + /**< Track offset in samples, relative to the beginning of the FLAC audio stream. */ + + FLAC__byte number; + /**< The track number. */ + + char isrc[13]; + /**< Track ISRC. This is a 12-digit alphanumeric code plus a trailing \c NUL byte */ + + unsigned type:1; + /**< The track type: 0 for audio, 1 for non-audio. */ + + unsigned pre_emphasis:1; + /**< The pre-emphasis flag: 0 for no pre-emphasis, 1 for pre-emphasis. */ + + FLAC__byte num_indices; + /**< The number of track index points. */ + + FLAC__StreamMetadata_CueSheet_Index *indices; + /**< NULL if num_indices == 0, else pointer to array of index points. */ + +} FLAC__StreamMetadata_CueSheet_Track; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN; /**< == 8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN; /**< == 12*8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN; /**< == 6+13*8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN; /**< == 8 (bits) */ + + +/** FLAC CUESHEET structure. (See the + * format specification + * for the full description of each field.) + */ +typedef struct { + char media_catalog_number[129]; + /**< Media catalog number, in ASCII printable characters 0x20-0x7e. In + * general, the media catalog number may be 0 to 128 bytes long; any + * unused characters should be right-padded with NUL characters. + */ + + FLAC__uint64 lead_in; + /**< The number of lead-in samples. */ + + FLAC__bool is_cd; + /**< \c true if CUESHEET corresponds to a Compact Disc, else \c false. */ + + unsigned num_tracks; + /**< The number of tracks. */ + + FLAC__StreamMetadata_CueSheet_Track *tracks; + /**< NULL if num_tracks == 0, else pointer to array of tracks. */ + +} FLAC__StreamMetadata_CueSheet; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN; /**< == 128*8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN; /**< == 64 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN; /**< == 7+258*8 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN; /**< == 8 (bits) */ + + +/** An enumeration of the PICTURE types (see FLAC__StreamMetadataPicture and id3 v2.4 APIC tag). */ +typedef enum { + FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER = 0, /**< Other */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD = 1, /**< 32x32 pixels 'file icon' (PNG only) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON = 2, /**< Other file icon */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER = 3, /**< Cover (front) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_BACK_COVER = 4, /**< Cover (back) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_LEAFLET_PAGE = 5, /**< Leaflet page */ + FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA = 6, /**< Media (e.g. label side of CD) */ + FLAC__STREAM_METADATA_PICTURE_TYPE_LEAD_ARTIST = 7, /**< Lead artist/lead performer/soloist */ + FLAC__STREAM_METADATA_PICTURE_TYPE_ARTIST = 8, /**< Artist/performer */ + FLAC__STREAM_METADATA_PICTURE_TYPE_CONDUCTOR = 9, /**< Conductor */ + FLAC__STREAM_METADATA_PICTURE_TYPE_BAND = 10, /**< Band/Orchestra */ + FLAC__STREAM_METADATA_PICTURE_TYPE_COMPOSER = 11, /**< Composer */ + FLAC__STREAM_METADATA_PICTURE_TYPE_LYRICIST = 12, /**< Lyricist/text writer */ + FLAC__STREAM_METADATA_PICTURE_TYPE_RECORDING_LOCATION = 13, /**< Recording Location */ + FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_RECORDING = 14, /**< During recording */ + FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_PERFORMANCE = 15, /**< During performance */ + FLAC__STREAM_METADATA_PICTURE_TYPE_VIDEO_SCREEN_CAPTURE = 16, /**< Movie/video screen capture */ + FLAC__STREAM_METADATA_PICTURE_TYPE_FISH = 17, /**< A bright coloured fish */ + FLAC__STREAM_METADATA_PICTURE_TYPE_ILLUSTRATION = 18, /**< Illustration */ + FLAC__STREAM_METADATA_PICTURE_TYPE_BAND_LOGOTYPE = 19, /**< Band/artist logotype */ + FLAC__STREAM_METADATA_PICTURE_TYPE_PUBLISHER_LOGOTYPE = 20, /**< Publisher/Studio logotype */ + FLAC__STREAM_METADATA_PICTURE_TYPE_UNDEFINED +} FLAC__StreamMetadata_Picture_Type; + +/** Maps a FLAC__StreamMetadata_Picture_Type to a C string. + * + * Using a FLAC__StreamMetadata_Picture_Type as the index to this array + * will give the string equivalent. The contents should not be + * modified. + */ +extern FLAC_API const char * const FLAC__StreamMetadata_Picture_TypeString[]; + +/** FLAC PICTURE structure. (See the + * format specification + * for the full description of each field.) + */ +typedef struct { + FLAC__StreamMetadata_Picture_Type type; + /**< The kind of picture stored. */ + + char *mime_type; + /**< Picture data's MIME type, in ASCII printable characters + * 0x20-0x7e, NUL terminated. For best compatibility with players, + * use picture data of MIME type \c image/jpeg or \c image/png. A + * MIME type of '-->' is also allowed, in which case the picture + * data should be a complete URL. In file storage, the MIME type is + * stored as a 32-bit length followed by the ASCII string with no NUL + * terminator, but is converted to a plain C string in this structure + * for convenience. + */ + + FLAC__byte *description; + /**< Picture's description in UTF-8, NUL terminated. In file storage, + * the description is stored as a 32-bit length followed by the UTF-8 + * string with no NUL terminator, but is converted to a plain C string + * in this structure for convenience. + */ + + FLAC__uint32 width; + /**< Picture's width in pixels. */ + + FLAC__uint32 height; + /**< Picture's height in pixels. */ + + FLAC__uint32 depth; + /**< Picture's color depth in bits-per-pixel. */ + + FLAC__uint32 colors; + /**< For indexed palettes (like GIF), picture's number of colors (the + * number of palette entries), or \c 0 for non-indexed (i.e. 2^depth). + */ + + FLAC__uint32 data_length; + /**< Length of binary picture data in bytes. */ + + FLAC__byte *data; + /**< Binary picture data. */ + +} FLAC__StreamMetadata_Picture; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_TYPE_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_COLORS_LEN; /**< == 32 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN; /**< == 32 (bits) */ + + +/** Structure that is used when a metadata block of unknown type is loaded. + * The contents are opaque. The structure is used only internally to + * correctly handle unknown metadata. + */ +typedef struct { + FLAC__byte *data; +} FLAC__StreamMetadata_Unknown; + + +/** FLAC metadata block structure. (c.f. format specification) + */ +typedef struct { + FLAC__MetadataType type; + /**< The type of the metadata block; used determine which member of the + * \a data union to dereference. If type >= FLAC__METADATA_TYPE_UNDEFINED + * then \a data.unknown must be used. */ + + FLAC__bool is_last; + /**< \c true if this metadata block is the last, else \a false */ + + unsigned length; + /**< Length, in bytes, of the block data as it appears in the stream. */ + + union { + FLAC__StreamMetadata_StreamInfo stream_info; + FLAC__StreamMetadata_Padding padding; + FLAC__StreamMetadata_Application application; + FLAC__StreamMetadata_SeekTable seek_table; + FLAC__StreamMetadata_VorbisComment vorbis_comment; + FLAC__StreamMetadata_CueSheet cue_sheet; + FLAC__StreamMetadata_Picture picture; + FLAC__StreamMetadata_Unknown unknown; + } data; + /**< Polymorphic block data; use the \a type value to determine which + * to use. */ +} FLAC__StreamMetadata; + +extern FLAC_API const unsigned FLAC__STREAM_METADATA_IS_LAST_LEN; /**< == 1 (bit) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_TYPE_LEN; /**< == 7 (bits) */ +extern FLAC_API const unsigned FLAC__STREAM_METADATA_LENGTH_LEN; /**< == 24 (bits) */ + +/** The total stream length of a metadata block header in bytes. */ +#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) + +/*****************************************************************************/ + + +/***************************************************************************** + * + * Utility functions + * + *****************************************************************************/ + +/** Tests that a sample rate is valid for FLAC. + * + * \param sample_rate The sample rate to test for compliance. + * \retval FLAC__bool + * \c true if the given sample rate conforms to the specification, else + * \c false. + */ +FLAC_API FLAC__bool FLAC__format_sample_rate_is_valid(unsigned sample_rate); + +/** Tests that a blocksize at the given sample rate is valid for the FLAC + * subset. + * + * \param blocksize The blocksize to test for compliance. + * \param sample_rate The sample rate is needed, since the valid subset + * blocksize depends on the sample rate. + * \retval FLAC__bool + * \c true if the given blocksize conforms to the specification for the + * subset at the given sample rate, else \c false. + */ +FLAC_API FLAC__bool FLAC__format_blocksize_is_subset(unsigned blocksize, unsigned sample_rate); + +/** Tests that a sample rate is valid for the FLAC subset. The subset rules + * for valid sample rates are slightly more complex since the rate has to + * be expressible completely in the frame header. + * + * \param sample_rate The sample rate to test for compliance. + * \retval FLAC__bool + * \c true if the given sample rate conforms to the specification for the + * subset, else \c false. + */ +FLAC_API FLAC__bool FLAC__format_sample_rate_is_subset(unsigned sample_rate); + +/** Check a Vorbis comment entry name to see if it conforms to the Vorbis + * comment specification. + * + * Vorbis comment names must be composed only of characters from + * [0x20-0x3C,0x3E-0x7D]. + * + * \param name A NUL-terminated string to be checked. + * \assert + * \code name != NULL \endcode + * \retval FLAC__bool + * \c false if entry name is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_name_is_legal(const char *name); + +/** Check a Vorbis comment entry value to see if it conforms to the Vorbis + * comment specification. + * + * Vorbis comment values must be valid UTF-8 sequences. + * + * \param value A string to be checked. + * \param length A the length of \a value in bytes. May be + * \c (unsigned)(-1) to indicate that \a value is a plain + * UTF-8 NUL-terminated string. + * \assert + * \code value != NULL \endcode + * \retval FLAC__bool + * \c false if entry name is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__byte *value, unsigned length); + +/** Check a Vorbis comment entry to see if it conforms to the Vorbis + * comment specification. + * + * Vorbis comment entries must be of the form 'name=value', and 'name' and + * 'value' must be legal according to + * FLAC__format_vorbiscomment_entry_name_is_legal() and + * FLAC__format_vorbiscomment_entry_value_is_legal() respectively. + * + * \param entry An entry to be checked. + * \param length The length of \a entry in bytes. + * \assert + * \code value != NULL \endcode + * \retval FLAC__bool + * \c false if entry name is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_is_legal(const FLAC__byte *entry, unsigned length); + +/** Check a seek table to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * seek table. + * + * \param seek_table A pointer to a seek table to be checked. + * \assert + * \code seek_table != NULL \endcode + * \retval FLAC__bool + * \c false if seek table is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_seektable_is_legal(const FLAC__StreamMetadata_SeekTable *seek_table); + +/** Sort a seek table's seek points according to the format specification. + * This includes a "unique-ification" step to remove duplicates, i.e. + * seek points with identical \a sample_number values. Duplicate seek + * points are converted into placeholder points and sorted to the end of + * the table. + * + * \param seek_table A pointer to a seek table to be sorted. + * \assert + * \code seek_table != NULL \endcode + * \retval unsigned + * The number of duplicate seek points converted into placeholders. + */ +FLAC_API unsigned FLAC__format_seektable_sort(FLAC__StreamMetadata_SeekTable *seek_table); + +/** Check a cue sheet to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * cue sheet. + * + * \param cue_sheet A pointer to an existing cue sheet to be checked. + * \param check_cd_da_subset If \c true, check CUESHEET against more + * stringent requirements for a CD-DA (audio) disc. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code cue_sheet != NULL \endcode + * \retval FLAC__bool + * \c false if cue sheet is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_cuesheet_is_legal(const FLAC__StreamMetadata_CueSheet *cue_sheet, FLAC__bool check_cd_da_subset, const char **violation); + +/** Check picture data to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * PICTURE block. + * + * \param picture A pointer to existing picture data to be checked. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code picture != NULL \endcode + * \retval FLAC__bool + * \c false if picture data is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__format_picture_is_legal(const FLAC__StreamMetadata_Picture *picture, const char **violation); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/Windows/codecs/include/FLAC/metadata.h b/quakespasm/Windows/codecs/include/FLAC/metadata.h new file mode 100644 index 00000000..fcc8ed95 --- /dev/null +++ b/quakespasm/Windows/codecs/include/FLAC/metadata.h @@ -0,0 +1,2182 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2001-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__METADATA_H +#define FLAC__METADATA_H + +#include /* for off_t */ +#include "export.h" +#include "callback.h" +#include "format.h" + +/* -------------------------------------------------------------------- + (For an example of how all these routines are used, see the source + code for the unit tests in src/test_libFLAC/metadata_*.c, or + metaflac in src/metaflac/) + ------------------------------------------------------------------*/ + +/** \file include/FLAC/metadata.h + * + * \brief + * This module provides functions for creating and manipulating FLAC + * metadata blocks in memory, and three progressively more powerful + * interfaces for traversing and editing metadata in FLAC files. + * + * See the detailed documentation for each interface in the + * \link flac_metadata metadata \endlink module. + */ + +/** \defgroup flac_metadata FLAC/metadata.h: metadata interfaces + * \ingroup flac + * + * \brief + * This module provides functions for creating and manipulating FLAC + * metadata blocks in memory, and three progressively more powerful + * interfaces for traversing and editing metadata in native FLAC files. + * Note that currently only the Chain interface (level 2) supports Ogg + * FLAC files, and it is read-only i.e. no writing back changed + * metadata to file. + * + * There are three metadata interfaces of increasing complexity: + * + * Level 0: + * Read-only access to the STREAMINFO, VORBIS_COMMENT, CUESHEET, and + * PICTURE blocks. + * + * Level 1: + * Read-write access to all metadata blocks. This level is write- + * efficient in most cases (more on this below), and uses less memory + * than level 2. + * + * Level 2: + * Read-write access to all metadata blocks. This level is write- + * efficient in all cases, but uses more memory since all metadata for + * the whole file is read into memory and manipulated before writing + * out again. + * + * What do we mean by efficient? Since FLAC metadata appears at the + * beginning of the file, when writing metadata back to a FLAC file + * it is possible to grow or shrink the metadata such that the entire + * file must be rewritten. However, if the size remains the same during + * changes or PADDING blocks are utilized, only the metadata needs to be + * overwritten, which is much faster. + * + * Efficient means the whole file is rewritten at most one time, and only + * when necessary. Level 1 is not efficient only in the case that you + * cause more than one metadata block to grow or shrink beyond what can + * be accomodated by padding. In this case you should probably use level + * 2, which allows you to edit all the metadata for a file in memory and + * write it out all at once. + * + * All levels know how to skip over and not disturb an ID3v2 tag at the + * front of the file. + * + * All levels access files via their filenames. In addition, level 2 + * has additional alternative read and write functions that take an I/O + * handle and callbacks, for situations where access by filename is not + * possible. + * + * In addition to the three interfaces, this module defines functions for + * creating and manipulating various metadata objects in memory. As we see + * from the Format module, FLAC metadata blocks in memory are very primitive + * structures for storing information in an efficient way. Reading + * information from the structures is easy but creating or modifying them + * directly is more complex. The metadata object routines here facilitate + * this by taking care of the consistency and memory management drudgery. + * + * Unless you will be using the level 1 or 2 interfaces to modify existing + * metadata however, you will not probably not need these. + * + * From a dependency standpoint, none of the encoders or decoders require + * the metadata module. This is so that embedded users can strip out the + * metadata module from libFLAC to reduce the size and complexity. + */ + +#ifdef __cplusplus +extern "C" { +#endif + + +/** \defgroup flac_metadata_level0 FLAC/metadata.h: metadata level 0 interface + * \ingroup flac_metadata + * + * \brief + * The level 0 interface consists of individual routines to read the + * STREAMINFO, VORBIS_COMMENT, CUESHEET, and PICTURE blocks, requiring + * only a filename. + * + * They try to skip any ID3v2 tag at the head of the file. + * + * \{ + */ + +/** Read the STREAMINFO metadata block of the given FLAC file. This function + * will try to skip any ID3v2 tag at the head of the file. + * + * \param filename The path to the FLAC file to read. + * \param streaminfo A pointer to space for the STREAMINFO block. Since + * FLAC__StreamMetadata is a simple structure with no + * memory allocation involved, you pass the address of + * an existing structure. It need not be initialized. + * \assert + * \code filename != NULL \endcode + * \code streaminfo != NULL \endcode + * \retval FLAC__bool + * \c true if a valid STREAMINFO block was read from \a filename. Returns + * \c false if there was a memory allocation error, a file decoder error, + * or the file contained no STREAMINFO block. (A memory allocation error + * is possible because this function must set up a file decoder.) + */ +FLAC_API FLAC__bool FLAC__metadata_get_streaminfo(const char *filename, FLAC__StreamMetadata *streaminfo); + +/** Read the VORBIS_COMMENT metadata block of the given FLAC file. This + * function will try to skip any ID3v2 tag at the head of the file. + * + * \param filename The path to the FLAC file to read. + * \param tags The address where the returned pointer will be + * stored. The \a tags object must be deleted by + * the caller using FLAC__metadata_object_delete(). + * \assert + * \code filename != NULL \endcode + * \code tags != NULL \endcode + * \retval FLAC__bool + * \c true if a valid VORBIS_COMMENT block was read from \a filename, + * and \a *tags will be set to the address of the metadata structure. + * Returns \c false if there was a memory allocation error, a file + * decoder error, or the file contained no VORBIS_COMMENT block, and + * \a *tags will be set to \c NULL. + */ +FLAC_API FLAC__bool FLAC__metadata_get_tags(const char *filename, FLAC__StreamMetadata **tags); + +/** Read the CUESHEET metadata block of the given FLAC file. This + * function will try to skip any ID3v2 tag at the head of the file. + * + * \param filename The path to the FLAC file to read. + * \param cuesheet The address where the returned pointer will be + * stored. The \a cuesheet object must be deleted by + * the caller using FLAC__metadata_object_delete(). + * \assert + * \code filename != NULL \endcode + * \code cuesheet != NULL \endcode + * \retval FLAC__bool + * \c true if a valid CUESHEET block was read from \a filename, + * and \a *cuesheet will be set to the address of the metadata + * structure. Returns \c false if there was a memory allocation + * error, a file decoder error, or the file contained no CUESHEET + * block, and \a *cuesheet will be set to \c NULL. + */ +FLAC_API FLAC__bool FLAC__metadata_get_cuesheet(const char *filename, FLAC__StreamMetadata **cuesheet); + +/** Read a PICTURE metadata block of the given FLAC file. This + * function will try to skip any ID3v2 tag at the head of the file. + * Since there can be more than one PICTURE block in a file, this + * function takes a number of parameters that act as constraints to + * the search. The PICTURE block with the largest area matching all + * the constraints will be returned, or \a *picture will be set to + * \c NULL if there was no such block. + * + * \param filename The path to the FLAC file to read. + * \param picture The address where the returned pointer will be + * stored. The \a picture object must be deleted by + * the caller using FLAC__metadata_object_delete(). + * \param type The desired picture type. Use \c -1 to mean + * "any type". + * \param mime_type The desired MIME type, e.g. "image/jpeg". The + * string will be matched exactly. Use \c NULL to + * mean "any MIME type". + * \param description The desired description. The string will be + * matched exactly. Use \c NULL to mean "any + * description". + * \param max_width The maximum width in pixels desired. Use + * \c (unsigned)(-1) to mean "any width". + * \param max_height The maximum height in pixels desired. Use + * \c (unsigned)(-1) to mean "any height". + * \param max_depth The maximum color depth in bits-per-pixel desired. + * Use \c (unsigned)(-1) to mean "any depth". + * \param max_colors The maximum number of colors desired. Use + * \c (unsigned)(-1) to mean "any number of colors". + * \assert + * \code filename != NULL \endcode + * \code picture != NULL \endcode + * \retval FLAC__bool + * \c true if a valid PICTURE block was read from \a filename, + * and \a *picture will be set to the address of the metadata + * structure. Returns \c false if there was a memory allocation + * error, a file decoder error, or the file contained no PICTURE + * block, and \a *picture will be set to \c NULL. + */ +FLAC_API FLAC__bool FLAC__metadata_get_picture(const char *filename, FLAC__StreamMetadata **picture, FLAC__StreamMetadata_Picture_Type type, const char *mime_type, const FLAC__byte *description, unsigned max_width, unsigned max_height, unsigned max_depth, unsigned max_colors); + +/* \} */ + + +/** \defgroup flac_metadata_level1 FLAC/metadata.h: metadata level 1 interface + * \ingroup flac_metadata + * + * \brief + * The level 1 interface provides read-write access to FLAC file metadata and + * operates directly on the FLAC file. + * + * The general usage of this interface is: + * + * - Create an iterator using FLAC__metadata_simple_iterator_new() + * - Attach it to a file using FLAC__metadata_simple_iterator_init() and check + * the exit code. Call FLAC__metadata_simple_iterator_is_writable() to + * see if the file is writable, or only read access is allowed. + * - Use FLAC__metadata_simple_iterator_next() and + * FLAC__metadata_simple_iterator_prev() to traverse the blocks. + * This is does not read the actual blocks themselves. + * FLAC__metadata_simple_iterator_next() is relatively fast. + * FLAC__metadata_simple_iterator_prev() is slower since it needs to search + * forward from the front of the file. + * - Use FLAC__metadata_simple_iterator_get_block_type() or + * FLAC__metadata_simple_iterator_get_block() to access the actual data at + * the current iterator position. The returned object is yours to modify + * and free. + * - Use FLAC__metadata_simple_iterator_set_block() to write a modified block + * back. You must have write permission to the original file. Make sure to + * read the whole comment to FLAC__metadata_simple_iterator_set_block() + * below. + * - Use FLAC__metadata_simple_iterator_insert_block_after() to add new blocks. + * Use the object creation functions from + * \link flac_metadata_object here \endlink to generate new objects. + * - Use FLAC__metadata_simple_iterator_delete_block() to remove the block + * currently referred to by the iterator, or replace it with padding. + * - Destroy the iterator with FLAC__metadata_simple_iterator_delete() when + * finished. + * + * \note + * The FLAC file remains open the whole time between + * FLAC__metadata_simple_iterator_init() and + * FLAC__metadata_simple_iterator_delete(), so make sure you are not altering + * the file during this time. + * + * \note + * Do not modify the \a is_last, \a length, or \a type fields of returned + * FLAC__StreamMetadata objects. These are managed automatically. + * + * \note + * If any of the modification functions + * (FLAC__metadata_simple_iterator_set_block(), + * FLAC__metadata_simple_iterator_delete_block(), + * FLAC__metadata_simple_iterator_insert_block_after(), etc.) return \c false, + * you should delete the iterator as it may no longer be valid. + * + * \{ + */ + +struct FLAC__Metadata_SimpleIterator; +/** The opaque structure definition for the level 1 iterator type. + * See the + * \link flac_metadata_level1 metadata level 1 module \endlink + * for a detailed description. + */ +typedef struct FLAC__Metadata_SimpleIterator FLAC__Metadata_SimpleIterator; + +/** Status type for FLAC__Metadata_SimpleIterator. + * + * The iterator's current status can be obtained by calling FLAC__metadata_simple_iterator_status(). + */ +typedef enum { + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK = 0, + /**< The iterator is in the normal OK state */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT, + /**< The data passed into a function violated the function's usage criteria */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE, + /**< The iterator could not open the target file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE, + /**< The iterator could not find the FLAC signature at the start of the file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE, + /**< The iterator tried to write to a file that was not writable */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_BAD_METADATA, + /**< The iterator encountered input that does not conform to the FLAC metadata specification */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR, + /**< The iterator encountered an error while reading the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR, + /**< The iterator encountered an error while seeking in the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR, + /**< The iterator encountered an error while writing the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR, + /**< The iterator encountered an error renaming the FLAC file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR, + /**< The iterator encountered an error removing the temporary file */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR, + /**< Memory allocation failed */ + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_INTERNAL_ERROR + /**< The caller violated an assertion or an unexpected error occurred */ + +} FLAC__Metadata_SimpleIteratorStatus; + +/** Maps a FLAC__Metadata_SimpleIteratorStatus to a C string. + * + * Using a FLAC__Metadata_SimpleIteratorStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__Metadata_SimpleIteratorStatusString[]; + + +/** Create a new iterator instance. + * + * \retval FLAC__Metadata_SimpleIterator* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__Metadata_SimpleIterator *FLAC__metadata_simple_iterator_new(void); + +/** Free an iterator instance. Deletes the object pointed to by \a iterator. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + */ +FLAC_API void FLAC__metadata_simple_iterator_delete(FLAC__Metadata_SimpleIterator *iterator); + +/** Get the current status of the iterator. Call this after a function + * returns \c false to get the reason for the error. Also resets the status + * to FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + * \retval FLAC__Metadata_SimpleIteratorStatus + * The current status of the iterator. + */ +FLAC_API FLAC__Metadata_SimpleIteratorStatus FLAC__metadata_simple_iterator_status(FLAC__Metadata_SimpleIterator *iterator); + +/** Initialize the iterator to point to the first metadata block in the + * given FLAC file. + * + * \param iterator A pointer to an existing iterator. + * \param filename The path to the FLAC file. + * \param read_only If \c true, the FLAC file will be opened + * in read-only mode; if \c false, the FLAC + * file will be opened for edit even if no + * edits are performed. + * \param preserve_file_stats If \c true, the owner and modification + * time will be preserved even if the FLAC + * file is written to. + * \assert + * \code iterator != NULL \endcode + * \code filename != NULL \endcode + * \retval FLAC__bool + * \c false if a memory allocation error occurs, the file can't be + * opened, or another error occurs, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_init(FLAC__Metadata_SimpleIterator *iterator, const char *filename, FLAC__bool read_only, FLAC__bool preserve_file_stats); + +/** Returns \c true if the FLAC file is writable. If \c false, calls to + * FLAC__metadata_simple_iterator_set_block() and + * FLAC__metadata_simple_iterator_insert_block_after() will fail. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + * \retval FLAC__bool + * See above. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_is_writable(const FLAC__Metadata_SimpleIterator *iterator); + +/** Moves the iterator forward one metadata block, returning \c false if + * already at the end. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c false if already at the last metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_next(FLAC__Metadata_SimpleIterator *iterator); + +/** Moves the iterator backward one metadata block, returning \c false if + * already at the beginning. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c false if already at the first metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_prev(FLAC__Metadata_SimpleIterator *iterator); + +/** Returns a flag telling if the current metadata block is the last. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c true if the current metadata block is the last in the file, + * else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_is_last(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the offset of the metadata block at the current position. This + * avoids reading the actual block data which can save time for large + * blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval off_t + * The offset of the metadata block at the current iterator position. + * This is the byte offset relative to the beginning of the file of + * the current metadata block's header. + */ +FLAC_API off_t FLAC__metadata_simple_iterator_get_block_offset(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the type of the metadata block at the current position. This + * avoids reading the actual block data which can save time for large + * blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__MetadataType + * The type of the metadata block at the current iterator position. + */ +FLAC_API FLAC__MetadataType FLAC__metadata_simple_iterator_get_block_type(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the length of the metadata block at the current position. This + * avoids reading the actual block data which can save time for large + * blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval unsigned + * The length of the metadata block at the current iterator position. + * The is same length as that in the + * metadata block header, + * i.e. the length of the metadata body that follows the header. + */ +FLAC_API unsigned FLAC__metadata_simple_iterator_get_block_length(const FLAC__Metadata_SimpleIterator *iterator); + +/** Get the application ID of the \c APPLICATION block at the current + * position. This avoids reading the actual block data which can save + * time for large blocks. + * + * \param iterator A pointer to an existing initialized iterator. + * \param id A pointer to a buffer of at least \c 4 bytes where + * the ID will be stored. + * \assert + * \code iterator != NULL \endcode + * \code id != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c true if the ID was successfully read, else \c false, in which + * case you should check FLAC__metadata_simple_iterator_status() to + * find out why. If the status is + * \c FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT, then the + * current metadata block is not an \c APPLICATION block. Otherwise + * if the status is + * \c FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR or + * \c FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR, an I/O error + * occurred and the iterator can no longer be used. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_get_application_id(FLAC__Metadata_SimpleIterator *iterator, FLAC__byte *id); + +/** Get the metadata block at the current position. You can modify the + * block but must use FLAC__metadata_simple_iterator_set_block() to + * write it back to the FLAC file. + * + * You must call FLAC__metadata_object_delete() on the returned object + * when you are finished with it. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__StreamMetadata* + * The current metadata block, or \c NULL if there was a memory + * allocation error. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_simple_iterator_get_block(FLAC__Metadata_SimpleIterator *iterator); + +/** Write a block back to the FLAC file. This function tries to be + * as efficient as possible; how the block is actually written is + * shown by the following: + * + * Existing block is a STREAMINFO block and the new block is a + * STREAMINFO block: the new block is written in place. Make sure + * you know what you're doing when changing the values of a + * STREAMINFO block. + * + * Existing block is a STREAMINFO block and the new block is a + * not a STREAMINFO block: this is an error since the first block + * must be a STREAMINFO block. Returns \c false without altering the + * file. + * + * Existing block is not a STREAMINFO block and the new block is a + * STREAMINFO block: this is an error since there may be only one + * STREAMINFO block. Returns \c false without altering the file. + * + * Existing block and new block are the same length: the existing + * block will be replaced by the new block, written in place. + * + * Existing block is longer than new block: if use_padding is \c true, + * the existing block will be overwritten in place with the new + * block followed by a PADDING block, if possible, to make the total + * size the same as the existing block. Remember that a padding + * block requires at least four bytes so if the difference in size + * between the new block and existing block is less than that, the + * entire file will have to be rewritten, using the new block's + * exact size. If use_padding is \c false, the entire file will be + * rewritten, replacing the existing block by the new block. + * + * Existing block is shorter than new block: if use_padding is \c true, + * the function will try and expand the new block into the following + * PADDING block, if it exists and doing so won't shrink the PADDING + * block to less than 4 bytes. If there is no following PADDING + * block, or it will shrink to less than 4 bytes, or use_padding is + * \c false, the entire file is rewritten, replacing the existing block + * with the new block. Note that in this case any following PADDING + * block is preserved as is. + * + * After writing the block, the iterator will remain in the same + * place, i.e. pointing to the new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block The block to set. + * \param use_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \code block != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_set_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding); + +/** This is similar to FLAC__metadata_simple_iterator_set_block() + * except that instead of writing over an existing block, it appends + * a block after the existing block. \a use_padding is again used to + * tell the function to try an expand into following padding in an + * attempt to avoid rewriting the entire file. + * + * This function will fail and return \c false if given a STREAMINFO + * block. + * + * After writing the block, the iterator will be pointing to the + * new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block The block to set. + * \param use_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \code block != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_insert_block_after(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding); + +/** Deletes the block at the current position. This will cause the + * entire FLAC file to be rewritten, unless \a use_padding is \c true, + * in which case the block will be replaced by an equal-sized PADDING + * block. The iterator will be left pointing to the block before the + * one just deleted. + * + * You may not delete the STREAMINFO block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param use_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_simple_iterator_init() + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_simple_iterator_delete_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__bool use_padding); + +/* \} */ + + +/** \defgroup flac_metadata_level2 FLAC/metadata.h: metadata level 2 interface + * \ingroup flac_metadata + * + * \brief + * The level 2 interface provides read-write access to FLAC file metadata; + * all metadata is read into memory, operated on in memory, and then written + * to file, which is more efficient than level 1 when editing multiple blocks. + * + * Currently Ogg FLAC is supported for read only, via + * FLAC__metadata_chain_read_ogg() but a subsequent + * FLAC__metadata_chain_write() will fail. + * + * The general usage of this interface is: + * + * - Create a new chain using FLAC__metadata_chain_new(). A chain is a + * linked list of FLAC metadata blocks. + * - Read all metadata into the the chain from a FLAC file using + * FLAC__metadata_chain_read() or FLAC__metadata_chain_read_ogg() and + * check the status. + * - Optionally, consolidate the padding using + * FLAC__metadata_chain_merge_padding() or + * FLAC__metadata_chain_sort_padding(). + * - Create a new iterator using FLAC__metadata_iterator_new() + * - Initialize the iterator to point to the first element in the chain + * using FLAC__metadata_iterator_init() + * - Traverse the chain using FLAC__metadata_iterator_next and + * FLAC__metadata_iterator_prev(). + * - Get a block for reading or modification using + * FLAC__metadata_iterator_get_block(). The pointer to the object + * inside the chain is returned, so the block is yours to modify. + * Changes will be reflected in the FLAC file when you write the + * chain. You can also add and delete blocks (see functions below). + * - When done, write out the chain using FLAC__metadata_chain_write(). + * Make sure to read the whole comment to the function below. + * - Delete the chain using FLAC__metadata_chain_delete(). + * + * \note + * Even though the FLAC file is not open while the chain is being + * manipulated, you must not alter the file externally during + * this time. The chain assumes the FLAC file will not change + * between the time of FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg() + * and FLAC__metadata_chain_write(). + * + * \note + * Do not modify the is_last, length, or type fields of returned + * FLAC__StreamMetadata objects. These are managed automatically. + * + * \note + * The metadata objects returned by FLAC__metadata_iterator_get_block() + * are owned by the chain; do not FLAC__metadata_object_delete() them. + * In the same way, blocks passed to FLAC__metadata_iterator_set_block() + * become owned by the chain and they will be deleted when the chain is + * deleted. + * + * \{ + */ + +struct FLAC__Metadata_Chain; +/** The opaque structure definition for the level 2 chain type. + */ +typedef struct FLAC__Metadata_Chain FLAC__Metadata_Chain; + +struct FLAC__Metadata_Iterator; +/** The opaque structure definition for the level 2 iterator type. + */ +typedef struct FLAC__Metadata_Iterator FLAC__Metadata_Iterator; + +typedef enum { + FLAC__METADATA_CHAIN_STATUS_OK = 0, + /**< The chain is in the normal OK state */ + + FLAC__METADATA_CHAIN_STATUS_ILLEGAL_INPUT, + /**< The data passed into a function violated the function's usage criteria */ + + FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE, + /**< The chain could not open the target file */ + + FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE, + /**< The chain could not find the FLAC signature at the start of the file */ + + FLAC__METADATA_CHAIN_STATUS_NOT_WRITABLE, + /**< The chain tried to write to a file that was not writable */ + + FLAC__METADATA_CHAIN_STATUS_BAD_METADATA, + /**< The chain encountered input that does not conform to the FLAC metadata specification */ + + FLAC__METADATA_CHAIN_STATUS_READ_ERROR, + /**< The chain encountered an error while reading the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR, + /**< The chain encountered an error while seeking in the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR, + /**< The chain encountered an error while writing the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_RENAME_ERROR, + /**< The chain encountered an error renaming the FLAC file */ + + FLAC__METADATA_CHAIN_STATUS_UNLINK_ERROR, + /**< The chain encountered an error removing the temporary file */ + + FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR, + /**< Memory allocation failed */ + + FLAC__METADATA_CHAIN_STATUS_INTERNAL_ERROR, + /**< The caller violated an assertion or an unexpected error occurred */ + + FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS, + /**< One or more of the required callbacks was NULL */ + + FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH, + /**< FLAC__metadata_chain_write() was called on a chain read by + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(), + * or + * FLAC__metadata_chain_write_with_callbacks()/FLAC__metadata_chain_write_with_callbacks_and_tempfile() + * was called on a chain read by + * FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(). + * Matching read/write methods must always be used. */ + + FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL + /**< FLAC__metadata_chain_write_with_callbacks() was called when the + * chain write requires a tempfile; use + * FLAC__metadata_chain_write_with_callbacks_and_tempfile() instead. + * Or, FLAC__metadata_chain_write_with_callbacks_and_tempfile() was + * called when the chain write does not require a tempfile; use + * FLAC__metadata_chain_write_with_callbacks() instead. + * Always check FLAC__metadata_chain_check_if_tempfile_needed() + * before writing via callbacks. */ + +} FLAC__Metadata_ChainStatus; + +/** Maps a FLAC__Metadata_ChainStatus to a C string. + * + * Using a FLAC__Metadata_ChainStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__Metadata_ChainStatusString[]; + +/*********** FLAC__Metadata_Chain ***********/ + +/** Create a new chain instance. + * + * \retval FLAC__Metadata_Chain* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__Metadata_Chain *FLAC__metadata_chain_new(void); + +/** Free a chain instance. Deletes the object pointed to by \a chain. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_chain_delete(FLAC__Metadata_Chain *chain); + +/** Get the current status of the chain. Call this after a function + * returns \c false to get the reason for the error. Also resets the + * status to FLAC__METADATA_CHAIN_STATUS_OK. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__Metadata_ChainStatus + * The current status of the chain. + */ +FLAC_API FLAC__Metadata_ChainStatus FLAC__metadata_chain_status(FLAC__Metadata_Chain *chain); + +/** Read all metadata from a FLAC file into the chain. + * + * \param chain A pointer to an existing chain. + * \param filename The path to the FLAC file to read. + * \assert + * \code chain != NULL \endcode + * \code filename != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a filename, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read(FLAC__Metadata_Chain *chain, const char *filename); + +/** Read all metadata from an Ogg FLAC file into the chain. + * + * \note Ogg FLAC metadata data writing is not supported yet and + * FLAC__metadata_chain_write() will fail. + * + * \param chain A pointer to an existing chain. + * \param filename The path to the Ogg FLAC file to read. + * \assert + * \code chain != NULL \endcode + * \code filename != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a filename, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read_ogg(FLAC__Metadata_Chain *chain, const char *filename); + +/** Read all metadata from a FLAC stream into the chain via I/O callbacks. + * + * The \a handle need only be open for reading, but must be seekable. + * The equivalent minimum stdio fopen() file mode is \c "r" (or \c "rb" + * for Windows). + * + * \param chain A pointer to an existing chain. + * \param handle The I/O handle of the FLAC stream to read. The + * handle will NOT be closed after the metadata is read; + * that is the duty of the caller. + * \param callbacks + * A set of callbacks to use for I/O. The mandatory + * callbacks are \a read, \a seek, and \a tell. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a handle, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks); + +/** Read all metadata from an Ogg FLAC stream into the chain via I/O callbacks. + * + * The \a handle need only be open for reading, but must be seekable. + * The equivalent minimum stdio fopen() file mode is \c "r" (or \c "rb" + * for Windows). + * + * \note Ogg FLAC metadata data writing is not supported yet and + * FLAC__metadata_chain_write() will fail. + * + * \param chain A pointer to an existing chain. + * \param handle The I/O handle of the Ogg FLAC stream to read. The + * handle will NOT be closed after the metadata is read; + * that is the duty of the caller. + * \param callbacks + * A set of callbacks to use for I/O. The mandatory + * callbacks are \a read, \a seek, and \a tell. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if a valid list of metadata blocks was read from + * \a handle, else \c false. On failure, check the status with + * FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_read_ogg_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks); + +/** Checks if writing the given chain would require the use of a + * temporary file, or if it could be written in place. + * + * Under certain conditions, padding can be utilized so that writing + * edited metadata back to the FLAC file does not require rewriting the + * entire file. If rewriting is required, then a temporary workfile is + * required. When writing metadata using callbacks, you must check + * this function to know whether to call + * FLAC__metadata_chain_write_with_callbacks() or + * FLAC__metadata_chain_write_with_callbacks_and_tempfile(). When + * writing with FLAC__metadata_chain_write(), the temporary file is + * handled internally. + * + * \param chain A pointer to an existing chain. + * \param use_padding + * Whether or not padding will be allowed to be used + * during the write. The value of \a use_padding given + * here must match the value later passed to + * FLAC__metadata_chain_write_with_callbacks() or + * FLAC__metadata_chain_write_with_callbacks_with_tempfile(). + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if writing the current chain would require a tempfile, or + * \c false if metadata can be written in place. + */ +FLAC_API FLAC__bool FLAC__metadata_chain_check_if_tempfile_needed(FLAC__Metadata_Chain *chain, FLAC__bool use_padding); + +/** Write all metadata out to the FLAC file. This function tries to be as + * efficient as possible; how the metadata is actually written is shown by + * the following: + * + * If the current chain is the same size as the existing metadata, the new + * data is written in place. + * + * If the current chain is longer than the existing metadata, and + * \a use_padding is \c true, and the last block is a PADDING block of + * sufficient length, the function will truncate the final padding block + * so that the overall size of the metadata is the same as the existing + * metadata, and then just rewrite the metadata. Otherwise, if not all of + * the above conditions are met, the entire FLAC file must be rewritten. + * If you want to use padding this way it is a good idea to call + * FLAC__metadata_chain_sort_padding() first so that you have the maximum + * amount of padding to work with, unless you need to preserve ordering + * of the PADDING blocks for some reason. + * + * If the current chain is shorter than the existing metadata, and + * \a use_padding is \c true, and the final block is a PADDING block, the padding + * is extended to make the overall size the same as the existing data. If + * \a use_padding is \c true and the last block is not a PADDING block, a new + * PADDING block is added to the end of the new data to make it the same + * size as the existing data (if possible, see the note to + * FLAC__metadata_simple_iterator_set_block() about the four byte limit) + * and the new data is written in place. If none of the above apply or + * \a use_padding is \c false, the entire FLAC file is rewritten. + * + * If \a preserve_file_stats is \c true, the owner and modification time will + * be preserved even if the FLAC file is written. + * + * For this write function to be used, the chain must have been read with + * FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(), not + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(). + * + * \param chain A pointer to an existing chain. + * \param use_padding See above. + * \param preserve_file_stats See above. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if the write succeeded, else \c false. On failure, + * check the status with FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_write(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__bool preserve_file_stats); + +/** Write all metadata out to a FLAC stream via callbacks. + * + * (See FLAC__metadata_chain_write() for the details on how padding is + * used to write metadata in place if possible.) + * + * The \a handle must be open for updating and be seekable. The + * equivalent minimum stdio fopen() file mode is \c "r+" (or \c "r+b" + * for Windows). + * + * For this write function to be used, the chain must have been read with + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(), + * not FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(). + * Also, FLAC__metadata_chain_check_if_tempfile_needed() must have returned + * \c false. + * + * \param chain A pointer to an existing chain. + * \param use_padding See FLAC__metadata_chain_write() + * \param handle The I/O handle of the FLAC stream to write. The + * handle will NOT be closed after the metadata is + * written; that is the duty of the caller. + * \param callbacks A set of callbacks to use for I/O. The mandatory + * callbacks are \a write and \a seek. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if the write succeeded, else \c false. On failure, + * check the status with FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks); + +/** Write all metadata out to a FLAC stream via callbacks. + * + * (See FLAC__metadata_chain_write() for the details on how padding is + * used to write metadata in place if possible.) + * + * This version of the write-with-callbacks function must be used when + * FLAC__metadata_chain_check_if_tempfile_needed() returns true. In + * this function, you must supply an I/O handle corresponding to the + * FLAC file to edit, and a temporary handle to which the new FLAC + * file will be written. It is the caller's job to move this temporary + * FLAC file on top of the original FLAC file to complete the metadata + * edit. + * + * The \a handle must be open for reading and be seekable. The + * equivalent minimum stdio fopen() file mode is \c "r" (or \c "rb" + * for Windows). + * + * The \a temp_handle must be open for writing. The + * equivalent minimum stdio fopen() file mode is \c "w" (or \c "wb" + * for Windows). It should be an empty stream, or at least positioned + * at the start-of-file (in which case it is the caller's duty to + * truncate it on return). + * + * For this write function to be used, the chain must have been read with + * FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(), + * not FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg(). + * Also, FLAC__metadata_chain_check_if_tempfile_needed() must have returned + * \c true. + * + * \param chain A pointer to an existing chain. + * \param use_padding See FLAC__metadata_chain_write() + * \param handle The I/O handle of the original FLAC stream to read. + * The handle will NOT be closed after the metadata is + * written; that is the duty of the caller. + * \param callbacks A set of callbacks to use for I/O on \a handle. + * The mandatory callbacks are \a read, \a seek, and + * \a eof. + * \param temp_handle The I/O handle of the FLAC stream to write. The + * handle will NOT be closed after the metadata is + * written; that is the duty of the caller. + * \param temp_callbacks + * A set of callbacks to use for I/O on temp_handle. + * The only mandatory callback is \a write. + * \assert + * \code chain != NULL \endcode + * \retval FLAC__bool + * \c true if the write succeeded, else \c false. On failure, + * check the status with FLAC__metadata_chain_status(). + */ +FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks_and_tempfile(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks, FLAC__IOHandle temp_handle, FLAC__IOCallbacks temp_callbacks); + +/** Merge adjacent PADDING blocks into a single block. + * + * \note This function does not write to the FLAC file, it only + * modifies the chain. + * + * \warning Any iterator on the current chain will become invalid after this + * call. You should delete the iterator and get a new one. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_chain_merge_padding(FLAC__Metadata_Chain *chain); + +/** This function will move all PADDING blocks to the end on the metadata, + * then merge them into a single block. + * + * \note This function does not write to the FLAC file, it only + * modifies the chain. + * + * \warning Any iterator on the current chain will become invalid after this + * call. You should delete the iterator and get a new one. + * + * \param chain A pointer to an existing chain. + * \assert + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_chain_sort_padding(FLAC__Metadata_Chain *chain); + + +/*********** FLAC__Metadata_Iterator ***********/ + +/** Create a new iterator instance. + * + * \retval FLAC__Metadata_Iterator* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__Metadata_Iterator *FLAC__metadata_iterator_new(void); + +/** Free an iterator instance. Deletes the object pointed to by \a iterator. + * + * \param iterator A pointer to an existing iterator. + * \assert + * \code iterator != NULL \endcode + */ +FLAC_API void FLAC__metadata_iterator_delete(FLAC__Metadata_Iterator *iterator); + +/** Initialize the iterator to point to the first metadata block in the + * given chain. + * + * \param iterator A pointer to an existing iterator. + * \param chain A pointer to an existing and initialized (read) chain. + * \assert + * \code iterator != NULL \endcode + * \code chain != NULL \endcode + */ +FLAC_API void FLAC__metadata_iterator_init(FLAC__Metadata_Iterator *iterator, FLAC__Metadata_Chain *chain); + +/** Moves the iterator forward one metadata block, returning \c false if + * already at the end. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if already at the last metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_next(FLAC__Metadata_Iterator *iterator); + +/** Moves the iterator backward one metadata block, returning \c false if + * already at the beginning. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if already at the first metadata block of the chain, else + * \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_prev(FLAC__Metadata_Iterator *iterator); + +/** Get the type of the metadata block at the current position. + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__MetadataType + * The type of the metadata block at the current iterator position. + */ +FLAC_API FLAC__MetadataType FLAC__metadata_iterator_get_block_type(const FLAC__Metadata_Iterator *iterator); + +/** Get the metadata block at the current position. You can modify + * the block in place but must write the chain before the changes + * are reflected to the FLAC file. You do not need to call + * FLAC__metadata_iterator_set_block() to reflect the changes; + * the pointer returned by FLAC__metadata_iterator_get_block() + * points directly into the chain. + * + * \warning + * Do not call FLAC__metadata_object_delete() on the returned object; + * to delete a block use FLAC__metadata_iterator_delete_block(). + * + * \param iterator A pointer to an existing initialized iterator. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__StreamMetadata* + * The current metadata block. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_iterator_get_block(FLAC__Metadata_Iterator *iterator); + +/** Set the metadata block at the current position, replacing the existing + * block. The new block passed in becomes owned by the chain and it will be + * deleted when the chain is deleted. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block A pointer to a metadata block. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \code block != NULL \endcode + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, or + * a memory allocation error occurs, otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_set_block(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block); + +/** Removes the current block from the chain. If \a replace_with_padding is + * \c true, the block will instead be replaced with a padding block of equal + * size. You can not delete the STREAMINFO block. The iterator will be + * left pointing to the block before the one just "deleted", even if + * \a replace_with_padding is \c true. + * + * \param iterator A pointer to an existing initialized iterator. + * \param replace_with_padding See above. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, + * otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_delete_block(FLAC__Metadata_Iterator *iterator, FLAC__bool replace_with_padding); + +/** Insert a new block before the current block. You cannot insert a block + * before the first STREAMINFO block. You cannot insert a STREAMINFO block + * as there can be only one, the one that already exists at the head when you + * read in a chain. The chain takes ownership of the new block and it will be + * deleted when the chain is deleted. The iterator will be left pointing to + * the new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block A pointer to a metadata block to insert. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, or + * a memory allocation error occurs, otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_before(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block); + +/** Insert a new block after the current block. You cannot insert a STREAMINFO + * block as there can be only one, the one that already exists at the head when + * you read in a chain. The chain takes ownership of the new block and it will + * be deleted when the chain is deleted. The iterator will be left pointing to + * the new block. + * + * \param iterator A pointer to an existing initialized iterator. + * \param block A pointer to a metadata block to insert. + * \assert + * \code iterator != NULL \endcode + * \a iterator has been successfully initialized with + * FLAC__metadata_iterator_init() + * \retval FLAC__bool + * \c false if the conditions in the above description are not met, or + * a memory allocation error occurs, otherwise \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_after(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block); + +/* \} */ + + +/** \defgroup flac_metadata_object FLAC/metadata.h: metadata object methods + * \ingroup flac_metadata + * + * \brief + * This module contains methods for manipulating FLAC metadata objects. + * + * Since many are variable length we have to be careful about the memory + * management. We decree that all pointers to data in the object are + * owned by the object and memory-managed by the object. + * + * Use the FLAC__metadata_object_new() and FLAC__metadata_object_delete() + * functions to create all instances. When using the + * FLAC__metadata_object_set_*() functions to set pointers to data, set + * \a copy to \c true to have the function make it's own copy of the data, or + * to \c false to give the object ownership of your data. In the latter case + * your pointer must be freeable by free() and will be free()d when the object + * is FLAC__metadata_object_delete()d. It is legal to pass a null pointer as + * the data pointer to a FLAC__metadata_object_set_*() function as long as + * the length argument is 0 and the \a copy argument is \c false. + * + * The FLAC__metadata_object_new() and FLAC__metadata_object_clone() function + * will return \c NULL in the case of a memory allocation error, otherwise a new + * object. The FLAC__metadata_object_set_*() functions return \c false in the + * case of a memory allocation error. + * + * We don't have the convenience of C++ here, so note that the library relies + * on you to keep the types straight. In other words, if you pass, for + * example, a FLAC__StreamMetadata* that represents a STREAMINFO block to + * FLAC__metadata_object_application_set_data(), you will get an assertion + * failure. + * + * For convenience the FLAC__metadata_object_vorbiscomment_*() functions + * maintain a trailing NUL on each Vorbis comment entry. This is not counted + * toward the length or stored in the stream, but it can make working with plain + * comments (those that don't contain embedded-NULs in the value) easier. + * Entries passed into these functions have trailing NULs added if missing, and + * returned entries are guaranteed to have a trailing NUL. + * + * The FLAC__metadata_object_vorbiscomment_*() functions that take a Vorbis + * comment entry/name/value will first validate that it complies with the Vorbis + * comment specification and return false if it does not. + * + * There is no need to recalculate the length field on metadata blocks you + * have modified. They will be calculated automatically before they are + * written back to a file. + * + * \{ + */ + + +/** Create a new metadata object instance of the given type. + * + * The object will be "empty"; i.e. values and data pointers will be \c 0, + * with the exception of FLAC__METADATA_TYPE_VORBIS_COMMENT, which will have + * the vendor string set (but zero comments). + * + * Do not pass in a value greater than or equal to + * \a FLAC__METADATA_TYPE_UNDEFINED unless you really know what you're + * doing. + * + * \param type Type of object to create + * \retval FLAC__StreamMetadata* + * \c NULL if there was an error allocating memory or the type code is + * greater than FLAC__MAX_METADATA_TYPE_CODE, else the new instance. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_new(FLAC__MetadataType type); + +/** Create a copy of an existing metadata object. + * + * The copy is a "deep" copy, i.e. dynamically allocated data within the + * object is also copied. The caller takes ownership of the new block and + * is responsible for freeing it with FLAC__metadata_object_delete(). + * + * \param object Pointer to object to copy. + * \assert + * \code object != NULL \endcode + * \retval FLAC__StreamMetadata* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_clone(const FLAC__StreamMetadata *object); + +/** Free a metadata object. Deletes the object pointed to by \a object. + * + * The delete is a "deep" delete, i.e. dynamically allocated data within the + * object is also deleted. + * + * \param object A pointer to an existing object. + * \assert + * \code object != NULL \endcode + */ +FLAC_API void FLAC__metadata_object_delete(FLAC__StreamMetadata *object); + +/** Compares two metadata objects. + * + * The compare is "deep", i.e. dynamically allocated data within the + * object is also compared. + * + * \param block1 A pointer to an existing object. + * \param block2 A pointer to an existing object. + * \assert + * \code block1 != NULL \endcode + * \code block2 != NULL \endcode + * \retval FLAC__bool + * \c true if objects are identical, else \c false. + */ +FLAC_API FLAC__bool FLAC__metadata_object_is_equal(const FLAC__StreamMetadata *block1, const FLAC__StreamMetadata *block2); + +/** Sets the application data of an APPLICATION block. + * + * If \a copy is \c true, a copy of the data is stored; otherwise, the object + * takes ownership of the pointer. The existing data will be freed if this + * function is successful, otherwise the original data will remain if \a copy + * is \c true and malloc() fails. + * + * \note It is safe to pass a const pointer to \a data if \a copy is \c true. + * + * \param object A pointer to an existing APPLICATION object. + * \param data A pointer to the data to set. + * \param length The length of \a data in bytes. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_APPLICATION \endcode + * \code (data != NULL && length > 0) || + * (data == NULL && length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, unsigned length, FLAC__bool copy); + +/** Resize the seekpoint array. + * + * If the size shrinks, elements will truncated; if it grows, new placeholder + * points will be added to the end. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param new_num_points The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code (object->data.seek_table.points == NULL && object->data.seek_table.num_points == 0) || + * (object->data.seek_table.points != NULL && object->data.seek_table.num_points > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMetadata *object, unsigned new_num_points); + +/** Set a seekpoint in a seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param point_num Index into seekpoint array to set. + * \param point The point to set. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code object->data.seek_table.num_points > point_num \endcode + */ +FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point); + +/** Insert a seekpoint into a seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param point_num Index into seekpoint array to set. + * \param point The point to set. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code object->data.seek_table.num_points >= point_num \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point); + +/** Delete a seekpoint from a seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param point_num Index into seekpoint array to set. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code object->data.seek_table.num_points > point_num \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_delete_point(FLAC__StreamMetadata *object, unsigned point_num); + +/** Check a seektable to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * seektable. + * + * \param object A pointer to an existing SEEKTABLE object. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if seek table is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_is_legal(const FLAC__StreamMetadata *object); + +/** Append a number of placeholder points to the end of a seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param num The number of placeholder points to append. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_placeholders(FLAC__StreamMetadata *object, unsigned num); + +/** Append a specific seek point template to the end of a seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param sample_number The sample number of the seek point template. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_point(FLAC__StreamMetadata *object, FLAC__uint64 sample_number); + +/** Append specific seek point templates to the end of a seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param sample_numbers An array of sample numbers for the seek points. + * \param num The number of seek point templates to append. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC__StreamMetadata *object, FLAC__uint64 sample_numbers[], unsigned num); + +/** Append a set of evenly-spaced seek point templates to the end of a + * seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param num The number of placeholder points to append. + * \param total_samples The total number of samples to be encoded; + * the seekpoints will be spaced approximately + * \a total_samples / \a num samples apart. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code total_samples > 0 \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points(FLAC__StreamMetadata *object, unsigned num, FLAC__uint64 total_samples); + +/** Append a set of evenly-spaced seek point templates to the end of a + * seek table. + * + * \note + * As with the other ..._seektable_template_... functions, you should + * call FLAC__metadata_object_seektable_template_sort() when finished + * to make the seek table legal. + * + * \param object A pointer to an existing SEEKTABLE object. + * \param samples The number of samples apart to space the placeholder + * points. The first point will be at sample \c 0, the + * second at sample \a samples, then 2*\a samples, and + * so on. As long as \a samples and \a total_samples + * are greater than \c 0, there will always be at least + * one seekpoint at sample \c 0. + * \param total_samples The total number of samples to be encoded; + * the seekpoints will be spaced + * \a samples samples apart. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \code samples > 0 \endcode + * \code total_samples > 0 \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(FLAC__StreamMetadata *object, unsigned samples, FLAC__uint64 total_samples); + +/** Sort a seek table's seek points according to the format specification, + * removing duplicates. + * + * \param object A pointer to a seek table to be sorted. + * \param compact If \c false, behaves like FLAC__format_seektable_sort(). + * If \c true, duplicates are deleted and the seek table is + * shrunk appropriately; the number of placeholder points + * present in the seek table will be the same after the call + * as before. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_sort(FLAC__StreamMetadata *object, FLAC__bool compact); + +/** Sets the vendor string in a VORBIS_COMMENT block. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param entry The entry to set the vendor string to. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_vendor_string(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Resize the comment array. + * + * If the size shrinks, elements will truncated; if it grows, new empty + * fields will be added to the end. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param new_num_comments The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (object->data.vorbis_comment.comments == NULL && object->data.vorbis_comment.num_comments == 0) || + * (object->data.vorbis_comment.comments != NULL && object->data.vorbis_comment.num_comments > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__StreamMetadata *object, unsigned new_num_comments); + +/** Sets a comment in a VORBIS_COMMENT block. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param comment_num Index into comment array to set. + * \param entry The entry to set the comment to. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code comment_num < object->data.vorbis_comment.num_comments \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Insert a comment in a VORBIS_COMMENT block at the given index. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param comment_num The index at which to insert the comment. The comments + * at and after \a comment_num move right one position. + * To append a comment to the end, set \a comment_num to + * \c object->data.vorbis_comment.num_comments . + * \param entry The comment to insert. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code object->data.vorbis_comment.num_comments >= comment_num \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_insert_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Appends a comment to a VORBIS_COMMENT block. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param entry The comment to insert. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_append_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy); + +/** Replaces comments in a VORBIS_COMMENT block with a new one. + * + * For convenience, a trailing NUL is added to the entry if it doesn't have + * one already. + * + * Depending on the the value of \a all, either all or just the first comment + * whose field name(s) match the given entry's name will be replaced by the + * given entry. If no comments match, \a entry will simply be appended. + * + * If \a copy is \c true, a copy of the entry is stored; otherwise, the object + * takes ownership of the \c entry.entry pointer. + * + * \note If this function returns \c false, the caller still owns the + * pointer. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param entry The comment to insert. + * \param all If \c true, all comments whose field name matches + * \a entry's field name will be removed, and \a entry will + * be inserted at the position of the first matching + * comment. If \c false, only the first comment whose + * field name matches \a entry's field name will be + * replaced with \a entry. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code (entry.entry != NULL && entry.length > 0) || + * (entry.entry == NULL && entry.length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_replace_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool all, FLAC__bool copy); + +/** Delete a comment in a VORBIS_COMMENT block at the given index. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param comment_num The index of the comment to delete. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code object->data.vorbis_comment.num_comments > comment_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_delete_comment(FLAC__StreamMetadata *object, unsigned comment_num); + +/** Creates a Vorbis comment entry from NUL-terminated name and value strings. + * + * On return, the filled-in \a entry->entry pointer will point to malloc()ed + * memory and shall be owned by the caller. For convenience the entry will + * have a terminating NUL. + * + * \param entry A pointer to a Vorbis comment entry. The entry's + * \c entry pointer should not point to allocated + * memory as it will be overwritten. + * \param field_name The field name in ASCII, \c NUL terminated. + * \param field_value The field value in UTF-8, \c NUL terminated. + * \assert + * \code entry != NULL \endcode + * \code field_name != NULL \endcode + * \code field_value != NULL \endcode + * \retval FLAC__bool + * \c false if malloc() fails, or if \a field_name or \a field_value does + * not comply with the Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field_name, const char *field_value); + +/** Splits a Vorbis comment entry into NUL-terminated name and value strings. + * + * The returned pointers to name and value will be allocated by malloc() + * and shall be owned by the caller. + * + * \param entry An existing Vorbis comment entry. + * \param field_name The address of where the returned pointer to the + * field name will be stored. + * \param field_value The address of where the returned pointer to the + * field value will be stored. + * \assert + * \code (entry.entry != NULL && entry.length > 0) \endcode + * \code memchr(entry.entry, '=', entry.length) != NULL \endcode + * \code field_name != NULL \endcode + * \code field_value != NULL \endcode + * \retval FLAC__bool + * \c false if memory allocation fails or \a entry does not comply with the + * Vorbis comment specification, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(const FLAC__StreamMetadata_VorbisComment_Entry entry, char **field_name, char **field_value); + +/** Check if the given Vorbis comment entry's field name matches the given + * field name. + * + * \param entry An existing Vorbis comment entry. + * \param field_name The field name to check. + * \param field_name_length The length of \a field_name, not including the + * terminating \c NUL. + * \assert + * \code (entry.entry != NULL && entry.length > 0) \endcode + * \retval FLAC__bool + * \c true if the field names match, else \c false + */ +FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC__StreamMetadata_VorbisComment_Entry entry, const char *field_name, unsigned field_name_length); + +/** Find a Vorbis comment with the given field name. + * + * The search begins at entry number \a offset; use an offset of 0 to + * search from the beginning of the comment array. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param offset The offset into the comment array from where to start + * the search. + * \param field_name The field name of the comment to find. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \code field_name != NULL \endcode + * \retval int + * The offset in the comment array of the first comment whose field + * name matches \a field_name, or \c -1 if no match was found. + */ +FLAC_API int FLAC__metadata_object_vorbiscomment_find_entry_from(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name); + +/** Remove first Vorbis comment matching the given field name. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param field_name The field name of comment to delete. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \retval int + * \c -1 for memory allocation error, \c 0 for no matching entries, + * \c 1 for one matching entry deleted. + */ +FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entry_matching(FLAC__StreamMetadata *object, const char *field_name); + +/** Remove all Vorbis comments matching the given field name. + * + * \param object A pointer to an existing VORBIS_COMMENT object. + * \param field_name The field name of comments to delete. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT \endcode + * \retval int + * \c -1 for memory allocation error, \c 0 for no matching entries, + * else the number of matching entries deleted. + */ +FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entries_matching(FLAC__StreamMetadata *object, const char *field_name); + +/** Create a new CUESHEET track instance. + * + * The object will be "empty"; i.e. values and data pointers will be \c 0. + * + * \retval FLAC__StreamMetadata_CueSheet_Track* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_new(void); + +/** Create a copy of an existing CUESHEET track object. + * + * The copy is a "deep" copy, i.e. dynamically allocated data within the + * object is also copied. The caller takes ownership of the new object and + * is responsible for freeing it with + * FLAC__metadata_object_cuesheet_track_delete(). + * + * \param object Pointer to object to copy. + * \assert + * \code object != NULL \endcode + * \retval FLAC__StreamMetadata_CueSheet_Track* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_clone(const FLAC__StreamMetadata_CueSheet_Track *object); + +/** Delete a CUESHEET track object + * + * \param object A pointer to an existing CUESHEET track object. + * \assert + * \code object != NULL \endcode + */ +FLAC_API void FLAC__metadata_object_cuesheet_track_delete(FLAC__StreamMetadata_CueSheet_Track *object); + +/** Resize a track's index point array. + * + * If the size shrinks, elements will truncated; if it grows, new blank + * indices will be added to the end. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index of the track to modify. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param new_num_indices The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code (object->data.cue_sheet.tracks[track_num].indices == NULL && object->data.cue_sheet.tracks[track_num].num_indices == 0) || + * (object->data.cue_sheet.tracks[track_num].indices != NULL && object->data.cue_sheet.tracks[track_num].num_indices > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__StreamMetadata *object, unsigned track_num, unsigned new_num_indices); + +/** Insert an index point in a CUESHEET track at the given index. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index of the track to modify. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param index_num The index into the track's index array at which to + * insert the index point. NOTE: this is not necessarily + * the same as the index point's \a number field. The + * indices at and after \a index_num move right one + * position. To append an index point to the end, set + * \a index_num to + * \c object->data.cue_sheet.tracks[track_num].num_indices . + * \param index The index point to insert. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code object->data.cue_sheet.tracks[track_num].num_indices >= index_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num, FLAC__StreamMetadata_CueSheet_Index index); + +/** Insert a blank index point in a CUESHEET track at the given index. + * + * A blank index point is one in which all field values are zero. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index of the track to modify. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param index_num The index into the track's index array at which to + * insert the index point. NOTE: this is not necessarily + * the same as the index point's \a number field. The + * indices at and after \a index_num move right one + * position. To append an index point to the end, set + * \a index_num to + * \c object->data.cue_sheet.tracks[track_num].num_indices . + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code object->data.cue_sheet.tracks[track_num].num_indices >= index_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num); + +/** Delete an index point in a CUESHEET track at the given index. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index into the track array of the track to + * modify. NOTE: this is not necessarily the same + * as the track's \a number field. + * \param index_num The index into the track's index array of the index + * to delete. NOTE: this is not necessarily the same + * as the index's \a number field. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \code object->data.cue_sheet.tracks[track_num].num_indices > index_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num); + +/** Resize the track array. + * + * If the size shrinks, elements will truncated; if it grows, new blank + * tracks will be added to the end. + * + * \param object A pointer to an existing CUESHEET object. + * \param new_num_tracks The desired length of the array; may be \c 0. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code (object->data.cue_sheet.tracks == NULL && object->data.cue_sheet.num_tracks == 0) || + * (object->data.cue_sheet.tracks != NULL && object->data.cue_sheet.num_tracks > 0) \endcode + * \retval FLAC__bool + * \c false if memory allocation error, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMetadata *object, unsigned new_num_tracks); + +/** Sets a track in a CUESHEET block. + * + * If \a copy is \c true, a copy of the track is stored; otherwise, the object + * takes ownership of the \a track pointer. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num Index into track array to set. NOTE: this is not + * necessarily the same as the track's \a number field. + * \param track The track to set the track to. You may safely pass in + * a const pointer if \a copy is \c true. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code track_num < object->data.cue_sheet.num_tracks \endcode + * \code (track->indices != NULL && track->num_indices > 0) || + * (track->indices == NULL && track->num_indices == 0) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy); + +/** Insert a track in a CUESHEET block at the given index. + * + * If \a copy is \c true, a copy of the track is stored; otherwise, the object + * takes ownership of the \a track pointer. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index at which to insert the track. NOTE: this + * is not necessarily the same as the track's \a number + * field. The tracks at and after \a track_num move right + * one position. To append a track to the end, set + * \a track_num to \c object->data.cue_sheet.num_tracks . + * \param track The track to insert. You may safely pass in a const + * pointer if \a copy is \c true. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks >= track_num \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy); + +/** Insert a blank track in a CUESHEET block at the given index. + * + * A blank track is one in which all field values are zero. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index at which to insert the track. NOTE: this + * is not necessarily the same as the track's \a number + * field. The tracks at and after \a track_num move right + * one position. To append a track to the end, set + * \a track_num to \c object->data.cue_sheet.num_tracks . + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks >= track_num \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__StreamMetadata *object, unsigned track_num); + +/** Delete a track in a CUESHEET block at the given index. + * + * \param object A pointer to an existing CUESHEET object. + * \param track_num The index into the track array of the track to + * delete. NOTE: this is not necessarily the same + * as the track's \a number field. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \code object->data.cue_sheet.num_tracks > track_num \endcode + * \retval FLAC__bool + * \c false if realloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_delete_track(FLAC__StreamMetadata *object, unsigned track_num); + +/** Check a cue sheet to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * cue sheet. + * + * \param object A pointer to an existing CUESHEET object. + * \param check_cd_da_subset If \c true, check CUESHEET against more + * stringent requirements for a CD-DA (audio) disc. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \retval FLAC__bool + * \c false if cue sheet is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_is_legal(const FLAC__StreamMetadata *object, FLAC__bool check_cd_da_subset, const char **violation); + +/** Calculate and return the CDDB/freedb ID for a cue sheet. The function + * assumes the cue sheet corresponds to a CD; the result is undefined + * if the cuesheet's is_cd bit is not set. + * + * \param object A pointer to an existing CUESHEET object. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_CUESHEET \endcode + * \retval FLAC__uint32 + * The unsigned integer representation of the CDDB/freedb ID + */ +FLAC_API FLAC__uint32 FLAC__metadata_object_cuesheet_calculate_cddb_id(const FLAC__StreamMetadata *object); + +/** Sets the MIME type of a PICTURE block. + * + * If \a copy is \c true, a copy of the string is stored; otherwise, the object + * takes ownership of the pointer. The existing string will be freed if this + * function is successful, otherwise the original string will remain if \a copy + * is \c true and malloc() fails. + * + * \note It is safe to pass a const pointer to \a mime_type if \a copy is \c true. + * + * \param object A pointer to an existing PICTURE object. + * \param mime_type A pointer to the MIME type string. The string must be + * ASCII characters 0x20-0x7e, NUL-terminated. No validation + * is done. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \code (mime_type != NULL) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_set_mime_type(FLAC__StreamMetadata *object, char *mime_type, FLAC__bool copy); + +/** Sets the description of a PICTURE block. + * + * If \a copy is \c true, a copy of the string is stored; otherwise, the object + * takes ownership of the pointer. The existing string will be freed if this + * function is successful, otherwise the original string will remain if \a copy + * is \c true and malloc() fails. + * + * \note It is safe to pass a const pointer to \a description if \a copy is \c true. + * + * \param object A pointer to an existing PICTURE object. + * \param description A pointer to the description string. The string must be + * valid UTF-8, NUL-terminated. No validation is done. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \code (description != NULL) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_set_description(FLAC__StreamMetadata *object, FLAC__byte *description, FLAC__bool copy); + +/** Sets the picture data of a PICTURE block. + * + * If \a copy is \c true, a copy of the data is stored; otherwise, the object + * takes ownership of the pointer. Also sets the \a data_length field of the + * metadata object to what is passed in as the \a length parameter. The + * existing data will be freed if this function is successful, otherwise the + * original data and data_length will remain if \a copy is \c true and + * malloc() fails. + * + * \note It is safe to pass a const pointer to \a data if \a copy is \c true. + * + * \param object A pointer to an existing PICTURE object. + * \param data A pointer to the data to set. + * \param length The length of \a data in bytes. + * \param copy See above. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \code (data != NULL && length > 0) || + * (data == NULL && length == 0 && copy == false) \endcode + * \retval FLAC__bool + * \c false if \a copy is \c true and malloc() fails, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, FLAC__uint32 length, FLAC__bool copy); + +/** Check a PICTURE block to see if it conforms to the FLAC specification. + * See the format specification for limits on the contents of the + * PICTURE block. + * + * \param object A pointer to existing PICTURE block to be checked. + * \param violation Address of a pointer to a string. If there is a + * violation, a pointer to a string explanation of the + * violation will be returned here. \a violation may be + * \c NULL if you don't need the returned string. Do not + * free the returned string; it will always point to static + * data. + * \assert + * \code object != NULL \endcode + * \code object->type == FLAC__METADATA_TYPE_PICTURE \endcode + * \retval FLAC__bool + * \c false if PICTURE block is illegal, else \c true. + */ +FLAC_API FLAC__bool FLAC__metadata_object_picture_is_legal(const FLAC__StreamMetadata *object, const char **violation); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/Windows/codecs/include/FLAC/ordinals.h b/quakespasm/Windows/codecs/include/FLAC/ordinals.h new file mode 100644 index 00000000..a0572997 --- /dev/null +++ b/quakespasm/Windows/codecs/include/FLAC/ordinals.h @@ -0,0 +1,86 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__ORDINALS_H +#define FLAC__ORDINALS_H + +#if defined(_MSC_VER) && _MSC_VER < 1600 + +/* Microsoft Visual Studio earlier than the 2010 version did not provide + * the 1999 ISO C Standard header file . + */ + +typedef __int8 FLAC__int8; +typedef unsigned __int8 FLAC__uint8; + +typedef __int16 FLAC__int16; +typedef __int32 FLAC__int32; +typedef __int64 FLAC__int64; +typedef unsigned __int16 FLAC__uint16; +typedef unsigned __int32 FLAC__uint32; +typedef unsigned __int64 FLAC__uint64; + +#else + +/* For MSVC 2010 and everything else which provides . */ + +#include + +typedef int8_t FLAC__int8; +typedef uint8_t FLAC__uint8; + +typedef int16_t FLAC__int16; +typedef int32_t FLAC__int32; +typedef int64_t FLAC__int64; +typedef uint16_t FLAC__uint16; +typedef uint32_t FLAC__uint32; +typedef uint64_t FLAC__uint64; + +#endif + +typedef int FLAC__bool; + +typedef FLAC__uint8 FLAC__byte; + + +#ifdef true +#undef true +#endif +#ifdef false +#undef false +#endif +#ifndef __cplusplus +#define true 1 +#define false 0 +#endif + +#endif diff --git a/quakespasm/Windows/codecs/include/FLAC/stream_decoder.h b/quakespasm/Windows/codecs/include/FLAC/stream_decoder.h new file mode 100644 index 00000000..152643fc --- /dev/null +++ b/quakespasm/Windows/codecs/include/FLAC/stream_decoder.h @@ -0,0 +1,1560 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__STREAM_DECODER_H +#define FLAC__STREAM_DECODER_H + +#include /* for FILE */ +#include "export.h" +#include "format.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** \file include/FLAC/stream_decoder.h + * + * \brief + * This module contains the functions which implement the stream + * decoder. + * + * See the detailed documentation in the + * \link flac_stream_decoder stream decoder \endlink module. + */ + +/** \defgroup flac_decoder FLAC/ \*_decoder.h: decoder interfaces + * \ingroup flac + * + * \brief + * This module describes the decoder layers provided by libFLAC. + * + * The stream decoder can be used to decode complete streams either from + * the client via callbacks, or directly from a file, depending on how + * it is initialized. When decoding via callbacks, the client provides + * callbacks for reading FLAC data and writing decoded samples, and + * handling metadata and errors. If the client also supplies seek-related + * callback, the decoder function for sample-accurate seeking within the + * FLAC input is also available. When decoding from a file, the client + * needs only supply a filename or open \c FILE* and write/metadata/error + * callbacks; the rest of the callbacks are supplied internally. For more + * info see the \link flac_stream_decoder stream decoder \endlink module. + */ + +/** \defgroup flac_stream_decoder FLAC/stream_decoder.h: stream decoder interface + * \ingroup flac_decoder + * + * \brief + * This module contains the functions which implement the stream + * decoder. + * + * The stream decoder can decode native FLAC, and optionally Ogg FLAC + * (check FLAC_API_SUPPORTS_OGG_FLAC) streams and files. + * + * The basic usage of this decoder is as follows: + * - The program creates an instance of a decoder using + * FLAC__stream_decoder_new(). + * - The program overrides the default settings using + * FLAC__stream_decoder_set_*() functions. + * - The program initializes the instance to validate the settings and + * prepare for decoding using + * - FLAC__stream_decoder_init_stream() or FLAC__stream_decoder_init_FILE() + * or FLAC__stream_decoder_init_file() for native FLAC, + * - FLAC__stream_decoder_init_ogg_stream() or FLAC__stream_decoder_init_ogg_FILE() + * or FLAC__stream_decoder_init_ogg_file() for Ogg FLAC + * - The program calls the FLAC__stream_decoder_process_*() functions + * to decode data, which subsequently calls the callbacks. + * - The program finishes the decoding with FLAC__stream_decoder_finish(), + * which flushes the input and output and resets the decoder to the + * uninitialized state. + * - The instance may be used again or deleted with + * FLAC__stream_decoder_delete(). + * + * In more detail, the program will create a new instance by calling + * FLAC__stream_decoder_new(), then call FLAC__stream_decoder_set_*() + * functions to override the default decoder options, and call + * one of the FLAC__stream_decoder_init_*() functions. + * + * There are three initialization functions for native FLAC, one for + * setting up the decoder to decode FLAC data from the client via + * callbacks, and two for decoding directly from a FLAC file. + * + * For decoding via callbacks, use FLAC__stream_decoder_init_stream(). + * You must also supply several callbacks for handling I/O. Some (like + * seeking) are optional, depending on the capabilities of the input. + * + * For decoding directly from a file, use FLAC__stream_decoder_init_FILE() + * or FLAC__stream_decoder_init_file(). Then you must only supply an open + * \c FILE* or filename and fewer callbacks; the decoder will handle + * the other callbacks internally. + * + * There are three similarly-named init functions for decoding from Ogg + * FLAC streams. Check \c FLAC_API_SUPPORTS_OGG_FLAC to find out if the + * library has been built with Ogg support. + * + * Once the decoder is initialized, your program will call one of several + * functions to start the decoding process: + * + * - FLAC__stream_decoder_process_single() - Tells the decoder to process at + * most one metadata block or audio frame and return, calling either the + * metadata callback or write callback, respectively, once. If the decoder + * loses sync it will return with only the error callback being called. + * - FLAC__stream_decoder_process_until_end_of_metadata() - Tells the decoder + * to process the stream from the current location and stop upon reaching + * the first audio frame. The client will get one metadata, write, or error + * callback per metadata block, audio frame, or sync error, respectively. + * - FLAC__stream_decoder_process_until_end_of_stream() - Tells the decoder + * to process the stream from the current location until the read callback + * returns FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM or + * FLAC__STREAM_DECODER_READ_STATUS_ABORT. The client will get one metadata, + * write, or error callback per metadata block, audio frame, or sync error, + * respectively. + * + * When the decoder has finished decoding (normally or through an abort), + * the instance is finished by calling FLAC__stream_decoder_finish(), which + * ensures the decoder is in the correct state and frees memory. Then the + * instance may be deleted with FLAC__stream_decoder_delete() or initialized + * again to decode another stream. + * + * Seeking is exposed through the FLAC__stream_decoder_seek_absolute() method. + * At any point after the stream decoder has been initialized, the client can + * call this function to seek to an exact sample within the stream. + * Subsequently, the first time the write callback is called it will be + * passed a (possibly partial) block starting at that sample. + * + * If the client cannot seek via the callback interface provided, but still + * has another way of seeking, it can flush the decoder using + * FLAC__stream_decoder_flush() and start feeding data from the new position + * through the read callback. + * + * The stream decoder also provides MD5 signature checking. If this is + * turned on before initialization, FLAC__stream_decoder_finish() will + * report when the decoded MD5 signature does not match the one stored + * in the STREAMINFO block. MD5 checking is automatically turned off + * (until the next FLAC__stream_decoder_reset()) if there is no signature + * in the STREAMINFO block or when a seek is attempted. + * + * The FLAC__stream_decoder_set_metadata_*() functions deserve special + * attention. By default, the decoder only calls the metadata_callback for + * the STREAMINFO block. These functions allow you to tell the decoder + * explicitly which blocks to parse and return via the metadata_callback + * and/or which to skip. Use a FLAC__stream_decoder_set_metadata_respond_all(), + * FLAC__stream_decoder_set_metadata_ignore() ... or FLAC__stream_decoder_set_metadata_ignore_all(), + * FLAC__stream_decoder_set_metadata_respond() ... sequence to exactly specify + * which blocks to return. Remember that metadata blocks can potentially + * be big (for example, cover art) so filtering out the ones you don't + * use can reduce the memory requirements of the decoder. Also note the + * special forms FLAC__stream_decoder_set_metadata_respond_application(id) + * and FLAC__stream_decoder_set_metadata_ignore_application(id) for + * filtering APPLICATION blocks based on the application ID. + * + * STREAMINFO and SEEKTABLE blocks are always parsed and used internally, but + * they still can legally be filtered from the metadata_callback. + * + * \note + * The "set" functions may only be called when the decoder is in the + * state FLAC__STREAM_DECODER_UNINITIALIZED, i.e. after + * FLAC__stream_decoder_new() or FLAC__stream_decoder_finish(), but + * before FLAC__stream_decoder_init_*(). If this is the case they will + * return \c true, otherwise \c false. + * + * \note + * FLAC__stream_decoder_finish() resets all settings to the constructor + * defaults, including the callbacks. + * + * \{ + */ + + +/** State values for a FLAC__StreamDecoder + * + * The decoder's state can be obtained by calling FLAC__stream_decoder_get_state(). + */ +typedef enum { + + FLAC__STREAM_DECODER_SEARCH_FOR_METADATA = 0, + /**< The decoder is ready to search for metadata. */ + + FLAC__STREAM_DECODER_READ_METADATA, + /**< The decoder is ready to or is in the process of reading metadata. */ + + FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC, + /**< The decoder is ready to or is in the process of searching for the + * frame sync code. + */ + + FLAC__STREAM_DECODER_READ_FRAME, + /**< The decoder is ready to or is in the process of reading a frame. */ + + FLAC__STREAM_DECODER_END_OF_STREAM, + /**< The decoder has reached the end of the stream. */ + + FLAC__STREAM_DECODER_OGG_ERROR, + /**< An error occurred in the underlying Ogg layer. */ + + FLAC__STREAM_DECODER_SEEK_ERROR, + /**< An error occurred while seeking. The decoder must be flushed + * with FLAC__stream_decoder_flush() or reset with + * FLAC__stream_decoder_reset() before decoding can continue. + */ + + FLAC__STREAM_DECODER_ABORTED, + /**< The decoder was aborted by the read callback. */ + + FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR, + /**< An error occurred allocating memory. The decoder is in an invalid + * state and can no longer be used. + */ + + FLAC__STREAM_DECODER_UNINITIALIZED + /**< The decoder is in the uninitialized state; one of the + * FLAC__stream_decoder_init_*() functions must be called before samples + * can be processed. + */ + +} FLAC__StreamDecoderState; + +/** Maps a FLAC__StreamDecoderState to a C string. + * + * Using a FLAC__StreamDecoderState as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderStateString[]; + + +/** Possible return values for the FLAC__stream_decoder_init_*() functions. + */ +typedef enum { + + FLAC__STREAM_DECODER_INIT_STATUS_OK = 0, + /**< Initialization was successful. */ + + FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER, + /**< The library was not compiled with support for the given container + * format. + */ + + FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS, + /**< A required callback was not supplied. */ + + FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR, + /**< An error occurred allocating memory. */ + + FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE, + /**< fopen() failed in FLAC__stream_decoder_init_file() or + * FLAC__stream_decoder_init_ogg_file(). */ + + FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED + /**< FLAC__stream_decoder_init_*() was called when the decoder was + * already initialized, usually because + * FLAC__stream_decoder_finish() was not called. + */ + +} FLAC__StreamDecoderInitStatus; + +/** Maps a FLAC__StreamDecoderInitStatus to a C string. + * + * Using a FLAC__StreamDecoderInitStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderInitStatusString[]; + + +/** Return values for the FLAC__StreamDecoder read callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_READ_STATUS_CONTINUE, + /**< The read was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM, + /**< The read was attempted while at the end of the stream. Note that + * the client must only return this value when the read callback was + * called when already at the end of the stream. Otherwise, if the read + * itself moves to the end of the stream, the client should still return + * the data and \c FLAC__STREAM_DECODER_READ_STATUS_CONTINUE, and then on + * the next read callback it should return + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM with a byte count + * of \c 0. + */ + + FLAC__STREAM_DECODER_READ_STATUS_ABORT + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + +} FLAC__StreamDecoderReadStatus; + +/** Maps a FLAC__StreamDecoderReadStatus to a C string. + * + * Using a FLAC__StreamDecoderReadStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderReadStatusString[]; + + +/** Return values for the FLAC__StreamDecoder seek callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_SEEK_STATUS_OK, + /**< The seek was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_SEEK_STATUS_ERROR, + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + + FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED + /**< Client does not support seeking. */ + +} FLAC__StreamDecoderSeekStatus; + +/** Maps a FLAC__StreamDecoderSeekStatus to a C string. + * + * Using a FLAC__StreamDecoderSeekStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderSeekStatusString[]; + + +/** Return values for the FLAC__StreamDecoder tell callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_TELL_STATUS_OK, + /**< The tell was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_TELL_STATUS_ERROR, + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + + FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED + /**< Client does not support telling the position. */ + +} FLAC__StreamDecoderTellStatus; + +/** Maps a FLAC__StreamDecoderTellStatus to a C string. + * + * Using a FLAC__StreamDecoderTellStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderTellStatusString[]; + + +/** Return values for the FLAC__StreamDecoder length callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_LENGTH_STATUS_OK, + /**< The length call was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR, + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + + FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED + /**< Client does not support reporting the length. */ + +} FLAC__StreamDecoderLengthStatus; + +/** Maps a FLAC__StreamDecoderLengthStatus to a C string. + * + * Using a FLAC__StreamDecoderLengthStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderLengthStatusString[]; + + +/** Return values for the FLAC__StreamDecoder write callback. + */ +typedef enum { + + FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE, + /**< The write was OK and decoding can continue. */ + + FLAC__STREAM_DECODER_WRITE_STATUS_ABORT + /**< An unrecoverable error occurred. The decoder will return from the process call. */ + +} FLAC__StreamDecoderWriteStatus; + +/** Maps a FLAC__StreamDecoderWriteStatus to a C string. + * + * Using a FLAC__StreamDecoderWriteStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderWriteStatusString[]; + + +/** Possible values passed back to the FLAC__StreamDecoder error callback. + * \c FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC is the generic catch- + * all. The rest could be caused by bad sync (false synchronization on + * data that is not the start of a frame) or corrupted data. The error + * itself is the decoder's best guess at what happened assuming a correct + * sync. For example \c FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER + * could be caused by a correct sync on the start of a frame, but some + * data in the frame header was corrupted. Or it could be the result of + * syncing on a point the stream that looked like the starting of a frame + * but was not. \c FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM + * could be because the decoder encountered a valid frame made by a future + * version of the encoder which it cannot parse, or because of a false + * sync making it appear as though an encountered frame was generated by + * a future encoder. + */ +typedef enum { + + FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC, + /**< An error in the stream caused the decoder to lose synchronization. */ + + FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER, + /**< The decoder encountered a corrupted frame header. */ + + FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH, + /**< The frame's data did not match the CRC in the footer. */ + + FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM + /**< The decoder encountered reserved fields in use in the stream. */ + +} FLAC__StreamDecoderErrorStatus; + +/** Maps a FLAC__StreamDecoderErrorStatus to a C string. + * + * Using a FLAC__StreamDecoderErrorStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamDecoderErrorStatusString[]; + + +/*********************************************************************** + * + * class FLAC__StreamDecoder + * + ***********************************************************************/ + +struct FLAC__StreamDecoderProtected; +struct FLAC__StreamDecoderPrivate; +/** The opaque structure definition for the stream decoder type. + * See the \link flac_stream_decoder stream decoder module \endlink + * for a detailed description. + */ +typedef struct { + struct FLAC__StreamDecoderProtected *protected_; /* avoid the C++ keyword 'protected' */ + struct FLAC__StreamDecoderPrivate *private_; /* avoid the C++ keyword 'private' */ +} FLAC__StreamDecoder; + +/** Signature for the read callback. + * + * A function pointer matching this signature must be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder needs more input data. The address of the + * buffer to be filled is supplied, along with the number of bytes the + * buffer can hold. The callback may choose to supply less data and + * modify the byte count but must be careful not to overflow the buffer. + * The callback then returns a status code chosen from + * FLAC__StreamDecoderReadStatus. + * + * Here is an example of a read callback for stdio streams: + * \code + * FLAC__StreamDecoderReadStatus read_cb(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(*bytes > 0) { + * *bytes = fread(buffer, sizeof(FLAC__byte), *bytes, file); + * if(ferror(file)) + * return FLAC__STREAM_DECODER_READ_STATUS_ABORT; + * else if(*bytes == 0) + * return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM; + * else + * return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; + * } + * else + * return FLAC__STREAM_DECODER_READ_STATUS_ABORT; + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param buffer A pointer to a location for the callee to store + * data to be decoded. + * \param bytes A pointer to the size of the buffer. On entry + * to the callback, it contains the maximum number + * of bytes that may be stored in \a buffer. The + * callee must set it to the actual number of bytes + * stored (0 in case of error or end-of-stream) before + * returning. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderReadStatus + * The callee's return status. Note that the callback should return + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM if and only if + * zero bytes were read and there is no more data to be read. + */ +typedef FLAC__StreamDecoderReadStatus (*FLAC__StreamDecoderReadCallback)(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data); + +/** Signature for the seek callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder needs to seek the input stream. The decoder + * will pass the absolute byte offset to seek to, 0 meaning the + * beginning of the stream. + * + * Here is an example of a seek callback for stdio streams: + * \code + * FLAC__StreamDecoderSeekStatus seek_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(file == stdin) + * return FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED; + * else if(fseeko(file, (off_t)absolute_byte_offset, SEEK_SET) < 0) + * return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR; + * else + * return FLAC__STREAM_DECODER_SEEK_STATUS_OK; + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param absolute_byte_offset The offset from the beginning of the stream + * to seek to. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderSeekStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderSeekStatus (*FLAC__StreamDecoderSeekCallback)(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data); + +/** Signature for the tell callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder wants to know the current position of the + * stream. The callback should return the byte offset from the + * beginning of the stream. + * + * Here is an example of a tell callback for stdio streams: + * \code + * FLAC__StreamDecoderTellStatus tell_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * off_t pos; + * if(file == stdin) + * return FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED; + * else if((pos = ftello(file)) < 0) + * return FLAC__STREAM_DECODER_TELL_STATUS_ERROR; + * else { + * *absolute_byte_offset = (FLAC__uint64)pos; + * return FLAC__STREAM_DECODER_TELL_STATUS_OK; + * } + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param absolute_byte_offset A pointer to storage for the current offset + * from the beginning of the stream. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderTellStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderTellStatus (*FLAC__StreamDecoderTellCallback)(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data); + +/** Signature for the length callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder wants to know the total length of the stream + * in bytes. + * + * Here is an example of a length callback for stdio streams: + * \code + * FLAC__StreamDecoderLengthStatus length_cb(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * struct stat filestats; + * + * if(file == stdin) + * return FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED; + * else if(fstat(fileno(file), &filestats) != 0) + * return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR; + * else { + * *stream_length = (FLAC__uint64)filestats.st_size; + * return FLAC__STREAM_DECODER_LENGTH_STATUS_OK; + * } + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param stream_length A pointer to storage for the length of the stream + * in bytes. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderLengthStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderLengthStatus (*FLAC__StreamDecoderLengthCallback)(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data); + +/** Signature for the EOF callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_decoder_init*_stream(). The supplied function will be + * called when the decoder needs to know if the end of the stream has + * been reached. + * + * Here is an example of a EOF callback for stdio streams: + * FLAC__bool eof_cb(const FLAC__StreamDecoder *decoder, void *client_data) + * \code + * { + * FILE *file = ((MyClientData*)client_data)->file; + * return feof(file)? true : false; + * } + * \endcode + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__bool + * \c true if the currently at the end of the stream, else \c false. + */ +typedef FLAC__bool (*FLAC__StreamDecoderEofCallback)(const FLAC__StreamDecoder *decoder, void *client_data); + +/** Signature for the write callback. + * + * A function pointer matching this signature must be passed to one of + * the FLAC__stream_decoder_init_*() functions. + * The supplied function will be called when the decoder has decoded a + * single audio frame. The decoder will pass the frame metadata as well + * as an array of pointers (one for each channel) pointing to the + * decoded audio. + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param frame The description of the decoded frame. See + * FLAC__Frame. + * \param buffer An array of pointers to decoded channels of data. + * Each pointer will point to an array of signed + * samples of length \a frame->header.blocksize. + * Channels will be ordered according to the FLAC + * specification; see the documentation for the + * frame header. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + * \retval FLAC__StreamDecoderWriteStatus + * The callee's return status. + */ +typedef FLAC__StreamDecoderWriteStatus (*FLAC__StreamDecoderWriteCallback)(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data); + +/** Signature for the metadata callback. + * + * A function pointer matching this signature must be passed to one of + * the FLAC__stream_decoder_init_*() functions. + * The supplied function will be called when the decoder has decoded a + * metadata block. In a valid FLAC file there will always be one + * \c STREAMINFO block, followed by zero or more other metadata blocks. + * These will be supplied by the decoder in the same order as they + * appear in the stream and always before the first audio frame (i.e. + * write callback). The metadata block that is passed in must not be + * modified, and it doesn't live beyond the callback, so you should make + * a copy of it with FLAC__metadata_object_clone() if you will need it + * elsewhere. Since metadata blocks can potentially be large, by + * default the decoder only calls the metadata callback for the + * \c STREAMINFO block; you can instruct the decoder to pass or filter + * other blocks with FLAC__stream_decoder_set_metadata_*() calls. + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param metadata The decoded metadata block. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + */ +typedef void (*FLAC__StreamDecoderMetadataCallback)(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data); + +/** Signature for the error callback. + * + * A function pointer matching this signature must be passed to one of + * the FLAC__stream_decoder_init_*() functions. + * The supplied function will be called whenever an error occurs during + * decoding. + * + * \note In general, FLAC__StreamDecoder functions which change the + * state should not be called on the \a decoder while in the callback. + * + * \param decoder The decoder instance calling the callback. + * \param status The error encountered by the decoder. + * \param client_data The callee's client data set through + * FLAC__stream_decoder_init_*(). + */ +typedef void (*FLAC__StreamDecoderErrorCallback)(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data); + + +/*********************************************************************** + * + * Class constructor/destructor + * + ***********************************************************************/ + +/** Create a new stream decoder instance. The instance is created with + * default settings; see the individual FLAC__stream_decoder_set_*() + * functions for each setting's default. + * + * \retval FLAC__StreamDecoder* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamDecoder *FLAC__stream_decoder_new(void); + +/** Free a decoder instance. Deletes the object pointed to by \a decoder. + * + * \param decoder A pointer to an existing decoder. + * \assert + * \code decoder != NULL \endcode + */ +FLAC_API void FLAC__stream_decoder_delete(FLAC__StreamDecoder *decoder); + + +/*********************************************************************** + * + * Public class method prototypes + * + ***********************************************************************/ + +/** Set the serial number for the FLAC stream within the Ogg container. + * The default behavior is to use the serial number of the first Ogg + * page. Setting a serial number here will explicitly specify which + * stream is to be decoded. + * + * \note + * This does not need to be set for native FLAC decoding. + * + * \default \c use serial number of first page + * \param decoder A decoder instance to set. + * \param serial_number See above. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_ogg_serial_number(FLAC__StreamDecoder *decoder, long serial_number); + +/** Set the "MD5 signature checking" flag. If \c true, the decoder will + * compute the MD5 signature of the unencoded audio data while decoding + * and compare it to the signature from the STREAMINFO block, if it + * exists, during FLAC__stream_decoder_finish(). + * + * MD5 signature checking will be turned off (until the next + * FLAC__stream_decoder_reset()) if there is no signature in the + * STREAMINFO block or when a seek is attempted. + * + * Clients that do not use the MD5 check should leave this off to speed + * up decoding. + * + * \default \c false + * \param decoder A decoder instance to set. + * \param value Flag value (see above). + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_md5_checking(FLAC__StreamDecoder *decoder, FLAC__bool value); + +/** Direct the decoder to pass on all metadata blocks of type \a type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param type See above. + * \assert + * \code decoder != NULL \endcode + * \a type is valid + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond(FLAC__StreamDecoder *decoder, FLAC__MetadataType type); + +/** Direct the decoder to pass on all APPLICATION metadata blocks of the + * given \a id. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param id See above. + * \assert + * \code decoder != NULL \endcode + * \code id != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond_application(FLAC__StreamDecoder *decoder, const FLAC__byte id[4]); + +/** Direct the decoder to pass on all metadata blocks of any type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond_all(FLAC__StreamDecoder *decoder); + +/** Direct the decoder to filter out all metadata blocks of type \a type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param type See above. + * \assert + * \code decoder != NULL \endcode + * \a type is valid + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore(FLAC__StreamDecoder *decoder, FLAC__MetadataType type); + +/** Direct the decoder to filter out all APPLICATION metadata blocks of + * the given \a id. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \param id See above. + * \assert + * \code decoder != NULL \endcode + * \code id != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore_application(FLAC__StreamDecoder *decoder, const FLAC__byte id[4]); + +/** Direct the decoder to filter out all metadata blocks of any type. + * + * \default By default, only the \c STREAMINFO block is returned via the + * metadata callback. + * \param decoder A decoder instance to set. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if the decoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore_all(FLAC__StreamDecoder *decoder); + +/** Get the current decoder state. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderState + * The current decoder state. + */ +FLAC_API FLAC__StreamDecoderState FLAC__stream_decoder_get_state(const FLAC__StreamDecoder *decoder); + +/** Get the current decoder state as a C string. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval const char * + * The decoder state as a C string. Do not modify the contents. + */ +FLAC_API const char *FLAC__stream_decoder_get_resolved_state_string(const FLAC__StreamDecoder *decoder); + +/** Get the "MD5 signature checking" flag. + * This is the value of the setting, not whether or not the decoder is + * currently checking the MD5 (remember, it can be turned off automatically + * by a seek). When the decoder is reset the flag will be restored to the + * value returned by this function. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * See above. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_get_md5_checking(const FLAC__StreamDecoder *decoder); + +/** Get the total number of samples in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the \c STREAMINFO block. A value of \c 0 means "unknown". + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API FLAC__uint64 FLAC__stream_decoder_get_total_samples(const FLAC__StreamDecoder *decoder); + +/** Get the current number of channels in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API unsigned FLAC__stream_decoder_get_channels(const FLAC__StreamDecoder *decoder); + +/** Get the current channel assignment in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__ChannelAssignment + * See above. + */ +FLAC_API FLAC__ChannelAssignment FLAC__stream_decoder_get_channel_assignment(const FLAC__StreamDecoder *decoder); + +/** Get the current sample resolution in the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API unsigned FLAC__stream_decoder_get_bits_per_sample(const FLAC__StreamDecoder *decoder); + +/** Get the current sample rate in Hz of the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API unsigned FLAC__stream_decoder_get_sample_rate(const FLAC__StreamDecoder *decoder); + +/** Get the current blocksize of the stream being decoded. + * Will only be valid after decoding has started and will contain the + * value from the most recently decoded frame header. + * + * \param decoder A decoder instance to query. + * \assert + * \code decoder != NULL \endcode + * \retval unsigned + * See above. + */ +FLAC_API unsigned FLAC__stream_decoder_get_blocksize(const FLAC__StreamDecoder *decoder); + +/** Returns the decoder's current read position within the stream. + * The position is the byte offset from the start of the stream. + * Bytes before this position have been fully decoded. Note that + * there may still be undecoded bytes in the decoder's read FIFO. + * The returned position is correct even after a seek. + * + * \warning This function currently only works for native FLAC, + * not Ogg FLAC streams. + * + * \param decoder A decoder instance to query. + * \param position Address at which to return the desired position. + * \assert + * \code decoder != NULL \endcode + * \code position != NULL \endcode + * \retval FLAC__bool + * \c true if successful, \c false if the stream is not native FLAC, + * or there was an error from the 'tell' callback or it returned + * \c FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_get_decode_position(const FLAC__StreamDecoder *decoder, FLAC__uint64 *position); + +/** Initialize the decoder instance to decode native FLAC streams. + * + * This flavor of initialization sets up the decoder to decode from a + * native FLAC stream. I/O is performed via callbacks to the client. + * For decoding from a plain file via filename or open FILE*, + * FLAC__stream_decoder_init_file() and FLAC__stream_decoder_init_FILE() + * provide a simpler interface. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \param decoder An uninitialized decoder instance. + * \param read_callback See FLAC__StreamDecoderReadCallback. This + * pointer must not be \c NULL. + * \param seek_callback See FLAC__StreamDecoderSeekCallback. This + * pointer may be \c NULL if seeking is not + * supported. If \a seek_callback is not \c NULL then a + * \a tell_callback, \a length_callback, and \a eof_callback must also be supplied. + * Alternatively, a dummy seek callback that just + * returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param tell_callback See FLAC__StreamDecoderTellCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a tell_callback must also be supplied. + * Alternatively, a dummy tell callback that just + * returns \c FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param length_callback See FLAC__StreamDecoderLengthCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a length_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param eof_callback See FLAC__StreamDecoderEofCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a eof_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c false + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_stream( + FLAC__StreamDecoder *decoder, + FLAC__StreamDecoderReadCallback read_callback, + FLAC__StreamDecoderSeekCallback seek_callback, + FLAC__StreamDecoderTellCallback tell_callback, + FLAC__StreamDecoderLengthCallback length_callback, + FLAC__StreamDecoderEofCallback eof_callback, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode Ogg FLAC streams. + * + * This flavor of initialization sets up the decoder to decode from a + * FLAC stream in an Ogg container. I/O is performed via callbacks to the + * client. For decoding from a plain file via filename or open FILE*, + * FLAC__stream_decoder_init_ogg_file() and FLAC__stream_decoder_init_ogg_FILE() + * provide a simpler interface. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \note Support for Ogg FLAC in the library is optional. If this + * library has been built without support for Ogg FLAC, this function + * will return \c FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER. + * + * \param decoder An uninitialized decoder instance. + * \param read_callback See FLAC__StreamDecoderReadCallback. This + * pointer must not be \c NULL. + * \param seek_callback See FLAC__StreamDecoderSeekCallback. This + * pointer may be \c NULL if seeking is not + * supported. If \a seek_callback is not \c NULL then a + * \a tell_callback, \a length_callback, and \a eof_callback must also be supplied. + * Alternatively, a dummy seek callback that just + * returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param tell_callback See FLAC__StreamDecoderTellCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a tell_callback must also be supplied. + * Alternatively, a dummy tell callback that just + * returns \c FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param length_callback See FLAC__StreamDecoderLengthCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a length_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param eof_callback See FLAC__StreamDecoderEofCallback. This + * pointer may be \c NULL if not supported by the client. If + * \a seek_callback is not \c NULL then a + * \a eof_callback must also be supplied. + * Alternatively, a dummy length callback that just + * returns \c false + * may also be supplied, all though this is slightly + * less efficient for the decoder. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_stream( + FLAC__StreamDecoder *decoder, + FLAC__StreamDecoderReadCallback read_callback, + FLAC__StreamDecoderSeekCallback seek_callback, + FLAC__StreamDecoderTellCallback tell_callback, + FLAC__StreamDecoderLengthCallback length_callback, + FLAC__StreamDecoderEofCallback eof_callback, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode native FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a + * plain native FLAC file. For non-stdio streams, you must use + * FLAC__stream_decoder_init_stream() and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \param decoder An uninitialized decoder instance. + * \param file An open FLAC file. The file should have been + * opened with mode \c "rb" and rewound. The file + * becomes owned by the decoder and should not be + * manipulated by the client while decoding. + * Unless \a file is \c stdin, it will be closed + * when FLAC__stream_decoder_finish() is called. + * Note however that seeking will not work when + * decoding from \c stdout since it is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \code file != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_FILE( + FLAC__StreamDecoder *decoder, + FILE *file, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode Ogg FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a + * plain Ogg FLAC file. For non-stdio streams, you must use + * FLAC__stream_decoder_init_ogg_stream() and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \note Support for Ogg FLAC in the library is optional. If this + * library has been built without support for Ogg FLAC, this function + * will return \c FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER. + * + * \param decoder An uninitialized decoder instance. + * \param file An open FLAC file. The file should have been + * opened with mode \c "rb" and rewound. The file + * becomes owned by the decoder and should not be + * manipulated by the client while decoding. + * Unless \a file is \c stdin, it will be closed + * when FLAC__stream_decoder_finish() is called. + * Note however that seeking will not work when + * decoding from \c stdout since it is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \code file != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_FILE( + FLAC__StreamDecoder *decoder, + FILE *file, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode native FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a plain + * native FLAC file. If POSIX fopen() semantics are not sufficient, (for + * example, with Unicode filenames on Windows), you must use + * FLAC__stream_decoder_init_FILE(), or FLAC__stream_decoder_init_stream() + * and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \param decoder An uninitialized decoder instance. + * \param filename The name of the file to decode from. The file will + * be opened with fopen(). Use \c NULL to decode from + * \c stdin. Note that \c stdin is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_file( + FLAC__StreamDecoder *decoder, + const char *filename, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Initialize the decoder instance to decode Ogg FLAC files. + * + * This flavor of initialization sets up the decoder to decode from a plain + * Ogg FLAC file. If POSIX fopen() semantics are not sufficient, (for + * example, with Unicode filenames on Windows), you must use + * FLAC__stream_decoder_init_ogg_FILE(), or FLAC__stream_decoder_init_ogg_stream() + * and provide callbacks for the I/O. + * + * This function should be called after FLAC__stream_decoder_new() and + * FLAC__stream_decoder_set_*() but before any of the + * FLAC__stream_decoder_process_*() functions. Will set and return the + * decoder state, which will be FLAC__STREAM_DECODER_SEARCH_FOR_METADATA + * if initialization succeeded. + * + * \note Support for Ogg FLAC in the library is optional. If this + * library has been built without support for Ogg FLAC, this function + * will return \c FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER. + * + * \param decoder An uninitialized decoder instance. + * \param filename The name of the file to decode from. The file will + * be opened with fopen(). Use \c NULL to decode from + * \c stdin. Note that \c stdin is not seekable. + * \param write_callback See FLAC__StreamDecoderWriteCallback. This + * pointer must not be \c NULL. + * \param metadata_callback See FLAC__StreamDecoderMetadataCallback. This + * pointer may be \c NULL if the callback is not + * desired. + * \param error_callback See FLAC__StreamDecoderErrorCallback. This + * pointer must not be \c NULL. + * \param client_data This value will be supplied to callbacks in their + * \a client_data argument. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__StreamDecoderInitStatus + * \c FLAC__STREAM_DECODER_INIT_STATUS_OK if initialization was successful; + * see FLAC__StreamDecoderInitStatus for the meanings of other return values. + */ +FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_file( + FLAC__StreamDecoder *decoder, + const char *filename, + FLAC__StreamDecoderWriteCallback write_callback, + FLAC__StreamDecoderMetadataCallback metadata_callback, + FLAC__StreamDecoderErrorCallback error_callback, + void *client_data +); + +/** Finish the decoding process. + * Flushes the decoding buffer, releases resources, resets the decoder + * settings to their defaults, and returns the decoder state to + * FLAC__STREAM_DECODER_UNINITIALIZED. + * + * In the event of a prematurely-terminated decode, it is not strictly + * necessary to call this immediately before FLAC__stream_decoder_delete() + * but it is good practice to match every FLAC__stream_decoder_init_*() + * with a FLAC__stream_decoder_finish(). + * + * \param decoder An uninitialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if MD5 checking is on AND a STREAMINFO block was available + * AND the MD5 signature in the STREAMINFO block was non-zero AND the + * signature does not match the one computed by the decoder; else + * \c true. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_finish(FLAC__StreamDecoder *decoder); + +/** Flush the stream input. + * The decoder's input buffer will be cleared and the state set to + * \c FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC. This will also turn + * off MD5 checking. + * + * \param decoder A decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false if a memory allocation + * error occurs (in which case the state will be set to + * \c FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder); + +/** Reset the decoding process. + * The decoder's input buffer will be cleared and the state set to + * \c FLAC__STREAM_DECODER_SEARCH_FOR_METADATA. This is similar to + * FLAC__stream_decoder_finish() except that the settings are + * preserved; there is no need to call FLAC__stream_decoder_init_*() + * before decoding again. MD5 checking will be restored to its original + * setting. + * + * If the decoder is seekable, or was initialized with + * FLAC__stream_decoder_init*_FILE() or FLAC__stream_decoder_init*_file(), + * the decoder will also attempt to seek to the beginning of the file. + * If this rewind fails, this function will return \c false. It follows + * that FLAC__stream_decoder_reset() cannot be used when decoding from + * \c stdin. + * + * If the decoder was initialized with FLAC__stream_encoder_init*_stream() + * and is not seekable (i.e. no seek callback was provided or the seek + * callback returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED), it + * is the duty of the client to start feeding data from the beginning of + * the stream on the next FLAC__stream_decoder_process() or + * FLAC__stream_decoder_process_interleaved() call. + * + * \param decoder A decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false if a memory allocation occurs + * (in which case the state will be set to + * \c FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR) or a seek error + * occurs (the state will be unchanged). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder); + +/** Decode one metadata block or audio frame. + * This version instructs the decoder to decode a either a single metadata + * block or a single frame and stop, unless the callbacks return a fatal + * error or the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM. + * + * As the decoder needs more input it will call the read callback. + * Depending on what was decoded, the metadata or write callback will be + * called with the decoded metadata block or audio frame. + * + * Unless there is a fatal read error or end of stream, this function + * will return once one whole frame is decoded. In other words, if the + * stream is not synchronized or points to a corrupt frame header, the + * decoder will continue to try and resync until it gets to a valid + * frame, then decode one frame, then return. If the decoder points to + * a frame whose frame CRC in the frame footer does not match the + * computed frame CRC, this function will issue a + * FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH error to the + * error callback, and return, having decoded one complete, although + * corrupt, frame. (Such corrupted frames are sent as silence of the + * correct length to the write callback.) + * + * \param decoder An initialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_process_single(FLAC__StreamDecoder *decoder); + +/** Decode until the end of the metadata. + * This version instructs the decoder to decode from the current position + * and continue until all the metadata has been read, or until the + * callbacks return a fatal error or the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM. + * + * As the decoder needs more input it will call the read callback. + * As each metadata block is decoded, the metadata callback will be called + * with the decoded metadata. + * + * \param decoder An initialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_process_until_end_of_metadata(FLAC__StreamDecoder *decoder); + +/** Decode until the end of the stream. + * This version instructs the decoder to decode from the current position + * and continue until the end of stream (the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM), or until the + * callbacks return a fatal error. + * + * As the decoder needs more input it will call the read callback. + * As each metadata block and frame is decoded, the metadata or write + * callback will be called with the decoded metadata or frame. + * + * \param decoder An initialized decoder instance. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_process_until_end_of_stream(FLAC__StreamDecoder *decoder); + +/** Skip one audio frame. + * This version instructs the decoder to 'skip' a single frame and stop, + * unless the callbacks return a fatal error or the read callback returns + * \c FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM. + * + * The decoding flow is the same as what occurs when + * FLAC__stream_decoder_process_single() is called to process an audio + * frame, except that this function does not decode the parsed data into + * PCM or call the write callback. The integrity of the frame is still + * checked the same way as in the other process functions. + * + * This function will return once one whole frame is skipped, in the + * same way that FLAC__stream_decoder_process_single() will return once + * one whole frame is decoded. + * + * This function can be used in more quickly determining FLAC frame + * boundaries when decoding of the actual data is not needed, for + * example when an application is separating a FLAC stream into frames + * for editing or storing in a container. To do this, the application + * can use FLAC__stream_decoder_skip_single_frame() to quickly advance + * to the next frame, then use + * FLAC__stream_decoder_get_decode_position() to find the new frame + * boundary. + * + * This function should only be called when the stream has advanced + * past all the metadata, otherwise it will return \c false. + * + * \param decoder An initialized decoder instance not in a metadata + * state. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c false if any fatal read, write, or memory allocation error + * occurred (meaning decoding must stop), or if the decoder + * is in the FLAC__STREAM_DECODER_SEARCH_FOR_METADATA or + * FLAC__STREAM_DECODER_READ_METADATA state, else \c true; for more + * information about the decoder, check the decoder state with + * FLAC__stream_decoder_get_state(). + */ +FLAC_API FLAC__bool FLAC__stream_decoder_skip_single_frame(FLAC__StreamDecoder *decoder); + +/** Flush the input and seek to an absolute sample. + * Decoding will resume at the given sample. Note that because of + * this, the next write callback may contain a partial block. The + * client must support seeking the input or this function will fail + * and return \c false. Furthermore, if the decoder state is + * \c FLAC__STREAM_DECODER_SEEK_ERROR, then the decoder must be flushed + * with FLAC__stream_decoder_flush() or reset with + * FLAC__stream_decoder_reset() before decoding can continue. + * + * \param decoder A decoder instance. + * \param sample The target sample number to seek to. + * \assert + * \code decoder != NULL \endcode + * \retval FLAC__bool + * \c true if successful, else \c false. + */ +FLAC_API FLAC__bool FLAC__stream_decoder_seek_absolute(FLAC__StreamDecoder *decoder, FLAC__uint64 sample); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/Windows/codecs/include/FLAC/stream_encoder.h b/quakespasm/Windows/codecs/include/FLAC/stream_encoder.h new file mode 100644 index 00000000..6f7796bb --- /dev/null +++ b/quakespasm/Windows/codecs/include/FLAC/stream_encoder.h @@ -0,0 +1,1769 @@ +/* libFLAC - Free Lossless Audio Codec library + * Copyright (C) 2000-2009 Josh Coalson + * Copyright (C) 2011-2013 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. + */ + +#ifndef FLAC__STREAM_ENCODER_H +#define FLAC__STREAM_ENCODER_H + +#include /* for FILE */ +#include "export.h" +#include "format.h" +#include "stream_decoder.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** \file include/FLAC/stream_encoder.h + * + * \brief + * This module contains the functions which implement the stream + * encoder. + * + * See the detailed documentation in the + * \link flac_stream_encoder stream encoder \endlink module. + */ + +/** \defgroup flac_encoder FLAC/ \*_encoder.h: encoder interfaces + * \ingroup flac + * + * \brief + * This module describes the encoder layers provided by libFLAC. + * + * The stream encoder can be used to encode complete streams either to the + * client via callbacks, or directly to a file, depending on how it is + * initialized. When encoding via callbacks, the client provides a write + * callback which will be called whenever FLAC data is ready to be written. + * If the client also supplies a seek callback, the encoder will also + * automatically handle the writing back of metadata discovered while + * encoding, like stream info, seek points offsets, etc. When encoding to + * a file, the client needs only supply a filename or open \c FILE* and an + * optional progress callback for periodic notification of progress; the + * write and seek callbacks are supplied internally. For more info see the + * \link flac_stream_encoder stream encoder \endlink module. + */ + +/** \defgroup flac_stream_encoder FLAC/stream_encoder.h: stream encoder interface + * \ingroup flac_encoder + * + * \brief + * This module contains the functions which implement the stream + * encoder. + * + * The stream encoder can encode to native FLAC, and optionally Ogg FLAC + * (check FLAC_API_SUPPORTS_OGG_FLAC) streams and files. + * + * The basic usage of this encoder is as follows: + * - The program creates an instance of an encoder using + * FLAC__stream_encoder_new(). + * - The program overrides the default settings using + * FLAC__stream_encoder_set_*() functions. At a minimum, the following + * functions should be called: + * - FLAC__stream_encoder_set_channels() + * - FLAC__stream_encoder_set_bits_per_sample() + * - FLAC__stream_encoder_set_sample_rate() + * - FLAC__stream_encoder_set_ogg_serial_number() (if encoding to Ogg FLAC) + * - FLAC__stream_encoder_set_total_samples_estimate() (if known) + * - If the application wants to control the compression level or set its own + * metadata, then the following should also be called: + * - FLAC__stream_encoder_set_compression_level() + * - FLAC__stream_encoder_set_verify() + * - FLAC__stream_encoder_set_metadata() + * - The rest of the set functions should only be called if the client needs + * exact control over how the audio is compressed; thorough understanding + * of the FLAC format is necessary to achieve good results. + * - The program initializes the instance to validate the settings and + * prepare for encoding using + * - FLAC__stream_encoder_init_stream() or FLAC__stream_encoder_init_FILE() + * or FLAC__stream_encoder_init_file() for native FLAC + * - FLAC__stream_encoder_init_ogg_stream() or FLAC__stream_encoder_init_ogg_FILE() + * or FLAC__stream_encoder_init_ogg_file() for Ogg FLAC + * - The program calls FLAC__stream_encoder_process() or + * FLAC__stream_encoder_process_interleaved() to encode data, which + * subsequently calls the callbacks when there is encoder data ready + * to be written. + * - The program finishes the encoding with FLAC__stream_encoder_finish(), + * which causes the encoder to encode any data still in its input pipe, + * update the metadata with the final encoding statistics if output + * seeking is possible, and finally reset the encoder to the + * uninitialized state. + * - The instance may be used again or deleted with + * FLAC__stream_encoder_delete(). + * + * In more detail, the stream encoder functions similarly to the + * \link flac_stream_decoder stream decoder \endlink, but has fewer + * callbacks and more options. Typically the client will create a new + * instance by calling FLAC__stream_encoder_new(), then set the necessary + * parameters with FLAC__stream_encoder_set_*(), and initialize it by + * calling one of the FLAC__stream_encoder_init_*() functions. + * + * Unlike the decoders, the stream encoder has many options that can + * affect the speed and compression ratio. When setting these parameters + * you should have some basic knowledge of the format (see the + * user-level documentation + * or the formal description). The + * FLAC__stream_encoder_set_*() functions themselves do not validate the + * values as many are interdependent. The FLAC__stream_encoder_init_*() + * functions will do this, so make sure to pay attention to the state + * returned by FLAC__stream_encoder_init_*() to make sure that it is + * FLAC__STREAM_ENCODER_INIT_STATUS_OK. Any parameters that are not set + * before FLAC__stream_encoder_init_*() will take on the defaults from + * the constructor. + * + * There are three initialization functions for native FLAC, one for + * setting up the encoder to encode FLAC data to the client via + * callbacks, and two for encoding directly to a file. + * + * For encoding via callbacks, use FLAC__stream_encoder_init_stream(). + * You must also supply a write callback which will be called anytime + * there is raw encoded data to write. If the client can seek the output + * it is best to also supply seek and tell callbacks, as this allows the + * encoder to go back after encoding is finished to write back + * information that was collected while encoding, like seek point offsets, + * frame sizes, etc. + * + * For encoding directly to a file, use FLAC__stream_encoder_init_FILE() + * or FLAC__stream_encoder_init_file(). Then you must only supply a + * filename or open \c FILE*; the encoder will handle all the callbacks + * internally. You may also supply a progress callback for periodic + * notification of the encoding progress. + * + * There are three similarly-named init functions for encoding to Ogg + * FLAC streams. Check \c FLAC_API_SUPPORTS_OGG_FLAC to find out if the + * library has been built with Ogg support. + * + * The call to FLAC__stream_encoder_init_*() currently will also immediately + * call the write callback several times, once with the \c fLaC signature, + * and once for each encoded metadata block. Note that for Ogg FLAC + * encoding you will usually get at least twice the number of callbacks than + * with native FLAC, one for the Ogg page header and one for the page body. + * + * After initializing the instance, the client may feed audio data to the + * encoder in one of two ways: + * + * - Channel separate, through FLAC__stream_encoder_process() - The client + * will pass an array of pointers to buffers, one for each channel, to + * the encoder, each of the same length. The samples need not be + * block-aligned, but each channel should have the same number of samples. + * - Channel interleaved, through + * FLAC__stream_encoder_process_interleaved() - The client will pass a single + * pointer to data that is channel-interleaved (i.e. channel0_sample0, + * channel1_sample0, ... , channelN_sample0, channel0_sample1, ...). + * Again, the samples need not be block-aligned but they must be + * sample-aligned, i.e. the first value should be channel0_sample0 and + * the last value channelN_sampleM. + * + * Note that for either process call, each sample in the buffers should be a + * signed integer, right-justified to the resolution set by + * FLAC__stream_encoder_set_bits_per_sample(). For example, if the resolution + * is 16 bits per sample, the samples should all be in the range [-32768,32767]. + * + * When the client is finished encoding data, it calls + * FLAC__stream_encoder_finish(), which causes the encoder to encode any + * data still in its input pipe, and call the metadata callback with the + * final encoding statistics. Then the instance may be deleted with + * FLAC__stream_encoder_delete() or initialized again to encode another + * stream. + * + * For programs that write their own metadata, but that do not know the + * actual metadata until after encoding, it is advantageous to instruct + * the encoder to write a PADDING block of the correct size, so that + * instead of rewriting the whole stream after encoding, the program can + * just overwrite the PADDING block. If only the maximum size of the + * metadata is known, the program can write a slightly larger padding + * block, then split it after encoding. + * + * Make sure you understand how lengths are calculated. All FLAC metadata + * blocks have a 4 byte header which contains the type and length. This + * length does not include the 4 bytes of the header. See the format page + * for the specification of metadata blocks and their lengths. + * + * \note + * If you are writing the FLAC data to a file via callbacks, make sure it + * is open for update (e.g. mode "w+" for stdio streams). This is because + * after the first encoding pass, the encoder will try to seek back to the + * beginning of the stream, to the STREAMINFO block, to write some data + * there. (If using FLAC__stream_encoder_init*_file() or + * FLAC__stream_encoder_init*_FILE(), the file is managed internally.) + * + * \note + * The "set" functions may only be called when the encoder is in the + * state FLAC__STREAM_ENCODER_UNINITIALIZED, i.e. after + * FLAC__stream_encoder_new() or FLAC__stream_encoder_finish(), but + * before FLAC__stream_encoder_init_*(). If this is the case they will + * return \c true, otherwise \c false. + * + * \note + * FLAC__stream_encoder_finish() resets all settings to the constructor + * defaults. + * + * \{ + */ + + +/** State values for a FLAC__StreamEncoder. + * + * The encoder's state can be obtained by calling FLAC__stream_encoder_get_state(). + * + * If the encoder gets into any other state besides \c FLAC__STREAM_ENCODER_OK + * or \c FLAC__STREAM_ENCODER_UNINITIALIZED, it becomes invalid for encoding and + * must be deleted with FLAC__stream_encoder_delete(). + */ +typedef enum { + + FLAC__STREAM_ENCODER_OK = 0, + /**< The encoder is in the normal OK state and samples can be processed. */ + + FLAC__STREAM_ENCODER_UNINITIALIZED, + /**< The encoder is in the uninitialized state; one of the + * FLAC__stream_encoder_init_*() functions must be called before samples + * can be processed. + */ + + FLAC__STREAM_ENCODER_OGG_ERROR, + /**< An error occurred in the underlying Ogg layer. */ + + FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR, + /**< An error occurred in the underlying verify stream decoder; + * check FLAC__stream_encoder_get_verify_decoder_state(). + */ + + FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA, + /**< The verify decoder detected a mismatch between the original + * audio signal and the decoded audio signal. + */ + + FLAC__STREAM_ENCODER_CLIENT_ERROR, + /**< One of the callbacks returned a fatal error. */ + + FLAC__STREAM_ENCODER_IO_ERROR, + /**< An I/O error occurred while opening/reading/writing a file. + * Check \c errno. + */ + + FLAC__STREAM_ENCODER_FRAMING_ERROR, + /**< An error occurred while writing the stream; usually, the + * write_callback returned an error. + */ + + FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR + /**< Memory allocation failed. */ + +} FLAC__StreamEncoderState; + +/** Maps a FLAC__StreamEncoderState to a C string. + * + * Using a FLAC__StreamEncoderState as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderStateString[]; + + +/** Possible return values for the FLAC__stream_encoder_init_*() functions. + */ +typedef enum { + + FLAC__STREAM_ENCODER_INIT_STATUS_OK = 0, + /**< Initialization was successful. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR, + /**< General failure to set up encoder; call FLAC__stream_encoder_get_state() for cause. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER, + /**< The library was not compiled with support for the given container + * format. + */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS, + /**< A required callback was not supplied. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS, + /**< The encoder has an invalid setting for number of channels. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE, + /**< The encoder has an invalid setting for bits-per-sample. + * FLAC supports 4-32 bps but the reference encoder currently supports + * only up to 24 bps. + */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE, + /**< The encoder has an invalid setting for the input sample rate. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE, + /**< The encoder has an invalid setting for the block size. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER, + /**< The encoder has an invalid setting for the maximum LPC order. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION, + /**< The encoder has an invalid setting for the precision of the quantized linear predictor coefficients. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER, + /**< The specified block size is less than the maximum LPC order. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE, + /**< The encoder is bound to the Subset but other settings violate it. */ + + FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA, + /**< The metadata input to the encoder is invalid, in one of the following ways: + * - FLAC__stream_encoder_set_metadata() was called with a null pointer but a block count > 0 + * - One of the metadata blocks contains an undefined type + * - It contains an illegal CUESHEET as checked by FLAC__format_cuesheet_is_legal() + * - It contains an illegal SEEKTABLE as checked by FLAC__format_seektable_is_legal() + * - It contains more than one SEEKTABLE block or more than one VORBIS_COMMENT block + */ + + FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED + /**< FLAC__stream_encoder_init_*() was called when the encoder was + * already initialized, usually because + * FLAC__stream_encoder_finish() was not called. + */ + +} FLAC__StreamEncoderInitStatus; + +/** Maps a FLAC__StreamEncoderInitStatus to a C string. + * + * Using a FLAC__StreamEncoderInitStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderInitStatusString[]; + + +/** Return values for the FLAC__StreamEncoder read callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE, + /**< The read was OK and decoding can continue. */ + + FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM, + /**< The read was attempted at the end of the stream. */ + + FLAC__STREAM_ENCODER_READ_STATUS_ABORT, + /**< An unrecoverable error occurred. */ + + FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED + /**< Client does not support reading back from the output. */ + +} FLAC__StreamEncoderReadStatus; + +/** Maps a FLAC__StreamEncoderReadStatus to a C string. + * + * Using a FLAC__StreamEncoderReadStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderReadStatusString[]; + + +/** Return values for the FLAC__StreamEncoder write callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_WRITE_STATUS_OK = 0, + /**< The write was OK and encoding can continue. */ + + FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR + /**< An unrecoverable error occurred. The encoder will return from the process call. */ + +} FLAC__StreamEncoderWriteStatus; + +/** Maps a FLAC__StreamEncoderWriteStatus to a C string. + * + * Using a FLAC__StreamEncoderWriteStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderWriteStatusString[]; + + +/** Return values for the FLAC__StreamEncoder seek callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_SEEK_STATUS_OK, + /**< The seek was OK and encoding can continue. */ + + FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR, + /**< An unrecoverable error occurred. */ + + FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED + /**< Client does not support seeking. */ + +} FLAC__StreamEncoderSeekStatus; + +/** Maps a FLAC__StreamEncoderSeekStatus to a C string. + * + * Using a FLAC__StreamEncoderSeekStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderSeekStatusString[]; + + +/** Return values for the FLAC__StreamEncoder tell callback. + */ +typedef enum { + + FLAC__STREAM_ENCODER_TELL_STATUS_OK, + /**< The tell was OK and encoding can continue. */ + + FLAC__STREAM_ENCODER_TELL_STATUS_ERROR, + /**< An unrecoverable error occurred. */ + + FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED + /**< Client does not support seeking. */ + +} FLAC__StreamEncoderTellStatus; + +/** Maps a FLAC__StreamEncoderTellStatus to a C string. + * + * Using a FLAC__StreamEncoderTellStatus as the index to this array + * will give the string equivalent. The contents should not be modified. + */ +extern FLAC_API const char * const FLAC__StreamEncoderTellStatusString[]; + + +/*********************************************************************** + * + * class FLAC__StreamEncoder + * + ***********************************************************************/ + +struct FLAC__StreamEncoderProtected; +struct FLAC__StreamEncoderPrivate; +/** The opaque structure definition for the stream encoder type. + * See the \link flac_stream_encoder stream encoder module \endlink + * for a detailed description. + */ +typedef struct { + struct FLAC__StreamEncoderProtected *protected_; /* avoid the C++ keyword 'protected' */ + struct FLAC__StreamEncoderPrivate *private_; /* avoid the C++ keyword 'private' */ +} FLAC__StreamEncoder; + +/** Signature for the read callback. + * + * A function pointer matching this signature must be passed to + * FLAC__stream_encoder_init_ogg_stream() if seeking is supported. + * The supplied function will be called when the encoder needs to read back + * encoded data. This happens during the metadata callback, when the encoder + * has to read, modify, and rewrite the metadata (e.g. seekpoints) gathered + * while encoding. The address of the buffer to be filled is supplied, along + * with the number of bytes the buffer can hold. The callback may choose to + * supply less data and modify the byte count but must be careful not to + * overflow the buffer. The callback then returns a status code chosen from + * FLAC__StreamEncoderReadStatus. + * + * Here is an example of a read callback for stdio streams: + * \code + * FLAC__StreamEncoderReadStatus read_cb(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(*bytes > 0) { + * *bytes = fread(buffer, sizeof(FLAC__byte), *bytes, file); + * if(ferror(file)) + * return FLAC__STREAM_ENCODER_READ_STATUS_ABORT; + * else if(*bytes == 0) + * return FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM; + * else + * return FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE; + * } + * else + * return FLAC__STREAM_ENCODER_READ_STATUS_ABORT; + * } + * \endcode + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param buffer A pointer to a location for the callee to store + * data to be encoded. + * \param bytes A pointer to the size of the buffer. On entry + * to the callback, it contains the maximum number + * of bytes that may be stored in \a buffer. The + * callee must set it to the actual number of bytes + * stored (0 in case of error or end-of-stream) before + * returning. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_set_client_data(). + * \retval FLAC__StreamEncoderReadStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderReadStatus (*FLAC__StreamEncoderReadCallback)(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data); + +/** Signature for the write callback. + * + * A function pointer matching this signature must be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * by the encoder anytime there is raw encoded data ready to write. It may + * include metadata mixed with encoded audio frames and the data is not + * guaranteed to be aligned on frame or metadata block boundaries. + * + * The only duty of the callback is to write out the \a bytes worth of data + * in \a buffer to the current position in the output stream. The arguments + * \a samples and \a current_frame are purely informational. If \a samples + * is greater than \c 0, then \a current_frame will hold the current frame + * number that is being written; otherwise it indicates that the write + * callback is being called to write metadata. + * + * \note + * Unlike when writing to native FLAC, when writing to Ogg FLAC the + * write callback will be called twice when writing each audio + * frame; once for the page header, and once for the page body. + * When writing the page header, the \a samples argument to the + * write callback will be \c 0. + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param buffer An array of encoded data of length \a bytes. + * \param bytes The byte length of \a buffer. + * \param samples The number of samples encoded by \a buffer. + * \c 0 has a special meaning; see above. + * \param current_frame The number of the current frame being encoded. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + * \retval FLAC__StreamEncoderWriteStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderWriteStatus (*FLAC__StreamEncoderWriteCallback)(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data); + +/** Signature for the seek callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * when the encoder needs to seek the output stream. The encoder will pass + * the absolute byte offset to seek to, 0 meaning the beginning of the stream. + * + * Here is an example of a seek callback for stdio streams: + * \code + * FLAC__StreamEncoderSeekStatus seek_cb(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * if(file == stdin) + * return FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED; + * else if(fseeko(file, (off_t)absolute_byte_offset, SEEK_SET) < 0) + * return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR; + * else + * return FLAC__STREAM_ENCODER_SEEK_STATUS_OK; + * } + * \endcode + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param absolute_byte_offset The offset from the beginning of the stream + * to seek to. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + * \retval FLAC__StreamEncoderSeekStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderSeekStatus (*FLAC__StreamEncoderSeekCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data); + +/** Signature for the tell callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * when the encoder needs to know the current position of the output stream. + * + * \warning + * The callback must return the true current byte offset of the output to + * which the encoder is writing. If you are buffering the output, make + * sure and take this into account. If you are writing directly to a + * FILE* from your write callback, ftell() is sufficient. If you are + * writing directly to a file descriptor from your write callback, you + * can use lseek(fd, SEEK_CUR, 0). The encoder may later seek back to + * these points to rewrite metadata after encoding. + * + * Here is an example of a tell callback for stdio streams: + * \code + * FLAC__StreamEncoderTellStatus tell_cb(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) + * { + * FILE *file = ((MyClientData*)client_data)->file; + * off_t pos; + * if(file == stdin) + * return FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED; + * else if((pos = ftello(file)) < 0) + * return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR; + * else { + * *absolute_byte_offset = (FLAC__uint64)pos; + * return FLAC__STREAM_ENCODER_TELL_STATUS_OK; + * } + * } + * \endcode + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param absolute_byte_offset The address at which to store the current + * position of the output. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + * \retval FLAC__StreamEncoderTellStatus + * The callee's return status. + */ +typedef FLAC__StreamEncoderTellStatus (*FLAC__StreamEncoderTellCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data); + +/** Signature for the metadata callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_stream(). The supplied function will be called + * once at the end of encoding with the populated STREAMINFO structure. This + * is so the client can seek back to the beginning of the file and write the + * STREAMINFO block with the correct statistics after encoding (like + * minimum/maximum frame size and total samples). + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param metadata The final populated STREAMINFO block. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + */ +typedef void (*FLAC__StreamEncoderMetadataCallback)(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data); + +/** Signature for the progress callback. + * + * A function pointer matching this signature may be passed to + * FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE(). + * The supplied function will be called when the encoder has finished + * writing a frame. The \c total_frames_estimate argument to the + * callback will be based on the value from + * FLAC__stream_encoder_set_total_samples_estimate(). + * + * \note In general, FLAC__StreamEncoder functions which change the + * state should not be called on the \a encoder while in the callback. + * + * \param encoder The encoder instance calling the callback. + * \param bytes_written Bytes written so far. + * \param samples_written Samples written so far. + * \param frames_written Frames written so far. + * \param total_frames_estimate The estimate of the total number of + * frames to be written. + * \param client_data The callee's client data set through + * FLAC__stream_encoder_init_*(). + */ +typedef void (*FLAC__StreamEncoderProgressCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data); + + +/*********************************************************************** + * + * Class constructor/destructor + * + ***********************************************************************/ + +/** Create a new stream encoder instance. The instance is created with + * default settings; see the individual FLAC__stream_encoder_set_*() + * functions for each setting's default. + * + * \retval FLAC__StreamEncoder* + * \c NULL if there was an error allocating memory, else the new instance. + */ +FLAC_API FLAC__StreamEncoder *FLAC__stream_encoder_new(void); + +/** Free an encoder instance. Deletes the object pointed to by \a encoder. + * + * \param encoder A pointer to an existing encoder. + * \assert + * \code encoder != NULL \endcode + */ +FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder); + + +/*********************************************************************** + * + * Public class method prototypes + * + ***********************************************************************/ + +/** Set the serial number for the FLAC stream to use in the Ogg container. + * + * \note + * This does not need to be set for native FLAC encoding. + * + * \note + * It is recommended to set a serial number explicitly as the default of '0' + * may collide with other streams. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param serial_number See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder *encoder, long serial_number); + +/** Set the "verify" flag. If \c true, the encoder will verify it's own + * encoded output by feeding it through an internal decoder and comparing + * the original signal against the decoded signal. If a mismatch occurs, + * the process call will return \c false. Note that this will slow the + * encoding process by the extra time required for decoding and comparison. + * + * \default \c false + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Set the Subset flag. If \c true, + * the encoder will comply with the Subset and will check the + * settings during FLAC__stream_encoder_init_*() to see if all settings + * comply. If \c false, the settings may take advantage of the full + * range that the format allows. + * + * Make sure you know what it entails before setting this to \c false. + * + * \default \c true + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Set the number of channels to be encoded. + * + * \default \c 2 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the sample resolution of the input to be encoded. + * + * \warning + * Do not feed the encoder data that is wider than the value you + * set here or you will generate an invalid stream. + * + * \default \c 16 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the sample rate (in Hz) of the input to be encoded. + * + * \default \c 44100 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the compression level + * + * The compression level is roughly proportional to the amount of effort + * the encoder expends to compress the file. A higher level usually + * means more computation but higher compression. The default level is + * suitable for most applications. + * + * Currently the levels range from \c 0 (fastest, least compression) to + * \c 8 (slowest, most compression). A value larger than \c 8 will be + * treated as \c 8. + * + * This function automatically calls the following other \c _set_ + * functions with appropriate values, so the client does not need to + * unless it specifically wants to override them: + * - FLAC__stream_encoder_set_do_mid_side_stereo() + * - FLAC__stream_encoder_set_loose_mid_side_stereo() + * - FLAC__stream_encoder_set_apodization() + * - FLAC__stream_encoder_set_max_lpc_order() + * - FLAC__stream_encoder_set_qlp_coeff_precision() + * - FLAC__stream_encoder_set_do_qlp_coeff_prec_search() + * - FLAC__stream_encoder_set_do_escape_coding() + * - FLAC__stream_encoder_set_do_exhaustive_model_search() + * - FLAC__stream_encoder_set_min_residual_partition_order() + * - FLAC__stream_encoder_set_max_residual_partition_order() + * - FLAC__stream_encoder_set_rice_parameter_search_dist() + * + * The actual values set for each level are: + * + * + * + * + * + * + * + * + * + * + * + * + *
level + * do mid-side stereo + * loose mid-side stereo + * apodization + * max lpc order + * qlp coeff precision + * qlp coeff prec search + * escape coding + * exhaustive model search + * min residual partition order + * max residual partition order + * rice parameter search dist + *
0 false false tukey(0.5) 0 0 false false false 0 3 0
1 true true tukey(0.5) 0 0 false false false 0 3 0
2 true false tukey(0.5) 0 0 false false false 0 3 0
3 false false tukey(0.5) 6 0 false false false 0 4 0
4 true true tukey(0.5) 8 0 false false false 0 4 0
5 true false tukey(0.5) 8 0 false false false 0 5 0
6 true false tukey(0.5) 8 0 false false false 0 6 0
7 true false tukey(0.5) 8 0 false false true 0 6 0
8 true false tukey(0.5) 12 0 false false true 0 6 0
+ * + * \default \c 5 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the blocksize to use while encoding. + * + * The number of samples to use per frame. Use \c 0 to let the encoder + * estimate a blocksize; this is usually best. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set to \c true to enable mid-side encoding on stereo input. The + * number of channels must be 2 for this to have any effect. Set to + * \c false to use only independent channel coding. + * + * \default \c false + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Set to \c true to enable adaptive switching between mid-side and + * left-right encoding on stereo input. Set to \c false to use + * exhaustive searching. Setting this to \c true requires + * FLAC__stream_encoder_set_do_mid_side_stereo() to also be set to + * \c true in order to have any effect. + * + * \default \c false + * \param encoder An encoder instance to set. + * \param value Flag value (see above). + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value); + +/** Sets the apodization function(s) the encoder will use when windowing + * audio data for LPC analysis. + * + * The \a specification is a plain ASCII string which specifies exactly + * which functions to use. There may be more than one (up to 32), + * separated by \c ';' characters. Some functions take one or more + * comma-separated arguments in parentheses. + * + * The available functions are \c bartlett, \c bartlett_hann, + * \c blackman, \c blackman_harris_4term_92db, \c connes, \c flattop, + * \c gauss(STDDEV), \c hamming, \c hann, \c kaiser_bessel, \c nuttall, + * \c rectangle, \c triangle, \c tukey(P), \c welch. + * + * For \c gauss(STDDEV), STDDEV specifies the standard deviation + * (0blocksize / (2 ^ order). + * + * Set both min and max values to \c 0 to force a single context, + * whose Rice parameter is based on the residual signal variance. + * Otherwise, set a min and max order, and the encoder will search + * all orders, using the mean of each context for its Rice parameter, + * and use the best. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set the maximum partition order to search when coding the residual. + * This is used in tandem with + * FLAC__stream_encoder_set_min_residual_partition_order(). + * + * The partition order determines the context size in the residual. + * The context size will be approximately blocksize / (2 ^ order). + * + * Set both min and max values to \c 0 to force a single context, + * whose Rice parameter is based on the residual signal variance. + * Otherwise, set a min and max order, and the encoder will search + * all orders, using the mean of each context for its Rice parameter, + * and use the best. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value); + +/** Deprecated. Setting this value has no effect. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value); + +/** Set an estimate of the total samples that will be encoded. + * This is merely an estimate and may be set to \c 0 if unknown. + * This value will be written to the STREAMINFO block before encoding, + * and can remove the need for the caller to rewrite the value later + * if the value is known before encoding. + * + * \default \c 0 + * \param encoder An encoder instance to set. + * \param value See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value); + +/** Set the metadata blocks to be emitted to the stream before encoding. + * A value of \c NULL, \c 0 implies no metadata; otherwise, supply an + * array of pointers to metadata blocks. The array is non-const since + * the encoder may need to change the \a is_last flag inside them, and + * in some cases update seek point offsets. Otherwise, the encoder will + * not modify or free the blocks. It is up to the caller to free the + * metadata blocks after encoding finishes. + * + * \note + * The encoder stores only copies of the pointers in the \a metadata array; + * the metadata blocks themselves must survive at least until after + * FLAC__stream_encoder_finish() returns. Do not free the blocks until then. + * + * \note + * The STREAMINFO block is always written and no STREAMINFO block may + * occur in the supplied array. + * + * \note + * By default the encoder does not create a SEEKTABLE. If one is supplied + * in the \a metadata array, but the client has specified that it does not + * support seeking, then the SEEKTABLE will be written verbatim. However + * by itself this is not very useful as the client will not know the stream + * offsets for the seekpoints ahead of time. In order to get a proper + * seektable the client must support seeking. See next note. + * + * \note + * SEEKTABLE blocks are handled specially. Since you will not know + * the values for the seek point stream offsets, you should pass in + * a SEEKTABLE 'template', that is, a SEEKTABLE object with the + * required sample numbers (or placeholder points), with \c 0 for the + * \a frame_samples and \a stream_offset fields for each point. If the + * client has specified that it supports seeking by providing a seek + * callback to FLAC__stream_encoder_init_stream() or both seek AND read + * callback to FLAC__stream_encoder_init_ogg_stream() (or by using + * FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE()), + * then while it is encoding the encoder will fill the stream offsets in + * for you and when encoding is finished, it will seek back and write the + * real values into the SEEKTABLE block in the stream. There are helper + * routines for manipulating seektable template blocks; see metadata.h: + * FLAC__metadata_object_seektable_template_*(). If the client does + * not support seeking, the SEEKTABLE will have inaccurate offsets which + * will slow down or remove the ability to seek in the FLAC stream. + * + * \note + * The encoder instance \b will modify the first \c SEEKTABLE block + * as it transforms the template to a valid seektable while encoding, + * but it is still up to the caller to free all metadata blocks after + * encoding. + * + * \note + * A VORBIS_COMMENT block may be supplied. The vendor string in it + * will be ignored. libFLAC will use it's own vendor string. libFLAC + * will not modify the passed-in VORBIS_COMMENT's vendor string, it + * will simply write it's own into the stream. If no VORBIS_COMMENT + * block is present in the \a metadata array, libFLAC will write an + * empty one, containing only the vendor string. + * + * \note The Ogg FLAC mapping requires that the VORBIS_COMMENT block be + * the second metadata block of the stream. The encoder already supplies + * the STREAMINFO block automatically. If \a metadata does not contain a + * VORBIS_COMMENT block, the encoder will supply that too. Otherwise, if + * \a metadata does contain a VORBIS_COMMENT block and it is not the + * first, the init function will reorder \a metadata by moving the + * VORBIS_COMMENT block to the front; the relative ordering of the other + * blocks will remain as they were. + * + * \note The Ogg FLAC mapping limits the number of metadata blocks per + * stream to \c 65535. If \a num_blocks exceeds this the function will + * return \c false. + * + * \default \c NULL, 0 + * \param encoder An encoder instance to set. + * \param metadata See above. + * \param num_blocks See above. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * \c false if the encoder is already initialized, else \c true. + * \c false if the encoder is already initialized, or if + * \a num_blocks > 65535 if encoding to Ogg FLAC, else \c true. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks); + +/** Get the current encoder state. + * + * \param encoder An encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__StreamEncoderState + * The current encoder state. + */ +FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder); + +/** Get the state of the verify stream decoder. + * Useful when the stream encoder state is + * \c FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR. + * + * \param encoder An encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__StreamDecoderState + * The verify stream decoder state. + */ +FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder); + +/** Get the current encoder state as a C string. + * This version automatically resolves + * \c FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR by getting the + * verify decoder's state. + * + * \param encoder A encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval const char * + * The encoder state as a C string. Do not modify the contents. + */ +FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder); + +/** Get relevant values about the nature of a verify decoder error. + * Useful when the stream encoder state is + * \c FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR. The arguments should + * be addresses in which the stats will be returned, or NULL if value + * is not desired. + * + * \param encoder An encoder instance to query. + * \param absolute_sample The absolute sample number of the mismatch. + * \param frame_number The number of the frame in which the mismatch occurred. + * \param channel The channel in which the mismatch occurred. + * \param sample The number of the sample (relative to the frame) in + * which the mismatch occurred. + * \param expected The expected value for the sample in question. + * \param got The actual value returned by the decoder. + * \assert + * \code encoder != NULL \endcode + */ +FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got); + +/** Get the "verify" flag. + * + * \param encoder An encoder instance to query. + * \assert + * \code encoder != NULL \endcode + * \retval FLAC__bool + * See FLAC__stream_encoder_set_verify(). + */ +FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder); + +/** Get the frame header. + * + * \param encoder An initialized encoder instance in the OK state. + * \param buffer An array of pointers to each channel's signal. + * \param samples The number of samples in one channel. + * \assert + * \code encoder != NULL \endcode + * \code FLAC__stream_encoder_get_state(encoder) == FLAC__STREAM_ENCODER_OK \endcode + * \retval FLAC__bool + * \c true if successful, else \c false; in this case, check the + * encoder state with FLAC__stream_encoder_get_state() to see what + * went wrong. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples); + +/** Submit data for encoding. + * This version allows you to supply the input data where the channels + * are interleaved into a single array (i.e. channel0_sample0, + * channel1_sample0, ... , channelN_sample0, channel0_sample1, ...). + * The samples need not be block-aligned but they must be + * sample-aligned, i.e. the first value should be channel0_sample0 + * and the last value channelN_sampleM. Each sample should be a signed + * integer, right-justified to the resolution set by + * FLAC__stream_encoder_set_bits_per_sample(). For example, if the + * resolution is 16 bits per sample, the samples should all be in the + * range [-32768,32767]. + * + * For applications where channel order is important, channels must + * follow the order as described in the + * frame header. + * + * \param encoder An initialized encoder instance in the OK state. + * \param buffer An array of channel-interleaved data (see above). + * \param samples The number of samples in one channel, the same as for + * FLAC__stream_encoder_process(). For example, if + * encoding two channels, \c 1000 \a samples corresponds + * to a \a buffer of 2000 values. + * \assert + * \code encoder != NULL \endcode + * \code FLAC__stream_encoder_get_state(encoder) == FLAC__STREAM_ENCODER_OK \endcode + * \retval FLAC__bool + * \c true if successful, else \c false; in this case, check the + * encoder state with FLAC__stream_encoder_get_state() to see what + * went wrong. + */ +FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples); + +/* \} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/quakespasm/Windows/codecs/x64/libFLAC-8.dll b/quakespasm/Windows/codecs/x64/libFLAC-8.dll new file mode 100644 index 0000000000000000000000000000000000000000..a357c54b5b8d98772ae295675c2034107b3f5dc9 GIT binary patch literal 315392 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

R^_{^KT*!kpJ9f~ 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

?u^G(qF(m2alLQ&n%# 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≫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 nobh1AgS8JXda&g|aD!{7fRv(n$!OSdrB~i literal 0 HcmV?d00001 diff --git a/quakespasm/Windows/codecs/x64/libFLAC.dll.a b/quakespasm/Windows/codecs/x64/libFLAC.dll.a new file mode 100644 index 0000000000000000000000000000000000000000..2555928a005e0ab38778eedc56fde3f1737b65e3 GIT binary patch literal 215910 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 rVX6IJjPbmYL)5`B9&X+2Nxs$8c!0qb&aqgaleL literal 0 HcmV?d00001 diff --git a/quakespasm/Windows/codecs/x86/libFLAC-8.dll b/quakespasm/Windows/codecs/x86/libFLAC-8.dll new file mode 100644 index 0000000000000000000000000000000000000000..b75cb40fc7b8b9bdee2011446e2fb9f3fd3544de GIT binary patch literal 275968 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 literal 0 HcmV?d00001 diff --git a/quakespasm/Windows/codecs/x86/libFLAC.dll.a b/quakespasm/Windows/codecs/x86/libFLAC.dll.a new file mode 100644 index 0000000000000000000000000000000000000000..d6a796505a632c8ff523d12101e3a3b3327e94fa GIT binary patch literal 215134 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 Dnh0AZM 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 Rrfg#`aSI}9)ki!8%1DS2jN zVhAyWB!rlR5G5ut#28|TA%+m5h=_`ail|5s5fKp;5fKrI{(twq`>Nl4b?blE`MPB3;w91l zZ=FlzJx6r!D@31IM0DR)qEFsUbpI02okXAN1HC}>z3eH;kCJ=g>K647UdK#vf8 z7SGQ^!ZT`{{HYL(Bnj30N)oLCVB+&k9>{ji{Ss_i$q_#hUm-l zLAMY+dLrl^qOWv=9wT}Tx*mI(=&RQgeeE#N9YkNh00cdc1KZ=U|BVfxXNjJu5d9B< zfc43vKp!Cb=BXg)d#Vcr4BvVO=vPEf-$?ZB1)#f#o>>iot?z6Hy+-ux4MgAF8+04d zb4x+D6MgR((0hrVKMsVyfBy{7-9#@e20{N1xx~9hNK7Z1kK+d=_x!x2i7FLh$rZvilpc81Rad`kY2_UbjY<49l9TRA>D!}=&*&7 z?!Xgt_<53G^Kj4+TP3}UC+Nr;UPyQ02|8{- z(zAGij^7c{f`iBl2^bcDPFOAJF+4#hj!JqRPtZx%MznB0@AiqMo0Z-7GyGyze zPtaNTJ)~Rl1f6}1qz~c=T70^syYU2_bH1c|@B}ScE$QQUg3iV7A&LJ7EyeF4J%A@@ zS*N6X@dPc$?;$;kCuqg6q$lwNt=uB%Sv*0jDw1Bq6LcQZAn2`!N%|n3p!3g@^Z=fq zw_POZK|DbhY>@N}o}deBk`SX8f>!U41RJYCxvL{uvpabq-GV2m;|NKx*#YWYE(ta} zL3!8>>1jMcUC=9N?Hoy{E7pR#7fM1|?FJPPA0gd|C+H&hDWv=G1g#sA1nlcTJzFI` zg(s*N?;+v0UQpkdr04Ji^~0|rJ%J}^U|14<8vtEAA?YPNL4)v5NN?Z?DqbJa&{5=t zbSs{q^@}9kjVEYBm!yaB1Z{+!kejC?`rTw97Emf`_}oLxuG0n z%Hxy1FEseMfr4LLKOhVg{r@(;vtU4i$z9{eAgPf3VPzU*aPTxq-a+AqSrPU~5_$;(kxQ zuN4(-!QuB0cIF3LhA{g?4CXf4S|8dBuQxkuqF$>`Ue!?@MTYhU_3hQsp{phXT?TiF z4D-AC`;lpW$6!aZvWTNQpA$}5Q$Rco;D3s_-hm#CX_dRDzhj+d;DCnSXkTFizv;|oSm}4d@(<`0Ri3QO(jV(-6AV_ng~ zW($r8ZTN+vt`aeNFA{RjmIMmqBYE|}tOlc-i)O?BrBYr8G{ z6sM=RfHpGD11HbLLTW>h&bZjl#zLo!3yS&tx`F-z8oj7RiP|KK{FxCPKqoQZ-QR;Y zorg9fB3nM&qM8tl8U)({7dfZU*VUih+ekYyAuGEGHeLzwg$8?boBTCQCxo#lL}hkp z`!Aem=dvQ|=*+e%k-AwePI{b@!1^^)6)#ams z=_nLst(GBC>@IZasMW@XV4x>brm*&%Sog; zeia-dnNIpPVhEEMwT&rgJI zwQ-eXwMo5XwMl)<%BNm(*`!{wTBW}6DK$_YsZZAe-}G%(oE{z%UwEe9H{|;|FZPHT8B%`VerLkTb1~@i- zQyMmdo~de0pJ6jPA{Iq{N3}Lwo*Jo+i$OjgRJ)2t#0zBVoTQHLr zi|mZc!4iK&42Iyp!N_HPdCac|pF%8v)N zZGk^o8Wm%FteO<3R@+2y1*;?cT`P&!lJ`r*V3hT%+j#gwK4M~Z_*azc+x?MJr7~PX zCC8>FR@o$Dw&1Eg&9Bug3aeEXs*HMFVbjYddrGos<*yL!H!ChV%+gKnOiW1lsn`yc zH3?Yj_Dd6^jnbKoI%Oy&owB+O&05@Y8C0t*8hP1hG2#sljr3I5uPjfDRT%|ICXJ4I zX`87K2=vjJp5Zy8JrkMywS| zZj;tBz5=pzMLcE=Qvs@lFqwX73|W$`uUW!M`*45`UuM$F6AAUPh)KV>A!%f_t}RLY zcx9&lCIZ1@LNHkic4T=h;xTDJx7aSq5{xNb)!}ypBXz$tIaw)>lov5|yd&Zo zSk^_cNQVAKtd=G&i$%1RSUM>>K|5P6X^~c>NS1!>r=1{9|6ZmnADiT)O*~TyJm`Hsr;-KFzPmBgvT9$#Nl~~ZqmJ-(P z7Ioq-c3ZY61+8qEn;d;+>DnJXr;K`lDUSrUMJ39sw5UEMaoliKRLrB-fKne^KAj$a zNmmjxTzV~;E@XVxJU+vvrkPuhDCVO8P%M+$PlQdwG$+95Jzmo-3CewmdBR7LTtCgGKlqE34o>6v< zLRsiVbUHaFA&{k8j6H>YGISyXeC^_8B-mc9U|PaDIlK;M1TKNrWI7UV$!6>66-FWL zYISN7zJ|-CI9H*~#7;WJDJ8SQ;16HrM?=mn`$B=E=(9%FJpP<+Xf)nPj!383)sbcy z=yIf*uatR7eTq~WS$no%EiGwdEgE(ot5wJSaHKmLhn_5zO<(u2=2kItTI^9^DhMOo z8G)oT+z_<4Rj2*%KHlk*+I@h$*3fUk)wLicYG*I}WR~WfN{;M?%!u096WxRs(x!;n z+S!55MYZN*IN33Jgte4#%H~wKWY}*E?!})n+V<4MY^9SOuhVOeMKbh@k>unso^fz2 zZAB+&VT&8y)|rs}wwf_pFV>zI>O!M|hM2XT>ev_p#Mw?PW^IT0x-zFG63Vc_4CSXa zYe)2(nG)mZ+`zt#U>0_KR+Xk~-7h|>Lhfv>V%|=yX|T*#Xr7VC&~6@tNIOI~8qv&S zoJi2KW}suH71H{&vkPe^QG2?S^#p$g(s-KJs+NtJBc0KlB8J?;%GNowCt@?6 zUux{e%T%iq$k3VkuJ8DGqitlU#M8Tvlv z(`ssJX;T^!?Q80n$yyaNAy_<$5}J{DX;v+gm}z>VUasI<7Aw8R8cT&(pJhneTZ=u# zcvNdEmeX27{gLkcraUP*w9;Y}%`Xk3;+oE=15%s@ZFOI*ESaQ=ZidQi))_CF#QyQ7 zWhAN8hHBINwwiq`>SJR;qdk(bw=lC%!`)I+HrpaHezH1|S~JPHt07>m+s$E8zpcj_ z?8#(jMO2*iT47_l!YVPSmC=Mvgqxi+^F||~*M3=fQdVMqxYVB4+{~?L4WexgTz@&u zqL(jEh3myfsuSp~V6isV=!fX^{kDcqMvS#HR=!enjGT-#$*>l71hru-e;Ri*q7&2F zi9a7S@fUk1X3@%P`}~YDEx%dwOwT_{=M1M&+f3IyL)i?YQP*hI$4qu<5-YyKLn5@{ zAA3+Fx>uU z^{uR!PuCOF@g~XuNVZ4wkp-?6nvk?mJv7xDWjF~(v^N?a>TFJ zFe#mx0V!@)E82T%tgz9hny2NdriCb)fYZtt zEg(gf-@eJ9Hb|MRU~!blCv5vcsgXhLkCxNJkDBDv7*V4=<@-4!YZP9yM&q}3(l6lv zLTX$@{T=&C#={0&x3^A{{OC`Lgb}0iZH~$tjjCyYAPLGOX0(H*w>)-LW?_!mGW0Zt z5(BZ5HXMWD`!b@fiFE5lZSBd-$_S5?B`${(BN~j-1eX?R_`7j@AKeyk z6iqXnyf!;rLYrpXqsd|v+-x9)=?uH<;f5DO*$TOAwZ(kel$yppV(iW19`P@71b|IV zgGXyS9z(!_q@Y#_N*I!~(T3H&34X0+@%3ApL^tm0aH9dMwTaiLaoA$yJob*z+Qe_x zJk!@@N>ZqEhSR8Rrn8%&Y=+USt2&N;8HV7oU85502=t>4$y8&KJ}qI?-rR-GK-?_A z>Na(pEv%SCIeS@sZjpgVfw|8eGdOfoO(GmlwaaAF=ayCsf<{}0-gAcg4N^ucsa|x3 z_7pd(wWa>A@RcxP7B<_IgF=}VR=jG^&_09^*e-aMlUQLR{;=W79Gyzm78(hob~XC4 zzYc^Kv@%8uT<1H(W1Ohbp3)c3Fre_7HHO^=rT?6zw^_od-PCo?Fkuoi+KIc;8G0p~ z`+4w7mMjg=hTl5(WDh5h-%GUU6GU6@Bf9&OL`&``x)ap*DV%l=dd~wy$9)>VfqEXq z3GSew&)`&d(9mab@;YeC=WtRwX!s$Vt_~XgJpK;a^e|3s2Mv7zr^17J9>J;ZpeqbI^@X6D{~Q(Osa`&%hRF`*(1X zI_QRHiT3_3(QTlm&k@}YI_7&s?*$$AJpK+kfs59^M@S>+ zk{59bJ?PRO;{3J;oiIXVq~$4`L^wBr@{8?@zTkON)%Do(ivUHWsp zgSNbechKlBAP0K)>+sz#ksi>zH{d6bIMV$Z(A-}U-3&V9*F-mg=0*p$)9Ic^w}TeU z@#r?tVY}fVchC{Ldvq&k!5$vH5431ck3I@IYcG#J3|h3eM;`($*~g=gfG(Kp(L!52-f}Mp(H)s(8|6`!8Mc@H#I>nzyq3h7Sahi=4_8X2s(YSM|XqHKgXkcK&zK{^l{Mn=i&)k zy%cEzbuRPhUeN00NDpXug-1_U7Z8IHSi_qhz`htmUluHbWz@;r$IZqJesrCqnkhryOFP;MFo%U z1g*Zvqx(QZ>!2UBwFh|z+S-eE&{!Yx4z#7;qbESa19%5bTt^5pExZIcKug~4(fy$3;QoNdXd7*(GQEQ?qY91F z1XXF0E~gqzQJtn~2VFr|(p7Xd{U*JWev7W5chR-<+w^Yw9lDNwm#(MZqxaD7(+%_o zbR+#C{So~!-9&#vH`AZu`hq{BKc~N-Tj($8R{AS?AHAP$qravP(BIJC(%;bs>F?=w z`Um3^ca1WzD8fC$LSmN1gfql>6`Qv zeT$x^Z__jM9eS3&OV82w=z01+y+A*pAJUKLMfx$lL_eXI>8JDx{fu6vpVMpf3woV? zNpGO&|B6u5Je$_VxDj_V?y_2YB|z0_ND!3f0{=J z(0n?O4x)qU5IU3&qr>S4I+Bi}qv;qrmX4$2X#t%;C(=o@kWQvWbPAnHr_t&37CM8@ zq_gO3T1@BA5;~Wb(lT03D`+LHqVwpjbUwX}E}#o(HRWgxbxW>lzxM@kWX8wM8h;fqr2kh|2&R%i~H%bIZZ6; zElCaW{>b#^KlyW_vnbA;iU(g66)7Iu^SV?Wjgz{PdzvH&-F_JZULEUfkH3n5#$QUA z=U8dkz_|^_U$Q2(*l7S)OHPo_c z2ubEyANgSgOgi5A=nX67(*KR4H1tBeZ_u2|vo7?~iRqh0Wi8!m>Oq+JvIMD&n)*j<3h9_A%2t>uqFY@HMuf+Q_tdf4aTNwrvr&F)0h0lV{$Ht=2YJ z+q2!-#*!%aPA(Awt?eI9!AWnelaZ_MNu`-ZUo+XQ68n2I^f$Vv_MENnpS8uJ?<%KL zE7nqEqL%T^b)1{@wz7jXBWb$kJZ)Fo+fFmN?#Il)rG6GhUsR37N@@=#^`mwva=h7c z%ylbc1T$r#5u2jB8|So!N3MoYHXIri8kSDP$c4>TH~ATDqSv8YyJ+N34Dc|?)~)bL zCPSILGw2D|BSkB(v}nTLH7lfIJK^tQL?cUw;IYvYWiN-86+Ps@K-wG1#!~O)s0%s^Mzsq&7pv zn`E(EBo@}u*!1DF(n|`NmvF@l=_OpoL<6n5NTsnJ%P8WqKuX}TS@IO~A@U8|42*Ev zx!B)m1h_IAzhn?Nug4J%Ft?aV)w&i_{k>_`yD?cx>zY`@ZWM@@#$+%wdSA*ab6X)U zg{HPX_JFCaSAI9N^-VmQw!Vo++ej*0EJt%&AIr9|dRgmW@l~g+MmBP_v|`w(Eu*TG zU#GKJtZTF^YG9{oRbXjpWh@85rCJpLT&h*UZ&R(te2&#>DArgEYD{DcHLuW|)nADV zfZ$b~C>LEC0Xf&Y!bEnh8*;T_ouUzUT&p%;FK=@L{jO`~aRYE0uDjoL&3rPF-yD?D9rZ0lS0re6@$#-~=KItwOX)fyzRrEuHS@c!nV%`7 zQIzbuW?qirrwdKOJ#6QPk=u36{H|-}{ax40H*T-rbc+<9$49hP3A{6Yd_m&$?7~68YNfw6-Jd3R-T61FV zFfO!)j1Vl1Z74=1(M(mwHP_5N){XrlZ2YCT;tdvBR1IE{0J(n9l99XSuc1~<7aCla z;IX_WLN5_-Ug2Sz3t2;Jw6u;_6RoV{dBk)E=SsOkKe+}|h-6=t>~afit2Z3WrKEB% zh&G|=jT?>ClZh=aE`m;SeW< z68EQaA~PE^WD%EJR_tVC0J+InmDL$sGV|kYH+H~;lbukdx233CaO{jW>4-Ms%tAPI zMr1mqW}K8Zt?a5Xw6roVEtM!+a~zY@{4J19iQ30cZ`0w-sgg2?8~ZQpCAlp-u38%R zL%Is;w(r>Mz@p4n?|GC3xdp!&H}u%!PN+y;faszib(f)wXv;SmiaMqRhY7LNb{{R= z^zIF|Vbe3S{mrz9=;|jspH3J2aUENop=eJ{i+AwFcjH;Pt?>oJeVC*nGT$f7td^fC zO@i@OA**Dd%Obv0#UgM+b)MF5?!Gj0T3->zeCVXLia2)(3$grEoHCJgNAzXfSk|g5 z0x6bwVLGElZZKjv!k9@fV9(;8Iiod$Q?Afdwj9}s@ZJ%qo3wmI1#q3kHXKkK1t4*{Q*qk!ltB^t8q;0|Fdm{o2x9?(p#*uMbyRYjg3|rf`)wo z8B(d;0T$dSWrnR+S;FjT%^AX~PqI%{76AdImd$@M-nh*H86dNI4oNfSo`cFI=DKYU zN^a_FB(`d0KyPd#ZeW4~!V_&F= zlj$ZXycT?>zEG^EvDu4pcH9Y4E}&reMKh>u{L0{M+WwWrZ&lR`6joJz$k=>)Lk5WE z-L@72Ei?`SUA#ps+k(qIUsAJL5!y5kLeRZ&5K{JyL(JV$;}8lrwvlCcjo(a`A#B&% ziwm2;rMf%2-4QY^wje^(wgm}!o41-}BwzUswQC!MA=x&(t5O~oThq>5>G!Sg>G6lU z*Y~aSJ99%hYW#B6Xr*%Yf(7TCyJG3NtCp=;wtRu|Z?Sw^ws?vBzpZn7yxpks{vTXC zA7@GLjib@=&pT^07@pp?uo%4(P8Y`c>G6wvuBQ2G&MJ%9=7me*pANzQ;HY|>${hXM z4Ug5d_&&+ET>cp+BNNSmy_iq@eKjq(Zw{V^-~?syZ+|6Gr_#am_rhO=M)6M|J>|iJ zddnlV>Qr^CzTnis(-!m;`qqWNrvI}a{vafU2Etj*;{WF3zk7uLrx>Eu7^0m7;8Py_ zP5LzsijFJ_8SzgboI`QCR}+Ppx5s}8Qz#^Mi~q7z@Zb+Pp<7BVoB50Q`-$Q|@}JO7 zINf>X-yEFUO!$f_^bYh74*8wfKsQ(z80sIi*>Tv$h*`4i+(g982_xoSAd3*|BW83a z8R7pWBIexqClN6pieKbYM2yh;W<-Kb?j8%tx;(DJ7HpkMVM*=rL_KzT zn8tnN$uPNrf?r%eAPP^>?_aw%>{_e!rTS)(qsy1Ym8xp_Oj!0%d&%y5$M(|1L{Q1$ zTC8mo$W`GfZx+5;W$=xtmv?hV2fR5z$HvZ{e4m<8EqHE)-gCXcw!15~ zEXO&=^QyRUPQ`N<(Cy)ju76PMhHZA5bAB$>`|Kj1+S3^omz}Q2RvOAdCy?#sjBGHs zu?^l@VW^WtWh`!nkTrw8Y&JF#DxOe--l7DqI7gpjqRHJSfnlOvt4?0k5#D0m8`QT~ zM~AMOj2GRj5S(L~tDEP}V2E~8clGy+0^Tv$(T*H2#H;9-?VGmDY?@acpuE}SL8ITT zwh$|UVm}j#p8k$?qN>J5t=v$4?dCRkWBDq5ESv)z`*S$_V&Rg!27q%UtT5EMtAJph z0YOK1uCFiO8!RhZk(KasZ}(OhS{Cuy zcA&w2dMlv{L3y(%56cX3cnT04WJ0jHuS2c;+*7_h?s})%)VILy!HnIu#2b_A;>$+1 z1?Cea6eqVg?T04pYmcg!t!+cZoeIAnHe(yjPDu!|vhDc71fw z%M-+BZ}&(YR+5~r7_?s3Os_+HAv zKgU?(X=`i2M9#4`h#KdusIF1oEFx!xp)8*V&m3ogqX!29`Gr1BRql#pm7zzy7D$e_ zK+>DZR}GS+D6guT)`j;afIi;ttns@cK{;+(p$}4DkU2&N*C8ot+c`H7yTA%ld*>upGX0GUt?)D-o2b-2&Mp0N1ERCw zq19$YZR%&NG?Xdv#hWu*-_Sp}MjWx+-y2TUiK*>y=2G7Ub1z*Csx{WA#7LJ!*p_;_ zu^28js(k`{)zO41JZW4F4QD?rGqemR!(yk_Vms=#<;*-zUT+mM3Yf%JV_$u!t+^=qO!N}OGJanAtqIN#OfW7MUiP?R4@s%`bn0tq*xw3b0q>@IZarmdAQu&}?< zu%hGwrZD{YgIlgs9y9m&>dw`3L9utxc`N1`q-|NkU;~J^lx}#nVnvJ>Q zkcbP>rN^@NwQZ@dnEC!b4F=@~2PMJoUx3`&ul|JXaMwU*Fj5^2YWZ4?o%U5A*_2Pi zyoXr(HDJI{z|neboq0CofmpbFu>phTz+ENjE#wB{i9rL3rn79{L<~g(hGP1V+*xAa z`jkT^4B}9Q_N<3sa$&u}def=Cv-AL0E;kr3Y{bba@PIg9ut7~*we{y=%8K3xlZ zq~ zA#83<+8hi&p0q|?)5(25m9QpWu7YHaK36O{f3a}w-*A)t_;hA*2zn*hR;sA>)HjP< z=5`8=G+B>N<1`p|&Tnqr?`V_t#Malu8Su08zTq29tUnL35JYFos{ovRz^%O=YevvG zjlNxZz^y>u#@G)}z?@~;xi8i2O}5o@F{9Hh+vNrBOSNo;L_NP>b&T?6Q7XB$M(?mf zle!l`0pR|v!p%WlHiM^e+7ymy;4U1PB^oYbD@HW(tfg7n=4z~Qqiywy1QmkvW)T}) ze_+ChKpY#QSW@3?>>7IKr=g~-8tsZ38&p&7(Z{t>ldR?Nt_U^R&h_(3!wB>FNcZKL z*3-8(s9=;gi#*^~!qj*ySCs49eVmnF87_@nHkHZ}R~+0bwkabH<3Z3l0e4@74laC?ETa6;mjaKy7X z>^nS8N%4s4Eero}EyI->RN^?SxJRuTYat>H^B`ik|5XOtvOk?Nt@ywu)rK!MvD^P@ zgXO7kkT<-bMKR}|Zf@t?ZyKzJH^0o%F8AH^PL18h?I+rffC9$C=iHdxZ)IDT#|SG{ z)hMvQz}3Rna2Q0`N9P!;0Gw-q6^0cPVlVT%tPn&;SgSCUHyb|~P@Dl2*K#Pt$#AOI z)i(><+&u7a^R}A~*;dl+j>PaKD^?u6+Zu_yV@QSK92ZoWdWY{ZBZ;myQcXL@AGeC^_Zi#M!PNFZ^hZjSk?9KNxBQXO(P1BV7N~%f zH;cI7Rz%!jfhTG%0fkPbeICB@78Zye8P4pU89Ex*F{@4PGs8Dp7*E`ysTF0ST# zuPd&$AmYZ7{>&OtbB9fFltl^WR;T~DH4a(lz%%8MAU(Y09M@bw?k~)kw1vvmAKZ8C zEoR%82njBqp8b3vGs^pyX6wyi;OukmTk=-3<%}swSMPHu{wfmr*eIy_uHYFxw>(dSh&8)ZDuUuik0xDDV#1}3DCEWZcP*EU#` zyCxOuYPZ$`3s;+ezzU1L^QfS*z`;fC-`L=g6}h|{Q!(E{YpTF;_t`m%JmOrNbBI1{i%7O~@qM1NL&Tlw{7<%sm#Dd$>Phi!FUKuL8oo=Hep$Uu-d@uKZOYDQ^~D;?4=b z(-u+U9^i5?h3iu4BiqXp+tdod-CL^+zjEpbP&;wE=w+}Hd^?UAXMAHRv1 z{>>hfdaLqmF&T1DoH}`zEhf=B)mQJ%^%b|b`rlpfsP{n6(n~80UJ^UCKBhsHzOYw2 zAmi*C?)&#YtWmUQj*V;S?zX@prv8%?ZcWom?%pwc*@zMP|FlG;n|@S6$D+RG*391H zf&=U7C$`nM&$f={@cfq(9(g&q;*b_kW!arN@aC>q8+X9Vd>4tOU za%Jh`Rv0pta5y94Mjt<6gGgS$u7-;8W>J#3H7)nqp=ey}uGm(C#s-ODgiV|a|49oZ z&BM|P9vcLPQX}>&-*1JWX;F!LR4^DmWr0DnxWpX;Q_DYKfkAXt+EL4MJ%Uf$;AqbZ zU_-w|tUi8l21T^UvT>nldwL_>+N#eOZOcoVmGF0OL%5aCpEcXAOi!hoQw4}kIb`DR zb4JVILdSA_%AX8s^5#Uf4pQH2a4IXnxbI6f z-acU`s1d}M$|Ece+!Bs! zZG(}^+AuD_?PB{PivrUwnwzi{FQ^`}@rhwYytr%XODvkiPEXaU`euQFn@#^Rk3sCH zSM8~97S_4`+@q{@+bpd=##?X0ju39Y-dB0+ zjmyAiSqhjI<7?Rn+TjDH9DY3;LDY*;^Id(jiGp}yDs>*6ICcDS9z%QV8*)M1_wx;- z{Wtgf;R&PN_=5H+v$NYGQubThrn?*EmYowoa zL)4z=Fq9Cnck7!*JZLk6+3pzN>ZhlSmc?=wzch>{dwTY56w`D07J~qnzqhgH!mVF< znnxk8=<;!gZMBvzEK1#N6Pbp3LhSbawhIm)TW!^Hp}yH*G1QsjH0o#EuuM)?$|I$A z^m7e!hhhinckD2s*i2R@(%Tx`Yc<2Dh#1d&)(MFwtK88TzJ$aYn(sQIF=m!CDsCk2 zITn@Z{9tsmT&nmJ)8oTIO^sgl%_5e$p78g~NG>Z+`cWh3ho>8qxe>rn2DPPFMGgiJb7&U@% zu5}GJijq6pj*%ThyDQf0{3H{}mD@|xQ}yzWz#qqGt%c#D}qk%t#yG?`YY_V{2iLYc~xx6xo zFbT%Sd`#7hv?+JEvB00Ph$_|U6e5LnkZTRkwg0cOXvRxd`jyEMzgoj_#Hnm@MZv9d z`FSP^u{3=YTWtKvQmq~i8f!s0mm?0F^l!8wMw^GM!cG3}hO_W$KEv}3H@@U<*X zANW;+;xDsY=(`K385m3;T@;^gtX&j|RI`pLNfU+kr601(QIN9&~c{5H~}!n-R^QQb3`VJH*2he8)-h0M)kKz%$iDN+A{Nd3os&>yGa