/* for FILE */
#include "export.h"
#include "format.h"
#include "stream_decoder.h"
@@ -128,8 +129,8 @@ extern "C" {
* 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
+ * 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
@@ -310,8 +311,7 @@ typedef enum {
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 supports 4-32 bps.
*/
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE,
@@ -330,7 +330,7 @@ typedef enum {
/**< 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. */
+ /**< 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:
@@ -742,7 +742,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncod
*/
FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value);
-/** Set the Subset flag. If \c true,
+/** 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
@@ -842,15 +842,15 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *en
* | 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);partial_tukey(2) | | 8 | 0 | false | false | false | 0 | 6 | 0 |
- * | 7 | true | false | tukey(0.5);partial_tukey(2) | | 12 | 0 | false | false | false | 0 | 6 | 0 |
- * | 8 | true | false | tukey(0.5);partial_tukey(2);punchout_tukey(3) | 12 | 0 | false | false | false | 0 | 6 | 0 |
+ * | 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 | subdivide_tukey(2) | 8 | 0 | false | false | false | 0 | 6 | 0 |
+ * | 7 | true | false | subdivide_tukey(2) | 12 | 0 | false | false | false | 0 | 6 | 0 |
+ * | 8 | true | false | subdivide_tukey(3) | 12 | 0 | false | false | false | 0 | 6 | 0 |
*
*
* \default \c 5
@@ -920,7 +920,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamE
* \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 partial_tukey(n[/ov[/P]]),
- * \c punchout_tukey(n[/ov[/P]]), \c welch.
+ * \c punchout_tukey(n[/ov[/P]]), \c subdivide_tukey(n[/P]), \c welch.
*
* For \c gauss(STDDEV), STDDEV specifies the standard deviation
* (0Subset flag.
*
* \param encoder An encoder instance to query.
* \assert
@@ -1428,6 +1458,16 @@ FLAC_API uint32_t FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC
*/
FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder);
+/** Get the "limit_min_bitrate" flag.
+ *
+ * \param encoder An encoder instance to query.
+ * \assert
+ * \code encoder != NULL \endcode
+ * \retval FLAC__bool
+ * See FLAC__stream_encoder_set_limit_min_bitrate().
+ */
+FLAC_API FLAC__bool FLAC__stream_encoder_get_limit_min_bitrate(const FLAC__StreamEncoder *encoder);
+
/** Initialize the encoder instance to encode native FLAC streams.
*
* This flavor of initialization sets up the encoder to encode to a
@@ -1632,11 +1672,15 @@ FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_FILE(FLAC__
/** Initialize the encoder instance to encode native FLAC files.
*
* This flavor of initialization sets up the encoder to encode to a plain
- * FLAC file. If POSIX fopen() semantics are not sufficient (for example,
- * with Unicode filenames on Windows), you must use
+ * FLAC file. If POSIX fopen() semantics are not sufficient you must use
* FLAC__stream_encoder_init_FILE(), or FLAC__stream_encoder_init_stream()
* and provide callbacks for the I/O.
*
+ * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ * internally translates to an appropriate representation to use with
+ * _wfopen. On all other systems, filename is passed to fopen without
+ * any translation.
+ *
* This function should be called after FLAC__stream_encoder_new() and
* FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
* or FLAC__stream_encoder_process_interleaved().
@@ -1664,11 +1708,15 @@ FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_file(FLAC__Stre
/** Initialize the encoder instance to encode Ogg FLAC files.
*
* This flavor of initialization sets up the encoder to encode to a plain
- * Ogg FLAC file. If POSIX fopen() semantics are not sufficient (for example,
- * with Unicode filenames on Windows), you must use
+ * Ogg FLAC file. If POSIX fopen() semantics are not sufficient, you must use
* FLAC__stream_encoder_init_ogg_FILE(), or FLAC__stream_encoder_init_ogg_stream()
* and provide callbacks for the I/O.
*
+ * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ * internally translates to an appropriate representation to use with
+ * _wfopen. On all other systems, filename is passed to fopen without
+ * any translation.
+ *
* This function should be called after FLAC__stream_encoder_new() and
* FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
* or FLAC__stream_encoder_process_interleaved().
@@ -1733,7 +1781,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder);
*
* For applications where channel order is important, channels must
* follow the order as described in the
- * frame header.
+ * frame header.
*
* \param encoder An initialized encoder instance in the OK state.
* \param buffer An array of pointers to each channel's signal.
@@ -1762,7 +1810,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, c
*
* For applications where channel order is important, channels must
* follow the order as described in the
- * frame header.
+ * frame header.
*
* \param encoder An initialized encoder instance in the OK state.
* \param buffer An array of channel-interleaved data (see above).
diff --git a/modules/juce_audio_formats/codecs/flac_143/all.h b/modules/juce_audio_formats/codecs/flac_143/all.h
deleted file mode 100644
index 03617ece45..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/all.h
+++ /dev/null
@@ -1,454 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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
-
-#ifndef FLAC__HAS_OGG
- #define FLAC__HAS_OGG 0
-#endif
-
-#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 \#defines in \c export.h of each
- * library's includes (e.g. \c include/FLAC/export.h). The
- * \#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 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 uint32_t.
- */
-
-/** \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 porting_1_3_4_to_1_4_0 Porting from FLAC 1.3.4 to 1.4.0
- * \ingroup porting
- *
- * \brief
- * This module describes porting from FLAC 1.3.4 to FLAC 1.4.0.
- *
- * \section porting_1_3_4_to_1_4_0_summary Summary
- *
- * Between FLAC 1.3.4 and FLAC 1.4.0, there have four breaking changes
- * - the function get_client_data_from_decoder has been renamed to
- * FLAC__get_decoder_client_data
- * - some data types in the FLAC__Frame struct have changed
- * - all functions resizing metadata blocks now return the object
- * untouched if memory allocation fails, whereas previously the
- * handling varied and was more or less undefined
- * - all functions accepting a filename now take UTF-8 encoded filenames
- * on Windows instead of filenames in the current codepage
- *
- * Furthermore, there have been the following additions
- * - the functions FLAC__stream_encoder_set_limit_min_bitrate,
- * FLAC__stream_encoder_get_limit_min_bitrate,
- * FLAC::encoder::file::set_limit_min_bitrate() and
- * FLAC::encoder::file::get_limit_min_bitrate() have been added
- * - Added FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA to the
- * FLAC__StreamDecoderErrorStatus enum
- *
- * \section porting_1_3_4_to_1_4_0_breaking Breaking changes
- *
- * The function \b get_client_data_from_decoder was added in FLAC 1.3.3
- * but did not follow the API naming convention and was not properly
- * exported. The function is now renamed and properly integrated as
- * FLAC__stream_decoder_get_client_data
- *
- * To accomodate encoding and decoding 32-bit int PCM, some data types
- * in the \b FLAC__frame struct were changed. Specifically, warmup
- * in both the FLAC__Subframe_Fixed struc and the FLAC__Subframe_LPC
- * struct is changed from FLAC__int32 to FLAC__int64. Also, value
- * in the FLAC__Subframe_Constant is changed from FLAC__int32 to
- * FLAC__int64. Finally, in FLAC__Subframe_Verbatim struct data is
- * changes from a FLAC__int32 array to a union containing a FLAC__int32
- * array and a FLAC__int64 array. Also, a new member is added,
- * data_type, which clarifies whether the FLAC__int32 or FLAC__int64
- * array is in use.
- *
- * Furthermore, the following functions now return the object untouched
- * if memory allocation fails, whereas previously the handling varied
- * and was more or less undefined
- *
- * - FLAC__metadata_object_seektable_resize_points
- * - FLAC__metadata_object_vorbiscomment_resize_comments
- * - FLAC__metadata_object_cuesheet_track_resize_indices
- * - FLAC__metadata_object_cuesheet_resize_tracks
- *
- * The last breaking change is that all API functions taking a filename
- * as an argument now, on Windows, must be supplied with that filename
- * in the UTF-8 character encoding instead of using the current code
- * page. libFLAC internally translates these UTF-8 encoded filenames to
- * an appropriate representation to use with _wfopen. On all other
- * systems, filename is passed to fopen without any translation, as it
- * in libFLAC 1.3.4 and earlier.
- *
- * \section porting_1_3_4_to_1_4_0_additions Additions
- *
- * To aid in creating properly streamable FLAC files, a set of functions
- * was added to make it possible to enfore a minimum bitrate to files
- * created through libFLAC's stream_encoder.h interface. With this
- * function enabled the resulting FLAC files have a minimum bitrate of
- * 1bit/sample independent of the number of channels, i.e. 48kbit/s for
- * 48kHz. This can be beneficial for streaming, as very low bitrates for
- * silent sections compressed with 'constant' subframes can result in a
- * bitrate of 1kbit/s, creating problems with clients that aren't aware
- * of this possibility and buffer too much data.
- *
- * Finally, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA was added to
- * the FLAC__StreamDecoderErrorStatus enum to signal that the decoder
- * encountered unreadable metadata.
- *
- */
-
-/** \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/modules/juce_audio_formats/codecs/flac_143/alloc.h b/modules/juce_audio_formats/codecs/flac_143/alloc.h
deleted file mode 100644
index 8e89e9b820..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/alloc.h
+++ /dev/null
@@ -1,321 +0,0 @@
-/* alloc - Convenience routines for safely allocating memory
- * Copyright (C) 2007-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__SHARE__ALLOC_H
-#define FLAC__SHARE__ALLOC_H
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-/* WATCHOUT: for c++ you may have to #define __STDC_LIMIT_MACROS 1 real early
- * before #including this file, otherwise SIZE_MAX might not be defined
- */
-
-// JUCE: removed as JUCE already includes standard headers and including
-// these in FlacNamespace will cause problems
-
-//#include /* for SIZE_MAX */
-//#if HAVE_STDINT_H
-//#include /* for SIZE_MAX in case limits.h didn't get it */
-//#endif
-//#include /* for size_t, malloc(), etc */
-#include "compat.h"
-
-#ifndef SIZE_MAX
-# ifndef SIZE_T_MAX
-# ifdef _MSC_VER
-# ifdef _WIN64
-# define SIZE_T_MAX FLAC__U64L(0xffffffffffffffff)
-# else
-# define SIZE_T_MAX 0xffffffff
-# endif
-# else
-# error
-# endif
-# endif
-# define SIZE_MAX SIZE_T_MAX
-#endif
-
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-extern int alloc_check_threshold, alloc_check_counter;
-
-static inline int alloc_check() {
- if(alloc_check_threshold == INT32_MAX)
- return 0;
- else if(alloc_check_counter++ == alloc_check_threshold)
- return 1;
- else
- return 0;
-}
-
-#endif
-
-/* avoid malloc()ing 0 bytes, see:
- * https://www.securecoding.cert.org/confluence/display/seccode/MEM04-A.+Do+not+make+assumptions+about+the+result+of+allocating+0+bytes?focusedCommentId=5407003
-*/
-
-static inline void *safe_malloc_(size_t size)
-{
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
- /* Fail if requested */
- if(alloc_check())
- return NULL;
-#endif
- /* malloc(0) is undefined; FLAC src convention is to always allocate */
- if(!size)
- size++;
- return malloc(size);
-}
-
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-static inline void *malloc_(size_t size)
-{
- /* Fail if requested */
- if(alloc_check())
- return NULL;
- return malloc(size);
-}
-#else
-#define malloc_ malloc
-#endif
-
-
-
-static inline void *safe_calloc_(size_t nmemb, size_t size)
-{
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
- /* Fail if requested */
- if(alloc_check())
- return NULL;
-#endif
- if(!nmemb || !size)
- return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */
- return calloc(nmemb, size);
-}
-
-/*@@@@ there's probably a better way to prevent overflows when allocating untrusted sums but this works for now */
-
-static inline void *safe_malloc_add_2op_(size_t size1, size_t size2)
-{
- size2 += size1;
- if(size2 < size1)
- return 0;
- return safe_malloc_(size2);
-}
-
-static inline void *safe_malloc_add_3op_(size_t size1, size_t size2, size_t size3)
-{
- size2 += size1;
- if(size2 < size1)
- return 0;
- size3 += size2;
- if(size3 < size2)
- return 0;
- return safe_malloc_(size3);
-}
-
-static inline void *safe_malloc_add_4op_(size_t size1, size_t size2, size_t size3, size_t size4)
-{
- size2 += size1;
- if(size2 < size1)
- return 0;
- size3 += size2;
- if(size3 < size2)
- return 0;
- size4 += size3;
- if(size4 < size3)
- return 0;
- return safe_malloc_(size4);
-}
-
-void *safe_malloc_mul_2op_(size_t size1, size_t size2) ;
-
-static inline void *safe_malloc_mul_3op_(size_t size1, size_t size2, size_t size3)
-{
- if(!size1 || !size2 || !size3)
- return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */
- if(size1 > SIZE_MAX / size2)
- return 0;
- size1 *= size2;
- if(size1 > SIZE_MAX / size3)
- return 0;
- return malloc_(size1*size3);
-}
-
-/* size1*size2 + size3 */
-static inline void *safe_malloc_mul2add_(size_t size1, size_t size2, size_t size3)
-{
- if(!size1 || !size2)
- return safe_malloc_(size3);
- if(size1 > SIZE_MAX / size2)
- return 0;
- return safe_malloc_add_2op_(size1*size2, size3);
-}
-
-/* size1 * (size2 + size3) */
-static inline void *safe_malloc_muladd2_(size_t size1, size_t size2, size_t size3)
-{
- if(!size1 || (!size2 && !size3))
- return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */
- size2 += size3;
- if(size2 < size3)
- return 0;
- if(size1 > SIZE_MAX / size2)
- return 0;
- return malloc_(size1*size2);
-}
-
-static inline void *safe_realloc_(void *ptr, size_t size)
-{
- void *oldptr;
- void *newptr;
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
- /* Fail if requested */
- if(alloc_check() && size > 0) {
- free(ptr);
- return NULL;
- }
-#endif
- oldptr = ptr;
- newptr = realloc(ptr, size);
- if(size > 0 && newptr == 0)
- free(oldptr);
- return newptr;
-}
-
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-static inline void *realloc_(void *ptr, size_t size)
-{
- /* Fail if requested */
- if(alloc_check())
- return NULL;
- return realloc(ptr, size);
-}
-#else
-#define realloc_ realloc
-#endif
-
-
-static inline void *safe_realloc_nofree_add_2op_(void *ptr, size_t size1, size_t size2)
-{
- size2 += size1;
- if(size2 < size1)
- return 0;
- return realloc_(ptr, size2);
-}
-
-static inline void *safe_realloc_add_3op_(void *ptr, size_t size1, size_t size2, size_t size3)
-{
- size2 += size1;
- if(size2 < size1) {
- free(ptr);
- return 0;
- }
- size3 += size2;
- if(size3 < size2) {
- free(ptr);
- return 0;
- }
- return safe_realloc_(ptr, size3);
-}
-
-static inline void *safe_realloc_nofree_add_3op_(void *ptr, size_t size1, size_t size2, size_t size3)
-{
- size2 += size1;
- if(size2 < size1)
- return 0;
- size3 += size2;
- if(size3 < size2)
- return 0;
- return realloc_(ptr, size3);
-}
-
-static inline void *safe_realloc_nofree_add_4op_(void *ptr, size_t size1, size_t size2, size_t size3, size_t size4)
-{
- size2 += size1;
- if(size2 < size1)
- return 0;
- size3 += size2;
- if(size3 < size2)
- return 0;
- size4 += size3;
- if(size4 < size3)
- return 0;
- return realloc_(ptr, size4);
-}
-
-static inline void *safe_realloc_mul_2op_(void *ptr, size_t size1, size_t size2)
-{
- if(!size1 || !size2)
- return realloc(ptr, 0); /* preserve POSIX realloc(ptr, 0) semantics */
- if(size1 > SIZE_MAX / size2) {
- free(ptr);
- return 0;
- }
- return safe_realloc_(ptr, size1*size2);
-}
-
-static inline void *safe_realloc_nofree_mul_2op_(void *ptr, size_t size1, size_t size2)
-{
- if(!size1 || !size2)
- return realloc(ptr, 0); /* preserve POSIX realloc(ptr, 0) semantics */
- if(size1 > SIZE_MAX / size2)
- return 0;
- return realloc_(ptr, size1*size2);
-}
-
-/* size1 * (size2 + size3) */
-static inline void *safe_realloc_muladd2_(void *ptr, size_t size1, size_t size2, size_t size3)
-{
- if(!size1 || (!size2 && !size3))
- return realloc(ptr, 0); /* preserve POSIX realloc(ptr, 0) semantics */
- size2 += size3;
- if(size2 < size3) {
- free(ptr);
- return 0;
- }
- return safe_realloc_mul_2op_(ptr, size1, size2);
-}
-
-/* size1 * (size2 + size3) */
-static inline void *safe_realloc_nofree_muladd2_(void *ptr, size_t size1, size_t size2, size_t size3)
-{
- if(!size1 || (!size2 && !size3))
- return realloc(ptr, 0); /* preserve POSIX realloc(ptr, 0) semantics */
- size2 += size3;
- if(size2 < size3)
- return 0;
- return safe_realloc_nofree_mul_2op_(ptr, size1, size2);
-}
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/assert.h b/modules/juce_audio_formats/codecs/flac_143/assert.h
deleted file mode 100644
index 7e73ac2787..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/assert.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2001-2009 Josh Coalson
- * Copyright (C) 2011-2023 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 FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-#define FLAC__ASSERT(x) if(!(x)) __builtin_abort();
-#define FLAC__ASSERT_DECLARATION(x) x
-#else
-#ifndef NDEBUG
-#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
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/callback.h b/modules/juce_audio_formats/codecs/flac_143/callback.h
deleted file mode 100644
index 8b7a763a7d..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/callback.h
+++ /dev/null
@@ -1,190 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2004-2009 Josh Coalson
- * Copyright (C) 2011-2023 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. Note that the global
- * variable errno from errno.h is read by some libFLAC functions to
- * detect read errors.
- *
- * \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 source is not seekable by setting the \a seek field to \c NULL.
- *
- * See the detailed documentation for callbacks in the
- * \link flac_callbacks callbacks \endlink module.
- */
-typedef struct {
- FLAC__IOCallback_Read read; /**< See FLAC__IOCallbacks */
- FLAC__IOCallback_Write write; /**< See FLAC__IOCallbacks */
- FLAC__IOCallback_Seek seek; /**< See FLAC__IOCallbacks */
- FLAC__IOCallback_Tell tell; /**< See FLAC__IOCallbacks */
- FLAC__IOCallback_Eof eof; /**< See FLAC__IOCallbacks */
- FLAC__IOCallback_Close close; /**< See FLAC__IOCallbacks */
-} FLAC__IOCallbacks;
-
-/* \} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/compat.h b/modules/juce_audio_formats/codecs/flac_143/compat.h
deleted file mode 100644
index 15944fd458..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/compat.h
+++ /dev/null
@@ -1,243 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2012-2023 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.
- */
-
-/* This is the preferred location of all CPP hackery to make $random_compiler
- * work like something approaching a C99 (or maybe more accurately GNU99)
- * compiler.
- *
- * It is assumed that this header will be included after "config.h".
- */
-
-#ifndef FLAC__SHARE__COMPAT_H
-#define FLAC__SHARE__COMPAT_H
-
-#include
-#include
-
-#if defined _WIN32 && !defined __CYGWIN__
-/* where MSVC puts unlink() */
-# include
-#else
-# include
-#endif
-
-#if defined _MSC_VER || defined __BORLANDC__ || defined __MINGW32__
-#include /* for off_t */
-#define FLAC__off_t __int64 /* use this instead of off_t to fix the 2 GB limit */
-#define FLAC__OFF_T_MAX INT64_MAX
-#if !defined __MINGW32__
-#define fseeko _fseeki64
-#define ftello _ftelli64
-#else /* MinGW */
-#if !defined(HAVE_FSEEKO)
-#define fseeko fseeko64
-#define ftello ftello64
-#endif
-#endif
-#else
-#define FLAC__off_t off_t
-#define FLAC__OFF_T_MAX OFF_T_MAX
-#endif
-
-
-
-#ifdef HAVE_INTTYPES_H
-#define __STDC_FORMAT_MACROS
-#include
-#endif
-
-#if defined(_MSC_VER)
-#define strtoll _strtoi64
-#define strtoull _strtoui64
-#endif
-
-#if defined(_MSC_VER) && !defined(__cplusplus)
-#define inline __inline
-#endif
-
-#if defined __INTEL_COMPILER || (defined _MSC_VER && defined _WIN64)
-/* MSVS generates VERY slow 32-bit code with __restrict */
-#define flac_restrict __restrict
-#elif defined __GNUC__
-#define flac_restrict __restrict__
-#else
-#define flac_restrict
-#endif
-
-#define FLAC__U64L(x) x##ULL
-
-#if defined _MSC_VER || defined __MINGW32__
-#define FLAC__STRCASECMP _stricmp
-#define FLAC__STRNCASECMP _strnicmp
-#elif defined __BORLANDC__
-#define FLAC__STRCASECMP stricmp
-#define FLAC__STRNCASECMP strnicmp
-#else
-#define FLAC__STRCASECMP strcasecmp
-#define FLAC__STRNCASECMP strncasecmp
-#endif
-
-#if defined _MSC_VER || defined __MINGW32__ || defined __EMX__
-#include /* for _setmode(), chmod() */
-#include /* for _O_BINARY */
-#else
-#include /* for chown(), unlink() */
-#endif
-
-#if defined _MSC_VER || defined __BORLANDC__ || defined __MINGW32__
-#if defined __BORLANDC__
-#include /* for utime() */
-#else
-#include /* for utime() */
-#endif
-#else
-#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L)
-#include
-#else
-#include /* some flavors of BSD (like OS X) require this to get time_t */
-#include /* for utime() */
-#endif
-#endif
-
-#if defined _MSC_VER
-# if _MSC_VER >= 1800
-# include
-# elif _MSC_VER >= 1600
-/* Visual Studio 2010 has decent C99 support */
-# include
-# define PRIu64 "llu"
-# define PRId64 "lld"
-# define PRIx64 "llx"
-# else
-# include
-# ifndef UINT32_MAX
-# define UINT32_MAX _UI32_MAX
-# endif
-# define PRIu64 "I64u"
-# define PRId64 "I64d"
-# define PRIx64 "I64x"
-# endif
-# if defined(_USING_V110_SDK71_) && !defined(_DLL)
-# pragma message("WARNING: This compile will NOT FUNCTION PROPERLY on Windows XP. See comments in include/share/compat.h for details")
-#define FLAC__USE_FILELENGTHI64
-/*
- *************************************************************************************
- * V110_SDK71, in MSVC 2017 also known as v141_xp, is a platform toolset that is supposed
- * to target Windows XP. It turns out however that certain functions provided silently fail
- * on Windows XP only, which makes debugging challenging. This only occurs when building with
- * /MT. This problem has been reported to Microsoft, but there hasn't been a fix for years. See
- * https://web.archive.org/web/20170327195018/https://connect.microsoft.com/VisualStudio/feedback/details/1557168/wstat64-returns-1-on-xp-always
- *
- * It is known that this problem affects the functions _wstat64 (used by flac_stat i.e.
- * stat64_utf8) and _fstat64 (i.e. flac_fstat) and therefore affects both libFLAC in
- * several places as well as the flac and metaflac command line tools
- *
- * As the extent of this problem is unknown and Microsoft seems unwilling to fix it,
- * users of libFLAC building with Visual Studio are encouraged to not use the /MT compile
- * switch when explicitly targeting Windows XP. When use of /MT is deemed necessary with
- * this toolset, be sure to check whether your application works properly on Windows XP.
- * It is also possible to build for Windows XP with MinGW instead.
- *************************************************************************************
-*/
-# endif
-#endif /* defined _MSC_VER */
-
-#ifdef _WIN32
-/* All char* strings are in UTF-8 format. Added to support Unicode files on Windows */
-
-#if 0
-#include "win_utf8_io.h"
-#define flac_printf printf_utf8
-#define flac_fprintf fprintf_utf8
-#define flac_vfprintf vfprintf_utf8
-#endif
-
-#define flac_fopen fopen_utf8
-#define flac_chmod chmod_utf8
-#define flac_utime utime_utf8
-#define flac_unlink unlink_utf8
-#define flac_rename rename_utf8
-#define flac_stat stat64_utf8
-
-#else
-
-#define flac_printf printf
-#define flac_fprintf fprintf
-#define flac_vfprintf vfprintf
-
-#define flac_fopen fopen
-#define flac_chmod chmod
-#define flac_unlink unlink
-#define flac_rename rename
-#define flac_stat stat
-
-#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L)
-#define flac_utime(a, b) utimensat (AT_FDCWD, a, *b, 0)
-#else
-#define flac_utime utime
-#endif
-#endif
-
-#ifdef _WIN32
-#define flac_stat_s __stat64 /* stat struct */
-#define flac_fstat _fstat64
-#else
-#define flac_stat_s stat /* stat struct */
-#define flac_fstat fstat
-#endif
-
-#ifdef ANDROID
-#include
-#endif
-
-#ifndef M_LN2
-#define M_LN2 0.69314718055994530942
-#endif
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-/* FLAC needs to compile and work correctly on systems with a normal ISO C99
- * snprintf as well as Microsoft Visual Studio which has an non-standards
- * conformant snprint_s function.
- *
- * This function wraps the MS version to behave more like the ISO version.
- */
-#ifdef __cplusplus
-extern "C" {
-#endif
-int flac_snprintf(char *str, size_t size, const char *fmt, ...);
-int flac_vsnprintf(char *str, size_t size, const char *fmt, va_list va);
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* FLAC__SHARE__COMPAT_H */
diff --git a/modules/juce_audio_formats/codecs/flac_143/endswap.h b/modules/juce_audio_formats/codecs/flac_143/endswap.h
deleted file mode 100644
index d11ea3d067..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/endswap.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2012-2023 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.
- */
-
-/* It is assumed that this header will be included after "config.h". */
-
-#ifdef HAVE_BSWAP32 /* GCC and Clang */
-
-/* GCC prior to 4.8 didn't provide bswap16 on x86_64 */
-#ifndef HAVE_BSWAP16
-static inline unsigned short __builtin_bswap16(unsigned short a)
-{
- return (a<<8)|(a>>8);
-}
-#endif
-
-#define ENDSWAP_16(x) (__builtin_bswap16 (x))
-#define ENDSWAP_32(x) (__builtin_bswap32 (x))
-#define ENDSWAP_64(x) (__builtin_bswap64 (x))
-
-#elif defined _MSC_VER /* Windows */
-
-#include
-
-#define ENDSWAP_16(x) (_byteswap_ushort (x))
-#define ENDSWAP_32(x) (_byteswap_ulong (x))
-#define ENDSWAP_64(x) (_byteswap_uint64 (x))
-
-#elif defined HAVE_BYTESWAP_H /* Linux */
-
-#include
-
-#define ENDSWAP_16(x) (bswap_16 (x))
-#define ENDSWAP_32(x) (bswap_32 (x))
-#define ENDSWAP_64(x) (bswap_64 (x))
-
-#else
-
-#define ENDSWAP_16(x) ((((x) >> 8) & 0xFF) | (((x) & 0xFF) << 8))
-#define ENDSWAP_32(x) ((((x) >> 24) & 0xFF) | (((x) >> 8) & 0xFF00) | (((x) & 0xFF00) << 8) | (((x) & 0xFF) << 24))
-#define ENDSWAP_64(x) ((ENDSWAP_32(((x) >> 32) & 0xFFFFFFFF)) | (ENDSWAP_32((x) & 0xFFFFFFFF) << 32))
-
-#endif
-
-
-/* Host to little-endian byte swapping (for MD5 calculation) */
-#if CPU_IS_BIG_ENDIAN
-
-#define H2LE_16(x) ENDSWAP_16 (x)
-#define H2LE_32(x) ENDSWAP_32 (x)
-
-#else
-
-#define H2LE_16(x) (x)
-#define H2LE_32(x) (x)
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/export.h b/modules/juce_audio_formats/codecs/flac_143/export.h
deleted file mode 100644
index 5ce224eeb6..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/export.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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 for Windows (with Visual Studio or MinGW for
- * example) 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.
- *
- * \{
- */
-
-/** This \#define is used internally in libFLAC and its headers to make
- * sure the correct symbols are exported when working with shared
- * libraries. On Windows, this \#define is set to __declspec(dllexport)
- * when compiling libFLAC into a library and to __declspec(dllimport)
- * when the headers are used to link to that DLL. On non-Windows systems
- * it is used to set symbol visibility.
- *
- * Because of this, the define FLAC__NO_DLL must be defined when linking
- * to libFLAC statically or linking will fail.
- */
-/* This has grown quite complicated. FLAC__NO_DLL is used by MSVC sln
- * files and CMake, which build either static or shared. autotools can
- * build static, shared or **both**. Therefore, DLL_EXPORT, which is set
- * by libtool, must override FLAC__NO_DLL on building shared components
- */
-#if defined(_WIN32)
-
-#if defined(FLAC__NO_DLL) && !(defined(DLL_EXPORT))
-#define FLAC_API
-#else
-#ifdef FLAC_API_EXPORTS
-#define FLAC_API __declspec(dllexport)
-#else
-#define FLAC_API __declspec(dllimport)
-#endif
-#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 13
-#define FLAC_API_VERSION_REVISION 0 /**< see above */
-#define FLAC_API_VERSION_AGE 1 /**< 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/modules/juce_audio_formats/codecs/flac_143/format.h b/modules/juce_audio_formats/codecs/flac_143/format.h
deleted file mode 100644
index ca8d8fcf2d..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/format.h
+++ /dev/null
@@ -1,1032 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- *
- * FLAC__MAX_BITS_PER_SAMPLE is the limit of the FLAC format. However,
- * the reference encoder/decoder used to be limited to 24 bits. This
- * value was used to signal that limit.
- */
-#define FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE (32u)
-
-/** The maximum sample rate permitted by the format. The value is
- * ((2 ^ 20) - 1)
- */
-#define FLAC__MAX_SAMPLE_RATE (1048575u)
-
-/** 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 uint32_t FLAC__STREAM_SYNC; /* = 0x664C6143 */
-
-/** The length of the FLAC signature in bits. */
-extern FLAC_API const uint32_t 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 {
-
- uint32_t *parameters;
- /**< The Rice parameters for each context. */
-
- uint32_t *raw_bits;
- /**< Widths for escape-coded partitions. Will be non-zero for escaped
- * partitions and zero for unescaped partitions.
- */
-
- uint32_t 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 {
-
- uint32_t 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 uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; /**< == 4 (bits) */
-extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; /**< == 4 (bits) */
-extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN; /**< == 5 (bits) */
-extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN; /**< == 5 (bits) */
-
-extern FLAC_API const uint32_t 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 uint32_t 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__int64 value; /**< The constant signal value. */
-} FLAC__Subframe_Constant;
-
-/** An enumeration of the possible verbatim subframe data types. */
-typedef enum {
- FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32, /**< verbatim subframe has 32-bit int */
- FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64 /**< verbatim subframe has 64-bit int */
-} FLAC__VerbatimSubframeDataType;
-
-
-/** VERBATIM subframe. (c.f. format specification)
- */
-typedef struct {
- union {
- const FLAC__int32 *int32; /**< A FLAC__int32 pointer to verbatim signal. */
- const FLAC__int64 *int64; /**< A FLAC__int64 pointer to verbatim signal. */
- } data;
- FLAC__VerbatimSubframeDataType data_type;
-} FLAC__Subframe_Verbatim;
-
-
-/** FIXED subframe. (c.f. format specification)
- */
-typedef struct {
- FLAC__EntropyCodingMethod entropy_coding_method;
- /**< The residual coding method. */
-
- uint32_t order;
- /**< The polynomial order. */
-
- FLAC__int64 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. */
-
- uint32_t order;
- /**< The FIR order. */
-
- uint32_t 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__int64 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 uint32_t FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN; /**< == 4 (bits) */
-extern FLAC_API const uint32_t 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;
- uint32_t 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 uint32_t FLAC__SUBFRAME_ZERO_PAD_LEN;
-extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_LEN; /**< == 6 (bits) */
-extern FLAC_API const uint32_t FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN; /**< == 1 (bit) */
-
-extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK; /**< = 0x00 */
-extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK; /**< = 0x02 */
-extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK; /**< = 0x10 */
-extern FLAC_API const uint32_t 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 {
- uint32_t blocksize;
- /**< The number of samples per subframe. */
-
- uint32_t sample_rate;
- /**< The sample rate in Hz. */
-
- uint32_t channels;
- /**< The number of channels (== number of subframes). */
-
- FLAC__ChannelAssignment channel_assignment;
- /**< The channel assignment for the frame. */
-
- uint32_t 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 uint32_t FLAC__FRAME_HEADER_SYNC; /**< == 0x3ffe; the frame header sync code */
-extern FLAC_API const uint32_t FLAC__FRAME_HEADER_SYNC_LEN; /**< == 14 (bits) */
-extern FLAC_API const uint32_t FLAC__FRAME_HEADER_RESERVED_LEN; /**< == 1 (bits) */
-extern FLAC_API const uint32_t FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN; /**< == 1 (bits) */
-extern FLAC_API const uint32_t FLAC__FRAME_HEADER_BLOCK_SIZE_LEN; /**< == 4 (bits) */
-extern FLAC_API const uint32_t FLAC__FRAME_HEADER_SAMPLE_RATE_LEN; /**< == 4 (bits) */
-extern FLAC_API const uint32_t FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN; /**< == 4 (bits) */
-extern FLAC_API const uint32_t FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN; /**< == 3 (bits) */
-extern FLAC_API const uint32_t FLAC__FRAME_HEADER_ZERO_PAD_LEN; /**< == 1 (bit) */
-extern FLAC_API const uint32_t 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 uint32_t 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__MAX_METADATA_TYPE = FLAC__MAX_METADATA_TYPE_CODE,
- /**< No type will ever be greater than this. There is not enough room in the protocol block. */
-} 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 {
- uint32_t min_blocksize, max_blocksize;
- uint32_t min_framesize, max_framesize;
- uint32_t sample_rate;
- uint32_t channels;
- uint32_t bits_per_sample;
- FLAC__uint64 total_samples;
- FLAC__byte md5sum[16];
-} FLAC__StreamMetadata_StreamInfo;
-
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN; /**< == 16 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN; /**< == 16 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN; /**< == 24 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN; /**< == 24 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN; /**< == 20 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN; /**< == 3 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN; /**< == 5 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN; /**< == 36 (bits) */
-extern FLAC_API const uint32_t 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 uint32_t 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. */
-
- uint32_t frame_samples;
- /**< The number of samples in the target frame. */
-} FLAC__StreamMetadata_SeekPoint;
-
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN; /**< == 64 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN; /**< == 64 (bits) */
-extern FLAC_API const uint32_t 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 {
- uint32_t 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 uint32_t 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 uint32_t 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 uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN; /**< == 64 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN; /**< == 8 (bits) */
-extern FLAC_API const uint32_t 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 */
-
- uint32_t type:1;
- /**< The track type: 0 for audio, 1 for non-audio. */
-
- uint32_t 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 uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN; /**< == 64 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN; /**< == 8 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN; /**< == 12*8 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN; /**< == 1 (bit) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN; /**< == 1 (bit) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN; /**< == 6+13*8 (bits) */
-extern FLAC_API const uint32_t 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. */
-
- uint32_t 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 uint32_t FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN; /**< == 128*8 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN; /**< == 64 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN; /**< == 1 (bit) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN; /**< == 7+258*8 (bits) */
-extern FLAC_API const uint32_t 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 uint32_t FLAC__STREAM_METADATA_PICTURE_TYPE_LEN; /**< == 32 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN; /**< == 32 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN; /**< == 32 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN; /**< == 32 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN; /**< == 32 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN; /**< == 32 (bits) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_COLORS_LEN; /**< == 32 (bits) */
-extern FLAC_API const uint32_t 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__StreamMetadata {
- 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 */
-
- uint32_t 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 uint32_t FLAC__STREAM_METADATA_IS_LAST_LEN; /**< == 1 (bit) */
-extern FLAC_API const uint32_t FLAC__STREAM_METADATA_TYPE_LEN; /**< == 7 (bits) */
-extern FLAC_API const uint32_t 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(uint32_t 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(uint32_t blocksize, uint32_t 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(uint32_t 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 (uint32_t)(-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, uint32_t 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, uint32_t 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 uint32_t
- * The number of duplicate seek points converted into placeholders.
- */
-FLAC_API uint32_t 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/modules/juce_audio_formats/codecs/flac_143/libFLAC/bitmath.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/bitmath.c
deleted file mode 100644
index 5c63fa23b1..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/bitmath.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2001-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include "include/private/bitmath.h"
-
-/* An example of what FLAC__bitmath_silog2() computes:
- *
- * silog2(-10) = 5
- * silog2(- 9) = 5
- * silog2(- 8) = 4
- * silog2(- 7) = 4
- * silog2(- 6) = 4
- * silog2(- 5) = 4
- * silog2(- 4) = 3
- * silog2(- 3) = 3
- * silog2(- 2) = 2
- * silog2(- 1) = 2
- * silog2( 0) = 0
- * silog2( 1) = 2
- * silog2( 2) = 3
- * silog2( 3) = 3
- * silog2( 4) = 4
- * silog2( 5) = 4
- * silog2( 6) = 4
- * silog2( 7) = 4
- * silog2( 8) = 5
- * silog2( 9) = 5
- * silog2( 10) = 5
- */
-uint32_t FLAC__bitmath_silog2(FLAC__int64 v)
-{
- if(v == 0)
- return 0;
-
- if(v == -1)
- return 2;
-
- v = (v < 0) ? (-(v+1)) : v;
- return FLAC__bitmath_ilog2_wide(v)+2;
-}
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/bitreader.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/bitreader.c
deleted file mode 100644
index b79c8bca64..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/bitreader.c
+++ /dev/null
@@ -1,1052 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include
-#include
-#include "include/private/bitmath.h"
-#include "include/private/bitreader.h"
-#include "include/private/crc.h"
-#include "include/private/cpu.h"
-
-#include "../assert.h"
-#include "../compat.h"
-#include "../endswap.h"
-
-/* Things should be fastest when this matches the machine word size */
-/* WATCHOUT: if you change this you must also change the following #defines down to COUNT_ZERO_MSBS2 below to match */
-/* WATCHOUT: there are a few places where the code will not work unless brword is >= 32 bits wide */
-/* also, some sections currently only have fast versions for 4 or 8 bytes per word */
-
-#if (ENABLE_64_BIT_WORDS == 0)
-
-typedef FLAC__uint32 brword;
-#define FLAC__BYTES_PER_WORD 4 /* sizeof brword */
-#define FLAC__BITS_PER_WORD 32
-#define FLAC__WORD_ALL_ONES ((FLAC__uint32)0xffffffff)
-/* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */
-#if WORDS_BIGENDIAN
-#define SWAP_BE_WORD_TO_HOST(x) (x)
-#else
-#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_32(x)
-#endif
-/* counts the # of zero MSBs in a word */
-#define COUNT_ZERO_MSBS(word) FLAC__clz_uint32(word)
-#define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint32(word)
-
-#else
-
-typedef FLAC__uint64 brword;
-#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */
-#define FLAC__BITS_PER_WORD 64
-#define FLAC__WORD_ALL_ONES ((FLAC__uint64)FLAC__U64L(0xffffffffffffffff))
-/* SWAP_BE_WORD_TO_HOST swaps bytes in a brword (which is always big-endian) if necessary to match host byte order */
-#if WORDS_BIGENDIAN
-#define SWAP_BE_WORD_TO_HOST(x) (x)
-#else
-#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x)
-#endif
-/* counts the # of zero MSBs in a word */
-#define COUNT_ZERO_MSBS(word) FLAC__clz_uint64(word)
-#define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint64(word)
-
-#endif
-
-/*
- * This should be at least twice as large as the largest number of words
- * required to represent any 'number' (in any encoding) you are going to
- * read. With FLAC this is on the order of maybe a few hundred bits.
- * If the buffer is smaller than that, the decoder won't be able to read
- * in a whole number that is in a variable length encoding (e.g. Rice).
- * But to be practical it should be at least 1K bytes.
- *
- * Increase this number to decrease the number of read callbacks, at the
- * expense of using more memory. Or decrease for the reverse effect,
- * keeping in mind the limit from the first paragraph. The optimal size
- * also depends on the CPU cache size and other factors; some twiddling
- * may be necessary to squeeze out the best performance.
- */
-static const uint32_t FLAC__BITREADER_DEFAULT_CAPACITY = 65536u / FLAC__BITS_PER_WORD; /* in words */
-
-struct FLAC__BitReader {
- /* any partially-consumed word at the head will stay right-justified as bits are consumed from the left */
- /* any incomplete word at the tail will be left-justified, and bytes from the read callback are added on the right */
- brword *buffer;
- uint32_t capacity; /* in words */
- uint32_t words; /* # of completed words in buffer */
- uint32_t bytes; /* # of bytes in incomplete word at buffer[words] */
- uint32_t consumed_words; /* #words ... */
- uint32_t consumed_bits; /* ... + (#bits of head word) already consumed from the front of buffer */
- uint32_t read_crc16; /* the running frame CRC */
- uint32_t crc16_offset; /* the number of words in the current buffer that should not be CRC'd */
- uint32_t crc16_align; /* the number of bits in the current consumed word that should not be CRC'd */
- FLAC__bool read_limit_set; /* whether reads are limited */
- uint32_t read_limit; /* the remaining size of what can be read */
- uint32_t last_seen_framesync; /* the location of the last seen framesync, if it is in the buffer, in bits from front of buffer */
- FLAC__BitReaderReadCallback read_callback;
- void *client_data;
-};
-
-static inline void crc16_update_word_(FLAC__BitReader *br, brword word)
-{
- uint32_t crc = br->read_crc16;
-
- for ( ; br->crc16_align < FLAC__BITS_PER_WORD ; br->crc16_align += 8) {
- uint32_t shift = FLAC__BITS_PER_WORD - 8 - br->crc16_align ;
- crc = FLAC__CRC16_UPDATE ((uint32_t) (shift < FLAC__BITS_PER_WORD ? (word >> shift) & 0xff : 0), crc);
- }
-
- br->read_crc16 = crc;
- br->crc16_align = 0;
-}
-
-static inline void crc16_update_block_(FLAC__BitReader *br)
-{
- if(br->consumed_words > br->crc16_offset && br->crc16_align)
- crc16_update_word_(br, br->buffer[br->crc16_offset++]);
-
- /* Prevent OOB read due to wrap-around. */
- if (br->consumed_words > br->crc16_offset) {
-#if FLAC__BYTES_PER_WORD == 4
- br->read_crc16 = FLAC__crc16_update_words32(br->buffer + br->crc16_offset, br->consumed_words - br->crc16_offset, br->read_crc16);
-#elif FLAC__BYTES_PER_WORD == 8
- br->read_crc16 = FLAC__crc16_update_words64(br->buffer + br->crc16_offset, br->consumed_words - br->crc16_offset, br->read_crc16);
-#else
- unsigned i;
-
- for (i = br->crc16_offset; i < br->consumed_words; i++)
- crc16_update_word_(br, br->buffer[i]);
-#endif
- }
-
- br->crc16_offset = 0;
-}
-
-static FLAC__bool bitreader_read_from_client_(FLAC__BitReader *br)
-{
- uint32_t start, end;
- size_t bytes;
- FLAC__byte *target;
-#if WORDS_BIGENDIAN
-#else
- brword preswap_backup;
-#endif
-
- /* first shift the unconsumed buffer data toward the front as much as possible */
- if(br->consumed_words > 0) {
- /* invalidate last seen framesync */
- br->last_seen_framesync = (uint32_t) -1;
-
- crc16_update_block_(br); /* CRC consumed words */
-
- start = br->consumed_words;
- end = br->words + (br->bytes? 1:0);
- memmove(br->buffer, br->buffer+start, FLAC__BYTES_PER_WORD * (end - start));
-
- br->words -= start;
- br->consumed_words = 0;
- }
-
- /*
- * set the target for reading, taking into account word alignment and endianness
- */
- bytes = (br->capacity - br->words) * FLAC__BYTES_PER_WORD - br->bytes;
- if(bytes == 0)
- return false; /* no space left, buffer is too small; see note for FLAC__BITREADER_DEFAULT_CAPACITY */
- target = ((FLAC__byte*)(br->buffer+br->words)) + br->bytes;
-
- /* before reading, if the existing reader looks like this (say brword is 32 bits wide)
- * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1 (partial tail word is left-justified)
- * buffer[BE]: 11 22 33 44 55 ?? ?? ?? (shown laid out as bytes sequentially in memory)
- * buffer[LE]: 44 33 22 11 ?? ?? ?? 55 (?? being don't-care)
- * ^^-------target, bytes=3
- * on LE machines, have to byteswap the odd tail word so nothing is
- * overwritten:
- */
-#if WORDS_BIGENDIAN
-#else
- preswap_backup = br->buffer[br->words];
- if(br->bytes)
- br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]);
-#endif
-
- /* now it looks like:
- * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1
- * buffer[BE]: 11 22 33 44 55 ?? ?? ??
- * buffer[LE]: 44 33 22 11 55 ?? ?? ??
- * ^^-------target, bytes=3
- */
-
- /* read in the data; note that the callback may return a smaller number of bytes */
- if(!br->read_callback(target, &bytes, br->client_data)){
- /* Despite the read callback failing, the data in the target
- * might be used later, when the buffer is rewound. Therefore
- * we revert the swap that was just done */
-#if WORDS_BIGENDIAN
-#else
- br->buffer[br->words] = preswap_backup;
-#endif
- return false;
- }
-
- /* after reading bytes 66 77 88 99 AA BB CC DD EE FF from the client:
- * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
- * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
- * buffer[LE]: 44 33 22 11 55 66 77 88 99 AA BB CC DD EE FF ??
- * now have to byteswap on LE machines:
- */
-#if WORDS_BIGENDIAN
-#else
- end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + (uint32_t)bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD;
- for(start = br->words; start < end; start++)
- br->buffer[start] = SWAP_BE_WORD_TO_HOST(br->buffer[start]);
-#endif
-
- /* now it looks like:
- * bitstream : 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
- * buffer[BE]: 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF ??
- * buffer[LE]: 44 33 22 11 88 77 66 55 CC BB AA 99 ?? FF EE DD
- * finally we'll update the reader values:
- */
- end = br->words*FLAC__BYTES_PER_WORD + br->bytes + (uint32_t)bytes;
- br->words = end / FLAC__BYTES_PER_WORD;
- br->bytes = end % FLAC__BYTES_PER_WORD;
-
- return true;
-}
-
-/***********************************************************************
- *
- * Class constructor/destructor
- *
- ***********************************************************************/
-
-FLAC__BitReader *FLAC__bitreader_new(void)
-{
- FLAC__BitReader *br = (FLAC__BitReader*) calloc(1, sizeof(FLAC__BitReader));
-
- /* calloc() implies:
- memset(br, 0, sizeof(FLAC__BitReader));
- br->buffer = 0;
- br->capacity = 0;
- br->words = br->bytes = 0;
- br->consumed_words = br->consumed_bits = 0;
- br->read_callback = 0;
- br->client_data = 0;
- */
- return br;
-}
-
-void FLAC__bitreader_delete(FLAC__BitReader *br)
-{
- FLAC__ASSERT(0 != br);
-
- FLAC__bitreader_free(br);
- free(br);
-}
-
-/***********************************************************************
- *
- * Public class methods
- *
- ***********************************************************************/
-
-FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__BitReaderReadCallback rcb, void *cd)
-{
- FLAC__ASSERT(0 != br);
-
- br->words = br->bytes = 0;
- br->consumed_words = br->consumed_bits = 0;
- br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY;
- br->buffer = (brword*) malloc(sizeof(brword) * br->capacity);
- if(br->buffer == 0)
- return false;
- br->read_callback = rcb;
- br->client_data = cd;
- br->read_limit_set = false;
- br->read_limit = (uint32_t) -1;
- br->last_seen_framesync = (uint32_t) -1;
-
- return true;
-}
-
-void FLAC__bitreader_free(FLAC__BitReader *br)
-{
- FLAC__ASSERT(0 != br);
-
- if(0 != br->buffer)
- free(br->buffer);
- br->buffer = 0;
- br->capacity = 0;
- br->words = br->bytes = 0;
- br->consumed_words = br->consumed_bits = 0;
- br->read_callback = 0;
- br->client_data = 0;
- br->read_limit_set = false;
- br->read_limit = (uint32_t) -1;
- br->last_seen_framesync = (uint32_t) -1;
-}
-
-FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br)
-{
- br->words = br->bytes = 0;
- br->consumed_words = br->consumed_bits = 0;
- br->read_limit_set = false;
- br->read_limit = (uint32_t) -1;
- br->last_seen_framesync = (uint32_t) -1;
- return true;
-}
-
-void FLAC__bitreader_set_framesync_location(FLAC__BitReader *br)
-{
- br->last_seen_framesync = br->consumed_words * FLAC__BYTES_PER_WORD + br->consumed_bits / 8;
-}
-
-FLAC__bool FLAC__bitreader_rewind_to_after_last_seen_framesync(FLAC__BitReader *br)
-{
- if(br->last_seen_framesync == (uint32_t)-1) {
- br->consumed_words = br->consumed_bits = 0;
- return false;
- }
- else {
- br->consumed_words = (br->last_seen_framesync + 1) / FLAC__BYTES_PER_WORD;
- br->consumed_bits = ((br->last_seen_framesync + 1) % FLAC__BYTES_PER_WORD) * 8;
- return true;
- }
-}
-
-void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed)
-{
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
- FLAC__ASSERT((br->consumed_bits & 7) == 0);
-
- br->read_crc16 = (uint32_t)seed;
- br->crc16_offset = br->consumed_words;
- br->crc16_align = br->consumed_bits;
-}
-
-FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br)
-{
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
-
- /* CRC consumed words up to here */
- crc16_update_block_(br);
-
- FLAC__ASSERT((br->consumed_bits & 7) == 0);
- FLAC__ASSERT(br->crc16_align <= br->consumed_bits);
-
- /* CRC any tail bytes in a partially-consumed word */
- if(br->consumed_bits) {
- const brword tail = br->buffer[br->consumed_words];
- for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8)
- br->read_crc16 = FLAC__CRC16_UPDATE((uint32_t)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16);
- }
- return br->read_crc16;
-}
-
-inline FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)
-{
- return ((br->consumed_bits & 7) == 0);
-}
-
-inline uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)
-{
- return 8 - (br->consumed_bits & 7);
-}
-
-inline uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)
-{
- return (br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits;
-}
-
-void FLAC__bitreader_set_limit(FLAC__BitReader *br, uint32_t limit)
-{
- br->read_limit = limit;
- br->read_limit_set = true;
-}
-
-void FLAC__bitreader_remove_limit(FLAC__BitReader *br)
-{
- br->read_limit_set = false;
- br->read_limit = (uint32_t) -1;
-}
-
-uint32_t FLAC__bitreader_limit_remaining(FLAC__BitReader *br)
-{
- FLAC__ASSERT(br->read_limit_set);
- return br->read_limit;
-}
-void FLAC__bitreader_limit_invalidate(FLAC__BitReader *br)
-{
- br->read_limit = (uint32_t) -1;
-}
-
-FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, uint32_t bits)
-{
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
-
- FLAC__ASSERT(bits <= 32);
- FLAC__ASSERT((br->capacity*FLAC__BITS_PER_WORD) * 2 >= bits);
- FLAC__ASSERT(br->consumed_words <= br->words);
-
- /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
- FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
-
- if(bits == 0) { /* OPT: investigate if this can ever happen, maybe change to assertion */
- *val = 0;
- return true;
- }
-
- if(br->read_limit_set && br->read_limit < (uint32_t)-1){
- if(br->read_limit < bits) {
- br->read_limit = (uint32_t) -1;
- return false;
- }
- else
- br->read_limit -= bits;
- }
-
- while((br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits < bits) {
- if(!bitreader_read_from_client_(br))
- return false;
- }
- if(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
- /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
- if(br->consumed_bits) {
- /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
- const uint32_t n = FLAC__BITS_PER_WORD - br->consumed_bits;
- const brword word = br->buffer[br->consumed_words];
- const brword mask = br->consumed_bits < FLAC__BITS_PER_WORD ? FLAC__WORD_ALL_ONES >> br->consumed_bits : 0;
- if(bits < n) {
- uint32_t shift = n - bits;
- *val = shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)((word & mask) >> shift) : 0; /* The result has <= 32 non-zero bits */
- br->consumed_bits += bits;
- return true;
- }
- /* (FLAC__BITS_PER_WORD - br->consumed_bits <= bits) ==> (FLAC__WORD_ALL_ONES >> br->consumed_bits) has no more than 'bits' non-zero bits */
- *val = (FLAC__uint32)(word & mask);
- bits -= n;
- br->consumed_words++;
- br->consumed_bits = 0;
- if(bits) { /* if there are still bits left to read, there have to be less than 32 so they will all be in the next word */
- uint32_t shift = FLAC__BITS_PER_WORD - bits;
- *val = bits < 32 ? *val << bits : 0;
- *val |= shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)(br->buffer[br->consumed_words] >> shift) : 0;
- br->consumed_bits = bits;
- }
- return true;
- }
- else { /* br->consumed_bits == 0 */
- const brword word = br->buffer[br->consumed_words];
- if(bits < FLAC__BITS_PER_WORD) {
- *val = (FLAC__uint32)(word >> (FLAC__BITS_PER_WORD-bits));
- br->consumed_bits = bits;
- return true;
- }
- /* at this point bits == FLAC__BITS_PER_WORD == 32; because of previous assertions, it can't be larger */
- *val = (FLAC__uint32)word;
- br->consumed_words++;
- return true;
- }
- }
- else {
- /* in this case we're starting our read at a partial tail word;
- * the reader has guaranteed that we have at least 'bits' bits
- * available to read, which makes this case simpler.
- */
- /* OPT: taking out the consumed_bits==0 "else" case below might make things faster if less code allows the compiler to inline this function */
- if(br->consumed_bits) {
- /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */
- FLAC__ASSERT(br->consumed_bits + bits <= br->bytes*8);
- *val = (FLAC__uint32)((br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits));
- br->consumed_bits += bits;
- return true;
- }
- else {
- *val = (FLAC__uint32)(br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits));
- br->consumed_bits += bits;
- return true;
- }
- }
-}
-
-FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, uint32_t bits)
-{
- FLAC__uint32 uval, mask;
- /* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */
- if (bits < 1 || ! FLAC__bitreader_read_raw_uint32(br, &uval, bits))
- return false;
- /* sign-extend *val assuming it is currently bits wide. */
- /* From: https://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend */
- mask = bits >= 33 ? 0 : 1lu << (bits - 1);
- *val = (uval ^ mask) - mask;
- return true;
-}
-
-FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, uint32_t bits)
-{
- FLAC__uint32 hi, lo;
-
- if(bits > 32) {
- if(!FLAC__bitreader_read_raw_uint32(br, &hi, bits-32))
- return false;
- if(!FLAC__bitreader_read_raw_uint32(br, &lo, 32))
- return false;
- *val = hi;
- *val <<= 32;
- *val |= lo;
- }
- else {
- if(!FLAC__bitreader_read_raw_uint32(br, &lo, bits))
- return false;
- *val = lo;
- }
- return true;
-}
-
-FLAC__bool FLAC__bitreader_read_raw_int64(FLAC__BitReader *br, FLAC__int64 *val, uint32_t bits)
-{
- FLAC__uint64 uval, mask;
- /* OPT: inline raw uint64 code here, or make into a macro if possible in the .h file */
- if (bits < 1 || ! FLAC__bitreader_read_raw_uint64(br, &uval, bits))
- return false;
- /* sign-extend *val assuming it is currently bits wide. */
- /* From: https://graphics.stanford.edu/~seander/bithacks.html#FixedSignExtend */
- mask = bits >= 65 ? 0 : 1llu << (bits - 1);
- *val = (uval ^ mask) - mask;
- return true;
-}
-
-inline FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)
-{
- FLAC__uint32 x8, x32 = 0;
-
- /* this doesn't need to be that fast as currently it is only used for vorbis comments */
-
- if(!FLAC__bitreader_read_raw_uint32(br, &x32, 8))
- return false;
-
- if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
- return false;
- x32 |= (x8 << 8);
-
- if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
- return false;
- x32 |= (x8 << 16);
-
- if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
- return false;
- x32 |= (x8 << 24);
-
- *val = x32;
- return true;
-}
-
-FLAC__bool FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader *br, uint32_t bits)
-{
- /*
- * OPT: a faster implementation is possible but probably not that useful
- * since this is only called a couple of times in the metadata readers.
- */
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
-
- if(bits > 0) {
- const uint32_t n = br->consumed_bits & 7;
- uint32_t m;
- FLAC__uint32 x;
-
- if(n != 0) {
- m = flac_min(8-n, bits);
- if(!FLAC__bitreader_read_raw_uint32(br, &x, m))
- return false;
- bits -= m;
- }
- m = bits / 8;
- if(m > 0) {
- if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(br, m))
- return false;
- bits %= 8;
- }
- if(bits > 0) {
- if(!FLAC__bitreader_read_raw_uint32(br, &x, bits))
- return false;
- }
- }
-
- return true;
-}
-
-FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, uint32_t nvals)
-{
- FLAC__uint32 x;
-
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
-
- if(br->read_limit_set && br->read_limit < (uint32_t)-1){
- if(br->read_limit < nvals*8){
- br->read_limit = (uint32_t) -1;
- return false;
- }
- }
-
- /* step 1: skip over partial head word to get word aligned */
- while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
- if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
- return false;
- nvals--;
- }
- if(0 == nvals)
- return true;
-
- /* step 2: skip whole words in chunks */
- while(nvals >= FLAC__BYTES_PER_WORD) {
- if(br->consumed_words < br->words) {
- br->consumed_words++;
- nvals -= FLAC__BYTES_PER_WORD;
- if(br->read_limit_set)
- br->read_limit -= FLAC__BITS_PER_WORD;
- }
- else if(!bitreader_read_from_client_(br))
- return false;
- }
- /* step 3: skip any remainder from partial tail bytes */
- while(nvals) {
- if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
- return false;
- nvals--;
- }
-
- return true;
-}
-
-FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, FLAC__byte *val, uint32_t nvals)
-{
- FLAC__uint32 x;
-
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
-
- if(br->read_limit_set && br->read_limit < (uint32_t)-1){
- if(br->read_limit < nvals*8){
- br->read_limit = (uint32_t) -1;
- return false;
- }
- }
-
- /* step 1: read from partial head word to get word aligned */
- while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
- if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
- return false;
- *val++ = (FLAC__byte)x;
- nvals--;
- }
- if(0 == nvals)
- return true;
- /* step 2: read whole words in chunks */
- while(nvals >= FLAC__BYTES_PER_WORD) {
- if(br->consumed_words < br->words) {
- const brword word = br->buffer[br->consumed_words++];
-#if FLAC__BYTES_PER_WORD == 4
- val[0] = (FLAC__byte)(word >> 24);
- val[1] = (FLAC__byte)(word >> 16);
- val[2] = (FLAC__byte)(word >> 8);
- val[3] = (FLAC__byte)word;
-#elif FLAC__BYTES_PER_WORD == 8
- val[0] = (FLAC__byte)(word >> 56);
- val[1] = (FLAC__byte)(word >> 48);
- val[2] = (FLAC__byte)(word >> 40);
- val[3] = (FLAC__byte)(word >> 32);
- val[4] = (FLAC__byte)(word >> 24);
- val[5] = (FLAC__byte)(word >> 16);
- val[6] = (FLAC__byte)(word >> 8);
- val[7] = (FLAC__byte)word;
-#else
- for(x = 0; x < FLAC__BYTES_PER_WORD; x++)
- val[x] = (FLAC__byte)(word >> (8*(FLAC__BYTES_PER_WORD-x-1)));
-#endif
- val += FLAC__BYTES_PER_WORD;
- nvals -= FLAC__BYTES_PER_WORD;
- if(br->read_limit_set)
- br->read_limit -= FLAC__BITS_PER_WORD;
- }
- else if(!bitreader_read_from_client_(br))
- return false;
- }
- /* step 3: read any remainder from partial tail bytes */
- while(nvals) {
- if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
- return false;
- *val++ = (FLAC__byte)x;
- nvals--;
- }
-
- return true;
-}
-
-FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, uint32_t *val)
-#if 0 /* slow but readable version */
-{
- uint32_t bit;
-
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
-
- *val = 0;
- while(1) {
- if(!FLAC__bitreader_read_bit(br, &bit))
- return false;
- if(bit)
- break;
- else
- *val++;
- }
- return true;
-}
-#else
-{
- uint32_t i;
-
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
-
- *val = 0;
- while(1) {
- while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
- brword b = br->consumed_bits < FLAC__BITS_PER_WORD ? br->buffer[br->consumed_words] << br->consumed_bits : 0;
- if(b) {
- i = COUNT_ZERO_MSBS(b);
- *val += i;
- i++;
- br->consumed_bits += i;
- if(br->consumed_bits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(br->consumed_bits == FLAC__BITS_PER_WORD) */
- br->consumed_words++;
- br->consumed_bits = 0;
- }
- return true;
- }
- else {
- *val += FLAC__BITS_PER_WORD - br->consumed_bits;
- br->consumed_words++;
- br->consumed_bits = 0;
- /* didn't find stop bit yet, have to keep going... */
- }
- }
- /* at this point we've eaten up all the whole words; have to try
- * reading through any tail bytes before calling the read callback.
- * this is a repeat of the above logic adjusted for the fact we
- * don't have a whole word. note though if the client is feeding
- * us data a byte at a time (unlikely), br->consumed_bits may not
- * be zero.
- */
- if(br->bytes*8 > br->consumed_bits) {
- const uint32_t end = br->bytes * 8;
- brword b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits;
- if(b) {
- i = COUNT_ZERO_MSBS(b);
- *val += i;
- i++;
- br->consumed_bits += i;
- FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
- return true;
- }
- else {
- *val += end - br->consumed_bits;
- br->consumed_bits = end;
- FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
- /* didn't find stop bit yet, have to keep going... */
- }
- }
- if(!bitreader_read_from_client_(br))
- return false;
- }
-}
-#endif
-
-#if 0 /* unused */
-FLAC__bool FLAC__bitreader_read_rice_signed(FLAC__BitReader *br, int *val, uint32_t parameter)
-{
- FLAC__uint32 lsbs = 0, msbs = 0;
- uint32_t uval;
-
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
- FLAC__ASSERT(parameter <= 31);
-
- /* read the unary MSBs and end bit */
- if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
- return false;
-
- /* read the binary LSBs */
- if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter))
- return false;
-
- /* compose the value */
- uval = (msbs << parameter) | lsbs;
- if(uval & 1)
- *val = -((int)(uval >> 1)) - 1;
- else
- *val = (int)(uval >> 1);
-
- return true;
-}
-#endif
-
-/* this is by far the most heavily used reader call. it ain't pretty but it's fast */
-FLAC__bool FLAC__bitreader_read_rice_signed_block(FLAC__BitReader *br, int vals[], uint32_t nvals, uint32_t parameter)
-#include "deduplication/bitreader_read_rice_signed_block.c"
-
-#ifdef FLAC__BMI2_SUPPORTED
-FLAC__SSE_TARGET("bmi2")
-FLAC__bool FLAC__bitreader_read_rice_signed_block_bmi2(FLAC__BitReader *br, int vals[], uint32_t nvals, uint32_t parameter)
-#include "deduplication/bitreader_read_rice_signed_block.c"
-#endif
-
-#if 0 /* UNUSED */
-FLAC__bool FLAC__bitreader_read_golomb_signed(FLAC__BitReader *br, int *val, uint32_t parameter)
-{
- FLAC__uint32 lsbs = 0, msbs = 0;
- uint32_t bit, uval, k;
-
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
-
- k = FLAC__bitmath_ilog2(parameter);
-
- /* read the unary MSBs and end bit */
- if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
- return false;
-
- /* read the binary LSBs */
- if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
- return false;
-
- if(parameter == 1u<= d) {
- if(!FLAC__bitreader_read_bit(br, &bit))
- return false;
- lsbs <<= 1;
- lsbs |= bit;
- lsbs -= d;
- }
- /* compose the value */
- uval = msbs * parameter + lsbs;
- }
-
- /* unfold uint32_t to signed */
- if(uval & 1)
- *val = -((int)(uval >> 1)) - 1;
- else
- *val = (int)(uval >> 1);
-
- return true;
-}
-
-FLAC__bool FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader *br, uint32_t *val, uint32_t parameter)
-{
- FLAC__uint32 lsbs, msbs = 0;
- uint32_t bit, k;
-
- FLAC__ASSERT(0 != br);
- FLAC__ASSERT(0 != br->buffer);
-
- k = FLAC__bitmath_ilog2(parameter);
-
- /* read the unary MSBs and end bit */
- if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
- return false;
-
- /* read the binary LSBs */
- if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
- return false;
-
- if(parameter == 1u<= d) {
- if(!FLAC__bitreader_read_bit(br, &bit))
- return false;
- lsbs <<= 1;
- lsbs |= bit;
- lsbs -= d;
- }
- /* compose the value */
- *val = msbs * parameter + lsbs;
- }
-
- return true;
-}
-#endif /* UNUSED */
-
-/* on return, if *val == 0xffffffff then the utf-8 sequence was invalid, but the return value will be true */
-FLAC__bool FLAC__bitreader_read_utf8_uint32(FLAC__BitReader *br, FLAC__uint32 *val, FLAC__byte *raw, uint32_t *rawlen)
-{
- FLAC__uint32 v = 0;
- FLAC__uint32 x;
- uint32_t i;
-
- if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
- return false;
- if(raw)
- raw[(*rawlen)++] = (FLAC__byte)x;
- if(!(x & 0x80)) { /* 0xxxxxxx */
- v = x;
- i = 0;
- }
- else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
- v = x & 0x1F;
- i = 1;
- }
- else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
- v = x & 0x0F;
- i = 2;
- }
- else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
- v = x & 0x07;
- i = 3;
- }
- else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
- v = x & 0x03;
- i = 4;
- }
- else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
- v = x & 0x01;
- i = 5;
- }
- else {
- *val = 0xffffffff;
- return true;
- }
- for( ; i; i--) {
- if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
- return false;
- if(raw)
- raw[(*rawlen)++] = (FLAC__byte)x;
- if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
- *val = 0xffffffff;
- return true;
- }
- v <<= 6;
- v |= (x & 0x3F);
- }
- *val = v;
- return true;
-}
-
-/* on return, if *val == 0xffffffffffffffff then the utf-8 sequence was invalid, but the return value will be true */
-FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *val, FLAC__byte *raw, uint32_t *rawlen)
-{
- FLAC__uint64 v = 0;
- FLAC__uint32 x;
- uint32_t i;
-
- if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
- return false;
- if(raw)
- raw[(*rawlen)++] = (FLAC__byte)x;
- if(!(x & 0x80)) { /* 0xxxxxxx */
- v = x;
- i = 0;
- }
- else if(x & 0xC0 && !(x & 0x20)) { /* 110xxxxx */
- v = x & 0x1F;
- i = 1;
- }
- else if(x & 0xE0 && !(x & 0x10)) { /* 1110xxxx */
- v = x & 0x0F;
- i = 2;
- }
- else if(x & 0xF0 && !(x & 0x08)) { /* 11110xxx */
- v = x & 0x07;
- i = 3;
- }
- else if(x & 0xF8 && !(x & 0x04)) { /* 111110xx */
- v = x & 0x03;
- i = 4;
- }
- else if(x & 0xFC && !(x & 0x02)) { /* 1111110x */
- v = x & 0x01;
- i = 5;
- }
- else if(x & 0xFE && !(x & 0x01)) { /* 11111110 */
- v = 0;
- i = 6;
- }
- else {
- *val = FLAC__U64L(0xffffffffffffffff);
- return true;
- }
- for( ; i; i--) {
- if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
- return false;
- if(raw)
- raw[(*rawlen)++] = (FLAC__byte)x;
- if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */
- *val = FLAC__U64L(0xffffffffffffffff);
- return true;
- }
- v <<= 6;
- v |= (x & 0x3F);
- }
- *val = v;
- return true;
-}
-
-/* These functions are declared inline in this file but are also callable as
- * externs from elsewhere.
- * According to the C99 spec, section 6.7.4, simply providing a function
- * prototype in a header file without 'inline' and making the function inline
- * in this file should be sufficient.
- * Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
- * fix that we add extern declarations here.
- */
-extern FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br);
-extern uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br);
-extern uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br);
-extern FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val);
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/bitwriter.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/bitwriter.c
deleted file mode 100644
index 743e6b5ca5..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/bitwriter.c
+++ /dev/null
@@ -1,955 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include
-#include
-#include "include/private/bitwriter.h"
-#include "include/private/crc.h"
-#include "include/private/format.h"
-
-#include "include/private/stream_encoder.h"
-#include "../assert.h"
-#include "../alloc.h"
-#include "../compat.h"
-#include "../endswap.h"
-
-/* Things should be fastest when this matches the machine word size */
-/* WATCHOUT: if you change this you must also change the following #defines down to SWAP_BE_WORD_TO_HOST below to match */
-/* WATCHOUT: there are a few places where the code will not work unless bwword is >= 32 bits wide */
-
-#if (ENABLE_64_BIT_WORDS == 0)
-
-typedef FLAC__uint32 bwword;
-typedef FLAC__uint64 FLAC__bwtemp;
-#define FLAC__BYTES_PER_WORD 4 /* sizeof bwword */
-#define FLAC__BITS_PER_WORD 32
-#define FLAC__TEMP_BITS 64
-#define FLAC__HALF_TEMP_BITS 32
-/* SWAP_BE_WORD_TO_HOST swaps bytes in a bwword (which is always big-endian) if necessary to match host byte order */
-#if WORDS_BIGENDIAN
-#define SWAP_BE_WORD_TO_HOST(x) (x)
-#else
-#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_32(x)
-#endif
-
-#else
-
-typedef FLAC__uint64 bwword;
-typedef FLAC__uint64 FLAC__bwtemp;
-#define FLAC__BYTES_PER_WORD 8 /* sizeof bwword */
-#define FLAC__BITS_PER_WORD 64
-#define FLAC__TEMP_BITS 64
-#define FLAC__HALF_TEMP_BITS 32
-/* SWAP_BE_WORD_TO_HOST swaps bytes in a bwword (which is always big-endian) if necessary to match host byte order */
-#if WORDS_BIGENDIAN
-#define SWAP_BE_WORD_TO_HOST(x) (x)
-#else
-#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x)
-#endif
-
-#endif
-
-/*
- * The default capacity here doesn't matter too much. The buffer always grows
- * to hold whatever is written to it. Usually the encoder will stop adding at
- * a frame or metadata block, then write that out and clear the buffer for the
- * next one.
- */
-static const uint32_t FLAC__BITWRITER_DEFAULT_CAPACITY = 32768u / sizeof(bwword); /* size in words */
-/* When growing, increment 4K at a time */
-static const uint32_t FLAC__BITWRITER_DEFAULT_INCREMENT = 4096u / sizeof(bwword); /* size in words */
-
-#define FLAC__WORDS_TO_BITS(words) ((words) * FLAC__BITS_PER_WORD)
-#define FLAC__TOTAL_BITS(bw) (FLAC__WORDS_TO_BITS((bw)->words) + (bw)->bits)
-
-struct FLAC__BitWriter {
- bwword *buffer;
- bwword accum; /* accumulator; bits are right-justified; when full, accum is appended to buffer */
- uint32_t capacity; /* capacity of buffer in words */
- uint32_t words; /* # of complete words in buffer */
- uint32_t bits; /* # of used bits in accum */
-};
-
-/* * WATCHOUT: The current implementation only grows the buffer. */
-#ifndef __SUNPRO_C
-static
-#endif
-FLAC__bool bitwriter_grow_(FLAC__BitWriter *bw, uint32_t bits_to_add)
-{
- uint32_t new_capacity;
- bwword *new_buffer;
-
- FLAC__ASSERT(0 != bw);
- FLAC__ASSERT(0 != bw->buffer);
-
- /* calculate total words needed to store 'bits_to_add' additional bits */
- new_capacity = bw->words + ((bw->bits + bits_to_add + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD);
-
- /* it's possible (due to pessimism in the growth estimation that
- * leads to this call) that we don't actually need to grow
- */
- if(bw->capacity >= new_capacity)
- return true;
-
- if(new_capacity * sizeof(bwword) > (1u << FLAC__STREAM_METADATA_LENGTH_LEN))
- /* Requested new capacity is larger than the largest possible metadata block,
- * which is also larger than the largest sane framesize. That means something
- * went very wrong somewhere and previous checks failed.
- * To prevent chrashing, give up */
- return false;
-
- /* round up capacity increase to the nearest FLAC__BITWRITER_DEFAULT_INCREMENT */
- if((new_capacity - bw->capacity) % FLAC__BITWRITER_DEFAULT_INCREMENT)
- new_capacity += FLAC__BITWRITER_DEFAULT_INCREMENT - ((new_capacity - bw->capacity) % FLAC__BITWRITER_DEFAULT_INCREMENT);
- /* make sure we got everything right */
- FLAC__ASSERT(0 == (new_capacity - bw->capacity) % FLAC__BITWRITER_DEFAULT_INCREMENT);
- FLAC__ASSERT(new_capacity > bw->capacity);
- FLAC__ASSERT(new_capacity >= bw->words + ((bw->bits + bits_to_add + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD));
-
- new_buffer = (bwword*) safe_realloc_nofree_mul_2op_(bw->buffer, sizeof(bwword), /*times*/new_capacity);
- if(new_buffer == 0)
- return false;
- bw->buffer = new_buffer;
- bw->capacity = new_capacity;
- return true;
-}
-
-
-/***********************************************************************
- *
- * Class constructor/destructor
- *
- ***********************************************************************/
-
-FLAC__BitWriter *FLAC__bitwriter_new(void)
-{
- FLAC__BitWriter *bw = (FLAC__BitWriter*) calloc(1, sizeof(FLAC__BitWriter));
- /* note that calloc() sets all members to 0 for us */
- return bw;
-}
-
-void FLAC__bitwriter_delete(FLAC__BitWriter *bw)
-{
- FLAC__ASSERT(0 != bw);
-
- FLAC__bitwriter_free(bw);
- free(bw);
-}
-
-/***********************************************************************
- *
- * Public class methods
- *
- ***********************************************************************/
-
-FLAC__bool FLAC__bitwriter_init(FLAC__BitWriter *bw)
-{
- FLAC__ASSERT(0 != bw);
-
- bw->words = bw->bits = 0;
- bw->capacity = FLAC__BITWRITER_DEFAULT_CAPACITY;
- bw->buffer = (bwword*) malloc(sizeof(bwword) * bw->capacity);
- if(bw->buffer == 0)
- return false;
-
- return true;
-}
-
-void FLAC__bitwriter_free(FLAC__BitWriter *bw)
-{
- FLAC__ASSERT(0 != bw);
-
- if(0 != bw->buffer)
- free(bw->buffer);
- bw->buffer = 0;
- bw->capacity = 0;
- bw->words = bw->bits = 0;
-}
-
-void FLAC__bitwriter_clear(FLAC__BitWriter *bw)
-{
- bw->words = bw->bits = 0;
-}
-
-FLAC__bool FLAC__bitwriter_get_write_crc16(FLAC__BitWriter *bw, FLAC__uint16 *crc)
-{
- const FLAC__byte *buffer;
- size_t bytes;
-
- FLAC__ASSERT((bw->bits & 7) == 0); /* assert that we're byte-aligned */
-
- if(!FLAC__bitwriter_get_buffer(bw, &buffer, &bytes))
- return false;
-
- *crc = (FLAC__uint16)FLAC__crc16(buffer, bytes);
- FLAC__bitwriter_release_buffer(bw);
- return true;
-}
-
-FLAC__bool FLAC__bitwriter_get_write_crc8(FLAC__BitWriter *bw, FLAC__byte *crc)
-{
- const FLAC__byte *buffer;
- size_t bytes;
-
- FLAC__ASSERT((bw->bits & 7) == 0); /* assert that we're byte-aligned */
-
- if(!FLAC__bitwriter_get_buffer(bw, &buffer, &bytes))
- return false;
-
- *crc = FLAC__crc8(buffer, bytes);
- FLAC__bitwriter_release_buffer(bw);
- return true;
-}
-
-FLAC__bool FLAC__bitwriter_is_byte_aligned(const FLAC__BitWriter *bw)
-{
- return ((bw->bits & 7) == 0);
-}
-
-uint32_t FLAC__bitwriter_get_input_bits_unconsumed(const FLAC__BitWriter *bw)
-{
- return FLAC__TOTAL_BITS(bw);
-}
-
-FLAC__bool FLAC__bitwriter_get_buffer(FLAC__BitWriter *bw, const FLAC__byte **buffer, size_t *bytes)
-{
- FLAC__ASSERT((bw->bits & 7) == 0);
- /* double protection */
- if(bw->bits & 7)
- return false;
- /* if we have bits in the accumulator we have to flush those to the buffer first */
- if(bw->bits) {
- FLAC__ASSERT(bw->words <= bw->capacity);
- if(bw->words == bw->capacity && !bitwriter_grow_(bw, FLAC__BITS_PER_WORD))
- return false;
- /* append bits as complete word to buffer, but don't change bw->accum or bw->bits */
- bw->buffer[bw->words] = SWAP_BE_WORD_TO_HOST(bw->accum << (FLAC__BITS_PER_WORD-bw->bits));
- }
- /* now we can just return what we have */
- *buffer = (FLAC__byte*)bw->buffer;
- *bytes = (FLAC__BYTES_PER_WORD * bw->words) + (bw->bits >> 3);
- return true;
-}
-
-void FLAC__bitwriter_release_buffer(FLAC__BitWriter *bw)
-{
- /* nothing to do. in the future, strict checking of a 'writer-is-in-
- * get-mode' flag could be added everywhere and then cleared here
- */
- (void)bw;
-}
-
-inline FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits)
-{
- uint32_t n;
-
- FLAC__ASSERT(0 != bw);
- FLAC__ASSERT(0 != bw->buffer);
-
- if(bits == 0)
- return true;
- /* slightly pessimistic size check but faster than "<= bw->words + (bw->bits+bits+FLAC__BITS_PER_WORD-1)/FLAC__BITS_PER_WORD" */
- if(bw->capacity <= bw->words + bits && !bitwriter_grow_(bw, bits))
- return false;
- /* first part gets to word alignment */
- if(bw->bits) {
- n = flac_min(FLAC__BITS_PER_WORD - bw->bits, bits);
- bw->accum <<= n;
- bits -= n;
- bw->bits += n;
- if(bw->bits == FLAC__BITS_PER_WORD) {
- bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum);
- bw->bits = 0;
- }
- else
- return true;
- }
- /* do whole words */
- while(bits >= FLAC__BITS_PER_WORD) {
- bw->buffer[bw->words++] = 0;
- bits -= FLAC__BITS_PER_WORD;
- }
- /* do any leftovers */
- if(bits > 0) {
- bw->accum = 0;
- bw->bits = bits;
- }
- return true;
-}
-
-static inline FLAC__bool FLAC__bitwriter_write_raw_uint32_nocheck(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits)
-{
- uint32_t left;
-
- /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
- FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
-
- if(bw == 0 || bw->buffer == 0)
- return false;
-
- if (bits > 32)
- return false;
-
- if(bits == 0)
- return true;
-
- FLAC__ASSERT((bits == 32) || (val>>bits == 0));
-
- /* slightly pessimistic size check but faster than "<= bw->words + (bw->bits+bits+FLAC__BITS_PER_WORD-1)/FLAC__BITS_PER_WORD" */
- if(bw->capacity <= bw->words + bits && !bitwriter_grow_(bw, bits))
- return false;
-
- left = FLAC__BITS_PER_WORD - bw->bits;
- if(bits < left) {
- bw->accum <<= bits;
- bw->accum |= val;
- bw->bits += bits;
- }
- else if(bw->bits) { /* WATCHOUT: if bw->bits == 0, left==FLAC__BITS_PER_WORD and bw->accum<<=left is a NOP instead of setting to 0 */
- bw->accum <<= left;
- bw->accum |= val >> (bw->bits = bits - left);
- bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum);
- bw->accum = val; /* unused top bits can contain garbage */
- }
- else { /* at this point bits == FLAC__BITS_PER_WORD == 32 and bw->bits == 0 */
- bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST((bwword)val);
- }
-
- return true;
-}
-
-inline FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits)
-{
- /* check that unused bits are unset */
- if((bits < 32) && (val>>bits != 0))
- return false;
-
- return FLAC__bitwriter_write_raw_uint32_nocheck(bw, val, bits);
-}
-
-inline FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits)
-{
- /* zero-out unused bits */
- if(bits < 32)
- val &= (~(0xffffffff << bits));
-
- return FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)val, bits);
-}
-
-inline FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits)
-{
- /* this could be a little faster but it's not used for much */
- if(bits > 32) {
- return
- FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)(val>>32), bits-32) &&
- FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)val, 32);
- }
- else
- return FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, bits);
-}
-
-inline FLAC__bool FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits)
-{
- FLAC__uint64 uval = val;
- /* zero-out unused bits */
- if(bits < 64)
- uval &= (~(UINT64_MAX << bits));
- return FLAC__bitwriter_write_raw_uint64(bw, uval, bits);
-}
-
-inline FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val)
-{
- /* this doesn't need to be that fast as currently it is only used for vorbis comments */
-
- if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, val & 0xff, 8))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, (val>>8) & 0xff, 8))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, (val>>16) & 0xff, 8))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, val>>24, 8))
- return false;
-
- return true;
-}
-
-inline FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals)
-{
- uint32_t i;
-
- /* grow capacity upfront to prevent constant reallocation during writes */
- if(bw->capacity <= bw->words + nvals / (FLAC__BITS_PER_WORD / 8) + 1 && !bitwriter_grow_(bw, nvals * 8))
- return false;
-
- /* this could be faster but currently we don't need it to be since it's only used for writing metadata */
- for(i = 0; i < nvals; i++) {
- if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)(vals[i]), 8))
- return false;
- }
-
- return true;
-}
-
-FLAC__bool FLAC__bitwriter_write_unary_unsigned(FLAC__BitWriter *bw, uint32_t val)
-{
- if(val < 32)
- return FLAC__bitwriter_write_raw_uint32_nocheck(bw, 1, ++val);
- else
- return
- FLAC__bitwriter_write_zeroes(bw, val) &&
- FLAC__bitwriter_write_raw_uint32_nocheck(bw, 1, 1);
-}
-
-#if 0 /* UNUSED */
-uint32_t FLAC__bitwriter_rice_bits(FLAC__int32 val, uint32_t parameter)
-{
- FLAC__uint32 uval;
-
- FLAC__ASSERT(parameter < 32);
-
- /* fold signed to uint32_t; actual formula is: negative(v)? -2v-1 : 2v */
- uval = val;
- uval <<= 1;
- uval ^= (val>>31);
-
- return 1 + parameter + (uval >> parameter);
-}
-
-uint32_t FLAC__bitwriter_golomb_bits_signed(int val, uint32_t parameter)
-{
- uint32_t bits, msbs, uval;
- uint32_t k;
-
- FLAC__ASSERT(parameter > 0);
-
- /* fold signed to uint32_t */
- if(val < 0)
- uval = (uint32_t)(((-(++val)) << 1) + 1);
- else
- uval = (uint32_t)(val << 1);
-
- k = FLAC__bitmath_ilog2(parameter);
- if(parameter == 1u<> k;
- bits = 1 + k + msbs;
- }
- else {
- uint32_t q, r, d;
-
- d = (1 << (k+1)) - parameter;
- q = uval / parameter;
- r = uval - (q * parameter);
-
- bits = 1 + q + k;
- if(r >= d)
- bits++;
- }
- return bits;
-}
-
-uint32_t FLAC__bitwriter_golomb_bits_unsigned(uint32_t uval, uint32_t parameter)
-{
- uint32_t bits, msbs;
- uint32_t k;
-
- FLAC__ASSERT(parameter > 0);
-
- k = FLAC__bitmath_ilog2(parameter);
- if(parameter == 1u<> k;
- bits = 1 + k + msbs;
- }
- else {
- uint32_t q, r, d;
-
- d = (1 << (k+1)) - parameter;
- q = uval / parameter;
- r = uval - (q * parameter);
-
- bits = 1 + q + k;
- if(r >= d)
- bits++;
- }
- return bits;
-}
-
-FLAC__bool FLAC__bitwriter_write_rice_signed(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t parameter)
-{
- uint32_t total_bits, interesting_bits, msbs;
- FLAC__uint32 uval, pattern;
-
- FLAC__ASSERT(0 != bw);
- FLAC__ASSERT(0 != bw->buffer);
- FLAC__ASSERT(parameter < 32);
-
- /* fold signed to uint32_t; actual formula is: negative(v)? -2v-1 : 2v */
- uval = val;
- uval <<= 1;
- uval ^= (val>>31);
-
- msbs = uval >> parameter;
- interesting_bits = 1 + parameter;
- total_bits = interesting_bits + msbs;
- pattern = 1 << parameter; /* the unary end bit */
- pattern |= (uval & ((1<accum = wide_accum >> FLAC__HALF_TEMP_BITS; \
- bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \
- wide_accum <<= FLAC__HALF_TEMP_BITS; \
- bitpointer += FLAC__HALF_TEMP_BITS; \
-}
-
-#else
-
-#define WIDE_ACCUM_TO_BW { \
- FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \
- if(bw->bits == 0) { \
- bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \
- wide_accum <<= FLAC__HALF_TEMP_BITS; \
- bw->bits = FLAC__HALF_TEMP_BITS; \
- } \
- else { \
- bw->accum <<= FLAC__HALF_TEMP_BITS; \
- bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \
- bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \
- wide_accum <<= FLAC__HALF_TEMP_BITS; \
- bw->bits = 0; \
- } \
- bitpointer += FLAC__HALF_TEMP_BITS; \
-}
-
-#endif
-
-FLAC__bool FLAC__bitwriter_write_rice_signed_block(FLAC__BitWriter *bw, const FLAC__int32 *vals, uint32_t nvals, uint32_t parameter)
-{
- const FLAC__uint32 mask1 = (FLAC__uint32)0xffffffff << parameter; /* we val|=mask1 to set the stop bit above it... */
- const FLAC__uint32 mask2 = (FLAC__uint32)0xffffffff >> (31-parameter); /* ...then mask off the bits above the stop bit with val&=mask2 */
- FLAC__uint32 uval;
- const uint32_t lsbits = 1 + parameter;
- uint32_t msbits, total_bits;
- FLAC__bwtemp wide_accum = 0;
- FLAC__uint32 bitpointer = FLAC__TEMP_BITS;
-
- FLAC__ASSERT(0 != bw);
- FLAC__ASSERT(0 != bw->buffer);
- FLAC__ASSERT(parameter < 31);
- /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
- FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
-#if (ENABLE_64_BIT_WORDS == 0)
- if(bw->bits > 0) {
- bitpointer -= bw->bits;
- wide_accum = (FLAC__bwtemp)(bw->accum) << bitpointer;
- bw->bits = 0;
- }
-#else
- if(bw->bits > 0 && bw->bits < FLAC__HALF_TEMP_BITS) {
- bitpointer -= bw->bits;
- wide_accum = bw->accum << bitpointer;
- bw->bits = 0;
- }
- else if(bw->bits > FLAC__HALF_TEMP_BITS) {
- bitpointer -= (bw->bits - FLAC__HALF_TEMP_BITS);
- wide_accum = bw->accum << bitpointer;
- bw->accum >>= (bw->bits - FLAC__HALF_TEMP_BITS);
- bw->bits = FLAC__HALF_TEMP_BITS;
- }
-#endif
-
- /* Reserve one FLAC__TEMP_BITS per symbol, so checks for space are only necessary when very large symbols are encountered
- * this might be considered wasteful, but is only at most 8kB more than necessary for a blocksize of 4096 */
- if(bw->capacity * FLAC__BITS_PER_WORD <= bw->words * FLAC__BITS_PER_WORD + nvals * FLAC__TEMP_BITS + bw->bits && !bitwriter_grow_(bw, nvals * FLAC__TEMP_BITS))
- return false;
-
- while(nvals) {
- /* fold signed to uint32_t; actual formula is: negative(v)? -2v-1 : 2v */
- uval = *vals;
- uval <<= 1;
- uval ^= (*vals>>31);
-
- msbits = uval >> parameter;
- total_bits = lsbits + msbits;
-
- uval |= mask1; /* set stop bit */
- uval &= mask2; /* mask off unused top bits */
-
-
- if(total_bits <= bitpointer) {
- /* There is room enough to store the symbol whole at once */
- wide_accum |= (FLAC__bwtemp)(uval) << (bitpointer - total_bits);
- bitpointer -= total_bits;
- if(bitpointer <= FLAC__HALF_TEMP_BITS) {
- /* A word is finished, copy the upper 32 bits of the wide_accum */
- WIDE_ACCUM_TO_BW
- }
- }
- else {
- /* The symbol needs to be split. This code isn't used often */
- /* First check for space in the bitwriter */
- if(total_bits > FLAC__TEMP_BITS) {
- FLAC__uint32 oversize_in_bits = total_bits - FLAC__TEMP_BITS;
- FLAC__uint32 capacity_needed = bw->words * FLAC__BITS_PER_WORD + bw->bits + nvals * FLAC__TEMP_BITS + oversize_in_bits;
- if(bw->capacity * FLAC__BITS_PER_WORD <= capacity_needed && !bitwriter_grow_(bw, nvals * FLAC__TEMP_BITS + oversize_in_bits))
- return false;
- }
- if(msbits > bitpointer) {
- /* We have a lot of 0 bits to write, first align with bitwriter word */
- msbits -= bitpointer - FLAC__HALF_TEMP_BITS;
- bitpointer = FLAC__HALF_TEMP_BITS;
- WIDE_ACCUM_TO_BW
- while(msbits > bitpointer) {
- /* As the accumulator is already zero, we only need to
- * assign zeroes to the bitbuffer */
- WIDE_ACCUM_TO_BW
- bitpointer -= FLAC__HALF_TEMP_BITS;
- msbits -= FLAC__HALF_TEMP_BITS;
- }
- /* The remaining bits are zero, and the accumulator already is zero,
- * so just subtract the number of bits from bitpointer. When storing,
- * we can also just store 0 */
- bitpointer -= msbits;
- if(bitpointer <= FLAC__HALF_TEMP_BITS)
- WIDE_ACCUM_TO_BW
- }
- else {
- bitpointer -= msbits;
- if(bitpointer <= FLAC__HALF_TEMP_BITS)
- WIDE_ACCUM_TO_BW
- }
- /* The lsbs + stop bit always fit 32 bit, so this code mirrors the code above */
- wide_accum |= (FLAC__bwtemp)(uval) << (bitpointer - lsbits);
- bitpointer -= lsbits;
- if(bitpointer <= FLAC__HALF_TEMP_BITS) {
- /* A word is finished, copy the upper 32 bits of the wide_accum */
- WIDE_ACCUM_TO_BW
- }
- }
- vals++;
- nvals--;
- }
- /* Now fixup remainder of wide_accum */
-#if (ENABLE_64_BIT_WORDS == 0)
- if(bitpointer < FLAC__TEMP_BITS) {
- bw->accum = wide_accum >> bitpointer;
- bw->bits = FLAC__TEMP_BITS - bitpointer;
- }
-#else
- if(bitpointer < FLAC__TEMP_BITS) {
- if(bw->bits == 0) {
- bw->accum = wide_accum >> bitpointer;
- bw->bits = FLAC__TEMP_BITS - bitpointer;
- }
- else if (bw->bits == FLAC__HALF_TEMP_BITS) {
- bw->accum <<= FLAC__TEMP_BITS - bitpointer;
- bw->accum |= (wide_accum >> bitpointer);
- bw->bits = FLAC__HALF_TEMP_BITS + FLAC__TEMP_BITS - bitpointer;
- }
- else {
- FLAC__ASSERT(0);
- }
- }
-#endif
-
-
- return true;
-}
-
-#if 0 /* UNUSED */
-FLAC__bool FLAC__bitwriter_write_golomb_signed(FLAC__BitWriter *bw, int val, uint32_t parameter)
-{
- uint32_t total_bits, msbs, uval;
- uint32_t k;
-
- FLAC__ASSERT(0 != bw);
- FLAC__ASSERT(0 != bw->buffer);
- FLAC__ASSERT(parameter > 0);
-
- /* fold signed to uint32_t */
- if(val < 0)
- uval = (uint32_t)(((-(++val)) << 1) + 1);
- else
- uval = (uint32_t)(val << 1);
-
- k = FLAC__bitmath_ilog2(parameter);
- if(parameter == 1u<> k;
- total_bits = 1 + k + msbs;
- pattern = 1 << k; /* the unary end bit */
- pattern |= (uval & ((1u<= d) {
- if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
- return false;
- }
- else {
- if(!FLAC__bitwriter_write_raw_uint32(bw, r, k))
- return false;
- }
- }
- return true;
-}
-
-FLAC__bool FLAC__bitwriter_write_golomb_unsigned(FLAC__BitWriter *bw, uint32_t uval, uint32_t parameter)
-{
- uint32_t total_bits, msbs;
- uint32_t k;
-
- FLAC__ASSERT(0 != bw);
- FLAC__ASSERT(0 != bw->buffer);
- FLAC__ASSERT(parameter > 0);
-
- k = FLAC__bitmath_ilog2(parameter);
- if(parameter == 1u<> k;
- total_bits = 1 + k + msbs;
- pattern = 1 << k; /* the unary end bit */
- pattern |= (uval & ((1u<= d) {
- if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
- return false;
- }
- else {
- if(!FLAC__bitwriter_write_raw_uint32(bw, r, k))
- return false;
- }
- }
- return true;
-}
-#endif /* UNUSED */
-
-FLAC__bool FLAC__bitwriter_write_utf8_uint32(FLAC__BitWriter *bw, FLAC__uint32 val)
-{
- FLAC__bool ok = 1;
-
- FLAC__ASSERT(0 != bw);
- FLAC__ASSERT(0 != bw->buffer);
-
- if((val & 0x80000000) != 0) /* this version only handles 31 bits */
- return false;
-
- if(val < 0x80) {
- return FLAC__bitwriter_write_raw_uint32_nocheck(bw, val, 8);
- }
- else if(val < 0x800) {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xC0 | (val>>6), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8);
- }
- else if(val < 0x10000) {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xE0 | (val>>12), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8);
- }
- else if(val < 0x200000) {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xF0 | (val>>18), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>12)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8);
- }
- else if(val < 0x4000000) {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xF8 | (val>>24), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>18)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>12)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8);
- }
- else {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xFC | (val>>30), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>24)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>18)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>12)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8);
- }
-
- return ok;
-}
-
-FLAC__bool FLAC__bitwriter_write_utf8_uint64(FLAC__BitWriter *bw, FLAC__uint64 val)
-{
- FLAC__bool ok = 1;
-
- FLAC__ASSERT(0 != bw);
- FLAC__ASSERT(0 != bw->buffer);
-
- if((val & FLAC__U64L(0xFFFFFFF000000000)) != 0) /* this version only handles 36 bits */
- return false;
-
- if(val < 0x80) {
- return FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)val, 8);
- }
- else if(val < 0x800) {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xC0 | (FLAC__uint32)(val>>6), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
- }
- else if(val < 0x10000) {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xE0 | (FLAC__uint32)(val>>12), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
- }
- else if(val < 0x200000) {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xF0 | (FLAC__uint32)(val>>18), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
- }
- else if(val < 0x4000000) {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xF8 | (FLAC__uint32)(val>>24), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
- }
- else if(val < 0x80000000) {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xFC | (FLAC__uint32)(val>>30), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
- }
- else {
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xFE, 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>30)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
- ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
- }
-
- return ok;
-}
-
-FLAC__bool FLAC__bitwriter_zero_pad_to_byte_boundary(FLAC__BitWriter *bw)
-{
- /* 0-pad to byte boundary */
- if(bw->bits & 7u)
- return FLAC__bitwriter_write_zeroes(bw, 8 - (bw->bits & 7u));
- else
- return true;
-}
-
-/* These functions are declared inline in this file but are also callable as
- * externs from elsewhere.
- * According to the C99 spec, section 6.7.4, simply providing a function
- * prototype in a header file without 'inline' and making the function inline
- * in this file should be sufficient.
- * Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
- * fix that we add extern declarations here.
- */
-extern FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val);
-extern FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals);
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/cpu.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/cpu.c
deleted file mode 100644
index d80a37f8a9..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/cpu.c
+++ /dev/null
@@ -1,261 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2001-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include "include/private/cpu.h"
-#include "../compat.h"
-#include
-#include
-
-#if defined _MSC_VER
-#include /* for __cpuid() and _xgetbv() */
-#elif defined __GNUC__ && defined HAVE_CPUID_H
-#include /* for __get_cpuid() and __get_cpuid_max() */
-#endif
-
-#ifndef NDEBUG
-#include
-#define dfprintf fprintf
-#else
-/* This is bad practice, it should be a static void empty function */
-#define dfprintf(file, format, ...)
-#endif
-
-#if defined(HAVE_SYS_AUXV_H)
-#include
-#endif
-
-#if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN && !defined FLAC__NO_ASM
-
-/* these are flags in EDX of CPUID AX=00000001 */
-static const uint32_t FLAC__CPUINFO_X86_CPUID_CMOV = 0x00008000;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_MMX = 0x00800000;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_SSE = 0x02000000;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_SSE2 = 0x04000000;
-
-/* these are flags in ECX of CPUID AX=00000001 */
-static const uint32_t FLAC__CPUINFO_X86_CPUID_SSE3 = 0x00000001;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_SSSE3 = 0x00000200;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_SSE41 = 0x00080000;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_SSE42 = 0x00100000;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_OSXSAVE = 0x08000000;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_AVX = 0x10000000;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_FMA = 0x00001000;
-
-/* these are flags in EBX of CPUID AX=00000007 */
-static const uint32_t FLAC__CPUINFO_X86_CPUID_AVX2 = 0x00000020;
-static const uint32_t FLAC__CPUINFO_X86_CPUID_BMI2 = 0x00000100;
-
-#if FLAC__AVX_SUPPORTED
-static uint32_t
-cpu_xgetbv_x86(void)
-{
-#if (defined _MSC_VER || defined __INTEL_COMPILER) && FLAC__AVX_SUPPORTED
- return (uint32_t)_xgetbv(0);
-#elif defined __GNUC__
- uint32_t lo, hi;
- __asm__ volatile (".byte 0x0f, 0x01, 0xd0" : "=a"(lo), "=d"(hi) : "c" (0));
- return lo;
-#else
- return 0;
-#endif
-}
-#endif
-
-static uint32_t
-cpu_have_cpuid(void)
-{
-#if defined FLAC__CPU_X86_64 || defined __i686__ || defined __SSE__ || (defined _M_IX86_FP && _M_IX86_FP > 0)
- /* target CPU does have CPUID instruction */
- return 1;
-#elif defined __GNUC__ && defined HAVE_CPUID_H
- if (__get_cpuid_max(0, 0) != 0)
- return 1;
- else
- return 0;
-#elif defined _MSC_VER
- FLAC__uint32 flags1, flags2;
- __asm {
- pushfd
- pushfd
- pop eax
- mov flags1, eax
- xor eax, 0x200000
- push eax
- popfd
- pushfd
- pop eax
- mov flags2, eax
- popfd
- }
- if (((flags1^flags2) & 0x200000) != 0)
- return 1;
- else
- return 0;
-#else
- return 0;
-#endif
-}
-
-static void
-cpuinfo_x86([[maybe_unused]] FLAC__uint32 level, FLAC__uint32 *eax, FLAC__uint32 *ebx, FLAC__uint32 *ecx, FLAC__uint32 *edx)
-{
-#if defined _MSC_VER
- int cpuinfo[4];
- int ext = level & 0x80000000;
- __cpuid(cpuinfo, ext);
- if ((uint32_t)cpuinfo[0] >= level) {
-#if FLAC__AVX_SUPPORTED
- __cpuidex(cpuinfo, level, 0); /* for AVX2 detection */
-#else
- __cpuid(cpuinfo, level); /* some old compilers don't support __cpuidex */
-#endif
- *eax = cpuinfo[0]; *ebx = cpuinfo[1]; *ecx = cpuinfo[2]; *edx = cpuinfo[3];
- return;
- }
-#elif defined __GNUC__ && defined HAVE_CPUID_H
- FLAC__uint32 ext = level & 0x80000000;
- __cpuid(ext, *eax, *ebx, *ecx, *edx);
- if (*eax >= level) {
- __cpuid_count(level, 0, *eax, *ebx, *ecx, *edx);
- return;
- }
-#endif
- *eax = *ebx = *ecx = *edx = 0;
-}
-
-#endif
-
-static void
-x86_cpu_info (FLAC__CPUInfo *info)
-{
-#if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN && !defined FLAC__NO_ASM
- #if FLAC__AVX_SUPPORTED
- FLAC__bool x86_osxsave = false;
- #endif
- FLAC__bool os_avx = false;
- FLAC__uint32 flags_eax, flags_ebx, flags_ecx, flags_edx;
-
- info->use_asm = true; /* we assume a minimum of 80386 */
- if (!cpu_have_cpuid())
- return;
-
- cpuinfo_x86(0, &flags_eax, &flags_ebx, &flags_ecx, &flags_edx);
- info->x86.intel = (flags_ebx == 0x756E6547 && flags_edx == 0x49656E69 && flags_ecx == 0x6C65746E) ? true : false; /* GenuineIntel */
- cpuinfo_x86(1, &flags_eax, &flags_ebx, &flags_ecx, &flags_edx);
-
- info->x86.cmov = (flags_edx & FLAC__CPUINFO_X86_CPUID_CMOV ) ? true : false;
- info->x86.mmx = (flags_edx & FLAC__CPUINFO_X86_CPUID_MMX ) ? true : false;
- info->x86.sse = (flags_edx & FLAC__CPUINFO_X86_CPUID_SSE ) ? true : false;
- info->x86.sse2 = (flags_edx & FLAC__CPUINFO_X86_CPUID_SSE2 ) ? true : false;
- info->x86.sse3 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSE3 ) ? true : false;
- info->x86.ssse3 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSSE3) ? true : false;
- info->x86.sse41 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSE41) ? true : false;
- info->x86.sse42 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSE42) ? true : false;
-
- #if (FLAC__AVX_SUPPORTED)
- x86_osxsave = (flags_ecx & FLAC__CPUINFO_X86_CPUID_OSXSAVE) ? true : false;
- info->x86.avx = (flags_ecx & FLAC__CPUINFO_X86_CPUID_AVX ) ? true : false;
- info->x86.fma = (flags_ecx & FLAC__CPUINFO_X86_CPUID_FMA ) ? true : false;
- cpuinfo_x86(7, &flags_eax, &flags_ebx, &flags_ecx, &flags_edx);
- info->x86.avx2 = (flags_ebx & FLAC__CPUINFO_X86_CPUID_AVX2 ) ? true : false;
- info->x86.bmi2 = (flags_ebx & FLAC__CPUINFO_X86_CPUID_BMI2 ) ? true : false;
- #endif
-
-#if defined FLAC__CPU_IA32
- dfprintf(stderr, "CPU info (IA-32):\n", "");
-#else
- dfprintf(stderr, "CPU info (x86-64):\n", "");
-#endif
- dfprintf(stderr, " CMOV ....... %c\n", info->x86.cmov ? 'Y' : 'n');
- dfprintf(stderr, " MMX ........ %c\n", info->x86.mmx ? 'Y' : 'n');
- dfprintf(stderr, " SSE ........ %c\n", info->x86.sse ? 'Y' : 'n');
- dfprintf(stderr, " SSE2 ....... %c\n", info->x86.sse2 ? 'Y' : 'n');
- dfprintf(stderr, " SSE3 ....... %c\n", info->x86.sse3 ? 'Y' : 'n');
- dfprintf(stderr, " SSSE3 ...... %c\n", info->x86.ssse3 ? 'Y' : 'n');
- dfprintf(stderr, " SSE41 ...... %c\n", info->x86.sse41 ? 'Y' : 'n');
- dfprintf(stderr, " SSE42 ...... %c\n", info->x86.sse42 ? 'Y' : 'n');
-
- if (FLAC__AVX_SUPPORTED) {
- dfprintf(stderr, " AVX ........ %c\n", info->x86.avx ? 'Y' : 'n');
- dfprintf(stderr, " FMA ........ %c\n", info->x86.fma ? 'Y' : 'n');
- dfprintf(stderr, " AVX2 ....... %c\n", info->x86.avx2 ? 'Y' : 'n');
- dfprintf(stderr, " BMI2 ....... %c\n", info->x86.bmi2 ? 'Y' : 'n');
- }
-
- /*
- * now have to check for OS support of AVX instructions
- */
- #if FLAC__AVX_SUPPORTED
- if (info->x86.avx && x86_osxsave && (cpu_xgetbv_x86() & 0x6) == 0x6) {
- os_avx = true;
- }
- #endif
- if (os_avx) {
- dfprintf(stderr, " AVX OS sup . %c\n", info->x86.avx ? 'Y' : 'n');
- }
- if (!os_avx) {
- /* no OS AVX support */
- info->x86.avx = false;
- info->x86.avx2 = false;
- info->x86.fma = false;
- }
-#else
- info->use_asm = false;
-#endif
-}
-
-void FLAC__cpu_info (FLAC__CPUInfo *info)
-{
- memset(info, 0, sizeof(*info));
-
-#ifdef FLAC__CPU_IA32
- info->type = FLAC__CPUINFO_TYPE_IA32;
-#elif defined FLAC__CPU_X86_64
- info->type = FLAC__CPUINFO_TYPE_X86_64;
-#else
- info->type = FLAC__CPUINFO_TYPE_UNKNOWN;
-#endif
-
- switch (info->type) {
- case FLAC__CPUINFO_TYPE_IA32: /* fallthrough */
- case FLAC__CPUINFO_TYPE_X86_64:
- x86_cpu_info (info);
- break;
- default:
- info->use_asm = false;
- break;
- }
-}
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/crc.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/crc.c
deleted file mode 100644
index c8ab234168..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/crc.c
+++ /dev/null
@@ -1,436 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include "include/private/crc.h"
-
-/* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
-
-FLAC__uint8 const FLAC__crc8_table[256] = {
- 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
- 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
- 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
- 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
- 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
- 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
- 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
- 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
- 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
- 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
- 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
- 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
- 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
- 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
- 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
- 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
- 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
- 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
- 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
- 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
- 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
- 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
- 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
- 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
- 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
- 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
- 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
- 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
- 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
- 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
- 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
- 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
-};
-
-/* CRC-16, poly = x^16 + x^15 + x^2 + x^0, init = 0 */
-
-FLAC__uint16 const FLAC__crc16_table[8][256] = {
- { 0x0000, 0x8005, 0x800f, 0x000a, 0x801b, 0x001e, 0x0014, 0x8011,
- 0x8033, 0x0036, 0x003c, 0x8039, 0x0028, 0x802d, 0x8027, 0x0022,
- 0x8063, 0x0066, 0x006c, 0x8069, 0x0078, 0x807d, 0x8077, 0x0072,
- 0x0050, 0x8055, 0x805f, 0x005a, 0x804b, 0x004e, 0x0044, 0x8041,
- 0x80c3, 0x00c6, 0x00cc, 0x80c9, 0x00d8, 0x80dd, 0x80d7, 0x00d2,
- 0x00f0, 0x80f5, 0x80ff, 0x00fa, 0x80eb, 0x00ee, 0x00e4, 0x80e1,
- 0x00a0, 0x80a5, 0x80af, 0x00aa, 0x80bb, 0x00be, 0x00b4, 0x80b1,
- 0x8093, 0x0096, 0x009c, 0x8099, 0x0088, 0x808d, 0x8087, 0x0082,
- 0x8183, 0x0186, 0x018c, 0x8189, 0x0198, 0x819d, 0x8197, 0x0192,
- 0x01b0, 0x81b5, 0x81bf, 0x01ba, 0x81ab, 0x01ae, 0x01a4, 0x81a1,
- 0x01e0, 0x81e5, 0x81ef, 0x01ea, 0x81fb, 0x01fe, 0x01f4, 0x81f1,
- 0x81d3, 0x01d6, 0x01dc, 0x81d9, 0x01c8, 0x81cd, 0x81c7, 0x01c2,
- 0x0140, 0x8145, 0x814f, 0x014a, 0x815b, 0x015e, 0x0154, 0x8151,
- 0x8173, 0x0176, 0x017c, 0x8179, 0x0168, 0x816d, 0x8167, 0x0162,
- 0x8123, 0x0126, 0x012c, 0x8129, 0x0138, 0x813d, 0x8137, 0x0132,
- 0x0110, 0x8115, 0x811f, 0x011a, 0x810b, 0x010e, 0x0104, 0x8101,
- 0x8303, 0x0306, 0x030c, 0x8309, 0x0318, 0x831d, 0x8317, 0x0312,
- 0x0330, 0x8335, 0x833f, 0x033a, 0x832b, 0x032e, 0x0324, 0x8321,
- 0x0360, 0x8365, 0x836f, 0x036a, 0x837b, 0x037e, 0x0374, 0x8371,
- 0x8353, 0x0356, 0x035c, 0x8359, 0x0348, 0x834d, 0x8347, 0x0342,
- 0x03c0, 0x83c5, 0x83cf, 0x03ca, 0x83db, 0x03de, 0x03d4, 0x83d1,
- 0x83f3, 0x03f6, 0x03fc, 0x83f9, 0x03e8, 0x83ed, 0x83e7, 0x03e2,
- 0x83a3, 0x03a6, 0x03ac, 0x83a9, 0x03b8, 0x83bd, 0x83b7, 0x03b2,
- 0x0390, 0x8395, 0x839f, 0x039a, 0x838b, 0x038e, 0x0384, 0x8381,
- 0x0280, 0x8285, 0x828f, 0x028a, 0x829b, 0x029e, 0x0294, 0x8291,
- 0x82b3, 0x02b6, 0x02bc, 0x82b9, 0x02a8, 0x82ad, 0x82a7, 0x02a2,
- 0x82e3, 0x02e6, 0x02ec, 0x82e9, 0x02f8, 0x82fd, 0x82f7, 0x02f2,
- 0x02d0, 0x82d5, 0x82df, 0x02da, 0x82cb, 0x02ce, 0x02c4, 0x82c1,
- 0x8243, 0x0246, 0x024c, 0x8249, 0x0258, 0x825d, 0x8257, 0x0252,
- 0x0270, 0x8275, 0x827f, 0x027a, 0x826b, 0x026e, 0x0264, 0x8261,
- 0x0220, 0x8225, 0x822f, 0x022a, 0x823b, 0x023e, 0x0234, 0x8231,
- 0x8213, 0x0216, 0x021c, 0x8219, 0x0208, 0x820d, 0x8207, 0x0202 },
-
- { 0x0000, 0x8603, 0x8c03, 0x0a00, 0x9803, 0x1e00, 0x1400, 0x9203,
- 0xb003, 0x3600, 0x3c00, 0xba03, 0x2800, 0xae03, 0xa403, 0x2200,
- 0xe003, 0x6600, 0x6c00, 0xea03, 0x7800, 0xfe03, 0xf403, 0x7200,
- 0x5000, 0xd603, 0xdc03, 0x5a00, 0xc803, 0x4e00, 0x4400, 0xc203,
- 0x4003, 0xc600, 0xcc00, 0x4a03, 0xd800, 0x5e03, 0x5403, 0xd200,
- 0xf000, 0x7603, 0x7c03, 0xfa00, 0x6803, 0xee00, 0xe400, 0x6203,
- 0xa000, 0x2603, 0x2c03, 0xaa00, 0x3803, 0xbe00, 0xb400, 0x3203,
- 0x1003, 0x9600, 0x9c00, 0x1a03, 0x8800, 0x0e03, 0x0403, 0x8200,
- 0x8006, 0x0605, 0x0c05, 0x8a06, 0x1805, 0x9e06, 0x9406, 0x1205,
- 0x3005, 0xb606, 0xbc06, 0x3a05, 0xa806, 0x2e05, 0x2405, 0xa206,
- 0x6005, 0xe606, 0xec06, 0x6a05, 0xf806, 0x7e05, 0x7405, 0xf206,
- 0xd006, 0x5605, 0x5c05, 0xda06, 0x4805, 0xce06, 0xc406, 0x4205,
- 0xc005, 0x4606, 0x4c06, 0xca05, 0x5806, 0xde05, 0xd405, 0x5206,
- 0x7006, 0xf605, 0xfc05, 0x7a06, 0xe805, 0x6e06, 0x6406, 0xe205,
- 0x2006, 0xa605, 0xac05, 0x2a06, 0xb805, 0x3e06, 0x3406, 0xb205,
- 0x9005, 0x1606, 0x1c06, 0x9a05, 0x0806, 0x8e05, 0x8405, 0x0206,
- 0x8009, 0x060a, 0x0c0a, 0x8a09, 0x180a, 0x9e09, 0x9409, 0x120a,
- 0x300a, 0xb609, 0xbc09, 0x3a0a, 0xa809, 0x2e0a, 0x240a, 0xa209,
- 0x600a, 0xe609, 0xec09, 0x6a0a, 0xf809, 0x7e0a, 0x740a, 0xf209,
- 0xd009, 0x560a, 0x5c0a, 0xda09, 0x480a, 0xce09, 0xc409, 0x420a,
- 0xc00a, 0x4609, 0x4c09, 0xca0a, 0x5809, 0xde0a, 0xd40a, 0x5209,
- 0x7009, 0xf60a, 0xfc0a, 0x7a09, 0xe80a, 0x6e09, 0x6409, 0xe20a,
- 0x2009, 0xa60a, 0xac0a, 0x2a09, 0xb80a, 0x3e09, 0x3409, 0xb20a,
- 0x900a, 0x1609, 0x1c09, 0x9a0a, 0x0809, 0x8e0a, 0x840a, 0x0209,
- 0x000f, 0x860c, 0x8c0c, 0x0a0f, 0x980c, 0x1e0f, 0x140f, 0x920c,
- 0xb00c, 0x360f, 0x3c0f, 0xba0c, 0x280f, 0xae0c, 0xa40c, 0x220f,
- 0xe00c, 0x660f, 0x6c0f, 0xea0c, 0x780f, 0xfe0c, 0xf40c, 0x720f,
- 0x500f, 0xd60c, 0xdc0c, 0x5a0f, 0xc80c, 0x4e0f, 0x440f, 0xc20c,
- 0x400c, 0xc60f, 0xcc0f, 0x4a0c, 0xd80f, 0x5e0c, 0x540c, 0xd20f,
- 0xf00f, 0x760c, 0x7c0c, 0xfa0f, 0x680c, 0xee0f, 0xe40f, 0x620c,
- 0xa00f, 0x260c, 0x2c0c, 0xaa0f, 0x380c, 0xbe0f, 0xb40f, 0x320c,
- 0x100c, 0x960f, 0x9c0f, 0x1a0c, 0x880f, 0x0e0c, 0x040c, 0x820f },
-
- { 0x0000, 0x8017, 0x802b, 0x003c, 0x8053, 0x0044, 0x0078, 0x806f,
- 0x80a3, 0x00b4, 0x0088, 0x809f, 0x00f0, 0x80e7, 0x80db, 0x00cc,
- 0x8143, 0x0154, 0x0168, 0x817f, 0x0110, 0x8107, 0x813b, 0x012c,
- 0x01e0, 0x81f7, 0x81cb, 0x01dc, 0x81b3, 0x01a4, 0x0198, 0x818f,
- 0x8283, 0x0294, 0x02a8, 0x82bf, 0x02d0, 0x82c7, 0x82fb, 0x02ec,
- 0x0220, 0x8237, 0x820b, 0x021c, 0x8273, 0x0264, 0x0258, 0x824f,
- 0x03c0, 0x83d7, 0x83eb, 0x03fc, 0x8393, 0x0384, 0x03b8, 0x83af,
- 0x8363, 0x0374, 0x0348, 0x835f, 0x0330, 0x8327, 0x831b, 0x030c,
- 0x8503, 0x0514, 0x0528, 0x853f, 0x0550, 0x8547, 0x857b, 0x056c,
- 0x05a0, 0x85b7, 0x858b, 0x059c, 0x85f3, 0x05e4, 0x05d8, 0x85cf,
- 0x0440, 0x8457, 0x846b, 0x047c, 0x8413, 0x0404, 0x0438, 0x842f,
- 0x84e3, 0x04f4, 0x04c8, 0x84df, 0x04b0, 0x84a7, 0x849b, 0x048c,
- 0x0780, 0x8797, 0x87ab, 0x07bc, 0x87d3, 0x07c4, 0x07f8, 0x87ef,
- 0x8723, 0x0734, 0x0708, 0x871f, 0x0770, 0x8767, 0x875b, 0x074c,
- 0x86c3, 0x06d4, 0x06e8, 0x86ff, 0x0690, 0x8687, 0x86bb, 0x06ac,
- 0x0660, 0x8677, 0x864b, 0x065c, 0x8633, 0x0624, 0x0618, 0x860f,
- 0x8a03, 0x0a14, 0x0a28, 0x8a3f, 0x0a50, 0x8a47, 0x8a7b, 0x0a6c,
- 0x0aa0, 0x8ab7, 0x8a8b, 0x0a9c, 0x8af3, 0x0ae4, 0x0ad8, 0x8acf,
- 0x0b40, 0x8b57, 0x8b6b, 0x0b7c, 0x8b13, 0x0b04, 0x0b38, 0x8b2f,
- 0x8be3, 0x0bf4, 0x0bc8, 0x8bdf, 0x0bb0, 0x8ba7, 0x8b9b, 0x0b8c,
- 0x0880, 0x8897, 0x88ab, 0x08bc, 0x88d3, 0x08c4, 0x08f8, 0x88ef,
- 0x8823, 0x0834, 0x0808, 0x881f, 0x0870, 0x8867, 0x885b, 0x084c,
- 0x89c3, 0x09d4, 0x09e8, 0x89ff, 0x0990, 0x8987, 0x89bb, 0x09ac,
- 0x0960, 0x8977, 0x894b, 0x095c, 0x8933, 0x0924, 0x0918, 0x890f,
- 0x0f00, 0x8f17, 0x8f2b, 0x0f3c, 0x8f53, 0x0f44, 0x0f78, 0x8f6f,
- 0x8fa3, 0x0fb4, 0x0f88, 0x8f9f, 0x0ff0, 0x8fe7, 0x8fdb, 0x0fcc,
- 0x8e43, 0x0e54, 0x0e68, 0x8e7f, 0x0e10, 0x8e07, 0x8e3b, 0x0e2c,
- 0x0ee0, 0x8ef7, 0x8ecb, 0x0edc, 0x8eb3, 0x0ea4, 0x0e98, 0x8e8f,
- 0x8d83, 0x0d94, 0x0da8, 0x8dbf, 0x0dd0, 0x8dc7, 0x8dfb, 0x0dec,
- 0x0d20, 0x8d37, 0x8d0b, 0x0d1c, 0x8d73, 0x0d64, 0x0d58, 0x8d4f,
- 0x0cc0, 0x8cd7, 0x8ceb, 0x0cfc, 0x8c93, 0x0c84, 0x0cb8, 0x8caf,
- 0x8c63, 0x0c74, 0x0c48, 0x8c5f, 0x0c30, 0x8c27, 0x8c1b, 0x0c0c },
-
- { 0x0000, 0x9403, 0xa803, 0x3c00, 0xd003, 0x4400, 0x7800, 0xec03,
- 0x2003, 0xb400, 0x8800, 0x1c03, 0xf000, 0x6403, 0x5803, 0xcc00,
- 0x4006, 0xd405, 0xe805, 0x7c06, 0x9005, 0x0406, 0x3806, 0xac05,
- 0x6005, 0xf406, 0xc806, 0x5c05, 0xb006, 0x2405, 0x1805, 0x8c06,
- 0x800c, 0x140f, 0x280f, 0xbc0c, 0x500f, 0xc40c, 0xf80c, 0x6c0f,
- 0xa00f, 0x340c, 0x080c, 0x9c0f, 0x700c, 0xe40f, 0xd80f, 0x4c0c,
- 0xc00a, 0x5409, 0x6809, 0xfc0a, 0x1009, 0x840a, 0xb80a, 0x2c09,
- 0xe009, 0x740a, 0x480a, 0xdc09, 0x300a, 0xa409, 0x9809, 0x0c0a,
- 0x801d, 0x141e, 0x281e, 0xbc1d, 0x501e, 0xc41d, 0xf81d, 0x6c1e,
- 0xa01e, 0x341d, 0x081d, 0x9c1e, 0x701d, 0xe41e, 0xd81e, 0x4c1d,
- 0xc01b, 0x5418, 0x6818, 0xfc1b, 0x1018, 0x841b, 0xb81b, 0x2c18,
- 0xe018, 0x741b, 0x481b, 0xdc18, 0x301b, 0xa418, 0x9818, 0x0c1b,
- 0x0011, 0x9412, 0xa812, 0x3c11, 0xd012, 0x4411, 0x7811, 0xec12,
- 0x2012, 0xb411, 0x8811, 0x1c12, 0xf011, 0x6412, 0x5812, 0xcc11,
- 0x4017, 0xd414, 0xe814, 0x7c17, 0x9014, 0x0417, 0x3817, 0xac14,
- 0x6014, 0xf417, 0xc817, 0x5c14, 0xb017, 0x2414, 0x1814, 0x8c17,
- 0x803f, 0x143c, 0x283c, 0xbc3f, 0x503c, 0xc43f, 0xf83f, 0x6c3c,
- 0xa03c, 0x343f, 0x083f, 0x9c3c, 0x703f, 0xe43c, 0xd83c, 0x4c3f,
- 0xc039, 0x543a, 0x683a, 0xfc39, 0x103a, 0x8439, 0xb839, 0x2c3a,
- 0xe03a, 0x7439, 0x4839, 0xdc3a, 0x3039, 0xa43a, 0x983a, 0x0c39,
- 0x0033, 0x9430, 0xa830, 0x3c33, 0xd030, 0x4433, 0x7833, 0xec30,
- 0x2030, 0xb433, 0x8833, 0x1c30, 0xf033, 0x6430, 0x5830, 0xcc33,
- 0x4035, 0xd436, 0xe836, 0x7c35, 0x9036, 0x0435, 0x3835, 0xac36,
- 0x6036, 0xf435, 0xc835, 0x5c36, 0xb035, 0x2436, 0x1836, 0x8c35,
- 0x0022, 0x9421, 0xa821, 0x3c22, 0xd021, 0x4422, 0x7822, 0xec21,
- 0x2021, 0xb422, 0x8822, 0x1c21, 0xf022, 0x6421, 0x5821, 0xcc22,
- 0x4024, 0xd427, 0xe827, 0x7c24, 0x9027, 0x0424, 0x3824, 0xac27,
- 0x6027, 0xf424, 0xc824, 0x5c27, 0xb024, 0x2427, 0x1827, 0x8c24,
- 0x802e, 0x142d, 0x282d, 0xbc2e, 0x502d, 0xc42e, 0xf82e, 0x6c2d,
- 0xa02d, 0x342e, 0x082e, 0x9c2d, 0x702e, 0xe42d, 0xd82d, 0x4c2e,
- 0xc028, 0x542b, 0x682b, 0xfc28, 0x102b, 0x8428, 0xb828, 0x2c2b,
- 0xe02b, 0x7428, 0x4828, 0xdc2b, 0x3028, 0xa42b, 0x982b, 0x0c28 },
-
- { 0x0000, 0x807b, 0x80f3, 0x0088, 0x81e3, 0x0198, 0x0110, 0x816b,
- 0x83c3, 0x03b8, 0x0330, 0x834b, 0x0220, 0x825b, 0x82d3, 0x02a8,
- 0x8783, 0x07f8, 0x0770, 0x870b, 0x0660, 0x861b, 0x8693, 0x06e8,
- 0x0440, 0x843b, 0x84b3, 0x04c8, 0x85a3, 0x05d8, 0x0550, 0x852b,
- 0x8f03, 0x0f78, 0x0ff0, 0x8f8b, 0x0ee0, 0x8e9b, 0x8e13, 0x0e68,
- 0x0cc0, 0x8cbb, 0x8c33, 0x0c48, 0x8d23, 0x0d58, 0x0dd0, 0x8dab,
- 0x0880, 0x88fb, 0x8873, 0x0808, 0x8963, 0x0918, 0x0990, 0x89eb,
- 0x8b43, 0x0b38, 0x0bb0, 0x8bcb, 0x0aa0, 0x8adb, 0x8a53, 0x0a28,
- 0x9e03, 0x1e78, 0x1ef0, 0x9e8b, 0x1fe0, 0x9f9b, 0x9f13, 0x1f68,
- 0x1dc0, 0x9dbb, 0x9d33, 0x1d48, 0x9c23, 0x1c58, 0x1cd0, 0x9cab,
- 0x1980, 0x99fb, 0x9973, 0x1908, 0x9863, 0x1818, 0x1890, 0x98eb,
- 0x9a43, 0x1a38, 0x1ab0, 0x9acb, 0x1ba0, 0x9bdb, 0x9b53, 0x1b28,
- 0x1100, 0x917b, 0x91f3, 0x1188, 0x90e3, 0x1098, 0x1010, 0x906b,
- 0x92c3, 0x12b8, 0x1230, 0x924b, 0x1320, 0x935b, 0x93d3, 0x13a8,
- 0x9683, 0x16f8, 0x1670, 0x960b, 0x1760, 0x971b, 0x9793, 0x17e8,
- 0x1540, 0x953b, 0x95b3, 0x15c8, 0x94a3, 0x14d8, 0x1450, 0x942b,
- 0xbc03, 0x3c78, 0x3cf0, 0xbc8b, 0x3de0, 0xbd9b, 0xbd13, 0x3d68,
- 0x3fc0, 0xbfbb, 0xbf33, 0x3f48, 0xbe23, 0x3e58, 0x3ed0, 0xbeab,
- 0x3b80, 0xbbfb, 0xbb73, 0x3b08, 0xba63, 0x3a18, 0x3a90, 0xbaeb,
- 0xb843, 0x3838, 0x38b0, 0xb8cb, 0x39a0, 0xb9db, 0xb953, 0x3928,
- 0x3300, 0xb37b, 0xb3f3, 0x3388, 0xb2e3, 0x3298, 0x3210, 0xb26b,
- 0xb0c3, 0x30b8, 0x3030, 0xb04b, 0x3120, 0xb15b, 0xb1d3, 0x31a8,
- 0xb483, 0x34f8, 0x3470, 0xb40b, 0x3560, 0xb51b, 0xb593, 0x35e8,
- 0x3740, 0xb73b, 0xb7b3, 0x37c8, 0xb6a3, 0x36d8, 0x3650, 0xb62b,
- 0x2200, 0xa27b, 0xa2f3, 0x2288, 0xa3e3, 0x2398, 0x2310, 0xa36b,
- 0xa1c3, 0x21b8, 0x2130, 0xa14b, 0x2020, 0xa05b, 0xa0d3, 0x20a8,
- 0xa583, 0x25f8, 0x2570, 0xa50b, 0x2460, 0xa41b, 0xa493, 0x24e8,
- 0x2640, 0xa63b, 0xa6b3, 0x26c8, 0xa7a3, 0x27d8, 0x2750, 0xa72b,
- 0xad03, 0x2d78, 0x2df0, 0xad8b, 0x2ce0, 0xac9b, 0xac13, 0x2c68,
- 0x2ec0, 0xaebb, 0xae33, 0x2e48, 0xaf23, 0x2f58, 0x2fd0, 0xafab,
- 0x2a80, 0xaafb, 0xaa73, 0x2a08, 0xab63, 0x2b18, 0x2b90, 0xabeb,
- 0xa943, 0x2938, 0x29b0, 0xa9cb, 0x28a0, 0xa8db, 0xa853, 0x2828 },
-
- { 0x0000, 0xf803, 0x7003, 0x8800, 0xe006, 0x1805, 0x9005, 0x6806,
- 0x4009, 0xb80a, 0x300a, 0xc809, 0xa00f, 0x580c, 0xd00c, 0x280f,
- 0x8012, 0x7811, 0xf011, 0x0812, 0x6014, 0x9817, 0x1017, 0xe814,
- 0xc01b, 0x3818, 0xb018, 0x481b, 0x201d, 0xd81e, 0x501e, 0xa81d,
- 0x8021, 0x7822, 0xf022, 0x0821, 0x6027, 0x9824, 0x1024, 0xe827,
- 0xc028, 0x382b, 0xb02b, 0x4828, 0x202e, 0xd82d, 0x502d, 0xa82e,
- 0x0033, 0xf830, 0x7030, 0x8833, 0xe035, 0x1836, 0x9036, 0x6835,
- 0x403a, 0xb839, 0x3039, 0xc83a, 0xa03c, 0x583f, 0xd03f, 0x283c,
- 0x8047, 0x7844, 0xf044, 0x0847, 0x6041, 0x9842, 0x1042, 0xe841,
- 0xc04e, 0x384d, 0xb04d, 0x484e, 0x2048, 0xd84b, 0x504b, 0xa848,
- 0x0055, 0xf856, 0x7056, 0x8855, 0xe053, 0x1850, 0x9050, 0x6853,
- 0x405c, 0xb85f, 0x305f, 0xc85c, 0xa05a, 0x5859, 0xd059, 0x285a,
- 0x0066, 0xf865, 0x7065, 0x8866, 0xe060, 0x1863, 0x9063, 0x6860,
- 0x406f, 0xb86c, 0x306c, 0xc86f, 0xa069, 0x586a, 0xd06a, 0x2869,
- 0x8074, 0x7877, 0xf077, 0x0874, 0x6072, 0x9871, 0x1071, 0xe872,
- 0xc07d, 0x387e, 0xb07e, 0x487d, 0x207b, 0xd878, 0x5078, 0xa87b,
- 0x808b, 0x7888, 0xf088, 0x088b, 0x608d, 0x988e, 0x108e, 0xe88d,
- 0xc082, 0x3881, 0xb081, 0x4882, 0x2084, 0xd887, 0x5087, 0xa884,
- 0x0099, 0xf89a, 0x709a, 0x8899, 0xe09f, 0x189c, 0x909c, 0x689f,
- 0x4090, 0xb893, 0x3093, 0xc890, 0xa096, 0x5895, 0xd095, 0x2896,
- 0x00aa, 0xf8a9, 0x70a9, 0x88aa, 0xe0ac, 0x18af, 0x90af, 0x68ac,
- 0x40a3, 0xb8a0, 0x30a0, 0xc8a3, 0xa0a5, 0x58a6, 0xd0a6, 0x28a5,
- 0x80b8, 0x78bb, 0xf0bb, 0x08b8, 0x60be, 0x98bd, 0x10bd, 0xe8be,
- 0xc0b1, 0x38b2, 0xb0b2, 0x48b1, 0x20b7, 0xd8b4, 0x50b4, 0xa8b7,
- 0x00cc, 0xf8cf, 0x70cf, 0x88cc, 0xe0ca, 0x18c9, 0x90c9, 0x68ca,
- 0x40c5, 0xb8c6, 0x30c6, 0xc8c5, 0xa0c3, 0x58c0, 0xd0c0, 0x28c3,
- 0x80de, 0x78dd, 0xf0dd, 0x08de, 0x60d8, 0x98db, 0x10db, 0xe8d8,
- 0xc0d7, 0x38d4, 0xb0d4, 0x48d7, 0x20d1, 0xd8d2, 0x50d2, 0xa8d1,
- 0x80ed, 0x78ee, 0xf0ee, 0x08ed, 0x60eb, 0x98e8, 0x10e8, 0xe8eb,
- 0xc0e4, 0x38e7, 0xb0e7, 0x48e4, 0x20e2, 0xd8e1, 0x50e1, 0xa8e2,
- 0x00ff, 0xf8fc, 0x70fc, 0x88ff, 0xe0f9, 0x18fa, 0x90fa, 0x68f9,
- 0x40f6, 0xb8f5, 0x30f5, 0xc8f6, 0xa0f0, 0x58f3, 0xd0f3, 0x28f0 },
-
- { 0x0000, 0x8113, 0x8223, 0x0330, 0x8443, 0x0550, 0x0660, 0x8773,
- 0x8883, 0x0990, 0x0aa0, 0x8bb3, 0x0cc0, 0x8dd3, 0x8ee3, 0x0ff0,
- 0x9103, 0x1010, 0x1320, 0x9233, 0x1540, 0x9453, 0x9763, 0x1670,
- 0x1980, 0x9893, 0x9ba3, 0x1ab0, 0x9dc3, 0x1cd0, 0x1fe0, 0x9ef3,
- 0xa203, 0x2310, 0x2020, 0xa133, 0x2640, 0xa753, 0xa463, 0x2570,
- 0x2a80, 0xab93, 0xa8a3, 0x29b0, 0xaec3, 0x2fd0, 0x2ce0, 0xadf3,
- 0x3300, 0xb213, 0xb123, 0x3030, 0xb743, 0x3650, 0x3560, 0xb473,
- 0xbb83, 0x3a90, 0x39a0, 0xb8b3, 0x3fc0, 0xbed3, 0xbde3, 0x3cf0,
- 0xc403, 0x4510, 0x4620, 0xc733, 0x4040, 0xc153, 0xc263, 0x4370,
- 0x4c80, 0xcd93, 0xcea3, 0x4fb0, 0xc8c3, 0x49d0, 0x4ae0, 0xcbf3,
- 0x5500, 0xd413, 0xd723, 0x5630, 0xd143, 0x5050, 0x5360, 0xd273,
- 0xdd83, 0x5c90, 0x5fa0, 0xdeb3, 0x59c0, 0xd8d3, 0xdbe3, 0x5af0,
- 0x6600, 0xe713, 0xe423, 0x6530, 0xe243, 0x6350, 0x6060, 0xe173,
- 0xee83, 0x6f90, 0x6ca0, 0xedb3, 0x6ac0, 0xebd3, 0xe8e3, 0x69f0,
- 0xf703, 0x7610, 0x7520, 0xf433, 0x7340, 0xf253, 0xf163, 0x7070,
- 0x7f80, 0xfe93, 0xfda3, 0x7cb0, 0xfbc3, 0x7ad0, 0x79e0, 0xf8f3,
- 0x0803, 0x8910, 0x8a20, 0x0b33, 0x8c40, 0x0d53, 0x0e63, 0x8f70,
- 0x8080, 0x0193, 0x02a3, 0x83b0, 0x04c3, 0x85d0, 0x86e0, 0x07f3,
- 0x9900, 0x1813, 0x1b23, 0x9a30, 0x1d43, 0x9c50, 0x9f60, 0x1e73,
- 0x1183, 0x9090, 0x93a0, 0x12b3, 0x95c0, 0x14d3, 0x17e3, 0x96f0,
- 0xaa00, 0x2b13, 0x2823, 0xa930, 0x2e43, 0xaf50, 0xac60, 0x2d73,
- 0x2283, 0xa390, 0xa0a0, 0x21b3, 0xa6c0, 0x27d3, 0x24e3, 0xa5f0,
- 0x3b03, 0xba10, 0xb920, 0x3833, 0xbf40, 0x3e53, 0x3d63, 0xbc70,
- 0xb380, 0x3293, 0x31a3, 0xb0b0, 0x37c3, 0xb6d0, 0xb5e0, 0x34f3,
- 0xcc00, 0x4d13, 0x4e23, 0xcf30, 0x4843, 0xc950, 0xca60, 0x4b73,
- 0x4483, 0xc590, 0xc6a0, 0x47b3, 0xc0c0, 0x41d3, 0x42e3, 0xc3f0,
- 0x5d03, 0xdc10, 0xdf20, 0x5e33, 0xd940, 0x5853, 0x5b63, 0xda70,
- 0xd580, 0x5493, 0x57a3, 0xd6b0, 0x51c3, 0xd0d0, 0xd3e0, 0x52f3,
- 0x6e03, 0xef10, 0xec20, 0x6d33, 0xea40, 0x6b53, 0x6863, 0xe970,
- 0xe680, 0x6793, 0x64a3, 0xe5b0, 0x62c3, 0xe3d0, 0xe0e0, 0x61f3,
- 0xff00, 0x7e13, 0x7d23, 0xfc30, 0x7b43, 0xfa50, 0xf960, 0x7873,
- 0x7783, 0xf690, 0xf5a0, 0x74b3, 0xf3c0, 0x72d3, 0x71e3, 0xf0f0 },
-
- { 0x0000, 0x1006, 0x200c, 0x300a, 0x4018, 0x501e, 0x6014, 0x7012,
- 0x8030, 0x9036, 0xa03c, 0xb03a, 0xc028, 0xd02e, 0xe024, 0xf022,
- 0x8065, 0x9063, 0xa069, 0xb06f, 0xc07d, 0xd07b, 0xe071, 0xf077,
- 0x0055, 0x1053, 0x2059, 0x305f, 0x404d, 0x504b, 0x6041, 0x7047,
- 0x80cf, 0x90c9, 0xa0c3, 0xb0c5, 0xc0d7, 0xd0d1, 0xe0db, 0xf0dd,
- 0x00ff, 0x10f9, 0x20f3, 0x30f5, 0x40e7, 0x50e1, 0x60eb, 0x70ed,
- 0x00aa, 0x10ac, 0x20a6, 0x30a0, 0x40b2, 0x50b4, 0x60be, 0x70b8,
- 0x809a, 0x909c, 0xa096, 0xb090, 0xc082, 0xd084, 0xe08e, 0xf088,
- 0x819b, 0x919d, 0xa197, 0xb191, 0xc183, 0xd185, 0xe18f, 0xf189,
- 0x01ab, 0x11ad, 0x21a7, 0x31a1, 0x41b3, 0x51b5, 0x61bf, 0x71b9,
- 0x01fe, 0x11f8, 0x21f2, 0x31f4, 0x41e6, 0x51e0, 0x61ea, 0x71ec,
- 0x81ce, 0x91c8, 0xa1c2, 0xb1c4, 0xc1d6, 0xd1d0, 0xe1da, 0xf1dc,
- 0x0154, 0x1152, 0x2158, 0x315e, 0x414c, 0x514a, 0x6140, 0x7146,
- 0x8164, 0x9162, 0xa168, 0xb16e, 0xc17c, 0xd17a, 0xe170, 0xf176,
- 0x8131, 0x9137, 0xa13d, 0xb13b, 0xc129, 0xd12f, 0xe125, 0xf123,
- 0x0101, 0x1107, 0x210d, 0x310b, 0x4119, 0x511f, 0x6115, 0x7113,
- 0x8333, 0x9335, 0xa33f, 0xb339, 0xc32b, 0xd32d, 0xe327, 0xf321,
- 0x0303, 0x1305, 0x230f, 0x3309, 0x431b, 0x531d, 0x6317, 0x7311,
- 0x0356, 0x1350, 0x235a, 0x335c, 0x434e, 0x5348, 0x6342, 0x7344,
- 0x8366, 0x9360, 0xa36a, 0xb36c, 0xc37e, 0xd378, 0xe372, 0xf374,
- 0x03fc, 0x13fa, 0x23f0, 0x33f6, 0x43e4, 0x53e2, 0x63e8, 0x73ee,
- 0x83cc, 0x93ca, 0xa3c0, 0xb3c6, 0xc3d4, 0xd3d2, 0xe3d8, 0xf3de,
- 0x8399, 0x939f, 0xa395, 0xb393, 0xc381, 0xd387, 0xe38d, 0xf38b,
- 0x03a9, 0x13af, 0x23a5, 0x33a3, 0x43b1, 0x53b7, 0x63bd, 0x73bb,
- 0x02a8, 0x12ae, 0x22a4, 0x32a2, 0x42b0, 0x52b6, 0x62bc, 0x72ba,
- 0x8298, 0x929e, 0xa294, 0xb292, 0xc280, 0xd286, 0xe28c, 0xf28a,
- 0x82cd, 0x92cb, 0xa2c1, 0xb2c7, 0xc2d5, 0xd2d3, 0xe2d9, 0xf2df,
- 0x02fd, 0x12fb, 0x22f1, 0x32f7, 0x42e5, 0x52e3, 0x62e9, 0x72ef,
- 0x8267, 0x9261, 0xa26b, 0xb26d, 0xc27f, 0xd279, 0xe273, 0xf275,
- 0x0257, 0x1251, 0x225b, 0x325d, 0x424f, 0x5249, 0x6243, 0x7245,
- 0x0202, 0x1204, 0x220e, 0x3208, 0x421a, 0x521c, 0x6216, 0x7210,
- 0x8232, 0x9234, 0xa23e, 0xb238, 0xc22a, 0xd22c, 0xe226, 0xf220 }
-};
-
-#if 0
-void FLAC__crc16_init_table(void)
-{
- int i, j;
- FLAC__uint16 polynomial, crc;
- polynomial = 0x8005;
-
- for(i = 0; i <= 0xFF; i++){
- crc = i << 8;
-
- for(j = 0; j < 8; j++)
- crc = (crc << 1) ^ (crc & (1 << 15) ? polynomial : 0);
-
- FLAC__crc16_table[0][i] = crc;
- }
-
- for(i = 0; i <= 0xFF; i++)
- for(j = 1; j < 8; j++)
- FLAC__crc16_table[j][i] = FLAC__crc16_table[0][FLAC__crc16_table[j - 1][i] >> 8] ^ (FLAC__crc16_table[j - 1][i] << 8);
-}
-#endif
-
-FLAC__uint8 FLAC__crc8(const FLAC__byte *data, uint32_t len)
-{
- FLAC__uint8 crc = 0;
-
- while(len--)
- crc = FLAC__crc8_table[crc ^ *data++];
-
- return crc;
-}
-
-FLAC__uint16 FLAC__crc16(const FLAC__byte *data, uint32_t len)
-{
- FLAC__uint16 crc = 0;
-
- while(len >= 8){
- crc ^= data[0] << 8 | data[1];
-
- crc = FLAC__crc16_table[7][crc >> 8] ^ FLAC__crc16_table[6][crc & 0xFF] ^
- FLAC__crc16_table[5][data[2] ] ^ FLAC__crc16_table[4][data[3] ] ^
- FLAC__crc16_table[3][data[4] ] ^ FLAC__crc16_table[2][data[5] ] ^
- FLAC__crc16_table[1][data[6] ] ^ FLAC__crc16_table[0][data[7] ];
-
- data += 8;
- len -= 8;
- }
-
- while(len--)
- crc = (crc<<8) ^ FLAC__crc16_table[0][(crc>>8) ^ *data++];
-
- return crc;
-}
-
-FLAC__uint16 FLAC__crc16_update_words32(const FLAC__uint32 *words, uint32_t len, FLAC__uint16 crc)
-{
- while (len >= 2) {
- crc ^= words[0] >> 16;
-
- crc = FLAC__crc16_table[7][crc >> 8 ] ^ FLAC__crc16_table[6][crc & 0xFF ] ^
- FLAC__crc16_table[5][(words[0] >> 8) & 0xFF] ^ FLAC__crc16_table[4][ words[0] & 0xFF] ^
- FLAC__crc16_table[3][ words[1] >> 24 ] ^ FLAC__crc16_table[2][(words[1] >> 16) & 0xFF] ^
- FLAC__crc16_table[1][(words[1] >> 8) & 0xFF] ^ FLAC__crc16_table[0][ words[1] & 0xFF];
-
- words += 2;
- len -= 2;
- }
-
- if (len) {
- crc ^= words[0] >> 16;
-
- crc = FLAC__crc16_table[3][crc >> 8 ] ^ FLAC__crc16_table[2][crc & 0xFF ] ^
- FLAC__crc16_table[1][(words[0] >> 8) & 0xFF] ^ FLAC__crc16_table[0][words[0] & 0xFF];
- }
-
- return crc;
-}
-
-FLAC__uint16 FLAC__crc16_update_words64(const FLAC__uint64 *words, uint32_t len, FLAC__uint16 crc)
-{
- while (len--) {
- crc ^= words[0] >> 48;
-
- crc = FLAC__crc16_table[7][crc >> 8 ] ^ FLAC__crc16_table[6][crc & 0xFF ] ^
- FLAC__crc16_table[5][(words[0] >> 40) & 0xFF] ^ FLAC__crc16_table[4][(words[0] >> 32) & 0xFF] ^
- FLAC__crc16_table[3][(words[0] >> 24) & 0xFF] ^ FLAC__crc16_table[2][(words[0] >> 16) & 0xFF] ^
- FLAC__crc16_table[1][(words[0] >> 8) & 0xFF] ^ FLAC__crc16_table[0][ words[0] & 0xFF];
-
- words++;
- }
-
- return crc;
-}
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/fixed.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/fixed.c
deleted file mode 100644
index 23028fbd0e..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/fixed.c
+++ /dev/null
@@ -1,667 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include
-#include
-#include "../compat.h"
-#include "include/private/bitmath.h"
-#include "include/private/fixed.h"
-
-#include "../assert.h"
-
-#ifdef local_abs
-#undef local_abs
-#endif
-#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x)))
-
-#ifdef local_abs64
-#undef local_abs64
-#endif
-#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x)))
-
-#ifdef FLAC__INTEGER_ONLY_LIBRARY
-/* rbps stands for residual bits per sample
- *
- * (ln(2) * err)
- * rbps = log (-----------)
- * 2 ( n )
- */
-static FLAC__fixedpoint local__compute_rbps_integerized(FLAC__uint32 err, FLAC__uint32 n)
-{
- FLAC__uint32 rbps;
- uint32_t bits; /* the number of bits required to represent a number */
- int fracbits; /* the number of bits of rbps that comprise the fractional part */
-
- FLAC__ASSERT(sizeof(rbps) == sizeof(FLAC__fixedpoint));
- FLAC__ASSERT(err > 0);
- FLAC__ASSERT(n > 0);
-
- FLAC__ASSERT(n <= FLAC__MAX_BLOCK_SIZE);
- if(err <= n)
- return 0;
- /*
- * The above two things tell us 1) n fits in 16 bits; 2) err/n > 1.
- * These allow us later to know we won't lose too much precision in the
- * fixed-point division (err< 0);
- bits = FLAC__bitmath_ilog2(err)+1;
- if(bits > 16) {
- err >>= (bits-16);
- fracbits -= (bits-16);
- }
- rbps = (FLAC__uint32)err;
-
- /* Multiply by fixed-point version of ln(2), with 16 fractional bits */
- rbps *= FLAC__FP_LN2;
- fracbits += 16;
- FLAC__ASSERT(fracbits >= 0);
-
- /* FLAC__fixedpoint_log2 requires fracbits%4 to be 0 */
- {
- const int f = fracbits & 3;
- if(f) {
- rbps >>= f;
- fracbits -= f;
- }
- }
-
- rbps = FLAC__fixedpoint_log2(rbps, fracbits, (uint32_t)(-1));
-
- if(rbps == 0)
- return 0;
-
- /*
- * The return value must have 16 fractional bits. Since the whole part
- * of the base-2 log of a 32 bit number must fit in 5 bits, and fracbits
- * must be >= -3, these assertion allows us to be able to shift rbps
- * left if necessary to get 16 fracbits without losing any bits of the
- * whole part of rbps.
- *
- * There is a slight chance due to accumulated error that the whole part
- * will require 6 bits, so we use 6 in the assertion. Really though as
- * long as it fits in 13 bits (32 - (16 - (-3))) we are fine.
- */
- FLAC__ASSERT((int)FLAC__bitmath_ilog2(rbps)+1 <= fracbits + 6);
- FLAC__ASSERT(fracbits >= -3);
-
- /* now shift the decimal point into place */
- if(fracbits < 16)
- return rbps << (16-fracbits);
- else if(fracbits > 16)
- return rbps >> (fracbits-16);
- else
- return rbps;
-}
-
-static FLAC__fixedpoint local__compute_rbps_wide_integerized(FLAC__uint64 err, FLAC__uint32 n)
-{
- FLAC__uint32 rbps;
- uint32_t bits; /* the number of bits required to represent a number */
- int fracbits; /* the number of bits of rbps that comprise the fractional part */
-
- FLAC__ASSERT(sizeof(rbps) == sizeof(FLAC__fixedpoint));
- FLAC__ASSERT(err > 0);
- FLAC__ASSERT(n > 0);
-
- FLAC__ASSERT(n <= FLAC__MAX_BLOCK_SIZE);
- if(err <= n)
- return 0;
- /*
- * The above two things tell us 1) n fits in 16 bits; 2) err/n > 1.
- * These allow us later to know we won't lose too much precision in the
- * fixed-point division (err< 0);
- bits = FLAC__bitmath_ilog2_wide(err)+1;
- if(bits > 16) {
- err >>= (bits-16);
- fracbits -= (bits-16);
- }
- rbps = (FLAC__uint32)err;
-
- /* Multiply by fixed-point version of ln(2), with 16 fractional bits */
- rbps *= FLAC__FP_LN2;
- fracbits += 16;
- FLAC__ASSERT(fracbits >= 0);
-
- /* FLAC__fixedpoint_log2 requires fracbits%4 to be 0 */
- {
- const int f = fracbits & 3;
- if(f) {
- rbps >>= f;
- fracbits -= f;
- }
- }
-
- rbps = FLAC__fixedpoint_log2(rbps, fracbits, (uint32_t)(-1));
-
- if(rbps == 0)
- return 0;
-
- /*
- * The return value must have 16 fractional bits. Since the whole part
- * of the base-2 log of a 32 bit number must fit in 5 bits, and fracbits
- * must be >= -3, these assertion allows us to be able to shift rbps
- * left if necessary to get 16 fracbits without losing any bits of the
- * whole part of rbps.
- *
- * There is a slight chance due to accumulated error that the whole part
- * will require 6 bits, so we use 6 in the assertion. Really though as
- * long as it fits in 13 bits (32 - (16 - (-3))) we are fine.
- */
- FLAC__ASSERT((int)FLAC__bitmath_ilog2(rbps)+1 <= fracbits + 6);
- FLAC__ASSERT(fracbits >= -3);
-
- /* now shift the decimal point into place */
- if(fracbits < 16)
- return rbps << (16-fracbits);
- else if(fracbits > 16)
- return rbps >> (fracbits-16);
- else
- return rbps;
-}
-#endif
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-uint32_t FLAC__fixed_compute_best_predictor(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
-#else
-uint32_t FLAC__fixed_compute_best_predictor(const FLAC__int32 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
-#endif
-{
- FLAC__uint32 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0;
- uint32_t order;
-#if 0
- /* This code has been around a long time, and was written when compilers weren't able
- * to vectorize code. These days, compilers are better in optimizing the next block
- * which is also much more readable
- */
- FLAC__int32 last_error_0 = data[-1];
- FLAC__int32 last_error_1 = data[-1] - data[-2];
- FLAC__int32 last_error_2 = last_error_1 - (data[-2] - data[-3]);
- FLAC__int32 last_error_3 = last_error_2 - (data[-2] - 2*data[-3] + data[-4]);
- FLAC__int32 error, save;
- uint32_t i;
- /* total_error_* are 64-bits to avoid overflow when encoding
- * erratic signals when the bits-per-sample and blocksize are
- * large.
- */
- for(i = 0; i < data_len; i++) {
- error = data[i] ; total_error_0 += local_abs(error); save = error;
- error -= last_error_0; total_error_1 += local_abs(error); last_error_0 = save; save = error;
- error -= last_error_1; total_error_2 += local_abs(error); last_error_1 = save; save = error;
- error -= last_error_2; total_error_3 += local_abs(error); last_error_2 = save; save = error;
- error -= last_error_3; total_error_4 += local_abs(error); last_error_3 = save;
- }
-#else
- int i;
- for(i = 0; i < (int)data_len; i++) {
- total_error_0 += local_abs(data[i]);
- total_error_1 += local_abs(data[i] - data[i-1]);
- total_error_2 += local_abs(data[i] - 2 * data[i-1] + data[i-2]);
- total_error_3 += local_abs(data[i] - 3 * data[i-1] + 3 * data[i-2] - data[i-3]);
- total_error_4 += local_abs(data[i] - 4 * data[i-1] + 6 * data[i-2] - 4 * data[i-3] + data[i-4]);
- }
-#endif
-
-
- /* prefer lower order */
- if(total_error_0 <= flac_min(flac_min(flac_min(total_error_1, total_error_2), total_error_3), total_error_4))
- order = 0;
- else if(total_error_1 <= flac_min(flac_min(total_error_2, total_error_3), total_error_4))
- order = 1;
- else if(total_error_2 <= flac_min(total_error_3, total_error_4))
- order = 2;
- else if(total_error_3 <= total_error_4)
- order = 3;
- else
- order = 4;
-
- /* Estimate the expected number of bits per residual signal sample. */
- /* 'total_error*' is linearly related to the variance of the residual */
- /* signal, so we use it directly to compute E(|x|) */
- FLAC__ASSERT(data_len > 0 || total_error_0 == 0);
- FLAC__ASSERT(data_len > 0 || total_error_1 == 0);
- FLAC__ASSERT(data_len > 0 || total_error_2 == 0);
- FLAC__ASSERT(data_len > 0 || total_error_3 == 0);
- FLAC__ASSERT(data_len > 0 || total_error_4 == 0);
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- residual_bits_per_sample[0] = (float)((total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double)data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[1] = (float)((total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double)data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[2] = (float)((total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double)data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[3] = (float)((total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double)data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[4] = (float)((total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double)data_len) / M_LN2 : 0.0);
-#else
- residual_bits_per_sample[0] = (total_error_0 > 0) ? local__compute_rbps_integerized(total_error_0, data_len) : 0;
- residual_bits_per_sample[1] = (total_error_1 > 0) ? local__compute_rbps_integerized(total_error_1, data_len) : 0;
- residual_bits_per_sample[2] = (total_error_2 > 0) ? local__compute_rbps_integerized(total_error_2, data_len) : 0;
- residual_bits_per_sample[3] = (total_error_3 > 0) ? local__compute_rbps_integerized(total_error_3, data_len) : 0;
- residual_bits_per_sample[4] = (total_error_4 > 0) ? local__compute_rbps_integerized(total_error_4, data_len) : 0;
-#endif
-
- return order;
-}
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-uint32_t FLAC__fixed_compute_best_predictor_wide(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
-#else
-uint32_t FLAC__fixed_compute_best_predictor_wide(const FLAC__int32 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
-#endif
-{
- FLAC__uint64 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0;
- uint32_t order;
- int i;
-
- for(i = 0; i < (int)data_len; i++) {
- total_error_0 += local_abs(data[i]);
- total_error_1 += local_abs(data[i] - data[i-1]);
- total_error_2 += local_abs(data[i] - 2 * data[i-1] + data[i-2]);
- total_error_3 += local_abs(data[i] - 3 * data[i-1] + 3 * data[i-2] - data[i-3]);
- total_error_4 += local_abs(data[i] - 4 * data[i-1] + 6 * data[i-2] - 4 * data[i-3] + data[i-4]);
- }
-
- /* prefer lower order */
- if(total_error_0 <= flac_min(flac_min(flac_min(total_error_1, total_error_2), total_error_3), total_error_4))
- order = 0;
- else if(total_error_1 <= flac_min(flac_min(total_error_2, total_error_3), total_error_4))
- order = 1;
- else if(total_error_2 <= flac_min(total_error_3, total_error_4))
- order = 2;
- else if(total_error_3 <= total_error_4)
- order = 3;
- else
- order = 4;
-
- /* Estimate the expected number of bits per residual signal sample. */
- /* 'total_error*' is linearly related to the variance of the residual */
- /* signal, so we use it directly to compute E(|x|) */
- FLAC__ASSERT(data_len > 0 || total_error_0 == 0);
- FLAC__ASSERT(data_len > 0 || total_error_1 == 0);
- FLAC__ASSERT(data_len > 0 || total_error_2 == 0);
- FLAC__ASSERT(data_len > 0 || total_error_3 == 0);
- FLAC__ASSERT(data_len > 0 || total_error_4 == 0);
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- residual_bits_per_sample[0] = (float)((total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double)data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[1] = (float)((total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double)data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[2] = (float)((total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double)data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[3] = (float)((total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double)data_len) / M_LN2 : 0.0);
- residual_bits_per_sample[4] = (float)((total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double)data_len) / M_LN2 : 0.0);
-#else
- residual_bits_per_sample[0] = (total_error_0 > 0) ? local__compute_rbps_wide_integerized(total_error_0, data_len) : 0;
- residual_bits_per_sample[1] = (total_error_1 > 0) ? local__compute_rbps_wide_integerized(total_error_1, data_len) : 0;
- residual_bits_per_sample[2] = (total_error_2 > 0) ? local__compute_rbps_wide_integerized(total_error_2, data_len) : 0;
- residual_bits_per_sample[3] = (total_error_3 > 0) ? local__compute_rbps_wide_integerized(total_error_3, data_len) : 0;
- residual_bits_per_sample[4] = (total_error_4 > 0) ? local__compute_rbps_wide_integerized(total_error_4, data_len) : 0;
-#endif
-
- return order;
-}
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-#define CHECK_ORDER_IS_VALID(macro_order) \
-if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \
- order = macro_order; \
- smallest_error = total_error_##macro_order ; \
- residual_bits_per_sample[ macro_order ] = (float)((total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double)data_len) / M_LN2 : 0.0); \
-} \
-else \
- residual_bits_per_sample[ macro_order ] = 34.0f;
-#else
-#define CHECK_ORDER_IS_VALID(macro_order) \
-if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \
- order = macro_order; \
- smallest_error = total_error_##macro_order ; \
- residual_bits_per_sample[ macro_order ] = (total_error_##macro_order > 0) ? local__compute_rbps_wide_integerized(total_error_##macro_order, data_len) : 0; \
-} \
-else \
- residual_bits_per_sample[ macro_order ] = 34 * FLAC__FP_ONE;
-#endif
-
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
-#else
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual(const FLAC__int32 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
-#endif
-{
- FLAC__uint64 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0, smallest_error = UINT64_MAX;
- FLAC__uint64 error_0, error_1, error_2, error_3, error_4;
- FLAC__bool order_0_is_valid = true, order_1_is_valid = true, order_2_is_valid = true, order_3_is_valid = true, order_4_is_valid = true;
- uint32_t order = 0;
- int i;
-
- for(i = -4; i < (int)data_len; i++) {
- error_0 = local_abs64((FLAC__int64)data[i]);
- error_1 = (i > -4) ? local_abs64((FLAC__int64)data[i] - data[i-1]) : 0 ;
- error_2 = (i > -3) ? local_abs64((FLAC__int64)data[i] - 2 * (FLAC__int64)data[i-1] + data[i-2]) : 0;
- error_3 = (i > -2) ? local_abs64((FLAC__int64)data[i] - 3 * (FLAC__int64)data[i-1] + 3 * (FLAC__int64)data[i-2] - data[i-3]) : 0;
- error_4 = (i > -1) ? local_abs64((FLAC__int64)data[i] - 4 * (FLAC__int64)data[i-1] + 6 * (FLAC__int64)data[i-2] - 4 * (FLAC__int64)data[i-3] + data[i-4]) : 0;
-
- total_error_0 += error_0;
- total_error_1 += error_1;
- total_error_2 += error_2;
- total_error_3 += error_3;
- total_error_4 += error_4;
-
- /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */
- if(error_0 > INT32_MAX)
- order_0_is_valid = false;
- if(error_1 > INT32_MAX)
- order_1_is_valid = false;
- if(error_2 > INT32_MAX)
- order_2_is_valid = false;
- if(error_3 > INT32_MAX)
- order_3_is_valid = false;
- if(error_4 > INT32_MAX)
- order_4_is_valid = false;
- }
-
- CHECK_ORDER_IS_VALID(0);
- CHECK_ORDER_IS_VALID(1);
- CHECK_ORDER_IS_VALID(2);
- CHECK_ORDER_IS_VALID(3);
- CHECK_ORDER_IS_VALID(4);
-
- return order;
-}
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual_33bit(const FLAC__int64 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
-#else
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual_33bit(const FLAC__int64 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1])
-#endif
-{
- FLAC__uint64 total_error_0 = 0, total_error_1 = 0, total_error_2 = 0, total_error_3 = 0, total_error_4 = 0, smallest_error = UINT64_MAX;
- FLAC__uint64 error_0, error_1, error_2, error_3, error_4;
- FLAC__bool order_0_is_valid = true, order_1_is_valid = true, order_2_is_valid = true, order_3_is_valid = true, order_4_is_valid = true;
- uint32_t order = 0;
- int i;
-
- for(i = -4; i < (int)data_len; i++) {
- error_0 = local_abs64(data[i]);
- error_1 = (i > -4) ? local_abs64(data[i] - data[i-1]) : 0 ;
- error_2 = (i > -3) ? local_abs64(data[i] - 2 * data[i-1] + data[i-2]) : 0;
- error_3 = (i > -2) ? local_abs64(data[i] - 3 * data[i-1] + 3 * data[i-2] - data[i-3]) : 0;
- error_4 = (i > -1) ? local_abs64(data[i] - 4 * data[i-1] + 6 * data[i-2] - 4 * data[i-3] + data[i-4]) : 0;
-
- total_error_0 += error_0;
- total_error_1 += error_1;
- total_error_2 += error_2;
- total_error_3 += error_3;
- total_error_4 += error_4;
-
- /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */
- if(error_0 > INT32_MAX)
- order_0_is_valid = false;
- if(error_1 > INT32_MAX)
- order_1_is_valid = false;
- if(error_2 > INT32_MAX)
- order_2_is_valid = false;
- if(error_3 > INT32_MAX)
- order_3_is_valid = false;
- if(error_4 > INT32_MAX)
- order_4_is_valid = false;
- }
-
- CHECK_ORDER_IS_VALID(0);
- CHECK_ORDER_IS_VALID(1);
- CHECK_ORDER_IS_VALID(2);
- CHECK_ORDER_IS_VALID(3);
- CHECK_ORDER_IS_VALID(4);
-
- return order;
-}
-
-void FLAC__fixed_compute_residual(const FLAC__int32 data[], uint32_t data_len, uint32_t order, FLAC__int32 residual[])
-{
- const int idata_len = (int)data_len;
- int i;
-
- switch(order) {
- case 0:
- FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0]));
- memcpy(residual, data, sizeof(residual[0])*data_len);
- break;
- case 1:
- for(i = 0; i < idata_len; i++)
- residual[i] = data[i] - data[i-1];
- break;
- case 2:
- for(i = 0; i < idata_len; i++)
- residual[i] = data[i] - 2*data[i-1] + data[i-2];
- break;
- case 3:
- for(i = 0; i < idata_len; i++)
- residual[i] = data[i] - 3*data[i-1] + 3*data[i-2] - data[i-3];
- break;
- case 4:
- for(i = 0; i < idata_len; i++)
- residual[i] = data[i] - 4*data[i-1] + 6*data[i-2] - 4*data[i-3] + data[i-4];
- break;
- default:
- FLAC__ASSERT(0);
- }
-}
-
-void FLAC__fixed_compute_residual_wide(const FLAC__int32 data[], uint32_t data_len, uint32_t order, FLAC__int32 residual[])
-{
- const int idata_len = (int)data_len;
- int i;
-
- switch(order) {
- case 0:
- FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0]));
- memcpy(residual, data, sizeof(residual[0])*data_len);
- break;
- case 1:
- for(i = 0; i < idata_len; i++)
- residual[i] = (FLAC__int64)data[i] - data[i-1];
- break;
- case 2:
- for(i = 0; i < idata_len; i++)
- residual[i] = (FLAC__int64)data[i] - 2*(FLAC__int64)data[i-1] + data[i-2];
- break;
- case 3:
- for(i = 0; i < idata_len; i++)
- residual[i] = (FLAC__int64)data[i] - 3*(FLAC__int64)data[i-1] + 3*(FLAC__int64)data[i-2] - data[i-3];
- break;
- case 4:
- for(i = 0; i < idata_len; i++)
- residual[i] = (FLAC__int64)data[i] - 4*(FLAC__int64)data[i-1] + 6*(FLAC__int64)data[i-2] - 4*(FLAC__int64)data[i-3] + data[i-4];
- break;
- default:
- FLAC__ASSERT(0);
- }
-}
-
-void FLAC__fixed_compute_residual_wide_33bit(const FLAC__int64 data[], uint32_t data_len, uint32_t order, FLAC__int32 residual[])
-{
- const int idata_len = (int)data_len;
- int i;
-
- switch(order) {
- case 0:
- for(i = 0; i < idata_len; i++)
- residual[i] = data[i];
- break;
- case 1:
- for(i = 0; i < idata_len; i++)
- residual[i] = data[i] - data[i-1];
- break;
- case 2:
- for(i = 0; i < idata_len; i++)
- residual[i] = data[i] - 2*data[i-1] + data[i-2];
- break;
- case 3:
- for(i = 0; i < idata_len; i++)
- residual[i] = data[i] - 3*data[i-1] + 3*data[i-2] - data[i-3];
- break;
- case 4:
- for(i = 0; i < idata_len; i++)
- residual[i] = data[i] - 4*data[i-1] + 6*data[i-2] - 4*data[i-3] + data[i-4];
- break;
- default:
- FLAC__ASSERT(0);
- }
-}
-
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && !defined(FUZZING_BUILD_MODE_FLAC_SANITIZE_SIGNED_INTEGER_OVERFLOW)
-/* The attribute below is to silence the undefined sanitizer of oss-fuzz.
- * Because fuzzing feeds bogus predictors and residual samples to the
- * decoder, having overflows in this section is unavoidable. Also,
- * because the calculated values are audio path only, there is no
- * potential for security problems */
-__attribute__((no_sanitize("signed-integer-overflow")))
-#endif
-void FLAC__fixed_restore_signal(const FLAC__int32 residual[], uint32_t data_len, uint32_t order, FLAC__int32 data[])
-{
- int i, idata_len = (int)data_len;
-
- switch(order) {
- case 0:
- FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0]));
- memcpy(data, residual, sizeof(residual[0])*data_len);
- break;
- case 1:
- for(i = 0; i < idata_len; i++)
- data[i] = residual[i] + data[i-1];
- break;
- case 2:
- for(i = 0; i < idata_len; i++)
- data[i] = residual[i] + 2*data[i-1] - data[i-2];
- break;
- case 3:
- for(i = 0; i < idata_len; i++)
- data[i] = residual[i] + 3*data[i-1] - 3*data[i-2] + data[i-3];
- break;
- case 4:
- for(i = 0; i < idata_len; i++)
- data[i] = residual[i] + 4*data[i-1] - 6*data[i-2] + 4*data[i-3] - data[i-4];
- break;
- default:
- FLAC__ASSERT(0);
- }
-}
-
-void FLAC__fixed_restore_signal_wide(const FLAC__int32 residual[], uint32_t data_len, uint32_t order, FLAC__int32 data[])
-{
- int i, idata_len = (int)data_len;
-
- switch(order) {
- case 0:
- FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0]));
- memcpy(data, residual, sizeof(residual[0])*data_len);
- break;
- case 1:
- for(i = 0; i < idata_len; i++)
- data[i] = (FLAC__int64)residual[i] + (FLAC__int64)data[i-1];
- break;
- case 2:
- for(i = 0; i < idata_len; i++)
- data[i] = (FLAC__int64)residual[i] + 2*(FLAC__int64)data[i-1] - (FLAC__int64)data[i-2];
- break;
- case 3:
- for(i = 0; i < idata_len; i++)
- data[i] = (FLAC__int64)residual[i] + 3*(FLAC__int64)data[i-1] - 3*(FLAC__int64)data[i-2] + (FLAC__int64)data[i-3];
- break;
- case 4:
- for(i = 0; i < idata_len; i++)
- data[i] = (FLAC__int64)residual[i] + 4*(FLAC__int64)data[i-1] - 6*(FLAC__int64)data[i-2] + 4*(FLAC__int64)data[i-3] - (FLAC__int64)data[i-4];
- break;
- default:
- FLAC__ASSERT(0);
- }
-}
-
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && !defined(FUZZING_BUILD_MODE_FLAC_SANITIZE_SIGNED_INTEGER_OVERFLOW)
-/* The attribute below is to silence the undefined sanitizer of oss-fuzz.
- * Because fuzzing feeds bogus predictors and residual samples to the
- * decoder, having overflows in this section is unavoidable. Also,
- * because the calculated values are audio path only, there is no
- * potential for security problems */
-__attribute__((no_sanitize("signed-integer-overflow")))
-#endif
-void FLAC__fixed_restore_signal_wide_33bit(const FLAC__int32 residual[], uint32_t data_len, uint32_t order, FLAC__int64 data[])
-{
- int i, idata_len = (int)data_len;
-
- switch(order) {
- case 0:
- for(i = 0; i < idata_len; i++)
- data[i] = residual[i];
- break;
- case 1:
- for(i = 0; i < idata_len; i++)
- data[i] = (FLAC__int64)residual[i] + data[i-1];
- break;
- case 2:
- for(i = 0; i < idata_len; i++)
- data[i] = (FLAC__int64)residual[i] + 2*data[i-1] - data[i-2];
- break;
- case 3:
- for(i = 0; i < idata_len; i++)
- data[i] = (FLAC__int64)residual[i] + 3*data[i-1] - 3*data[i-2] + data[i-3];
- break;
- case 4:
- for(i = 0; i < idata_len; i++)
- data[i] = (FLAC__int64)residual[i] + 4*data[i-1] - 6*data[i-2] + 4*data[i-3] - data[i-4];
- break;
- default:
- FLAC__ASSERT(0);
- }
-}
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/float.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/float.c
deleted file mode 100644
index dfa7c9377e..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/float.c
+++ /dev/null
@@ -1,302 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2004-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include "../assert.h"
-#include "../compat.h"
-#include "include/private/float.h"
-
-#ifdef FLAC__INTEGER_ONLY_LIBRARY
-
-const FLAC__fixedpoint FLAC__FP_ZERO = 0;
-const FLAC__fixedpoint FLAC__FP_ONE_HALF = 0x00008000;
-const FLAC__fixedpoint FLAC__FP_ONE = 0x00010000;
-const FLAC__fixedpoint FLAC__FP_LN2 = 45426;
-const FLAC__fixedpoint FLAC__FP_E = 178145;
-
-/* Lookup tables for Knuth's logarithm algorithm */
-#define LOG2_LOOKUP_PRECISION 16
-static const FLAC__uint32 log2_lookup[][LOG2_LOOKUP_PRECISION] = {
- {
- /*
- * 0 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ 0x00000001,
- /* lg(4/3) = */ 0x00000000,
- /* lg(8/7) = */ 0x00000000,
- /* lg(16/15) = */ 0x00000000,
- /* lg(32/31) = */ 0x00000000,
- /* lg(64/63) = */ 0x00000000,
- /* lg(128/127) = */ 0x00000000,
- /* lg(256/255) = */ 0x00000000,
- /* lg(512/511) = */ 0x00000000,
- /* lg(1024/1023) = */ 0x00000000,
- /* lg(2048/2047) = */ 0x00000000,
- /* lg(4096/4095) = */ 0x00000000,
- /* lg(8192/8191) = */ 0x00000000,
- /* lg(16384/16383) = */ 0x00000000,
- /* lg(32768/32767) = */ 0x00000000
- },
- {
- /*
- * 4 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ 0x00000010,
- /* lg(4/3) = */ 0x00000007,
- /* lg(8/7) = */ 0x00000003,
- /* lg(16/15) = */ 0x00000001,
- /* lg(32/31) = */ 0x00000001,
- /* lg(64/63) = */ 0x00000000,
- /* lg(128/127) = */ 0x00000000,
- /* lg(256/255) = */ 0x00000000,
- /* lg(512/511) = */ 0x00000000,
- /* lg(1024/1023) = */ 0x00000000,
- /* lg(2048/2047) = */ 0x00000000,
- /* lg(4096/4095) = */ 0x00000000,
- /* lg(8192/8191) = */ 0x00000000,
- /* lg(16384/16383) = */ 0x00000000,
- /* lg(32768/32767) = */ 0x00000000
- },
- {
- /*
- * 8 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ 0x00000100,
- /* lg(4/3) = */ 0x0000006a,
- /* lg(8/7) = */ 0x00000031,
- /* lg(16/15) = */ 0x00000018,
- /* lg(32/31) = */ 0x0000000c,
- /* lg(64/63) = */ 0x00000006,
- /* lg(128/127) = */ 0x00000003,
- /* lg(256/255) = */ 0x00000001,
- /* lg(512/511) = */ 0x00000001,
- /* lg(1024/1023) = */ 0x00000000,
- /* lg(2048/2047) = */ 0x00000000,
- /* lg(4096/4095) = */ 0x00000000,
- /* lg(8192/8191) = */ 0x00000000,
- /* lg(16384/16383) = */ 0x00000000,
- /* lg(32768/32767) = */ 0x00000000
- },
- {
- /*
- * 12 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ 0x00001000,
- /* lg(4/3) = */ 0x000006a4,
- /* lg(8/7) = */ 0x00000315,
- /* lg(16/15) = */ 0x0000017d,
- /* lg(32/31) = */ 0x000000bc,
- /* lg(64/63) = */ 0x0000005d,
- /* lg(128/127) = */ 0x0000002e,
- /* lg(256/255) = */ 0x00000017,
- /* lg(512/511) = */ 0x0000000c,
- /* lg(1024/1023) = */ 0x00000006,
- /* lg(2048/2047) = */ 0x00000003,
- /* lg(4096/4095) = */ 0x00000001,
- /* lg(8192/8191) = */ 0x00000001,
- /* lg(16384/16383) = */ 0x00000000,
- /* lg(32768/32767) = */ 0x00000000
- },
- {
- /*
- * 16 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ 0x00010000,
- /* lg(4/3) = */ 0x00006a40,
- /* lg(8/7) = */ 0x00003151,
- /* lg(16/15) = */ 0x000017d6,
- /* lg(32/31) = */ 0x00000bba,
- /* lg(64/63) = */ 0x000005d1,
- /* lg(128/127) = */ 0x000002e6,
- /* lg(256/255) = */ 0x00000172,
- /* lg(512/511) = */ 0x000000b9,
- /* lg(1024/1023) = */ 0x0000005c,
- /* lg(2048/2047) = */ 0x0000002e,
- /* lg(4096/4095) = */ 0x00000017,
- /* lg(8192/8191) = */ 0x0000000c,
- /* lg(16384/16383) = */ 0x00000006,
- /* lg(32768/32767) = */ 0x00000003
- },
- {
- /*
- * 20 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ 0x00100000,
- /* lg(4/3) = */ 0x0006a3fe,
- /* lg(8/7) = */ 0x00031513,
- /* lg(16/15) = */ 0x00017d60,
- /* lg(32/31) = */ 0x0000bb9d,
- /* lg(64/63) = */ 0x00005d10,
- /* lg(128/127) = */ 0x00002e59,
- /* lg(256/255) = */ 0x00001721,
- /* lg(512/511) = */ 0x00000b8e,
- /* lg(1024/1023) = */ 0x000005c6,
- /* lg(2048/2047) = */ 0x000002e3,
- /* lg(4096/4095) = */ 0x00000171,
- /* lg(8192/8191) = */ 0x000000b9,
- /* lg(16384/16383) = */ 0x0000005c,
- /* lg(32768/32767) = */ 0x0000002e
- },
- {
- /*
- * 24 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ 0x01000000,
- /* lg(4/3) = */ 0x006a3fe6,
- /* lg(8/7) = */ 0x00315130,
- /* lg(16/15) = */ 0x0017d605,
- /* lg(32/31) = */ 0x000bb9ca,
- /* lg(64/63) = */ 0x0005d0fc,
- /* lg(128/127) = */ 0x0002e58f,
- /* lg(256/255) = */ 0x0001720e,
- /* lg(512/511) = */ 0x0000b8d8,
- /* lg(1024/1023) = */ 0x00005c61,
- /* lg(2048/2047) = */ 0x00002e2d,
- /* lg(4096/4095) = */ 0x00001716,
- /* lg(8192/8191) = */ 0x00000b8b,
- /* lg(16384/16383) = */ 0x000005c5,
- /* lg(32768/32767) = */ 0x000002e3
- },
- {
- /*
- * 28 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ 0x10000000,
- /* lg(4/3) = */ 0x06a3fe5c,
- /* lg(8/7) = */ 0x03151301,
- /* lg(16/15) = */ 0x017d6049,
- /* lg(32/31) = */ 0x00bb9ca6,
- /* lg(64/63) = */ 0x005d0fba,
- /* lg(128/127) = */ 0x002e58f7,
- /* lg(256/255) = */ 0x001720da,
- /* lg(512/511) = */ 0x000b8d87,
- /* lg(1024/1023) = */ 0x0005c60b,
- /* lg(2048/2047) = */ 0x0002e2d7,
- /* lg(4096/4095) = */ 0x00017160,
- /* lg(8192/8191) = */ 0x0000b8ad,
- /* lg(16384/16383) = */ 0x00005c56,
- /* lg(32768/32767) = */ 0x00002e2b
- }
-};
-
-#if 0
-static const FLAC__uint64 log2_lookup_wide[] = {
- {
- /*
- * 32 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ FLAC__U64L(0x100000000),
- /* lg(4/3) = */ FLAC__U64L(0x6a3fe5c6),
- /* lg(8/7) = */ FLAC__U64L(0x31513015),
- /* lg(16/15) = */ FLAC__U64L(0x17d60497),
- /* lg(32/31) = */ FLAC__U64L(0x0bb9ca65),
- /* lg(64/63) = */ FLAC__U64L(0x05d0fba2),
- /* lg(128/127) = */ FLAC__U64L(0x02e58f74),
- /* lg(256/255) = */ FLAC__U64L(0x01720d9c),
- /* lg(512/511) = */ FLAC__U64L(0x00b8d875),
- /* lg(1024/1023) = */ FLAC__U64L(0x005c60aa),
- /* lg(2048/2047) = */ FLAC__U64L(0x002e2d72),
- /* lg(4096/4095) = */ FLAC__U64L(0x00171600),
- /* lg(8192/8191) = */ FLAC__U64L(0x000b8ad2),
- /* lg(16384/16383) = */ FLAC__U64L(0x0005c55d),
- /* lg(32768/32767) = */ FLAC__U64L(0x0002e2ac)
- },
- {
- /*
- * 48 fraction bits
- */
- /* undefined */ 0x00000000,
- /* lg(2/1) = */ FLAC__U64L(0x1000000000000),
- /* lg(4/3) = */ FLAC__U64L(0x6a3fe5c60429),
- /* lg(8/7) = */ FLAC__U64L(0x315130157f7a),
- /* lg(16/15) = */ FLAC__U64L(0x17d60496cfbb),
- /* lg(32/31) = */ FLAC__U64L(0xbb9ca64ecac),
- /* lg(64/63) = */ FLAC__U64L(0x5d0fba187cd),
- /* lg(128/127) = */ FLAC__U64L(0x2e58f7441ee),
- /* lg(256/255) = */ FLAC__U64L(0x1720d9c06a8),
- /* lg(512/511) = */ FLAC__U64L(0xb8d8752173),
- /* lg(1024/1023) = */ FLAC__U64L(0x5c60aa252e),
- /* lg(2048/2047) = */ FLAC__U64L(0x2e2d71b0d8),
- /* lg(4096/4095) = */ FLAC__U64L(0x1716001719),
- /* lg(8192/8191) = */ FLAC__U64L(0xb8ad1de1b),
- /* lg(16384/16383) = */ FLAC__U64L(0x5c55d640d),
- /* lg(32768/32767) = */ FLAC__U64L(0x2e2abcf52)
- }
-};
-#endif
-
-FLAC__uint32 FLAC__fixedpoint_log2(FLAC__uint32 x, uint32_t fracbits, uint32_t precision)
-{
- const FLAC__uint32 ONE = (1u << fracbits);
- const FLAC__uint32 *table = log2_lookup[fracbits >> 2];
-
- FLAC__ASSERT(fracbits < 32);
- FLAC__ASSERT((fracbits & 0x3) == 0);
-
- if(x < ONE)
- return 0;
-
- if(precision > LOG2_LOOKUP_PRECISION)
- precision = LOG2_LOOKUP_PRECISION;
-
- /* Knuth's algorithm for computing logarithms, optimized for base-2 with lookup tables */
- {
- FLAC__uint32 y = 0;
- FLAC__uint32 z = x >> 1, k = 1;
- while (x > ONE && k < precision) {
- if (x - z >= ONE) {
- x -= z;
- z = x >> k;
- y += table[k];
- }
- else {
- z >>= 1;
- k++;
- }
- }
- return y;
- }
-}
-
-#endif /* defined FLAC__INTEGER_ONLY_LIBRARY */
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/format.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/format.c
deleted file mode 100644
index 66b88faaf0..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/format.c
+++ /dev/null
@@ -1,608 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include
-#include /* for qsort() */
-#include /* for memset() */
-#include "../assert.h"
-#include "../format.h"
-#include "../alloc.h"
-#include "../compat.h"
-#include "include/private/format.h"
-
-
-#if (defined GIT_COMMIT_HASH && defined GIT_COMMIT_DATE)
-# ifdef GIT_COMMIT_TAG
-FLAC_API const char *FLAC__VERSION_STRING = GIT_COMMIT_TAG;
-FLAC_API const char *FLAC__VENDOR_STRING = "reference libFLAC " GIT_COMMIT_TAG " " GIT_COMMIT_DATE;
-# else
-FLAC_API const char *FLAC__VERSION_STRING = "git-" GIT_COMMIT_HASH " " GIT_COMMIT_DATE;
-FLAC_API const char *FLAC__VENDOR_STRING = "reference libFLAC git-" GIT_COMMIT_HASH " " GIT_COMMIT_DATE;
-# endif
-#else
-/* PACKAGE_VERSION should come from configure */
-FLAC_API const char *FLAC__VERSION_STRING = PACKAGE_VERSION;
-FLAC_API const char *FLAC__VENDOR_STRING = "reference libFLAC " PACKAGE_VERSION " 20230623";
-#endif
-
-FLAC_API const FLAC__byte FLAC__STREAM_SYNC_STRING[4] = { 'f','L','a','C' };
-FLAC_API const uint32_t FLAC__STREAM_SYNC = 0x664C6143;
-FLAC_API const uint32_t FLAC__STREAM_SYNC_LEN = 32; /* bits */
-
-FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN = 16; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN = 16; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN = 24; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN = 24; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN = 20; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN = 3; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN = 5; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN = 36; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN = 128; /* bits */
-
-FLAC_API const uint32_t FLAC__STREAM_METADATA_APPLICATION_ID_LEN = 32; /* bits */
-
-FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN = 64; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN = 64; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN = 16; /* bits */
-
-FLAC_API const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER = FLAC__U64L(0xffffffffffffffff);
-
-FLAC_API const uint32_t FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN = 32; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN = 32; /* bits */
-
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN = 64; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN = 8; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN = 3*8; /* bits */
-
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN = 64; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN = 8; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN = 12*8; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN = 1; /* bit */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN = 1; /* bit */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN = 6+13*8; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN = 8; /* bits */
-
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN = 128*8; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN = 64; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN = 1; /* bit */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN = 7+258*8; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN = 8; /* bits */
-
-FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_TYPE_LEN = 32; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN = 32; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN = 32; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN = 32; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN = 32; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN = 32; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_COLORS_LEN = 32; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN = 32; /* bits */
-
-FLAC_API const uint32_t FLAC__STREAM_METADATA_IS_LAST_LEN = 1; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_TYPE_LEN = 7; /* bits */
-FLAC_API const uint32_t FLAC__STREAM_METADATA_LENGTH_LEN = 24; /* bits */
-
-FLAC_API const uint32_t FLAC__FRAME_HEADER_SYNC = 0x3ffe;
-FLAC_API const uint32_t FLAC__FRAME_HEADER_SYNC_LEN = 14; /* bits */
-FLAC_API const uint32_t FLAC__FRAME_HEADER_RESERVED_LEN = 1; /* bits */
-FLAC_API const uint32_t FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN = 1; /* bits */
-FLAC_API const uint32_t FLAC__FRAME_HEADER_BLOCK_SIZE_LEN = 4; /* bits */
-FLAC_API const uint32_t FLAC__FRAME_HEADER_SAMPLE_RATE_LEN = 4; /* bits */
-FLAC_API const uint32_t FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN = 4; /* bits */
-FLAC_API const uint32_t FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN = 3; /* bits */
-FLAC_API const uint32_t FLAC__FRAME_HEADER_ZERO_PAD_LEN = 1; /* bits */
-FLAC_API const uint32_t FLAC__FRAME_HEADER_CRC_LEN = 8; /* bits */
-
-FLAC_API const uint32_t FLAC__FRAME_FOOTER_CRC_LEN = 16; /* bits */
-
-FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_TYPE_LEN = 2; /* bits */
-FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN = 4; /* bits */
-FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN = 4; /* bits */
-FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN = 5; /* bits */
-FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN = 5; /* bits */
-
-FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER = 15; /* == (1< FLAC__MAX_SAMPLE_RATE) {
- return false;
- }
- else
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__format_blocksize_is_subset(uint32_t blocksize, uint32_t sample_rate)
-{
- if(blocksize > 16384)
- return false;
- else if(sample_rate <= 48000 && blocksize > 4608)
- return false;
- else
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__format_sample_rate_is_subset(uint32_t sample_rate)
-{
- if( // sample rate is not subset if
- !FLAC__format_sample_rate_is_valid(sample_rate) || // sample rate is invalid or
- sample_rate >= ((1u << 16) * 10) || // sample rate is larger then or equal to 655360 or
- (sample_rate >= (1u << 16) && sample_rate % 10 != 0) //sample rate is >= 65536 and not divisible by 10
- ) {
- return false;
- }
- else
- return true;
-}
-
-/* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
-FLAC_API FLAC__bool FLAC__format_seektable_is_legal(const FLAC__StreamMetadata_SeekTable *seek_table)
-{
- uint32_t i;
- FLAC__uint64 prev_sample_number = 0;
- FLAC__bool got_prev = false;
-
- FLAC__ASSERT(0 != seek_table);
-
- if((FLAC__uint64)(seek_table->num_points) * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH >= (1u << FLAC__STREAM_METADATA_LENGTH_LEN))
- return false;
-
- for(i = 0; i < seek_table->num_points; i++) {
- if(got_prev) {
- if(
- seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER &&
- seek_table->points[i].sample_number <= prev_sample_number
- )
- return false;
- }
- prev_sample_number = seek_table->points[i].sample_number;
- got_prev = true;
- }
-
- return true;
-}
-
-/* used as the sort predicate for qsort() */
-static int seekpoint_compare_(const FLAC__StreamMetadata_SeekPoint *l, const FLAC__StreamMetadata_SeekPoint *r)
-{
- /* we don't just 'return l->sample_number - r->sample_number' since the result (FLAC__int64) might overflow an 'int' */
- if(l->sample_number == r->sample_number)
- return 0;
- else if(l->sample_number < r->sample_number)
- return -1;
- else
- return 1;
-}
-
-/* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
-FLAC_API uint32_t FLAC__format_seektable_sort(FLAC__StreamMetadata_SeekTable *seek_table)
-{
- uint32_t i, j;
- FLAC__bool first;
-
- FLAC__ASSERT(0 != seek_table);
-
- if (seek_table->num_points == 0)
- return 0;
-
- /* sort the seekpoints */
- qsort(seek_table->points, seek_table->num_points, sizeof(FLAC__StreamMetadata_SeekPoint), (int (*)(const void *, const void *))seekpoint_compare_);
-
- /* uniquify the seekpoints */
- first = true;
- for(i = j = 0; i < seek_table->num_points; i++) {
- if(seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER) {
- if(!first) {
- if(seek_table->points[i].sample_number == seek_table->points[j-1].sample_number)
- continue;
- }
- }
- first = false;
- seek_table->points[j++] = seek_table->points[i];
- }
-
- for(i = j; i < seek_table->num_points; i++) {
- seek_table->points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
- seek_table->points[i].stream_offset = 0;
- seek_table->points[i].frame_samples = 0;
- }
-
- return j;
-}
-
-/*
- * also disallows non-shortest-form encodings, c.f.
- * http://www.unicode.org/versions/corrigendum1.html
- * and a more clear explanation at the end of this section:
- * http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
- */
-static uint32_t utf8len_(const FLAC__byte *utf8)
-{
- FLAC__ASSERT(0 != utf8);
- if ((utf8[0] & 0x80) == 0) {
- return 1;
- }
- else if ((utf8[0] & 0xE0) == 0xC0 && (utf8[1] & 0xC0) == 0x80) {
- if ((utf8[0] & 0xFE) == 0xC0) /* overlong sequence check */
- return 0;
- return 2;
- }
- else if ((utf8[0] & 0xF0) == 0xE0 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80) {
- if (utf8[0] == 0xE0 && (utf8[1] & 0xE0) == 0x80) /* overlong sequence check */
- return 0;
- /* illegal surrogates check (U+D800...U+DFFF and U+FFFE...U+FFFF) */
- if (utf8[0] == 0xED && (utf8[1] & 0xE0) == 0xA0) /* D800-DFFF */
- return 0;
- if (utf8[0] == 0xEF && utf8[1] == 0xBF && (utf8[2] & 0xFE) == 0xBE) /* FFFE-FFFF */
- return 0;
- return 3;
- }
- else if ((utf8[0] & 0xF8) == 0xF0 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80) {
- if (utf8[0] == 0xF0 && (utf8[1] & 0xF0) == 0x80) /* overlong sequence check */
- return 0;
- return 4;
- }
- else if ((utf8[0] & 0xFC) == 0xF8 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80 && (utf8[4] & 0xC0) == 0x80) {
- if (utf8[0] == 0xF8 && (utf8[1] & 0xF8) == 0x80) /* overlong sequence check */
- return 0;
- return 5;
- }
- else if ((utf8[0] & 0xFE) == 0xFC && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80 && (utf8[4] & 0xC0) == 0x80 && (utf8[5] & 0xC0) == 0x80) {
- if (utf8[0] == 0xFC && (utf8[1] & 0xFC) == 0x80) /* overlong sequence check */
- return 0;
- return 6;
- }
- else {
- return 0;
- }
-}
-
-FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_name_is_legal(const char *name)
-{
- char c;
- for(c = *name; c; c = *(++name))
- if(c < 0x20 || c == 0x3d || c > 0x7d)
- return false;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__byte *value, uint32_t length)
-{
- if(length == (uint32_t)(-1)) {
- while(*value) {
- uint32_t n = utf8len_(value);
- if(n == 0)
- return false;
- value += n;
- }
- }
- else {
- const FLAC__byte *end = value + length;
- while(value < end) {
- uint32_t n = utf8len_(value);
- if(n == 0)
- return false;
- value += n;
- }
- if(value != end)
- return false;
- }
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_is_legal(const FLAC__byte *entry, uint32_t length)
-{
- const FLAC__byte *s, *end;
-
- for(s = entry, end = s + length; s < end && *s != '='; s++) {
- if(*s < 0x20 || *s > 0x7D)
- return false;
- }
- if(s == end)
- return false;
-
- s++; /* skip '=' */
-
- while(s < end) {
- uint32_t n = utf8len_(s);
- if(n == 0)
- return false;
- s += n;
- }
- if(s != end)
- return false;
-
- return true;
-}
-
-/* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
-FLAC_API FLAC__bool FLAC__format_cuesheet_is_legal(const FLAC__StreamMetadata_CueSheet *cue_sheet, FLAC__bool check_cd_da_subset, const char **violation)
-{
- uint32_t i, j;
-
- if(check_cd_da_subset) {
- if(cue_sheet->lead_in < 2 * 44100) {
- if(violation) *violation = "CD-DA cue sheet must have a lead-in length of at least 2 seconds";
- return false;
- }
- if(cue_sheet->lead_in % 588 != 0) {
- if(violation) *violation = "CD-DA cue sheet lead-in length must be evenly divisible by 588 samples";
- return false;
- }
- }
-
- if(cue_sheet->num_tracks == 0) {
- if(violation) *violation = "cue sheet must have at least one track (the lead-out)";
- return false;
- }
-
- if(check_cd_da_subset && cue_sheet->tracks[cue_sheet->num_tracks-1].number != 170) {
- if(violation) *violation = "CD-DA cue sheet must have a lead-out track number 170 (0xAA)";
- return false;
- }
-
- for(i = 0; i < cue_sheet->num_tracks; i++) {
- if(cue_sheet->tracks[i].number == 0) {
- if(violation) *violation = "cue sheet may not have a track number 0";
- return false;
- }
-
- if(check_cd_da_subset) {
- if(!((cue_sheet->tracks[i].number >= 1 && cue_sheet->tracks[i].number <= 99) || cue_sheet->tracks[i].number == 170)) {
- if(violation) *violation = "CD-DA cue sheet track number must be 1-99 or 170";
- return false;
- }
- }
-
- if(check_cd_da_subset && cue_sheet->tracks[i].offset % 588 != 0) {
- if(violation) {
- if(i == cue_sheet->num_tracks-1) /* the lead-out track... */
- *violation = "CD-DA cue sheet lead-out offset must be evenly divisible by 588 samples";
- else
- *violation = "CD-DA cue sheet track offset must be evenly divisible by 588 samples";
- }
- return false;
- }
-
- if(i < cue_sheet->num_tracks - 1) {
- if(cue_sheet->tracks[i].num_indices == 0) {
- if(violation) *violation = "cue sheet track must have at least one index point";
- return false;
- }
-
- if(cue_sheet->tracks[i].indices[0].number > 1) {
- if(violation) *violation = "cue sheet track's first index number must be 0 or 1";
- return false;
- }
- }
-
- for(j = 0; j < cue_sheet->tracks[i].num_indices; j++) {
- if(check_cd_da_subset && cue_sheet->tracks[i].indices[j].offset % 588 != 0) {
- if(violation) *violation = "CD-DA cue sheet track index offset must be evenly divisible by 588 samples";
- return false;
- }
-
- if(j > 0) {
- if(cue_sheet->tracks[i].indices[j].number != cue_sheet->tracks[i].indices[j-1].number + 1) {
- if(violation) *violation = "cue sheet track index numbers must increase by 1";
- return false;
- }
- }
- }
- }
-
- return true;
-}
-
-/* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
-FLAC_API FLAC__bool FLAC__format_picture_is_legal(const FLAC__StreamMetadata_Picture *picture, const char **violation)
-{
- char *p;
- FLAC__byte *b;
-
- for(p = picture->mime_type; *p; p++) {
- if(*p < 0x20 || *p > 0x7e) {
- if(violation) *violation = "MIME type string must contain only printable ASCII characters (0x20-0x7e)";
- return false;
- }
- }
-
- for(b = picture->description; *b; ) {
- uint32_t n = utf8len_(b);
- if(n == 0) {
- if(violation) *violation = "description string must be valid UTF-8";
- return false;
- }
- b += n;
- }
-
- return true;
-}
-
-/*
- * These routines are private to libFLAC
- */
-#if 0 /* UNUSED */
-uint32_t FLAC__format_get_max_rice_partition_order(uint32_t blocksize, uint32_t predictor_order)
-{
- return
- FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(
- FLAC__format_get_max_rice_partition_order_from_blocksize(blocksize),
- blocksize,
- predictor_order
- );
-}
-#endif
-
-uint32_t FLAC__format_get_max_rice_partition_order_from_blocksize(uint32_t blocksize)
-{
- uint32_t max_rice_partition_order = 0;
- while(!(blocksize & 1)) {
- max_rice_partition_order++;
- blocksize >>= 1;
- }
- return flac_min(FLAC__MAX_RICE_PARTITION_ORDER, max_rice_partition_order);
-}
-
-uint32_t FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(uint32_t limit, uint32_t blocksize, uint32_t predictor_order)
-{
- uint32_t max_rice_partition_order = limit;
-
- while(max_rice_partition_order > 0 && (blocksize >> max_rice_partition_order) <= predictor_order)
- max_rice_partition_order--;
-
- FLAC__ASSERT(
- (max_rice_partition_order == 0 && blocksize >= predictor_order) ||
- (max_rice_partition_order > 0 && blocksize >> max_rice_partition_order > predictor_order)
- );
-
- return max_rice_partition_order;
-}
-
-void FLAC__format_entropy_coding_method_partitioned_rice_contents_init(FLAC__EntropyCodingMethod_PartitionedRiceContents *object)
-{
- FLAC__ASSERT(0 != object);
-
- object->parameters = 0;
- object->raw_bits = 0;
- object->capacity_by_order = 0;
-}
-
-void FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(FLAC__EntropyCodingMethod_PartitionedRiceContents *object)
-{
- FLAC__ASSERT(0 != object);
-
- if(0 != object->parameters)
- free(object->parameters);
- if(0 != object->raw_bits)
- free(object->raw_bits);
- FLAC__format_entropy_coding_method_partitioned_rice_contents_init(object);
-}
-
-#if defined(_MSC_VER)
-// silence three MSVC warnings 'result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)'
-#pragma warning ( disable : 4334 )
-#endif
-
-FLAC__bool FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(FLAC__EntropyCodingMethod_PartitionedRiceContents *object, uint32_t max_partition_order)
-{
- FLAC__ASSERT(0 != object);
-
- if(object->capacity_by_order < max_partition_order || object->parameters == NULL || object->raw_bits == NULL) {
- if(0 == (object->parameters = (uint32_t*) safe_realloc_(object->parameters, sizeof(uint32_t)*(1 << max_partition_order))))
- return false;
- if(0 == (object->raw_bits = (uint32_t*) safe_realloc_(object->raw_bits, sizeof(uint32_t)*(1 << max_partition_order))))
- return false;
- memset(object->raw_bits, 0, sizeof(uint32_t)*(1 << max_partition_order));
- object->capacity_by_order = max_partition_order;
- }
-
- return true;
-}
-
-#if defined(_MSC_VER)
-#pragma warning ( default : 4334 )
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/bitmath.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/bitmath.h
deleted file mode 100644
index c5f23fbdcf..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/bitmath.h
+++ /dev/null
@@ -1,210 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2001-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__BITMATH_H
-#define FLAC__PRIVATE__BITMATH_H
-
-#include "../../../ordinals.h"
-#include "../../../assert.h"
-
-#include "../../../compat.h"
-
-#if defined(_MSC_VER)
-#include /* for _BitScanReverse* */
-#endif
-
-/* Will never be emitted for MSVC, GCC, Intel compilers */
-static inline uint32_t FLAC__clz_soft_uint32(FLAC__uint32 word)
-{
- static const uint8_t byte_to_unary_table[] = {
- 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- };
-
- return word > 0xffffff ? byte_to_unary_table[word >> 24] :
- word > 0xffff ? byte_to_unary_table[word >> 16] + 8 :
- word > 0xff ? byte_to_unary_table[word >> 8] + 16 :
- byte_to_unary_table[word] + 24;
-}
-
-static inline uint32_t FLAC__clz_uint32(FLAC__uint32 v)
-{
-/* Never used with input 0 */
- FLAC__ASSERT(v > 0);
-#if defined(__INTEL_COMPILER)
- return _bit_scan_reverse(v) ^ 31U;
-#elif defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-/* This will translate either to (bsr ^ 31U), clz , ctlz, cntlz, lzcnt depending on
- * -march= setting or to a software routine in exotic machines. */
- return __builtin_clz(v);
-#elif defined(_MSC_VER)
- {
- uint32_t idx;
- _BitScanReverse((unsigned long*) &idx, v);
- return idx ^ 31U;
- }
-#else
- return FLAC__clz_soft_uint32(v);
-#endif
-}
-
-/* Used when 64-bit bsr/clz is unavailable; can use 32-bit bsr/clz when possible */
-static inline uint32_t FLAC__clz_soft_uint64(FLAC__uint64 word)
-{
- return (FLAC__uint32)(word>>32) ? FLAC__clz_uint32((FLAC__uint32)(word>>32)) :
- FLAC__clz_uint32((FLAC__uint32)word) + 32;
-}
-
-static inline uint32_t FLAC__clz_uint64(FLAC__uint64 v)
-{
- /* Never used with input 0 */
- FLAC__ASSERT(v > 0);
-#if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
- return __builtin_clzll(v);
-#elif (defined(__INTEL_COMPILER) || defined(_MSC_VER)) && (defined(_M_IA64) || defined(_M_X64))
- {
- uint32_t idx;
- _BitScanReverse64((unsigned long*) &idx, v);
- return idx ^ 63U;
- }
-#else
- return FLAC__clz_soft_uint64(v);
-#endif
-}
-
-/* These two functions work with input 0 */
-static inline uint32_t FLAC__clz2_uint32(FLAC__uint32 v)
-{
- if (!v)
- return 32;
- return FLAC__clz_uint32(v);
-}
-
-static inline uint32_t FLAC__clz2_uint64(FLAC__uint64 v)
-{
- if (!v)
- return 64;
- return FLAC__clz_uint64(v);
-}
-
-/* An example of what FLAC__bitmath_ilog2() computes:
- *
- * ilog2( 0) = assertion failure
- * ilog2( 1) = 0
- * ilog2( 2) = 1
- * ilog2( 3) = 1
- * ilog2( 4) = 2
- * ilog2( 5) = 2
- * ilog2( 6) = 2
- * ilog2( 7) = 2
- * ilog2( 8) = 3
- * ilog2( 9) = 3
- * ilog2(10) = 3
- * ilog2(11) = 3
- * ilog2(12) = 3
- * ilog2(13) = 3
- * ilog2(14) = 3
- * ilog2(15) = 3
- * ilog2(16) = 4
- * ilog2(17) = 4
- * ilog2(18) = 4
- */
-
-static inline uint32_t FLAC__bitmath_ilog2(FLAC__uint32 v)
-{
- FLAC__ASSERT(v > 0);
-#if defined(__INTEL_COMPILER)
- return _bit_scan_reverse(v);
-#elif defined(_MSC_VER)
- {
- uint32_t idx;
- _BitScanReverse((unsigned long*) &idx, v);
- return idx;
- }
-#else
- return FLAC__clz_uint32(v) ^ 31U;
-#endif
-}
-
-static inline uint32_t FLAC__bitmath_ilog2_wide(FLAC__uint64 v)
-{
- FLAC__ASSERT(v > 0);
-#if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
- return __builtin_clzll(v) ^ 63U;
-/* Sorry, only supported in x64/Itanium.. and both have fast FPU which makes integer-only encoder pointless */
-#elif (defined(__INTEL_COMPILER) || defined(_MSC_VER)) && (defined(_M_IA64) || defined(_M_X64))
- {
- uint32_t idx;
- _BitScanReverse64((unsigned long*) &idx, v);
- return idx;
- }
-#else
-/* Brain-damaged compilers will use the fastest possible way that is,
- de Bruijn sequences (http://supertech.csail.mit.edu/papers/debruijn.pdf)
- (C) Timothy B. Terriberry (tterribe@xiph.org) 2001-2009 CC0 (Public domain).
-*/
- {
- static const uint8_t DEBRUIJN_IDX64[64]={
- 0, 1, 2, 7, 3,13, 8,19, 4,25,14,28, 9,34,20,40,
- 5,17,26,38,15,46,29,48,10,31,35,54,21,50,41,57,
- 63, 6,12,18,24,27,33,39,16,37,45,47,30,53,49,56,
- 62,11,23,32,36,44,52,55,61,22,43,51,60,42,59,58
- };
- v|= v>>1;
- v|= v>>2;
- v|= v>>4;
- v|= v>>8;
- v|= v>>16;
- v|= v>>32;
- v= (v>>1)+1;
- return DEBRUIJN_IDX64[v*FLAC__U64L(0x218A392CD3D5DBF)>>58&0x3F];
- }
-#endif
-}
-
-uint32_t FLAC__bitmath_silog2(FLAC__int64 v);
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/bitreader.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/bitreader.h
deleted file mode 100644
index 408f7d3a91..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/bitreader.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__BITREADER_H
-#define FLAC__PRIVATE__BITREADER_H
-
-#include /* for FILE */
-#include "../../../ordinals.h"
-#include "cpu.h"
-
-/*
- * opaque structure definition
- */
-struct FLAC__BitReader;
-typedef struct FLAC__BitReader FLAC__BitReader;
-
-typedef FLAC__bool (*FLAC__BitReaderReadCallback)(FLAC__byte buffer[], size_t *bytes, void *client_data);
-
-/*
- * construction, deletion, initialization, etc functions
- */
-FLAC__BitReader *FLAC__bitreader_new(void);
-void FLAC__bitreader_delete(FLAC__BitReader *br);
-FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__BitReaderReadCallback rcb, void *cd);
-void FLAC__bitreader_free(FLAC__BitReader *br); /* does not 'free(br)' */
-FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br);
-void FLAC__bitreader_set_framesync_location(FLAC__BitReader *br);
-FLAC__bool FLAC__bitreader_rewind_to_after_last_seen_framesync(FLAC__BitReader *br);
-
-/*
- * CRC functions
- */
-void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed);
-FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br);
-
-/*
- * info functions
- */
-FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br);
-uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br);
-uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br);
-void FLAC__bitreader_set_limit(FLAC__BitReader *br, uint32_t limit);
-void FLAC__bitreader_remove_limit(FLAC__BitReader *br);
-uint32_t FLAC__bitreader_limit_remaining(FLAC__BitReader *br);
-void FLAC__bitreader_limit_invalidate(FLAC__BitReader *br);
-
-/*
- * read functions
- */
-
-FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, uint32_t bits);
-FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, uint32_t bits);
-FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, uint32_t bits);
-FLAC__bool FLAC__bitreader_read_raw_int64(FLAC__BitReader *br, FLAC__int64 *val, uint32_t bits);
-FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val); /*only for bits=32*/
-FLAC__bool FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader *br, uint32_t bits); /* WATCHOUT: does not CRC the skipped data! */ /*@@@@ add to unit tests */
-FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, uint32_t nvals); /* WATCHOUT: does not CRC the read data! */
-FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, FLAC__byte *val, uint32_t nvals); /* WATCHOUT: does not CRC the read data! */
-FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, uint32_t *val);
-FLAC__bool FLAC__bitreader_read_rice_signed(FLAC__BitReader *br, int *val, uint32_t parameter);
-FLAC__bool FLAC__bitreader_read_rice_signed_block(FLAC__BitReader *br, int vals[], uint32_t nvals, uint32_t parameter);
-#ifdef FLAC__BMI2_SUPPORTED
-FLAC__bool FLAC__bitreader_read_rice_signed_block_bmi2(FLAC__BitReader *br, int vals[], uint32_t nvals, uint32_t parameter);
-#endif
-
-#if 0 /* UNUSED */
-FLAC__bool FLAC__bitreader_read_golomb_signed(FLAC__BitReader *br, int *val, uint32_t parameter);
-FLAC__bool FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader *br, uint32_t *val, uint32_t parameter);
-#endif
-FLAC__bool FLAC__bitreader_read_utf8_uint32(FLAC__BitReader *br, FLAC__uint32 *val, FLAC__byte *raw, uint32_t *rawlen);
-FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *val, FLAC__byte *raw, uint32_t *rawlen);
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/bitwriter.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/bitwriter.h
deleted file mode 100644
index 8b41de9dd2..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/bitwriter.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__BITWRITER_H
-#define FLAC__PRIVATE__BITWRITER_H
-
-#include /* for FILE */
-#include "../../../ordinals.h"
-
-/*
- * opaque structure definition
- */
-struct FLAC__BitWriter;
-typedef struct FLAC__BitWriter FLAC__BitWriter;
-
-/*
- * construction, deletion, initialization, etc functions
- */
-FLAC__BitWriter *FLAC__bitwriter_new(void);
-void FLAC__bitwriter_delete(FLAC__BitWriter *bw);
-FLAC__bool FLAC__bitwriter_init(FLAC__BitWriter *bw);
-void FLAC__bitwriter_free(FLAC__BitWriter *bw); /* does not 'free(buffer)' */
-void FLAC__bitwriter_clear(FLAC__BitWriter *bw);
-
-/*
- * CRC functions
- *
- * non-const *bw because they have to cal FLAC__bitwriter_get_buffer()
- */
-FLAC__bool FLAC__bitwriter_get_write_crc16(FLAC__BitWriter *bw, FLAC__uint16 *crc);
-FLAC__bool FLAC__bitwriter_get_write_crc8(FLAC__BitWriter *bw, FLAC__byte *crc);
-
-/*
- * info functions
- */
-FLAC__bool FLAC__bitwriter_is_byte_aligned(const FLAC__BitWriter *bw);
-uint32_t FLAC__bitwriter_get_input_bits_unconsumed(const FLAC__BitWriter *bw); /* can be called anytime, returns total # of bits unconsumed */
-
-/*
- * direct buffer access
- *
- * there may be no calls on the bitwriter between get and release.
- * the bitwriter continues to own the returned buffer.
- * before get, bitwriter MUST be byte aligned: check with FLAC__bitwriter_is_byte_aligned()
- */
-FLAC__bool FLAC__bitwriter_get_buffer(FLAC__BitWriter *bw, const FLAC__byte **buffer, size_t *bytes);
-void FLAC__bitwriter_release_buffer(FLAC__BitWriter *bw);
-
-/*
- * write functions
- */
-FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits);
-FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits);
-FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits);
-FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits);
-FLAC__bool FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits);
-FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val); /*only for bits=32*/
-FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals);
-FLAC__bool FLAC__bitwriter_write_unary_unsigned(FLAC__BitWriter *bw, uint32_t val);
-#if 0 /* UNUSED */
-uint32_t FLAC__bitwriter_rice_bits(FLAC__int32 val, uint32_t parameter);
-uint32_t FLAC__bitwriter_golomb_bits_signed(int val, uint32_t parameter);
-uint32_t FLAC__bitwriter_golomb_bits_unsigned(uint32_t val, uint32_t parameter);
-FLAC__bool FLAC__bitwriter_write_rice_signed(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t parameter);
-#endif
-FLAC__bool FLAC__bitwriter_write_rice_signed_block(FLAC__BitWriter *bw, const FLAC__int32 *vals, uint32_t nvals, uint32_t parameter);
-#if 0 /* UNUSED */
-FLAC__bool FLAC__bitwriter_write_golomb_signed(FLAC__BitWriter *bw, int val, uint32_t parameter);
-FLAC__bool FLAC__bitwriter_write_golomb_unsigned(FLAC__BitWriter *bw, uint32_t val, uint32_t parameter);
-#endif
-FLAC__bool FLAC__bitwriter_write_utf8_uint32(FLAC__BitWriter *bw, FLAC__uint32 val);
-FLAC__bool FLAC__bitwriter_write_utf8_uint64(FLAC__BitWriter *bw, FLAC__uint64 val);
-FLAC__bool FLAC__bitwriter_zero_pad_to_byte_boundary(FLAC__BitWriter *bw);
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/cpu.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/cpu.h
deleted file mode 100644
index 087e459084..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/cpu.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2001-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__CPU_H
-#define FLAC__PRIVATE__CPU_H
-
-#include "../../../ordinals.h"
-
-#ifdef HAVE_CONFIG_H
-#include
-#endif
-
-#ifndef FLAC__CPU_X86_64
-
-#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
-#define FLAC__CPU_X86_64
-#endif
-
-#endif
-
-#ifndef FLAC__CPU_IA32
-
-#if defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__) ||defined( __i386) || defined(_M_IX86)
-#define FLAC__CPU_IA32
-#endif
-
-#endif
-
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-
-#ifndef FLAC__AVX_SUPPORTED
-#define FLAC__AVX_SUPPORTED 0
-#endif
-
-typedef enum {
- FLAC__CPUINFO_TYPE_IA32,
- FLAC__CPUINFO_TYPE_X86_64,
- FLAC__CPUINFO_TYPE_UNKNOWN
-} FLAC__CPUInfo_Type;
-
-typedef struct {
- FLAC__bool intel;
-
- FLAC__bool cmov;
- FLAC__bool mmx;
- FLAC__bool sse;
- FLAC__bool sse2;
-
- FLAC__bool sse3;
- FLAC__bool ssse3;
- FLAC__bool sse41;
- FLAC__bool sse42;
- FLAC__bool avx;
- FLAC__bool avx2;
- FLAC__bool fma;
- FLAC__bool bmi2;
-} FLAC__CPUInfo_x86;
-
-typedef struct {
- FLAC__bool use_asm;
- FLAC__CPUInfo_Type type;
- FLAC__CPUInfo_x86 x86;
-} FLAC__CPUInfo;
-
-void FLAC__cpu_info(FLAC__CPUInfo *info);
-
-FLAC__uint32 FLAC__cpu_have_cpuid_asm_ia32(void);
-
-void FLAC__cpu_info_asm_ia32(FLAC__uint32 level, FLAC__uint32 *eax, FLAC__uint32 *ebx, FLAC__uint32 *ecx, FLAC__uint32 *edx);
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/crc.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/crc.h
deleted file mode 100644
index 9f62aedafe..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/crc.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__CRC_H
-#define FLAC__PRIVATE__CRC_H
-
-#include "../../../ordinals.h"
-
-/* 8 bit CRC generator, MSB shifted first
-** polynomial = x^8 + x^2 + x^1 + x^0
-** init = 0
-*/
-FLAC__uint8 FLAC__crc8(const FLAC__byte *data, uint32_t len);
-
-/* 16 bit CRC generator, MSB shifted first
-** polynomial = x^16 + x^15 + x^2 + x^0
-** init = 0
-*/
-extern FLAC__uint16 const FLAC__crc16_table[8][256];
-
-#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) & 0xffff) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)])
-/* this alternate may be faster on some systems/compilers */
-#if 0
-#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)]) & 0xffff)
-#endif
-
-FLAC__uint16 FLAC__crc16(const FLAC__byte *data, uint32_t len);
-FLAC__uint16 FLAC__crc16_update_words32(const FLAC__uint32 *words, uint32_t len, FLAC__uint16 crc);
-FLAC__uint16 FLAC__crc16_update_words64(const FLAC__uint64 *words, uint32_t len, FLAC__uint16 crc);
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/fixed.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/fixed.h
deleted file mode 100644
index 866f110c59..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/fixed.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__FIXED_H
-#define FLAC__PRIVATE__FIXED_H
-
-#ifdef HAVE_CONFIG_H
-#include
-#endif
-
-#include "cpu.h"
-#include "float.h"
-#include "../../../format.h"
-
-/*
- * FLAC__fixed_compute_best_predictor()
- * --------------------------------------------------------------------
- * Compute the best fixed predictor and the expected bits-per-sample
- * of the residual signal for each order. The _wide() version uses
- * 64-bit integers which is statistically necessary when bits-per-
- * sample + log2(blocksize) > 30
- *
- * IN data[0,data_len-1]
- * IN data_len
- * OUT residual_bits_per_sample[0,FLAC__MAX_FIXED_ORDER]
- */
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-uint32_t FLAC__fixed_compute_best_predictor(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-uint32_t FLAC__fixed_compute_best_predictor_wide(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual_33bit(const FLAC__int64 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-# ifndef FLAC__NO_ASM
-# if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN
-# ifdef FLAC__SSE2_SUPPORTED
-uint32_t FLAC__fixed_compute_best_predictor_intrin_sse2(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER + 1]);
-# endif
-# ifdef FLAC__SSSE3_SUPPORTED
-uint32_t FLAC__fixed_compute_best_predictor_intrin_ssse3(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-# endif
-# ifdef FLAC__SSE4_2_SUPPORTED
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual_intrin_sse42(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-# endif
-# ifdef FLAC__AVX2_SUPPORTED
-uint32_t FLAC__fixed_compute_best_predictor_wide_intrin_avx2(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual_intrin_avx2(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-# endif
-# endif
-# endif
-#else
-uint32_t FLAC__fixed_compute_best_predictor(const FLAC__int32 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-uint32_t FLAC__fixed_compute_best_predictor_wide(const FLAC__int32 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual(const FLAC__int32 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-uint32_t FLAC__fixed_compute_best_predictor_limit_residual_33bit(const FLAC__int64 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-#endif
-
-/*
- * FLAC__fixed_compute_residual()
- * --------------------------------------------------------------------
- * Compute the residual signal obtained from sutracting the predicted
- * signal from the original.
- *
- * IN data[-order,data_len-1] original signal (NOTE THE INDICES!)
- * IN data_len length of original signal
- * IN order <= FLAC__MAX_FIXED_ORDER fixed-predictor order
- * OUT residual[0,data_len-1] residual signal
- */
-void FLAC__fixed_compute_residual(const FLAC__int32 data[], uint32_t data_len, uint32_t order, FLAC__int32 residual[]);
-void FLAC__fixed_compute_residual_wide(const FLAC__int32 data[], uint32_t data_len, uint32_t order, FLAC__int32 residual[]);
-void FLAC__fixed_compute_residual_wide_33bit(const FLAC__int64 data[], uint32_t data_len, uint32_t order, FLAC__int32 residual[]);
-
-/*
- * FLAC__fixed_restore_signal()
- * --------------------------------------------------------------------
- * Restore the original signal by summing the residual and the
- * predictor.
- *
- * IN residual[0,data_len-1] residual signal
- * IN data_len length of original signal
- * IN order <= FLAC__MAX_FIXED_ORDER fixed-predictor order
- * *** IMPORTANT: the caller must pass in the historical samples:
- * IN data[-order,-1] previously-reconstructed historical samples
- * OUT data[0,data_len-1] original signal
- */
-void FLAC__fixed_restore_signal(const FLAC__int32 residual[], uint32_t data_len, uint32_t order, FLAC__int32 data[]);
-void FLAC__fixed_restore_signal_wide(const FLAC__int32 residual[], uint32_t data_len, uint32_t order, FLAC__int32 data[]);
-void FLAC__fixed_restore_signal_wide_33bit(const FLAC__int32 residual[], uint32_t data_len, uint32_t order, FLAC__int64 data[]);
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/float.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/float.h
deleted file mode 100644
index 649de9e760..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/float.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2004-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__FLOAT_H
-#define FLAC__PRIVATE__FLOAT_H
-
-#ifdef HAVE_CONFIG_H
-#include
-#endif
-
-#include "../../../ordinals.h"
-
-/*
- * All the code in libFLAC that uses float and double
- * should be protected by checks of the macro
- * FLAC__INTEGER_ONLY_LIBRARY.
- *
- */
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-/*
- * FLAC__real is the basic floating point type used in LPC analysis.
- *
- * WATCHOUT: changing FLAC__real will change the signatures of many
- * functions that have assembly language equivalents and break them.
- */
-typedef float FLAC__real;
-#else
-/*
- * The convention for FLAC__fixedpoint is to use the upper 16 bits
- * for the integer part and lower 16 bits for the fractional part.
- */
-typedef FLAC__int32 FLAC__fixedpoint;
-extern const FLAC__fixedpoint FLAC__FP_ZERO;
-extern const FLAC__fixedpoint FLAC__FP_ONE_HALF;
-extern const FLAC__fixedpoint FLAC__FP_ONE;
-extern const FLAC__fixedpoint FLAC__FP_LN2;
-extern const FLAC__fixedpoint FLAC__FP_E;
-
-#define FLAC__fixedpoint_trunc(x) ((x)>>16)
-
-#define FLAC__fixedpoint_mul(x, y) ( (FLAC__fixedpoint) ( ((FLAC__int64)(x)*(FLAC__int64)(y)) >> 16 ) )
-
-#define FLAC__fixedpoint_div(x, y) ( (FLAC__fixedpoint) ( ( ((FLAC__int64)(x)<<32) / (FLAC__int64)(y) ) >> 16 ) )
-
-/*
- * FLAC__fixedpoint_log2()
- * --------------------------------------------------------------------
- * Returns the base-2 logarithm of the fixed-point number 'x' using an
- * algorithm by Knuth for x >= 1.0
- *
- * 'fracbits' is the number of fractional bits of 'x'. 'fracbits' must
- * be < 32 and evenly divisible by 4 (0 is OK but not very precise).
- *
- * 'precision' roughly limits the number of iterations that are done;
- * use (uint32_t)(-1) for maximum precision.
- *
- * If 'x' is less than one -- that is, x < (1<
-#endif
-
-#include "cpu.h"
-#include "float.h"
-#include "../../../format.h"
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-
-/*
- * FLAC__lpc_window_data()
- * --------------------------------------------------------------------
- * Applies the given window to the data.
- * OPT: asm implementation
- *
- * IN in[0,data_len-1]
- * IN window[0,data_len-1]
- * OUT out[0,lag-1]
- * IN data_len
- */
-void FLAC__lpc_window_data(const FLAC__int32 in[], const FLAC__real window[], FLAC__real out[], uint32_t data_len);
-void FLAC__lpc_window_data_wide(const FLAC__int64 in[], const FLAC__real window[], FLAC__real out[], uint32_t data_len);
-void FLAC__lpc_window_data_partial(const FLAC__int32 in[], const FLAC__real window[], FLAC__real out[], uint32_t data_len, uint32_t part_size, uint32_t data_shift);
-void FLAC__lpc_window_data_partial_wide(const FLAC__int64 in[], const FLAC__real window[], FLAC__real out[], uint32_t data_len, uint32_t part_size, uint32_t data_shift);
-
-/*
- * FLAC__lpc_compute_autocorrelation()
- * --------------------------------------------------------------------
- * Compute the autocorrelation for lags between 0 and lag-1.
- * Assumes data[] outside of [0,data_len-1] == 0.
- * Asserts that lag > 0.
- *
- * IN data[0,data_len-1]
- * IN data_len
- * IN 0 < lag <= data_len
- * OUT autoc[0,lag-1]
- */
-void FLAC__lpc_compute_autocorrelation(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-#ifndef FLAC__NO_ASM
-# if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN
-# ifdef FLAC__SSE2_SUPPORTED
-void FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_8(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-void FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_10(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-void FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_14(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-# endif
-# endif
-# if defined FLAC__CPU_X86_64 && FLAC__HAS_X86INTRIN
-# ifdef FLAC__FMA_SUPPORTED
-void FLAC__lpc_compute_autocorrelation_intrin_fma_lag_8(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-void FLAC__lpc_compute_autocorrelation_intrin_fma_lag_12(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-void FLAC__lpc_compute_autocorrelation_intrin_fma_lag_16(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-# endif
-# endif
-#if defined FLAC__CPU_ARM64 && FLAC__HAS_NEONINTRIN && FLAC__HAS_A64NEONINTRIN
-void FLAC__lpc_compute_autocorrelation_intrin_neon_lag_8(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-void FLAC__lpc_compute_autocorrelation_intrin_neon_lag_10(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-void FLAC__lpc_compute_autocorrelation_intrin_neon_lag_14(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
-#endif
-#endif /* FLAC__NO_ASM */
-
-/*
- * FLAC__lpc_compute_lp_coefficients()
- * --------------------------------------------------------------------
- * Computes LP coefficients for orders 1..max_order.
- * Do not call if autoc[0] == 0.0. This means the signal is zero
- * and there is no point in calculating a predictor.
- *
- * IN autoc[0,max_order] autocorrelation values
- * IN 0 < max_order <= FLAC__MAX_LPC_ORDER max LP order to compute
- * OUT lp_coeff[0,max_order-1][0,max_order-1] LP coefficients for each order
- * *** IMPORTANT:
- * *** lp_coeff[0,max_order-1][max_order,FLAC__MAX_LPC_ORDER-1] are untouched
- * OUT error[0,max_order-1] error for each order (more
- * specifically, the variance of
- * the error signal times # of
- * samples in the signal)
- *
- * Example: if max_order is 9, the LP coefficients for order 9 will be
- * in lp_coeff[8][0,8], the LP coefficients for order 8 will be
- * in lp_coeff[7][0,7], etc.
- */
-void FLAC__lpc_compute_lp_coefficients(const double autoc[], uint32_t *max_order, FLAC__real lp_coeff[][FLAC__MAX_LPC_ORDER], double error[]);
-
-/*
- * FLAC__lpc_quantize_coefficients()
- * --------------------------------------------------------------------
- * Quantizes the LP coefficients. NOTE: precision + bits_per_sample
- * must be less than 32 (sizeof(FLAC__int32)*8).
- *
- * IN lp_coeff[0,order-1] LP coefficients
- * IN order LP order
- * IN FLAC__MIN_QLP_COEFF_PRECISION < precision
- * desired precision (in bits, including sign
- * bit) of largest coefficient
- * OUT qlp_coeff[0,order-1] quantized coefficients
- * OUT shift # of bits to shift right to get approximated
- * LP coefficients. NOTE: could be negative.
- * RETURN 0 => quantization OK
- * 1 => coefficients require too much shifting for *shift to
- * fit in the LPC subframe header. 'shift' is unset.
- * 2 => coefficients are all zero, which is bad. 'shift' is
- * unset.
- */
-int FLAC__lpc_quantize_coefficients(const FLAC__real lp_coeff[], uint32_t order, uint32_t precision, FLAC__int32 qlp_coeff[], int *shift);
-
-/*
- * FLAC__lpc_compute_residual_from_qlp_coefficients()
- * --------------------------------------------------------------------
- * Compute the residual signal obtained from sutracting the predicted
- * signal from the original.
- *
- * IN data[-order,data_len-1] original signal (NOTE THE INDICES!)
- * IN data_len length of original signal
- * IN qlp_coeff[0,order-1] quantized LP coefficients
- * IN order > 0 LP order
- * IN lp_quantization quantization of LP coefficients in bits
- * OUT residual[0,data_len-1] residual signal
- */
-void FLAC__lpc_compute_residual_from_qlp_coefficients(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-void FLAC__lpc_compute_residual_from_qlp_coefficients_wide(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-FLAC__bool FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-FLAC__bool FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual_33bit(const FLAC__int64 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-#ifndef FLAC__NO_ASM
-# ifdef FLAC__CPU_ARM64
-void FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_neon(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-void FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_neon(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-# endif
-
-# if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN
-# ifdef FLAC__SSE2_SUPPORTED
-void FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-void FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse2(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-# endif
-# ifdef FLAC__SSE4_1_SUPPORTED
-void FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-void FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_sse41(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-# endif
-# ifdef FLAC__AVX2_SUPPORTED
-void FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-void FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-void FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-# endif
-# endif
-#endif
-
-#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
-
-uint32_t FLAC__lpc_max_prediction_before_shift_bps(uint32_t subframe_bps, const FLAC__int32 qlp_coeff[], uint32_t order);
-uint32_t FLAC__lpc_max_residual_bps(uint32_t subframe_bps, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization);
-
-/*
- * FLAC__lpc_restore_signal()
- * --------------------------------------------------------------------
- * Restore the original signal by summing the residual and the
- * predictor.
- *
- * IN residual[0,data_len-1] residual signal
- * IN data_len length of original signal
- * IN qlp_coeff[0,order-1] quantized LP coefficients
- * IN order > 0 LP order
- * IN lp_quantization quantization of LP coefficients in bits
- * *** IMPORTANT: the caller must pass in the historical samples:
- * IN data[-order,-1] previously-reconstructed historical samples
- * OUT data[0,data_len-1] original signal
- */
-void FLAC__lpc_restore_signal(const FLAC__int32 residual[], uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 data[]);
-void FLAC__lpc_restore_signal_wide(const FLAC__int32 residual[], uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 data[]);
-void FLAC__lpc_restore_signal_wide_33bit(const FLAC__int32 residual[], uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int64 data[]);
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-
-/*
- * FLAC__lpc_compute_expected_bits_per_residual_sample()
- * --------------------------------------------------------------------
- * Compute the expected number of bits per residual signal sample
- * based on the LP error (which is related to the residual variance).
- *
- * IN lpc_error >= 0.0 error returned from calculating LP coefficients
- * IN total_samples > 0 # of samples in residual signal
- * RETURN expected bits per sample
- */
-double FLAC__lpc_compute_expected_bits_per_residual_sample(double lpc_error, uint32_t total_samples);
-double FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(double lpc_error, double error_scale);
-
-/*
- * FLAC__lpc_compute_best_order()
- * --------------------------------------------------------------------
- * Compute the best order from the array of signal errors returned
- * during coefficient computation.
- *
- * IN lpc_error[0,max_order-1] >= 0.0 error returned from calculating LP coefficients
- * IN max_order > 0 max LP order
- * IN total_samples > 0 # of samples in residual signal
- * IN overhead_bits_per_order # of bits overhead for each increased LP order
- * (includes warmup sample size and quantized LP coefficient)
- * RETURN [1,max_order] best order
- */
-uint32_t FLAC__lpc_compute_best_order(const double lpc_error[], uint32_t max_order, uint32_t total_samples, uint32_t overhead_bits_per_order);
-
-#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/md5.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/md5.h
deleted file mode 100644
index 57be3bf865..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/md5.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef FLAC__PRIVATE__MD5_H
-#define FLAC__PRIVATE__MD5_H
-
-/*
- * This is the header file for the MD5 message-digest algorithm.
- * The algorithm is due to Ron Rivest. This code was
- * written by Colin Plumb in 1993, no copyright is claimed.
- * This code is in the public domain; do with it what you wish.
- *
- * Equivalent code is available from RSA Data Security, Inc.
- * This code has been tested against that, and is equivalent,
- * except that you don't need to include two pages of legalese
- * with every copy.
- *
- * To compute the message digest of a chunk of bytes, declare an
- * MD5Context structure, pass it to MD5Init, call MD5Update as
- * needed on buffers full of bytes, and then call MD5Final, which
- * will fill a supplied 16-byte array with the digest.
- *
- * Changed so as no longer to depend on Colin Plumb's `usual.h'
- * header definitions; now uses stuff from dpkg's config.h
- * - Ian Jackson .
- * Still in the public domain.
- *
- * Josh Coalson: made some changes to integrate with libFLAC.
- * Still in the public domain, with no warranty.
- */
-
-#include "../../../ordinals.h"
-
-typedef union {
- FLAC__byte *p8;
- FLAC__int16 *p16;
- FLAC__int32 *p32;
-} FLAC__multibyte;
-
-typedef struct {
- FLAC__uint32 in[16];
- FLAC__uint32 buf[4];
- FLAC__uint32 bytes[2];
- FLAC__multibyte internal_buf;
- size_t capacity;
-} FLAC__MD5Context;
-
-void FLAC__MD5Init(FLAC__MD5Context *context);
-void FLAC__MD5Final(FLAC__byte digest[16], FLAC__MD5Context *context);
-
-FLAC__bool FLAC__MD5Accumulate(FLAC__MD5Context *ctx, const FLAC__int32 * const signal[], uint32_t channels, uint32_t samples, uint32_t bytes_per_sample);
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/memory.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/memory.h
deleted file mode 100644
index bb7853f287..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/memory.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2001-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__MEMORY_H
-#define FLAC__PRIVATE__MEMORY_H
-
-#ifdef HAVE_CONFIG_H
-#include
-#endif
-
-#include /* for size_t */
-
-#include "float.h"
-#include "../../../ordinals.h" /* for FLAC__bool */
-
-/* Returns the unaligned address returned by malloc.
- * Use free() on this address to deallocate.
- */
-void *FLAC__memory_alloc_aligned(size_t bytes, void **aligned_address);
-FLAC__bool FLAC__memory_alloc_aligned_int32_array(size_t elements, FLAC__int32 **unaligned_pointer, FLAC__int32 **aligned_pointer);
-FLAC__bool FLAC__memory_alloc_aligned_uint32_array(size_t elements, FLAC__uint32 **unaligned_pointer, FLAC__uint32 **aligned_pointer);
-FLAC__bool FLAC__memory_alloc_aligned_int64_array(size_t elements, FLAC__int64 **unaligned_pointer, FLAC__int64 **aligned_pointer);
-FLAC__bool FLAC__memory_alloc_aligned_uint64_array(size_t elements, FLAC__uint64 **unaligned_pointer, FLAC__uint64 **aligned_pointer);
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-FLAC__bool FLAC__memory_alloc_aligned_real_array(size_t elements, FLAC__real **unaligned_pointer, FLAC__real **aligned_pointer);
-#endif
-void *safe_malloc_mul_2op_p(size_t size1, size_t size2);
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/stream_encoder.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/stream_encoder.h
deleted file mode 100644
index 36bbc24c1e..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/stream_encoder.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__STREAM_ENCODER_H
-#define FLAC__PRIVATE__STREAM_ENCODER_H
-
-#ifdef HAVE_CONFIG_H
-#include
-#endif
-
-/*
- * This is used to avoid overflow with unusual signals in 32-bit
- * accumulator in the *precompute_partition_info_sums_* functions.
- */
-#define FLAC__MAX_EXTRA_RESIDUAL_BPS 4
-
-#if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && defined FLAC__HAS_X86INTRIN
-#include "cpu.h"
-#include "../../../format.h"
-
-#ifdef FLAC__SSE2_SUPPORTED
-extern void FLAC__precompute_partition_info_sums_intrin_sse2(const FLAC__int32 residual[], FLAC__uint64 abs_residual_partition_sums[],
- uint32_t residual_samples, uint32_t predictor_order, uint32_t min_partition_order, uint32_t max_partition_order, uint32_t bps);
-#endif
-
-#ifdef FLAC__SSSE3_SUPPORTED
-extern void FLAC__precompute_partition_info_sums_intrin_ssse3(const FLAC__int32 residual[], FLAC__uint64 abs_residual_partition_sums[],
- uint32_t residual_samples, uint32_t predictor_order, uint32_t min_partition_order, uint32_t max_partition_order, uint32_t bps);
-#endif
-
-#ifdef FLAC__AVX2_SUPPORTED
-extern void FLAC__precompute_partition_info_sums_intrin_avx2(const FLAC__int32 residual[], FLAC__uint64 abs_residual_partition_sums[],
- uint32_t residual_samples, uint32_t predictor_order, uint32_t min_partition_order, uint32_t max_partition_order, uint32_t bps);
-#endif
-
-#endif
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/stream_encoder_framing.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/stream_encoder_framing.h
deleted file mode 100644
index 9e55f3095b..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/stream_encoder_framing.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__STREAM_ENCODER_FRAMING_H
-#define FLAC__PRIVATE__STREAM_ENCODER_FRAMING_H
-
-#include "../../../format.h"
-#include "bitwriter.h"
-
-FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetadata *metadata, FLAC__BitWriter *bw, FLAC__bool update_vendor_string);
-FLAC__bool FLAC__frame_add_header(const FLAC__FrameHeader *header, FLAC__BitWriter *bw);
-FLAC__bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, uint32_t subframe_bps, uint32_t wasted_bits, FLAC__BitWriter *bw);
-FLAC__bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, uint32_t residual_samples, uint32_t subframe_bps, uint32_t wasted_bits, FLAC__BitWriter *bw);
-FLAC__bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, uint32_t residual_samples, uint32_t subframe_bps, uint32_t wasted_bits, FLAC__BitWriter *bw);
-FLAC__bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, uint32_t samples, uint32_t subframe_bps, uint32_t wasted_bits, FLAC__BitWriter *bw);
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/window.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/window.h
deleted file mode 100644
index 512140a380..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/private/window.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2006-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PRIVATE__WINDOW_H
-#define FLAC__PRIVATE__WINDOW_H
-
-#ifdef HAVE_CONFIG_H
-#include
-#endif
-
-#include "float.h"
-#include "../../../format.h"
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-
-/*
- * FLAC__window_*()
- * --------------------------------------------------------------------
- * Calculates window coefficients according to different apodization
- * functions.
- *
- * OUT window[0,L-1]
- * IN L (number of points in window)
- */
-void FLAC__window_bartlett(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_bartlett_hann(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_blackman(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_blackman_harris_4term_92db_sidelobe(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_connes(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_flattop(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_gauss(FLAC__real *window, const FLAC__int32 L, const FLAC__real stddev); /* 0.0 < stddev <= 0.5 */
-void FLAC__window_hamming(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_hann(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_kaiser_bessel(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_nuttall(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_rectangle(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_triangle(FLAC__real *window, const FLAC__int32 L);
-void FLAC__window_tukey(FLAC__real *window, const FLAC__int32 L, const FLAC__real p);
-void FLAC__window_partial_tukey(FLAC__real *window, const FLAC__int32 L, const FLAC__real p, const FLAC__real start, const FLAC__real end);
-void FLAC__window_punchout_tukey(FLAC__real *window, const FLAC__int32 L, const FLAC__real p, const FLAC__real start, const FLAC__real end);
-void FLAC__window_welch(FLAC__real *window, const FLAC__int32 L);
-
-#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/protected/stream_decoder.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/protected/stream_decoder.h
deleted file mode 100644
index 8c7794b7a2..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/protected/stream_decoder.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PROTECTED__STREAM_DECODER_H
-#define FLAC__PROTECTED__STREAM_DECODER_H
-
-#include "../../../stream_decoder.h"
-#if FLAC__HAS_OGG
-#include "../private/ogg_decoder_aspect.h"
-#endif
-
-typedef struct FLAC__StreamDecoderProtected {
- FLAC__StreamDecoderState state;
- FLAC__StreamDecoderInitStatus initstate;
- uint32_t channels;
- FLAC__ChannelAssignment channel_assignment;
- uint32_t bits_per_sample;
- uint32_t sample_rate; /* in Hz */
- uint32_t blocksize; /* in samples (per channel) */
- FLAC__bool md5_checking; /* if true, generate MD5 signature of decoded data and compare against signature in the STREAMINFO metadata block */
-#if FLAC__HAS_OGG
- FLAC__OggDecoderAspect ogg_decoder_aspect;
-#endif
-} FLAC__StreamDecoderProtected;
-
-/*
- * Return the number of input bytes consumed
- */
-uint32_t FLAC__stream_decoder_get_input_bytes_unconsumed(const FLAC__StreamDecoder *decoder);
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/protected/stream_encoder.h b/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/protected/stream_encoder.h
deleted file mode 100644
index 0354fb0b24..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/include/protected/stream_encoder.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2001-2009 Josh Coalson
- * Copyright (C) 2011-2023 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__PROTECTED__STREAM_ENCODER_H
-#define FLAC__PROTECTED__STREAM_ENCODER_H
-
-#include "../../../stream_encoder.h"
-#if FLAC__HAS_OGG
-#include "../private/ogg_encoder_aspect.h"
-#endif
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-
-#include "../private/float.h"
-
-#define FLAC__MAX_APODIZATION_FUNCTIONS 32
-
-typedef enum {
- FLAC__APODIZATION_BARTLETT,
- FLAC__APODIZATION_BARTLETT_HANN,
- FLAC__APODIZATION_BLACKMAN,
- FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE,
- FLAC__APODIZATION_CONNES,
- FLAC__APODIZATION_FLATTOP,
- FLAC__APODIZATION_GAUSS,
- FLAC__APODIZATION_HAMMING,
- FLAC__APODIZATION_HANN,
- FLAC__APODIZATION_KAISER_BESSEL,
- FLAC__APODIZATION_NUTTALL,
- FLAC__APODIZATION_RECTANGLE,
- FLAC__APODIZATION_TRIANGLE,
- FLAC__APODIZATION_TUKEY,
- FLAC__APODIZATION_PARTIAL_TUKEY,
- FLAC__APODIZATION_PUNCHOUT_TUKEY,
- FLAC__APODIZATION_SUBDIVIDE_TUKEY,
- FLAC__APODIZATION_WELCH
-} FLAC__ApodizationFunction;
-
-typedef struct {
- FLAC__ApodizationFunction type;
- union {
- struct {
- FLAC__real stddev;
- } gauss;
- struct {
- FLAC__real p;
- } tukey;
- struct {
- FLAC__real p;
- FLAC__real start;
- FLAC__real end;
- } multiple_tukey;
- struct {
- FLAC__real p;
- FLAC__int32 parts;
- } subdivide_tukey;
- } parameters;
-} FLAC__ApodizationSpecification;
-
-#endif // #ifndef FLAC__INTEGER_ONLY_LIBRARY
-
-typedef struct FLAC__StreamEncoderProtected {
- FLAC__StreamEncoderState state;
- FLAC__bool verify;
- FLAC__bool streamable_subset;
- FLAC__bool do_md5;
- FLAC__bool do_mid_side_stereo;
- FLAC__bool loose_mid_side_stereo;
- uint32_t channels;
- uint32_t bits_per_sample;
- uint32_t sample_rate;
- uint32_t blocksize;
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- uint32_t num_apodizations;
- FLAC__ApodizationSpecification apodizations[FLAC__MAX_APODIZATION_FUNCTIONS];
-#endif
- uint32_t max_lpc_order;
- uint32_t qlp_coeff_precision;
- FLAC__bool do_qlp_coeff_prec_search;
- FLAC__bool do_exhaustive_model_search;
- FLAC__bool do_escape_coding;
- uint32_t min_residual_partition_order;
- uint32_t max_residual_partition_order;
- uint32_t rice_parameter_search_dist;
- FLAC__uint64 total_samples_estimate;
- FLAC__bool limit_min_bitrate;
- FLAC__StreamMetadata **metadata;
- uint32_t num_metadata_blocks;
- FLAC__uint64 streaminfo_offset, seektable_offset, audio_offset;
-#if FLAC__HAS_OGG
- FLAC__OggEncoderAspect ogg_encoder_aspect;
-#endif
-} FLAC__StreamEncoderProtected;
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/lpc_flac.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/lpc_flac.c
deleted file mode 100644
index e86cd1134f..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/lpc_flac.c
+++ /dev/null
@@ -1,1629 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include
-#include
-
-#include "../assert.h"
-#include "../format.h"
-#include "../compat.h"
-#include "include/private/bitmath.h"
-#include "include/private/lpc.h"
-
-
-#if !defined(NDEBUG) || defined FLAC__OVERFLOW_DETECT || defined FLAC__OVERFLOW_DETECT_VERBOSE
-#include
-#endif
-
-/* OPT: #undef'ing this may improve the speed on some architectures */
-#define FLAC__LPC_UNROLLED_FILTER_LOOPS
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-
-#if defined(_MSC_VER) && (_MSC_VER < 1800)
-#include
-static inline long int lround(double x) {
- return (long)(x + _copysign(0.5, x));
-}
-#elif !defined(HAVE_LROUND) && defined(__GNUC__)
-static inline long int lround(double x) {
- return (long)(x + __builtin_copysign(0.5, x));
-}
-/* If this fails, we are in the presence of a mid 90's compiler, move along... */
-#endif
-
-void FLAC__lpc_window_data(const FLAC__int32 in[], const FLAC__real window[], FLAC__real out[], uint32_t data_len)
-{
- uint32_t i;
- for(i = 0; i < data_len; i++)
- out[i] = in[i] * window[i];
-}
-
-void FLAC__lpc_window_data_wide(const FLAC__int64 in[], const FLAC__real window[], FLAC__real out[], uint32_t data_len)
-{
- uint32_t i;
- for(i = 0; i < data_len; i++)
- out[i] = in[i] * window[i];
-}
-
-void FLAC__lpc_window_data_partial(const FLAC__int32 in[], const FLAC__real window[], FLAC__real out[], uint32_t data_len, uint32_t part_size, uint32_t data_shift)
-{
- uint32_t i, j;
- if((part_size + data_shift) < data_len){
- for(i = 0; i < part_size; i++)
- out[i] = in[data_shift+i] * window[i];
- i = flac_min(i,data_len - part_size - data_shift);
- for(j = data_len - part_size; j < data_len; i++, j++)
- out[i] = in[data_shift+i] * window[j];
- if(i < data_len)
- out[i] = 0.0f;
- }
-}
-
-void FLAC__lpc_window_data_partial_wide(const FLAC__int64 in[], const FLAC__real window[], FLAC__real out[], uint32_t data_len, uint32_t part_size, uint32_t data_shift)
-{
- uint32_t i, j;
- if((part_size + data_shift) < data_len){
- for(i = 0; i < part_size; i++)
- out[i] = in[data_shift+i] * window[i];
- i = flac_min(i,data_len - part_size - data_shift);
- for(j = data_len - part_size; j < data_len; i++, j++)
- out[i] = in[data_shift+i] * window[j];
- if(i < data_len)
- out[i] = 0.0f;
- }
-}
-
-void FLAC__lpc_compute_autocorrelation(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[])
-{
- /* a readable, but slower, version */
-#if 0
- double d;
- uint32_t i;
-
- FLAC__ASSERT(lag > 0);
- FLAC__ASSERT(lag <= data_len);
-
- /*
- * Technically we should subtract the mean first like so:
- * for(i = 0; i < data_len; i++)
- * data[i] -= mean;
- * but it appears not to make enough of a difference to matter, and
- * most signals are already closely centered around zero
- */
- while(lag--) {
- for(i = lag, d = 0.0; i < data_len; i++)
- d += data[i] * (double)data[i - lag];
- autoc[lag] = d;
- }
-#endif
- if (data_len < FLAC__MAX_LPC_ORDER || lag > 16) {
- /*
- * this version tends to run faster because of better data locality
- * ('data_len' is usually much larger than 'lag')
- */
- double d;
- uint32_t sample, coeff;
- const uint32_t limit = data_len - lag;
-
- FLAC__ASSERT(lag > 0);
- FLAC__ASSERT(lag <= data_len);
-
- for(coeff = 0; coeff < lag; coeff++)
- autoc[coeff] = 0.0;
- for(sample = 0; sample <= limit; sample++) {
- d = data[sample];
- for(coeff = 0; coeff < lag; coeff++)
- autoc[coeff] += d * data[sample+coeff];
- }
- for(; sample < data_len; sample++) {
- d = data[sample];
- for(coeff = 0; coeff < data_len - sample; coeff++)
- autoc[coeff] += d * data[sample+coeff];
- }
- }
- else if(lag <= 8) {
- #undef MAX_LAG
- #define MAX_LAG 8
- #include "deduplication/lpc_compute_autocorrelation_intrin.c"
- }
- else if(lag <= 12) {
- #undef MAX_LAG
- #define MAX_LAG 12
- #include "deduplication/lpc_compute_autocorrelation_intrin.c"
- }
- else if(lag <= 16) {
- #undef MAX_LAG
- #define MAX_LAG 16
- #include "deduplication/lpc_compute_autocorrelation_intrin.c"
- }
-
-}
-
-void FLAC__lpc_compute_lp_coefficients(const double autoc[], uint32_t *max_order, FLAC__real lp_coeff[][FLAC__MAX_LPC_ORDER], double error[])
-{
- uint32_t i, j;
- double r, err, lpc[FLAC__MAX_LPC_ORDER];
-
- FLAC__ASSERT(0 != max_order);
- FLAC__ASSERT(0 < *max_order);
- FLAC__ASSERT(*max_order <= FLAC__MAX_LPC_ORDER);
- FLAC__ASSERT(autoc[0] != 0.0);
-
- err = autoc[0];
-
- for(i = 0; i < *max_order; i++) {
- /* Sum up this iteration's reflection coefficient. */
- r = -autoc[i+1];
- for(j = 0; j < i; j++)
- r -= lpc[j] * autoc[i-j];
- r /= err;
-
- /* Update LPC coefficients and total error. */
- lpc[i]=r;
- for(j = 0; j < (i>>1); j++) {
- double tmp = lpc[j];
- lpc[j] += r * lpc[i-1-j];
- lpc[i-1-j] += r * tmp;
- }
- if(i & 1)
- lpc[j] += lpc[j] * r;
-
- err *= (1.0 - r * r);
-
- /* save this order */
- for(j = 0; j <= i; j++)
- lp_coeff[i][j] = (FLAC__real)(-lpc[j]); /* negate FIR filter coeff to get predictor coeff */
- error[i] = err;
-
- /* see SF bug https://sourceforge.net/p/flac/bugs/234/ */
- if(err == 0.0) {
- *max_order = i+1;
- return;
- }
- }
-}
-
-int FLAC__lpc_quantize_coefficients(const FLAC__real lp_coeff[], uint32_t order, uint32_t precision, FLAC__int32 qlp_coeff[], int *shift)
-{
- uint32_t i;
- double cmax;
- FLAC__int32 qmax, qmin;
-
- FLAC__ASSERT(precision > 0);
- FLAC__ASSERT(precision >= FLAC__MIN_QLP_COEFF_PRECISION);
-
- /* drop one bit for the sign; from here on out we consider only |lp_coeff[i]| */
- precision--;
- qmax = 1 << precision;
- qmin = -qmax;
- qmax--;
-
- /* calc cmax = max( |lp_coeff[i]| ) */
- cmax = 0.0;
- for(i = 0; i < order; i++) {
- const double d = fabs(lp_coeff[i]);
- if(d > cmax)
- cmax = d;
- }
-
- if(cmax <= 0.0) {
- /* => coefficients are all 0, which means our constant-detect didn't work */
- return 2;
- }
- else {
- const int max_shiftlimit = (1 << (FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN-1)) - 1;
- const int min_shiftlimit = -max_shiftlimit - 1;
- int log2cmax;
-
- (void)frexp(cmax, &log2cmax);
- log2cmax--;
- *shift = (int)precision - log2cmax - 1;
-
- if(*shift > max_shiftlimit)
- *shift = max_shiftlimit;
- else if(*shift < min_shiftlimit)
- return 1;
- }
-
- if(*shift >= 0) {
- double error = 0.0;
- FLAC__int32 q;
- for(i = 0; i < order; i++) {
- error += lp_coeff[i] * (1 << *shift);
- q = lround(error);
-
-#ifdef FLAC__OVERFLOW_DETECT
- if(q > qmax+1) /* we expect q==qmax+1 occasionally due to rounding */
- fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q>qmax %d>%d shift=%d cmax=%f precision=%u lpc[%u]=%f\n",q,qmax,*shift,cmax,precision+1,i,lp_coeff[i]);
- else if(q < qmin)
- fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q qmax)
- q = qmax;
- else if(q < qmin)
- q = qmin;
- error -= q;
- qlp_coeff[i] = q;
- }
- }
- /* negative shift is very rare but due to design flaw, negative shift is
- * not allowed in the decoder, so it must be handled specially by scaling
- * down coeffs
- */
- else {
- const int nshift = -(*shift);
- double error = 0.0;
- FLAC__int32 q;
-#ifndef NDEBUG
- fprintf(stderr,"FLAC__lpc_quantize_coefficients: negative shift=%d order=%u cmax=%f\n", *shift, order, cmax);
-#endif
- for(i = 0; i < order; i++) {
- error += lp_coeff[i] / (1 << nshift);
- q = lround(error);
-#ifdef FLAC__OVERFLOW_DETECT
- if(q > qmax+1) /* we expect q==qmax+1 occasionally due to rounding */
- fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q>qmax %d>%d shift=%d cmax=%f precision=%u lpc[%u]=%f\n",q,qmax,*shift,cmax,precision+1,i,lp_coeff[i]);
- else if(q < qmin)
- fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q qmax)
- q = qmax;
- else if(q < qmin)
- q = qmin;
- error -= q;
- qlp_coeff[i] = q;
- }
- *shift = 0;
- }
-
- return 0;
-}
-
-#if defined(_MSC_VER)
-// silence MSVC warnings about __restrict modifier
-#pragma warning ( disable : 4028 )
-#endif
-
-void FLAC__lpc_compute_residual_from_qlp_coefficients(const FLAC__int32 * flac_restrict data, uint32_t data_len, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order, int lp_quantization, FLAC__int32 * flac_restrict residual)
-#if defined(FLAC__OVERFLOW_DETECT) || !defined(FLAC__LPC_UNROLLED_FILTER_LOOPS)
-{
- FLAC__int64 sumo;
- uint32_t i, j;
- FLAC__int32 sum;
- const FLAC__int32 *history;
-
-#ifdef FLAC__OVERFLOW_DETECT_VERBOSE
- fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
- for(i=0;i 0);
-
- for(i = 0; i < data_len; i++) {
- sumo = 0;
- sum = 0;
- history = data;
- for(j = 0; j < order; j++) {
- sum += qlp_coeff[j] * (*(--history));
- sumo += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*history);
- if(sumo > 2147483647ll || sumo < -2147483648ll)
- fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients: OVERFLOW, i=%u, j=%u, c=%d, d=%d, sumo=%" PRId64 "\n",i,j,qlp_coeff[j],*history,sumo);
- }
- *(residual++) = *(data++) - (sum >> lp_quantization);
- }
-
- /* Here's a slower but clearer version:
- for(i = 0; i < data_len; i++) {
- sum = 0;
- for(j = 0; j < order; j++)
- sum += qlp_coeff[j] * data[i-j-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- */
-}
-#else /* fully unrolled version for normal use */
-{
- int i;
- FLAC__int32 sum;
-
- FLAC__ASSERT(order > 0);
- FLAC__ASSERT(order <= 32);
-
- /*
- * We do unique versions up to 12th order since that's the subset limit.
- * Also they are roughly ordered to match frequency of occurrence to
- * minimize branching.
- */
- if(order <= 12) {
- if(order > 8) {
- if(order > 10) {
- if(order == 12) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[11] * data[i-12];
- sum += qlp_coeff[10] * data[i-11];
- sum += qlp_coeff[9] * data[i-10];
- sum += qlp_coeff[8] * data[i-9];
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 11 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[10] * data[i-11];
- sum += qlp_coeff[9] * data[i-10];
- sum += qlp_coeff[8] * data[i-9];
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- else {
- if(order == 10) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[9] * data[i-10];
- sum += qlp_coeff[8] * data[i-9];
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 9 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[8] * data[i-9];
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- }
- else if(order > 4) {
- if(order > 6) {
- if(order == 8) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 7 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- else {
- if(order == 6) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 5 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- }
- else {
- if(order > 2) {
- if(order == 4) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 3 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- else {
- if(order == 2) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 1 */
- for(i = 0; i < (int)data_len; i++)
- residual[i] = data[i] - ((qlp_coeff[0] * data[i-1]) >> lp_quantization);
- }
- }
- }
- }
- else { /* order > 12 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- switch(order) {
- case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */
- case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */
- case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */
- case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */
- case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */
- case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */
- case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */
- case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */
- case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */
- case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */
- case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */
- case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */
- case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */
- case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */
- case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */
- case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */
- case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */
- case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */
- case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */
- case 13: sum += qlp_coeff[12] * data[i-13];
- sum += qlp_coeff[11] * data[i-12];
- sum += qlp_coeff[10] * data[i-11];
- sum += qlp_coeff[ 9] * data[i-10];
- sum += qlp_coeff[ 8] * data[i- 9];
- sum += qlp_coeff[ 7] * data[i- 8];
- sum += qlp_coeff[ 6] * data[i- 7];
- sum += qlp_coeff[ 5] * data[i- 6];
- sum += qlp_coeff[ 4] * data[i- 5];
- sum += qlp_coeff[ 3] * data[i- 4];
- sum += qlp_coeff[ 2] * data[i- 3];
- sum += qlp_coeff[ 1] * data[i- 2];
- sum += qlp_coeff[ 0] * data[i- 1];
- }
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
-}
-#endif
-
-void FLAC__lpc_compute_residual_from_qlp_coefficients_wide(const FLAC__int32 * flac_restrict data, uint32_t data_len, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order, int lp_quantization, FLAC__int32 * flac_restrict residual)
-#if defined(FLAC__OVERFLOW_DETECT) || !defined(FLAC__LPC_UNROLLED_FILTER_LOOPS)
-{
- uint32_t i, j;
- FLAC__int64 sum;
- const FLAC__int32 *history;
-
-#ifdef FLAC__OVERFLOW_DETECT_VERBOSE
- fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients_wide: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
- for(i=0;i 0);
-
- for(i = 0; i < data_len; i++) {
- sum = 0;
- history = data;
- for(j = 0; j < order; j++)
- sum += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*(--history));
- if(FLAC__bitmath_silog2((FLAC__int64)(*data) - (sum >> lp_quantization)) > 32) {
- fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients_wide: OVERFLOW, i=%u, data=%d, sum=%" PRId64 ", residual=%" PRId64 "\n", i, *data, (int64_t)(sum >> lp_quantization), ((FLAC__int64)(*data) - (sum >> lp_quantization)));
- break;
- }
- *(residual++) = *(data++) - (FLAC__int32)(sum >> lp_quantization);
- }
-}
-#else /* fully unrolled version for normal use */
-{
- int i;
- FLAC__int64 sum;
-
- FLAC__ASSERT(order > 0);
- FLAC__ASSERT(order <= 32);
-
- /*
- * We do unique versions up to 12th order since that's the subset limit.
- * Also they are roughly ordered to match frequency of occurrence to
- * minimize branching.
- */
- if(order <= 12) {
- if(order > 8) {
- if(order > 10) {
- if(order == 12) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[11] * (FLAC__int64)data[i-12];
- sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
- sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
- sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 11 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
- sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
- sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- else {
- if(order == 10) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
- sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 9 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- }
- else if(order > 4) {
- if(order > 6) {
- if(order == 8) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 7 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- else {
- if(order == 6) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 5 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- }
- else {
- if(order > 2) {
- if(order == 4) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 3 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- }
- else {
- if(order == 2) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
- else { /* order == 1 */
- for(i = 0; i < (int)data_len; i++)
- residual[i] = data[i] - ((qlp_coeff[0] * (FLAC__int64)data[i-1]) >> lp_quantization);
- }
- }
- }
- }
- else { /* order > 12 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- switch(order) {
- case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32]; /* Falls through. */
- case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31]; /* Falls through. */
- case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30]; /* Falls through. */
- case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29]; /* Falls through. */
- case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28]; /* Falls through. */
- case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27]; /* Falls through. */
- case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26]; /* Falls through. */
- case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25]; /* Falls through. */
- case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24]; /* Falls through. */
- case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23]; /* Falls through. */
- case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22]; /* Falls through. */
- case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21]; /* Falls through. */
- case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20]; /* Falls through. */
- case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19]; /* Falls through. */
- case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18]; /* Falls through. */
- case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17]; /* Falls through. */
- case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16]; /* Falls through. */
- case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15]; /* Falls through. */
- case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14]; /* Falls through. */
- case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13];
- sum += qlp_coeff[11] * (FLAC__int64)data[i-12];
- sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
- sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10];
- sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9];
- sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8];
- sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7];
- sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6];
- sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5];
- sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4];
- sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3];
- sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2];
- sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1];
- }
- residual[i] = data[i] - (sum >> lp_quantization);
- }
- }
-}
-#endif
-
-FLAC__bool FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual(const FLAC__int32 * flac_restrict data, uint32_t data_len, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order, int lp_quantization, FLAC__int32 * flac_restrict residual)
-{
- int i;
- FLAC__int64 sum, residual_to_check;
-
- FLAC__ASSERT(order > 0);
- FLAC__ASSERT(order <= 32);
-
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- switch(order) {
- case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32]; /* Falls through. */
- case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31]; /* Falls through. */
- case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30]; /* Falls through. */
- case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29]; /* Falls through. */
- case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28]; /* Falls through. */
- case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27]; /* Falls through. */
- case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26]; /* Falls through. */
- case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25]; /* Falls through. */
- case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24]; /* Falls through. */
- case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23]; /* Falls through. */
- case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22]; /* Falls through. */
- case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21]; /* Falls through. */
- case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20]; /* Falls through. */
- case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19]; /* Falls through. */
- case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18]; /* Falls through. */
- case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17]; /* Falls through. */
- case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16]; /* Falls through. */
- case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15]; /* Falls through. */
- case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14]; /* Falls through. */
- case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13]; /* Falls through. */
- case 12: sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; /* Falls through. */
- case 11: sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; /* Falls through. */
- case 10: sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10]; /* Falls through. */
- case 9: sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9]; /* Falls through. */
- case 8: sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8]; /* Falls through. */
- case 7: sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7]; /* Falls through. */
- case 6: sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6]; /* Falls through. */
- case 5: sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5]; /* Falls through. */
- case 4: sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4]; /* Falls through. */
- case 3: sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3]; /* Falls through. */
- case 2: sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; /* Falls through. */
- case 1: sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1];
- }
- residual_to_check = data[i] - (sum >> lp_quantization);
- /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */
- if(residual_to_check <= INT32_MIN || residual_to_check > INT32_MAX)
- return false;
- else
- residual[i] = residual_to_check;
- }
- return true;
-}
-
-FLAC__bool FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual_33bit(const FLAC__int64 * flac_restrict data, uint32_t data_len, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order, int lp_quantization, FLAC__int32 * flac_restrict residual)
-{
- int i;
- FLAC__int64 sum, residual_to_check;
-
- FLAC__ASSERT(order > 0);
- FLAC__ASSERT(order <= 32);
-
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- switch(order) {
- case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */
- case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */
- case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */
- case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */
- case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */
- case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */
- case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */
- case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */
- case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */
- case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */
- case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */
- case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */
- case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */
- case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */
- case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */
- case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */
- case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */
- case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */
- case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */
- case 13: sum += qlp_coeff[12] * data[i-13]; /* Falls through. */
- case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */
- case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */
- case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */
- case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */
- case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */
- case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */
- case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */
- case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */
- case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */
- case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */
- case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */
- case 1: sum += qlp_coeff[ 0] * data[i- 1];
- }
- residual_to_check = data[i] - (sum >> lp_quantization);
- /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */
- if(residual_to_check <= INT32_MIN || residual_to_check > INT32_MAX)
- return false;
- else
- residual[i] = residual_to_check;
- }
- return true;
-}
-
-#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
-
-uint32_t FLAC__lpc_max_prediction_before_shift_bps(uint32_t subframe_bps, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order)
-{
- /* This used to be subframe_bps + qlp_coeff_precision + FLAC__bitmath_ilog2(order)
- * but that treats both the samples as well as the predictor as unknown. The
- * predictor is known however, so taking the log2 of the sum of the absolute values
- * of all coefficients is a more accurate representation of the predictor */
- FLAC__int32 abs_sum_of_qlp_coeff = 0;
- uint32_t i;
- for(i = 0; i < order; i++)
- abs_sum_of_qlp_coeff += abs(qlp_coeff[i]);
- if(abs_sum_of_qlp_coeff == 0)
- abs_sum_of_qlp_coeff = 1;
- return subframe_bps + FLAC__bitmath_silog2(abs_sum_of_qlp_coeff);
-}
-
-
-uint32_t FLAC__lpc_max_residual_bps(uint32_t subframe_bps, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order, int lp_quantization)
-{
- FLAC__int32 predictor_sum_bps = FLAC__lpc_max_prediction_before_shift_bps(subframe_bps, qlp_coeff, order) - lp_quantization;
- if((int)subframe_bps > predictor_sum_bps)
- return subframe_bps + 1;
- else
- return predictor_sum_bps + 1;
-}
-
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && !defined(FUZZING_BUILD_MODE_FLAC_SANITIZE_SIGNED_INTEGER_OVERFLOW)
-/* The attribute below is to silence the undefined sanitizer of oss-fuzz.
- * Because fuzzing feeds bogus predictors and residual samples to the
- * decoder, having overflows in this section is unavoidable. Also,
- * because the calculated values are audio path only, there is no
- * potential for security problems */
-__attribute__((no_sanitize("signed-integer-overflow")))
-#endif
-void FLAC__lpc_restore_signal(const FLAC__int32 * flac_restrict residual, uint32_t data_len, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order, int lp_quantization, FLAC__int32 * flac_restrict data)
-#if defined(FLAC__OVERFLOW_DETECT) || !defined(FLAC__LPC_UNROLLED_FILTER_LOOPS)
-{
- FLAC__int64 sumo;
- uint32_t i, j;
- FLAC__int32 sum;
- const FLAC__int32 *r = residual, *history;
-
-#ifdef FLAC__OVERFLOW_DETECT_VERBOSE
- fprintf(stderr,"FLAC__lpc_restore_signal: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
- for(i=0;i 0);
-
- for(i = 0; i < data_len; i++) {
- sumo = 0;
- sum = 0;
- history = data;
- for(j = 0; j < order; j++) {
- sum += qlp_coeff[j] * (*(--history));
- sumo += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*history);
-#ifdef FLAC__OVERFLOW_DETECT
- if(sumo > 2147483647ll || sumo < -2147483648ll)
- fprintf(stderr,"FLAC__lpc_restore_signal: OVERFLOW, i=%u, j=%u, c=%d, d=%d, sumo=%" PRId64 "\n",i,j,qlp_coeff[j],*history,sumo);
-#endif
- }
- *(data++) = *(r++) + (sum >> lp_quantization);
- }
-
- /* Here's a slower but clearer version:
- for(i = 0; i < data_len; i++) {
- sum = 0;
- for(j = 0; j < order; j++)
- sum += qlp_coeff[j] * data[i-j-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- */
-}
-#else /* fully unrolled version for normal use */
-{
- int i;
- FLAC__int32 sum;
-
- FLAC__ASSERT(order > 0);
- FLAC__ASSERT(order <= 32);
-
- /*
- * We do unique versions up to 12th order since that's the subset limit.
- * Also they are roughly ordered to match frequency of occurrence to
- * minimize branching.
- */
- if(order <= 12) {
- if(order > 8) {
- if(order > 10) {
- if(order == 12) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[11] * data[i-12];
- sum += qlp_coeff[10] * data[i-11];
- sum += qlp_coeff[9] * data[i-10];
- sum += qlp_coeff[8] * data[i-9];
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- else { /* order == 11 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[10] * data[i-11];
- sum += qlp_coeff[9] * data[i-10];
- sum += qlp_coeff[8] * data[i-9];
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- }
- else {
- if(order == 10) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[9] * data[i-10];
- sum += qlp_coeff[8] * data[i-9];
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- else { /* order == 9 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[8] * data[i-9];
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- }
- }
- else if(order > 4) {
- if(order > 6) {
- if(order == 8) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[7] * data[i-8];
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- else { /* order == 7 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[6] * data[i-7];
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- }
- else {
- if(order == 6) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[5] * data[i-6];
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- else { /* order == 5 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[4] * data[i-5];
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- }
- }
- else {
- if(order > 2) {
- if(order == 4) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[3] * data[i-4];
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- else { /* order == 3 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[2] * data[i-3];
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- }
- else {
- if(order == 2) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[1] * data[i-2];
- sum += qlp_coeff[0] * data[i-1];
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
- else { /* order == 1 */
- for(i = 0; i < (int)data_len; i++)
- data[i] = residual[i] + ((qlp_coeff[0] * data[i-1]) >> lp_quantization);
- }
- }
- }
- }
- else { /* order > 12 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- switch(order) {
- case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */
- case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */
- case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */
- case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */
- case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */
- case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */
- case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */
- case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */
- case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */
- case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */
- case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */
- case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */
- case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */
- case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */
- case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */
- case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */
- case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */
- case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */
- case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */
- case 13: sum += qlp_coeff[12] * data[i-13];
- sum += qlp_coeff[11] * data[i-12];
- sum += qlp_coeff[10] * data[i-11];
- sum += qlp_coeff[ 9] * data[i-10];
- sum += qlp_coeff[ 8] * data[i- 9];
- sum += qlp_coeff[ 7] * data[i- 8];
- sum += qlp_coeff[ 6] * data[i- 7];
- sum += qlp_coeff[ 5] * data[i- 6];
- sum += qlp_coeff[ 4] * data[i- 5];
- sum += qlp_coeff[ 3] * data[i- 4];
- sum += qlp_coeff[ 2] * data[i- 3];
- sum += qlp_coeff[ 1] * data[i- 2];
- sum += qlp_coeff[ 0] * data[i- 1];
- }
- data[i] = residual[i] + (sum >> lp_quantization);
- }
- }
-}
-#endif
-
-void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, uint32_t data_len, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order, int lp_quantization, FLAC__int32 * flac_restrict data)
-#if defined(FLAC__OVERFLOW_DETECT) || !defined(FLAC__LPC_UNROLLED_FILTER_LOOPS)
-{
- uint32_t i, j;
- FLAC__int64 sum;
- const FLAC__int32 *r = residual, *history;
-
-#ifdef FLAC__OVERFLOW_DETECT_VERBOSE
- fprintf(stderr,"FLAC__lpc_restore_signal_wide: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
- for(i=0;i 0);
-
- for(i = 0; i < data_len; i++) {
- sum = 0;
- history = data;
- for(j = 0; j < order; j++)
- sum += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*(--history));
-#ifdef FLAC__OVERFLOW_DETECT
- if(FLAC__bitmath_silog2((FLAC__int64)(*r) + (sum >> lp_quantization)) > 32) {
- fprintf(stderr,"FLAC__lpc_restore_signal_wide: OVERFLOW, i=%u, residual=%d, sum=%" PRId64 ", data=%" PRId64 "\n", i, *r, (sum >> lp_quantization), ((FLAC__int64)(*r) + (sum >> lp_quantization)));
- break;
- }
-#endif
- *(data++) = (FLAC__int32)(*(r++) + (sum >> lp_quantization));
- }
-}
-#else /* fully unrolled version for normal use */
-{
- int i;
- FLAC__int64 sum;
-
- FLAC__ASSERT(order > 0);
- FLAC__ASSERT(order <= 32);
-
- /*
- * We do unique versions up to 12th order since that's the subset limit.
- * Also they are roughly ordered to match frequency of occurrence to
- * minimize branching.
- */
- if(order <= 12) {
- if(order > 8) {
- if(order > 10) {
- if(order == 12) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[11] * (FLAC__int64)data[i-12];
- sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
- sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
- sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- else { /* order == 11 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
- sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
- sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- }
- else {
- if(order == 10) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
- sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- else { /* order == 9 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- }
- }
- else if(order > 4) {
- if(order > 6) {
- if(order == 8) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- else { /* order == 7 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- }
- else {
- if(order == 6) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- else { /* order == 5 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- }
- }
- else {
- if(order > 2) {
- if(order == 4) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- else { /* order == 3 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- }
- else {
- if(order == 2) {
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
- sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
- else { /* order == 1 */
- for(i = 0; i < (int)data_len; i++)
- data[i] = (FLAC__int32)(residual[i] + ((qlp_coeff[0] * (FLAC__int64)data[i-1]) >> lp_quantization));
- }
- }
- }
- }
- else { /* order > 12 */
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- switch(order) {
- case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32]; /* Falls through. */
- case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31]; /* Falls through. */
- case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30]; /* Falls through. */
- case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29]; /* Falls through. */
- case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28]; /* Falls through. */
- case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27]; /* Falls through. */
- case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26]; /* Falls through. */
- case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25]; /* Falls through. */
- case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24]; /* Falls through. */
- case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23]; /* Falls through. */
- case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22]; /* Falls through. */
- case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21]; /* Falls through. */
- case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20]; /* Falls through. */
- case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19]; /* Falls through. */
- case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18]; /* Falls through. */
- case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17]; /* Falls through. */
- case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16]; /* Falls through. */
- case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15]; /* Falls through. */
- case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14]; /* Falls through. */
- case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13];
- sum += qlp_coeff[11] * (FLAC__int64)data[i-12];
- sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
- sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10];
- sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9];
- sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8];
- sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7];
- sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6];
- sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5];
- sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4];
- sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3];
- sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2];
- sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1];
- }
- data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization));
- }
- }
-}
-#endif
-
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && !defined(FUZZING_BUILD_MODE_FLAC_SANITIZE_SIGNED_INTEGER_OVERFLOW)
-/* The attribute below is to silence the undefined sanitizer of oss-fuzz.
- * Because fuzzing feeds bogus predictors and residual samples to the
- * decoder, having overflows in this section is unavoidable. Also,
- * because the calculated values are audio path only, there is no
- * potential for security problems */
-__attribute__((no_sanitize("signed-integer-overflow")))
-#endif
-void FLAC__lpc_restore_signal_wide_33bit(const FLAC__int32 * flac_restrict residual, uint32_t data_len, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order, int lp_quantization, FLAC__int64 * flac_restrict data)
-#if defined(FLAC__OVERFLOW_DETECT) || !defined(FLAC__LPC_UNROLLED_FILTER_LOOPS)
-{
- uint32_t i, j;
- FLAC__int64 sum;
- const FLAC__int32 *r = residual;
- const FLAC__int64 *history;
-
- FLAC__ASSERT(order > 0);
-
- for(i = 0; i < data_len; i++) {
- sum = 0;
- history = data;
- for(j = 0; j < order; j++)
- sum += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*(--history));
-#ifdef FLAC__OVERFLOW_DETECT
- if(FLAC__bitmath_silog2((FLAC__int64)(*r) + (sum >> lp_quantization)) > 33) {
- fprintf(stderr,"FLAC__lpc_restore_signal_33bit: OVERFLOW, i=%u, residual=%d, sum=%" PRId64 ", data=%" PRId64 "\n", i, *r, (sum >> lp_quantization), ((FLAC__int64)(*r) + (sum >> lp_quantization)));
- break;
- }
-#endif
- *(data++) = (FLAC__int64)(*(r++)) + (sum >> lp_quantization);
- }
-}
-#else /* unrolled version for normal use */
-{
- int i;
- FLAC__int64 sum;
-
- FLAC__ASSERT(order > 0);
- FLAC__ASSERT(order <= 32);
-
- for(i = 0; i < (int)data_len; i++) {
- sum = 0;
- switch(order) {
- case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */
- case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */
- case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */
- case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */
- case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */
- case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */
- case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */
- case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */
- case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */
- case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */
- case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */
- case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */
- case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */
- case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */
- case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */
- case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */
- case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */
- case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */
- case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */
- case 13: sum += qlp_coeff[12] * data[i-13]; /* Falls through. */
- case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */
- case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */
- case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */
- case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */
- case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */
- case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */
- case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */
- case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */
- case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */
- case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */
- case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */
- case 1: sum += qlp_coeff[ 0] * data[i- 1];
- }
- data[i] = residual[i] + (sum >> lp_quantization);
- }
-}
-#endif
-
-#if defined(_MSC_VER)
-#pragma warning ( default : 4028 )
-#endif
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-
-double FLAC__lpc_compute_expected_bits_per_residual_sample(double lpc_error, uint32_t total_samples)
-{
- double error_scale;
-
- FLAC__ASSERT(total_samples > 0);
-
- error_scale = 0.5 / (double)total_samples;
-
- return FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error, error_scale);
-}
-
-double FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(double lpc_error, double error_scale)
-{
- if(lpc_error > 0.0) {
- double bps = (double)0.5 * log(error_scale * lpc_error) / M_LN2;
- if(bps >= 0.0)
- return bps;
- else
- return 0.0;
- }
- else if(lpc_error < 0.0) { /* error should not be negative but can happen due to inadequate floating-point resolution */
- return 1e32;
- }
- else {
- return 0.0;
- }
-}
-
-uint32_t FLAC__lpc_compute_best_order(const double lpc_error[], uint32_t max_order, uint32_t total_samples, uint32_t overhead_bits_per_order)
-{
- uint32_t order, indx, best_index; /* 'index' the index into lpc_error; index==order-1 since lpc_error[0] is for order==1, lpc_error[1] is for order==2, etc */
- double bits, best_bits, error_scale;
-
- FLAC__ASSERT(max_order > 0);
- FLAC__ASSERT(total_samples > 0);
-
- error_scale = 0.5 / (double)total_samples;
-
- best_index = 0;
- best_bits = (uint32_t)(-1);
-
- for(indx = 0, order = 1; indx < max_order; indx++, order++) {
- bits = FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error[indx], error_scale) * (double)(total_samples - order) + (double)(order * overhead_bits_per_order);
- if(bits < best_bits) {
- best_index = indx;
- best_bits = bits;
- }
- }
-
- return best_index+1; /* +1 since indx of lpc_error[] is order-1 */
-}
-
-#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/md5.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/md5.c
deleted file mode 100644
index 06903c68b3..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/md5.c
+++ /dev/null
@@ -1,517 +0,0 @@
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include /* for malloc() */
-#include /* for memcpy() */
-
-#include "include/private/md5.h"
-#include "../alloc.h"
-#include "../compat.h"
-#include "../endswap.h"
-
-/*
- * This code implements the MD5 message-digest algorithm.
- * The algorithm is due to Ron Rivest. This code was
- * written by Colin Plumb in 1993, no copyright is claimed.
- * This code is in the public domain; do with it what you wish.
- *
- * Equivalent code is available from RSA Data Security, Inc.
- * This code has been tested against that, and is equivalent,
- * except that you don't need to include two pages of legalese
- * with every copy.
- *
- * To compute the message digest of a chunk of bytes, declare an
- * MD5Context structure, pass it to MD5Init, call MD5Update as
- * needed on buffers full of bytes, and then call MD5Final, which
- * will fill a supplied 16-byte array with the digest.
- *
- * Changed so as no longer to depend on Colin Plumb's `usual.h' header
- * definitions; now uses stuff from dpkg's config.h.
- * - Ian Jackson .
- * Still in the public domain.
- *
- * Josh Coalson: made some changes to integrate with libFLAC.
- * Still in the public domain.
- */
-
-/* The four core functions - F1 is optimized somewhat */
-
-/* #define F1(x, y, z) (x & y | ~x & z) */
-#define F1(x, y, z) (z ^ (x & (y ^ z)))
-#define F2(x, y, z) F1(z, x, y)
-#define F3(x, y, z) (x ^ y ^ z)
-#define F4(x, y, z) (y ^ (x | ~z))
-
-/* This is the central step in the MD5 algorithm. */
-#define MD5STEP(f,w,x,y,z,in,s) \
- (w += f(x,y,z) + in, w = (w<>(32-s)) + x)
-
-/*
- * The core of the MD5 algorithm, this alters an existing MD5 hash to
- * reflect the addition of 16 longwords of new data. MD5Update blocks
- * the data and converts bytes into longwords for this routine.
- */
-static void FLAC__MD5Transform(FLAC__uint32 buf[4], FLAC__uint32 const in[16])
-{
- FLAC__uint32 a, b, c, d;
-
- a = buf[0];
- b = buf[1];
- c = buf[2];
- d = buf[3];
-
- MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
- MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
- MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
- MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
- MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
- MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
- MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
- MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
- MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
- MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
- MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
- MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
- MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
- MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
- MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
- MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
- MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
- MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
- MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
- MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
- MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
- MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
- MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
- MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
- MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
- MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
- MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
- MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
- MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
- MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
- MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
- MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
- MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
- MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
- MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
- MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
- MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
- MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
- MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
- MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
- MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
- MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
- MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
- MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
- MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
- MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
- MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
- MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
- MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
- MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
- MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
- MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
- MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
- MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
- MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
- MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
- MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
- MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
- MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
- MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
- MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
- MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
- MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
- MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
- buf[0] += a;
- buf[1] += b;
- buf[2] += c;
- buf[3] += d;
-}
-
-#if WORDS_BIGENDIAN
-//@@@@@@ OPT: use bswap/intrinsics
-static void byteSwap(FLAC__uint32 *buf, uint32_t words)
-{
- register FLAC__uint32 x;
- do {
- x = *buf;
- x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff);
- *buf++ = (x >> 16) | (x << 16);
- } while (--words);
-}
-static void byteSwapX16(FLAC__uint32 *buf)
-{
- register FLAC__uint32 x;
-
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf++ = (x >> 16) | (x << 16);
- x = *buf; x = ((x << 8) & 0xff00ff00) | ((x >> 8) & 0x00ff00ff); *buf = (x >> 16) | (x << 16);
-}
-#else
-#define byteSwap(buf, words)
-#define byteSwapX16(buf)
-#endif
-
-/*
- * Update context to reflect the concatenation of another buffer full
- * of bytes.
- */
-static void FLAC__MD5Update(FLAC__MD5Context *ctx, FLAC__byte const *buf, uint32_t len)
-{
- FLAC__uint32 t;
-
- /* Update byte count */
-
- t = ctx->bytes[0];
- if ((ctx->bytes[0] = t + len) < t)
- ctx->bytes[1]++; /* Carry from low to high */
-
- t = 64 - (t & 0x3f); /* Space available in ctx->in (at least 1) */
- if (t > len) {
- memcpy((FLAC__byte *)ctx->in + 64 - t, buf, len);
- return;
- }
- /* First chunk is an odd size */
- memcpy((FLAC__byte *)ctx->in + 64 - t, buf, t);
- byteSwapX16(ctx->in);
- FLAC__MD5Transform(ctx->buf, ctx->in);
- buf += t;
- len -= t;
-
- /* Process data in 64-byte chunks */
- while (len >= 64) {
- memcpy(ctx->in, buf, 64);
- byteSwapX16(ctx->in);
- FLAC__MD5Transform(ctx->buf, ctx->in);
- buf += 64;
- len -= 64;
- }
-
- /* Handle any remaining bytes of data. */
- memcpy(ctx->in, buf, len);
-}
-
-/*
- * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
- * initialization constants.
- */
-void FLAC__MD5Init(FLAC__MD5Context *ctx)
-{
- ctx->buf[0] = 0x67452301;
- ctx->buf[1] = 0xefcdab89;
- ctx->buf[2] = 0x98badcfe;
- ctx->buf[3] = 0x10325476;
-
- ctx->bytes[0] = 0;
- ctx->bytes[1] = 0;
-
- ctx->internal_buf.p8 = 0;
- ctx->capacity = 0;
-}
-
-/*
- * Final wrapup - pad to 64-byte boundary with the bit pattern
- * 1 0* (64-bit count of bits processed, MSB-first)
- */
-void FLAC__MD5Final(FLAC__byte digest[16], FLAC__MD5Context *ctx)
-{
- int count = ctx->bytes[0] & 0x3f; /* Number of bytes in ctx->in */
- FLAC__byte *p = (FLAC__byte *)ctx->in + count;
-
- /* Set the first char of padding to 0x80. There is always room. */
- *p++ = 0x80;
-
- /* Bytes of padding needed to make 56 bytes (-8..55) */
- count = 56 - 1 - count;
-
- if (count < 0) { /* Padding forces an extra block */
- memset(p, 0, count + 8);
- byteSwapX16(ctx->in);
- FLAC__MD5Transform(ctx->buf, ctx->in);
- p = (FLAC__byte *)ctx->in;
- count = 56;
- }
- memset(p, 0, count);
- byteSwap(ctx->in, 14);
-
- /* Append length in bits and transform */
- ctx->in[14] = ctx->bytes[0] << 3;
- ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
- FLAC__MD5Transform(ctx->buf, ctx->in);
-
- byteSwap(ctx->buf, 4);
- memcpy(digest, ctx->buf, 16);
- if (0 != ctx->internal_buf.p8) {
- free(ctx->internal_buf.p8);
- ctx->internal_buf.p8 = 0;
- ctx->capacity = 0;
- }
- memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
-}
-
-/*
- * Convert the incoming audio signal to a byte stream
- */
-static void format_input_(FLAC__multibyte *mbuf, const FLAC__int32 * const signal[], uint32_t channels, uint32_t samples, uint32_t bytes_per_sample)
-{
- FLAC__byte *buf_ = mbuf->p8;
- FLAC__int16 *buf16 = mbuf->p16;
- FLAC__int32 *buf32 = mbuf->p32;
- FLAC__int32 a_word;
- uint32_t channel, sample;
-
- /* Storage in the output buffer, buf, is little endian. */
-
-#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels)
-
- /* First do the most commonly used combinations. */
- switch (BYTES_CHANNEL_SELECTOR (bytes_per_sample, channels)) {
- /* One byte per sample. */
- case (BYTES_CHANNEL_SELECTOR (1, 1)):
- for (sample = 0; sample < samples; sample++)
- *buf_++ = signal[0][sample];
- return;
-
- case (BYTES_CHANNEL_SELECTOR (1, 2)):
- for (sample = 0; sample < samples; sample++) {
- *buf_++ = signal[0][sample];
- *buf_++ = signal[1][sample];
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (1, 4)):
- for (sample = 0; sample < samples; sample++) {
- *buf_++ = signal[0][sample];
- *buf_++ = signal[1][sample];
- *buf_++ = signal[2][sample];
- *buf_++ = signal[3][sample];
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (1, 6)):
- for (sample = 0; sample < samples; sample++) {
- *buf_++ = signal[0][sample];
- *buf_++ = signal[1][sample];
- *buf_++ = signal[2][sample];
- *buf_++ = signal[3][sample];
- *buf_++ = signal[4][sample];
- *buf_++ = signal[5][sample];
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (1, 8)):
- for (sample = 0; sample < samples; sample++) {
- *buf_++ = signal[0][sample];
- *buf_++ = signal[1][sample];
- *buf_++ = signal[2][sample];
- *buf_++ = signal[3][sample];
- *buf_++ = signal[4][sample];
- *buf_++ = signal[5][sample];
- *buf_++ = signal[6][sample];
- *buf_++ = signal[7][sample];
- }
- return;
-
- /* Two bytes per sample. */
- case (BYTES_CHANNEL_SELECTOR (2, 1)):
- for (sample = 0; sample < samples; sample++)
- *buf16++ = H2LE_16(signal[0][sample]);
- return;
-
- case (BYTES_CHANNEL_SELECTOR (2, 2)):
- for (sample = 0; sample < samples; sample++) {
- *buf16++ = H2LE_16(signal[0][sample]);
- *buf16++ = H2LE_16(signal[1][sample]);
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (2, 4)):
- for (sample = 0; sample < samples; sample++) {
- *buf16++ = H2LE_16(signal[0][sample]);
- *buf16++ = H2LE_16(signal[1][sample]);
- *buf16++ = H2LE_16(signal[2][sample]);
- *buf16++ = H2LE_16(signal[3][sample]);
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (2, 6)):
- for (sample = 0; sample < samples; sample++) {
- *buf16++ = H2LE_16(signal[0][sample]);
- *buf16++ = H2LE_16(signal[1][sample]);
- *buf16++ = H2LE_16(signal[2][sample]);
- *buf16++ = H2LE_16(signal[3][sample]);
- *buf16++ = H2LE_16(signal[4][sample]);
- *buf16++ = H2LE_16(signal[5][sample]);
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (2, 8)):
- for (sample = 0; sample < samples; sample++) {
- *buf16++ = H2LE_16(signal[0][sample]);
- *buf16++ = H2LE_16(signal[1][sample]);
- *buf16++ = H2LE_16(signal[2][sample]);
- *buf16++ = H2LE_16(signal[3][sample]);
- *buf16++ = H2LE_16(signal[4][sample]);
- *buf16++ = H2LE_16(signal[5][sample]);
- *buf16++ = H2LE_16(signal[6][sample]);
- *buf16++ = H2LE_16(signal[7][sample]);
- }
- return;
-
- /* Three bytes per sample. */
- case (BYTES_CHANNEL_SELECTOR (3, 1)):
- for (sample = 0; sample < samples; sample++) {
- a_word = signal[0][sample];
- *buf_++ = (FLAC__byte)a_word; a_word >>= 8;
- *buf_++ = (FLAC__byte)a_word; a_word >>= 8;
- *buf_++ = (FLAC__byte)a_word;
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (3, 2)):
- for (sample = 0; sample < samples; sample++) {
- a_word = signal[0][sample];
- *buf_++ = (FLAC__byte)a_word; a_word >>= 8;
- *buf_++ = (FLAC__byte)a_word; a_word >>= 8;
- *buf_++ = (FLAC__byte)a_word;
- a_word = signal[1][sample];
- *buf_++ = (FLAC__byte)a_word; a_word >>= 8;
- *buf_++ = (FLAC__byte)a_word; a_word >>= 8;
- *buf_++ = (FLAC__byte)a_word;
- }
- return;
-
- /* Four bytes per sample. */
- case (BYTES_CHANNEL_SELECTOR (4, 1)):
- for (sample = 0; sample < samples; sample++)
- *buf32++ = H2LE_32(signal[0][sample]);
- return;
-
- case (BYTES_CHANNEL_SELECTOR (4, 2)):
- for (sample = 0; sample < samples; sample++) {
- *buf32++ = H2LE_32(signal[0][sample]);
- *buf32++ = H2LE_32(signal[1][sample]);
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (4, 4)):
- for (sample = 0; sample < samples; sample++) {
- *buf32++ = H2LE_32(signal[0][sample]);
- *buf32++ = H2LE_32(signal[1][sample]);
- *buf32++ = H2LE_32(signal[2][sample]);
- *buf32++ = H2LE_32(signal[3][sample]);
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (4, 6)):
- for (sample = 0; sample < samples; sample++) {
- *buf32++ = H2LE_32(signal[0][sample]);
- *buf32++ = H2LE_32(signal[1][sample]);
- *buf32++ = H2LE_32(signal[2][sample]);
- *buf32++ = H2LE_32(signal[3][sample]);
- *buf32++ = H2LE_32(signal[4][sample]);
- *buf32++ = H2LE_32(signal[5][sample]);
- }
- return;
-
- case (BYTES_CHANNEL_SELECTOR (4, 8)):
- for (sample = 0; sample < samples; sample++) {
- *buf32++ = H2LE_32(signal[0][sample]);
- *buf32++ = H2LE_32(signal[1][sample]);
- *buf32++ = H2LE_32(signal[2][sample]);
- *buf32++ = H2LE_32(signal[3][sample]);
- *buf32++ = H2LE_32(signal[4][sample]);
- *buf32++ = H2LE_32(signal[5][sample]);
- *buf32++ = H2LE_32(signal[6][sample]);
- *buf32++ = H2LE_32(signal[7][sample]);
- }
- return;
-
- default:
- break;
- }
-
- /* General version. */
- switch (bytes_per_sample) {
- case 1:
- for (sample = 0; sample < samples; sample++)
- for (channel = 0; channel < channels; channel++)
- *buf_++ = signal[channel][sample];
- return;
-
- case 2:
- for (sample = 0; sample < samples; sample++)
- for (channel = 0; channel < channels; channel++)
- *buf16++ = H2LE_16(signal[channel][sample]);
- return;
-
- case 3:
- for (sample = 0; sample < samples; sample++)
- for (channel = 0; channel < channels; channel++) {
- a_word = signal[channel][sample];
- *buf_++ = (FLAC__byte)a_word; a_word >>= 8;
- *buf_++ = (FLAC__byte)a_word; a_word >>= 8;
- *buf_++ = (FLAC__byte)a_word;
- }
- return;
-
- case 4:
- for (sample = 0; sample < samples; sample++)
- for (channel = 0; channel < channels; channel++)
- *buf32++ = H2LE_32(signal[channel][sample]);
- return;
-
- default:
- break;
- }
-}
-
-/*
- * Convert the incoming audio signal to a byte stream and FLAC__MD5Update it.
- */
-FLAC__bool FLAC__MD5Accumulate(FLAC__MD5Context *ctx, const FLAC__int32 * const signal[], uint32_t channels, uint32_t samples, uint32_t bytes_per_sample)
-{
- const size_t bytes_needed = (size_t)channels * (size_t)samples * (size_t)bytes_per_sample;
-
- /* overflow check */
- if ((size_t)channels > SIZE_MAX / (size_t)bytes_per_sample)
- return false;
- if ((size_t)channels * (size_t)bytes_per_sample > SIZE_MAX / (size_t)samples)
- return false;
-
- if (ctx->capacity < bytes_needed) {
- if (0 == (ctx->internal_buf.p8 = (FLAC__byte*) safe_realloc_(ctx->internal_buf.p8, bytes_needed))) {
- if (0 == (ctx->internal_buf.p8 = (FLAC__byte*) safe_malloc_(bytes_needed))) {
- ctx->capacity = 0;
- return false;
- }
- }
- ctx->capacity = bytes_needed;
- }
-
- format_input_(&ctx->internal_buf, signal, channels, samples, bytes_per_sample);
-
- FLAC__MD5Update(ctx, ctx->internal_buf.p8, bytes_needed);
-
- return true;
-}
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/memory.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/memory.c
deleted file mode 100644
index 8d563a6f37..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/memory.c
+++ /dev/null
@@ -1,219 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2001-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#ifdef HAVE_STDINT_H
-#include
-#endif
-
-#include "include/private/memory.h"
-#include "../assert.h"
-#include "../compat.h"
-#include "../alloc.h"
-
-void *FLAC__memory_alloc_aligned(size_t bytes, void **aligned_address)
-{
- void *x;
-
- FLAC__ASSERT(0 != aligned_address);
-
-#ifdef FLAC__ALIGN_MALLOC_DATA
- /* align on 32-byte (256-bit) boundary */
- x = safe_malloc_add_2op_(bytes, /*+*/31L);
- *aligned_address = (void*)(((uintptr_t)x + 31L) & -32L);
-#else
- x = safe_malloc_(bytes);
- *aligned_address = x;
-#endif
- return x;
-}
-
-FLAC__bool FLAC__memory_alloc_aligned_int32_array(size_t elements, FLAC__int32 **unaligned_pointer, FLAC__int32 **aligned_pointer)
-{
- FLAC__int32 *pu; /* unaligned pointer */
- union { /* union needed to comply with C99 pointer aliasing rules */
- FLAC__int32 *pa; /* aligned pointer */
- void *pv; /* aligned pointer alias */
- } u;
-
- FLAC__ASSERT(elements > 0);
- FLAC__ASSERT(0 != unaligned_pointer);
- FLAC__ASSERT(0 != aligned_pointer);
- FLAC__ASSERT(unaligned_pointer != aligned_pointer);
-
- if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */
- return false;
-
- pu = (FLAC__int32*) FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv);
- if(0 == pu) {
- return false;
- }
- else {
- if(*unaligned_pointer != 0)
- free(*unaligned_pointer);
- *unaligned_pointer = pu;
- *aligned_pointer = u.pa;
- return true;
- }
-}
-
-FLAC__bool FLAC__memory_alloc_aligned_uint32_array(size_t elements, FLAC__uint32 **unaligned_pointer, FLAC__uint32 **aligned_pointer)
-{
- FLAC__uint32 *pu; /* unaligned pointer */
- union { /* union needed to comply with C99 pointer aliasing rules */
- FLAC__uint32 *pa; /* aligned pointer */
- void *pv; /* aligned pointer alias */
- } u;
-
- FLAC__ASSERT(elements > 0);
- FLAC__ASSERT(0 != unaligned_pointer);
- FLAC__ASSERT(0 != aligned_pointer);
- FLAC__ASSERT(unaligned_pointer != aligned_pointer);
-
- if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */
- return false;
-
- pu = (FLAC__uint32*) FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv);
- if(0 == pu) {
- return false;
- }
- else {
- if(*unaligned_pointer != 0)
- free(*unaligned_pointer);
- *unaligned_pointer = pu;
- *aligned_pointer = u.pa;
- return true;
- }
-}
-
-FLAC__bool FLAC__memory_alloc_aligned_int64_array(size_t elements, FLAC__int64 **unaligned_pointer, FLAC__int64 **aligned_pointer)
-{
- FLAC__int64 *pu; /* unaligned pointer */
- union { /* union needed to comply with C99 pointer aliasing rules */
- FLAC__int64 *pa; /* aligned pointer */
- void *pv; /* aligned pointer alias */
- } u;
-
- FLAC__ASSERT(elements > 0);
- FLAC__ASSERT(0 != unaligned_pointer);
- FLAC__ASSERT(0 != aligned_pointer);
- FLAC__ASSERT(unaligned_pointer != aligned_pointer);
-
- if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */
- return false;
-
- pu = (FLAC__int64*) FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv);
- if(0 == pu) {
- return false;
- }
- else {
- if(*unaligned_pointer != 0)
- free(*unaligned_pointer);
- *unaligned_pointer = pu;
- *aligned_pointer = u.pa;
- return true;
- }
-}
-
-FLAC__bool FLAC__memory_alloc_aligned_uint64_array(size_t elements, FLAC__uint64 **unaligned_pointer, FLAC__uint64 **aligned_pointer)
-{
- FLAC__uint64 *pu; /* unaligned pointer */
- union { /* union needed to comply with C99 pointer aliasing rules */
- FLAC__uint64 *pa; /* aligned pointer */
- void *pv; /* aligned pointer alias */
- } u;
-
- FLAC__ASSERT(elements > 0);
- FLAC__ASSERT(0 != unaligned_pointer);
- FLAC__ASSERT(0 != aligned_pointer);
- FLAC__ASSERT(unaligned_pointer != aligned_pointer);
-
- if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */
- return false;
-
- pu = (FLAC__uint64*) FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv);
- if(0 == pu) {
- return false;
- }
- else {
- if(*unaligned_pointer != 0)
- free(*unaligned_pointer);
- *unaligned_pointer = pu;
- *aligned_pointer = u.pa;
- return true;
- }
-}
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-
-FLAC__bool FLAC__memory_alloc_aligned_real_array(size_t elements, FLAC__real **unaligned_pointer, FLAC__real **aligned_pointer)
-{
- FLAC__real *pu; /* unaligned pointer */
- union { /* union needed to comply with C99 pointer aliasing rules */
- FLAC__real *pa; /* aligned pointer */
- void *pv; /* aligned pointer alias */
- } u;
-
- FLAC__ASSERT(elements > 0);
- FLAC__ASSERT(0 != unaligned_pointer);
- FLAC__ASSERT(0 != aligned_pointer);
- FLAC__ASSERT(unaligned_pointer != aligned_pointer);
-
- if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */
- return false;
-
- pu = (FLAC__real*) FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv);
- if(0 == pu) {
- return false;
- }
- else {
- if(*unaligned_pointer != 0)
- free(*unaligned_pointer);
- *unaligned_pointer = pu;
- *aligned_pointer = u.pa;
- return true;
- }
-}
-
-#endif
-
-void *safe_malloc_mul_2op_p(size_t size1, size_t size2)
-{
- if(!size1 || !size2)
- return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */
- if(size1 > SIZE_MAX / size2)
- return 0;
- return malloc(size1*size2);
-}
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/stream_decoder.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/stream_decoder.c
deleted file mode 100644
index bf1b2ba1ed..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/stream_decoder.c
+++ /dev/null
@@ -1,3739 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include
-#include /* for malloc() */
-#include /* for memset/memcpy() */
-#include /* for off_t */
-#include /* for stat() */
-#include "../compat.h"
-#include "../assert.h"
-#include "../alloc.h"
-#include "include/protected/stream_decoder.h"
-#include "include/private/bitreader.h"
-#include "include/private/bitmath.h"
-#include "include/private/cpu.h"
-#include "include/private/crc.h"
-#include "include/private/fixed.h"
-#include "include/private/format.h"
-#include "include/private/lpc.h"
-#include "include/private/md5.h"
-#include "include/private/memory.h"
-
-
-
-/* technically this should be in an "export.c" but this is convenient enough */
-FLAC_API int FLAC_API_SUPPORTS_OGG_FLAC = FLAC__HAS_OGG;
-
-
-/***********************************************************************
- *
- * Private static data
- *
- ***********************************************************************/
-
-static const FLAC__byte ID3V2_TAG_[3] = { 'I', 'D', '3' };
-
-/***********************************************************************
- *
- * Private class method prototypes
- *
- ***********************************************************************/
-
-static void set_defaults_(FLAC__StreamDecoder *decoder);
-//static FILE *get_binary_stdin_(void);
-static FLAC__bool allocate_output_(FLAC__StreamDecoder *decoder, uint32_t size, uint32_t channels, uint32_t bps);
-static FLAC__bool has_id_filtered_(FLAC__StreamDecoder *decoder, FLAC__byte *id);
-static FLAC__bool find_metadata_(FLAC__StreamDecoder *decoder);
-static FLAC__bool read_metadata_(FLAC__StreamDecoder *decoder);
-static FLAC__bool read_metadata_streaminfo_(FLAC__StreamDecoder *decoder, FLAC__bool is_last, uint32_t length);
-static FLAC__bool read_metadata_seektable_(FLAC__StreamDecoder *decoder, FLAC__bool is_last, uint32_t length);
-static FLAC__bool read_metadata_vorbiscomment_(FLAC__StreamDecoder *decoder, FLAC__StreamMetadata_VorbisComment *obj, uint32_t length);
-static FLAC__bool read_metadata_cuesheet_(FLAC__StreamDecoder *decoder, FLAC__StreamMetadata_CueSheet *obj);
-static FLAC__bool read_metadata_picture_(FLAC__StreamDecoder *decoder, FLAC__StreamMetadata_Picture *obj);
-static FLAC__bool skip_id3v2_tag_(FLAC__StreamDecoder *decoder);
-static FLAC__bool frame_sync_(FLAC__StreamDecoder *decoder);
-static FLAC__bool read_frame_(FLAC__StreamDecoder *decoder, FLAC__bool *got_a_frame, FLAC__bool do_full_decode);
-static FLAC__bool read_frame_header_(FLAC__StreamDecoder *decoder);
-static FLAC__bool read_subframe_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, FLAC__bool do_full_decode);
-static FLAC__bool read_subframe_constant_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, FLAC__bool do_full_decode);
-static FLAC__bool read_subframe_fixed_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, const uint32_t order, FLAC__bool do_full_decode);
-static FLAC__bool read_subframe_lpc_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, const uint32_t order, FLAC__bool do_full_decode);
-static FLAC__bool read_subframe_verbatim_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, FLAC__bool do_full_decode);
-static FLAC__bool read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, uint32_t predictor_order, uint32_t partition_order, FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, FLAC__int32 *residual, FLAC__bool is_extended);
-static FLAC__bool read_zero_padding_(FLAC__StreamDecoder *decoder);
-static void undo_channel_coding(FLAC__StreamDecoder *decoder);
-static FLAC__bool read_callback_(FLAC__byte buffer[], size_t *bytes, void *client_data);
-#if FLAC__HAS_OGG
-static FLAC__StreamDecoderReadStatus read_callback_ogg_aspect_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes);
-static FLAC__OggDecoderAspectReadStatus read_callback_proxy_(const void *void_decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
-#endif
-static FLAC__StreamDecoderWriteStatus write_audio_frame_to_client_(FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[]);
-static void send_error_to_client_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status);
-static FLAC__bool seek_to_absolute_sample_(FLAC__StreamDecoder *decoder, FLAC__uint64 stream_length, FLAC__uint64 target_sample);
-#if FLAC__HAS_OGG
-static FLAC__bool seek_to_absolute_sample_ogg_(FLAC__StreamDecoder *decoder, FLAC__uint64 stream_length, FLAC__uint64 target_sample);
-#endif
-//static FLAC__StreamDecoderReadStatus file_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
-//static FLAC__StreamDecoderSeekStatus file_seek_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
-//static FLAC__StreamDecoderTellStatus file_tell_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
-//static FLAC__StreamDecoderLengthStatus file_length_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
-//static FLAC__bool file_eof_callback_(const FLAC__StreamDecoder *decoder, void *client_data);
-
-/***********************************************************************
- *
- * Private class data
- *
- ***********************************************************************/
-
-typedef struct FLAC__StreamDecoderPrivate {
- FLAC__bool is_ogg;
- 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;
- FILE *file; /* only used if FLAC__stream_decoder_init_file()/FLAC__stream_decoder_init_file() called, else NULL */
- FLAC__BitReader *input;
- FLAC__int32 *output[FLAC__MAX_CHANNELS];
- FLAC__int32 *residual[FLAC__MAX_CHANNELS]; /* WATCHOUT: these are the aligned pointers; the real pointers that should be free()'d are residual_unaligned[] below */
- FLAC__int64 *side_subframe;
- FLAC__bool side_subframe_in_use;
- FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents[FLAC__MAX_CHANNELS];
- uint32_t output_capacity, output_channels;
- FLAC__uint32 fixed_block_size, next_fixed_block_size;
- FLAC__uint64 samples_decoded;
- FLAC__bool has_stream_info, has_seek_table;
- FLAC__StreamMetadata stream_info;
- FLAC__StreamMetadata seek_table;
- FLAC__bool metadata_filter[128]; /* MAGIC number 128 == total number of metadata block types == 1 << 7 */
- FLAC__byte *metadata_filter_ids;
- size_t metadata_filter_ids_count, metadata_filter_ids_capacity; /* units for both are IDs, not bytes */
- FLAC__Frame frame;
- FLAC__bool cached; /* true if there is a byte in lookahead */
- FLAC__CPUInfo cpuinfo;
- FLAC__byte header_warmup[2]; /* contains the sync code and reserved bits */
- FLAC__byte lookahead; /* temp storage when we need to look ahead one byte in the stream */
- /* unaligned (original) pointers to allocated data */
- FLAC__int32 *residual_unaligned[FLAC__MAX_CHANNELS];
- FLAC__bool do_md5_checking; /* initially gets protected_->md5_checking but is turned off after a seek or if the metadata has a zero MD5 */
- FLAC__bool internal_reset_hack; /* used only during init() so we can call reset to set up the decoder without rewinding the input */
- FLAC__bool is_seeking;
- FLAC__MD5Context md5context;
- FLAC__byte computed_md5sum[16]; /* this is the sum we computed from the decoded data */
- /* (the rest of these are only used for seeking) */
- FLAC__Frame last_frame; /* holds the info of the last frame we decoded or seeked to */
- FLAC__bool last_frame_is_set;
- FLAC__uint64 first_frame_offset; /* hint to the seek routine of where in the stream the first audio frame starts */
- FLAC__uint64 last_seen_framesync; /* if tell callback works, the location of the last seen frame sync code, to rewind to if needed */
- FLAC__uint64 target_sample;
- uint32_t unparseable_frame_count; /* used to tell whether we're decoding a future version of FLAC or just got a bad sync */
- FLAC__bool got_a_frame; /* hack needed in Ogg FLAC seek routine to check when process_single() actually writes a frame */
- FLAC__bool (*local_bitreader_read_rice_signed_block)(FLAC__BitReader *br, int vals[], uint32_t nvals, uint32_t parameter);
-} FLAC__StreamDecoderPrivate;
-
-/***********************************************************************
- *
- * Public static class data
- *
- ***********************************************************************/
-
-FLAC_API const char * const FLAC__StreamDecoderStateString[] = {
- "FLAC__STREAM_DECODER_SEARCH_FOR_METADATA",
- "FLAC__STREAM_DECODER_READ_METADATA",
- "FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC",
- "FLAC__STREAM_DECODER_READ_FRAME",
- "FLAC__STREAM_DECODER_END_OF_STREAM",
- "FLAC__STREAM_DECODER_OGG_ERROR",
- "FLAC__STREAM_DECODER_SEEK_ERROR",
- "FLAC__STREAM_DECODER_ABORTED",
- "FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR",
- "FLAC__STREAM_DECODER_UNINITIALIZED"
-};
-
-FLAC_API const char * const FLAC__StreamDecoderInitStatusString[] = {
- "FLAC__STREAM_DECODER_INIT_STATUS_OK",
- "FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER",
- "FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS",
- "FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR",
- "FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE",
- "FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED"
-};
-
-FLAC_API const char * const FLAC__StreamDecoderReadStatusString[] = {
- "FLAC__STREAM_DECODER_READ_STATUS_CONTINUE",
- "FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM",
- "FLAC__STREAM_DECODER_READ_STATUS_ABORT"
-};
-
-FLAC_API const char * const FLAC__StreamDecoderSeekStatusString[] = {
- "FLAC__STREAM_DECODER_SEEK_STATUS_OK",
- "FLAC__STREAM_DECODER_SEEK_STATUS_ERROR",
- "FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED"
-};
-
-FLAC_API const char * const FLAC__StreamDecoderTellStatusString[] = {
- "FLAC__STREAM_DECODER_TELL_STATUS_OK",
- "FLAC__STREAM_DECODER_TELL_STATUS_ERROR",
- "FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED"
-};
-
-FLAC_API const char * const FLAC__StreamDecoderLengthStatusString[] = {
- "FLAC__STREAM_DECODER_LENGTH_STATUS_OK",
- "FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR",
- "FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED"
-};
-
-FLAC_API const char * const FLAC__StreamDecoderWriteStatusString[] = {
- "FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE",
- "FLAC__STREAM_DECODER_WRITE_STATUS_ABORT"
-};
-
-FLAC_API const char * const FLAC__StreamDecoderErrorStatusString[] = {
- "FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC",
- "FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER",
- "FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH",
- "FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM",
- "FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA"
-};
-
-/***********************************************************************
- *
- * Class constructor/destructor
- *
- ***********************************************************************/
-FLAC_API FLAC__StreamDecoder *FLAC__stream_decoder_new(void)
-{
- FLAC__StreamDecoder *decoder;
- uint32_t i;
-
- FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
-
- decoder = (FLAC__StreamDecoder*) calloc(1, sizeof(FLAC__StreamDecoder));
- if(decoder == 0) {
- return 0;
- }
-
- decoder->protected_ = (FLAC__StreamDecoderProtected*) calloc(1, sizeof(FLAC__StreamDecoderProtected));
- if(decoder->protected_ == 0) {
- free(decoder);
- return 0;
- }
-
- decoder->private_ = (FLAC__StreamDecoderPrivate*) calloc(1, sizeof(FLAC__StreamDecoderPrivate));
- if(decoder->private_ == 0) {
- free(decoder->protected_);
- free(decoder);
- return 0;
- }
-
- decoder->private_->input = FLAC__bitreader_new();
- if(decoder->private_->input == 0) {
- free(decoder->private_);
- free(decoder->protected_);
- free(decoder);
- return 0;
- }
-
- decoder->private_->metadata_filter_ids_capacity = 16;
- if(0 == (decoder->private_->metadata_filter_ids = (FLAC__byte*) malloc((FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8) * decoder->private_->metadata_filter_ids_capacity))) {
- FLAC__bitreader_delete(decoder->private_->input);
- free(decoder->private_);
- free(decoder->protected_);
- free(decoder);
- return 0;
- }
-
- for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
- decoder->private_->output[i] = 0;
- decoder->private_->residual_unaligned[i] = decoder->private_->residual[i] = 0;
- }
-
- decoder->private_->side_subframe = 0;
-
- decoder->private_->output_capacity = 0;
- decoder->private_->output_channels = 0;
- decoder->private_->has_seek_table = false;
-
- for(i = 0; i < FLAC__MAX_CHANNELS; i++)
- FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&decoder->private_->partitioned_rice_contents[i]);
-
- decoder->private_->file = 0;
-
- set_defaults_(decoder);
-
- decoder->protected_->state = FLAC__STREAM_DECODER_UNINITIALIZED;
-
- return decoder;
-}
-
-FLAC_API void FLAC__stream_decoder_delete(FLAC__StreamDecoder *decoder)
-{
- uint32_t i;
-
- if (decoder == NULL)
- return ;
-
- FLAC__ASSERT(0 != decoder->protected_);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->private_->input);
-
- (void)FLAC__stream_decoder_finish(decoder);
-
- if(0 != decoder->private_->metadata_filter_ids)
- free(decoder->private_->metadata_filter_ids);
-
- FLAC__bitreader_delete(decoder->private_->input);
-
- for(i = 0; i < FLAC__MAX_CHANNELS; i++)
- FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&decoder->private_->partitioned_rice_contents[i]);
-
- free(decoder->private_);
- free(decoder->protected_);
- free(decoder);
-}
-
-/***********************************************************************
- *
- * Public class methods
- *
- ***********************************************************************/
-
-static FLAC__StreamDecoderInitStatus init_stream_internal_(
- 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,
- FLAC__bool is_ogg
-)
-{
- FLAC__ASSERT(0 != decoder);
-
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED;
-
- #if FLAC__HAS_OGG == 0
- if(is_ogg)
- return FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER;
- #endif
-
- if(
- 0 == read_callback ||
- 0 == write_callback ||
- 0 == error_callback ||
- (seek_callback && (0 == tell_callback || 0 == length_callback || 0 == eof_callback))
- )
- return FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS;
-
-#if FLAC__HAS_OGG
- decoder->private_->is_ogg = is_ogg;
- if(is_ogg && !FLAC__ogg_decoder_aspect_init(&decoder->protected_->ogg_decoder_aspect))
- return decoder->protected_->initstate = FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE;
-#endif
-
- FLAC__cpu_info(&decoder->private_->cpuinfo);
- decoder->private_->local_bitreader_read_rice_signed_block = FLAC__bitreader_read_rice_signed_block;
-
-#ifdef FLAC__BMI2_SUPPORTED
- if (decoder->private_->cpuinfo.x86.bmi2) {
- decoder->private_->local_bitreader_read_rice_signed_block = FLAC__bitreader_read_rice_signed_block_bmi2;
- }
-#endif
-
- /* from here on, errors are fatal */
-
- if(!FLAC__bitreader_init(decoder->private_->input, read_callback_, decoder)) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR;
- }
-
- decoder->private_->read_callback = read_callback;
- decoder->private_->seek_callback = seek_callback;
- decoder->private_->tell_callback = tell_callback;
- decoder->private_->length_callback = length_callback;
- decoder->private_->eof_callback = eof_callback;
- decoder->private_->write_callback = write_callback;
- decoder->private_->metadata_callback = metadata_callback;
- decoder->private_->error_callback = error_callback;
- decoder->private_->client_data = client_data;
- decoder->private_->fixed_block_size = decoder->private_->next_fixed_block_size = 0;
- decoder->private_->samples_decoded = 0;
- decoder->private_->has_stream_info = false;
- decoder->private_->cached = false;
-
- decoder->private_->do_md5_checking = decoder->protected_->md5_checking;
- decoder->private_->is_seeking = false;
-
- decoder->private_->internal_reset_hack = true; /* so the following reset does not try to rewind the input */
- if(!FLAC__stream_decoder_reset(decoder)) {
- /* above call sets the state for us */
- return FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR;
- }
-
- return FLAC__STREAM_DECODER_INIT_STATUS_OK;
-}
-
-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
-)
-{
- return init_stream_internal_(
- decoder,
- read_callback,
- seek_callback,
- tell_callback,
- length_callback,
- eof_callback,
- write_callback,
- metadata_callback,
- error_callback,
- client_data,
- /*is_ogg=*/false
- );
-}
-
-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
-)
-{
- return init_stream_internal_(
- decoder,
- read_callback,
- seek_callback,
- tell_callback,
- length_callback,
- eof_callback,
- write_callback,
- metadata_callback,
- error_callback,
- client_data,
- /*is_ogg=*/true
- );
-}
-
-#if 0
-static FLAC__StreamDecoderInitStatus init_FILE_internal_(
- FLAC__StreamDecoder *decoder,
- FILE *file,
- FLAC__StreamDecoderWriteCallback write_callback,
- FLAC__StreamDecoderMetadataCallback metadata_callback,
- FLAC__StreamDecoderErrorCallback error_callback,
- void *client_data,
- FLAC__bool is_ogg
-)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != file);
-
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return decoder->protected_->initstate = FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED;
-
- if(0 == write_callback || 0 == error_callback)
- return decoder->protected_->initstate = FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS;
-
- /*
- * To make sure that our file does not go unclosed after an error, we
- * must assign the FILE pointer before any further error can occur in
- * this routine.
- */
- if(file == stdin)
- file = get_binary_stdin_(); /* just to be safe */
-
- decoder->private_->file = file;
-
- return init_stream_internal_(
- decoder,
- file_read_callback_,
- decoder->private_->file == stdin? 0: file_seek_callback_,
- decoder->private_->file == stdin? 0: file_tell_callback_,
- decoder->private_->file == stdin? 0: file_length_callback_,
- file_eof_callback_,
- write_callback,
- metadata_callback,
- error_callback,
- client_data,
- is_ogg
- );
-}
-
-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
-)
-{
- return init_FILE_internal_(decoder, file, write_callback, metadata_callback, error_callback, client_data, /*is_ogg=*/false);
-}
-
-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
-)
-{
- return init_FILE_internal_(decoder, file, write_callback, metadata_callback, error_callback, client_data, /*is_ogg=*/true);
-}
-
-static FLAC__StreamDecoderInitStatus init_file_internal_(
- FLAC__StreamDecoder *decoder,
- const char *filename,
- FLAC__StreamDecoderWriteCallback write_callback,
- FLAC__StreamDecoderMetadataCallback metadata_callback,
- FLAC__StreamDecoderErrorCallback error_callback,
- void *client_data,
- FLAC__bool is_ogg
-)
-{
- FILE *file;
-
- FLAC__ASSERT(0 != decoder);
-
- /*
- * To make sure that our file does not go unclosed after an error, we
- * have to do the same entrance checks here that are later performed
- * in FLAC__stream_decoder_init_FILE() before the FILE* is assigned.
- */
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return decoder->protected_->initstate = FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED;
-
- if(0 == write_callback || 0 == error_callback)
- return decoder->protected_->initstate = FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS;
-
- file = filename? flac_fopen(filename, "rb") : stdin;
-
- if(0 == file)
- return FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE;
-
- return init_FILE_internal_(decoder, file, write_callback, metadata_callback, error_callback, client_data, is_ogg);
-}
-
-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
-)
-{
- return init_file_internal_(decoder, filename, write_callback, metadata_callback, error_callback, client_data, /*is_ogg=*/false);
-}
-
-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
-)
-{
- return init_file_internal_(decoder, filename, write_callback, metadata_callback, error_callback, client_data, /*is_ogg=*/true);
-}
-#endif
-
-FLAC_API FLAC__bool FLAC__stream_decoder_finish(FLAC__StreamDecoder *decoder)
-{
- FLAC__bool md5_failed = false;
- uint32_t i;
-
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
-
- if(decoder->protected_->state == FLAC__STREAM_DECODER_UNINITIALIZED)
- return true;
-
- /* see the comment in FLAC__stream_decoder_reset() as to why we
- * always call FLAC__MD5Final()
- */
- FLAC__MD5Final(decoder->private_->computed_md5sum, &decoder->private_->md5context);
-
- free(decoder->private_->seek_table.data.seek_table.points);
- decoder->private_->seek_table.data.seek_table.points = 0;
- decoder->private_->has_seek_table = false;
-
- FLAC__bitreader_free(decoder->private_->input);
- for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
- /* WATCHOUT:
- * FLAC__lpc_restore_signal_asm_ia32_mmx() and ..._intrin_sseN()
- * require that the output arrays have a buffer of up to 3 zeroes
- * in front (at negative indices) for alignment purposes;
- * we use 4 to keep the data well-aligned.
- */
- if(0 != decoder->private_->output[i]) {
- free(decoder->private_->output[i]-4);
- decoder->private_->output[i] = 0;
- }
- if(0 != decoder->private_->residual_unaligned[i]) {
- free(decoder->private_->residual_unaligned[i]);
- decoder->private_->residual_unaligned[i] = decoder->private_->residual[i] = 0;
- }
- }
- if(0 != decoder->private_->side_subframe) {
- free(decoder->private_->side_subframe);
- decoder->private_->side_subframe = 0;
- }
- decoder->private_->output_capacity = 0;
- decoder->private_->output_channels = 0;
-
-#if FLAC__HAS_OGG
- if(decoder->private_->is_ogg)
- FLAC__ogg_decoder_aspect_finish(&decoder->protected_->ogg_decoder_aspect);
-#endif
-
- if(0 != decoder->private_->file) {
- if(decoder->private_->file != stdin)
- fclose(decoder->private_->file);
- decoder->private_->file = 0;
- }
-
- if(decoder->private_->do_md5_checking) {
- if(memcmp(decoder->private_->stream_info.data.stream_info.md5sum, decoder->private_->computed_md5sum, 16))
- md5_failed = true;
- }
- decoder->private_->is_seeking = false;
-
- set_defaults_(decoder);
-
- decoder->protected_->state = FLAC__STREAM_DECODER_UNINITIALIZED;
-
- return !md5_failed;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_set_ogg_serial_number(FLAC__StreamDecoder *decoder, long value)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return false;
-#if FLAC__HAS_OGG
- /* can't check decoder->private_->is_ogg since that's not set until init time */
- FLAC__ogg_decoder_aspect_set_serial_number(&decoder->protected_->ogg_decoder_aspect, value);
- return true;
-#else
- (void)value;
- return false;
-#endif
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_set_md5_checking(FLAC__StreamDecoder *decoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return false;
- decoder->protected_->md5_checking = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond(FLAC__StreamDecoder *decoder, FLAC__MetadataType type)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
- FLAC__ASSERT((uint32_t)type <= FLAC__MAX_METADATA_TYPE_CODE);
- /* double protection */
- if((uint32_t)type > FLAC__MAX_METADATA_TYPE_CODE)
- return false;
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return false;
- decoder->private_->metadata_filter[type] = true;
- if(type == FLAC__METADATA_TYPE_APPLICATION)
- decoder->private_->metadata_filter_ids_count = 0;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond_application(FLAC__StreamDecoder *decoder, const FLAC__byte id[4])
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
- FLAC__ASSERT(0 != id);
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return false;
-
- if(decoder->private_->metadata_filter[FLAC__METADATA_TYPE_APPLICATION])
- return true;
-
- FLAC__ASSERT(0 != decoder->private_->metadata_filter_ids);
-
- if(decoder->private_->metadata_filter_ids_count == decoder->private_->metadata_filter_ids_capacity) {
- if(0 == (decoder->private_->metadata_filter_ids = (FLAC__byte*) safe_realloc_mul_2op_(decoder->private_->metadata_filter_ids, decoder->private_->metadata_filter_ids_capacity, /*times*/2))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- decoder->private_->metadata_filter_ids_capacity *= 2;
- }
-
- memcpy(decoder->private_->metadata_filter_ids + decoder->private_->metadata_filter_ids_count * (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8), id, (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8));
- decoder->private_->metadata_filter_ids_count++;
-
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_respond_all(FLAC__StreamDecoder *decoder)
-{
- uint32_t i;
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return false;
- for(i = 0; i < sizeof(decoder->private_->metadata_filter) / sizeof(decoder->private_->metadata_filter[0]); i++)
- decoder->private_->metadata_filter[i] = true;
- decoder->private_->metadata_filter_ids_count = 0;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore(FLAC__StreamDecoder *decoder, FLAC__MetadataType type)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
- FLAC__ASSERT((uint32_t)type <= FLAC__MAX_METADATA_TYPE_CODE);
- /* double protection */
- if((uint32_t)type > FLAC__MAX_METADATA_TYPE_CODE)
- return false;
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return false;
- decoder->private_->metadata_filter[type] = false;
- if(type == FLAC__METADATA_TYPE_APPLICATION)
- decoder->private_->metadata_filter_ids_count = 0;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore_application(FLAC__StreamDecoder *decoder, const FLAC__byte id[4])
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
- FLAC__ASSERT(0 != id);
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return false;
-
- if(!decoder->private_->metadata_filter[FLAC__METADATA_TYPE_APPLICATION])
- return true;
-
- FLAC__ASSERT(0 != decoder->private_->metadata_filter_ids);
-
- if(decoder->private_->metadata_filter_ids_count == decoder->private_->metadata_filter_ids_capacity) {
- if(0 == (decoder->private_->metadata_filter_ids = (FLAC__byte*) safe_realloc_mul_2op_(decoder->private_->metadata_filter_ids, decoder->private_->metadata_filter_ids_capacity, /*times*/2))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- decoder->private_->metadata_filter_ids_capacity *= 2;
- }
-
- memcpy(decoder->private_->metadata_filter_ids + decoder->private_->metadata_filter_ids_count * (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8), id, (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8));
- decoder->private_->metadata_filter_ids_count++;
-
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_set_metadata_ignore_all(FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
- if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED)
- return false;
- memset(decoder->private_->metadata_filter, 0, sizeof(decoder->private_->metadata_filter));
- decoder->private_->metadata_filter_ids_count = 0;
- return true;
-}
-
-FLAC_API FLAC__StreamDecoderState FLAC__stream_decoder_get_state(const FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
- return decoder->protected_->state;
-}
-
-FLAC_API const char *FLAC__stream_decoder_get_resolved_state_string(const FLAC__StreamDecoder *decoder)
-{
- return FLAC__StreamDecoderStateString[decoder->protected_->state];
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_get_md5_checking(const FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
- return decoder->protected_->md5_checking;
-}
-
-FLAC_API FLAC__uint64 FLAC__stream_decoder_get_total_samples(const FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
- return decoder->private_->has_stream_info? decoder->private_->stream_info.data.stream_info.total_samples : 0;
-}
-
-FLAC_API uint32_t FLAC__stream_decoder_get_channels(const FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
- return decoder->protected_->channels;
-}
-
-FLAC_API FLAC__ChannelAssignment FLAC__stream_decoder_get_channel_assignment(const FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
- return decoder->protected_->channel_assignment;
-}
-
-FLAC_API uint32_t FLAC__stream_decoder_get_bits_per_sample(const FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
- return decoder->protected_->bits_per_sample;
-}
-
-FLAC_API uint32_t FLAC__stream_decoder_get_sample_rate(const FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
- return decoder->protected_->sample_rate;
-}
-
-FLAC_API uint32_t FLAC__stream_decoder_get_blocksize(const FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
- return decoder->protected_->blocksize;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_get_decode_position(const FLAC__StreamDecoder *decoder, FLAC__uint64 *position)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != position);
-
- if(FLAC__HAS_OGG && decoder->private_->is_ogg)
- return false;
-
- if(0 == decoder->private_->tell_callback)
- return false;
- if(decoder->private_->tell_callback(decoder, position, decoder->private_->client_data) != FLAC__STREAM_DECODER_TELL_STATUS_OK)
- return false;
- /* should never happen since all FLAC frames and metadata blocks are byte aligned, but check just in case */
- if(!FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input))
- return false;
- FLAC__ASSERT(*position >= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder));
- *position -= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder);
- return true;
-}
-
-FLAC_API const void *FLAC__stream_decoder_get_client_data(FLAC__StreamDecoder *decoder)
-{
- return decoder->private_->client_data;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
-
- if(!decoder->private_->internal_reset_hack && decoder->protected_->state == FLAC__STREAM_DECODER_UNINITIALIZED)
- return false;
-
- decoder->private_->samples_decoded = 0;
- decoder->private_->do_md5_checking = false;
- decoder->private_->last_seen_framesync = 0;
- decoder->private_->last_frame_is_set = false;
-
-#if FLAC__HAS_OGG
- if(decoder->private_->is_ogg)
- FLAC__ogg_decoder_aspect_flush(&decoder->protected_->ogg_decoder_aspect);
-#endif
-
- if(!FLAC__bitreader_clear(decoder->private_->input)) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
-
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_reset(FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
- FLAC__ASSERT(0 != decoder->protected_);
-
- if(!FLAC__stream_decoder_flush(decoder)) {
- /* above call sets the state for us */
- return false;
- }
-
-#if FLAC__HAS_OGG
- /*@@@ could go in !internal_reset_hack block below */
- if(decoder->private_->is_ogg)
- FLAC__ogg_decoder_aspect_reset(&decoder->protected_->ogg_decoder_aspect);
-#endif
-
- /* Rewind if necessary. If FLAC__stream_decoder_init() is calling us,
- * (internal_reset_hack) don't try to rewind since we are already at
- * the beginning of the stream and don't want to fail if the input is
- * not seekable.
- */
- if(!decoder->private_->internal_reset_hack) {
- if(decoder->private_->file == stdin)
- return false; /* can't rewind stdin, reset fails */
- if(decoder->private_->seek_callback && decoder->private_->seek_callback(decoder, 0, decoder->private_->client_data) == FLAC__STREAM_DECODER_SEEK_STATUS_ERROR)
- return false; /* seekable and seek fails, reset fails */
- }
-
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_METADATA;
-
- decoder->private_->has_stream_info = false;
-
- free(decoder->private_->seek_table.data.seek_table.points);
- decoder->private_->seek_table.data.seek_table.points = 0;
- decoder->private_->has_seek_table = false;
-
- decoder->private_->do_md5_checking = decoder->protected_->md5_checking;
- /*
- * This goes in reset() and not flush() because according to the spec, a
- * fixed-blocksize stream must stay that way through the whole stream.
- */
- decoder->private_->fixed_block_size = decoder->private_->next_fixed_block_size = 0;
-
- /* We initialize the FLAC__MD5Context even though we may never use it. This
- * is because md5 checking may be turned on to start and then turned off if
- * a seek occurs. So we init the context here and finalize it in
- * FLAC__stream_decoder_finish() to make sure things are always cleaned up
- * properly.
- */
- if(!decoder->private_->internal_reset_hack) {
- /* Only finish MD5 context when it has been initialized
- * (i.e. when internal_reset_hack is not set) */
- FLAC__MD5Final(decoder->private_->computed_md5sum, &decoder->private_->md5context);
- }
- else
- decoder->private_->internal_reset_hack = false;
- FLAC__MD5Init(&decoder->private_->md5context);
-
- decoder->private_->first_frame_offset = 0;
- decoder->private_->unparseable_frame_count = 0;
- decoder->private_->last_seen_framesync = 0;
- decoder->private_->last_frame_is_set = false;
-
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_process_single(FLAC__StreamDecoder *decoder)
-{
- FLAC__bool got_a_frame;
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
-
- while(1) {
- switch(decoder->protected_->state) {
- case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
- if(!find_metadata_(decoder))
- return false; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_READ_METADATA:
- if(!read_metadata_(decoder))
- return false; /* above function sets the status for us */
- else
- return true;
- case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
- if(!frame_sync_(decoder))
- return true; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_READ_FRAME:
- if(!read_frame_(decoder, &got_a_frame, /*do_full_decode=*/true))
- return false; /* above function sets the status for us */
- if(got_a_frame)
- return true; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_END_OF_STREAM:
- case FLAC__STREAM_DECODER_ABORTED:
- return true;
- default:
- return false;
- }
- }
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_process_until_end_of_metadata(FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
-
- while(1) {
- switch(decoder->protected_->state) {
- case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
- if(!find_metadata_(decoder))
- return false; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_READ_METADATA:
- if(!read_metadata_(decoder))
- return false; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
- case FLAC__STREAM_DECODER_READ_FRAME:
- case FLAC__STREAM_DECODER_END_OF_STREAM:
- case FLAC__STREAM_DECODER_ABORTED:
- return true;
- default:
- return false;
- }
- }
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_process_until_end_of_stream(FLAC__StreamDecoder *decoder)
-{
- FLAC__bool dummy;
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
-
- while(1) {
- switch(decoder->protected_->state) {
- case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
- if(!find_metadata_(decoder))
- return false; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_READ_METADATA:
- if(!read_metadata_(decoder))
- return false; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
- if(!frame_sync_(decoder))
- return true; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_READ_FRAME:
- if(!read_frame_(decoder, &dummy, /*do_full_decode=*/true))
- return false; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_END_OF_STREAM:
- case FLAC__STREAM_DECODER_ABORTED:
- return true;
- default:
- return false;
- }
- }
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_skip_single_frame(FLAC__StreamDecoder *decoder)
-{
- FLAC__bool got_a_frame;
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->protected_);
-
- while(1) {
- switch(decoder->protected_->state) {
- case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
- case FLAC__STREAM_DECODER_READ_METADATA:
- return false; /* above function sets the status for us */
- case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
- if(!frame_sync_(decoder))
- return true; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_READ_FRAME:
- if(!read_frame_(decoder, &got_a_frame, /*do_full_decode=*/false))
- return false; /* above function sets the status for us */
- if(got_a_frame)
- return true; /* above function sets the status for us */
- break;
- case FLAC__STREAM_DECODER_END_OF_STREAM:
- case FLAC__STREAM_DECODER_ABORTED:
- return true;
- default:
- return false;
- }
- }
-}
-
-FLAC_API FLAC__bool FLAC__stream_decoder_seek_absolute(FLAC__StreamDecoder *decoder, FLAC__uint64 sample)
-{
- FLAC__uint64 length;
-
- FLAC__ASSERT(0 != decoder);
-
- if(
- decoder->protected_->state != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA &&
- decoder->protected_->state != FLAC__STREAM_DECODER_READ_METADATA &&
- decoder->protected_->state != FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC &&
- decoder->protected_->state != FLAC__STREAM_DECODER_READ_FRAME &&
- decoder->protected_->state != FLAC__STREAM_DECODER_END_OF_STREAM
- )
- return false;
-
- if(0 == decoder->private_->seek_callback)
- return false;
-
- FLAC__ASSERT(decoder->private_->seek_callback);
- FLAC__ASSERT(decoder->private_->tell_callback);
- FLAC__ASSERT(decoder->private_->length_callback);
- FLAC__ASSERT(decoder->private_->eof_callback);
-
- if(FLAC__stream_decoder_get_total_samples(decoder) > 0 && sample >= FLAC__stream_decoder_get_total_samples(decoder))
- return false;
-
- decoder->private_->is_seeking = true;
-
- /* turn off md5 checking if a seek is attempted */
- decoder->private_->do_md5_checking = false;
-
- /* get the file length (currently our algorithm needs to know the length so it's also an error to get FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED) */
- if(decoder->private_->length_callback(decoder, &length, decoder->private_->client_data) != FLAC__STREAM_DECODER_LENGTH_STATUS_OK) {
- decoder->private_->is_seeking = false;
- return false;
- }
-
- /* if we haven't finished processing the metadata yet, do that so we have the STREAMINFO, SEEK_TABLE, and first_frame_offset */
- if(
- decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_METADATA ||
- decoder->protected_->state == FLAC__STREAM_DECODER_READ_METADATA
- ) {
- if(!FLAC__stream_decoder_process_until_end_of_metadata(decoder)) {
- /* above call sets the state for us */
- decoder->private_->is_seeking = false;
- return false;
- }
- /* check this again in case we didn't know total_samples the first time */
- if(FLAC__stream_decoder_get_total_samples(decoder) > 0 && sample >= FLAC__stream_decoder_get_total_samples(decoder)) {
- decoder->private_->is_seeking = false;
- return false;
- }
- }
-
- {
- const FLAC__bool ok =
-#if FLAC__HAS_OGG
- decoder->private_->is_ogg?
- seek_to_absolute_sample_ogg_(decoder, length, sample) :
-#endif
- seek_to_absolute_sample_(decoder, length, sample)
- ;
- decoder->private_->is_seeking = false;
- return ok;
- }
-}
-
-/***********************************************************************
- *
- * Protected class methods
- *
- ***********************************************************************/
-
-uint32_t FLAC__stream_decoder_get_input_bytes_unconsumed(const FLAC__StreamDecoder *decoder)
-{
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input));
- FLAC__ASSERT(!(FLAC__bitreader_get_input_bits_unconsumed(decoder->private_->input) & 7));
- return FLAC__bitreader_get_input_bits_unconsumed(decoder->private_->input) / 8;
-}
-
-/***********************************************************************
- *
- * Private class methods
- *
- ***********************************************************************/
-
-void set_defaults_(FLAC__StreamDecoder *decoder)
-{
- decoder->private_->is_ogg = false;
- decoder->private_->read_callback = 0;
- decoder->private_->seek_callback = 0;
- decoder->private_->tell_callback = 0;
- decoder->private_->length_callback = 0;
- decoder->private_->eof_callback = 0;
- decoder->private_->write_callback = 0;
- decoder->private_->metadata_callback = 0;
- decoder->private_->error_callback = 0;
- decoder->private_->client_data = 0;
-
- memset(decoder->private_->metadata_filter, 0, sizeof(decoder->private_->metadata_filter));
- decoder->private_->metadata_filter[FLAC__METADATA_TYPE_STREAMINFO] = true;
- decoder->private_->metadata_filter_ids_count = 0;
-
- decoder->protected_->md5_checking = false;
-
-#if FLAC__HAS_OGG
- FLAC__ogg_decoder_aspect_set_defaults(&decoder->protected_->ogg_decoder_aspect);
-#endif
-}
-
-#if 0
-/*
- * This will forcibly set stdin to binary mode (for OSes that require it)
- */
-FILE *get_binary_stdin_(void)
-{
- /* if something breaks here it is probably due to the presence or
- * absence of an underscore before the identifiers 'setmode',
- * 'fileno', and/or 'O_BINARY'; check your system header files.
- */
-#if defined _MSC_VER || defined __MINGW32__
- _setmode(_fileno(stdin), _O_BINARY);
-#elif defined __EMX__
- setmode(fileno(stdin), O_BINARY);
-#endif
-
- return stdin;
-}
-#endif
-
-FLAC__bool allocate_output_(FLAC__StreamDecoder *decoder, uint32_t size, uint32_t channels, uint32_t bps)
-{
- uint32_t i;
- FLAC__int32 *tmp;
-
- if(size <= decoder->private_->output_capacity && channels <= decoder->private_->output_channels &&
- (bps < 32 || decoder->private_->side_subframe != 0))
- return true;
-
- /* simply using realloc() is not practical because the number of channels may change mid-stream */
-
- for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
- if(0 != decoder->private_->output[i]) {
- free(decoder->private_->output[i]-4);
- decoder->private_->output[i] = 0;
- }
- if(0 != decoder->private_->residual_unaligned[i]) {
- free(decoder->private_->residual_unaligned[i]);
- decoder->private_->residual_unaligned[i] = decoder->private_->residual[i] = 0;
- }
- }
-
- if(0 != decoder->private_->side_subframe) {
- free(decoder->private_->side_subframe);
- decoder->private_->side_subframe = 0;
- }
-
- for(i = 0; i < channels; i++) {
- /* WATCHOUT:
- * FLAC__lpc_restore_signal_asm_ia32_mmx() and ..._intrin_sseN()
- * require that the output arrays have a buffer of up to 3 zeroes
- * in front (at negative indices) for alignment purposes;
- * we use 4 to keep the data well-aligned.
- */
- tmp = (FLAC__int32*) safe_malloc_muladd2_(sizeof(FLAC__int32), /*times (*/size, /*+*/4/*)*/);
- if(tmp == 0) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- memset(tmp, 0, sizeof(FLAC__int32)*4);
- decoder->private_->output[i] = tmp + 4;
-
- if(!FLAC__memory_alloc_aligned_int32_array(size, &decoder->private_->residual_unaligned[i], &decoder->private_->residual[i])) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- }
-
- if(bps == 32) {
- decoder->private_->side_subframe = (FLAC__int64*) safe_malloc_mul_2op_p(sizeof(FLAC__int64), /*times (*/size);
- if(decoder->private_->side_subframe == NULL) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- }
-
- decoder->private_->output_capacity = size;
- decoder->private_->output_channels = channels;
-
- return true;
-}
-
-FLAC__bool has_id_filtered_(FLAC__StreamDecoder *decoder, FLAC__byte *id)
-{
- size_t i;
-
- FLAC__ASSERT(0 != decoder);
- FLAC__ASSERT(0 != decoder->private_);
-
- for(i = 0; i < decoder->private_->metadata_filter_ids_count; i++)
- if(0 == memcmp(decoder->private_->metadata_filter_ids + i * (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8), id, (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8)))
- return true;
-
- return false;
-}
-
-FLAC__bool find_metadata_(FLAC__StreamDecoder *decoder)
-{
- FLAC__uint32 x;
- uint32_t i, id;
- FLAC__bool first = true;
-
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input));
-
- for(i = id = 0; i < 4; ) {
- if(decoder->private_->cached) {
- x = (FLAC__uint32)decoder->private_->lookahead;
- decoder->private_->cached = false;
- }
- else {
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8))
- return false; /* read_callback_ sets the state for us */
- }
- if(x == FLAC__STREAM_SYNC_STRING[i]) {
- first = true;
- i++;
- id = 0;
- continue;
- }
-
- if(id >= 3)
- return false;
-
- if(x == ID3V2_TAG_[id]) {
- id++;
- i = 0;
- if(id == 3) {
- if(!skip_id3v2_tag_(decoder))
- return false; /* skip_id3v2_tag_ sets the state for us */
- }
- continue;
- }
- id = 0;
- if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
- decoder->private_->header_warmup[0] = (FLAC__byte)x;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8))
- return false; /* read_callback_ sets the state for us */
-
- /* we have to check if we just read two 0xff's in a row; the second may actually be the beginning of the sync code */
- /* else we have to check if the second byte is the end of a sync code */
- if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
- decoder->private_->lookahead = (FLAC__byte)x;
- decoder->private_->cached = true;
- }
- else if(x >> 1 == 0x7c) { /* MAGIC NUMBER for the last 6 sync bits and reserved 7th bit */
- decoder->private_->header_warmup[1] = (FLAC__byte)x;
- decoder->protected_->state = FLAC__STREAM_DECODER_READ_FRAME;
- return true;
- }
- }
- i = 0;
- if(first) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- first = false;
- }
- }
-
- decoder->protected_->state = FLAC__STREAM_DECODER_READ_METADATA;
- return true;
-}
-
-FLAC__bool read_metadata_(FLAC__StreamDecoder *decoder)
-{
- FLAC__bool is_last;
- FLAC__uint32 i, x, type, length;
-
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input));
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_IS_LAST_LEN))
- return false; /* read_callback_ sets the state for us */
- is_last = x? true : false;
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &type, FLAC__STREAM_METADATA_TYPE_LEN))
- return false; /* read_callback_ sets the state for us */
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &length, FLAC__STREAM_METADATA_LENGTH_LEN))
- return false; /* read_callback_ sets the state for us */
-
- if(type == FLAC__METADATA_TYPE_STREAMINFO) {
- if(!read_metadata_streaminfo_(decoder, is_last, length))
- return false;
-
- decoder->private_->has_stream_info = true;
- if(0 == memcmp(decoder->private_->stream_info.data.stream_info.md5sum, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16))
- decoder->private_->do_md5_checking = false;
- if(!decoder->private_->is_seeking && decoder->private_->metadata_filter[FLAC__METADATA_TYPE_STREAMINFO] && decoder->private_->metadata_callback)
- decoder->private_->metadata_callback(decoder, &decoder->private_->stream_info, decoder->private_->client_data);
- }
- else if(type == FLAC__METADATA_TYPE_SEEKTABLE) {
- /* just in case we already have a seek table, and reading the next one fails: */
- decoder->private_->has_seek_table = false;
-
- if(length > 0) {
- if(!read_metadata_seektable_(decoder, is_last, length))
- return false;
-
- decoder->private_->has_seek_table = true;
- if(!decoder->private_->is_seeking && decoder->private_->metadata_filter[FLAC__METADATA_TYPE_SEEKTABLE] && decoder->private_->metadata_callback)
- decoder->private_->metadata_callback(decoder, &decoder->private_->seek_table, decoder->private_->client_data);
- }
- }
- else {
- FLAC__bool skip_it = !decoder->private_->metadata_filter[type];
- uint32_t real_length = length;
- FLAC__StreamMetadata block;
-
- memset(&block, 0, sizeof(block));
- block.is_last = is_last;
- block.type = (FLAC__MetadataType)type;
- block.length = length;
-
- if(type == FLAC__METADATA_TYPE_APPLICATION) {
- if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, block.data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8))
- return false; /* read_callback_ sets the state for us */
-
- if(real_length < FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8) { /* underflow check */
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;/*@@@@@@ maybe wrong error? need to resync?*/
- return false;
- }
-
- real_length -= FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8;
-
- if(decoder->private_->metadata_filter_ids_count > 0 && has_id_filtered_(decoder, block.data.application.id))
- skip_it = !skip_it;
- }
-
- if(skip_it) {
- if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, real_length))
- return false; /* read_callback_ sets the state for us */
- }
- else {
- FLAC__bool ok = true;
- FLAC__bitreader_set_limit(decoder->private_->input, real_length*8);
- switch(type) {
- case FLAC__METADATA_TYPE_PADDING:
- /* skip the padding bytes */
- if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, real_length))
- ok = false; /* read_callback_ sets the state for us */
- break;
- case FLAC__METADATA_TYPE_APPLICATION:
- /* remember, we read the ID already */
- if(real_length > 0) {
- if(0 == (block.data.application.data = (FLAC__byte*) malloc(real_length))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- ok = false;
- }
- else if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, block.data.application.data, real_length))
- ok = false; /* read_callback_ sets the state for us */
- }
- else
- block.data.application.data = 0;
- break;
- case FLAC__METADATA_TYPE_VORBIS_COMMENT:
- if(!read_metadata_vorbiscomment_(decoder, &block.data.vorbis_comment, real_length))
- ok = false;
- break;
- case FLAC__METADATA_TYPE_CUESHEET:
- if(!read_metadata_cuesheet_(decoder, &block.data.cue_sheet))
- ok = false;
- break;
- case FLAC__METADATA_TYPE_PICTURE:
- if(!read_metadata_picture_(decoder, &block.data.picture))
- ok = false;
- break;
- case FLAC__METADATA_TYPE_STREAMINFO:
- case FLAC__METADATA_TYPE_SEEKTABLE:
- FLAC__ASSERT(0);
- break;
- default:
- if(real_length > 0) {
- if(0 == (block.data.unknown.data = (FLAC__byte*) malloc(real_length))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- ok = false;
- }
- else if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, block.data.unknown.data, real_length))
- ok = false; /* read_callback_ sets the state for us */
- }
- else
- block.data.unknown.data = 0;
- break;
- }
- if(FLAC__bitreader_limit_remaining(decoder->private_->input) > 0) {
- /* Content in metadata block didn't fit in block length
- * We cannot know whether the length or the content was
- * corrupt, so stop parsing metadata */
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA);
- if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_METADATA)
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- ok = false;
- }
- FLAC__bitreader_remove_limit(decoder->private_->input);
- if(ok && !decoder->private_->is_seeking && decoder->private_->metadata_callback)
- decoder->private_->metadata_callback(decoder, &block, decoder->private_->client_data);
-
- /* now we have to free any malloc()ed data in the block */
- switch(type) {
- case FLAC__METADATA_TYPE_PADDING:
- break;
- case FLAC__METADATA_TYPE_APPLICATION:
- if(0 != block.data.application.data)
- free(block.data.application.data);
- break;
- case FLAC__METADATA_TYPE_VORBIS_COMMENT:
- if(0 != block.data.vorbis_comment.vendor_string.entry)
- free(block.data.vorbis_comment.vendor_string.entry);
- if(block.data.vorbis_comment.num_comments > 0)
- for(i = 0; i < block.data.vorbis_comment.num_comments; i++)
- if(0 != block.data.vorbis_comment.comments[i].entry)
- free(block.data.vorbis_comment.comments[i].entry);
- if(0 != block.data.vorbis_comment.comments)
- free(block.data.vorbis_comment.comments);
- break;
- case FLAC__METADATA_TYPE_CUESHEET:
- if(block.data.cue_sheet.num_tracks > 0 && 0 != block.data.cue_sheet.tracks)
- for(i = 0; i < block.data.cue_sheet.num_tracks; i++)
- if(0 != block.data.cue_sheet.tracks[i].indices)
- free(block.data.cue_sheet.tracks[i].indices);
- if(0 != block.data.cue_sheet.tracks)
- free(block.data.cue_sheet.tracks);
- break;
- case FLAC__METADATA_TYPE_PICTURE:
- if(0 != block.data.picture.mime_type)
- free(block.data.picture.mime_type);
- if(0 != block.data.picture.description)
- free(block.data.picture.description);
- if(0 != block.data.picture.data)
- free(block.data.picture.data);
- break;
- case FLAC__METADATA_TYPE_STREAMINFO:
- case FLAC__METADATA_TYPE_SEEKTABLE:
- FLAC__ASSERT(0);
- default:
- if(0 != block.data.unknown.data)
- free(block.data.unknown.data);
- break;
- }
-
- if(!ok) /* anything that unsets "ok" should also make sure decoder->protected_->state is updated */
- return false;
- }
- }
-
- if(is_last) {
- /* if this fails, it's OK, it's just a hint for the seek routine */
- if(!FLAC__stream_decoder_get_decode_position(decoder, &decoder->private_->first_frame_offset))
- decoder->private_->first_frame_offset = 0;
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- }
-
- return true;
-}
-
-FLAC__bool read_metadata_streaminfo_(FLAC__StreamDecoder *decoder, FLAC__bool is_last, uint32_t length)
-{
- FLAC__uint32 x;
- uint32_t bits, used_bits = 0;
-
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input));
-
- decoder->private_->stream_info.type = FLAC__METADATA_TYPE_STREAMINFO;
- decoder->private_->stream_info.is_last = is_last;
- decoder->private_->stream_info.length = length;
-
- bits = FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, bits))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->stream_info.data.stream_info.min_blocksize = x;
- used_bits += bits;
-
- bits = FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->stream_info.data.stream_info.max_blocksize = x;
- used_bits += bits;
-
- bits = FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->stream_info.data.stream_info.min_framesize = x;
- used_bits += bits;
-
- bits = FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->stream_info.data.stream_info.max_framesize = x;
- used_bits += bits;
-
- bits = FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->stream_info.data.stream_info.sample_rate = x;
- used_bits += bits;
-
- bits = FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->stream_info.data.stream_info.channels = x+1;
- used_bits += bits;
-
- bits = FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->stream_info.data.stream_info.bits_per_sample = x+1;
- used_bits += bits;
-
- bits = FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN;
- if(!FLAC__bitreader_read_raw_uint64(decoder->private_->input, &decoder->private_->stream_info.data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN))
- return false; /* read_callback_ sets the state for us */
- used_bits += bits;
-
- if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, decoder->private_->stream_info.data.stream_info.md5sum, 16))
- return false; /* read_callback_ sets the state for us */
- used_bits += 16*8;
-
- /* skip the rest of the block */
- FLAC__ASSERT(used_bits % 8 == 0);
- if (length < (used_bits / 8))
- return false; /* read_callback_ sets the state for us */
- length -= (used_bits / 8);
- if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, length))
- return false; /* read_callback_ sets the state for us */
-
- return true;
-}
-
-FLAC__bool read_metadata_seektable_(FLAC__StreamDecoder *decoder, FLAC__bool is_last, uint32_t length)
-{
- FLAC__uint32 i, x;
- FLAC__uint64 xx;
-
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input));
-
- decoder->private_->seek_table.type = FLAC__METADATA_TYPE_SEEKTABLE;
- decoder->private_->seek_table.is_last = is_last;
- decoder->private_->seek_table.length = length;
-
- if(length % FLAC__STREAM_METADATA_SEEKPOINT_LENGTH) {
- FLAC__bitreader_limit_invalidate(decoder->private_->input);
- return false;
- }
-
- decoder->private_->seek_table.data.seek_table.num_points = length / FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
-
- /* use realloc since we may pass through here several times (e.g. after seeking) */
- if(0 == (decoder->private_->seek_table.data.seek_table.points = (FLAC__StreamMetadata_SeekPoint*) safe_realloc_mul_2op_(decoder->private_->seek_table.data.seek_table.points, decoder->private_->seek_table.data.seek_table.num_points, /*times*/sizeof(FLAC__StreamMetadata_SeekPoint)))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- for(i = 0; i < decoder->private_->seek_table.data.seek_table.num_points; i++) {
- if(!FLAC__bitreader_read_raw_uint64(decoder->private_->input, &xx, FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->seek_table.data.seek_table.points[i].sample_number = xx;
-
- if(!FLAC__bitreader_read_raw_uint64(decoder->private_->input, &xx, FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->seek_table.data.seek_table.points[i].stream_offset = xx;
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->seek_table.data.seek_table.points[i].frame_samples = x;
- }
- length -= (decoder->private_->seek_table.data.seek_table.num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH);
-
- FLAC__ASSERT(length == 0);
-
- return true;
-}
-
-FLAC__bool read_metadata_vorbiscomment_(FLAC__StreamDecoder *decoder, FLAC__StreamMetadata_VorbisComment *obj, uint32_t length)
-{
- FLAC__uint32 i;
-
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input));
-
- /* read vendor string */
- if (length >= 8) {
- length -= 8; /* vendor string length + num comments entries alone take 8 bytes */
- FLAC__ASSERT(FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN == 32);
- if (!FLAC__bitreader_read_uint32_little_endian(decoder->private_->input, &obj->vendor_string.length))
- return false; /* read_callback_ sets the state for us */
- if (length < obj->vendor_string.length) {
- obj->vendor_string.length = 0;
- obj->vendor_string.entry = 0;
- goto skip;
- }
- else
- length -= obj->vendor_string.length;
- if (0 == (obj->vendor_string.entry = (FLAC__byte*) safe_malloc_add_2op_(obj->vendor_string.length, /*+*/1))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- if (!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, obj->vendor_string.entry, obj->vendor_string.length))
- return false; /* read_callback_ sets the state for us */
- obj->vendor_string.entry[obj->vendor_string.length] = '\0';
-
- /* read num comments */
- FLAC__ASSERT(FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN == 32);
- if (!FLAC__bitreader_read_uint32_little_endian(decoder->private_->input, &obj->num_comments))
- return false; /* read_callback_ sets the state for us */
-
- /* read comments */
- if (obj->num_comments > 100000) {
- /* Possibly malicious file. */
- obj->num_comments = 0;
- return false;
- }
- if (obj->num_comments > 0) {
- if (0 == (obj->comments = (FLAC__StreamMetadata_VorbisComment_Entry*) safe_malloc_mul_2op_p(obj->num_comments, /*times*/sizeof(FLAC__StreamMetadata_VorbisComment_Entry)))) {
- obj->num_comments = 0;
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- for (i = 0; i < obj->num_comments; i++) {
- /* Initialize here just to make sure. */
- obj->comments[i].length = 0;
- obj->comments[i].entry = 0;
-
- FLAC__ASSERT(FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN == 32);
- if (length < 4) {
- obj->num_comments = i;
- goto skip;
- }
- else
- length -= 4;
- if (!FLAC__bitreader_read_uint32_little_endian(decoder->private_->input, &obj->comments[i].length)) {
- obj->num_comments = i;
- return false; /* read_callback_ sets the state for us */
- }
- if (length < obj->comments[i].length) {
- obj->num_comments = i;
- FLAC__bitreader_limit_invalidate(decoder->private_->input);
- return false;
- }
- else
- length -= obj->comments[i].length;
- if (0 == (obj->comments[i].entry = (FLAC__byte*) safe_malloc_add_2op_(obj->comments[i].length, /*+*/1))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- obj->num_comments = i;
- return false;
- }
- memset (obj->comments[i].entry, 0, obj->comments[i].length) ;
- if (!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, obj->comments[i].entry, obj->comments[i].length)) {
- /* Current i-th entry is bad, so we delete it. */
- free (obj->comments[i].entry) ;
- obj->comments[i].entry = NULL ;
- obj->num_comments = i;
- goto skip;
- }
- obj->comments[i].entry[obj->comments[i].length] = '\0';
- }
- }
- }
- else {
- FLAC__bitreader_limit_invalidate(decoder->private_->input);
- return false;
- }
-
- skip:
- if (length > 0) {
- /* length > 0 can only happen on files with invalid data in comments */
- if(obj->num_comments < 1) {
- free(obj->comments);
- obj->comments = NULL;
- }
- FLAC__bitreader_limit_invalidate(decoder->private_->input);
- return false;
- }
-
- return true;
-}
-
-FLAC__bool read_metadata_cuesheet_(FLAC__StreamDecoder *decoder, FLAC__StreamMetadata_CueSheet *obj)
-{
- FLAC__uint32 i, j, x;
-
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input));
-
- memset(obj, 0, sizeof(FLAC__StreamMetadata_CueSheet));
-
- FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0);
- if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, (FLAC__byte*)obj->media_catalog_number, FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN/8))
- return false; /* read_callback_ sets the state for us */
-
- if(!FLAC__bitreader_read_raw_uint64(decoder->private_->input, &obj->lead_in, FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN))
- return false; /* read_callback_ sets the state for us */
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN))
- return false; /* read_callback_ sets the state for us */
- obj->is_cd = x? true : false;
-
- if(!FLAC__bitreader_skip_bits_no_crc(decoder->private_->input, FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN))
- return false; /* read_callback_ sets the state for us */
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN))
- return false; /* read_callback_ sets the state for us */
- obj->num_tracks = x;
-
- if(obj->num_tracks > 0) {
- if(0 == (obj->tracks = (FLAC__StreamMetadata_CueSheet_Track*) safe_calloc_(obj->num_tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track)))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- for(i = 0; i < obj->num_tracks; i++) {
- FLAC__StreamMetadata_CueSheet_Track *track = &obj->tracks[i];
- if(!FLAC__bitreader_read_raw_uint64(decoder->private_->input, &track->offset, FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN))
- return false; /* read_callback_ sets the state for us */
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN))
- return false; /* read_callback_ sets the state for us */
- track->number = (FLAC__byte)x;
-
- FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0);
- if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, (FLAC__byte*)track->isrc, FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN/8))
- return false; /* read_callback_ sets the state for us */
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN))
- return false; /* read_callback_ sets the state for us */
- track->type = x;
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN))
- return false; /* read_callback_ sets the state for us */
- track->pre_emphasis = x;
-
- if(!FLAC__bitreader_skip_bits_no_crc(decoder->private_->input, FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN))
- return false; /* read_callback_ sets the state for us */
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN))
- return false; /* read_callback_ sets the state for us */
- track->num_indices = (FLAC__byte)x;
-
- if(track->num_indices > 0) {
- if(0 == (track->indices = (FLAC__StreamMetadata_CueSheet_Index*) safe_calloc_(track->num_indices, sizeof(FLAC__StreamMetadata_CueSheet_Index)))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- for(j = 0; j < track->num_indices; j++) {
- FLAC__StreamMetadata_CueSheet_Index *indx = &track->indices[j];
- if(!FLAC__bitreader_read_raw_uint64(decoder->private_->input, &indx->offset, FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN))
- return false; /* read_callback_ sets the state for us */
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN))
- return false; /* read_callback_ sets the state for us */
- indx->number = (FLAC__byte)x;
-
- if(!FLAC__bitreader_skip_bits_no_crc(decoder->private_->input, FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN))
- return false; /* read_callback_ sets the state for us */
- }
- }
- }
- }
- else { /* obj->num_tracks == 0 */
- FLAC__bitreader_limit_invalidate(decoder->private_->input);
- return false;
- }
-
- return true;
-}
-
-FLAC__bool read_metadata_picture_(FLAC__StreamDecoder *decoder, FLAC__StreamMetadata_Picture *obj)
-{
- FLAC__uint32 x;
-
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input));
-
- /* read type */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_PICTURE_TYPE_LEN))
- return false; /* read_callback_ sets the state for us */
- if(x < FLAC__STREAM_METADATA_PICTURE_TYPE_UNDEFINED)
- obj->type = (FLAC__StreamMetadata_Picture_Type) x;
- else
- obj->type = FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER;
-
- /* read MIME type */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN))
- return false; /* read_callback_ sets the state for us */
- if(FLAC__bitreader_limit_remaining(decoder->private_->input) < x){
- FLAC__bitreader_limit_invalidate(decoder->private_->input);
- return false;
- }
- if(0 == (obj->mime_type = (char*) safe_malloc_add_2op_(x, /*+*/1))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- if(x > 0) {
- if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, (FLAC__byte*)obj->mime_type, x))
- return false; /* read_callback_ sets the state for us */
- }
- obj->mime_type[x] = '\0';
-
- /* read description */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN))
- return false; /* read_callback_ sets the state for us */
- if(FLAC__bitreader_limit_remaining(decoder->private_->input) < x){
- FLAC__bitreader_limit_invalidate(decoder->private_->input);
- return false;
- }
- if(0 == (obj->description = (FLAC__byte*) safe_malloc_add_2op_(x, /*+*/1))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- if(x > 0) {
- if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, obj->description, x))
- return false; /* read_callback_ sets the state for us */
- }
- obj->description[x] = '\0';
-
- /* read width */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &obj->width, FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN))
- return false; /* read_callback_ sets the state for us */
-
- /* read height */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &obj->height, FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN))
- return false; /* read_callback_ sets the state for us */
-
- /* read depth */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &obj->depth, FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN))
- return false; /* read_callback_ sets the state for us */
-
- /* read colors */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &obj->colors, FLAC__STREAM_METADATA_PICTURE_COLORS_LEN))
- return false; /* read_callback_ sets the state for us */
-
- /* read data */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &(obj->data_length), FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN))
- return false; /* read_callback_ sets the state for us */
- if(FLAC__bitreader_limit_remaining(decoder->private_->input) < obj->data_length){
- FLAC__bitreader_limit_invalidate(decoder->private_->input);
- return false;
- }
- if(0 == (obj->data = (FLAC__byte*) safe_malloc_(obj->data_length))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- if(obj->data_length > 0) {
- if(!FLAC__bitreader_read_byte_block_aligned_no_crc(decoder->private_->input, obj->data, obj->data_length))
- return false; /* read_callback_ sets the state for us */
- }
-
- return true;
-}
-
-FLAC__bool skip_id3v2_tag_(FLAC__StreamDecoder *decoder)
-{
- FLAC__uint32 x;
- uint32_t i, skip;
-
- /* skip the version and flags bytes */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 24))
- return false; /* read_callback_ sets the state for us */
- /* get the size (in bytes) to skip */
- skip = 0;
- for(i = 0; i < 4; i++) {
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8))
- return false; /* read_callback_ sets the state for us */
- skip <<= 7;
- skip |= (x & 0x7f);
- }
- /* skip the rest of the tag */
- if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, skip))
- return false; /* read_callback_ sets the state for us */
- return true;
-}
-
-FLAC__bool frame_sync_(FLAC__StreamDecoder *decoder)
-{
- FLAC__uint32 x;
- FLAC__bool first = true;
-
- /* make sure we're byte aligned */
- if(!FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)) {
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__bitreader_bits_left_for_byte_alignment(decoder->private_->input)))
- return false; /* read_callback_ sets the state for us */
- }
-
- while(1) {
- if(decoder->private_->cached) {
- x = (FLAC__uint32)decoder->private_->lookahead;
- decoder->private_->cached = false;
- }
- else {
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8))
- return false; /* read_callback_ sets the state for us */
- }
- if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
- decoder->private_->header_warmup[0] = (FLAC__byte)x;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8))
- return false; /* read_callback_ sets the state for us */
-
- /* we have to check if we just read two 0xff's in a row; the second may actually be the beginning of the sync code */
- /* else we have to check if the second byte is the end of a sync code */
- if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
- decoder->private_->lookahead = (FLAC__byte)x;
- decoder->private_->cached = true;
- }
- else if(x >> 1 == 0x7c) { /* MAGIC NUMBER for the last 6 sync bits and reserved 7th bit */
- decoder->private_->header_warmup[1] = (FLAC__byte)x;
- decoder->protected_->state = FLAC__STREAM_DECODER_READ_FRAME;
-
- /* Save location so we can rewind in case the frame turns
- * out to be invalid after the header */
- FLAC__bitreader_set_framesync_location(decoder->private_->input);
- if(!FLAC__stream_decoder_get_decode_position(decoder, &decoder->private_->last_seen_framesync))
- decoder->private_->last_seen_framesync = 0;
- return true;
- }
- }
- if(first) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- first = false;
- }
- }
-
- return true;
-}
-
-FLAC__bool read_frame_(FLAC__StreamDecoder *decoder, FLAC__bool *got_a_frame, FLAC__bool do_full_decode)
-{
- uint32_t channel;
- uint32_t i;
- uint32_t frame_crc; /* the one we calculate from the input stream */
- FLAC__uint32 x{};
-
- *got_a_frame = false;
- decoder->private_->side_subframe_in_use = false;
-
- /* init the CRC */
- frame_crc = 0;
- frame_crc = FLAC__CRC16_UPDATE(decoder->private_->header_warmup[0], frame_crc);
- frame_crc = FLAC__CRC16_UPDATE(decoder->private_->header_warmup[1], frame_crc);
- FLAC__bitreader_reset_read_crc16(decoder->private_->input, (FLAC__uint16)frame_crc);
-
- if(!read_frame_header_(decoder))
- return false;
- if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means we didn't sync on a valid header */
- return true;
- if(!allocate_output_(decoder, decoder->private_->frame.header.blocksize, decoder->private_->frame.header.channels, decoder->private_->frame.header.bits_per_sample))
- return false;
- for(channel = 0; channel < decoder->private_->frame.header.channels; channel++) {
- /*
- * first figure the correct bits-per-sample of the subframe
- */
- uint32_t bps = decoder->private_->frame.header.bits_per_sample;
- switch(decoder->private_->frame.header.channel_assignment) {
- case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
- /* no adjustment needed */
- break;
- case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
- FLAC__ASSERT(decoder->private_->frame.header.channels == 2);
- if(channel == 1)
- bps++;
- break;
- case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
- FLAC__ASSERT(decoder->private_->frame.header.channels == 2);
- if(channel == 0)
- bps++;
- break;
- case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
- FLAC__ASSERT(decoder->private_->frame.header.channels == 2);
- if(channel == 1)
- bps++;
- break;
- default:
- FLAC__ASSERT(0);
- }
- /*
- * now read it
- */
- if(!read_subframe_(decoder, channel, bps, do_full_decode)){
- /* read_callback_ sets the state for us */
- if(decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
- break;
- else
- return false;
- }
- if(decoder->protected_->state != FLAC__STREAM_DECODER_READ_FRAME)
- break;
- }
-
- if(decoder->protected_->state != FLAC__STREAM_DECODER_END_OF_STREAM)
- if(!read_zero_padding_(decoder))
- return false;
-
- /*
- * Read the frame CRC-16 from the footer and check
- */
- if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME) {
- frame_crc = FLAC__bitreader_get_read_crc16(decoder->private_->input);
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__FRAME_FOOTER_CRC_LEN)) {
- /* read_callback_ sets the state for us */
- if(decoder->protected_->state != FLAC__STREAM_DECODER_END_OF_STREAM)
- return false;
- }
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
- }
- if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME && frame_crc == x) {
-#endif
- if(do_full_decode) {
- /* Undo any special channel coding */
- undo_channel_coding(decoder);
- /* Check whether decoded data actually fits bps */
- for(channel = 0; channel < decoder->private_->frame.header.channels; channel++) {
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++) {
- int shift_bits = 32 - decoder->private_->frame.header.bits_per_sample;
- /* Check whether shift_bits MSBs are 'empty' by shifting up and down */
- if((decoder->private_->output[channel][i] < (INT32_MIN >> shift_bits)) ||
- (decoder->private_->output[channel][i] > (INT32_MAX >> shift_bits))) {
- /* Bad frame, emit error */
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- break;
- }
- }
- }
- }
- }
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
- else if (decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME) {
- /* Bad frame, emit error */
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- }
-#endif
-
- /* Check whether frames are missing, if so, add silence to compensate */
- if(decoder->private_->last_frame_is_set && decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME && !decoder->private_->is_seeking && do_full_decode) {
- FLAC__ASSERT(decoder->private_->frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
- FLAC__ASSERT(decoder->private_->last_frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
- if(decoder->private_->last_frame.header.number.sample_number + decoder->private_->last_frame.header.blocksize < decoder->private_->frame.header.number.sample_number) {
- uint32_t padding_samples_needed = decoder->private_->frame.header.number.sample_number - (decoder->private_->last_frame.header.number.sample_number + decoder->private_->last_frame.header.blocksize);
-
- /* Do some extra validation to assure last frame an current frame
- * header are both valid before adding silence inbetween
- * Technically both frames could be valid with differing sample_rates,
- * channels and bits_per_sample, but it is quite rare */
- if(decoder->private_->last_frame.header.sample_rate == decoder->private_->frame.header.sample_rate &&
- decoder->private_->last_frame.header.channels == decoder->private_->frame.header.channels &&
- decoder->private_->last_frame.header.bits_per_sample == decoder->private_->frame.header.bits_per_sample &&
- decoder->private_->last_frame.header.blocksize >= 16) {
- FLAC__Frame empty_frame;
- FLAC__int32 * empty_buffer[FLAC__MAX_CHANNELS] = {NULL};
- empty_frame.header = decoder->private_->last_frame.header;
- empty_frame.footer.crc = 0;
- for(i = 0; i < empty_frame.header.channels; i++) {
- empty_buffer[i] = (FLAC__int32*) safe_calloc_(empty_frame.header.blocksize, sizeof(FLAC__int32));
- if(empty_buffer[i] == NULL) {
- for(i = 0; i < empty_frame.header.channels; i++)
- if(empty_buffer[i] != NULL)
- free(empty_buffer[i]);
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- }
- /* No repairs larger than 5 seconds or 50 frames are made, to not
- * unexpectedly create enormous files when one of the headers was
- * corrupt after all */
- if(padding_samples_needed > (5*empty_frame.header.sample_rate))
- padding_samples_needed = 5*empty_frame.header.sample_rate;
- if(padding_samples_needed > (50*empty_frame.header.blocksize))
- padding_samples_needed = 50*empty_frame.header.blocksize;
- while(padding_samples_needed){
- empty_frame.header.number.sample_number += empty_frame.header.blocksize;
- if(padding_samples_needed < empty_frame.header.blocksize)
- empty_frame.header.blocksize = padding_samples_needed;
- padding_samples_needed -= empty_frame.header.blocksize;
- decoder->protected_->blocksize = empty_frame.header.blocksize;
-
- FLAC__ASSERT(empty_frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
- decoder->private_->samples_decoded = empty_frame.header.number.sample_number + empty_frame.header.blocksize;
-
- for(channel = 0; channel < empty_frame.header.channels; channel++) {
- empty_frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_CONSTANT;
- empty_frame.subframes[channel].data.constant.value = 0;
- empty_frame.subframes[channel].wasted_bits = 0;
- }
-
- if(write_audio_frame_to_client_(decoder, &empty_frame, (const FLAC__int32 * const *)empty_buffer) != FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE) {
- decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED;
- for(i = 0; i < empty_frame.header.channels; i++)
- if(empty_buffer[i] != NULL)
- free(empty_buffer[i]);
- return false;
- }
- }
- for(i = 0; i < empty_frame.header.channels; i++)
- if(empty_buffer[i] != NULL)
- free(empty_buffer[i]);
-
- }
- }
- }
-
- if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC || decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM) {
- /* Got corruption, rewind if possible. Return value of seek
- * isn't checked, if the seek fails the decoder will continue anyway */
- if(!FLAC__bitreader_rewind_to_after_last_seen_framesync(decoder->private_->input)){
-#ifndef NDEBUG
- fprintf(stderr, "Rewinding, seeking necessary\n");
-#endif
- if(decoder->private_->seek_callback && decoder->private_->last_seen_framesync){
- /* Last framesync isn't in bitreader anymore, rewind with seek if possible */
-#ifndef NDEBUG
- FLAC__uint64 current_decode_position;
- if(FLAC__stream_decoder_get_decode_position(decoder, ¤t_decode_position))
- fprintf(stderr, "Bitreader was %" PRIu64 " bytes short\n", current_decode_position-decoder->private_->last_seen_framesync);
-#endif
- if(decoder->private_->seek_callback(decoder, decoder->private_->last_seen_framesync, decoder->private_->client_data) == FLAC__STREAM_DECODER_SEEK_STATUS_ERROR) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- if(!FLAC__bitreader_clear(decoder->private_->input)) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
- }
- }
-#ifndef NDEBUG
- else{
- fprintf(stderr, "Rewinding, seeking not necessary\n");
- }
-#endif
- }
- else {
- *got_a_frame = true;
-
- /* we wait to update fixed_block_size until here, when we're sure we've got a proper frame and hence a correct blocksize */
- if(decoder->private_->next_fixed_block_size)
- decoder->private_->fixed_block_size = decoder->private_->next_fixed_block_size;
-
- /* put the latest values into the public section of the decoder instance */
- decoder->protected_->channels = decoder->private_->frame.header.channels;
- decoder->protected_->channel_assignment = decoder->private_->frame.header.channel_assignment;
- decoder->protected_->bits_per_sample = decoder->private_->frame.header.bits_per_sample;
- decoder->protected_->sample_rate = decoder->private_->frame.header.sample_rate;
- decoder->protected_->blocksize = decoder->private_->frame.header.blocksize;
-
- FLAC__ASSERT(decoder->private_->frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
- decoder->private_->samples_decoded = decoder->private_->frame.header.number.sample_number + decoder->private_->frame.header.blocksize;
-
- /* write it */
- if(do_full_decode) {
- if(write_audio_frame_to_client_(decoder, &decoder->private_->frame, (const FLAC__int32 * const *)decoder->private_->output) != FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE) {
- decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED;
- return false;
- }
- }
- }
-
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
-}
-
-FLAC__bool read_frame_header_(FLAC__StreamDecoder *decoder)
-{
- FLAC__uint32 x;
- FLAC__uint64 xx;
- uint32_t i, blocksize_hint = 0, sample_rate_hint = 0;
- FLAC__byte crc8, raw_header[16]; /* MAGIC NUMBER based on the maximum frame header size, including CRC */
- uint32_t raw_header_len;
- FLAC__bool is_unparseable = false;
-
- FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input));
-
- /* init the raw header with the saved bits from synchronization */
- raw_header[0] = decoder->private_->header_warmup[0];
- raw_header[1] = decoder->private_->header_warmup[1];
- raw_header_len = 2;
-
- /* check to make sure that reserved bit is 0 */
- if(raw_header[1] & 0x02) /* MAGIC NUMBER */
- is_unparseable = true;
-
- /*
- * Note that along the way as we read the header, we look for a sync
- * code inside. If we find one it would indicate that our original
- * sync was bad since there cannot be a sync code in a valid header.
- *
- * Three kinds of things can go wrong when reading the frame header:
- * 1) We may have sync'ed incorrectly and not landed on a frame header.
- * If we don't find a sync code, it can end up looking like we read
- * a valid but unparseable header, until getting to the frame header
- * CRC. Even then we could get a false positive on the CRC.
- * 2) We may have sync'ed correctly but on an unparseable frame (from a
- * future encoder).
- * 3) We may be on a damaged frame which appears valid but unparseable.
- *
- * For all these reasons, we try and read a complete frame header as
- * long as it seems valid, even if unparseable, up until the frame
- * header CRC.
- */
-
- /*
- * read in the raw header as bytes so we can CRC it, and parse it on the way
- */
- for(i = 0; i < 2; i++) {
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8))
- return false; /* read_callback_ sets the state for us */
- if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */
- /* if we get here it means our original sync was erroneous since the sync code cannot appear in the header */
- decoder->private_->lookahead = (FLAC__byte)x;
- decoder->private_->cached = true;
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- raw_header[raw_header_len++] = (FLAC__byte)x;
- }
-
- switch(x = raw_header[2] >> 4) {
- case 0:
- is_unparseable = true;
- break;
- case 1:
- decoder->private_->frame.header.blocksize = 192;
- break;
- case 2:
- case 3:
- case 4:
- case 5:
- decoder->private_->frame.header.blocksize = 576 << (x-2);
- break;
- case 6:
- case 7:
- blocksize_hint = x;
- break;
- case 8:
- case 9:
- case 10:
- case 11:
- case 12:
- case 13:
- case 14:
- case 15:
- decoder->private_->frame.header.blocksize = 256 << (x-8);
- break;
- default:
- FLAC__ASSERT(0);
- break;
- }
-
- switch(x = raw_header[2] & 0x0f) {
- case 0:
- if(decoder->private_->has_stream_info)
- decoder->private_->frame.header.sample_rate = decoder->private_->stream_info.data.stream_info.sample_rate;
- else
- is_unparseable = true;
- break;
- case 1:
- decoder->private_->frame.header.sample_rate = 88200;
- break;
- case 2:
- decoder->private_->frame.header.sample_rate = 176400;
- break;
- case 3:
- decoder->private_->frame.header.sample_rate = 192000;
- break;
- case 4:
- decoder->private_->frame.header.sample_rate = 8000;
- break;
- case 5:
- decoder->private_->frame.header.sample_rate = 16000;
- break;
- case 6:
- decoder->private_->frame.header.sample_rate = 22050;
- break;
- case 7:
- decoder->private_->frame.header.sample_rate = 24000;
- break;
- case 8:
- decoder->private_->frame.header.sample_rate = 32000;
- break;
- case 9:
- decoder->private_->frame.header.sample_rate = 44100;
- break;
- case 10:
- decoder->private_->frame.header.sample_rate = 48000;
- break;
- case 11:
- decoder->private_->frame.header.sample_rate = 96000;
- break;
- case 12:
- case 13:
- case 14:
- sample_rate_hint = x;
- break;
- case 15:
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- default:
- FLAC__ASSERT(0);
- }
-
- x = (uint32_t)(raw_header[3] >> 4);
- if(x & 8) {
- decoder->private_->frame.header.channels = 2;
- switch(x & 7) {
- case 0:
- decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
- break;
- case 1:
- decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
- break;
- case 2:
- decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
- break;
- default:
- is_unparseable = true;
- break;
- }
- }
- else {
- decoder->private_->frame.header.channels = (uint32_t)x + 1;
- decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT;
- }
-
- switch(x = (uint32_t)(raw_header[3] & 0x0e) >> 1) {
- case 0:
- if(decoder->private_->has_stream_info)
- decoder->private_->frame.header.bits_per_sample = decoder->private_->stream_info.data.stream_info.bits_per_sample;
- else
- is_unparseable = true;
- break;
- case 1:
- decoder->private_->frame.header.bits_per_sample = 8;
- break;
- case 2:
- decoder->private_->frame.header.bits_per_sample = 12;
- break;
- case 3:
- is_unparseable = true;
- break;
- case 4:
- decoder->private_->frame.header.bits_per_sample = 16;
- break;
- case 5:
- decoder->private_->frame.header.bits_per_sample = 20;
- break;
- case 6:
- decoder->private_->frame.header.bits_per_sample = 24;
- break;
- case 7:
- decoder->private_->frame.header.bits_per_sample = 32;
- break;
- default:
- FLAC__ASSERT(0);
- break;
- }
-
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
- /* check to make sure that reserved bit is 0 */
- if(raw_header[3] & 0x01) /* MAGIC NUMBER */
- is_unparseable = true;
-#endif
-
- /* read the frame's starting sample number (or frame number as the case may be) */
- if(
- raw_header[1] & 0x01 ||
- /*@@@ this clause is a concession to the old way of doing variable blocksize; the only known implementation is flake and can probably be removed without inconveniencing anyone */
- (decoder->private_->has_stream_info && decoder->private_->stream_info.data.stream_info.min_blocksize != decoder->private_->stream_info.data.stream_info.max_blocksize)
- ) { /* variable blocksize */
- if(!FLAC__bitreader_read_utf8_uint64(decoder->private_->input, &xx, raw_header, &raw_header_len))
- return false; /* read_callback_ sets the state for us */
- if(xx == FLAC__U64L(0xffffffffffffffff)) { /* i.e. non-UTF8 code... */
- decoder->private_->lookahead = raw_header[raw_header_len-1]; /* back up as much as we can */
- decoder->private_->cached = true;
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- decoder->private_->frame.header.number_type = FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER;
- decoder->private_->frame.header.number.sample_number = xx;
- }
- else { /* fixed blocksize */
- if(!FLAC__bitreader_read_utf8_uint32(decoder->private_->input, &x, raw_header, &raw_header_len))
- return false; /* read_callback_ sets the state for us */
- if(x == 0xffffffff) { /* i.e. non-UTF8 code... */
- decoder->private_->lookahead = raw_header[raw_header_len-1]; /* back up as much as we can */
- decoder->private_->cached = true;
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- decoder->private_->frame.header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER;
- decoder->private_->frame.header.number.frame_number = x;
- }
-
- if(blocksize_hint) {
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8))
- return false; /* read_callback_ sets the state for us */
- raw_header[raw_header_len++] = (FLAC__byte)x;
- if(blocksize_hint == 7) {
- FLAC__uint32 _x;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &_x, 8))
- return false; /* read_callback_ sets the state for us */
- raw_header[raw_header_len++] = (FLAC__byte)_x;
- x = (x << 8) | _x;
- }
- decoder->private_->frame.header.blocksize = x+1;
- if(decoder->private_->frame.header.blocksize > 65535) { /* invalid blocksize (65536) specified */
- decoder->private_->lookahead = raw_header[raw_header_len-1]; /* back up as much as we can */
- decoder->private_->cached = true;
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
-
- }
-
- if(sample_rate_hint) {
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8))
- return false; /* read_callback_ sets the state for us */
- raw_header[raw_header_len++] = (FLAC__byte)x;
- if(sample_rate_hint != 12) {
- FLAC__uint32 _x;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &_x, 8))
- return false; /* read_callback_ sets the state for us */
- raw_header[raw_header_len++] = (FLAC__byte)_x;
- x = (x << 8) | _x;
- }
- if(sample_rate_hint == 12)
- decoder->private_->frame.header.sample_rate = x*1000;
- else if(sample_rate_hint == 13)
- decoder->private_->frame.header.sample_rate = x;
- else
- decoder->private_->frame.header.sample_rate = x*10;
- }
-
- /* read the CRC-8 byte */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8))
- return false; /* read_callback_ sets the state for us */
- crc8 = (FLAC__byte)x;
-
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
- if(FLAC__crc8(raw_header, raw_header_len) != crc8) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
-#endif
-
- /* calculate the sample number from the frame number if needed */
- decoder->private_->next_fixed_block_size = 0;
- if(decoder->private_->frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER) {
- x = decoder->private_->frame.header.number.frame_number;
- decoder->private_->frame.header.number_type = FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER;
- if(decoder->private_->fixed_block_size)
- decoder->private_->frame.header.number.sample_number = (FLAC__uint64)decoder->private_->fixed_block_size * (FLAC__uint64)x;
- else if(decoder->private_->has_stream_info) {
- if(decoder->private_->stream_info.data.stream_info.min_blocksize == decoder->private_->stream_info.data.stream_info.max_blocksize) {
- decoder->private_->frame.header.number.sample_number = (FLAC__uint64)decoder->private_->stream_info.data.stream_info.min_blocksize * (FLAC__uint64)x;
- decoder->private_->next_fixed_block_size = decoder->private_->stream_info.data.stream_info.max_blocksize;
- }
- else
- is_unparseable = true;
- }
- else if(x == 0) {
- decoder->private_->frame.header.number.sample_number = 0;
- decoder->private_->next_fixed_block_size = decoder->private_->frame.header.blocksize;
- }
- else {
- /* can only get here if the stream has invalid frame numbering and no STREAMINFO, so assume it's not the last (possibly short) frame */
- decoder->private_->frame.header.number.sample_number = (FLAC__uint64)decoder->private_->frame.header.blocksize * (FLAC__uint64)x;
- }
- }
-
- if(is_unparseable) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
-
- return true;
-}
-
-FLAC__bool read_subframe_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, FLAC__bool do_full_decode)
-{
- FLAC__uint32 x;
- FLAC__bool wasted_bits;
- uint32_t i;
-
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) /* MAGIC NUMBER */
- return false; /* read_callback_ sets the state for us */
-
- wasted_bits = (x & 1);
- x &= 0xfe;
-
- if(wasted_bits) {
- uint32_t u;
- if(!FLAC__bitreader_read_unary_unsigned(decoder->private_->input, &u))
- return false; /* read_callback_ sets the state for us */
- decoder->private_->frame.subframes[channel].wasted_bits = u+1;
- if (decoder->private_->frame.subframes[channel].wasted_bits >= bps) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- bps -= decoder->private_->frame.subframes[channel].wasted_bits;
- }
- else
- decoder->private_->frame.subframes[channel].wasted_bits = 0;
-
- /*
- * Lots of magic numbers here
- */
- if(x & 0x80) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- else if(x == 0) {
- if(!read_subframe_constant_(decoder, channel, bps, do_full_decode))
- return false;
- }
- else if(x == 2) {
- if(!read_subframe_verbatim_(decoder, channel, bps, do_full_decode))
- return false;
- }
- else if(x < 16) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- else if(x <= 24) {
- uint32_t predictor_order = (x>>1)&7;
- if(decoder->private_->frame.header.blocksize <= predictor_order){
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- if(!read_subframe_fixed_(decoder, channel, bps, predictor_order, do_full_decode))
- return false;
- if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means bad sync or got corruption */
- return true;
- }
- else if(x < 64) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- else {
- uint32_t predictor_order = ((x>>1)&31)+1;
- if(decoder->private_->frame.header.blocksize <= predictor_order){
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- if(!read_subframe_lpc_(decoder, channel, bps, predictor_order, do_full_decode))
- return false;
- if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means bad sync or got corruption */
- return true;
- }
-
- if(wasted_bits && do_full_decode) {
- x = decoder->private_->frame.subframes[channel].wasted_bits;
- if((bps + x) < 33) {
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++) {
- uint32_t val = decoder->private_->output[channel][i];
- decoder->private_->output[channel][i] = (val << x);
- }
- }
- else {
- /* When there are wasted bits, bps is never 33 and so
- * side_subframe is never already in use */
- FLAC__ASSERT(!decoder->private_->side_subframe_in_use);
- decoder->private_->side_subframe_in_use = true;
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++) {
- uint64_t val = decoder->private_->output[channel][i];
- decoder->private_->side_subframe[i] = (val << x);
- }
- }
- }
-
- return true;
-}
-
-FLAC__bool read_subframe_constant_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, FLAC__bool do_full_decode)
-{
- FLAC__Subframe_Constant *subframe = &decoder->private_->frame.subframes[channel].data.constant;
- FLAC__int64 x;
- uint32_t i;
-
- decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_CONSTANT;
-
- if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &x, bps))
- return false; /* read_callback_ sets the state for us */
-
- subframe->value = x;
-
- /* decode the subframe */
- if(do_full_decode) {
- if(bps <= 32) {
- FLAC__int32 *output = decoder->private_->output[channel];
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++)
- output[i] = x;
- } else {
- FLAC__int64 *output = decoder->private_->side_subframe;
- decoder->private_->side_subframe_in_use = true;
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++)
- output[i] = x;
- }
- }
-
- return true;
-}
-
-FLAC__bool read_subframe_fixed_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, const uint32_t order, FLAC__bool do_full_decode)
-{
- FLAC__Subframe_Fixed *subframe = &decoder->private_->frame.subframes[channel].data.fixed;
- FLAC__int64 i64;
- FLAC__uint32 u32;
- uint32_t u;
-
- decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_FIXED;
-
- subframe->residual = decoder->private_->residual[channel];
- subframe->order = order;
-
- /* read warm-up samples */
- for(u = 0; u < order; u++) {
- if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &i64, bps))
- return false; /* read_callback_ sets the state for us */
- subframe->warmup[u] = i64;
- }
-
- /* read entropy coding method info */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN))
- return false; /* read_callback_ sets the state for us */
- subframe->entropy_coding_method.type = (FLAC__EntropyCodingMethodType)u32;
- switch(subframe->entropy_coding_method.type) {
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2:
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
- return false; /* read_callback_ sets the state for us */
- if((decoder->private_->frame.header.blocksize >> u32 < order) ||
- (decoder->private_->frame.header.blocksize % (1 << u32) > 0)) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- subframe->entropy_coding_method.data.partitioned_rice.order = u32;
- subframe->entropy_coding_method.data.partitioned_rice.contents = &decoder->private_->partitioned_rice_contents[channel];
- break;
- default:
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
-
- /* read residual */
- switch(subframe->entropy_coding_method.type) {
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2:
- if(!read_residual_partitioned_rice_(decoder, order, subframe->entropy_coding_method.data.partitioned_rice.order, &decoder->private_->partitioned_rice_contents[channel], decoder->private_->residual[channel], /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2))
- return false;
- break;
- default:
- FLAC__ASSERT(0);
- }
-
- /* decode the subframe */
- if(do_full_decode) {
- if(bps < 33){
- uint32_t i;
- for(i = 0; i < order; i++)
- decoder->private_->output[channel][i] = subframe->warmup[i];
- if(bps+order <= 32)
- FLAC__fixed_restore_signal(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, order, decoder->private_->output[channel]+order);
- else
- FLAC__fixed_restore_signal_wide(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, order, decoder->private_->output[channel]+order);
- }
- else {
- decoder->private_->side_subframe_in_use = true;
- memcpy(decoder->private_->side_subframe, subframe->warmup, sizeof(FLAC__int64) * order);
- FLAC__fixed_restore_signal_wide_33bit(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, order, decoder->private_->side_subframe+order);
- }
- }
-
- return true;
-}
-
-FLAC__bool read_subframe_lpc_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, const uint32_t order, FLAC__bool do_full_decode)
-{
- FLAC__Subframe_LPC *subframe = &decoder->private_->frame.subframes[channel].data.lpc;
- FLAC__int32 i32;
- FLAC__int64 i64;
- FLAC__uint32 u32;
- uint32_t u;
-
- decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_LPC;
-
- subframe->residual = decoder->private_->residual[channel];
- subframe->order = order;
-
- /* read warm-up samples */
- for(u = 0; u < order; u++) {
- if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &i64, bps))
- return false; /* read_callback_ sets the state for us */
- subframe->warmup[u] = i64;
- }
-
- /* read qlp coeff precision */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN))
- return false; /* read_callback_ sets the state for us */
- if(u32 == (1u << FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN) - 1) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- subframe->qlp_coeff_precision = u32+1;
-
- /* read qlp shift */
- if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i32, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN))
- return false; /* read_callback_ sets the state for us */
- if(i32 < 0) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- subframe->quantization_level = i32;
-
- /* read quantized lp coefficiencts */
- for(u = 0; u < order; u++) {
- if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i32, subframe->qlp_coeff_precision))
- return false; /* read_callback_ sets the state for us */
- subframe->qlp_coeff[u] = i32;
- }
-
- /* read entropy coding method info */
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN))
- return false; /* read_callback_ sets the state for us */
- subframe->entropy_coding_method.type = (FLAC__EntropyCodingMethodType)u32;
- switch(subframe->entropy_coding_method.type) {
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2:
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
- return false; /* read_callback_ sets the state for us */
- if((decoder->private_->frame.header.blocksize >> u32 < order) ||
- (decoder->private_->frame.header.blocksize % (1 << u32) > 0)) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- subframe->entropy_coding_method.data.partitioned_rice.order = u32;
- subframe->entropy_coding_method.data.partitioned_rice.contents = &decoder->private_->partitioned_rice_contents[channel];
- break;
- default:
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
-
- /* read residual */
- switch(subframe->entropy_coding_method.type) {
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2:
- if(!read_residual_partitioned_rice_(decoder, order, subframe->entropy_coding_method.data.partitioned_rice.order, &decoder->private_->partitioned_rice_contents[channel], decoder->private_->residual[channel], /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2))
- return false;
- break;
- default:
- FLAC__ASSERT(0);
- }
-
- /* decode the subframe */
- if(do_full_decode) {
- if(bps <= 32) {
- uint32_t i;
- for(i = 0; i < order; i++)
- decoder->private_->output[channel][i] = subframe->warmup[i];
- if(FLAC__lpc_max_residual_bps(bps, subframe->qlp_coeff, order, subframe->quantization_level) <= 32 &&
- FLAC__lpc_max_prediction_before_shift_bps(bps, subframe->qlp_coeff, order) <= 32)
- FLAC__lpc_restore_signal(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, subframe->qlp_coeff, order, subframe->quantization_level, decoder->private_->output[channel]+order);
- else
- FLAC__lpc_restore_signal_wide(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, subframe->qlp_coeff, order, subframe->quantization_level, decoder->private_->output[channel]+order);
- }
- else {
- decoder->private_->side_subframe_in_use = true;
- memcpy(decoder->private_->side_subframe, subframe->warmup, sizeof(FLAC__int64) * order);
- FLAC__lpc_restore_signal_wide_33bit(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, subframe->qlp_coeff, order, subframe->quantization_level, decoder->private_->side_subframe+order);
- }
- }
-
- return true;
-}
-
-FLAC__bool read_subframe_verbatim_(FLAC__StreamDecoder *decoder, uint32_t channel, uint32_t bps, FLAC__bool do_full_decode)
-{
- FLAC__Subframe_Verbatim *subframe = &decoder->private_->frame.subframes[channel].data.verbatim;
- uint32_t i;
-
- decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_VERBATIM;
-
- if(bps < 33) {
- FLAC__int32 x, *residual = decoder->private_->residual[channel];
-
- subframe->data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32;
- subframe->data.int32 = residual;
-
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++) {
- if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &x, bps))
- return false; /* read_callback_ sets the state for us */
- residual[i] = x;
- }
-
- /* decode the subframe */
- if(do_full_decode)
- memcpy(decoder->private_->output[channel], subframe->data.int32, sizeof(FLAC__int32) * decoder->private_->frame.header.blocksize);
- }
- else {
- FLAC__int64 x, *side = decoder->private_->side_subframe;
-
- subframe->data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64;
- subframe->data.int64 = side;
- decoder->private_->side_subframe_in_use = true;
-
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++) {
- if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &x, bps))
- return false; /* read_callback_ sets the state for us */
- side[i] = x;
- }
- }
-
- return true;
-}
-
-FLAC__bool read_residual_partitioned_rice_(FLAC__StreamDecoder *decoder, uint32_t predictor_order, uint32_t partition_order, FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, FLAC__int32 *residual, FLAC__bool is_extended)
-{
- FLAC__uint32 rice_parameter;
- int i;
- uint32_t partition, sample, u;
- const uint32_t partitions = 1u << partition_order;
- const uint32_t partition_samples = decoder->private_->frame.header.blocksize >> partition_order;
- const uint32_t plen = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN;
- const uint32_t pesc = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER;
-
- /* invalid predictor and partition orders mush be handled in the callers */
- FLAC__ASSERT(partition_order > 0? partition_samples >= predictor_order : decoder->private_->frame.header.blocksize >= predictor_order);
-
- if(!FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(partitioned_rice_contents, flac_max(6u, partition_order))) {
- decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
-
- sample = 0;
- for(partition = 0; partition < partitions; partition++) {
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &rice_parameter, plen))
- return false; /* read_callback_ sets the state for us */
- partitioned_rice_contents->parameters[partition] = rice_parameter;
- if(rice_parameter < pesc) {
- partitioned_rice_contents->raw_bits[partition] = 0;
- u = (partition == 0) ? partition_samples - predictor_order : partition_samples;
- if(!decoder->private_->local_bitreader_read_rice_signed_block(decoder->private_->input, residual + sample, u, rice_parameter)){
- if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME) {
- /* no error was set, read_callback_ didn't set it, so
- * invalid rice symbol was found */
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- return true;
- }
- else
- return false; /* read_callback_ sets the state for us */
- }
- sample += u;
- }
- else {
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN))
- return false; /* read_callback_ sets the state for us */
- partitioned_rice_contents->raw_bits[partition] = rice_parameter;
- if(rice_parameter == 0) {
- for(u = (partition == 0)? predictor_order : 0; u < partition_samples; u++, sample++)
- residual[sample] = 0;
- }
- else{
- for(u = (partition == 0)? predictor_order : 0; u < partition_samples; u++, sample++) {
- if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i, rice_parameter))
- return false; /* read_callback_ sets the state for us */
- residual[sample] = i;
- }
- }
- }
- }
-
- return true;
-}
-
-FLAC__bool read_zero_padding_(FLAC__StreamDecoder *decoder)
-{
- if(!FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)) {
- FLAC__uint32 zero = 0;
- if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &zero, FLAC__bitreader_bits_left_for_byte_alignment(decoder->private_->input)))
- return false; /* read_callback_ sets the state for us */
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
- if(zero != 0) {
- send_error_to_client_(decoder, FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC);
- decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC;
- }
-#endif
- }
- return true;
-}
-
-FLAC__bool read_callback_(FLAC__byte buffer[], size_t *bytes, void *client_data)
-{
- FLAC__StreamDecoder *decoder = (FLAC__StreamDecoder *)client_data;
-
- if(
-#if FLAC__HAS_OGG
- /* see [1] HACK NOTE below for why we don't call the eof_callback when decoding Ogg FLAC */
- !decoder->private_->is_ogg &&
-#endif
- decoder->private_->eof_callback && decoder->private_->eof_callback(decoder, decoder->private_->client_data)
- ) {
- *bytes = 0;
- decoder->protected_->state = FLAC__STREAM_DECODER_END_OF_STREAM;
- return false;
- }
- else if(*bytes > 0) {
- /* While seeking, it is possible for our seek to land in the
- * middle of audio data that looks exactly like a frame header
- * from a future version of an encoder. When that happens, our
- * error callback will get an
- * FLAC__STREAM_DECODER_UNPARSEABLE_STREAM and increment its
- * unparseable_frame_count. But there is a remote possibility
- * that it is properly synced at such a "future-codec frame",
- * so to make sure, we wait to see many "unparseable" errors in
- * a row before bailing out.
- */
- if(decoder->private_->is_seeking && decoder->private_->unparseable_frame_count > 20) {
- decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED;
- return false;
- }
- else {
- const FLAC__StreamDecoderReadStatus status =
-#if FLAC__HAS_OGG
- decoder->private_->is_ogg?
- read_callback_ogg_aspect_(decoder, buffer, bytes) :
-#endif
- decoder->private_->read_callback(decoder, buffer, bytes, decoder->private_->client_data)
- ;
- if(status == FLAC__STREAM_DECODER_READ_STATUS_ABORT) {
- decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED;
- return false;
- }
- else if(*bytes == 0) {
- if(
- status == FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM ||
- (
-#if FLAC__HAS_OGG
- /* see [1] HACK NOTE below for why we don't call the eof_callback when decoding Ogg FLAC */
- !decoder->private_->is_ogg &&
-#endif
- decoder->private_->eof_callback && decoder->private_->eof_callback(decoder, decoder->private_->client_data)
- )
- ) {
- decoder->protected_->state = FLAC__STREAM_DECODER_END_OF_STREAM;
- return false;
- }
- else
- return true;
- }
- else
- return true;
- }
- }
- else {
- /* abort to avoid a deadlock */
- decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED;
- return false;
- }
- /* [1] @@@ HACK NOTE: The end-of-stream checking has to be hacked around
- * for Ogg FLAC. This is because the ogg decoder aspect can lose sync
- * and at the same time hit the end of the stream (for example, seeking
- * to a point that is after the beginning of the last Ogg page). There
- * is no way to report an Ogg sync loss through the callbacks (see note
- * in read_callback_ogg_aspect_()) so it returns CONTINUE with *bytes==0.
- * So to keep the decoder from stopping at this point we gate the call
- * to the eof_callback and let the Ogg decoder aspect set the
- * end-of-stream state when it is needed.
- */
-}
-
-#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && !defined(FUZZING_BUILD_MODE_FLAC_SANITIZE_SIGNED_INTEGER_OVERFLOW)
-/* The attribute below is to silence the undefined sanitizer of oss-fuzz.
- * Because fuzzing feeds bogus predictors and residual samples to the
- * decoder, having overflows in this section is unavoidable. Also,
- * because the calculated values are audio path only, there is no
- * potential for security problems */
-__attribute__((no_sanitize("signed-integer-overflow")))
-#endif
-void undo_channel_coding(FLAC__StreamDecoder *decoder) {
- uint32_t i;
- switch(decoder->private_->frame.header.channel_assignment) {
- case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
- /* do nothing */
- break;
- case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
- FLAC__ASSERT(decoder->private_->frame.header.channels == 2);
- FLAC__ASSERT(decoder->private_->side_subframe_in_use != /* logical XOR */ (decoder->private_->frame.header.bits_per_sample < 32));
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++)
- if(decoder->private_->side_subframe_in_use)
- decoder->private_->output[1][i] = decoder->private_->output[0][i] - decoder->private_->side_subframe[i];
- else
- decoder->private_->output[1][i] = decoder->private_->output[0][i] - decoder->private_->output[1][i];
- break;
- case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
- FLAC__ASSERT(decoder->private_->frame.header.channels == 2);
- FLAC__ASSERT(decoder->private_->side_subframe_in_use != /* logical XOR */ (decoder->private_->frame.header.bits_per_sample < 32));
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++)
- if(decoder->private_->side_subframe_in_use)
- decoder->private_->output[0][i] = decoder->private_->output[1][i] + decoder->private_->side_subframe[i];
- else
- decoder->private_->output[0][i] += decoder->private_->output[1][i];
- break;
- case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
- FLAC__ASSERT(decoder->private_->frame.header.channels == 2);
- FLAC__ASSERT(decoder->private_->side_subframe_in_use != /* logical XOR */ (decoder->private_->frame.header.bits_per_sample < 32));
- for(i = 0; i < decoder->private_->frame.header.blocksize; i++) {
- if(!decoder->private_->side_subframe_in_use){
- FLAC__int32 mid, side;
- mid = decoder->private_->output[0][i];
- side = decoder->private_->output[1][i];
- mid = ((uint32_t) mid) << 1;
- mid |= (side & 1); /* i.e. if 'side' is odd... */
- decoder->private_->output[0][i] = (mid + side) >> 1;
- decoder->private_->output[1][i] = (mid - side) >> 1;
- }
- else { /* bps == 32 */
- FLAC__int64 mid;
- mid = ((uint64_t)decoder->private_->output[0][i]) << 1;
- mid |= (decoder->private_->side_subframe[i] & 1); /* i.e. if 'side' is odd... */
- decoder->private_->output[0][i] = (mid + decoder->private_->side_subframe[i]) >> 1;
- decoder->private_->output[1][i] = (mid - decoder->private_->side_subframe[i]) >> 1;
- }
- }
- break;
- default:
- FLAC__ASSERT(0);
- break;
- }
-}
-
-#if FLAC__HAS_OGG
-FLAC__StreamDecoderReadStatus read_callback_ogg_aspect_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes)
-{
- switch(FLAC__ogg_decoder_aspect_read_callback_wrapper(&decoder->protected_->ogg_decoder_aspect, buffer, bytes, read_callback_proxy_, decoder, decoder->private_->client_data)) {
- case FLAC__OGG_DECODER_ASPECT_READ_STATUS_OK:
- return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
- /* we don't really have a way to handle lost sync via read
- * callback so we'll let it pass and let the underlying
- * FLAC decoder catch the error
- */
- case FLAC__OGG_DECODER_ASPECT_READ_STATUS_LOST_SYNC:
- return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
- case FLAC__OGG_DECODER_ASPECT_READ_STATUS_END_OF_STREAM:
- return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
- case FLAC__OGG_DECODER_ASPECT_READ_STATUS_NOT_FLAC:
- case FLAC__OGG_DECODER_ASPECT_READ_STATUS_UNSUPPORTED_MAPPING_VERSION:
- case FLAC__OGG_DECODER_ASPECT_READ_STATUS_ABORT:
- case FLAC__OGG_DECODER_ASPECT_READ_STATUS_ERROR:
- case FLAC__OGG_DECODER_ASPECT_READ_STATUS_MEMORY_ALLOCATION_ERROR:
- return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
- default:
- FLAC__ASSERT(0);
- /* double protection */
- return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
- }
-}
-
-FLAC__OggDecoderAspectReadStatus read_callback_proxy_(const void *void_decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
-{
- FLAC__StreamDecoder *decoder = (FLAC__StreamDecoder*)void_decoder;
-
- switch(decoder->private_->read_callback(decoder, buffer, bytes, client_data)) {
- case FLAC__STREAM_DECODER_READ_STATUS_CONTINUE:
- return FLAC__OGG_DECODER_ASPECT_READ_STATUS_OK;
- case FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM:
- return FLAC__OGG_DECODER_ASPECT_READ_STATUS_END_OF_STREAM;
- case FLAC__STREAM_DECODER_READ_STATUS_ABORT:
- return FLAC__OGG_DECODER_ASPECT_READ_STATUS_ABORT;
- default:
- /* double protection: */
- FLAC__ASSERT(0);
- return FLAC__OGG_DECODER_ASPECT_READ_STATUS_ABORT;
- }
-}
-#endif
-
-FLAC__StreamDecoderWriteStatus write_audio_frame_to_client_(FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[])
-{
- decoder->private_->last_frame = *frame; /* save the frame */
- decoder->private_->last_frame_is_set = true;
- if(decoder->private_->is_seeking) {
- FLAC__uint64 this_frame_sample = frame->header.number.sample_number;
- FLAC__uint64 next_frame_sample = this_frame_sample + (FLAC__uint64)frame->header.blocksize;
- FLAC__uint64 target_sample = decoder->private_->target_sample;
-
- FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
-
-#if FLAC__HAS_OGG
- decoder->private_->got_a_frame = true;
-#endif
- if(this_frame_sample <= target_sample && target_sample < next_frame_sample) { /* we hit our target frame */
- uint32_t delta = (uint32_t)(target_sample - this_frame_sample);
- /* kick out of seek mode */
- decoder->private_->is_seeking = false;
- /* shift out the samples before target_sample */
- if(delta > 0) {
- uint32_t channel;
- const FLAC__int32 *newbuffer[FLAC__MAX_CHANNELS];
- for(channel = 0; channel < frame->header.channels; channel++) {
- newbuffer[channel] = buffer[channel] + delta;
- decoder->private_->last_frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_VERBATIM;
- decoder->private_->last_frame.subframes[channel].data.verbatim.data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32;
- decoder->private_->last_frame.subframes[channel].data.verbatim.data.int32 = newbuffer[channel];
- }
- decoder->private_->last_frame.header.blocksize -= delta;
- decoder->private_->last_frame.header.number.sample_number += (FLAC__uint64)delta;
- /* write the relevant samples */
- return decoder->private_->write_callback(decoder, &decoder->private_->last_frame, newbuffer, decoder->private_->client_data);
- }
- else {
- /* write the relevant samples */
- return decoder->private_->write_callback(decoder, frame, buffer, decoder->private_->client_data);
- }
- }
- else {
- return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
- }
- }
- else {
- /*
- * If we never got STREAMINFO, turn off MD5 checking to save
- * cycles since we don't have a sum to compare to anyway
- */
- if(!decoder->private_->has_stream_info)
- decoder->private_->do_md5_checking = false;
- if(decoder->private_->do_md5_checking) {
- if(!FLAC__MD5Accumulate(&decoder->private_->md5context, buffer, frame->header.channels, frame->header.blocksize, (frame->header.bits_per_sample+7) / 8))
- return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
- }
- return decoder->private_->write_callback(decoder, frame, buffer, decoder->private_->client_data);
- }
-}
-
-void send_error_to_client_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status)
-{
- if(!decoder->private_->is_seeking)
- decoder->private_->error_callback(decoder, status, decoder->private_->client_data);
- else if(status == FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM)
- decoder->private_->unparseable_frame_count++;
-}
-
-FLAC__bool seek_to_absolute_sample_(FLAC__StreamDecoder *decoder, FLAC__uint64 stream_length, FLAC__uint64 target_sample)
-{
- FLAC__uint64 first_frame_offset = decoder->private_->first_frame_offset, lower_bound, upper_bound, lower_bound_sample, upper_bound_sample, this_frame_sample;
- FLAC__int64 pos = -1;
- int i;
- uint32_t approx_bytes_per_frame;
- FLAC__bool first_seek = true, seek_from_lower_bound = false;
- const FLAC__uint64 total_samples = FLAC__stream_decoder_get_total_samples(decoder);
- const uint32_t min_blocksize = decoder->private_->stream_info.data.stream_info.min_blocksize;
- const uint32_t max_blocksize = decoder->private_->stream_info.data.stream_info.max_blocksize;
- const uint32_t max_framesize = decoder->private_->stream_info.data.stream_info.max_framesize;
- const uint32_t min_framesize = decoder->private_->stream_info.data.stream_info.min_framesize;
- /* take these from the current frame in case they've changed mid-stream */
- uint32_t channels = FLAC__stream_decoder_get_channels(decoder);
- uint32_t bps = FLAC__stream_decoder_get_bits_per_sample(decoder);
- const FLAC__StreamMetadata_SeekTable *seek_table = decoder->private_->has_seek_table? &decoder->private_->seek_table.data.seek_table : 0;
-
- /* use values from stream info if we didn't decode a frame */
- if(channels == 0)
- channels = decoder->private_->stream_info.data.stream_info.channels;
- if(bps == 0)
- bps = decoder->private_->stream_info.data.stream_info.bits_per_sample;
-
- /* we are just guessing here */
- if(max_framesize > 0)
- approx_bytes_per_frame = (max_framesize + min_framesize) / 2 + 1;
- /*
- * Check if it's a known fixed-blocksize stream. Note that though
- * the spec doesn't allow zeroes in the STREAMINFO block, we may
- * never get a STREAMINFO block when decoding so the value of
- * min_blocksize might be zero.
- */
- else if(min_blocksize == max_blocksize && min_blocksize > 0) {
- /* note there are no () around 'bps/8' to keep precision up since it's an integer calculation */
- approx_bytes_per_frame = min_blocksize * channels * bps/8 + 64;
- }
- else
- approx_bytes_per_frame = 4096 * channels * bps/8 + 64;
-
- /*
- * First, we set an upper and lower bound on where in the
- * stream we will search. For now we take the current position
- * as one bound and, depending on where the target position lies,
- * the beginning of the first frame or the end of the stream as
- * the other bound.
- */
- lower_bound = first_frame_offset;
- lower_bound_sample = 0;
- upper_bound = stream_length;
- upper_bound_sample = total_samples > 0 ? total_samples : target_sample /*estimate it*/;
-
- if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC &&
- decoder->private_->samples_decoded != 0) {
- if(target_sample < decoder->private_->samples_decoded) {
- if(FLAC__stream_decoder_get_decode_position(decoder, &upper_bound))
- upper_bound_sample = decoder->private_->samples_decoded;
- } else {
- if(FLAC__stream_decoder_get_decode_position(decoder, &lower_bound))
- lower_bound_sample = decoder->private_->samples_decoded;
- }
- }
-
- /*
- * Now we refine the bounds if we have a seektable with
- * suitable points. Note that according to the spec they
- * must be ordered by ascending sample number.
- *
- * Note: to protect against invalid seek tables we will ignore points
- * that have frame_samples==0 or sample_number>=total_samples. Also,
- * because math is limited to 64-bit ints, seekpoints with an offset
- * larger than 2^63 (8 exbibyte) are rejected.
- */
- if(seek_table) {
- FLAC__uint64 new_lower_bound = lower_bound;
- FLAC__uint64 new_upper_bound = upper_bound;
- FLAC__uint64 new_lower_bound_sample = lower_bound_sample;
- FLAC__uint64 new_upper_bound_sample = upper_bound_sample;
-
- /* find the closest seek point <= target_sample, if it exists */
- for(i = (int)seek_table->num_points - 1; i >= 0; i--) {
- if(
- seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER &&
- seek_table->points[i].frame_samples > 0 && /* defense against bad seekpoints */
- (total_samples <= 0 || seek_table->points[i].sample_number < total_samples) && /* defense against bad seekpoints */
- seek_table->points[i].sample_number <= target_sample
- )
- break;
- }
- if(i >= 0) { /* i.e. we found a suitable seek point... */
- new_lower_bound = first_frame_offset + seek_table->points[i].stream_offset;
- new_lower_bound_sample = seek_table->points[i].sample_number;
- }
-
- /* find the closest seek point > target_sample, if it exists */
- for(i = 0; i < (int)seek_table->num_points; i++) {
- if(
- seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER &&
- seek_table->points[i].frame_samples > 0 && /* defense against bad seekpoints */
- (total_samples <= 0 || seek_table->points[i].sample_number < total_samples) && /* defense against bad seekpoints */
- seek_table->points[i].sample_number > target_sample
- )
- break;
- }
- if(i < (int)seek_table->num_points) { /* i.e. we found a suitable seek point... */
- new_upper_bound = first_frame_offset + seek_table->points[i].stream_offset;
- new_upper_bound_sample = seek_table->points[i].sample_number;
- }
- /* final protection against unsorted seek tables; keep original values if bogus */
- if(new_upper_bound >= new_lower_bound) {
- lower_bound = new_lower_bound;
- upper_bound = new_upper_bound;
- lower_bound_sample = new_lower_bound_sample;
- upper_bound_sample = new_upper_bound_sample;
- }
- }
-
- FLAC__ASSERT(upper_bound_sample >= lower_bound_sample);
- /* there are 2 insidious ways that the following equality occurs, which
- * we need to fix:
- * 1) total_samples is 0 (unknown) and target_sample is 0
- * 2) total_samples is 0 (unknown) and target_sample happens to be
- * exactly equal to the last seek point in the seek table; this
- * means there is no seek point above it, and upper_bound_samples
- * remains equal to the estimate (of target_samples) we made above
- * in either case it does not hurt to move upper_bound_sample up by 1
- */
- if(upper_bound_sample == lower_bound_sample)
- upper_bound_sample++;
-
- decoder->private_->target_sample = target_sample;
- while(1) {
- /* check whether decoder is still valid so bad state isn't overwritten
- * with seek error */
- if(decoder->protected_->state == FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR ||
- decoder->protected_->state == FLAC__STREAM_DECODER_ABORTED)
- return false;
- /* check if the bounds are still ok */
- if (lower_bound_sample >= upper_bound_sample ||
- lower_bound > upper_bound ||
- upper_bound >= INT64_MAX) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- if(seek_from_lower_bound) {
- pos = lower_bound;
- }
- else {
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- pos = (FLAC__int64)lower_bound + (FLAC__int64)((double)(target_sample - lower_bound_sample) / (double)(upper_bound_sample - lower_bound_sample) * (double)(upper_bound - lower_bound)) - approx_bytes_per_frame;
-#else
- /* a little less accurate: */
- if(upper_bound - lower_bound < 0xffffffff)
- pos = (FLAC__int64)lower_bound + (FLAC__int64)(((target_sample - lower_bound_sample) * (upper_bound - lower_bound)) / (upper_bound_sample - lower_bound_sample)) - approx_bytes_per_frame;
- else { /* @@@ WATCHOUT, ~2TB limit */
- FLAC__uint64 ratio = (1<<16) / (upper_bound_sample - lower_bound_sample);
- pos = (FLAC__int64)lower_bound + (FLAC__int64)((((target_sample - lower_bound_sample)>>8) * ((upper_bound - lower_bound)>>8) * ratio)) - approx_bytes_per_frame;
- }
-#endif
- }
- if(pos >= (FLAC__int64)upper_bound)
- pos = (FLAC__int64)upper_bound - 1;
- if(pos < (FLAC__int64)lower_bound)
- pos = (FLAC__int64)lower_bound;
- if(decoder->private_->seek_callback(decoder, (FLAC__uint64)pos, decoder->private_->client_data) != FLAC__STREAM_DECODER_SEEK_STATUS_OK) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- if(!FLAC__stream_decoder_flush(decoder)) {
- /* above call sets the state for us */
- return false;
- }
- /* Now we need to get a frame. First we need to reset our
- * unparseable_frame_count; if we get too many unparseable
- * frames in a row, the read callback will return
- * FLAC__STREAM_DECODER_READ_STATUS_ABORT, causing
- * FLAC__stream_decoder_process_single() to return false.
- */
- decoder->private_->unparseable_frame_count = 0;
- if(!FLAC__stream_decoder_process_single(decoder) || decoder->protected_->state == FLAC__STREAM_DECODER_ABORTED || 0 == decoder->private_->samples_decoded) {
- /* No frame could be decoded */
- if(decoder->protected_->state != FLAC__STREAM_DECODER_ABORTED && decoder->private_->eof_callback(decoder, decoder->private_->client_data) && !seek_from_lower_bound){
- /* decoder has hit end of stream while processing corrupt
- * frame. To remedy this, try decoding a frame at the lower
- * bound so the seek after that hopefully ends up somewhere
- * else */
- seek_from_lower_bound = true;
- continue;
- }
- else {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- }
- seek_from_lower_bound = false;
-
- /* our write callback will change the state when it gets to the target frame */
- /* actually, we could have got_a_frame if our decoder is at FLAC__STREAM_DECODER_END_OF_STREAM so we need to check for that also */
- if(!decoder->private_->is_seeking)
- break;
-
- FLAC__ASSERT(decoder->private_->last_frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
- this_frame_sample = decoder->private_->last_frame.header.number.sample_number;
-
- if(this_frame_sample + decoder->private_->last_frame.header.blocksize >= upper_bound_sample && !first_seek) {
- if (pos == (FLAC__int64)lower_bound) {
- /* can't move back any more than the first frame, something is fatally wrong */
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- /* our last move backwards wasn't big enough, try again */
- approx_bytes_per_frame = approx_bytes_per_frame? approx_bytes_per_frame * 2 : 16;
- continue;
- }
- /* allow one seek over upper bound, so we can get a correct upper_bound_sample for streams with unknown total_samples */
- first_seek = false;
-
- /* make sure we are not seeking in corrupted stream */
- if (this_frame_sample < lower_bound_sample) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
-
- /* we need to narrow the search */
- if(target_sample < this_frame_sample) {
- upper_bound_sample = this_frame_sample + decoder->private_->last_frame.header.blocksize;
-/*@@@@@@ what will decode position be if at end of stream? */
- if(!FLAC__stream_decoder_get_decode_position(decoder, &upper_bound)) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- approx_bytes_per_frame = (uint32_t)(2 * (upper_bound - pos) / 3 + 16);
- }
- else { /* target_sample >= this_frame_sample + this frame's blocksize */
- lower_bound_sample = this_frame_sample + decoder->private_->last_frame.header.blocksize;
- if(!FLAC__stream_decoder_get_decode_position(decoder, &lower_bound)) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- approx_bytes_per_frame = (uint32_t)(2 * (lower_bound - pos) / 3 + 16);
- }
- }
-
- return true;
-}
-
-#if FLAC__HAS_OGG
-FLAC__bool seek_to_absolute_sample_ogg_(FLAC__StreamDecoder *decoder, FLAC__uint64 stream_length, FLAC__uint64 target_sample)
-{
- FLAC__uint64 left_pos = 0, right_pos = stream_length;
- FLAC__uint64 left_sample = 0, right_sample = FLAC__stream_decoder_get_total_samples(decoder);
- FLAC__uint64 this_frame_sample = (FLAC__uint64)0 - 1;
- FLAC__uint64 pos = 0; /* only initialized to avoid compiler warning */
- FLAC__bool did_a_seek;
- uint32_t iteration = 0;
-
- /* In the first iterations, we will calculate the target byte position
- * by the distance from the target sample to left_sample and
- * right_sample (let's call it "proportional search"). After that, we
- * will switch to binary search.
- */
- uint32_t BINARY_SEARCH_AFTER_ITERATION = 2;
-
- /* We will switch to a linear search once our current sample is less
- * than this number of samples ahead of the target sample
- */
- static const FLAC__uint64 LINEAR_SEARCH_WITHIN_SAMPLES = FLAC__MAX_BLOCK_SIZE * 2;
-
- /* If the total number of samples is unknown, use a large value, and
- * force binary search immediately.
- */
- if(right_sample == 0) {
- right_sample = (FLAC__uint64)(-1);
- BINARY_SEARCH_AFTER_ITERATION = 0;
- }
-
- decoder->private_->target_sample = target_sample;
- for( ; ; iteration++) {
- /* Do sanity checks on bounds */
- if(right_pos <= left_pos || right_pos - left_pos < 9) {
- /* FLAC frame is at least 9 byte in size */
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- if (iteration == 0 || this_frame_sample > target_sample || target_sample - this_frame_sample > LINEAR_SEARCH_WITHIN_SAMPLES) {
- if (iteration >= BINARY_SEARCH_AFTER_ITERATION) {
- pos = (right_pos + left_pos) / 2;
- }
- else {
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- pos = (FLAC__uint64)((double)(target_sample - left_sample) / (double)(right_sample - left_sample) * (double)(right_pos - left_pos));
-#else
- /* a little less accurate: */
- if ((target_sample-left_sample <= 0xffffffff) && (right_pos-left_pos <= 0xffffffff))
- pos = (FLAC__int64)(((target_sample-left_sample) * (right_pos-left_pos)) / (right_sample-left_sample));
- else /* @@@ WATCHOUT, ~2TB limit */
- pos = (FLAC__int64)((((target_sample-left_sample)>>8) * ((right_pos-left_pos)>>8)) / ((right_sample-left_sample)>>16));
-#endif
- /* @@@ TODO: might want to limit pos to some distance
- * before EOF, to make sure we land before the last frame,
- * thereby getting a this_frame_sample and so having a better
- * estimate.
- */
- }
-
- /* physical seek */
- if(decoder->private_->seek_callback((FLAC__StreamDecoder*)decoder, (FLAC__uint64)pos, decoder->private_->client_data) != FLAC__STREAM_DECODER_SEEK_STATUS_OK) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- if(!FLAC__stream_decoder_flush(decoder)) {
- /* above call sets the state for us */
- return false;
- }
- did_a_seek = true;
- }
- else
- did_a_seek = false;
-
- decoder->private_->got_a_frame = false;
- if(!FLAC__stream_decoder_process_single(decoder) ||
- decoder->protected_->state == FLAC__STREAM_DECODER_ABORTED) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- if(!decoder->private_->got_a_frame) {
- if(did_a_seek) {
- /* this can happen if we seek to a point after the last frame; we drop
- * to binary search right away in this case to avoid any wasted
- * iterations of proportional search.
- */
- right_pos = pos;
- BINARY_SEARCH_AFTER_ITERATION = 0;
- }
- else {
- /* this can probably only happen if total_samples is unknown and the
- * target_sample is past the end of the stream
- */
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- }
- /* our write callback will change the state when it gets to the target frame */
- else if(!decoder->private_->is_seeking) {
- break;
- }
- else {
- this_frame_sample = decoder->private_->last_frame.header.number.sample_number;
- FLAC__ASSERT(decoder->private_->last_frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
-
- if (did_a_seek) {
- if (this_frame_sample <= target_sample) {
- /* The 'equal' case should not happen, since
- * FLAC__stream_decoder_process_single()
- * should recognize that it has hit the
- * target sample and we would exit through
- * the 'break' above.
- */
- FLAC__ASSERT(this_frame_sample != target_sample);
-
- left_sample = this_frame_sample;
- /* sanity check to avoid infinite loop */
- if (left_pos == pos) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- left_pos = pos;
- }
- else {
- right_sample = this_frame_sample;
- /* sanity check to avoid infinite loop */
- if (right_pos == pos) {
- decoder->protected_->state = FLAC__STREAM_DECODER_SEEK_ERROR;
- return false;
- }
- right_pos = pos;
- }
- }
- }
- }
-
- return true;
-}
-#endif
-
-#if 0
-FLAC__StreamDecoderReadStatus file_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
-{
- (void)client_data;
-
- if(*bytes > 0) {
- *bytes = fread(buffer, sizeof(FLAC__byte), *bytes, decoder->private_->file);
- if(ferror(decoder->private_->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; /* abort to avoid a deadlock */
-}
-
-FLAC__StreamDecoderSeekStatus file_seek_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
-{
- (void)client_data;
-
- if(decoder->private_->file == stdin)
- return FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED;
- else if(fseeko(decoder->private_->file, (FLAC__off_t)absolute_byte_offset, SEEK_SET) < 0)
- return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
- else
- return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
-}
-
-FLAC__StreamDecoderTellStatus file_tell_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
-{
- FLAC__off_t pos;
- (void)client_data;
-
- if(decoder->private_->file == stdin)
- return FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED;
- else if((pos = ftello(decoder->private_->file)) < 0)
- return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
- else {
- *absolute_byte_offset = (FLAC__uint64)pos;
- return FLAC__STREAM_DECODER_TELL_STATUS_OK;
- }
-}
-
-FLAC__StreamDecoderLengthStatus file_length_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
-{
- struct flac_stat_s filestats;
- (void)client_data;
-
- if(decoder->private_->file == stdin)
- return FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED;
-
-#ifndef FLAC__USE_FILELENGTHI64
- if(flac_fstat(fileno(decoder->private_->file), &filestats) != 0)
-#else
- filestats.st_size = _filelengthi64(fileno(decoder->private_->file));
- if(filestats.st_size < 0)
-#endif
- return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
- else {
- *stream_length = (FLAC__uint64)filestats.st_size;
- return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
- }
-}
-
-FLAC__bool file_eof_callback_(const FLAC__StreamDecoder *decoder, void *client_data)
-{
- (void)client_data;
-
- return feof(decoder->private_->file)? true : false;
-}
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/stream_encoder.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/stream_encoder.c
deleted file mode 100644
index c9af0eb5a9..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/stream_encoder.c
+++ /dev/null
@@ -1,4744 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include
-#include
-#include /* for malloc() */
-#include /* for memcpy() */
-#include /* for off_t */
-#ifdef _WIN32
-#include /* for GetFileType() */
-#include /* for _get_osfhandle() */
-#endif
-#include "../compat.h"
-#include "../assert.h"
-#include "../stream_decoder.h"
-#include "include/protected/stream_encoder.h"
-#include "include/private/bitwriter.h"
-#include "include/private/bitmath.h"
-#include "include/private/crc.h"
-#include "include/private/cpu.h"
-#include "include/private/fixed.h"
-#include "include/private/format.h"
-#include "include/private/lpc.h"
-#include "include/private/md5.h"
-#include "include/private/memory.h"
-
-#if FLAC__HAS_OGG
-#include "include/private/ogg_helper.h"
-#include "include/private/ogg_mapping.h"
-#endif
-#include "include/private/stream_encoder.h"
-#include "include/private/stream_encoder_framing.h"
-#include "include/private/window.h"
-#include "../alloc.h"
-#include "../private.h"
-
-
-/* Exact Rice codeword length calculation is off by default. The simple
- * (and fast) estimation (of how many bits a residual value will be
- * encoded with) in this encoder is very good, almost always yielding
- * compression within 0.1% of exact calculation.
- */
-#undef EXACT_RICE_BITS_CALCULATION
-/* Rice parameter searching is off by default. The simple (and fast)
- * parameter estimation in this encoder is very good, almost always
- * yielding compression within 0.1% of the optimal parameters.
- */
-#undef ENABLE_RICE_PARAMETER_SEARCH
-
-
-typedef struct {
- FLAC__int32 *data[FLAC__MAX_CHANNELS];
- uint32_t size; /* of each data[] in samples */
- uint32_t tail;
-} verify_input_fifo;
-
-typedef struct {
- const FLAC__byte *data;
- uint32_t capacity;
- uint32_t bytes;
-} verify_output;
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-typedef struct {
- uint32_t a, b, c;
- FLAC__ApodizationSpecification * current_apodization;
- double autoc_root[FLAC__MAX_LPC_ORDER+1];
- double autoc[FLAC__MAX_LPC_ORDER+1];
-} apply_apodization_state_struct;
-#endif
-
-typedef enum {
- ENCODER_IN_MAGIC = 0,
- ENCODER_IN_METADATA = 1,
- ENCODER_IN_AUDIO = 2
-} EncoderStateHint;
-
-static const struct CompressionLevels {
- FLAC__bool do_mid_side_stereo;
- FLAC__bool loose_mid_side_stereo;
- uint32_t max_lpc_order;
- uint32_t qlp_coeff_precision;
- FLAC__bool do_qlp_coeff_prec_search;
- FLAC__bool do_escape_coding;
- FLAC__bool do_exhaustive_model_search;
- uint32_t min_residual_partition_order;
- uint32_t max_residual_partition_order;
- uint32_t rice_parameter_search_dist;
- const char *apodization;
-} compression_levels_[] = {
- { false, false, 0, 0, false, false, false, 0, 3, 0, "tukey(5e-1)" },
- { true , true , 0, 0, false, false, false, 0, 3, 0, "tukey(5e-1)" },
- { true , false, 0, 0, false, false, false, 0, 3, 0, "tukey(5e-1)" },
- { false, false, 6, 0, false, false, false, 0, 4, 0, "tukey(5e-1)" },
- { true , true , 8, 0, false, false, false, 0, 4, 0, "tukey(5e-1)" },
- { true , false, 8, 0, false, false, false, 0, 5, 0, "tukey(5e-1)" },
- { true , false, 8, 0, false, false, false, 0, 6, 0, "subdivide_tukey(2)" },
- { true , false, 12, 0, false, false, false, 0, 6, 0, "subdivide_tukey(2)" },
- { true , false, 12, 0, false, false, false, 0, 6, 0, "subdivide_tukey(3)" }
- /* here we use locale-independent 5e-1 instead of 0.5 or 0,5 */
-};
-
-
-/***********************************************************************
- *
- * Private class method prototypes
- *
- ***********************************************************************/
-
-static void set_defaults_(FLAC__StreamEncoder *encoder);
-static void free_(FLAC__StreamEncoder *encoder);
-static FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, uint32_t new_blocksize);
-static FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, uint32_t samples, FLAC__bool is_last_block);
-static FLAC__StreamEncoderWriteStatus write_frame_(FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, FLAC__bool is_last_block);
-static void update_metadata_(const FLAC__StreamEncoder *encoder);
-#if FLAC__HAS_OGG
-static void update_ogg_metadata_(FLAC__StreamEncoder *encoder);
-#endif
-static FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_block);
-static FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder);
-
-static FLAC__bool process_subframe_(
- FLAC__StreamEncoder *encoder,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- const FLAC__FrameHeader *frame_header,
- uint32_t subframe_bps,
- const void *integer_signal,
- FLAC__Subframe *subframe[2],
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2],
- FLAC__int32 *residual[2],
- uint32_t *best_subframe,
- uint32_t *best_bits
-);
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-static FLAC__bool apply_apodization_(
- FLAC__StreamEncoder *encoder,
- apply_apodization_state_struct *apply_apodization_state,
- uint32_t blocksize,
- double *lpc_error,
- uint32_t *max_lpc_order_this_apodization,
- uint32_t subframe_bps,
- const void *integer_signal,
- uint32_t *guess_lpc_order
-);
-#endif
-
-static FLAC__bool add_subframe_(
- FLAC__StreamEncoder *encoder,
- uint32_t blocksize,
- uint32_t subframe_bps,
- const FLAC__Subframe *subframe,
- FLAC__BitWriter *frame
-);
-
-static uint32_t evaluate_constant_subframe_(
- FLAC__StreamEncoder *encoder,
- const FLAC__int64 signal,
- uint32_t blocksize,
- uint32_t subframe_bps,
- FLAC__Subframe *subframe
-);
-
-static uint32_t evaluate_fixed_subframe_(
- FLAC__StreamEncoder *encoder,
- const void *signal,
- FLAC__int32 residual[],
- FLAC__uint64 abs_residual_partition_sums[],
- uint32_t raw_bits_per_partition[],
- uint32_t blocksize,
- uint32_t subframe_bps,
- uint32_t order,
- uint32_t rice_parameter_limit,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- FLAC__bool do_escape_coding,
- uint32_t rice_parameter_search_dist,
- FLAC__Subframe *subframe,
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
-);
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-static uint32_t evaluate_lpc_subframe_(
- FLAC__StreamEncoder *encoder,
- const void *signal,
- FLAC__int32 residual[],
- FLAC__uint64 abs_residual_partition_sums[],
- uint32_t raw_bits_per_partition[],
- const FLAC__real lp_coeff[],
- uint32_t blocksize,
- uint32_t subframe_bps,
- uint32_t order,
- uint32_t qlp_coeff_precision,
- uint32_t rice_parameter_limit,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- FLAC__bool do_escape_coding,
- uint32_t rice_parameter_search_dist,
- FLAC__Subframe *subframe,
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
-);
-#endif
-
-static uint32_t evaluate_verbatim_subframe_(
- FLAC__StreamEncoder *encoder,
- const void *signal,
- uint32_t blocksize,
- uint32_t subframe_bps,
- FLAC__Subframe *subframe
-);
-
-static uint32_t find_best_partition_order_(
- struct FLAC__StreamEncoderPrivate *private_,
- const FLAC__int32 residual[],
- FLAC__uint64 abs_residual_partition_sums[],
- uint32_t raw_bits_per_partition[],
- uint32_t residual_samples,
- uint32_t predictor_order,
- uint32_t rice_parameter_limit,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- uint32_t bps,
- FLAC__bool do_escape_coding,
- uint32_t rice_parameter_search_dist,
- FLAC__EntropyCodingMethod *best_ecm
-);
-
-static void precompute_partition_info_sums_(
- const FLAC__int32 residual[],
- FLAC__uint64 abs_residual_partition_sums[],
- uint32_t residual_samples,
- uint32_t predictor_order,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- uint32_t bps
-);
-
-static void precompute_partition_info_escapes_(
- const FLAC__int32 residual[],
- uint32_t raw_bits_per_partition[],
- uint32_t residual_samples,
- uint32_t predictor_order,
- uint32_t min_partition_order,
- uint32_t max_partition_order
-);
-
-static FLAC__bool set_partitioned_rice_(
-#ifdef EXACT_RICE_BITS_CALCULATION
- const FLAC__int32 residual[],
-#endif
- const FLAC__uint64 abs_residual_partition_sums[],
- const uint32_t raw_bits_per_partition[],
- const uint32_t residual_samples,
- const uint32_t predictor_order,
- const uint32_t rice_parameter_limit,
- const uint32_t rice_parameter_search_dist,
- const uint32_t partition_order,
- const FLAC__bool search_for_escapes,
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents,
- uint32_t *bits
-);
-
-static uint32_t get_wasted_bits_(FLAC__int32 signal[], uint32_t samples);
-static uint32_t get_wasted_bits_wide_(FLAC__int64 signal_wide[], FLAC__int32 signal[], uint32_t samples);
-
-/* verify-related routines: */
-static void append_to_verify_fifo_(
- verify_input_fifo *fifo,
- const FLAC__int32 * const input[],
- uint32_t input_offset,
- uint32_t channels,
- uint32_t wide_samples
-);
-
-static void append_to_verify_fifo_interleaved_(
- verify_input_fifo *fifo,
- const FLAC__int32 input[],
- uint32_t input_offset,
- uint32_t channels,
- uint32_t wide_samples
-);
-
-static FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
-static FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
-static void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
-static void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
-
-//static FLAC__StreamEncoderReadStatus file_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
-//static FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data);
-//static FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
-//static FLAC__StreamEncoderWriteStatus file_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame, void *client_data);
-//static FILE *get_binary_stdout_(void);
-
-
-/***********************************************************************
- *
- * Private class data
- *
- ***********************************************************************/
-
-typedef struct FLAC__StreamEncoderPrivate {
- uint32_t input_capacity; /* current size (in samples) of the signal and residual buffers */
- FLAC__int32 *integer_signal[FLAC__MAX_CHANNELS]; /* the integer version of the input signal */
- FLAC__int32 *integer_signal_mid_side[2]; /* the integer version of the mid-side input signal (stereo only) */
- FLAC__int64 *integer_signal_33bit_side; /* 33-bit side for 32-bit stereo decorrelation */
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- FLAC__real *real_signal[FLAC__MAX_CHANNELS]; /* (@@@ currently unused) the floating-point version of the input signal */
- FLAC__real *real_signal_mid_side[2]; /* (@@@ currently unused) the floating-point version of the mid-side input signal (stereo only) */
- FLAC__real *window[FLAC__MAX_APODIZATION_FUNCTIONS]; /* the pre-computed floating-point window for each apodization function */
- FLAC__real *windowed_signal; /* the integer_signal[] * current window[] */
-#endif
- uint32_t subframe_bps[FLAC__MAX_CHANNELS]; /* the effective bits per sample of the input signal (stream bps - wasted bits) */
- uint32_t subframe_bps_mid_side[2]; /* the effective bits per sample of the mid-side input signal (stream bps - wasted bits + 0/1) */
- FLAC__int32 *residual_workspace[FLAC__MAX_CHANNELS][2]; /* each channel has a candidate and best workspace where the subframe residual signals will be stored */
- FLAC__int32 *residual_workspace_mid_side[2][2];
- FLAC__Subframe subframe_workspace[FLAC__MAX_CHANNELS][2];
- FLAC__Subframe subframe_workspace_mid_side[2][2];
- FLAC__Subframe *subframe_workspace_ptr[FLAC__MAX_CHANNELS][2];
- FLAC__Subframe *subframe_workspace_ptr_mid_side[2][2];
- FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace[FLAC__MAX_CHANNELS][2];
- FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace_mid_side[FLAC__MAX_CHANNELS][2];
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr[FLAC__MAX_CHANNELS][2];
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr_mid_side[FLAC__MAX_CHANNELS][2];
- uint32_t best_subframe[FLAC__MAX_CHANNELS]; /* index (0 or 1) into 2nd dimension of the above workspaces */
- uint32_t best_subframe_mid_side[2];
- uint32_t best_subframe_bits[FLAC__MAX_CHANNELS]; /* size in bits of the best subframe for each channel */
- uint32_t best_subframe_bits_mid_side[2];
- FLAC__uint64 *abs_residual_partition_sums; /* workspace where the sum of abs(candidate residual) for each partition is stored */
- uint32_t *raw_bits_per_partition; /* workspace where the sum of silog2(candidate residual) for each partition is stored */
- FLAC__BitWriter *frame; /* the current frame being worked on */
- uint32_t loose_mid_side_stereo_frames; /* rounded number of frames the encoder will use before trying both independent and mid/side frames again */
- uint32_t loose_mid_side_stereo_frame_count; /* number of frames using the current channel assignment */
- FLAC__ChannelAssignment last_channel_assignment;
- FLAC__StreamMetadata streaminfo; /* scratchpad for STREAMINFO as it is built */
- FLAC__StreamMetadata_SeekTable *seek_table; /* pointer into encoder->protected_->metadata_ where the seek table is */
- uint32_t current_sample_number;
- uint32_t current_frame_number;
- FLAC__MD5Context md5context;
- FLAC__CPUInfo cpuinfo;
- void (*local_precompute_partition_info_sums)(const FLAC__int32 residual[], FLAC__uint64 abs_residual_partition_sums[], uint32_t residual_samples, uint32_t predictor_order, uint32_t min_partition_order, uint32_t max_partition_order, uint32_t bps);
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- uint32_t (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
- uint32_t (*local_fixed_compute_best_predictor_wide)(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
- uint32_t (*local_fixed_compute_best_predictor_limit_residual)(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-#else
- uint32_t (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
- uint32_t (*local_fixed_compute_best_predictor_wide)(const FLAC__int32 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
- uint32_t (*local_fixed_compute_best_predictor_limit_residual)(const FLAC__int32 data[], uint32_t data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
-#endif
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- void (*local_lpc_compute_autocorrelation)(const FLAC__real data[], uint32_t data_len, uint32_t lag, double autoc[]);
- void (*local_lpc_compute_residual_from_qlp_coefficients)(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
- void (*local_lpc_compute_residual_from_qlp_coefficients_64bit)(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
- void (*local_lpc_compute_residual_from_qlp_coefficients_16bit)(const FLAC__int32 *data, uint32_t data_len, const FLAC__int32 qlp_coeff[], uint32_t order, int lp_quantization, FLAC__int32 residual[]);
-#endif
- FLAC__bool disable_mmx;
- FLAC__bool disable_sse2;
- FLAC__bool disable_ssse3;
- FLAC__bool disable_sse41;
- FLAC__bool disable_sse42;
- FLAC__bool disable_avx2;
- FLAC__bool disable_fma;
- FLAC__bool disable_constant_subframes;
- FLAC__bool disable_fixed_subframes;
- FLAC__bool disable_verbatim_subframes;
- FLAC__bool is_ogg;
- FLAC__StreamEncoderReadCallback read_callback; /* currently only needed for Ogg FLAC */
- FLAC__StreamEncoderSeekCallback seek_callback;
- FLAC__StreamEncoderTellCallback tell_callback;
- FLAC__StreamEncoderWriteCallback write_callback;
- FLAC__StreamEncoderMetadataCallback metadata_callback;
- FLAC__StreamEncoderProgressCallback progress_callback;
- void *client_data;
- uint32_t first_seekpoint_to_check;
- FILE *file; /* only used when encoding to a file */
- FLAC__uint64 bytes_written;
- FLAC__uint64 samples_written;
- uint32_t frames_written;
- uint32_t total_frames_estimate;
- /* unaligned (original) pointers to allocated data */
- FLAC__int32 *integer_signal_unaligned[FLAC__MAX_CHANNELS];
- FLAC__int32 *integer_signal_mid_side_unaligned[2];
- FLAC__int64 *integer_signal_33bit_side_unaligned;
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- FLAC__real *real_signal_unaligned[FLAC__MAX_CHANNELS]; /* (@@@ currently unused) */
- FLAC__real *real_signal_mid_side_unaligned[2]; /* (@@@ currently unused) */
- FLAC__real *window_unaligned[FLAC__MAX_APODIZATION_FUNCTIONS];
- FLAC__real *windowed_signal_unaligned;
-#endif
- FLAC__int32 *residual_workspace_unaligned[FLAC__MAX_CHANNELS][2];
- FLAC__int32 *residual_workspace_mid_side_unaligned[2][2];
- FLAC__uint64 *abs_residual_partition_sums_unaligned;
- uint32_t *raw_bits_per_partition_unaligned;
- /*
- * These fields have been moved here from private function local
- * declarations merely to save stack space during encoding.
- */
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- FLAC__real lp_coeff[FLAC__MAX_LPC_ORDER][FLAC__MAX_LPC_ORDER]; /* from process_subframe_() */
-#endif
- FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_extra[2]; /* from find_best_partition_order_() */
- /*
- * The data for the verify section
- */
- struct {
- FLAC__StreamDecoder *decoder;
- EncoderStateHint state_hint;
- FLAC__bool needs_magic_hack;
- verify_input_fifo input_fifo;
- verify_output output;
- struct {
- FLAC__uint64 absolute_sample;
- uint32_t frame_number;
- uint32_t channel;
- uint32_t sample;
- FLAC__int32 expected;
- FLAC__int32 got;
- } error_stats;
- } verify;
- FLAC__bool is_being_deleted; /* if true, call to ..._finish() from ..._delete() will not call the callbacks */
-} FLAC__StreamEncoderPrivate;
-
-/***********************************************************************
- *
- * Public static class data
- *
- ***********************************************************************/
-
-FLAC_API const char * const FLAC__StreamEncoderStateString[] = {
- "FLAC__STREAM_ENCODER_OK",
- "FLAC__STREAM_ENCODER_UNINITIALIZED",
- "FLAC__STREAM_ENCODER_OGG_ERROR",
- "FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR",
- "FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA",
- "FLAC__STREAM_ENCODER_CLIENT_ERROR",
- "FLAC__STREAM_ENCODER_IO_ERROR",
- "FLAC__STREAM_ENCODER_FRAMING_ERROR",
- "FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR"
-};
-
-FLAC_API const char * const FLAC__StreamEncoderInitStatusString[] = {
- "FLAC__STREAM_ENCODER_INIT_STATUS_OK",
- "FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR",
- "FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER",
- "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS",
- "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS",
- "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE",
- "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE",
- "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE",
- "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER",
- "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION",
- "FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER",
- "FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE",
- "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA",
- "FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED"
-};
-
-FLAC_API const char * const FLAC__StreamEncoderReadStatusString[] = {
- "FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE",
- "FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM",
- "FLAC__STREAM_ENCODER_READ_STATUS_ABORT",
- "FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED"
-};
-
-FLAC_API const char * const FLAC__StreamEncoderWriteStatusString[] = {
- "FLAC__STREAM_ENCODER_WRITE_STATUS_OK",
- "FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR"
-};
-
-FLAC_API const char * const FLAC__StreamEncoderSeekStatusString[] = {
- "FLAC__STREAM_ENCODER_SEEK_STATUS_OK",
- "FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR",
- "FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED"
-};
-
-FLAC_API const char * const FLAC__StreamEncoderTellStatusString[] = {
- "FLAC__STREAM_ENCODER_TELL_STATUS_OK",
- "FLAC__STREAM_ENCODER_TELL_STATUS_ERROR",
- "FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED"
-};
-
-/* Number of samples that will be overread to watch for end of stream. By
- * 'overread', we mean that the FLAC__stream_encoder_process*() calls will
- * always try to read blocksize+1 samples before encoding a block, so that
- * even if the stream has a total sample count that is an integral multiple
- * of the blocksize, we will still notice when we are encoding the last
- * block. This is needed, for example, to correctly set the end-of-stream
- * marker in Ogg FLAC.
- *
- * WATCHOUT: some parts of the code assert that OVERREAD_ == 1 and there's
- * not really any reason to change it.
- */
-static const uint32_t OVERREAD_ = 1;
-
-/***********************************************************************
- *
- * Class constructor/destructor
- *
- */
-FLAC_API FLAC__StreamEncoder *FLAC__stream_encoder_new(void)
-{
- FLAC__StreamEncoder *encoder;
- uint32_t i;
-
- FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
-
- encoder = (FLAC__StreamEncoder*) calloc(1, sizeof(FLAC__StreamEncoder));
- if(encoder == 0) {
- return 0;
- }
-
- encoder->protected_ = (FLAC__StreamEncoderProtected*) calloc(1, sizeof(FLAC__StreamEncoderProtected));
- if(encoder->protected_ == 0) {
- free(encoder);
- return 0;
- }
-
- encoder->private_ = (FLAC__StreamEncoderPrivate*) calloc(1, sizeof(FLAC__StreamEncoderPrivate));
- if(encoder->private_ == 0) {
- free(encoder->protected_);
- free(encoder);
- return 0;
- }
-
- encoder->private_->frame = FLAC__bitwriter_new();
- if(encoder->private_->frame == 0) {
- free(encoder->private_);
- free(encoder->protected_);
- free(encoder);
- return 0;
- }
-
- encoder->private_->file = 0;
-
- encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
-
- set_defaults_(encoder);
-
- encoder->private_->is_being_deleted = false;
-
- for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
- encoder->private_->subframe_workspace_ptr[i][0] = &encoder->private_->subframe_workspace[i][0];
- encoder->private_->subframe_workspace_ptr[i][1] = &encoder->private_->subframe_workspace[i][1];
- }
- for(i = 0; i < 2; i++) {
- encoder->private_->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->subframe_workspace_mid_side[i][0];
- encoder->private_->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->subframe_workspace_mid_side[i][1];
- }
- for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
- encoder->private_->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->partitioned_rice_contents_workspace[i][0];
- encoder->private_->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->partitioned_rice_contents_workspace[i][1];
- }
- for(i = 0; i < 2; i++) {
- encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][0] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0];
- encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][1] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1];
- }
-
- for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
- FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][0]);
- FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][1]);
- }
- for(i = 0; i < 2; i++) {
- FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]);
- FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]);
- }
- for(i = 0; i < 2; i++)
- FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_extra[i]);
-
- return encoder;
-}
-
-FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder)
-{
- uint32_t i;
-
- if (encoder == NULL)
- return ;
-
- FLAC__ASSERT(0 != encoder->protected_);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->private_->frame);
-
- encoder->private_->is_being_deleted = true;
-
- (void)FLAC__stream_encoder_finish(encoder);
-
- if(0 != encoder->private_->verify.decoder)
- FLAC__stream_decoder_delete(encoder->private_->verify.decoder);
-
- for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
- FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][0]);
- FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][1]);
- }
- for(i = 0; i < 2; i++) {
- FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]);
- FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]);
- }
- for(i = 0; i < 2; i++)
- FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_extra[i]);
-
- FLAC__bitwriter_delete(encoder->private_->frame);
- free(encoder->private_);
- free(encoder->protected_);
- free(encoder);
-}
-
-/***********************************************************************
- *
- * Public class methods
- *
- ***********************************************************************/
-
-static FLAC__StreamEncoderInitStatus init_stream_internal_(
- FLAC__StreamEncoder *encoder,
- FLAC__StreamEncoderReadCallback read_callback,
- FLAC__StreamEncoderWriteCallback write_callback,
- FLAC__StreamEncoderSeekCallback seek_callback,
- FLAC__StreamEncoderTellCallback tell_callback,
- FLAC__StreamEncoderMetadataCallback metadata_callback,
- void *client_data,
- FLAC__bool is_ogg
-)
-{
- uint32_t i;
- FLAC__bool metadata_has_seektable, metadata_has_vorbis_comment, metadata_picture_has_type1, metadata_picture_has_type2;
-
- FLAC__ASSERT(0 != encoder);
-
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED;
-
- #if FLAC__HAS_OGG == 0
- if(is_ogg)
- return FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER;
- #endif
-
- if(0 == write_callback || (seek_callback && 0 == tell_callback))
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS;
-
- if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS)
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS;
-
- if(encoder->protected_->channels != 2) {
- encoder->protected_->do_mid_side_stereo = false;
- encoder->protected_->loose_mid_side_stereo = false;
- }
- else if(!encoder->protected_->do_mid_side_stereo)
- encoder->protected_->loose_mid_side_stereo = false;
-
- if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__MAX_BITS_PER_SAMPLE)
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE;
-
- if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate))
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE;
-
- if(encoder->protected_->blocksize == 0) {
- if(encoder->protected_->max_lpc_order == 0)
- encoder->protected_->blocksize = 1152;
- else
- encoder->protected_->blocksize = 4096;
- }
-
- if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE)
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE;
-
- if(encoder->protected_->max_lpc_order > FLAC__MAX_LPC_ORDER)
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER;
-
- if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order)
- return FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER;
-
- if(encoder->protected_->qlp_coeff_precision == 0) {
- if(encoder->protected_->bits_per_sample < 16) {
- /* @@@ need some data about how to set this here w.r.t. blocksize and sample rate */
- /* @@@ until then we'll make a guess */
- encoder->protected_->qlp_coeff_precision = flac_max(FLAC__MIN_QLP_COEFF_PRECISION, 2 + encoder->protected_->bits_per_sample / 2);
- }
- else if(encoder->protected_->bits_per_sample == 16) {
- if(encoder->protected_->blocksize <= 192)
- encoder->protected_->qlp_coeff_precision = 7;
- else if(encoder->protected_->blocksize <= 384)
- encoder->protected_->qlp_coeff_precision = 8;
- else if(encoder->protected_->blocksize <= 576)
- encoder->protected_->qlp_coeff_precision = 9;
- else if(encoder->protected_->blocksize <= 1152)
- encoder->protected_->qlp_coeff_precision = 10;
- else if(encoder->protected_->blocksize <= 2304)
- encoder->protected_->qlp_coeff_precision = 11;
- else if(encoder->protected_->blocksize <= 4608)
- encoder->protected_->qlp_coeff_precision = 12;
- else
- encoder->protected_->qlp_coeff_precision = 13;
- }
- else {
- if(encoder->protected_->blocksize <= 384)
- encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-2;
- else if(encoder->protected_->blocksize <= 1152)
- encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-1;
- else
- encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION;
- }
- FLAC__ASSERT(encoder->protected_->qlp_coeff_precision <= FLAC__MAX_QLP_COEFF_PRECISION);
- }
- else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION)
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION;
-
- if(encoder->protected_->streamable_subset) {
- if(!FLAC__format_blocksize_is_subset(encoder->protected_->blocksize, encoder->protected_->sample_rate))
- return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
- if(!FLAC__format_sample_rate_is_subset(encoder->protected_->sample_rate))
- return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
- if(
- encoder->protected_->bits_per_sample != 8 &&
- encoder->protected_->bits_per_sample != 12 &&
- encoder->protected_->bits_per_sample != 16 &&
- encoder->protected_->bits_per_sample != 20 &&
- encoder->protected_->bits_per_sample != 24 &&
- encoder->protected_->bits_per_sample != 32
- )
- return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
- if(encoder->protected_->max_residual_partition_order > FLAC__SUBSET_MAX_RICE_PARTITION_ORDER)
- return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
- if(
- encoder->protected_->sample_rate <= 48000 &&
- (
- encoder->protected_->blocksize > FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ ||
- encoder->protected_->max_lpc_order > FLAC__SUBSET_MAX_LPC_ORDER_48000HZ
- )
- ) {
- return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
- }
- }
-
- if(encoder->protected_->max_residual_partition_order >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
- encoder->protected_->max_residual_partition_order = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1;
- if(encoder->protected_->min_residual_partition_order >= encoder->protected_->max_residual_partition_order)
- encoder->protected_->min_residual_partition_order = encoder->protected_->max_residual_partition_order;
-
-#if FLAC__HAS_OGG
- /* drop any seektable for ogg */
- if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) {
- uint32_t i1;
- for(i1 = 0; i1 < encoder->protected_->num_metadata_blocks; i1++) {
- if(0 != encoder->protected_->metadata[i1] && encoder->protected_->metadata[i1]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
- encoder->protected_->num_metadata_blocks--;
- for( ; i1 < encoder->protected_->num_metadata_blocks; i1++)
- encoder->protected_->metadata[i1] = encoder->protected_->metadata[i1+1];
- break;
- }
- }
- }
- /* reorder metadata if necessary to ensure that any VORBIS_COMMENT is the first, according to the mapping spec */
- if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 1) {
- uint32_t i1;
- for(i1 = 1; i1 < encoder->protected_->num_metadata_blocks; i1++) {
- if(0 != encoder->protected_->metadata[i1] && encoder->protected_->metadata[i1]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
- FLAC__StreamMetadata *vc = encoder->protected_->metadata[i1];
- for( ; i1 > 0; i1--)
- encoder->protected_->metadata[i1] = encoder->protected_->metadata[i1-1];
- encoder->protected_->metadata[0] = vc;
- break;
- }
- }
- }
-#endif
- /* keep track of any SEEKTABLE block */
- if(0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) {
- uint32_t i2;
- for(i2 = 0; i2 < encoder->protected_->num_metadata_blocks; i2++) {
- if(0 != encoder->protected_->metadata[i2] && encoder->protected_->metadata[i2]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
- encoder->private_->seek_table = &encoder->protected_->metadata[i2]->data.seek_table;
- break; /* take only the first one */
- }
- }
- }
-
- /* validate metadata */
- if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0)
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- metadata_has_seektable = false;
- metadata_has_vorbis_comment = false;
- metadata_picture_has_type1 = false;
- metadata_picture_has_type2 = false;
- for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
- const FLAC__StreamMetadata *m = encoder->protected_->metadata[i];
- if(m->type == FLAC__METADATA_TYPE_STREAMINFO)
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- else if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
- if(metadata_has_seektable) /* only one is allowed */
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- metadata_has_seektable = true;
- if(!FLAC__format_seektable_is_legal(&m->data.seek_table))
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- }
- else if(m->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
- if(metadata_has_vorbis_comment) /* only one is allowed */
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- metadata_has_vorbis_comment = true;
- }
- else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
- if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0))
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- }
- else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
- if(!FLAC__format_picture_is_legal(&m->data.picture, /*violation=*/0))
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
- if(metadata_picture_has_type1) /* there should only be 1 per stream */
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- metadata_picture_has_type1 = true;
- /* standard icon must be 32x32 pixel PNG */
- if(
- m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD &&
- (
- (strcmp(m->data.picture.mime_type, "image/png") && strcmp(m->data.picture.mime_type, "-->")) ||
- m->data.picture.width != 32 ||
- m->data.picture.height != 32
- )
- )
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- }
- else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
- if(metadata_picture_has_type2) /* there should only be 1 per stream */
- return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
- metadata_picture_has_type2 = true;
- }
- }
- }
-
- encoder->private_->input_capacity = 0;
- for(i = 0; i < encoder->protected_->channels; i++) {
- encoder->private_->integer_signal_unaligned[i] = encoder->private_->integer_signal[i] = 0;
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- encoder->private_->real_signal_unaligned[i] = encoder->private_->real_signal[i] = 0;
-#endif
- }
- for(i = 0; i < 2; i++) {
- encoder->private_->integer_signal_mid_side_unaligned[i] = encoder->private_->integer_signal_mid_side[i] = 0;
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- encoder->private_->real_signal_mid_side_unaligned[i] = encoder->private_->real_signal_mid_side[i] = 0;
-#endif
- }
- encoder->private_->integer_signal_33bit_side_unaligned = encoder->private_->integer_signal_33bit_side = 0;
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- for(i = 0; i < encoder->protected_->num_apodizations; i++)
- encoder->private_->window_unaligned[i] = encoder->private_->window[i] = 0;
- encoder->private_->windowed_signal_unaligned = encoder->private_->windowed_signal = 0;
-#endif
- for(i = 0; i < encoder->protected_->channels; i++) {
- encoder->private_->residual_workspace_unaligned[i][0] = encoder->private_->residual_workspace[i][0] = 0;
- encoder->private_->residual_workspace_unaligned[i][1] = encoder->private_->residual_workspace[i][1] = 0;
- encoder->private_->best_subframe[i] = 0;
- }
- for(i = 0; i < 2; i++) {
- encoder->private_->residual_workspace_mid_side_unaligned[i][0] = encoder->private_->residual_workspace_mid_side[i][0] = 0;
- encoder->private_->residual_workspace_mid_side_unaligned[i][1] = encoder->private_->residual_workspace_mid_side[i][1] = 0;
- encoder->private_->best_subframe_mid_side[i] = 0;
- }
- encoder->private_->abs_residual_partition_sums_unaligned = encoder->private_->abs_residual_partition_sums = 0;
- encoder->private_->raw_bits_per_partition_unaligned = encoder->private_->raw_bits_per_partition = 0;
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- encoder->private_->loose_mid_side_stereo_frames = (uint32_t)((double)encoder->protected_->sample_rate * 0.4 / (double)encoder->protected_->blocksize + 0.5);
-#else
- /* 26214 is the approximate fixed-point equivalent to 0.4 (0.4 * 2^16) */
- /* sample rate can be up to 1048575 Hz, and thus use 20 bits, so we do the multiply÷ by hand */
- FLAC__ASSERT(FLAC__MAX_SAMPLE_RATE <= 1048575);
- FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535);
- FLAC__ASSERT(encoder->protected_->sample_rate <= 1048575);
- FLAC__ASSERT(encoder->protected_->blocksize <= 65535);
- encoder->private_->loose_mid_side_stereo_frames = (uint32_t)FLAC__fixedpoint_trunc((((FLAC__uint64)(encoder->protected_->sample_rate) * (FLAC__uint64)(26214)) << 16) / (encoder->protected_->blocksize<<16) + FLAC__FP_ONE_HALF);
-#endif
- if(encoder->private_->loose_mid_side_stereo_frames == 0)
- encoder->private_->loose_mid_side_stereo_frames = 1;
- encoder->private_->loose_mid_side_stereo_frame_count = 0;
- encoder->private_->current_sample_number = 0;
- encoder->private_->current_frame_number = 0;
-
- /*
- * get the CPU info and set the function pointers
- */
- FLAC__cpu_info(&encoder->private_->cpuinfo);
- /* remove cpu info as requested by
- * FLAC__stream_encoder_disable_instruction_set */
- if(encoder->private_->disable_mmx)
- encoder->private_->cpuinfo.x86.mmx = false;
- if(encoder->private_->disable_sse2)
- encoder->private_->cpuinfo.x86.sse2 = false;
- if(encoder->private_->disable_ssse3)
- encoder->private_->cpuinfo.x86.ssse3 = false;
- if(encoder->private_->disable_sse41)
- encoder->private_->cpuinfo.x86.sse41 = false;
- if(encoder->private_->disable_sse42)
- encoder->private_->cpuinfo.x86.sse42 = false;
- if(encoder->private_->disable_avx2)
- encoder->private_->cpuinfo.x86.avx2 = false;
- if(encoder->private_->disable_fma)
- encoder->private_->cpuinfo.x86.fma = false;
- /* first default to the non-asm routines */
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
-#endif
- encoder->private_->local_precompute_partition_info_sums = precompute_partition_info_sums_;
- encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor;
- encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide;
- encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual;
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients;
-#endif
- /* now override with asm where appropriate */
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-# ifndef FLAC__NO_ASM
-#if defined FLAC__CPU_ARM64 && FLAC__HAS_NEONINTRIN
-#if FLAC__HAS_A64NEONINTRIN
- if(encoder->protected_->max_lpc_order < 8)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_neon_lag_8;
- else if(encoder->protected_->max_lpc_order < 10)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_neon_lag_10;
- else if(encoder->protected_->max_lpc_order < 14)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_neon_lag_14;
- else
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
-#endif
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_neon;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_neon;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_neon;
-#endif /* defined FLAC__CPU_ARM64 && FLAC__HAS_NEONINTRIN */
-
- if(encoder->private_->cpuinfo.use_asm) {
-# ifdef FLAC__CPU_IA32
- FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32);
-# if FLAC__HAS_X86INTRIN
-# ifdef FLAC__SSE2_SUPPORTED
- if (encoder->private_->cpuinfo.x86.sse2) {
- if(encoder->protected_->max_lpc_order < 8)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_8;
- else if(encoder->protected_->max_lpc_order < 10)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_10;
- else if(encoder->protected_->max_lpc_order < 14)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_14;
-
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse2;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2;
- }
-# endif
-# ifdef FLAC__SSE4_1_SUPPORTED
- if (encoder->private_->cpuinfo.x86.sse41) {
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_sse41;
- }
-# endif
-# ifdef FLAC__AVX2_SUPPORTED
- if (encoder->private_->cpuinfo.x86.avx2) {
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2;
- }
-# endif
-
-# ifdef FLAC__SSE2_SUPPORTED
- if (encoder->private_->cpuinfo.x86.sse2) {
- encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_sse2;
- }
-# endif
-# ifdef FLAC__SSSE3_SUPPORTED
- if (encoder->private_->cpuinfo.x86.ssse3) {
- encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3;
- }
-# endif
-# ifdef FLAC__SSE4_2_SUPPORTED
- if (encoder->private_->cpuinfo.x86.sse42) {
- encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_sse42;
- }
-# endif
-# ifdef FLAC__AVX2_SUPPORTED
- if (encoder->private_->cpuinfo.x86.avx2) {
- encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_avx2;
- encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_avx2;
- }
-# endif
-# endif /* FLAC__HAS_X86INTRIN */
-# elif defined FLAC__CPU_X86_64
- FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_X86_64);
-# if FLAC__HAS_X86INTRIN
-# ifdef FLAC__SSE2_SUPPORTED
- if(encoder->private_->cpuinfo.x86.sse2) { /* For fuzzing */
- if(encoder->protected_->max_lpc_order < 8)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_8;
- else if(encoder->protected_->max_lpc_order < 10)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_10;
- else if(encoder->protected_->max_lpc_order < 14)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_14;
-
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2;
- }
-# endif
-# ifdef FLAC__SSE4_1_SUPPORTED
- if(encoder->private_->cpuinfo.x86.sse41) {
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41;
- }
-# endif
-# ifdef FLAC__AVX2_SUPPORTED
- if(encoder->private_->cpuinfo.x86.avx2) {
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2;
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2;
- }
-# endif
-# ifdef FLAC__FMA_SUPPORTED
- if(encoder->private_->cpuinfo.x86.fma) {
- if(encoder->protected_->max_lpc_order < 8)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_fma_lag_8;
- else if(encoder->protected_->max_lpc_order < 12)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_fma_lag_12;
- else if(encoder->protected_->max_lpc_order < 16)
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_fma_lag_16;
- }
-# endif
-
-
-# ifdef FLAC__SSE2_SUPPORTED
- if(encoder->private_->cpuinfo.x86.sse2) { /* For fuzzing */
- encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_sse2;
- }
-# endif
-# ifdef FLAC__SSSE3_SUPPORTED
- if (encoder->private_->cpuinfo.x86.ssse3) {
- encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3;
- }
-# endif
-# ifdef FLAC__SSE4_2_SUPPORTED
- if (encoder->private_->cpuinfo.x86.sse42) {
- encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_sse42;
- }
-# endif
-# ifdef FLAC__AVX2_SUPPORTED
- if (encoder->private_->cpuinfo.x86.avx2) {
- encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_avx2;
- encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_avx2;
- }
-# endif
-# endif /* FLAC__HAS_X86INTRIN */
-# endif /* FLAC__CPU_... */
- }
-# endif /* !FLAC__NO_ASM */
-
-#endif /* !FLAC__INTEGER_ONLY_LIBRARY */
-#if !defined FLAC__NO_ASM && FLAC__HAS_X86INTRIN
- if(encoder->private_->cpuinfo.use_asm) {
-# if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64)
-# ifdef FLAC__SSE2_SUPPORTED
- if (encoder->private_->cpuinfo.x86.sse2)
- encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_sse2;
-# endif
-# ifdef FLAC__SSSE3_SUPPORTED
- if (encoder->private_->cpuinfo.x86.ssse3)
- encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_ssse3;
-# endif
-# ifdef FLAC__AVX2_SUPPORTED
- if (encoder->private_->cpuinfo.x86.avx2)
- encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_avx2;
-# endif
-# endif /* FLAC__CPU_... */
- }
-#endif /* !FLAC__NO_ASM && FLAC__HAS_X86INTRIN */
-
- /* set state to OK; from here on, errors are fatal and we'll override the state then */
- encoder->protected_->state = FLAC__STREAM_ENCODER_OK;
-
-#if FLAC__HAS_OGG
- encoder->private_->is_ogg = is_ogg;
- if(is_ogg && !FLAC__ogg_encoder_aspect_init(&encoder->protected_->ogg_encoder_aspect)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
-#endif
-
- encoder->private_->read_callback = read_callback;
- encoder->private_->write_callback = write_callback;
- encoder->private_->seek_callback = seek_callback;
- encoder->private_->tell_callback = tell_callback;
- encoder->private_->metadata_callback = metadata_callback;
- encoder->private_->client_data = client_data;
-
- if(!resize_buffers_(encoder, encoder->protected_->blocksize)) {
- /* the above function sets the state for us in case of an error */
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
-
- if(!FLAC__bitwriter_init(encoder->private_->frame)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
-
- /*
- * Set up the verify stuff if necessary
- */
- if(encoder->protected_->verify) {
- /*
- * First, set up the fifo which will hold the
- * original signal to compare against
- */
- encoder->private_->verify.input_fifo.size = encoder->protected_->blocksize+OVERREAD_;
- for(i = 0; i < encoder->protected_->channels; i++) {
- if(0 == (encoder->private_->verify.input_fifo.data[i] = (FLAC__int32*) safe_malloc_mul_2op_p(sizeof(FLAC__int32), /*times*/encoder->private_->verify.input_fifo.size))) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- }
- encoder->private_->verify.input_fifo.tail = 0;
-
- /*
- * Now set up a stream decoder for verification
- */
- if(0 == encoder->private_->verify.decoder) {
- encoder->private_->verify.decoder = FLAC__stream_decoder_new();
- if(0 == encoder->private_->verify.decoder) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- }
-
- if(FLAC__stream_decoder_init_stream(encoder->private_->verify.decoder, verify_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, verify_write_callback_, verify_metadata_callback_, verify_error_callback_, /*client_data=*/encoder) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- }
- encoder->private_->verify.error_stats.absolute_sample = 0;
- encoder->private_->verify.error_stats.frame_number = 0;
- encoder->private_->verify.error_stats.channel = 0;
- encoder->private_->verify.error_stats.sample = 0;
- encoder->private_->verify.error_stats.expected = 0;
- encoder->private_->verify.error_stats.got = 0;
-
- /*
- * These must be done before we write any metadata, because that
- * calls the write_callback, which uses these values.
- */
- encoder->private_->first_seekpoint_to_check = 0;
- encoder->private_->samples_written = 0;
- encoder->protected_->streaminfo_offset = 0;
- encoder->protected_->seektable_offset = 0;
- encoder->protected_->audio_offset = 0;
-
- /*
- * write the stream header
- */
- if(encoder->protected_->verify)
- encoder->private_->verify.state_hint = ENCODER_IN_MAGIC;
- if(!FLAC__bitwriter_write_raw_uint32(encoder->private_->frame, FLAC__STREAM_SYNC, FLAC__STREAM_SYNC_LEN)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
- /* the above function sets the state for us in case of an error */
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
-
- /*
- * write the STREAMINFO metadata block
- */
- if(encoder->protected_->verify)
- encoder->private_->verify.state_hint = ENCODER_IN_METADATA;
- encoder->private_->streaminfo.type = FLAC__METADATA_TYPE_STREAMINFO;
- encoder->private_->streaminfo.is_last = false; /* we will have at a minimum a VORBIS_COMMENT afterwards */
- encoder->private_->streaminfo.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
- encoder->private_->streaminfo.data.stream_info.min_blocksize = encoder->protected_->blocksize; /* this encoder uses the same blocksize for the whole stream */
- encoder->private_->streaminfo.data.stream_info.max_blocksize = encoder->protected_->blocksize;
- encoder->private_->streaminfo.data.stream_info.min_framesize = 0; /* we don't know this yet; have to fill it in later */
- encoder->private_->streaminfo.data.stream_info.max_framesize = 0; /* we don't know this yet; have to fill it in later */
- encoder->private_->streaminfo.data.stream_info.sample_rate = encoder->protected_->sample_rate;
- encoder->private_->streaminfo.data.stream_info.channels = encoder->protected_->channels;
- encoder->private_->streaminfo.data.stream_info.bits_per_sample = encoder->protected_->bits_per_sample;
- encoder->private_->streaminfo.data.stream_info.total_samples = encoder->protected_->total_samples_estimate; /* we will replace this later with the real total */
- memset(encoder->private_->streaminfo.data.stream_info.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */
- if(encoder->protected_->do_md5)
- FLAC__MD5Init(&encoder->private_->md5context);
- if(!FLAC__add_metadata_block(&encoder->private_->streaminfo, encoder->private_->frame, true)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
- /* the above function sets the state for us in case of an error */
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
-
- /*
- * Now that the STREAMINFO block is written, we can init this to an
- * absurdly-high value...
- */
- encoder->private_->streaminfo.data.stream_info.min_framesize = (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN) - 1;
- /* ... and clear this to 0 */
- encoder->private_->streaminfo.data.stream_info.total_samples = 0;
-
- /*
- * Check to see if the supplied metadata contains a VORBIS_COMMENT;
- * if not, we will write an empty one (FLAC__add_metadata_block()
- * automatically supplies the vendor string).
- *
- * WATCHOUT: the Ogg FLAC mapping requires us to write this block after
- * the STREAMINFO. (In the case that metadata_has_vorbis_comment is
- * true it will have already insured that the metadata list is properly
- * ordered.)
- */
- if(!metadata_has_vorbis_comment) {
- FLAC__StreamMetadata vorbis_comment;
- vorbis_comment.type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
- vorbis_comment.is_last = (encoder->protected_->num_metadata_blocks == 0);
- vorbis_comment.length = 4 + 4; /* MAGIC NUMBER */
- vorbis_comment.data.vorbis_comment.vendor_string.length = 0;
- vorbis_comment.data.vorbis_comment.vendor_string.entry = 0;
- vorbis_comment.data.vorbis_comment.num_comments = 0;
- vorbis_comment.data.vorbis_comment.comments = 0;
- if(!FLAC__add_metadata_block(&vorbis_comment, encoder->private_->frame, true)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
- /* the above function sets the state for us in case of an error */
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- }
-
- /*
- * write the user's metadata blocks
- */
- for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
- encoder->protected_->metadata[i]->is_last = (i == encoder->protected_->num_metadata_blocks - 1);
- if(!FLAC__add_metadata_block(encoder->protected_->metadata[i], encoder->private_->frame, true)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
- /* the above function sets the state for us in case of an error */
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- }
-
- /* now that all the metadata is written, we save the stream offset */
- if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &encoder->protected_->audio_offset, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) { /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
-
- if(encoder->protected_->verify)
- encoder->private_->verify.state_hint = ENCODER_IN_AUDIO;
-
- return FLAC__STREAM_ENCODER_INIT_STATUS_OK;
-}
-
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_stream(
- FLAC__StreamEncoder *encoder,
- FLAC__StreamEncoderWriteCallback write_callback,
- FLAC__StreamEncoderSeekCallback seek_callback,
- FLAC__StreamEncoderTellCallback tell_callback,
- FLAC__StreamEncoderMetadataCallback metadata_callback,
- void *client_data
-)
-{
- return init_stream_internal_(
- encoder,
- /*read_callback=*/0,
- write_callback,
- seek_callback,
- tell_callback,
- metadata_callback,
- client_data,
- /*is_ogg=*/false
- );
-}
-
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_stream(
- FLAC__StreamEncoder *encoder,
- FLAC__StreamEncoderReadCallback read_callback,
- FLAC__StreamEncoderWriteCallback write_callback,
- FLAC__StreamEncoderSeekCallback seek_callback,
- FLAC__StreamEncoderTellCallback tell_callback,
- FLAC__StreamEncoderMetadataCallback metadata_callback,
- void *client_data
-)
-{
- return init_stream_internal_(
- encoder,
- read_callback,
- write_callback,
- seek_callback,
- tell_callback,
- metadata_callback,
- client_data,
- /*is_ogg=*/true
- );
-}
-
-#if 0
-static FLAC__StreamEncoderInitStatus init_FILE_internal_(
- FLAC__StreamEncoder *encoder,
- FILE *file,
- FLAC__StreamEncoderProgressCallback progress_callback,
- void *client_data,
- FLAC__bool is_ogg
-)
-{
- FLAC__StreamEncoderInitStatus init_status;
-
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != file);
-
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED;
-
- /* double protection */
- if(file == 0) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
-
- /*
- * To make sure that our file does not go unclosed after an error, we
- * must assign the FILE pointer before any further error can occur in
- * this routine.
- */
- if(file == stdout)
- file = get_binary_stdout_(); /* just to be safe */
-
-#ifdef _WIN32
- /*
- * Windows can suffer quite badly from disk fragmentation. This can be
- * reduced significantly by setting the output buffer size to be 10MB.
- */
- if(GetFileType((HANDLE)_get_osfhandle(_fileno(file))) == FILE_TYPE_DISK)
- setvbuf(file, NULL, _IOFBF, 10*1024*1024);
-#endif
- encoder->private_->file = file;
-
- encoder->private_->progress_callback = progress_callback;
- encoder->private_->bytes_written = 0;
- encoder->private_->samples_written = 0;
- encoder->private_->frames_written = 0;
-
- init_status = init_stream_internal_(
- encoder,
- encoder->private_->file == stdout? 0 : is_ogg? file_read_callback_ : 0,
- file_write_callback_,
- encoder->private_->file == stdout? 0 : file_seek_callback_,
- encoder->private_->file == stdout? 0 : file_tell_callback_,
- /*metadata_callback=*/0,
- client_data,
- is_ogg
- );
- if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
- /* the above function sets the state for us in case of an error */
- return init_status;
- }
-
- {
- uint32_t blocksize = FLAC__stream_encoder_get_blocksize(encoder);
-
- FLAC__ASSERT(blocksize != 0);
- encoder->private_->total_frames_estimate = (uint32_t)((FLAC__stream_encoder_get_total_samples_estimate(encoder) + blocksize - 1) / blocksize);
- }
-
- return init_status;
-}
-
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_FILE(
- FLAC__StreamEncoder *encoder,
- FILE *file,
- FLAC__StreamEncoderProgressCallback progress_callback,
- void *client_data
-)
-{
- return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/false);
-}
-
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_FILE(
- FLAC__StreamEncoder *encoder,
- FILE *file,
- FLAC__StreamEncoderProgressCallback progress_callback,
- void *client_data
-)
-{
- return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/true);
-}
-
-static FLAC__StreamEncoderInitStatus init_file_internal_(
- FLAC__StreamEncoder *encoder,
- const char *filename,
- FLAC__StreamEncoderProgressCallback progress_callback,
- void *client_data,
- FLAC__bool is_ogg
-)
-{
- FILE *file;
-
- FLAC__ASSERT(0 != encoder);
-
- /*
- * To make sure that our file does not go unclosed after an error, we
- * have to do the same entrance checks here that are later performed
- * in FLAC__stream_encoder_init_FILE() before the FILE* is assigned.
- */
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED;
-
- file = filename? flac_fopen(filename, "w+b") : stdout;
-
- if(file == 0) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
-
- return init_FILE_internal_(encoder, file, progress_callback, client_data, is_ogg);
-}
-
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_file(
- FLAC__StreamEncoder *encoder,
- const char *filename,
- FLAC__StreamEncoderProgressCallback progress_callback,
- void *client_data
-)
-{
- return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/false);
-}
-
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_file(
- FLAC__StreamEncoder *encoder,
- const char *filename,
- FLAC__StreamEncoderProgressCallback progress_callback,
- void *client_data
-)
-{
- return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/true);
-}
-#endif
-
-FLAC_API FLAC__bool FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder)
-{
- FLAC__bool error = false;
-
- if (encoder == NULL)
- return false;
-
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
-
- if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED){
- if(encoder->protected_->metadata){ // True in case FLAC__stream_encoder_set_metadata was used but init failed
- free(encoder->protected_->metadata);
- encoder->protected_->metadata = 0;
- encoder->protected_->num_metadata_blocks = 0;
- }
- if(0 != encoder->private_->file) {
- if(encoder->private_->file != stdout)
- fclose(encoder->private_->file);
- encoder->private_->file = 0;
- }
- return true;
- }
-
- if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) {
- if(encoder->private_->current_sample_number != 0) {
- encoder->protected_->blocksize = encoder->private_->current_sample_number;
- if(!resize_buffers_(encoder, encoder->protected_->blocksize)) {
- /* the above function sets the state for us in case of an error */
- return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
- }
- if(!process_frame_(encoder, /*is_last_block=*/true))
- error = true;
- }
- }
-
- if(encoder->protected_->do_md5)
- FLAC__MD5Final(encoder->private_->streaminfo.data.stream_info.md5sum, &encoder->private_->md5context);
-
- if(!encoder->private_->is_being_deleted) {
- if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK) {
- if(encoder->private_->seek_callback) {
-#if FLAC__HAS_OGG
- if(encoder->private_->is_ogg)
- update_ogg_metadata_(encoder);
- else
-#endif
- update_metadata_(encoder);
-
- /* check if an error occurred while updating metadata */
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK)
- error = true;
- }
- if(encoder->private_->metadata_callback)
- encoder->private_->metadata_callback(encoder, &encoder->private_->streaminfo, encoder->private_->client_data);
- }
-
- if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder && !FLAC__stream_decoder_finish(encoder->private_->verify.decoder)) {
- if(!error)
- encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA;
- error = true;
- }
- }
-
- if(0 != encoder->private_->file) {
- if(encoder->private_->file != stdout)
- fclose(encoder->private_->file);
- encoder->private_->file = 0;
- }
-
-#if FLAC__HAS_OGG
- if(encoder->private_->is_ogg)
- FLAC__ogg_encoder_aspect_finish(&encoder->protected_->ogg_encoder_aspect);
-#endif
-
- free_(encoder);
- set_defaults_(encoder);
-
- if(!error)
- encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
-
- return !error;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder *encoder, long value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
-#if FLAC__HAS_OGG
- /* can't check encoder->private_->is_ogg since that's not set until init time */
- FLAC__ogg_encoder_aspect_set_serial_number(&encoder->protected_->ogg_encoder_aspect, value);
- return true;
-#else
- (void)value;
- return false;
-#endif
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
-#ifndef FLAC__MANDATORY_VERIFY_WHILE_ENCODING
- encoder->protected_->verify = value;
-#endif
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->streamable_subset = value;
- return true;
-}
-
-/*
- * The following routine was intended as debug routine and is not in the
- * public headers, but SHOULD NOT CHANGE! It is known is is used in
- * some non-audio projects needing every last bit of performance.
- * See https://github.com/xiph/flac/issues/547 for details. These projects
- * provide their own prototype, so changing the signature of this function
- * would break building.
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->do_md5 = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->channels = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->bits_per_sample = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->sample_rate = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__bool ok = true;
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- if(value >= sizeof(compression_levels_)/sizeof(compression_levels_[0]))
- value = sizeof(compression_levels_)/sizeof(compression_levels_[0]) - 1;
- ok &= FLAC__stream_encoder_set_do_mid_side_stereo (encoder, compression_levels_[value].do_mid_side_stereo);
- ok &= FLAC__stream_encoder_set_loose_mid_side_stereo (encoder, compression_levels_[value].loose_mid_side_stereo);
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-#if 1
- ok &= FLAC__stream_encoder_set_apodization (encoder, compression_levels_[value].apodization);
-#else
- /* equivalent to -A tukey(0.5) */
- encoder->protected_->num_apodizations = 1;
- encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
- encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
-#endif
-#endif
- ok &= FLAC__stream_encoder_set_max_lpc_order (encoder, compression_levels_[value].max_lpc_order);
- ok &= FLAC__stream_encoder_set_qlp_coeff_precision (encoder, compression_levels_[value].qlp_coeff_precision);
- ok &= FLAC__stream_encoder_set_do_qlp_coeff_prec_search (encoder, compression_levels_[value].do_qlp_coeff_prec_search);
- ok &= FLAC__stream_encoder_set_do_escape_coding (encoder, compression_levels_[value].do_escape_coding);
- ok &= FLAC__stream_encoder_set_do_exhaustive_model_search (encoder, compression_levels_[value].do_exhaustive_model_search);
- ok &= FLAC__stream_encoder_set_min_residual_partition_order(encoder, compression_levels_[value].min_residual_partition_order);
- ok &= FLAC__stream_encoder_set_max_residual_partition_order(encoder, compression_levels_[value].max_residual_partition_order);
- ok &= FLAC__stream_encoder_set_rice_parameter_search_dist (encoder, compression_levels_[value].rice_parameter_search_dist);
- return ok;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->blocksize = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->do_mid_side_stereo = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->loose_mid_side_stereo = value;
- return true;
-}
-
-/*@@@@add to tests*/
-FLAC_API FLAC__bool FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder *encoder, const char *specification)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- FLAC__ASSERT(0 != specification);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
-#ifdef FLAC__INTEGER_ONLY_LIBRARY
- (void)specification; /* silently ignore since we haven't integerized; will always use a rectangular window */
-#else
- encoder->protected_->num_apodizations = 0;
- while(1) {
- const char *s = strchr(specification, ';');
- const size_t n = s? (size_t)(s - specification) : strlen(specification);
- if (n==8 && 0 == strncmp("bartlett" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT;
- else if(n==13 && 0 == strncmp("bartlett_hann", specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT_HANN;
- else if(n==8 && 0 == strncmp("blackman" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN;
- else if(n==26 && 0 == strncmp("blackman_harris_4term_92db", specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE;
- else if(n==6 && 0 == strncmp("connes" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_CONNES;
- else if(n==7 && 0 == strncmp("flattop" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_FLATTOP;
- else if(n>7 && 0 == strncmp("gauss(" , specification, 6)) {
- FLAC__real stddev = (FLAC__real)strtod(specification+6, 0);
- if (stddev > 0.0 && stddev <= 0.5) {
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.gauss.stddev = stddev;
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_GAUSS;
- }
- }
- else if(n==7 && 0 == strncmp("hamming" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HAMMING;
- else if(n==4 && 0 == strncmp("hann" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HANN;
- else if(n==13 && 0 == strncmp("kaiser_bessel", specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_KAISER_BESSEL;
- else if(n==7 && 0 == strncmp("nuttall" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_NUTTALL;
- else if(n==9 && 0 == strncmp("rectangle" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_RECTANGLE;
- else if(n==8 && 0 == strncmp("triangle" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TRIANGLE;
- else if(n>7 && 0 == strncmp("tukey(" , specification, 6)) {
- FLAC__real p = (FLAC__real)strtod(specification+6, 0);
- if (p >= 0.0 && p <= 1.0) {
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = p;
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
- }
- }
- else if(n>15 && 0 == strncmp("partial_tukey(", specification, 14)) {
- FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+14, 0);
- const char *si_1 = strchr(specification, '/');
- FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.1f;
- FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f;
- const char *si_2 = strchr((si_1?(si_1+1):specification), '/');
- FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f;
-
- if (tukey_parts <= 1) {
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p;
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
- }else if (encoder->protected_->num_apodizations + tukey_parts < 32){
- FLAC__int32 m;
- for(m = 0; m < tukey_parts; m++){
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p;
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units);
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units);
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PARTIAL_TUKEY;
- }
- }
- }
- else if(n>16 && 0 == strncmp("punchout_tukey(", specification, 15)) {
- FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+15, 0);
- const char *si_1 = strchr(specification, '/');
- FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.2f;
- FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f;
- const char *si_2 = strchr((si_1?(si_1+1):specification), '/');
- FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f;
-
- if (tukey_parts <= 1) {
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p;
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
- }else if (encoder->protected_->num_apodizations + tukey_parts < 32){
- FLAC__int32 m;
- for(m = 0; m < tukey_parts; m++){
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p;
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units);
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units);
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PUNCHOUT_TUKEY;
- }
- }
- }
- else if(n>17 && 0 == strncmp("subdivide_tukey(", specification, 16)){
- FLAC__int32 parts = (FLAC__int32)strtod(specification+16, 0);
- if(parts > 1){
- const char *si_1 = strchr(specification, '/');
- FLAC__real p = si_1?(FLAC__real)strtod(si_1+1, 0):5e-1;
- if(p > 1)
- p = 1;
- else if(p < 0)
- p = 0;
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.subdivide_tukey.parts = parts;
- encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.subdivide_tukey.p = p/parts;
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_SUBDIVIDE_TUKEY;
- }
- }
- else if(n==5 && 0 == strncmp("welch" , specification, n))
- encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_WELCH;
- if (encoder->protected_->num_apodizations == 32)
- break;
- if (s)
- specification = s+1;
- else
- break;
- }
- if(encoder->protected_->num_apodizations == 0) {
- encoder->protected_->num_apodizations = 1;
- encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
- encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
- }
-#endif
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->max_lpc_order = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->qlp_coeff_precision = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->do_qlp_coeff_prec_search = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
-#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
- /* was deprecated since FLAC 1.0.4 (24-Sep-2002), but is needed for
- * full spec coverage, so this should be reenabled at some point.
- * For now only enable while fuzzing */
- encoder->protected_->do_escape_coding = value;
-#else
- (void)value;
-#endif
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->do_exhaustive_model_search = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->min_residual_partition_order = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->max_residual_partition_order = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, uint32_t value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
-#if 0
- /*@@@ deprecated: */
- encoder->protected_->rice_parameter_search_dist = value;
-#else
- (void)value;
-#endif
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- value = flac_min(value, (FLAC__uint64)((FLAC__U64L(1) << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN) - 1));
- encoder->protected_->total_samples_estimate = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, uint32_t num_blocks)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- if(0 == metadata)
- num_blocks = 0;
- if(0 == num_blocks)
- metadata = 0;
- /* realloc() does not do exactly what we want so... */
- if(encoder->protected_->metadata) {
- free(encoder->protected_->metadata);
- encoder->protected_->metadata = 0;
- encoder->protected_->num_metadata_blocks = 0;
- }
- if(num_blocks) {
- FLAC__StreamMetadata **m;
- if(0 == (m = (FLAC__StreamMetadata**) safe_malloc_mul_2op_p(sizeof(m[0]), /*times*/num_blocks)))
- return false;
- memcpy(m, metadata, sizeof(m[0]) * num_blocks);
- encoder->protected_->metadata = m;
- encoder->protected_->num_metadata_blocks = num_blocks;
- }
-#if FLAC__HAS_OGG
- if(!FLAC__ogg_encoder_aspect_set_num_metadata(&encoder->protected_->ogg_encoder_aspect, num_blocks))
- return false;
-#endif
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_set_limit_min_bitrate(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->protected_->limit_min_bitrate = value;
- return true;
-}
-
-/*
- * These four functions are not static, but not publicly exposed in
- * include/FLAC/ either. They are used by the test suite and in fuzzing
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_disable_instruction_set(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->private_->disable_mmx = value & 1;
- encoder->private_->disable_sse2 = value & 2;
- encoder->private_->disable_ssse3 = value & 4;
- encoder->private_->disable_sse41 = value & 8;
- encoder->private_->disable_avx2 = value & 16;
- encoder->private_->disable_fma = value & 32;
- encoder->private_->disable_sse42 = value & 64;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->private_->disable_constant_subframes = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->private_->disable_fixed_subframes = value;
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
- return false;
- encoder->private_->disable_verbatim_subframes = value;
- return true;
-}
-
-FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->state;
-}
-
-FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->verify)
- return FLAC__stream_decoder_get_state(encoder->private_->verify.decoder);
- else
- return FLAC__STREAM_DECODER_UNINITIALIZED;
-}
-
-FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR)
- return FLAC__StreamEncoderStateString[encoder->protected_->state];
- else
- return FLAC__stream_decoder_get_resolved_state_string(encoder->private_->verify.decoder);
-}
-
-FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, uint32_t *frame_number, uint32_t *channel, uint32_t *sample, FLAC__int32 *expected, FLAC__int32 *got)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- if(0 != absolute_sample)
- *absolute_sample = encoder->private_->verify.error_stats.absolute_sample;
- if(0 != frame_number)
- *frame_number = encoder->private_->verify.error_stats.frame_number;
- if(0 != channel)
- *channel = encoder->private_->verify.error_stats.channel;
- if(0 != sample)
- *sample = encoder->private_->verify.error_stats.sample;
- if(0 != expected)
- *expected = encoder->private_->verify.error_stats.expected;
- if(0 != got)
- *got = encoder->private_->verify.error_stats.got;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->verify;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->streamable_subset;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_md5(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->do_md5;
-}
-
-FLAC_API uint32_t FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->channels;
-}
-
-FLAC_API uint32_t FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->bits_per_sample;
-}
-
-FLAC_API uint32_t FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->sample_rate;
-}
-
-FLAC_API uint32_t FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->blocksize;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->do_mid_side_stereo;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->loose_mid_side_stereo;
-}
-
-FLAC_API uint32_t FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->max_lpc_order;
-}
-
-FLAC_API uint32_t FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->qlp_coeff_precision;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->do_qlp_coeff_prec_search;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->do_escape_coding;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->do_exhaustive_model_search;
-}
-
-FLAC_API uint32_t FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->min_residual_partition_order;
-}
-
-FLAC_API uint32_t FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->max_residual_partition_order;
-}
-
-FLAC_API uint32_t FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->rice_parameter_search_dist;
-}
-
-FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->total_samples_estimate;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_get_limit_min_bitrate(const FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
- return encoder->protected_->limit_min_bitrate;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], uint32_t samples)
-{
- uint32_t i, j = 0, k = 0, channel;
- const uint32_t channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
- const FLAC__int32 sample_max = INT32_MAX >> (32 - encoder->protected_->bits_per_sample);
- const FLAC__int32 sample_min = INT32_MIN >> (32 - encoder->protected_->bits_per_sample);
-
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
-
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK)
- return false;
-
- do {
- const uint32_t n = flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j);
-
- if(encoder->protected_->verify)
- append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, n);
-
- for(channel = 0; channel < channels; channel++) {
- if (buffer[channel] == NULL) {
- return false;
- }
- for(i = encoder->private_->current_sample_number, k = j; i <= blocksize && k < samples; i++, k++) {
- if(buffer[channel][k] < sample_min || buffer[channel][k] > sample_max){
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return false;
- }
- }
- memcpy(&encoder->private_->integer_signal[channel][encoder->private_->current_sample_number], &buffer[channel][j], sizeof(buffer[channel][0]) * n);
- }
- j += n;
- encoder->private_->current_sample_number += n;
-
- /* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */
- if(encoder->private_->current_sample_number > blocksize) {
- FLAC__ASSERT(encoder->private_->current_sample_number == blocksize+OVERREAD_);
- FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */
- if(!process_frame_(encoder, /*is_last_block=*/false))
- return false;
- /* move unprocessed overread samples to beginnings of arrays */
- for(channel = 0; channel < channels; channel++)
- encoder->private_->integer_signal[channel][0] = encoder->private_->integer_signal[channel][blocksize];
- encoder->private_->current_sample_number = 1;
- }
- } while(j < samples);
-
- return true;
-}
-
-FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], uint32_t samples)
-{
- uint32_t i, j, k, channel;
- const uint32_t channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
- const FLAC__int32 sample_max = INT32_MAX >> (32 - encoder->protected_->bits_per_sample);
- const FLAC__int32 sample_min = INT32_MIN >> (32 - encoder->protected_->bits_per_sample);
-
- FLAC__ASSERT(0 != encoder);
- FLAC__ASSERT(0 != encoder->private_);
- FLAC__ASSERT(0 != encoder->protected_);
-
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK)
- return false;
-
- j = k = 0;
- do {
- if(encoder->protected_->verify)
- append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j));
-
- /* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */
- for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) {
- for(channel = 0; channel < channels; channel++){
- if(buffer[k] < sample_min || buffer[k] > sample_max){
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return false;
- }
- encoder->private_->integer_signal[channel][i] = buffer[k++];
- }
- }
- encoder->private_->current_sample_number = i;
- /* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */
- if(i > blocksize) {
- if(!process_frame_(encoder, /*is_last_block=*/false))
- return false;
- /* move unprocessed overread samples to beginnings of arrays */
- FLAC__ASSERT(i == blocksize+OVERREAD_);
- FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */
- for(channel = 0; channel < channels; channel++)
- encoder->private_->integer_signal[channel][0] = encoder->private_->integer_signal[channel][blocksize];
- encoder->private_->current_sample_number = 1;
- }
- } while(j < samples);
-
- return true;
-}
-
-/***********************************************************************
- *
- * Private class methods
- *
- ***********************************************************************/
-
-void set_defaults_(FLAC__StreamEncoder *encoder)
-{
- FLAC__ASSERT(0 != encoder);
-
-#ifdef FLAC__MANDATORY_VERIFY_WHILE_ENCODING
- encoder->protected_->verify = true;
-#else
- encoder->protected_->verify = false;
-#endif
- encoder->protected_->streamable_subset = true;
- encoder->protected_->do_md5 = true;
- encoder->protected_->do_mid_side_stereo = false;
- encoder->protected_->loose_mid_side_stereo = false;
- encoder->protected_->channels = 2;
- encoder->protected_->bits_per_sample = 16;
- encoder->protected_->sample_rate = 44100;
- encoder->protected_->blocksize = 0;
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- encoder->protected_->num_apodizations = 1;
- encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
- encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
-#endif
- encoder->protected_->max_lpc_order = 0;
- encoder->protected_->qlp_coeff_precision = 0;
- encoder->protected_->do_qlp_coeff_prec_search = false;
- encoder->protected_->do_exhaustive_model_search = false;
- encoder->protected_->do_escape_coding = false;
- encoder->protected_->min_residual_partition_order = 0;
- encoder->protected_->max_residual_partition_order = 0;
- encoder->protected_->rice_parameter_search_dist = 0;
- encoder->protected_->total_samples_estimate = 0;
- encoder->protected_->limit_min_bitrate = false;
- encoder->protected_->metadata = 0;
- encoder->protected_->num_metadata_blocks = 0;
-
- encoder->private_->seek_table = 0;
- encoder->private_->disable_mmx = false;
- encoder->private_->disable_sse2 = false;
- encoder->private_->disable_ssse3 = false;
- encoder->private_->disable_sse41 = false;
- encoder->private_->disable_sse42 = false;
- encoder->private_->disable_avx2 = false;
- encoder->private_->disable_constant_subframes = false;
- encoder->private_->disable_fixed_subframes = false;
- encoder->private_->disable_verbatim_subframes = false;
- encoder->private_->is_ogg = false;
- encoder->private_->read_callback = 0;
- encoder->private_->write_callback = 0;
- encoder->private_->seek_callback = 0;
- encoder->private_->tell_callback = 0;
- encoder->private_->metadata_callback = 0;
- encoder->private_->progress_callback = 0;
- encoder->private_->client_data = 0;
-
-#if FLAC__HAS_OGG
- FLAC__ogg_encoder_aspect_set_defaults(&encoder->protected_->ogg_encoder_aspect);
-#endif
-
- FLAC__stream_encoder_set_compression_level(encoder, 5);
-}
-
-void free_(FLAC__StreamEncoder *encoder)
-{
- uint32_t i, channel;
-
- FLAC__ASSERT(0 != encoder);
- if(encoder->protected_->metadata) {
- free(encoder->protected_->metadata);
- encoder->protected_->metadata = 0;
- encoder->protected_->num_metadata_blocks = 0;
- }
- for(i = 0; i < encoder->protected_->channels; i++) {
- if(0 != encoder->private_->integer_signal_unaligned[i]) {
- free(encoder->private_->integer_signal_unaligned[i]);
- encoder->private_->integer_signal_unaligned[i] = 0;
- }
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- if(0 != encoder->private_->real_signal_unaligned[i]) {
- free(encoder->private_->real_signal_unaligned[i]);
- encoder->private_->real_signal_unaligned[i] = 0;
- }
-#endif
- }
- for(i = 0; i < 2; i++) {
- if(0 != encoder->private_->integer_signal_mid_side_unaligned[i]) {
- free(encoder->private_->integer_signal_mid_side_unaligned[i]);
- encoder->private_->integer_signal_mid_side_unaligned[i] = 0;
- }
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- if(0 != encoder->private_->real_signal_mid_side_unaligned[i]) {
- free(encoder->private_->real_signal_mid_side_unaligned[i]);
- encoder->private_->real_signal_mid_side_unaligned[i] = 0;
- }
-#endif
- }
- if(0 != encoder->private_->integer_signal_33bit_side_unaligned){
- free(encoder->private_->integer_signal_33bit_side_unaligned);
- encoder->private_->integer_signal_33bit_side_unaligned = 0;
- }
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- for(i = 0; i < encoder->protected_->num_apodizations; i++) {
- if(0 != encoder->private_->window_unaligned[i]) {
- free(encoder->private_->window_unaligned[i]);
- encoder->private_->window_unaligned[i] = 0;
- }
- }
- if(0 != encoder->private_->windowed_signal_unaligned) {
- free(encoder->private_->windowed_signal_unaligned);
- encoder->private_->windowed_signal_unaligned = 0;
- }
-#endif
- for(channel = 0; channel < encoder->protected_->channels; channel++) {
- for(i = 0; i < 2; i++) {
- if(0 != encoder->private_->residual_workspace_unaligned[channel][i]) {
- free(encoder->private_->residual_workspace_unaligned[channel][i]);
- encoder->private_->residual_workspace_unaligned[channel][i] = 0;
- }
- }
- }
- for(channel = 0; channel < 2; channel++) {
- for(i = 0; i < 2; i++) {
- if(0 != encoder->private_->residual_workspace_mid_side_unaligned[channel][i]) {
- free(encoder->private_->residual_workspace_mid_side_unaligned[channel][i]);
- encoder->private_->residual_workspace_mid_side_unaligned[channel][i] = 0;
- }
- }
- }
- if(0 != encoder->private_->abs_residual_partition_sums_unaligned) {
- free(encoder->private_->abs_residual_partition_sums_unaligned);
- encoder->private_->abs_residual_partition_sums_unaligned = 0;
- }
- if(0 != encoder->private_->raw_bits_per_partition_unaligned) {
- free(encoder->private_->raw_bits_per_partition_unaligned);
- encoder->private_->raw_bits_per_partition_unaligned = 0;
- }
- if(encoder->protected_->verify) {
- for(i = 0; i < encoder->protected_->channels; i++) {
- if(0 != encoder->private_->verify.input_fifo.data[i]) {
- free(encoder->private_->verify.input_fifo.data[i]);
- encoder->private_->verify.input_fifo.data[i] = 0;
- }
- }
- }
- FLAC__bitwriter_free(encoder->private_->frame);
-}
-
-FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, uint32_t new_blocksize)
-{
- FLAC__bool ok;
- uint32_t i, channel;
-
- FLAC__ASSERT(new_blocksize > 0);
- FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
-
- ok = true;
-
- /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */
- if(new_blocksize > encoder->private_->input_capacity) {
-
- /* WATCHOUT: FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx() and ..._intrin_sse2()
- * require that the input arrays (in our case the integer signals)
- * have a buffer of up to 3 zeroes in front (at negative indices) for
- * alignment purposes; we use 4 in front to keep the data well-aligned.
- */
-
- for(i = 0; ok && i < encoder->protected_->channels; i++) {
- ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize+4+OVERREAD_, &encoder->private_->integer_signal_unaligned[i], &encoder->private_->integer_signal[i]);
- if(ok) {
- memset(encoder->private_->integer_signal[i], 0, sizeof(FLAC__int32)*4);
- encoder->private_->integer_signal[i] += 4;
- }
- }
- for(i = 0; ok && i < 2; i++) {
- ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize+4+OVERREAD_, &encoder->private_->integer_signal_mid_side_unaligned[i], &encoder->private_->integer_signal_mid_side[i]);
- if(ok) {
- memset(encoder->private_->integer_signal_mid_side[i], 0, sizeof(FLAC__int32)*4);
- encoder->private_->integer_signal_mid_side[i] += 4;
- }
- }
- ok = ok && FLAC__memory_alloc_aligned_int64_array(new_blocksize+4+OVERREAD_, &encoder->private_->integer_signal_33bit_side_unaligned, &encoder->private_->integer_signal_33bit_side);
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- if(ok && encoder->protected_->max_lpc_order > 0) {
- for(i = 0; ok && i < encoder->protected_->num_apodizations; i++)
- ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->window_unaligned[i], &encoder->private_->window[i]);
- ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->windowed_signal_unaligned, &encoder->private_->windowed_signal);
- }
-#endif
- for(channel = 0; ok && channel < encoder->protected_->channels; channel++) {
- for(i = 0; ok && i < 2; i++) {
- ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize, &encoder->private_->residual_workspace_unaligned[channel][i], &encoder->private_->residual_workspace[channel][i]);
- }
- }
-
-
- for(channel = 0; ok && channel < encoder->protected_->channels; channel++) {
- for(i = 0; ok && i < 2; i++) {
- ok = ok && FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(&encoder->private_->partitioned_rice_contents_workspace[channel][i], encoder->protected_->max_residual_partition_order);
- ok = ok && FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(&encoder->private_->partitioned_rice_contents_workspace[channel][i], encoder->protected_->max_residual_partition_order);
- }
- }
-
- for(channel = 0; ok && channel < 2; channel++) {
- for(i = 0; ok && i < 2; i++) {
- ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize, &encoder->private_->residual_workspace_mid_side_unaligned[channel][i], &encoder->private_->residual_workspace_mid_side[channel][i]);
- }
- }
-
- for(channel = 0; ok && channel < 2; channel++) {
- for(i = 0; ok && i < 2; i++) {
- ok = ok && FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(&encoder->private_->partitioned_rice_contents_workspace_mid_side[channel][i], encoder->protected_->max_residual_partition_order);
- }
- }
-
- for(i = 0; ok && i < 2; i++) {
- ok = ok && FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(&encoder->private_->partitioned_rice_contents_extra[i], encoder->protected_->max_residual_partition_order);
- }
-
-
- /* the *2 is an approximation to the series 1 + 1/2 + 1/4 + ... that sums tree occupies in a flat array */
- /*@@@ new_blocksize*2 is too pessimistic, but to fix, we need smarter logic because a smaller new_blocksize can actually increase the # of partitions; would require moving this out into a separate function, then checking its capacity against the need of the current blocksize&min/max_partition_order (and maybe predictor order) */
- ok = ok && FLAC__memory_alloc_aligned_uint64_array(new_blocksize * 2, &encoder->private_->abs_residual_partition_sums_unaligned, &encoder->private_->abs_residual_partition_sums);
- if(encoder->protected_->do_escape_coding)
- ok = ok && FLAC__memory_alloc_aligned_uint32_array(new_blocksize * 2, &encoder->private_->raw_bits_per_partition_unaligned, &encoder->private_->raw_bits_per_partition);
-}
- if(ok)
- encoder->private_->input_capacity = new_blocksize;
- else {
- encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
- return ok;
- }
-
-
- /* now adjust the windows if the blocksize has changed */
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- if(encoder->protected_->max_lpc_order > 0 && new_blocksize > 1) {
- for(i = 0; i < encoder->protected_->num_apodizations; i++) {
- switch(encoder->protected_->apodizations[i].type) {
- case FLAC__APODIZATION_BARTLETT:
- FLAC__window_bartlett(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_BARTLETT_HANN:
- FLAC__window_bartlett_hann(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_BLACKMAN:
- FLAC__window_blackman(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE:
- FLAC__window_blackman_harris_4term_92db_sidelobe(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_CONNES:
- FLAC__window_connes(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_FLATTOP:
- FLAC__window_flattop(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_GAUSS:
- FLAC__window_gauss(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.gauss.stddev);
- break;
- case FLAC__APODIZATION_HAMMING:
- FLAC__window_hamming(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_HANN:
- FLAC__window_hann(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_KAISER_BESSEL:
- FLAC__window_kaiser_bessel(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_NUTTALL:
- FLAC__window_nuttall(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_RECTANGLE:
- FLAC__window_rectangle(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_TRIANGLE:
- FLAC__window_triangle(encoder->private_->window[i], new_blocksize);
- break;
- case FLAC__APODIZATION_TUKEY:
- FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p);
- break;
- case FLAC__APODIZATION_PARTIAL_TUKEY:
- FLAC__window_partial_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.multiple_tukey.p, encoder->protected_->apodizations[i].parameters.multiple_tukey.start, encoder->protected_->apodizations[i].parameters.multiple_tukey.end);
- break;
- case FLAC__APODIZATION_PUNCHOUT_TUKEY:
- FLAC__window_punchout_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.multiple_tukey.p, encoder->protected_->apodizations[i].parameters.multiple_tukey.start, encoder->protected_->apodizations[i].parameters.multiple_tukey.end);
- break;
- case FLAC__APODIZATION_SUBDIVIDE_TUKEY:
- FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p);
- break;
- case FLAC__APODIZATION_WELCH:
- FLAC__window_welch(encoder->private_->window[i], new_blocksize);
- break;
- default:
- FLAC__ASSERT(0);
- /* double protection */
- FLAC__window_hann(encoder->private_->window[i], new_blocksize);
- break;
- }
- }
- }
- if (new_blocksize <= FLAC__MAX_LPC_ORDER) {
- /* intrinsics autocorrelation routines do not all handle cases in which lag might be
- * larger than data_len. Lag is one larger than the LPC order */
- encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
- }
-#endif
-
- return true;
-}
-
-FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, uint32_t samples, FLAC__bool is_last_block)
-{
- const FLAC__byte *buffer;
- size_t bytes;
-
- FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame));
-
- if(!FLAC__bitwriter_get_buffer(encoder->private_->frame, &buffer, &bytes)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
-
- if(encoder->protected_->verify) {
- encoder->private_->verify.output.data = buffer;
- encoder->private_->verify.output.bytes = bytes;
- if(encoder->private_->verify.state_hint == ENCODER_IN_MAGIC) {
- encoder->private_->verify.needs_magic_hack = true;
- }
- else {
- if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder)
- || (!is_last_block
- && (FLAC__stream_encoder_get_verify_decoder_state(encoder) == FLAC__STREAM_DECODER_END_OF_STREAM))
- || encoder->protected_->state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR /* Happens when error callback was used */) {
- FLAC__bitwriter_release_buffer(encoder->private_->frame);
- FLAC__bitwriter_clear(encoder->private_->frame);
- if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
- encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
- return false;
- }
- }
- }
-
- if(write_frame_(encoder, buffer, bytes, samples, is_last_block) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
- FLAC__bitwriter_release_buffer(encoder->private_->frame);
- FLAC__bitwriter_clear(encoder->private_->frame);
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return false;
- }
-
- FLAC__bitwriter_release_buffer(encoder->private_->frame);
- FLAC__bitwriter_clear(encoder->private_->frame);
-
- if(samples > 0) {
- encoder->private_->streaminfo.data.stream_info.min_framesize = flac_min((uint32_t) bytes, encoder->private_->streaminfo.data.stream_info.min_framesize);
- encoder->private_->streaminfo.data.stream_info.max_framesize = flac_max((uint32_t) bytes, encoder->private_->streaminfo.data.stream_info.max_framesize);
- }
-
- return true;
-}
-
-FLAC__StreamEncoderWriteStatus write_frame_(FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, FLAC__bool is_last_block)
-{
- FLAC__StreamEncoderWriteStatus status;
- FLAC__uint64 output_position = 0;
-
-#if FLAC__HAS_OGG == 0
- (void)is_last_block;
-#endif
-
- /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */
- if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &output_position, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
- }
-
- /*
- * Watch for the STREAMINFO block and first SEEKTABLE block to go by and store their offsets.
- */
- if(samples == 0) {
- FLAC__MetadataType type = (FLAC__MetadataType) (buffer[0] & 0x7f);
- if(type == FLAC__METADATA_TYPE_STREAMINFO)
- encoder->protected_->streaminfo_offset = output_position;
- else if(type == FLAC__METADATA_TYPE_SEEKTABLE && encoder->protected_->seektable_offset == 0)
- encoder->protected_->seektable_offset = output_position;
- }
-
- /*
- * Mark the current seek point if hit (if audio_offset == 0 that
- * means we're still writing metadata and haven't hit the first
- * frame yet)
- */
- if(0 != encoder->private_->seek_table && encoder->protected_->audio_offset > 0 && encoder->private_->seek_table->num_points > 0) {
- const uint32_t blocksize = FLAC__stream_encoder_get_blocksize(encoder);
- const FLAC__uint64 frame_first_sample = encoder->private_->samples_written;
- const FLAC__uint64 frame_last_sample = frame_first_sample + (FLAC__uint64)blocksize - 1;
- FLAC__uint64 test_sample;
- uint32_t i;
- for(i = encoder->private_->first_seekpoint_to_check; i < encoder->private_->seek_table->num_points; i++) {
- test_sample = encoder->private_->seek_table->points[i].sample_number;
- if(test_sample > frame_last_sample) {
- break;
- }
- else if(test_sample >= frame_first_sample) {
- encoder->private_->seek_table->points[i].sample_number = frame_first_sample;
- encoder->private_->seek_table->points[i].stream_offset = output_position - encoder->protected_->audio_offset;
- encoder->private_->seek_table->points[i].frame_samples = blocksize;
- encoder->private_->first_seekpoint_to_check++;
- /* DO NOT: "break;" and here's why:
- * The seektable template may contain more than one target
- * sample for any given frame; we will keep looping, generating
- * duplicate seekpoints for them, and we'll clean it up later,
- * just before writing the seektable back to the metadata.
- */
- }
- else {
- encoder->private_->first_seekpoint_to_check++;
- }
- }
- }
-
-#if FLAC__HAS_OGG
- if(encoder->private_->is_ogg) {
- status = FLAC__ogg_encoder_aspect_write_callback_wrapper(
- &encoder->protected_->ogg_encoder_aspect,
- buffer,
- bytes,
- samples,
- encoder->private_->current_frame_number,
- is_last_block,
- (FLAC__OggEncoderAspectWriteCallbackProxy)encoder->private_->write_callback,
- encoder,
- encoder->private_->client_data
- );
- }
- else
-#endif
- status = encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data);
-
- if(status == FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
- encoder->private_->bytes_written += bytes;
- encoder->private_->samples_written += samples;
- /* we keep a high watermark on the number of frames written because
- * when the encoder goes back to write metadata, 'current_frame'
- * will drop back to 0.
- */
- encoder->private_->frames_written = flac_max(encoder->private_->frames_written, encoder->private_->current_frame_number+1);
- }
- else
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
-
- return status;
-}
-
-/* Gets called when the encoding process has finished so that we can update the STREAMINFO and SEEKTABLE blocks. */
-void update_metadata_(const FLAC__StreamEncoder *encoder)
-{
- FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)];
- const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo;
- FLAC__uint64 samples = metadata->data.stream_info.total_samples;
- const uint32_t min_framesize = metadata->data.stream_info.min_framesize;
- const uint32_t max_framesize = metadata->data.stream_info.max_framesize;
- const uint32_t bps = metadata->data.stream_info.bits_per_sample;
- FLAC__StreamEncoderSeekStatus seek_status;
-
- FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO);
-
- /* All this is based on intimate knowledge of the stream header
- * layout, but a change to the header format that would break this
- * would also break all streams encoded in the previous format.
- */
-
- /*
- * Write MD5 signature
- */
- {
- const uint32_t md5_offset =
- FLAC__STREAM_METADATA_HEADER_LENGTH +
- (
- FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN
- ) / 8;
-
- if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + md5_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
- if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return;
- }
- if(encoder->private_->write_callback(encoder, metadata->data.stream_info.md5sum, 16, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return;
- }
- }
-
- /*
- * Write total samples
- */
- {
- const uint32_t total_samples_byte_offset =
- FLAC__STREAM_METADATA_HEADER_LENGTH +
- (
- FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
- - 4
- ) / 8;
- if(samples > (FLAC__U64L(1) << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN))
- samples = 0;
-
- b[0] = ((FLAC__byte)(bps-1) << 4) | (FLAC__byte)((samples >> 32) & 0x0F);
- b[1] = (FLAC__byte)((samples >> 24) & 0xFF);
- b[2] = (FLAC__byte)((samples >> 16) & 0xFF);
- b[3] = (FLAC__byte)((samples >> 8) & 0xFF);
- b[4] = (FLAC__byte)(samples & 0xFF);
- if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + total_samples_byte_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
- if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return;
- }
- if(encoder->private_->write_callback(encoder, b, 5, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return;
- }
- }
-
- /*
- * Write min/max framesize
- */
- {
- const uint32_t min_framesize_offset =
- FLAC__STREAM_METADATA_HEADER_LENGTH +
- (
- FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
- ) / 8;
-
- b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF);
- b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF);
- b[2] = (FLAC__byte)(min_framesize & 0xFF);
- b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF);
- b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF);
- b[5] = (FLAC__byte)(max_framesize & 0xFF);
- if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + min_framesize_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
- if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return;
- }
- if(encoder->private_->write_callback(encoder, b, 6, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return;
- }
- }
-
- /*
- * Write seektable
- */
- if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) {
- uint32_t i;
-
- FLAC__format_seektable_sort(encoder->private_->seek_table);
-
- FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table));
-
- if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->seektable_offset + FLAC__STREAM_METADATA_HEADER_LENGTH, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
- if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return;
- }
-
- for(i = 0; i < encoder->private_->seek_table->num_points; i++) {
- FLAC__uint64 xx;
- uint32_t x;
- xx = encoder->private_->seek_table->points[i].sample_number;
- b[7] = (FLAC__byte)xx; xx >>= 8;
- b[6] = (FLAC__byte)xx; xx >>= 8;
- b[5] = (FLAC__byte)xx; xx >>= 8;
- b[4] = (FLAC__byte)xx; xx >>= 8;
- b[3] = (FLAC__byte)xx; xx >>= 8;
- b[2] = (FLAC__byte)xx; xx >>= 8;
- b[1] = (FLAC__byte)xx; xx >>= 8;
- b[0] = (FLAC__byte)xx; xx >>= 8;
- xx = encoder->private_->seek_table->points[i].stream_offset;
- b[15] = (FLAC__byte)xx; xx >>= 8;
- b[14] = (FLAC__byte)xx; xx >>= 8;
- b[13] = (FLAC__byte)xx; xx >>= 8;
- b[12] = (FLAC__byte)xx; xx >>= 8;
- b[11] = (FLAC__byte)xx; xx >>= 8;
- b[10] = (FLAC__byte)xx; xx >>= 8;
- b[9] = (FLAC__byte)xx; xx >>= 8;
- b[8] = (FLAC__byte)xx; xx >>= 8;
- x = encoder->private_->seek_table->points[i].frame_samples;
- b[17] = (FLAC__byte)x; x >>= 8;
- b[16] = (FLAC__byte)x; x >>= 8;
- if(encoder->private_->write_callback(encoder, b, 18, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
- return;
- }
- }
- }
-}
-
-#if FLAC__HAS_OGG
-/* Gets called when the encoding process has finished so that we can update the STREAMINFO and SEEKTABLE blocks. */
-void update_ogg_metadata_(FLAC__StreamEncoder *encoder)
-{
- /* the # of bytes in the 1st packet that precede the STREAMINFO */
- static const uint32_t FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH =
- FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH +
- FLAC__OGG_MAPPING_MAGIC_LENGTH +
- FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH +
- FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH +
- FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH +
- FLAC__STREAM_SYNC_LENGTH
- ;
- FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)];
- const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo;
- const FLAC__uint64 samples = metadata->data.stream_info.total_samples;
- const uint32_t min_framesize = metadata->data.stream_info.min_framesize;
- const uint32_t max_framesize = metadata->data.stream_info.max_framesize;
- ogg_page page;
-
- FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO);
- FLAC__ASSERT(0 != encoder->private_->seek_callback);
-
- /* Pre-check that client supports seeking, since we don't want the
- * ogg_helper code to ever have to deal with this condition.
- */
- if(encoder->private_->seek_callback(encoder, 0, encoder->private_->client_data) == FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED)
- return;
-
- /* All this is based on intimate knowledge of the stream header
- * layout, but a change to the header format that would break this
- * would also break all streams encoded in the previous format.
- */
-
- /**
- ** Write STREAMINFO stats
- **/
- simple_ogg_page__init(&page);
- if(!simple_ogg_page__get_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->read_callback, encoder->private_->client_data)) {
- simple_ogg_page__clear(&page);
- return; /* state already set */
- }
-
- /*
- * Write MD5 signature
- */
- {
- const uint32_t md5_offset =
- FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH +
- FLAC__STREAM_METADATA_HEADER_LENGTH +
- (
- FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN
- ) / 8;
-
- if(md5_offset + 16 > (uint32_t)page.body_len) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
- simple_ogg_page__clear(&page);
- return;
- }
- memcpy(page.body + md5_offset, metadata->data.stream_info.md5sum, 16);
- }
-
- /*
- * Write total samples
- */
- {
- const uint32_t total_samples_byte_offset =
- FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH +
- FLAC__STREAM_METADATA_HEADER_LENGTH +
- (
- FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
- - 4
- ) / 8;
-
- if(total_samples_byte_offset + 5 > (uint32_t)page.body_len) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
- simple_ogg_page__clear(&page);
- return;
- }
- b[0] = (FLAC__byte)page.body[total_samples_byte_offset] & 0xF0;
- b[0] |= (FLAC__byte)((samples >> 32) & 0x0F);
- b[1] = (FLAC__byte)((samples >> 24) & 0xFF);
- b[2] = (FLAC__byte)((samples >> 16) & 0xFF);
- b[3] = (FLAC__byte)((samples >> 8) & 0xFF);
- b[4] = (FLAC__byte)(samples & 0xFF);
- memcpy(page.body + total_samples_byte_offset, b, 5);
- }
-
- /*
- * Write min/max framesize
- */
- {
- const uint32_t min_framesize_offset =
- FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH +
- FLAC__STREAM_METADATA_HEADER_LENGTH +
- (
- FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
- FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
- ) / 8;
-
- if(min_framesize_offset + 6 > (uint32_t)page.body_len) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
- simple_ogg_page__clear(&page);
- return;
- }
- b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF);
- b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF);
- b[2] = (FLAC__byte)(min_framesize & 0xFF);
- b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF);
- b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF);
- b[5] = (FLAC__byte)(max_framesize & 0xFF);
- memcpy(page.body + min_framesize_offset, b, 6);
- }
- if(!simple_ogg_page__set_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->write_callback, encoder->private_->client_data)) {
- simple_ogg_page__clear(&page);
- return; /* state already set */
- }
- simple_ogg_page__clear(&page);
-}
-#endif
-
-FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_block)
-{
- FLAC__uint16 crc;
- FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
-
- /*
- * Accumulate raw signal to the MD5 signature
- */
- if(encoder->protected_->do_md5 && !FLAC__MD5Accumulate(&encoder->private_->md5context, (const FLAC__int32 * const *)encoder->private_->integer_signal, encoder->protected_->channels, encoder->protected_->blocksize, (encoder->protected_->bits_per_sample+7) / 8)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
-
- /*
- * Process the frame header and subframes into the frame bitbuffer
- */
- if(!process_subframes_(encoder)) {
- /* the above function sets the state for us in case of an error */
- return false;
- }
-
- /*
- * Zero-pad the frame to a byte_boundary
- */
- if(!FLAC__bitwriter_zero_pad_to_byte_boundary(encoder->private_->frame)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
-
- /*
- * CRC-16 the whole thing
- */
- FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame));
- if(
- !FLAC__bitwriter_get_write_crc16(encoder->private_->frame, &crc) ||
- !FLAC__bitwriter_write_raw_uint32(encoder->private_->frame, crc, FLAC__FRAME_FOOTER_CRC_LEN)
- ) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
- return false;
- }
-
- /*
- * Write it
- */
- if(!write_bitbuffer_(encoder, encoder->protected_->blocksize, is_last_block)) {
- /* the above function sets the state for us in case of an error */
- return false;
- }
-
- /*
- * Get ready for the next frame
- */
- encoder->private_->current_sample_number = 0;
- encoder->private_->current_frame_number++;
- encoder->private_->streaminfo.data.stream_info.total_samples += (FLAC__uint64)encoder->protected_->blocksize;
-
- return true;
-}
-
-FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder)
-{
- FLAC__FrameHeader frame_header;
- uint32_t channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order;
- FLAC__bool do_independent, do_mid_side, backup_disable_constant_subframes = encoder->private_->disable_constant_subframes, all_subframes_constant = true;
-
- /*
- * Calculate the min,max Rice partition orders
- */
-
- max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize(encoder->protected_->blocksize);
- max_partition_order = flac_min(max_partition_order, encoder->protected_->max_residual_partition_order);
- min_partition_order = flac_min(min_partition_order, max_partition_order);
-
- /*
- * Setup the frame
- */
- frame_header.blocksize = encoder->protected_->blocksize;
- frame_header.sample_rate = encoder->protected_->sample_rate;
- frame_header.channels = encoder->protected_->channels;
- frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */
- frame_header.bits_per_sample = encoder->protected_->bits_per_sample;
- frame_header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER;
- frame_header.number.frame_number = encoder->private_->current_frame_number;
-
- /*
- * Figure out what channel assignments to try
- */
- if(encoder->protected_->do_mid_side_stereo) {
- if(encoder->protected_->loose_mid_side_stereo) {
- if(encoder->private_->loose_mid_side_stereo_frame_count == 0) {
- do_independent = true;
- do_mid_side = true;
- }
- else {
- do_independent = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT);
- do_mid_side = !do_independent;
- }
- }
- else {
- do_independent = true;
- do_mid_side = true;
- }
- }
- else {
- do_independent = true;
- do_mid_side = false;
- }
-
- FLAC__ASSERT(do_independent || do_mid_side);
-
- /*
- * Prepare mid-side signals if applicable
- */
- if(do_mid_side) {
- uint32_t i;
- FLAC__ASSERT(encoder->protected_->channels == 2);
- if(encoder->protected_->bits_per_sample < 32)
- for(i = 0; i < encoder->protected_->blocksize; i++) {
- encoder->private_->integer_signal_mid_side[1][i] = encoder->private_->integer_signal[0][i] - encoder->private_->integer_signal[1][i];
- encoder->private_->integer_signal_mid_side[0][i] = (encoder->private_->integer_signal[0][i] + encoder->private_->integer_signal[1][i]) >> 1; /* NOTE: not the same as 'mid = (signal[0][j] + signal[1][j]) / 2' ! */
- }
- else
- for(i = 0; i <= encoder->protected_->blocksize; i++) {
- encoder->private_->integer_signal_33bit_side[i] = (FLAC__int64)encoder->private_->integer_signal[0][i] - (FLAC__int64)encoder->private_->integer_signal[1][i];
- encoder->private_->integer_signal_mid_side[0][i] = ((FLAC__int64)encoder->private_->integer_signal[0][i] + (FLAC__int64)encoder->private_->integer_signal[1][i]) >> 1; /* NOTE: not the same as 'mid = (signal[0][j] + signal[1][j]) / 2' ! */
- }
- }
-
-
- /*
- * Check for wasted bits; set effective bps for each subframe
- */
- if(do_independent) {
- for(channel = 0; channel < encoder->protected_->channels; channel++) {
- uint32_t w = get_wasted_bits_(encoder->private_->integer_signal[channel], encoder->protected_->blocksize);
- if (w > encoder->protected_->bits_per_sample) {
- w = encoder->protected_->bits_per_sample;
- }
- encoder->private_->subframe_workspace[channel][0].wasted_bits = encoder->private_->subframe_workspace[channel][1].wasted_bits = w;
- encoder->private_->subframe_bps[channel] = encoder->protected_->bits_per_sample - w;
- }
- }
- if(do_mid_side) {
- FLAC__ASSERT(encoder->protected_->channels == 2);
- for(channel = 0; channel < 2; channel++) {
- uint32_t w;
- if(encoder->protected_->bits_per_sample < 32 || channel == 0)
- w = get_wasted_bits_(encoder->private_->integer_signal_mid_side[channel], encoder->protected_->blocksize);
- else
- w = get_wasted_bits_wide_(encoder->private_->integer_signal_33bit_side, encoder->private_->integer_signal_mid_side[channel], encoder->protected_->blocksize);
-
- if (w > encoder->protected_->bits_per_sample) {
- w = encoder->protected_->bits_per_sample;
- }
- encoder->private_->subframe_workspace_mid_side[channel][0].wasted_bits = encoder->private_->subframe_workspace_mid_side[channel][1].wasted_bits = w;
- encoder->private_->subframe_bps_mid_side[channel] = encoder->protected_->bits_per_sample - w + (channel==0? 0:1);
- }
- }
-
- /*
- * First do a normal encoding pass of each independent channel
- */
- if(do_independent) {
- for(channel = 0; channel < encoder->protected_->channels; channel++) {
- if(encoder->protected_->limit_min_bitrate && all_subframes_constant && (channel + 1) == encoder->protected_->channels){
- /* This frame contains only constant subframes at this point.
- * To prevent the frame from becoming too small, make sure
- * the last subframe isn't constant */
- encoder->private_->disable_constant_subframes = true;
- }
- if(!
- process_subframe_(
- encoder,
- min_partition_order,
- max_partition_order,
- &frame_header,
- encoder->private_->subframe_bps[channel],
- encoder->private_->integer_signal[channel],
- encoder->private_->subframe_workspace_ptr[channel],
- encoder->private_->partitioned_rice_contents_workspace_ptr[channel],
- encoder->private_->residual_workspace[channel],
- encoder->private_->best_subframe+channel,
- encoder->private_->best_subframe_bits+channel
- )
- )
- return false;
- if(encoder->private_->subframe_workspace[channel][encoder->private_->best_subframe[channel]].type != FLAC__SUBFRAME_TYPE_CONSTANT)
- all_subframes_constant = false;
- }
- }
-
- /*
- * Now do mid and side channels if requested
- */
- if(do_mid_side) {
- FLAC__ASSERT(encoder->protected_->channels == 2);
-
- for(channel = 0; channel < 2; channel++) {
- void *integer_signal_;
- if(encoder->private_->subframe_bps_mid_side[channel] <= 32)
- integer_signal_ = encoder->private_->integer_signal_mid_side[channel];
- else
- integer_signal_ = encoder->private_->integer_signal_33bit_side;
- if(!
- process_subframe_(
- encoder,
- min_partition_order,
- max_partition_order,
- &frame_header,
- encoder->private_->subframe_bps_mid_side[channel],
- integer_signal_,
- encoder->private_->subframe_workspace_ptr_mid_side[channel],
- encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[channel],
- encoder->private_->residual_workspace_mid_side[channel],
- encoder->private_->best_subframe_mid_side+channel,
- encoder->private_->best_subframe_bits_mid_side+channel
- )
- )
- return false;
- }
- }
-
- /*
- * Compose the frame bitbuffer
- */
- if(do_mid_side) {
- uint32_t left_bps = 0, right_bps = 0; /* initialized only to prevent superfluous compiler warning */
- FLAC__Subframe *left_subframe = 0, *right_subframe = 0; /* initialized only to prevent superfluous compiler warning */
- FLAC__ChannelAssignment channel_assignment;
-
- FLAC__ASSERT(encoder->protected_->channels == 2);
-
- if(encoder->protected_->loose_mid_side_stereo && encoder->private_->loose_mid_side_stereo_frame_count > 0) {
- channel_assignment = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT? FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT : FLAC__CHANNEL_ASSIGNMENT_MID_SIDE);
- }
- else {
- uint32_t bits[4]; /* WATCHOUT - indexed by FLAC__ChannelAssignment */
- uint32_t min_bits;
- int ca;
-
- FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT == 0);
- FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE == 1);
- FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE == 2);
- FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_MID_SIDE == 3);
- FLAC__ASSERT(do_independent && do_mid_side);
-
- /* We have to figure out which channel assignent results in the smallest frame */
- bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = encoder->private_->best_subframe_bits [0] + encoder->private_->best_subframe_bits [1];
- bits[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE ] = encoder->private_->best_subframe_bits [0] + encoder->private_->best_subframe_bits_mid_side[1];
- bits[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE ] = encoder->private_->best_subframe_bits [1] + encoder->private_->best_subframe_bits_mid_side[1];
- bits[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE ] = encoder->private_->best_subframe_bits_mid_side[0] + encoder->private_->best_subframe_bits_mid_side[1];
-
- channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT;
- min_bits = bits[channel_assignment];
-
- /* When doing loose mid-side stereo, ignore left-side
- * and right-side options */
- ca = encoder->protected_->loose_mid_side_stereo ? 3 : 1;
- for( ; ca <= 3; ca++) {
- if(bits[ca] < min_bits) {
- min_bits = bits[ca];
- channel_assignment = (FLAC__ChannelAssignment)ca;
- }
- }
- }
-
- frame_header.channel_assignment = channel_assignment;
-
- if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return false;
- }
-
- switch(channel_assignment) {
- case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
- left_subframe = &encoder->private_->subframe_workspace [0][encoder->private_->best_subframe [0]];
- right_subframe = &encoder->private_->subframe_workspace [1][encoder->private_->best_subframe [1]];
- break;
- case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
- left_subframe = &encoder->private_->subframe_workspace [0][encoder->private_->best_subframe [0]];
- right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
- break;
- case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
- left_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
- right_subframe = &encoder->private_->subframe_workspace [1][encoder->private_->best_subframe [1]];
- break;
- case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
- left_subframe = &encoder->private_->subframe_workspace_mid_side[0][encoder->private_->best_subframe_mid_side[0]];
- right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
- break;
- default:
- FLAC__ASSERT(0);
- }
-
- switch(channel_assignment) {
- case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
- left_bps = encoder->private_->subframe_bps [0];
- right_bps = encoder->private_->subframe_bps [1];
- break;
- case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
- left_bps = encoder->private_->subframe_bps [0];
- right_bps = encoder->private_->subframe_bps_mid_side[1];
- break;
- case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
- left_bps = encoder->private_->subframe_bps_mid_side[1];
- right_bps = encoder->private_->subframe_bps [1];
- break;
- case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
- left_bps = encoder->private_->subframe_bps_mid_side[0];
- right_bps = encoder->private_->subframe_bps_mid_side[1];
- break;
- default:
- FLAC__ASSERT(0);
- }
-
- /* note that encoder_add_subframe_ sets the state for us in case of an error */
- if(!add_subframe_(encoder, frame_header.blocksize, left_bps , left_subframe , encoder->private_->frame))
- return false;
- if(!add_subframe_(encoder, frame_header.blocksize, right_bps, right_subframe, encoder->private_->frame))
- return false;
- }
- else {
- if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return false;
- }
-
- for(channel = 0; channel < encoder->protected_->channels; channel++) {
- if(!add_subframe_(encoder, frame_header.blocksize, encoder->private_->subframe_bps[channel], &encoder->private_->subframe_workspace[channel][encoder->private_->best_subframe[channel]], encoder->private_->frame)) {
- /* the above function sets the state for us in case of an error */
- return false;
- }
- }
- }
-
- if(encoder->protected_->loose_mid_side_stereo) {
- encoder->private_->loose_mid_side_stereo_frame_count++;
- if(encoder->private_->loose_mid_side_stereo_frame_count >= encoder->private_->loose_mid_side_stereo_frames)
- encoder->private_->loose_mid_side_stereo_frame_count = 0;
- }
-
- encoder->private_->last_channel_assignment = frame_header.channel_assignment;
- encoder->private_->disable_constant_subframes = backup_disable_constant_subframes;
-
- return true;
-}
-
-FLAC__bool process_subframe_(
- FLAC__StreamEncoder *encoder,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- const FLAC__FrameHeader *frame_header,
- uint32_t subframe_bps,
- const void *integer_signal,
- FLAC__Subframe *subframe[2],
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2],
- FLAC__int32 *residual[2],
- uint32_t *best_subframe,
- uint32_t *best_bits
-)
-{
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- float fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
-#else
- FLAC__fixedpoint fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
-#endif
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- double lpc_residual_bits_per_sample;
- apply_apodization_state_struct apply_apodization_state;
- double lpc_error[FLAC__MAX_LPC_ORDER];
- uint32_t min_lpc_order, max_lpc_order, lpc_order, guess_lpc_order;
- uint32_t min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision;
-#endif
- uint32_t min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order;
- uint32_t _candidate_bits, _best_bits;
- uint32_t _best_subframe;
- /* only use RICE2 partitions if stream bps > 16 */
- const uint32_t rice_parameter_limit = FLAC__stream_encoder_get_bits_per_sample(encoder) > 16? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER;
-
- FLAC__ASSERT(frame_header->blocksize > 0);
-
- /* verbatim subframe is the baseline against which we measure other compressed subframes */
- _best_subframe = 0;
- if(encoder->private_->disable_verbatim_subframes && frame_header->blocksize >= FLAC__MAX_FIXED_ORDER)
- _best_bits = UINT32_MAX;
- else
- _best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
- *best_bits = _best_bits;
-
- if(frame_header->blocksize > FLAC__MAX_FIXED_ORDER) {
- uint32_t signal_is_constant = false;
- /* The next formula determines when to use a 64-bit accumulator
- * for the error of a fixed predictor, and when a 32-bit one. As
- * the error of a 4th order predictor for a given sample is the
- * sum of 17 sample values (1+4+6+4+1) and there are blocksize -
- * order error values to be summed, the maximum total error is
- * maximum_sample_value * (blocksize - order) * 17. As ilog2(x)
- * calculates floor(2log(x)), the result must be 31 or lower
- */
- if(subframe_bps < 28){
- if(subframe_bps + FLAC__bitmath_ilog2((frame_header->blocksize-FLAC__MAX_FIXED_ORDER)*17) < 32)
- guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor(((FLAC__int32 *)integer_signal)+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample);
- else
- guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor_wide(((FLAC__int32 *)integer_signal)+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample);
- }
- else
- if(subframe_bps <= 32)
- guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor_limit_residual(((FLAC__int32 *)integer_signal+FLAC__MAX_FIXED_ORDER),frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample);
- else
- guess_fixed_order = FLAC__fixed_compute_best_predictor_limit_residual_33bit(((FLAC__int64 *)integer_signal+FLAC__MAX_FIXED_ORDER),frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample);
-
- /* check for constant subframe */
- if(
- !encoder->private_->disable_constant_subframes &&
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- fixed_residual_bits_per_sample[1] == 0.0
-#else
- fixed_residual_bits_per_sample[1] == FLAC__FP_ZERO
-#endif
- ) {
- /* the above means it's possible all samples are the same value; now double-check it: */
- uint32_t i;
- signal_is_constant = true;
- if(subframe_bps <= 32){
- const FLAC__int32 *integer_signal_ = (FLAC__int32*) integer_signal;
- for(i = 1; i < frame_header->blocksize; i++) {
- if(integer_signal_[0] != integer_signal_[i]) {
- signal_is_constant = false;
- break;
- }
- }
- }
- else {
- const FLAC__int64 *integer_signal_ = (FLAC__int64*) integer_signal;
- for(i = 1; i < frame_header->blocksize; i++) {
- if(integer_signal_[0] != integer_signal_[i]) {
- signal_is_constant = false;
- break;
- }
- }
- }
- }
- if(signal_is_constant) {
- if(subframe_bps <= 32)
- _candidate_bits = evaluate_constant_subframe_(encoder, ((FLAC__int32 *)integer_signal)[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]);
- else
- _candidate_bits = evaluate_constant_subframe_(encoder, ((FLAC__int64 *)integer_signal)[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]);
-
- if(_candidate_bits < _best_bits) {
- _best_subframe = !_best_subframe;
- _best_bits = _candidate_bits;
- }
- }
- else {
- if(!encoder->private_->disable_fixed_subframes || (encoder->protected_->max_lpc_order == 0 && _best_bits == UINT_MAX)) {
- /* encode fixed */
- if(encoder->protected_->do_exhaustive_model_search) {
- min_fixed_order = 0;
- max_fixed_order = FLAC__MAX_FIXED_ORDER;
- }
- else {
- min_fixed_order = max_fixed_order = guess_fixed_order;
- }
- if(max_fixed_order >= frame_header->blocksize)
- max_fixed_order = frame_header->blocksize - 1;
- for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) {
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- if(fixed_residual_bits_per_sample[fixed_order] >= (float)subframe_bps)
- continue; /* don't even try */
-#else
- if(FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample[fixed_order]) >= (int)subframe_bps)
- continue; /* don't even try */
-#endif
- _candidate_bits =
- evaluate_fixed_subframe_(
- encoder,
- integer_signal,
- residual[!_best_subframe],
- encoder->private_->abs_residual_partition_sums,
- encoder->private_->raw_bits_per_partition,
- frame_header->blocksize,
- subframe_bps,
- fixed_order,
- rice_parameter_limit,
- min_partition_order,
- max_partition_order,
- encoder->protected_->do_escape_coding,
- encoder->protected_->rice_parameter_search_dist,
- subframe[!_best_subframe],
- partitioned_rice_contents[!_best_subframe]
- );
- if(_candidate_bits < _best_bits) {
- _best_subframe = !_best_subframe;
- _best_bits = _candidate_bits;
- }
- }
- }
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
- /* encode lpc */
- if(encoder->protected_->max_lpc_order > 0) {
- if(encoder->protected_->max_lpc_order >= frame_header->blocksize)
- max_lpc_order = frame_header->blocksize-1;
- else
- max_lpc_order = encoder->protected_->max_lpc_order;
- if(max_lpc_order > 0) {
- apply_apodization_state.a = 0;
- apply_apodization_state.b = 1;
- apply_apodization_state.c = 0;
- while (apply_apodization_state.a < encoder->protected_->num_apodizations) {
- uint32_t max_lpc_order_this_apodization = max_lpc_order;
-
- if(!apply_apodization_(encoder, &apply_apodization_state,
- frame_header->blocksize, lpc_error,
- &max_lpc_order_this_apodization,
- subframe_bps, integer_signal,
- &guess_lpc_order))
- /* If apply_apodization_ fails, try next apodization */
- continue;
-
- if(encoder->protected_->do_exhaustive_model_search) {
- min_lpc_order = 1;
- }
- else {
- min_lpc_order = max_lpc_order_this_apodization = guess_lpc_order;
- }
- for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order_this_apodization; lpc_order++) {
- lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize-lpc_order);
- if(lpc_residual_bits_per_sample >= (double)subframe_bps)
- continue; /* don't even try */
- if(encoder->protected_->do_qlp_coeff_prec_search) {
- min_qlp_coeff_precision = FLAC__MIN_QLP_COEFF_PRECISION;
- /* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps(+1bps for side channel) streams */
- if(subframe_bps <= 17) {
- max_qlp_coeff_precision = flac_min(32 - subframe_bps - FLAC__bitmath_ilog2(lpc_order), FLAC__MAX_QLP_COEFF_PRECISION);
- max_qlp_coeff_precision = flac_max(max_qlp_coeff_precision, min_qlp_coeff_precision);
- }
- else
- max_qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION;
- }
- else {
- min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision;
- }
- for(qlp_coeff_precision = min_qlp_coeff_precision; qlp_coeff_precision <= max_qlp_coeff_precision; qlp_coeff_precision++) {
- _candidate_bits =
- evaluate_lpc_subframe_(
- encoder,
- integer_signal,
- residual[!_best_subframe],
- encoder->private_->abs_residual_partition_sums,
- encoder->private_->raw_bits_per_partition,
- encoder->private_->lp_coeff[lpc_order-1],
- frame_header->blocksize,
- subframe_bps,
- lpc_order,
- qlp_coeff_precision,
- rice_parameter_limit,
- min_partition_order,
- max_partition_order,
- encoder->protected_->do_escape_coding,
- encoder->protected_->rice_parameter_search_dist,
- subframe[!_best_subframe],
- partitioned_rice_contents[!_best_subframe]
- );
- if(_candidate_bits > 0) { /* if == 0, there was a problem quantizing the lpcoeffs */
- if(_candidate_bits < _best_bits) {
- _best_subframe = !_best_subframe;
- _best_bits = _candidate_bits;
- }
- }
- }
- }
- }
- }
- }
-#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
- }
- }
-
- /* under rare circumstances this can happen when all but lpc subframe types are disabled: */
- if(_best_bits == UINT32_MAX) {
- FLAC__ASSERT(_best_subframe == 0);
- _best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
- }
-
- *best_subframe = _best_subframe;
- *best_bits = _best_bits;
-
- return true;
-}
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-static inline void set_next_subdivide_tukey(FLAC__int32 parts, uint32_t * apodizations, uint32_t * current_depth, uint32_t * current_part){
- // current_part is interleaved: even are partial, odd are punchout
- if(*current_depth == 2){
- // For depth 2, we only do partial, no punchout as that is almost redundant
- if(*current_part == 0){
- *current_part = 2;
- }else{ /* *current_path == 2 */
- *current_part = 0;
- (*current_depth)++;
- }
- }else if((*current_part) < (2*(*current_depth)-1)){
- (*current_part)++;
- }else{ /* (*current_part) >= (2*(*current_depth)-1) */
- *current_part = 0;
- (*current_depth)++;
- }
-
- /* Now check if we are done with this SUBDIVIDE_TUKEY apodization */
- if(*current_depth > (uint32_t) parts){
- (*apodizations)++;
- *current_depth = 1;
- *current_part = 0;
- }
-}
-
-FLAC__bool apply_apodization_(FLAC__StreamEncoder *encoder,
- apply_apodization_state_struct *apply_apodization_state,
- uint32_t blocksize,
- double *lpc_error,
- uint32_t *max_lpc_order_this_apodization,
- uint32_t subframe_bps,
- const void *integer_signal,
- uint32_t *guess_lpc_order)
-{
- apply_apodization_state->current_apodization = &encoder->protected_->apodizations[apply_apodization_state->a];
-
- if(apply_apodization_state->b == 1) {
- /* window full subblock */
- if(subframe_bps <= 32)
- FLAC__lpc_window_data((const FLAC__int32*) integer_signal, encoder->private_->window[apply_apodization_state->a], encoder->private_->windowed_signal, blocksize);
- else
- FLAC__lpc_window_data_wide((const FLAC__int64*) integer_signal, encoder->private_->window[apply_apodization_state->a], encoder->private_->windowed_signal, blocksize);
- encoder->private_->local_lpc_compute_autocorrelation(encoder->private_->windowed_signal, blocksize, (*max_lpc_order_this_apodization)+1, apply_apodization_state->autoc);
- if(apply_apodization_state->current_apodization->type == FLAC__APODIZATION_SUBDIVIDE_TUKEY){
- uint32_t i;
- for(i = 0; i < *max_lpc_order_this_apodization; i++)
- memcpy(apply_apodization_state->autoc_root, apply_apodization_state->autoc, *max_lpc_order_this_apodization*sizeof(apply_apodization_state->autoc[0]));
-
- (apply_apodization_state->b)++;
- }else{
- (apply_apodization_state->a)++;
- }
- }
- else {
- /* window part of subblock */
- if(blocksize/apply_apodization_state->b <= FLAC__MAX_LPC_ORDER) {
- /* intrinsics autocorrelation routines do not all handle cases in which lag might be
- * larger than data_len, and some routines round lag up to the nearest multiple of 4
- * As little gain is expected from using LPC on part of a signal as small as 32 samples
- * and to enable widening this rounding up to larger values in the future, windowing
- * parts smaller than or equal to FLAC__MAX_LPC_ORDER (which is 32) samples is not supported */
- set_next_subdivide_tukey(apply_apodization_state->current_apodization->parameters.subdivide_tukey.parts, &apply_apodization_state->a, &apply_apodization_state->b, &apply_apodization_state->c);
- return false;
- }
- if(!(apply_apodization_state->c % 2)) {
- /* on even c, evaluate the (c/2)th partial window of size blocksize/b */
- if(subframe_bps <= 32)
- FLAC__lpc_window_data_partial((const FLAC__int32*) integer_signal, encoder->private_->window[apply_apodization_state->a], encoder->private_->windowed_signal, blocksize, blocksize/apply_apodization_state->b/2, (apply_apodization_state->c/2*blocksize)/apply_apodization_state->b);
- else
- FLAC__lpc_window_data_partial_wide((const FLAC__int64*) integer_signal, encoder->private_->window[apply_apodization_state->a], encoder->private_->windowed_signal, blocksize, blocksize/apply_apodization_state->b/2, (apply_apodization_state->c/2*blocksize)/apply_apodization_state->b);
- encoder->private_->local_lpc_compute_autocorrelation(encoder->private_->windowed_signal, blocksize/apply_apodization_state->b, (*max_lpc_order_this_apodization)+1, apply_apodization_state->autoc);
- }
- else {
- /* on uneven c, evaluate the root window (over the whole block) minus the previous partial window
- * similar to tukey_punchout apodization but more efficient */
- uint32_t i;
- for(i = 0; i < *max_lpc_order_this_apodization; i++)
- apply_apodization_state->autoc[i] = apply_apodization_state->autoc_root[i] - apply_apodization_state->autoc[i];
- }
- /* Next function sets a, b and c appropriate for next iteration */
- set_next_subdivide_tukey(apply_apodization_state->current_apodization->parameters.subdivide_tukey.parts, &apply_apodization_state->a, &apply_apodization_state->b, &apply_apodization_state->c);
- }
-
- if(apply_apodization_state->autoc[0] == 0.0) /* Signal seems to be constant, so we can't do lp. Constant detection is probably disabled */
- return false;
- FLAC__lpc_compute_lp_coefficients(apply_apodization_state->autoc, max_lpc_order_this_apodization, encoder->private_->lp_coeff, lpc_error);
- *guess_lpc_order =
- FLAC__lpc_compute_best_order(
- lpc_error,
- *max_lpc_order_this_apodization,
- blocksize,
- subframe_bps + (
- encoder->protected_->do_qlp_coeff_prec_search?
- FLAC__MIN_QLP_COEFF_PRECISION : /* have to guess; use the min possible size to avoid accidentally favoring lower orders */
- encoder->protected_->qlp_coeff_precision
- )
- );
- return true;
-}
-#endif
-
-FLAC__bool add_subframe_(
- FLAC__StreamEncoder *encoder,
- uint32_t blocksize,
- uint32_t subframe_bps,
- const FLAC__Subframe *subframe,
- FLAC__BitWriter *frame
-)
-{
- switch(subframe->type) {
- case FLAC__SUBFRAME_TYPE_CONSTANT:
- if(!FLAC__subframe_add_constant(&(subframe->data.constant), subframe_bps, subframe->wasted_bits, frame)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return false;
- }
- break;
- case FLAC__SUBFRAME_TYPE_FIXED:
- if(!FLAC__subframe_add_fixed(&(subframe->data.fixed), blocksize - subframe->data.fixed.order, subframe_bps, subframe->wasted_bits, frame)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return false;
- }
- break;
- case FLAC__SUBFRAME_TYPE_LPC:
- if(!FLAC__subframe_add_lpc(&(subframe->data.lpc), blocksize - subframe->data.lpc.order, subframe_bps, subframe->wasted_bits, frame)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return false;
- }
- break;
- case FLAC__SUBFRAME_TYPE_VERBATIM:
- if(!FLAC__subframe_add_verbatim(&(subframe->data.verbatim), blocksize, subframe_bps, subframe->wasted_bits, frame)) {
- encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
- return false;
- }
- break;
- default:
- FLAC__ASSERT(0);
- }
-
- return true;
-}
-
-#define SPOTCHECK_ESTIMATE 0
-#if SPOTCHECK_ESTIMATE
-static void spotcheck_subframe_estimate_(
- FLAC__StreamEncoder *encoder,
- uint32_t blocksize,
- uint32_t subframe_bps,
- const FLAC__Subframe *subframe,
- uint32_t estimate
-)
-{
- FLAC__bool ret;
- FLAC__BitWriter *frame = FLAC__bitwriter_new();
- if(frame == 0) {
- fprintf(stderr, "EST: can't allocate frame\n");
- return;
- }
- if(!FLAC__bitwriter_init(frame)) {
- fprintf(stderr, "EST: can't init frame\n");
- return;
- }
- ret = add_subframe_(encoder, blocksize, subframe_bps, subframe, frame);
- FLAC__ASSERT(ret);
- {
- const uint32_t actual = FLAC__bitwriter_get_input_bits_unconsumed(frame);
- if(estimate != actual)
- fprintf(stderr, "EST: bad, frame#%u sub#%%d type=%8s est=%u, actual=%u, delta=%d\n", encoder->private_->current_frame_number, FLAC__SubframeTypeString[subframe->type], estimate, actual, (int)actual-(int)estimate);
- }
- FLAC__bitwriter_delete(frame);
-}
-#endif
-
-uint32_t evaluate_constant_subframe_(
- FLAC__StreamEncoder *encoder,
- const FLAC__int64 signal,
- uint32_t blocksize,
- uint32_t subframe_bps,
- FLAC__Subframe *subframe
-)
-{
- uint32_t estimate;
- subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT;
- subframe->data.constant.value = signal;
-
- estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + subframe_bps;
-
-#if SPOTCHECK_ESTIMATE
- spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
-#else
- (void)encoder, (void)blocksize;
-#endif
-
- return estimate;
-}
-
-uint32_t evaluate_fixed_subframe_(
- FLAC__StreamEncoder *encoder,
- const void *signal,
- FLAC__int32 residual[],
- FLAC__uint64 abs_residual_partition_sums[],
- uint32_t raw_bits_per_partition[],
- uint32_t blocksize,
- uint32_t subframe_bps,
- uint32_t order,
- uint32_t rice_parameter_limit,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- FLAC__bool do_escape_coding,
- uint32_t rice_parameter_search_dist,
- FLAC__Subframe *subframe,
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
-)
-{
- uint32_t i, residual_bits, estimate;
- const uint32_t residual_samples = blocksize - order;
-
- if((subframe_bps + order) <= 32)
- FLAC__fixed_compute_residual(((FLAC__int32 *)signal)+order, residual_samples, order, residual);
- else if(subframe_bps <= 32)
- FLAC__fixed_compute_residual_wide(((FLAC__int32 *)signal)+order, residual_samples, order, residual);
- else
- FLAC__fixed_compute_residual_wide_33bit(((FLAC__int64 *)signal)+order, residual_samples, order, residual);
-
- subframe->type = FLAC__SUBFRAME_TYPE_FIXED;
-
- subframe->data.fixed.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
- subframe->data.fixed.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents;
- subframe->data.fixed.residual = residual;
-
- residual_bits =
- find_best_partition_order_(
- encoder->private_,
- residual,
- abs_residual_partition_sums,
- raw_bits_per_partition,
- residual_samples,
- order,
- rice_parameter_limit,
- min_partition_order,
- max_partition_order,
- subframe_bps,
- do_escape_coding,
- rice_parameter_search_dist,
- &subframe->data.fixed.entropy_coding_method
- );
-
- subframe->data.fixed.order = order;
- if(subframe_bps <= 32)
- for(i = 0; i < order; i++)
- subframe->data.fixed.warmup[i] = ((FLAC__int32 *)signal)[i];
- else
- for(i = 0; i < order; i++)
- subframe->data.fixed.warmup[i] = ((FLAC__int64 *)signal)[i];
-
- estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + (order * subframe_bps);
- if(residual_bits < UINT32_MAX - estimate) // To make sure estimate doesn't overflow
- estimate += residual_bits;
- else
- estimate = UINT32_MAX;
-
-#if SPOTCHECK_ESTIMATE
- spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
-#endif
-
- return estimate;
-}
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-uint32_t evaluate_lpc_subframe_(
- FLAC__StreamEncoder *encoder,
- const void *signal,
- FLAC__int32 residual[],
- FLAC__uint64 abs_residual_partition_sums[],
- uint32_t raw_bits_per_partition[],
- const FLAC__real lp_coeff[],
- uint32_t blocksize,
- uint32_t subframe_bps,
- uint32_t order,
- uint32_t qlp_coeff_precision,
- uint32_t rice_parameter_limit,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- FLAC__bool do_escape_coding,
- uint32_t rice_parameter_search_dist,
- FLAC__Subframe *subframe,
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
-)
-{
- FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; /* WATCHOUT: the size is important; some x86 intrinsic routines need more than lpc order elements */
- uint32_t i, residual_bits, estimate;
- int quantization, ret;
- const uint32_t residual_samples = blocksize - order;
-
- /* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps(+1bps for side channel) streams */
- if(subframe_bps <= 17) {
- FLAC__ASSERT(order > 0);
- FLAC__ASSERT(order <= FLAC__MAX_LPC_ORDER);
- qlp_coeff_precision = flac_min(qlp_coeff_precision, 32 - subframe_bps - FLAC__bitmath_ilog2(order));
- }
-
- ret = FLAC__lpc_quantize_coefficients(lp_coeff, order, qlp_coeff_precision, qlp_coeff, &quantization);
- if(ret != 0)
- return 0; /* this is a hack to indicate to the caller that we can't do lp at this order on this subframe */
-
- if(FLAC__lpc_max_residual_bps(subframe_bps, qlp_coeff, order, quantization) > 32) {
- if(subframe_bps <= 32){
- if(!FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual))
- return 0;
- }
- else
- if(!FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual_33bit(((FLAC__int64 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual))
- return 0;
- }
- else
- if(FLAC__lpc_max_prediction_before_shift_bps(subframe_bps, qlp_coeff, order) <= 32)
- if(subframe_bps <= 16 && qlp_coeff_precision <= 16)
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual);
- else
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual);
- else
- encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual);
-
- subframe->type = FLAC__SUBFRAME_TYPE_LPC;
-
- subframe->data.lpc.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
- subframe->data.lpc.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents;
- subframe->data.lpc.residual = residual;
-
- residual_bits =
- find_best_partition_order_(
- encoder->private_,
- residual,
- abs_residual_partition_sums,
- raw_bits_per_partition,
- residual_samples,
- order,
- rice_parameter_limit,
- min_partition_order,
- max_partition_order,
- subframe_bps,
- do_escape_coding,
- rice_parameter_search_dist,
- &subframe->data.lpc.entropy_coding_method
- );
-
- subframe->data.lpc.order = order;
- subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision;
- subframe->data.lpc.quantization_level = quantization;
- memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(FLAC__int32)*FLAC__MAX_LPC_ORDER);
- if(subframe_bps <= 32)
- for(i = 0; i < order; i++)
- subframe->data.lpc.warmup[i] = ((FLAC__int32 *)signal)[i];
- else
- for(i = 0; i < order; i++)
- subframe->data.lpc.warmup[i] = ((FLAC__int64 *)signal)[i];
-
-
- estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN + FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN + (order * (qlp_coeff_precision + subframe_bps));
- if(residual_bits < UINT32_MAX - estimate) // To make sure estimate doesn't overflow
- estimate += residual_bits;
- else
- estimate = UINT32_MAX;
-
-#if SPOTCHECK_ESTIMATE
- spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
-#endif
-
- return estimate;
-}
-#endif
-
-uint32_t evaluate_verbatim_subframe_(
- FLAC__StreamEncoder *encoder,
- const void *signal,
- uint32_t blocksize,
- uint32_t subframe_bps,
- FLAC__Subframe *subframe
-)
-{
- uint32_t estimate;
-
- subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM;
-
- if(subframe_bps <= 32){
- subframe->data.verbatim.data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32;
- subframe->data.verbatim.data.int32 = (const FLAC__int32*) signal;
- }
- else {
- subframe->data.verbatim.data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64;
- subframe->data.verbatim.data.int64 = (const FLAC__int64*) signal;
- }
-
- estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + (blocksize * subframe_bps);
-
-#if SPOTCHECK_ESTIMATE
- spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
-#else
- (void)encoder;
-#endif
-
- return estimate;
-}
-
-uint32_t find_best_partition_order_(
- FLAC__StreamEncoderPrivate *private_,
- const FLAC__int32 residual[],
- FLAC__uint64 abs_residual_partition_sums[],
- uint32_t raw_bits_per_partition[],
- uint32_t residual_samples,
- uint32_t predictor_order,
- uint32_t rice_parameter_limit,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- uint32_t bps,
- FLAC__bool do_escape_coding,
- uint32_t rice_parameter_search_dist,
- FLAC__EntropyCodingMethod *best_ecm
-)
-{
- uint32_t residual_bits, best_residual_bits = 0;
- uint32_t best_parameters_index = 0;
- uint32_t best_partition_order = 0;
- const uint32_t blocksize = residual_samples + predictor_order;
-
- max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(max_partition_order, blocksize, predictor_order);
- min_partition_order = flac_min(min_partition_order, max_partition_order);
-
- private_->local_precompute_partition_info_sums(residual, abs_residual_partition_sums, residual_samples, predictor_order, min_partition_order, max_partition_order, bps);
-
- if(do_escape_coding)
- precompute_partition_info_escapes_(residual, raw_bits_per_partition, residual_samples, predictor_order, min_partition_order, max_partition_order);
-
- {
- int partition_order;
- uint32_t sum;
-
- for(partition_order = (int)max_partition_order, sum = 0; partition_order >= (int)min_partition_order; partition_order--) {
- if(!
- set_partitioned_rice_(
-#ifdef EXACT_RICE_BITS_CALCULATION
- residual,
-#endif
- abs_residual_partition_sums+sum,
- raw_bits_per_partition+sum,
- residual_samples,
- predictor_order,
- rice_parameter_limit,
- rice_parameter_search_dist,
- (uint32_t)partition_order,
- do_escape_coding,
- &private_->partitioned_rice_contents_extra[!best_parameters_index],
- &residual_bits
- )
- )
- {
- FLAC__ASSERT(best_residual_bits != 0);
- break;
- }
- sum += 1u << partition_order;
- if(best_residual_bits == 0 || residual_bits < best_residual_bits) {
- best_residual_bits = residual_bits;
- best_parameters_index = !best_parameters_index;
- best_partition_order = partition_order;
- }
- }
- }
-
- best_ecm->data.partitioned_rice.order = best_partition_order;
-
- {
- /*
- * We are allowed to de-const the pointer based on our special
- * knowledge; it is const to the outside world.
- */
- FLAC__EntropyCodingMethod_PartitionedRiceContents* prc = (FLAC__EntropyCodingMethod_PartitionedRiceContents*)best_ecm->data.partitioned_rice.contents;
- uint32_t partition;
-
- /* save best parameters and raw_bits */
- memcpy(prc->parameters, private_->partitioned_rice_contents_extra[best_parameters_index].parameters, (uint32_t)sizeof(uint32_t)*(1<<(best_partition_order)));
- if(do_escape_coding)
- memcpy(prc->raw_bits, private_->partitioned_rice_contents_extra[best_parameters_index].raw_bits, (uint32_t)sizeof(uint32_t)*(1<<(best_partition_order)));
- /*
- * Now need to check if the type should be changed to
- * FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 based on the
- * size of the rice parameters.
- */
- for(partition = 0; partition < (1u<parameters[partition] >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
- best_ecm->type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2;
- break;
- }
- }
- }
-
- return best_residual_bits;
-}
-
-void precompute_partition_info_sums_(
- const FLAC__int32 residual[],
- FLAC__uint64 abs_residual_partition_sums[],
- uint32_t residual_samples,
- uint32_t predictor_order,
- uint32_t min_partition_order,
- uint32_t max_partition_order,
- uint32_t bps
-)
-{
- const uint32_t default_partition_samples = (residual_samples + predictor_order) >> max_partition_order;
- uint32_t partitions = 1u << max_partition_order;
-
- FLAC__ASSERT(default_partition_samples > predictor_order);
-
- /* first do max_partition_order */
- {
- const uint32_t threshold = 32 - FLAC__bitmath_ilog2(default_partition_samples);
- uint32_t partition, residual_sample, end = (uint32_t)(-(int)predictor_order);
- /* WATCHOUT: "bps + FLAC__MAX_EXTRA_RESIDUAL_BPS" is the maximum assumed size of the average residual magnitude */
- if(bps + FLAC__MAX_EXTRA_RESIDUAL_BPS < threshold) {
- for(partition = residual_sample = 0; partition < partitions; partition++) {
- FLAC__uint32 abs_residual_partition_sum = 0;
- end += default_partition_samples;
- for( ; residual_sample < end; residual_sample++)
- abs_residual_partition_sum += abs(residual[residual_sample]); /* abs(INT_MIN) is undefined, but if the residual is INT_MIN we have bigger problems */
- abs_residual_partition_sums[partition] = abs_residual_partition_sum;
- }
- }
- else { /* have to pessimistically use 64 bits for accumulator */
- for(partition = residual_sample = 0; partition < partitions; partition++) {
- FLAC__uint64 abs_residual_partition_sum64 = 0;
- end += default_partition_samples;
- for( ; residual_sample < end; residual_sample++)
- abs_residual_partition_sum64 += abs(residual[residual_sample]); /* abs(INT_MIN) is undefined, but if the residual is INT_MIN we have bigger problems */
- abs_residual_partition_sums[partition] = abs_residual_partition_sum64;
- }
- }
- }
-
- /* now merge partitions for lower orders */
- {
- uint32_t from_partition = 0, to_partition = partitions;
- int partition_order;
- for(partition_order = (int)max_partition_order - 1; partition_order >= (int)min_partition_order; partition_order--) {
- uint32_t i;
- partitions >>= 1;
- for(i = 0; i < partitions; i++) {
- abs_residual_partition_sums[to_partition++] =
- abs_residual_partition_sums[from_partition ] +
- abs_residual_partition_sums[from_partition+1];
- from_partition += 2;
- }
- }
- }
-}
-
-void precompute_partition_info_escapes_(
- const FLAC__int32 residual[],
- uint32_t raw_bits_per_partition[],
- uint32_t residual_samples,
- uint32_t predictor_order,
- uint32_t min_partition_order,
- uint32_t max_partition_order
-)
-{
- int partition_order;
- uint32_t from_partition, to_partition = 0;
- const uint32_t blocksize = residual_samples + predictor_order;
-
- /* first do max_partition_order */
- for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) {
- FLAC__int32 r;
- FLAC__uint32 rmax;
- uint32_t partition, partition_sample, partition_samples, residual_sample;
- const uint32_t partitions = 1u << partition_order;
- const uint32_t default_partition_samples = blocksize >> partition_order;
-
- FLAC__ASSERT(default_partition_samples > predictor_order);
-
- for(partition = residual_sample = 0; partition < partitions; partition++) {
- partition_samples = default_partition_samples;
- if(partition == 0)
- partition_samples -= predictor_order;
- rmax = 0;
- for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) {
- r = residual[residual_sample++];
- /* OPT: maybe faster: rmax |= r ^ (r>>31) */
- if(r < 0)
- rmax |= ~r;
- else
- rmax |= r;
- }
- /* now we know all residual values are in the range [-rmax-1,rmax] */
- raw_bits_per_partition[partition] = rmax? FLAC__bitmath_ilog2(rmax) + 2 : 1;
- }
- to_partition = partitions;
- break; /*@@@ yuck, should remove the 'for' loop instead */
- }
-
- /* now merge partitions for lower orders */
- for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) {
- uint32_t m;
- uint32_t i;
- const uint32_t partitions = 1u << partition_order;
- for(i = 0; i < partitions; i++) {
- m = raw_bits_per_partition[from_partition];
- from_partition++;
- raw_bits_per_partition[to_partition] = flac_max(m, raw_bits_per_partition[from_partition]);
- from_partition++;
- to_partition++;
- }
- }
-}
-
-#ifdef EXACT_RICE_BITS_CALCULATION
-static inline uint32_t count_rice_bits_in_partition_(
- const uint32_t rice_parameter,
- const uint32_t partition_samples,
- const FLAC__int32 *residual
-)
-{
- uint32_t i;
- uint64_t partition_bits =
- FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN + /* actually could end up being FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN but err on side of 16bps */
- (1+rice_parameter) * partition_samples /* 1 for unary stop bit + rice_parameter for the binary portion */
- ;
- for(i = 0; i < partition_samples; i++)
- partition_bits += ( (FLAC__uint32)((residual[i]<<1)^(residual[i]>>31)) >> rice_parameter );
- return (uint32_t)(flac_min(partition_bits,UINT32_MAX)); // To make sure the return value doesn't overflow
-}
-#else
-static inline uint32_t count_rice_bits_in_partition_(
- const uint32_t rice_parameter,
- const uint32_t partition_samples,
- const FLAC__uint64 abs_residual_partition_sum
-)
-{
- return (uint32_t)(flac_min( // To make sure the return value doesn't overflow
- (uint32_t) (FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN + /* actually could end up being FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN but err on side of 16bps */
- (1+rice_parameter) * partition_samples + /* 1 for unary stop bit + rice_parameter for the binary portion */
- (
- rice_parameter?
- (abs_residual_partition_sum >> (rice_parameter-1)) /* rice_parameter-1 because the real coder sign-folds instead of using a sign bit */
- : (abs_residual_partition_sum << 1) /* can't shift by negative number, so reverse */
- )
- - (partition_samples >> 1)),UINT32_MAX));
- /* -(partition_samples>>1) to subtract out extra contributions to the abs_residual_partition_sum.
- * The actual number of bits used is closer to the sum(for all i in the partition) of abs(residual[i])>>(rice_parameter-1)
- * By using the abs_residual_partition sum, we also add in bits in the LSBs that would normally be shifted out.
- * So the subtraction term tries to guess how many extra bits were contributed.
- * If the LSBs are randomly distributed, this should average to 0.5 extra bits per sample.
- */
- ;
-}
-#endif
-
-FLAC__bool set_partitioned_rice_(
-#ifdef EXACT_RICE_BITS_CALCULATION
- const FLAC__int32 residual[],
-#endif
- const FLAC__uint64 abs_residual_partition_sums[],
- const uint32_t raw_bits_per_partition[],
- const uint32_t residual_samples,
- const uint32_t predictor_order,
- const uint32_t rice_parameter_limit,
- const uint32_t rice_parameter_search_dist,
- const uint32_t partition_order,
- const FLAC__bool search_for_escapes,
- FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents,
- uint32_t *bits
-)
-{
- uint32_t rice_parameter, partition_bits;
- uint32_t best_partition_bits, best_rice_parameter = 0;
- uint32_t bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN;
- uint32_t *parameters, *raw_bits;
- uint32_t partition, residual_sample;
- uint32_t partition_samples, partition_samples_base;
- uint32_t partition_samples_fixed_point_divisor, partition_samples_fixed_point_divisor_base;
- const uint32_t partitions = 1u << partition_order;
- FLAC__uint64 mean;
-#ifdef ENABLE_RICE_PARAMETER_SEARCH
- uint32_t min_rice_parameter, max_rice_parameter;
-#else
- (void)rice_parameter_search_dist;
-#endif
-
- FLAC__ASSERT(rice_parameter_limit <= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER);
-
- parameters = partitioned_rice_contents->parameters;
- raw_bits = partitioned_rice_contents->raw_bits;
-
- partition_samples_base = (residual_samples+predictor_order) >> partition_order;
-
- /* Integer division is slow. To speed up things, precalculate a fixed point
- * divisor, as all partitions except the first are the same size. 18 bits
- * are taken because maximum block size is 65535, max partition size for
- * partitions other than 0 is 32767 (15 bit), max abs residual is 2^31,
- * which leaves 18 bit */
- partition_samples_fixed_point_divisor_base = 0x40000 / partition_samples_base;
-
- for(partition = residual_sample = 0; partition < partitions; partition++) {
- partition_samples = partition_samples_base;
- if(partition > 0) {
- partition_samples_fixed_point_divisor = partition_samples_fixed_point_divisor_base;
- }
- else {
- if(partition_samples <= predictor_order)
- return false;
- else
- partition_samples -= predictor_order;
- partition_samples_fixed_point_divisor = 0x40000 / partition_samples;
- }
- mean = abs_residual_partition_sums[partition];
- /* 'mean' is not a good name for the variable, it is
- * actually the sum of magnitudes of all residual values
- * in the partition, so the actual mean is
- * mean/partition_samples
- */
- if(mean < 2 || (((mean - 1)*partition_samples_fixed_point_divisor)>>18) == 0)
- rice_parameter = 0;
- else
- rice_parameter = FLAC__bitmath_ilog2_wide(((mean - 1)*partition_samples_fixed_point_divisor)>>18) + 1;
-
- if(rice_parameter >= rice_parameter_limit) {
-#ifndef NDEBUG
- fprintf(stderr, "clipping rice_parameter (%u -> %u) @6\n", rice_parameter, rice_parameter_limit - 1);
-#endif
- rice_parameter = rice_parameter_limit - 1;
- }
-
- best_partition_bits = UINT32_MAX;
-#ifdef ENABLE_RICE_PARAMETER_SEARCH
- if(rice_parameter_search_dist) {
- if(rice_parameter < rice_parameter_search_dist)
- min_rice_parameter = 0;
- else
- min_rice_parameter = rice_parameter - rice_parameter_search_dist;
- max_rice_parameter = rice_parameter + rice_parameter_search_dist;
- if(max_rice_parameter >= rice_parameter_limit) {
-#ifndef NDEBUG
- fprintf(stderr, "clipping rice_parameter (%u -> %u) @7\n", max_rice_parameter, rice_parameter_limit - 1);
-#endif
- max_rice_parameter = rice_parameter_limit - 1;
- }
- }
- else
- min_rice_parameter = max_rice_parameter = rice_parameter;
-
- for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) {
-#endif
-#ifdef EXACT_RICE_BITS_CALCULATION
- partition_bits = count_rice_bits_in_partition_(rice_parameter, partition_samples, residual+residual_sample);
-#else
- partition_bits = count_rice_bits_in_partition_(rice_parameter, partition_samples, abs_residual_partition_sums[partition]);
-#endif
- if(partition_bits < best_partition_bits) {
- best_rice_parameter = rice_parameter;
- best_partition_bits = partition_bits;
- }
-#ifdef ENABLE_RICE_PARAMETER_SEARCH
- }
-#endif
- if(search_for_escapes) {
- partition_bits = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN + raw_bits_per_partition[partition] * partition_samples;
- if(partition_bits <= best_partition_bits && raw_bits_per_partition[partition] < 32) {
- raw_bits[partition] = raw_bits_per_partition[partition];
- best_rice_parameter = 0; /* will be converted to appropriate escape parameter later */
- best_partition_bits = partition_bits;
- }
- else
- raw_bits[partition] = 0;
- }
- parameters[partition] = best_rice_parameter;
- if(best_partition_bits < UINT32_MAX - bits_) // To make sure _bits doesn't overflow
- bits_ += best_partition_bits;
- else
- bits_ = UINT32_MAX;
- residual_sample += partition_samples;
- }
-
- *bits = bits_;
- return true;
-}
-
-uint32_t get_wasted_bits_(FLAC__int32 signal[], uint32_t samples)
-{
- uint32_t i, shift;
- FLAC__int32 x = 0;
-
- for(i = 0; i < samples && !(x&1); i++)
- x |= signal[i];
-
- if(x == 0) {
- shift = 0;
- }
- else {
- for(shift = 0; !(x&1); shift++)
- x >>= 1;
- }
-
- if(shift > 0) {
- for(i = 0; i < samples; i++)
- signal[i] >>= shift;
- }
-
- return shift;
-}
-
-uint32_t get_wasted_bits_wide_(FLAC__int64 signal_wide[], FLAC__int32 signal[], uint32_t samples)
-{
- uint32_t i, shift;
- FLAC__int64 x = 0;
-
- for(i = 0; i < samples && !(x&1); i++)
- x |= signal_wide[i];
-
- if(x == 0) {
- shift = 1;
- }
- else {
- for(shift = 0; !(x&1); shift++)
- x >>= 1;
- }
-
- if(shift > 0) {
- for(i = 0; i < samples; i++)
- signal[i] = (FLAC__int32)(signal_wide[i] >> shift);
- }
-
- return shift;
-}
-
-
-void append_to_verify_fifo_(verify_input_fifo *fifo, const FLAC__int32 * const input[], uint32_t input_offset, uint32_t channels, uint32_t wide_samples)
-{
- uint32_t channel;
-
- for(channel = 0; channel < channels; channel++)
- memcpy(&fifo->data[channel][fifo->tail], &input[channel][input_offset], sizeof(FLAC__int32) * wide_samples);
-
- fifo->tail += wide_samples;
-
- FLAC__ASSERT(fifo->tail <= fifo->size);
-}
-
-void append_to_verify_fifo_interleaved_(verify_input_fifo *fifo, const FLAC__int32 input[], uint32_t input_offset, uint32_t channels, uint32_t wide_samples)
-{
- uint32_t channel;
- uint32_t sample, wide_sample;
- uint32_t tail = fifo->tail;
-
- sample = input_offset * channels;
- for(wide_sample = 0; wide_sample < wide_samples; wide_sample++) {
- for(channel = 0; channel < channels; channel++)
- fifo->data[channel][tail] = input[sample++];
- tail++;
- }
- fifo->tail = tail;
-
- FLAC__ASSERT(fifo->tail <= fifo->size);
-}
-
-FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
-{
- FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
- const size_t encoded_bytes = encoder->private_->verify.output.bytes;
- (void)decoder;
-
- if(encoder->private_->verify.needs_magic_hack) {
- FLAC__ASSERT(*bytes >= FLAC__STREAM_SYNC_LENGTH);
- *bytes = FLAC__STREAM_SYNC_LENGTH;
- memcpy(buffer, FLAC__STREAM_SYNC_STRING, *bytes);
- encoder->private_->verify.needs_magic_hack = false;
- }
- else {
- if(encoded_bytes == 0) {
- /*
- * If we get here, a FIFO underflow has occurred,
- * which means there is a bug somewhere.
- */
- FLAC__ASSERT(0);
- return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
- }
- else if(encoded_bytes < *bytes)
- *bytes = encoded_bytes;
- memcpy(buffer, encoder->private_->verify.output.data, *bytes);
- encoder->private_->verify.output.data += *bytes;
- encoder->private_->verify.output.bytes -= *bytes;
- }
-
- return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
-}
-
-FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
-{
- FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder *)client_data;
- uint32_t channel;
- const uint32_t channels = frame->header.channels;
- const uint32_t blocksize = frame->header.blocksize;
- const uint32_t bytes_per_block = sizeof(FLAC__int32) * blocksize;
-
- (void)decoder;
-
- if(encoder->protected_->state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
- /* This is set when verify_error_callback_ was called */
- return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
- }
-
- for(channel = 0; channel < channels; channel++) {
- if(0 != memcmp(buffer[channel], encoder->private_->verify.input_fifo.data[channel], bytes_per_block)) {
- uint32_t i, sample = 0;
- FLAC__int32 expect = 0, got = 0;
-
- for(i = 0; i < blocksize; i++) {
- if(buffer[channel][i] != encoder->private_->verify.input_fifo.data[channel][i]) {
- sample = i;
- expect = (FLAC__int32)encoder->private_->verify.input_fifo.data[channel][i];
- got = (FLAC__int32)buffer[channel][i];
- break;
- }
- }
- FLAC__ASSERT(i < blocksize);
- FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
- encoder->private_->verify.error_stats.absolute_sample = frame->header.number.sample_number + sample;
- encoder->private_->verify.error_stats.frame_number = (uint32_t)(frame->header.number.sample_number / blocksize);
- encoder->private_->verify.error_stats.channel = channel;
- encoder->private_->verify.error_stats.sample = sample;
- encoder->private_->verify.error_stats.expected = expect;
- encoder->private_->verify.error_stats.got = got;
- encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA;
- return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
- }
- }
- /* dequeue the frame from the fifo */
- encoder->private_->verify.input_fifo.tail -= blocksize;
- FLAC__ASSERT(encoder->private_->verify.input_fifo.tail <= OVERREAD_);
- for(channel = 0; channel < channels; channel++)
- memmove(&encoder->private_->verify.input_fifo.data[channel][0], &encoder->private_->verify.input_fifo.data[channel][blocksize], encoder->private_->verify.input_fifo.tail * sizeof(encoder->private_->verify.input_fifo.data[0][0]));
- return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
-}
-
-void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
-{
- (void)decoder, (void)metadata, (void)client_data;
-}
-
-void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
-{
- FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
- (void)decoder, (void)status;
- encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
-}
-
-#if 0
-FLAC__StreamEncoderReadStatus file_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
-{
- (void)client_data;
-
- *bytes = fread(buffer, 1, *bytes, encoder->private_->file);
- if (*bytes == 0) {
- if (feof(encoder->private_->file))
- return FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM;
- else if (ferror(encoder->private_->file))
- return FLAC__STREAM_ENCODER_READ_STATUS_ABORT;
- }
- return FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE;
-}
-
-FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
-{
- (void)client_data;
-
- if(fseeko(encoder->private_->file, (FLAC__off_t)absolute_byte_offset, SEEK_SET) < 0)
- return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR;
- else
- return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
-}
-
-FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
-{
- FLAC__off_t offset;
-
- (void)client_data;
-
- offset = ftello(encoder->private_->file);
-
- if(offset < 0) {
- return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR;
- }
- else {
- *absolute_byte_offset = (FLAC__uint64)offset;
- return FLAC__STREAM_ENCODER_TELL_STATUS_OK;
- }
-}
-
-#ifdef FLAC__VALGRIND_TESTING
-static size_t local__fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
-{
- size_t ret = fwrite(ptr, size, nmemb, stream);
- if(!ferror(stream))
- fflush(stream);
- return ret;
-}
-#else
-#define local__fwrite fwrite
-#endif
-
-FLAC__StreamEncoderWriteStatus file_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame, void *client_data)
-{
- (void)client_data, (void)current_frame;
-
- if(local__fwrite(buffer, sizeof(FLAC__byte), bytes, encoder->private_->file) == bytes) {
- FLAC__bool call_it = 0 != encoder->private_->progress_callback && (
-#if FLAC__HAS_OGG
- /* We would like to be able to use 'samples > 0' in the
- * clause here but currently because of the nature of our
- * Ogg writing implementation, 'samples' is always 0 (see
- * ogg_encoder_aspect.c). The downside is extra progress
- * callbacks.
- */
- encoder->private_->is_ogg? true :
-#endif
- samples > 0
- );
- if(call_it) {
- /* NOTE: We have to add +bytes, +samples, and +1 to the stats
- * because at this point in the callback chain, the stats
- * have not been updated. Only after we return and control
- * gets back to write_frame_() are the stats updated
- */
- encoder->private_->progress_callback(encoder, encoder->private_->bytes_written+bytes, encoder->private_->samples_written+samples, encoder->private_->frames_written+(samples?1:0), encoder->private_->total_frames_estimate, encoder->private_->client_data);
- }
- return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
- }
- else
- return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
-}
-
-/*
- * This will forcibly set stdout to binary mode (for OSes that require it)
- */
-FILE *get_binary_stdout_(void)
-{
- /* if something breaks here it is probably due to the presence or
- * absence of an underscore before the identifiers 'setmode',
- * 'fileno', and/or 'O_BINARY'; check your system header files.
- */
-#if defined _MSC_VER || defined __MINGW32__
- _setmode(_fileno(stdout), _O_BINARY);
-#elif defined __EMX__
- setmode(fileno(stdout), O_BINARY);
-#endif
-
- return stdout;
-}
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/libFLAC/stream_encoder_framing.c b/modules/juce_audio_formats/codecs/flac_143/libFLAC/stream_encoder_framing.c
deleted file mode 100644
index aa424b0ded..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/libFLAC/stream_encoder_framing.c
+++ /dev/null
@@ -1,594 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
-#ifdef HAVE_CONFIG_H
-# include
-#endif
-
-#include
-#include /* for strlen() */
-#include "include/private/stream_encoder_framing.h"
-#include "include/private/crc.h"
-#include "../assert.h"
-#include "../compat.h"
-
-static FLAC__bool add_entropy_coding_method_(FLAC__BitWriter *bw, const FLAC__EntropyCodingMethod *method);
-static FLAC__bool add_residual_partitioned_rice_(FLAC__BitWriter *bw, const FLAC__int32 residual[], const uint32_t residual_samples, const uint32_t predictor_order, const uint32_t rice_parameters[], const uint32_t raw_bits[], const uint32_t partition_order, const FLAC__bool is_extended);
-
-FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetadata *metadata, FLAC__BitWriter *bw, FLAC__bool update_vendor_string)
-{
- uint32_t i, j, metadata_length;
- const uint32_t vendor_string_length = (uint32_t)strlen(FLAC__VENDOR_STRING);
- const uint32_t start_bits = FLAC__bitwriter_get_input_bits_unconsumed(bw);
-
- FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw));
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->is_last, FLAC__STREAM_METADATA_IS_LAST_LEN))
- return false;
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->type, FLAC__STREAM_METADATA_TYPE_LEN))
- return false;
-
- /*
- * First, for VORBIS_COMMENTs, adjust the length to reflect our vendor string
- */
- metadata_length = metadata->length;
- if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && update_vendor_string) {
- FLAC__ASSERT(metadata->data.vorbis_comment.vendor_string.length == 0 || 0 != metadata->data.vorbis_comment.vendor_string.entry);
- metadata_length -= metadata->data.vorbis_comment.vendor_string.length;
- metadata_length += vendor_string_length;
- }
- FLAC__ASSERT(metadata_length < (1u << FLAC__STREAM_METADATA_LENGTH_LEN));
- /* double protection */
- if(metadata_length >= (1u << FLAC__STREAM_METADATA_LENGTH_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata_length, FLAC__STREAM_METADATA_LENGTH_LEN))
- return false;
-
- switch(metadata->type) {
- case FLAC__METADATA_TYPE_STREAMINFO:
- FLAC__ASSERT(metadata->data.stream_info.min_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN));
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.min_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN))
- return false;
- FLAC__ASSERT(metadata->data.stream_info.max_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN));
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.max_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN))
- return false;
- FLAC__ASSERT(metadata->data.stream_info.min_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN));
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.min_framesize, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN))
- return false;
- FLAC__ASSERT(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN));
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.max_framesize, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN))
- return false;
- FLAC__ASSERT(FLAC__format_sample_rate_is_valid(metadata->data.stream_info.sample_rate));
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.sample_rate, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN))
- return false;
- FLAC__ASSERT(metadata->data.stream_info.channels > 0);
- FLAC__ASSERT(metadata->data.stream_info.channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN));
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.channels-1, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN))
- return false;
- FLAC__ASSERT(metadata->data.stream_info.bits_per_sample > 0);
- FLAC__ASSERT(metadata->data.stream_info.bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN));
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.bits_per_sample-1, FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN))
- return false;
- if(metadata->data.stream_info.total_samples >= (FLAC__U64L(1) << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)){
- if(!FLAC__bitwriter_write_raw_uint64(bw, 0, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN))
- return false;
- }else{
- if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN))
- return false;
- }
- if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.stream_info.md5sum, 16))
- return false;
- break;
- case FLAC__METADATA_TYPE_PADDING:
- if(!FLAC__bitwriter_write_zeroes(bw, metadata->length * 8))
- return false;
- break;
- case FLAC__METADATA_TYPE_APPLICATION:
- if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8))
- return false;
- if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.application.data, metadata->length - (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)))
- return false;
- break;
- case FLAC__METADATA_TYPE_SEEKTABLE:
- for(i = 0; i < metadata->data.seek_table.num_points; i++) {
- if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.seek_table.points[i].sample_number, FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.seek_table.points[i].stream_offset, FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.seek_table.points[i].frame_samples, FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN))
- return false;
- }
- break;
- case FLAC__METADATA_TYPE_VORBIS_COMMENT:
- if(update_vendor_string) {
- if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, vendor_string_length))
- return false;
- if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)FLAC__VENDOR_STRING, vendor_string_length))
- return false;
- }
- else {
- if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, metadata->data.vorbis_comment.vendor_string.length))
- return false;
- if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.vorbis_comment.vendor_string.entry, metadata->data.vorbis_comment.vendor_string.length))
- return false;
- }
- if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, metadata->data.vorbis_comment.num_comments))
- return false;
- for(i = 0; i < metadata->data.vorbis_comment.num_comments; i++) {
- if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, metadata->data.vorbis_comment.comments[i].length))
- return false;
- if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.vorbis_comment.comments[i].entry, metadata->data.vorbis_comment.comments[i].length))
- return false;
- }
- break;
- case FLAC__METADATA_TYPE_CUESHEET:
- FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0);
- if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)metadata->data.cue_sheet.media_catalog_number, FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN/8))
- return false;
- if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.cue_sheet.lead_in, FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.cue_sheet.is_cd? 1 : 0, FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN))
- return false;
- if(!FLAC__bitwriter_write_zeroes(bw, FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.cue_sheet.num_tracks, FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN))
- return false;
- for(i = 0; i < metadata->data.cue_sheet.num_tracks; i++) {
- const FLAC__StreamMetadata_CueSheet_Track *track = metadata->data.cue_sheet.tracks + i;
-
- if(!FLAC__bitwriter_write_raw_uint64(bw, track->offset, FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, track->number, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN))
- return false;
- FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0);
- if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)track->isrc, FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN/8))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, track->type, FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, track->pre_emphasis, FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN))
- return false;
- if(!FLAC__bitwriter_write_zeroes(bw, FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, track->num_indices, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN))
- return false;
- for(j = 0; j < track->num_indices; j++) {
- const FLAC__StreamMetadata_CueSheet_Index *indx = track->indices + j;
-
- if(!FLAC__bitwriter_write_raw_uint64(bw, indx->offset, FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, indx->number, FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN))
- return false;
- if(!FLAC__bitwriter_write_zeroes(bw, FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN))
- return false;
- }
- }
- break;
- case FLAC__METADATA_TYPE_PICTURE:
- {
- size_t len;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.type, FLAC__STREAM_METADATA_PICTURE_TYPE_LEN))
- return false;
- len = strlen(metadata->data.picture.mime_type);
- if(!FLAC__bitwriter_write_raw_uint32(bw, len, FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN))
- return false;
- if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)metadata->data.picture.mime_type, len))
- return false;
- len = strlen((const char *)metadata->data.picture.description);
- if(!FLAC__bitwriter_write_raw_uint32(bw, len, FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN))
- return false;
- if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.picture.description, len))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.width, FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.height, FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.depth, FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.colors, FLAC__STREAM_METADATA_PICTURE_COLORS_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.data_length, FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN))
- return false;
- if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.picture.data, metadata->data.picture.data_length))
- return false;
- }
- break;
- default:
- if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.unknown.data, metadata->length))
- return false;
- break;
- }
-
- /* Now check whether metadata block length was correct */
- {
- uint32_t length_in_bits = FLAC__bitwriter_get_input_bits_unconsumed(bw);
- if(length_in_bits < start_bits)
- return false;
- length_in_bits -= start_bits;
- if(length_in_bits % 8 != 0 || length_in_bits != (metadata_length*8+32))
- return false;
- }
-
- FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw));
- return true;
-}
-
-FLAC__bool FLAC__frame_add_header(const FLAC__FrameHeader *header, FLAC__BitWriter *bw)
-{
- uint32_t u, blocksize_hint, sample_rate_hint;
- FLAC__byte crc;
-
- FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw));
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__FRAME_HEADER_SYNC, FLAC__FRAME_HEADER_SYNC_LEN))
- return false;
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, 0, FLAC__FRAME_HEADER_RESERVED_LEN))
- return false;
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, (header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER)? 0 : 1, FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN))
- return false;
-
- FLAC__ASSERT(header->blocksize > 0 && header->blocksize <= FLAC__MAX_BLOCK_SIZE);
- /* when this assertion holds true, any legal blocksize can be expressed in the frame header */
- FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535u);
- blocksize_hint = 0;
- switch(header->blocksize) {
- case 192: u = 1; break;
- case 576: u = 2; break;
- case 1152: u = 3; break;
- case 2304: u = 4; break;
- case 4608: u = 5; break;
- case 256: u = 8; break;
- case 512: u = 9; break;
- case 1024: u = 10; break;
- case 2048: u = 11; break;
- case 4096: u = 12; break;
- case 8192: u = 13; break;
- case 16384: u = 14; break;
- case 32768: u = 15; break;
- default:
- if(header->blocksize <= 0x100)
- blocksize_hint = u = 6;
- else
- blocksize_hint = u = 7;
- break;
- }
- if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_BLOCK_SIZE_LEN))
- return false;
-
- FLAC__ASSERT(FLAC__format_sample_rate_is_valid(header->sample_rate));
- sample_rate_hint = 0;
- switch(header->sample_rate) {
- case 88200: u = 1; break;
- case 176400: u = 2; break;
- case 192000: u = 3; break;
- case 8000: u = 4; break;
- case 16000: u = 5; break;
- case 22050: u = 6; break;
- case 24000: u = 7; break;
- case 32000: u = 8; break;
- case 44100: u = 9; break;
- case 48000: u = 10; break;
- case 96000: u = 11; break;
- default:
- if(header->sample_rate <= 255000 && header->sample_rate % 1000 == 0)
- sample_rate_hint = u = 12;
- else if(header->sample_rate <= 655350 && header->sample_rate % 10 == 0)
- sample_rate_hint = u = 14;
- else if(header->sample_rate <= 0xffff)
- sample_rate_hint = u = 13;
- else
- u = 0;
- break;
- }
- if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_SAMPLE_RATE_LEN))
- return false;
-
- FLAC__ASSERT(header->channels > 0 && header->channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN) && header->channels <= FLAC__MAX_CHANNELS);
- switch(header->channel_assignment) {
- case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
- u = header->channels - 1;
- break;
- case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
- FLAC__ASSERT(header->channels == 2);
- u = 8;
- break;
- case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
- FLAC__ASSERT(header->channels == 2);
- u = 9;
- break;
- case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
- FLAC__ASSERT(header->channels == 2);
- u = 10;
- break;
- default:
- FLAC__ASSERT(0);
- }
- if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN))
- return false;
-
- FLAC__ASSERT(header->bits_per_sample > 0 && header->bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN));
- switch(header->bits_per_sample) {
- case 8 : u = 1; break;
- case 12: u = 2; break;
- case 16: u = 4; break;
- case 20: u = 5; break;
- case 24: u = 6; break;
- case 32: u = 7; break;
- default: u = 0; break;
- }
- if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN))
- return false;
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, 0, FLAC__FRAME_HEADER_ZERO_PAD_LEN))
- return false;
-
- if(header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER) {
- if(!FLAC__bitwriter_write_utf8_uint32(bw, header->number.frame_number))
- return false;
- }
- else {
- if(!FLAC__bitwriter_write_utf8_uint64(bw, header->number.sample_number))
- return false;
- }
-
- if(blocksize_hint)
- if(!FLAC__bitwriter_write_raw_uint32(bw, header->blocksize-1, (blocksize_hint==6)? 8:16))
- return false;
-
- switch(sample_rate_hint) {
- case 12:
- if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate / 1000, 8))
- return false;
- break;
- case 13:
- if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate, 16))
- return false;
- break;
- case 14:
- if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate / 10, 16))
- return false;
- break;
- }
-
- /* write the CRC */
- if(!FLAC__bitwriter_get_write_crc8(bw, &crc))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, crc, FLAC__FRAME_HEADER_CRC_LEN))
- return false;
-
- return true;
-}
-
-FLAC__bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, uint32_t subframe_bps, uint32_t wasted_bits, FLAC__BitWriter *bw)
-{
- FLAC__bool ok;
-
- ok =
- FLAC__bitwriter_write_raw_uint32(bw, FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN) &&
- (wasted_bits? FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1) : true) &&
- FLAC__bitwriter_write_raw_int64(bw, subframe->value, subframe_bps)
- ;
-
- return ok;
-}
-
-FLAC__bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, uint32_t residual_samples, uint32_t subframe_bps, uint32_t wasted_bits, FLAC__BitWriter *bw)
-{
- uint32_t i;
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK | (subframe->order<<1) | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN))
- return false;
- if(wasted_bits)
- if(!FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1))
- return false;
-
- for(i = 0; i < subframe->order; i++)
- if(!FLAC__bitwriter_write_raw_int64(bw, subframe->warmup[i], subframe_bps))
- return false;
-
- if(!add_entropy_coding_method_(bw, &subframe->entropy_coding_method))
- return false;
- switch(subframe->entropy_coding_method.type) {
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2:
- if(!add_residual_partitioned_rice_(
- bw,
- subframe->residual,
- residual_samples,
- subframe->order,
- subframe->entropy_coding_method.data.partitioned_rice.contents->parameters,
- subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits,
- subframe->entropy_coding_method.data.partitioned_rice.order,
- /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2
- ))
- return false;
- break;
- default:
- FLAC__ASSERT(0);
- }
-
- return true;
-}
-
-FLAC__bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, uint32_t residual_samples, uint32_t subframe_bps, uint32_t wasted_bits, FLAC__BitWriter *bw)
-{
- uint32_t i;
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK | ((subframe->order-1)<<1) | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN))
- return false;
- if(wasted_bits)
- if(!FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1))
- return false;
-
- for(i = 0; i < subframe->order; i++)
- if(!FLAC__bitwriter_write_raw_int64(bw, subframe->warmup[i], subframe_bps))
- return false;
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, subframe->qlp_coeff_precision-1, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN))
- return false;
- if(!FLAC__bitwriter_write_raw_int32(bw, subframe->quantization_level, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN))
- return false;
- for(i = 0; i < subframe->order; i++)
- if(!FLAC__bitwriter_write_raw_int32(bw, subframe->qlp_coeff[i], subframe->qlp_coeff_precision))
- return false;
-
- if(!add_entropy_coding_method_(bw, &subframe->entropy_coding_method))
- return false;
- switch(subframe->entropy_coding_method.type) {
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2:
- if(!add_residual_partitioned_rice_(
- bw,
- subframe->residual,
- residual_samples,
- subframe->order,
- subframe->entropy_coding_method.data.partitioned_rice.contents->parameters,
- subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits,
- subframe->entropy_coding_method.data.partitioned_rice.order,
- /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2
- ))
- return false;
- break;
- default:
- FLAC__ASSERT(0);
- }
-
- return true;
-}
-
-FLAC__bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, uint32_t samples, uint32_t subframe_bps, uint32_t wasted_bits, FLAC__BitWriter *bw)
-{
- uint32_t i;
-
- if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN))
- return false;
- if(wasted_bits)
- if(!FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1))
- return false;
-
- if(subframe->data_type == FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32) {
- const FLAC__int32 *signal = subframe->data.int32;
-
- FLAC__ASSERT(subframe_bps < 33);
-
- for(i = 0; i < samples; i++)
- if(!FLAC__bitwriter_write_raw_int32(bw, signal[i], subframe_bps))
- return false;
- }
- else {
- const FLAC__int64 *signal = subframe->data.int64;
-
- FLAC__ASSERT(subframe_bps == 33);
-
- for(i = 0; i < samples; i++)
- if(!FLAC__bitwriter_write_raw_int64(bw, (FLAC__int64)signal[i], subframe_bps))
- return false;
- }
-
- return true;
-}
-
-FLAC__bool add_entropy_coding_method_(FLAC__BitWriter *bw, const FLAC__EntropyCodingMethod *method)
-{
- if(!FLAC__bitwriter_write_raw_uint32(bw, method->type, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN))
- return false;
- switch(method->type) {
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
- case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2:
- if(!FLAC__bitwriter_write_raw_uint32(bw, method->data.partitioned_rice.order, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
- return false;
- break;
- default:
- FLAC__ASSERT(0);
- }
- return true;
-}
-
-FLAC__bool add_residual_partitioned_rice_(FLAC__BitWriter *bw, const FLAC__int32 residual[], const uint32_t residual_samples, const uint32_t predictor_order, const uint32_t rice_parameters[], const uint32_t raw_bits[], const uint32_t partition_order, const FLAC__bool is_extended)
-{
- const uint32_t plen = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN;
- const uint32_t pesc = is_extended? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER;
-
- if(partition_order == 0) {
- uint32_t i;
-
- if(raw_bits[0] == 0) {
- if(!FLAC__bitwriter_write_raw_uint32(bw, rice_parameters[0], plen))
- return false;
- if(!FLAC__bitwriter_write_rice_signed_block(bw, residual, residual_samples, rice_parameters[0]))
- return false;
- }
- else {
- FLAC__ASSERT(rice_parameters[0] == 0);
- if(!FLAC__bitwriter_write_raw_uint32(bw, pesc, plen))
- return false;
- if(!FLAC__bitwriter_write_raw_uint32(bw, raw_bits[0], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN))
- return false;
- for(i = 0; i < residual_samples; i++) {
- if(!FLAC__bitwriter_write_raw_int32(bw, residual[i], raw_bits[0]))
- return false;
- }
- }
- return true;
- }
- else {
- uint32_t i, j, k = 0, k_last = 0;
- uint32_t partition_samples;
- const uint32_t default_partition_samples = (residual_samples+predictor_order) >> partition_order;
- for(i = 0; i < (1u<
-#endif
-
-#include
-#include "../compat.h"
-#include "../assert.h"
-#include "../format.h"
-#include "include/private/window.h"
-
-#ifndef FLAC__INTEGER_ONLY_LIBRARY
-
-#if defined(_MSC_VER)
-// silence 25 MSVC warnings 'conversion from 'double' to 'float', possible loss of data'
-#pragma warning ( disable : 4244 )
-#endif
-
-void FLAC__window_bartlett(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- FLAC__int32 n;
-
- if (L & 1) {
- for (n = 0; n <= N/2; n++)
- window[n] = 2.0f * n / (float)N;
- for (; n <= N; n++)
- window[n] = 2.0f - 2.0f * n / (float)N;
- }
- else {
- for (n = 0; n <= L/2-1; n++)
- window[n] = 2.0f * n / (float)N;
- for (; n <= N; n++)
- window[n] = 2.0f - 2.0f * n / (float)N;
- }
-}
-
-void FLAC__window_bartlett_hann(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- FLAC__int32 n;
-
- for (n = 0; n < L; n++)
- window[n] = (FLAC__real)(0.62f - 0.48f * fabsf((float)n/(float)N-0.5f) - 0.38f * cosf(2.0f * M_PI * ((float)n/(float)N)));
-}
-
-void FLAC__window_blackman(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- FLAC__int32 n;
-
- for (n = 0; n < L; n++)
- window[n] = (FLAC__real)(0.42f - 0.5f * cosf(2.0f * M_PI * n / N) + 0.08f * cosf(4.0f * M_PI * n / N));
-}
-
-/* 4-term -92dB side-lobe */
-void FLAC__window_blackman_harris_4term_92db_sidelobe(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- FLAC__int32 n;
-
- for (n = 0; n <= N; n++)
- window[n] = (FLAC__real)(0.35875f - 0.48829f * cosf(2.0f * M_PI * n / N) + 0.14128f * cosf(4.0f * M_PI * n / N) - 0.01168f * cosf(6.0f * M_PI * n / N));
-}
-
-void FLAC__window_connes(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- const double N2 = (double)N / 2.;
- FLAC__int32 n;
-
- for (n = 0; n <= N; n++) {
- double k = ((double)n - N2) / N2;
- k = 1.0f - k * k;
- window[n] = (FLAC__real)(k * k);
- }
-}
-
-void FLAC__window_flattop(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- FLAC__int32 n;
-
- for (n = 0; n < L; n++)
- window[n] = (FLAC__real)(0.21557895f - 0.41663158f * cosf(2.0f * M_PI * n / N) + 0.277263158f * cosf(4.0f * M_PI * n / N) - 0.083578947f * cosf(6.0f * M_PI * n / N) + 0.006947368f * cosf(8.0f * M_PI * n / N));
-}
-
-void FLAC__window_gauss(FLAC__real *window, const FLAC__int32 L, const FLAC__real stddev)
-{
- const FLAC__int32 N = L - 1;
- const double N2 = (double)N / 2.;
- FLAC__int32 n;
-
- if(!(stddev > 0.0f && stddev <= 0.5f))
- /* stddev is not between 0 and 0.5, might be NaN.
- * Default to 0.5 */
- FLAC__window_gauss(window, L, 0.25f);
- else {
- for (n = 0; n <= N; n++) {
- const double k = ((double)n - N2) / (stddev * N2);
- window[n] = (FLAC__real)exp(-0.5f * k * k);
- }
- }
-}
-
-void FLAC__window_hamming(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- FLAC__int32 n;
-
- for (n = 0; n < L; n++)
- window[n] = (FLAC__real)(0.54f - 0.46f * cosf(2.0f * M_PI * n / N));
-}
-
-void FLAC__window_hann(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- FLAC__int32 n;
-
- for (n = 0; n < L; n++)
- window[n] = (FLAC__real)(0.5f - 0.5f * cosf(2.0f * M_PI * n / N));
-}
-
-void FLAC__window_kaiser_bessel(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- FLAC__int32 n;
-
- for (n = 0; n < L; n++)
- window[n] = (FLAC__real)(0.402f - 0.498f * cosf(2.0f * M_PI * n / N) + 0.098f * cosf(4.0f * M_PI * n / N) - 0.001f * cosf(6.0f * M_PI * n / N));
-}
-
-void FLAC__window_nuttall(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- FLAC__int32 n;
-
- for (n = 0; n < L; n++)
- window[n] = (FLAC__real)(0.3635819f - 0.4891775f*cosf(2.0f*M_PI*n/N) + 0.1365995f*cosf(4.0f*M_PI*n/N) - 0.0106411f*cosf(6.0f*M_PI*n/N));
-}
-
-void FLAC__window_rectangle(FLAC__real *window, const FLAC__int32 L)
-{
- FLAC__int32 n;
-
- for (n = 0; n < L; n++)
- window[n] = 1.0f;
-}
-
-void FLAC__window_triangle(FLAC__real *window, const FLAC__int32 L)
-{
- FLAC__int32 n;
-
- if (L & 1) {
- for (n = 1; n <= (L+1)/2; n++)
- window[n-1] = 2.0f * n / ((float)L + 1.0f);
- for (; n <= L; n++)
- window[n-1] = (float)(2 * (L - n + 1)) / ((float)L + 1.0f);
- }
- else {
- for (n = 1; n <= L/2; n++)
- window[n-1] = 2.0f * n / ((float)L + 1.0f);
- for (; n <= L; n++)
- window[n-1] = (float)(2 * (L - n + 1)) / ((float)L + 1.0f);
- }
-}
-
-void FLAC__window_tukey(FLAC__real *window, const FLAC__int32 L, const FLAC__real p)
-{
- if (p <= 0.0)
- FLAC__window_rectangle(window, L);
- else if (p >= 1.0)
- FLAC__window_hann(window, L);
- else if (!(p > 0.0f && p < 1.0f))
- /* p is not between 0 and 1, probably NaN.
- * Default to 0.5 */
- FLAC__window_tukey(window, L, 0.5f);
- else {
- const FLAC__int32 Np = (FLAC__int32)(p / 2.0f * L) - 1;
- FLAC__int32 n;
- /* start with rectangle... */
- FLAC__window_rectangle(window, L);
- /* ...replace ends with hann */
- if (Np > 0) {
- for (n = 0; n <= Np; n++) {
- window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * n / Np));
- window[L-Np-1+n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * (n+Np) / Np));
- }
- }
- }
-}
-
-void FLAC__window_partial_tukey(FLAC__real *window, const FLAC__int32 L, const FLAC__real p, const FLAC__real start, const FLAC__real end)
-{
- const FLAC__int32 start_n = (FLAC__int32)(start * L);
- const FLAC__int32 end_n = (FLAC__int32)(end * L);
- const FLAC__int32 N = end_n - start_n;
- FLAC__int32 Np, n, i;
-
- if (p <= 0.0f)
- FLAC__window_partial_tukey(window, L, 0.05f, start, end);
- else if (p >= 1.0f)
- FLAC__window_partial_tukey(window, L, 0.95f, start, end);
- else if (!(p > 0.0f && p < 1.0f))
- /* p is not between 0 and 1, probably NaN.
- * Default to 0.5 */
- FLAC__window_partial_tukey(window, L, 0.5f, start, end);
- else {
-
- Np = (FLAC__int32)(p / 2.0f * N);
-
- for (n = 0; n < start_n && n < L; n++)
- window[n] = 0.0f;
- for (i = 1; n < (start_n+Np) && n < L; n++, i++)
- window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Np));
- for (; n < (end_n-Np) && n < L; n++)
- window[n] = 1.0f;
- for (i = Np; n < end_n && n < L; n++, i--)
- window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Np));
- for (; n < L; n++)
- window[n] = 0.0f;
- }
-}
-
-void FLAC__window_punchout_tukey(FLAC__real *window, const FLAC__int32 L, const FLAC__real p, const FLAC__real start, const FLAC__real end)
-{
- const FLAC__int32 start_n = (FLAC__int32)(start * L);
- const FLAC__int32 end_n = (FLAC__int32)(end * L);
- FLAC__int32 Ns, Ne, n, i;
-
- if (p <= 0.0f)
- FLAC__window_punchout_tukey(window, L, 0.05f, start, end);
- else if (p >= 1.0f)
- FLAC__window_punchout_tukey(window, L, 0.95f, start, end);
- else if (!(p > 0.0f && p < 1.0f))
- /* p is not between 0 and 1, probably NaN.
- * Default to 0.5 */
- FLAC__window_punchout_tukey(window, L, 0.5f, start, end);
- else {
-
- Ns = (FLAC__int32)(p / 2.0f * start_n);
- Ne = (FLAC__int32)(p / 2.0f * (L - end_n));
-
- for (n = 0, i = 1; n < Ns && n < L; n++, i++)
- window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ns));
- for (; n < start_n-Ns && n < L; n++)
- window[n] = 1.0f;
- for (i = Ns; n < start_n && n < L; n++, i--)
- window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ns));
- for (; n < end_n && n < L; n++)
- window[n] = 0.0f;
- for (i = 1; n < end_n+Ne && n < L; n++, i++)
- window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ne));
- for (; n < L - (Ne) && n < L; n++)
- window[n] = 1.0f;
- for (i = Ne; n < L; n++, i--)
- window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ne));
- }
-}
-
-void FLAC__window_welch(FLAC__real *window, const FLAC__int32 L)
-{
- const FLAC__int32 N = L - 1;
- const double N2 = (double)N / 2.;
- FLAC__int32 n;
-
- for (n = 0; n <= N; n++) {
- const double k = ((double)n - N2) / N2;
- window[n] = (FLAC__real)(1.0f - k * k);
- }
-}
-
-#if defined(_MSC_VER)
-#pragma warning ( default : 4244 )
-#endif
-
-#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
diff --git a/modules/juce_audio_formats/codecs/flac_143/metadata.h b/modules/juce_audio_formats/codecs/flac_143/metadata.h
deleted file mode 100644
index 88763a0f42..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/metadata.h
+++ /dev/null
@@ -1,2234 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2001-2009 Josh Coalson
- * Copyright (C) 2011-2023 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 accommodated 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.
- *
- * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
- * internally translates to an appropriate representation to use with
- * _wfopen. On all other systems, filename is passed to fopen without
- * any translation.
- *
- * 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 (uint32_t)(-1) to mean "any width".
- * \param max_height The maximum height in pixels desired. Use
- * \c (uint32_t)(-1) to mean "any height".
- * \param max_depth The maximum color depth in bits-per-pixel desired.
- * Use \c (uint32_t)(-1) to mean "any depth".
- * \param max_colors The maximum number of colors desired. Use
- * \c (uint32_t)(-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, uint32_t max_width, uint32_t max_height, uint32_t max_depth, uint32_t 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.
- *
- * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
- * internally translates to an appropriate representation to use with
- * _wfopen. On all other systems, filename is passed to fopen without
- * any translation.
- *
- * \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 uint32_t
- * 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 uint32_t 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 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.
- *
- * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
- * internally translates to an appropriate representation to use with
- * _wfopen. On all other systems, filename is passed to fopen without
- * any translation.
- *
- * \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.
- *
- * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
- * internally translates to an appropriate representation to use with
- * _wfopen. On all other systems, filename is passed to fopen without
- * any translation.
- *
- * \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, uint32_t 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. If this function returns false, the
- * object is left untouched.
- *
- * \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, uint32_t 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, uint32_t 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, uint32_t 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, uint32_t 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, uint32_t 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[], uint32_t 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, uint32_t 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, uint32_t 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. If this function returns false, the
- * object is left untouched.
- *
- * \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, uint32_t 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, uint32_t 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, uint32_t 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 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, uint32_t 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, uint32_t 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, uint32_t 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. If this function returns false, the
- * track object is left untouched.
- *
- * \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, uint32_t track_num, uint32_t 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, uint32_t track_num, uint32_t 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, uint32_t track_num, uint32_t 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, uint32_t track_num, uint32_t 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. If this function returns false, the
- * object is left untouched.
- *
- * \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, uint32_t 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, uint32_t 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, uint32_t 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, uint32_t 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, uint32_t 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);
-
-
-/** Get the raw (binary) representation of a FLAC__StreamMetadata objeect.
- * After use, free() the returned buffer. The length of the buffer is
- * the length of the input metadata object plus 4 bytes for the header.
- *
- * \param object A pointer to metadata block to be converted.
- * \assert
- * \code object != NULL \endcode
- * \retval FLAC__byte*
- * \c NULL if there was an error, else a pointer to a buffer holding
- * the requested data.
- */
-FLAC_API FLAC__byte * FLAC__metadata_object_get_raw(const FLAC__StreamMetadata *object);
-
-
-/** Turn a raw (binary) representation into a FLAC__StreamMetadata objeect.
- * The returned object must be deleted with FLAC__metadata_object_delete()
- * after use.
- *
- * \param buffer A pointer to a buffer containing a binary representation
- * to be converted to a FLAC__StreamMetadata object
- * \param length The length of the supplied buffer
- * \retval FLAC__StreamMetadata*
- * \c NULL if there was an error, else a pointer to a FLAC__StreamMetadata
- * holding the requested data.
- */
-
-FLAC_API FLAC__StreamMetadata * FLAC__metadata_object_set_raw(FLAC__byte *buffer, FLAC__uint32 length);
-/* \} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/ordinals.h b/modules/juce_audio_formats/codecs/flac_143/ordinals.h
deleted file mode 100644
index 81fa201037..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/ordinals.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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
-
-/* This of course assumes C99 headers */
-
-#include
-#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;
-
-typedef int FLAC__bool;
-
-typedef FLAC__uint8 FLAC__byte;
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/flac_143/stream_decoder.h b/modules/juce_audio_formats/codecs/flac_143/stream_decoder.h
deleted file mode 100644
index ff1981fcc0..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/stream_decoder.h
+++ /dev/null
@@ -1,1584 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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 or write 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. \c FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA is
- * caused by finding data that doesn't fit a metadata block (too large
- * or too small) or finding inconsistencies in the metadata, for example
- * a PICTURE block with an image that exceeds the size of the metadata
- * block.
- */
-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__STREAM_DECODER_ERROR_STATUS_BAD_METADATA
- /**< The decoder encountered a corrupted metadata block. */
-
-} 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 uint32_t
- * 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 uint32_t
- * See above.
- */
-FLAC_API uint32_t 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 uint32_t
- * See above.
- */
-FLAC_API uint32_t 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 uint32_t
- * See above.
- */
-FLAC_API uint32_t 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 uint32_t
- * See above.
- */
-FLAC_API uint32_t 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);
-
-/** Return client_data from decoder.
- * The data pointed to by the pointer should not be modified.
- *
- * \param decoder A decoder instance.
- * \retval const void *
- * The callee's client data set through FLAC__stream_decoder_init_*().
- * Do not modify the contents.
- */
-FLAC_API const void *FLAC__stream_decoder_get_client_data(FLAC__StreamDecoder *decoder);
-
-/** 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 stdin 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 stdin 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, you must
- * use FLAC__stream_decoder_init_FILE(), or FLAC__stream_decoder_init_stream()
- * and provide callbacks for the I/O.
- *
- * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
- * internally translates to an appropriate representation to use with
- * _wfopen. On all other systems, filename is passed to fopen without
- * any translation.
- *
- * 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, you must use
- * FLAC__stream_decoder_init_ogg_FILE(), or FLAC__stream_decoder_init_ogg_stream()
- * and provide callbacks for the I/O.
- *
- * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
- * internally translates to an appropriate representation to use with
- * _wfopen. On all other systems, filename is passed to fopen without
- * any translation.
- *
- * 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_*() 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/modules/juce_audio_formats/codecs/flac_143/stream_encoder.h b/modules/juce_audio_formats/codecs/flac_143/stream_encoder.h
deleted file mode 100644
index 6d2d1d11ef..0000000000
--- a/modules/juce_audio_formats/codecs/flac_143/stream_encoder.h
+++ /dev/null
@@ -1,1837 +0,0 @@
-/* libFLAC - Free Lossless Audio Codec library
- * Copyright (C) 2000-2009 Josh Coalson
- * Copyright (C) 2011-2023 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.
- */
-
- 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, uint32_t samples, uint32_t 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, uint32_t frames_written, uint32_t 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, uint32_t 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, uint32_t 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, uint32_t 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 | subdivide_tukey(2) | 8 | 0 | false | false | false | 0 | 6 | 0 |
- * | 7 | true | false | subdivide_tukey(2) | 12 | 0 | false | false | false | 0 | 6 | 0 |
- * | 8 | true | false | subdivide_tukey(3) | 12 | 0 | false | false | false | 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, uint32_t 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, uint32_t 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 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_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 partial_tukey(n[/ov[/P]]),
- * \c punchout_tukey(n[/ov[/P]]), \c subdivide_tukey(n[/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, uint32_t 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 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_max_residual_partition_order(FLAC__StreamEncoder *encoder, uint32_t 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, uint32_t 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, uint32_t num_blocks);
-
-/** Set to \c true to make the encoder not output frames which contain
- * only constant subframes. This is beneficial for streaming
- * applications: very small frames can cause problems with buffering
- * as bitrates can drop as low 1kbit/s for CDDA audio encoded within
- * subset. The minimum bitrate for a FLAC file encoded with this
- * function used is raised to 1bit/sample (i.e. 48kbit/s for 48kHz
- * material).
- *
- * \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_limit_min_bitrate(FLAC__StreamEncoder *encoder, FLAC__bool value);
-
-/** 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, uint32_t *frame_number, uint32_t *channel, uint32_t *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 Subset flag.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__bool
- * See FLAC__stream_encoder_set_streamable_subset().
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder);
-
-/** Get the number of input channels being processed.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval uint32_t
- * See FLAC__stream_encoder_set_channels().
- */
-FLAC_API uint32_t FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder);
-
-/** Get the input sample resolution setting.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval uint32_t
- * See FLAC__stream_encoder_set_bits_per_sample().
- */
-FLAC_API uint32_t FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder);
-
-/** Get the input sample rate setting.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval uint32_t
- * See FLAC__stream_encoder_set_sample_rate().
- */
-FLAC_API uint32_t FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder);
-
-/** Get the blocksize setting.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval uint32_t
- * See FLAC__stream_encoder_set_blocksize().
- */
-FLAC_API uint32_t FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder);
-
-/** Get the "mid/side stereo coding" flag.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__bool
- * See FLAC__stream_encoder_get_do_mid_side_stereo().
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder);
-
-/** Get the "adaptive mid/side switching" flag.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__bool
- * See FLAC__stream_encoder_set_loose_mid_side_stereo().
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder);
-
-/** Get the maximum LPC order setting.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval uint32_t
- * See FLAC__stream_encoder_set_max_lpc_order().
- */
-FLAC_API uint32_t FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder);
-
-/** Get the quantized linear predictor coefficient precision setting.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval uint32_t
- * See FLAC__stream_encoder_set_qlp_coeff_precision().
- */
-FLAC_API uint32_t FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder);
-
-/** Get the qlp coefficient precision search flag.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__bool
- * See FLAC__stream_encoder_set_do_qlp_coeff_prec_search().
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder);
-
-/** Get the "escape coding" flag.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__bool
- * See FLAC__stream_encoder_set_do_escape_coding().
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder);
-
-/** Get the exhaustive model search flag.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__bool
- * See FLAC__stream_encoder_set_do_exhaustive_model_search().
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder);
-
-/** Get the minimum residual partition order setting.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval uint32_t
- * See FLAC__stream_encoder_set_min_residual_partition_order().
- */
-FLAC_API uint32_t FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder);
-
-/** Get maximum residual partition order setting.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval uint32_t
- * See FLAC__stream_encoder_set_max_residual_partition_order().
- */
-FLAC_API uint32_t FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder);
-
-/** Get the Rice parameter search distance setting.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval uint32_t
- * See FLAC__stream_encoder_set_rice_parameter_search_dist().
- */
-FLAC_API uint32_t FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder);
-
-/** Get the previously set estimate of the total samples to be encoded.
- * The encoder merely mimics back the value given to
- * FLAC__stream_encoder_set_total_samples_estimate() since it has no
- * other way of knowing how many samples the client will encode.
- *
- * \param encoder An encoder instance to set.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__uint64
- * See FLAC__stream_encoder_get_total_samples_estimate().
- */
-FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder);
-
-/** Get the "limit_min_bitrate" flag.
- *
- * \param encoder An encoder instance to query.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__bool
- * See FLAC__stream_encoder_set_limit_min_bitrate().
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_get_limit_min_bitrate(const FLAC__StreamEncoder *encoder);
-
-/** Initialize the encoder instance to encode native FLAC streams.
- *
- * This flavor of initialization sets up the encoder to encode to a
- * native FLAC stream. I/O is performed via callbacks to the client.
- * For encoding to a plain file via filename or open \c FILE*,
- * FLAC__stream_encoder_init_file() and FLAC__stream_encoder_init_FILE()
- * provide a simpler interface.
- *
- * This function should be called after FLAC__stream_encoder_new() and
- * FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
- * or FLAC__stream_encoder_process_interleaved().
- * initialization succeeded.
- *
- * The call to FLAC__stream_encoder_init_stream() currently will also
- * immediately call the write callback several times, once with the \c fLaC
- * signature, and once for each encoded metadata block.
- *
- * \param encoder An uninitialized encoder instance.
- * \param write_callback See FLAC__StreamEncoderWriteCallback. This
- * pointer must not be \c NULL.
- * \param seek_callback See FLAC__StreamEncoderSeekCallback. This
- * pointer may be \c NULL if seeking is not
- * supported. The encoder uses seeking to go back
- * and write some some stream statistics to the
- * STREAMINFO block; this is recommended but not
- * necessary to create a valid FLAC stream. If
- * \a seek_callback is not \c NULL then a
- * \a tell_callback must also be supplied.
- * Alternatively, a dummy seek callback that just
- * returns \c FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED
- * may also be supplied, all though this is slightly
- * less efficient for the encoder.
- * \param tell_callback See FLAC__StreamEncoderTellCallback. This
- * pointer may be \c NULL if seeking is not
- * supported. If \a seek_callback is \c NULL then
- * this argument will be ignored. 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_ENCODER_TELL_STATUS_UNSUPPORTED
- * may also be supplied, all though this is slightly
- * less efficient for the encoder.
- * \param metadata_callback See FLAC__StreamEncoderMetadataCallback. This
- * pointer may be \c NULL if the callback is not
- * desired. If the client provides a seek callback,
- * this function is not necessary as the encoder
- * will automatically seek back and update the
- * STREAMINFO block. It may also be \c NULL if the
- * client does not support seeking, since it will
- * have no way of going back to update the
- * STREAMINFO. However the client can still supply
- * a callback if it would like to know the details
- * from the STREAMINFO.
- * \param client_data This value will be supplied to callbacks in their
- * \a client_data argument.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__StreamEncoderInitStatus
- * \c FLAC__STREAM_ENCODER_INIT_STATUS_OK if initialization was successful;
- * see FLAC__StreamEncoderInitStatus for the meanings of other return values.
- */
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_stream(FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteCallback write_callback, FLAC__StreamEncoderSeekCallback seek_callback, FLAC__StreamEncoderTellCallback tell_callback, FLAC__StreamEncoderMetadataCallback metadata_callback, void *client_data);
-
-/** Initialize the encoder instance to encode Ogg FLAC streams.
- *
- * This flavor of initialization sets up the encoder to encode to a FLAC
- * stream in an Ogg container. I/O is performed via callbacks to the
- * client. For encoding to a plain file via filename or open \c FILE*,
- * FLAC__stream_encoder_init_ogg_file() and FLAC__stream_encoder_init_ogg_FILE()
- * provide a simpler interface.
- *
- * This function should be called after FLAC__stream_encoder_new() and
- * FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
- * or FLAC__stream_encoder_process_interleaved().
- * initialization succeeded.
- *
- * The call to FLAC__stream_encoder_init_ogg_stream() currently will also
- * immediately call the write callback several times to write the metadata
- * packets.
- *
- * \param encoder An uninitialized encoder instance.
- * \param read_callback See FLAC__StreamEncoderReadCallback. This
- * pointer must not be \c NULL if \a seek_callback
- * is non-NULL since they are both needed to be
- * able to write data back to the Ogg FLAC stream
- * in the post-encode phase.
- * \param write_callback See FLAC__StreamEncoderWriteCallback. This
- * pointer must not be \c NULL.
- * \param seek_callback See FLAC__StreamEncoderSeekCallback. This
- * pointer may be \c NULL if seeking is not
- * supported. The encoder uses seeking to go back
- * and write some some stream statistics to the
- * STREAMINFO block; this is recommended but not
- * necessary to create a valid FLAC stream. If
- * \a seek_callback is not \c NULL then a
- * \a tell_callback must also be supplied.
- * Alternatively, a dummy seek callback that just
- * returns \c FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED
- * may also be supplied, all though this is slightly
- * less efficient for the encoder.
- * \param tell_callback See FLAC__StreamEncoderTellCallback. This
- * pointer may be \c NULL if seeking is not
- * supported. If \a seek_callback is \c NULL then
- * this argument will be ignored. 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_ENCODER_TELL_STATUS_UNSUPPORTED
- * may also be supplied, all though this is slightly
- * less efficient for the encoder.
- * \param metadata_callback See FLAC__StreamEncoderMetadataCallback. This
- * pointer may be \c NULL if the callback is not
- * desired. If the client provides a seek callback,
- * this function is not necessary as the encoder
- * will automatically seek back and update the
- * STREAMINFO block. It may also be \c NULL if the
- * client does not support seeking, since it will
- * have no way of going back to update the
- * STREAMINFO. However the client can still supply
- * a callback if it would like to know the details
- * from the STREAMINFO.
- * \param client_data This value will be supplied to callbacks in their
- * \a client_data argument.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__StreamEncoderInitStatus
- * \c FLAC__STREAM_ENCODER_INIT_STATUS_OK if initialization was successful;
- * see FLAC__StreamEncoderInitStatus for the meanings of other return values.
- */
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_stream(FLAC__StreamEncoder *encoder, FLAC__StreamEncoderReadCallback read_callback, FLAC__StreamEncoderWriteCallback write_callback, FLAC__StreamEncoderSeekCallback seek_callback, FLAC__StreamEncoderTellCallback tell_callback, FLAC__StreamEncoderMetadataCallback metadata_callback, void *client_data);
-
-/** Initialize the encoder instance to encode native FLAC files.
- *
- * This flavor of initialization sets up the encoder to encode to a
- * plain native FLAC file. For non-stdio streams, you must use
- * FLAC__stream_encoder_init_stream() and provide callbacks for the I/O.
- *
- * This function should be called after FLAC__stream_encoder_new() and
- * FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
- * or FLAC__stream_encoder_process_interleaved().
- * initialization succeeded.
- *
- * \param encoder An uninitialized encoder instance.
- * \param file An open file. The file should have been opened
- * with mode \c "w+b" and rewound. The file
- * becomes owned by the encoder and should not be
- * manipulated by the client while encoding.
- * Unless \a file is \c stdout, it will be closed
- * when FLAC__stream_encoder_finish() is called.
- * Note however that a proper SEEKTABLE cannot be
- * created when encoding to \c stdout since it is
- * not seekable.
- * \param progress_callback See FLAC__StreamEncoderProgressCallback. This
- * pointer may be \c NULL if the callback is not
- * desired.
- * \param client_data This value will be supplied to callbacks in their
- * \a client_data argument.
- * \assert
- * \code encoder != NULL \endcode
- * \code file != NULL \endcode
- * \retval FLAC__StreamEncoderInitStatus
- * \c FLAC__STREAM_ENCODER_INIT_STATUS_OK if initialization was successful;
- * see FLAC__StreamEncoderInitStatus for the meanings of other return values.
- */
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_FILE(FLAC__StreamEncoder *encoder, FILE *file, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data);
-
-/** Initialize the encoder instance to encode Ogg FLAC files.
- *
- * This flavor of initialization sets up the encoder to encode to a
- * plain Ogg FLAC file. For non-stdio streams, you must use
- * FLAC__stream_encoder_init_ogg_stream() and provide callbacks for the I/O.
- *
- * This function should be called after FLAC__stream_encoder_new() and
- * FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
- * or FLAC__stream_encoder_process_interleaved().
- * initialization succeeded.
- *
- * \param encoder An uninitialized encoder instance.
- * \param file An open file. The file should have been opened
- * with mode \c "w+b" and rewound. The file
- * becomes owned by the encoder and should not be
- * manipulated by the client while encoding.
- * Unless \a file is \c stdout, it will be closed
- * when FLAC__stream_encoder_finish() is called.
- * Note however that a proper SEEKTABLE cannot be
- * created when encoding to \c stdout since it is
- * not seekable.
- * \param progress_callback See FLAC__StreamEncoderProgressCallback. This
- * pointer may be \c NULL if the callback is not
- * desired.
- * \param client_data This value will be supplied to callbacks in their
- * \a client_data argument.
- * \assert
- * \code encoder != NULL \endcode
- * \code file != NULL \endcode
- * \retval FLAC__StreamEncoderInitStatus
- * \c FLAC__STREAM_ENCODER_INIT_STATUS_OK if initialization was successful;
- * see FLAC__StreamEncoderInitStatus for the meanings of other return values.
- */
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_FILE(FLAC__StreamEncoder *encoder, FILE *file, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data);
-
-/** Initialize the encoder instance to encode native FLAC files.
- *
- * This flavor of initialization sets up the encoder to encode to a plain
- * FLAC file. If POSIX fopen() semantics are not sufficient you must use
- * FLAC__stream_encoder_init_FILE(), or FLAC__stream_encoder_init_stream()
- * and provide callbacks for the I/O.
- *
- * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
- * internally translates to an appropriate representation to use with
- * _wfopen. On all other systems, filename is passed to fopen without
- * any translation.
- *
- * This function should be called after FLAC__stream_encoder_new() and
- * FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
- * or FLAC__stream_encoder_process_interleaved().
- * initialization succeeded.
- *
- * \param encoder An uninitialized encoder instance.
- * \param filename The name of the file to encode to. The file will
- * be opened with fopen(). Use \c NULL to encode to
- * \c stdout. Note however that a proper SEEKTABLE
- * cannot be created when encoding to \c stdout since
- * it is not seekable.
- * \param progress_callback See FLAC__StreamEncoderProgressCallback. This
- * pointer may be \c NULL if the callback is not
- * desired.
- * \param client_data This value will be supplied to callbacks in their
- * \a client_data argument.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__StreamEncoderInitStatus
- * \c FLAC__STREAM_ENCODER_INIT_STATUS_OK if initialization was successful;
- * see FLAC__StreamEncoderInitStatus for the meanings of other return values.
- */
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_file(FLAC__StreamEncoder *encoder, const char *filename, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data);
-
-/** Initialize the encoder instance to encode Ogg FLAC files.
- *
- * This flavor of initialization sets up the encoder to encode to a plain
- * Ogg FLAC file. If POSIX fopen() semantics are not sufficient, you must use
- * FLAC__stream_encoder_init_ogg_FILE(), or FLAC__stream_encoder_init_ogg_stream()
- * and provide callbacks for the I/O.
- *
- * On Windows, filename must be a UTF-8 encoded filename, which libFLAC
- * internally translates to an appropriate representation to use with
- * _wfopen. On all other systems, filename is passed to fopen without
- * any translation.
- *
- * This function should be called after FLAC__stream_encoder_new() and
- * FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
- * or FLAC__stream_encoder_process_interleaved().
- * initialization succeeded.
- *
- * \param encoder An uninitialized encoder instance.
- * \param filename The name of the file to encode to. The file will
- * be opened with fopen(). Use \c NULL to encode to
- * \c stdout. Note however that a proper SEEKTABLE
- * cannot be created when encoding to \c stdout since
- * it is not seekable.
- * \param progress_callback See FLAC__StreamEncoderProgressCallback. This
- * pointer may be \c NULL if the callback is not
- * desired.
- * \param client_data This value will be supplied to callbacks in their
- * \a client_data argument.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__StreamEncoderInitStatus
- * \c FLAC__STREAM_ENCODER_INIT_STATUS_OK if initialization was successful;
- * see FLAC__StreamEncoderInitStatus for the meanings of other return values.
- */
-FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_file(FLAC__StreamEncoder *encoder, const char *filename, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data);
-
-/** Finish the encoding process.
- * Flushes the encoding buffer, releases resources, resets the encoder
- * settings to their defaults, and returns the encoder state to
- * FLAC__STREAM_ENCODER_UNINITIALIZED. Note that this can generate
- * one or more write callbacks before returning, and will generate
- * a metadata callback.
- *
- * Note that in the course of processing the last frame, errors can
- * occur, so the caller should be sure to check the return value to
- * ensure the file was encoded properly.
- *
- * In the event of a prematurely-terminated encode, it is not strictly
- * necessary to call this immediately before FLAC__stream_encoder_delete()
- * but it is good practice to match every FLAC__stream_encoder_init_*()
- * with a FLAC__stream_encoder_finish().
- *
- * \param encoder An uninitialized encoder instance.
- * \assert
- * \code encoder != NULL \endcode
- * \retval FLAC__bool
- * \c false if an error occurred processing the last frame; or if verify
- * mode is set (see FLAC__stream_encoder_set_verify()), there was a
- * verify mismatch; else \c true. If \c false, caller should check the
- * state with FLAC__stream_encoder_get_state() for more information
- * about the error.
- */
-FLAC_API FLAC__bool FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder);
-
-/** Submit data for encoding.
- * This version allows you to supply the input data via an array of
- * pointers, each pointer pointing to an array of \a samples samples
- * representing one channel. The samples need not be block-aligned,
- * but each channel should have the same number of samples. 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 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[], uint32_t 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[], uint32_t samples);
-
-/* \} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/modules/juce_audio_formats/codecs/juce_FlacAudioFormat.cpp b/modules/juce_audio_formats/codecs/juce_FlacAudioFormat.cpp
index c689bccc55..00eaa38236 100644
--- a/modules/juce_audio_formats/codecs/juce_FlacAudioFormat.cpp
+++ b/modules/juce_audio_formats/codecs/juce_FlacAudioFormat.cpp
@@ -93,7 +93,7 @@ namespace FlacNamespace
#if JUCE_INCLUDE_FLAC_CODE || ! defined (JUCE_INCLUDE_FLAC_CODE)
#undef PACKAGE_VERSION
- #define PACKAGE_VERSION "1.3.4"
+ #define PACKAGE_VERSION "1.4.3"
#define FLAC__NO_DLL 1
@@ -132,6 +132,15 @@ namespace FlacNamespace
#define FLAC__HAS_X86INTRIN 1
#endif
+ #if JUCE_ARM && JUCE_64BIT
+ #define FLAC__CPU_ARM64 1
+
+ #if JUCE_USE_ARM_NEON
+ #define FLAC__HAS_NEONINTRIN 1
+ #define FLAC__HAS_A64NEONINTRIN 1
+ #endif
+ #endif
+
#define flac_max jmax
#define flac_min jmin
@@ -153,6 +162,7 @@ namespace FlacNamespace
#include "flac/libFLAC/float.c"
#include "flac/libFLAC/format.c"
#include "flac/libFLAC/lpc_flac.c"
+ #include "flac/libFLAC/lpc_intrin_neon.c"
#include "flac/libFLAC/md5.c"
#include "flac/libFLAC/memory.c"
#include "flac/libFLAC/stream_decoder.c"