/src/flac/src/libFLAC++/stream_encoder.cpp

Source (jump to first uncovered line)
/* libFLAC++ - Free Lossless Audio Codec library
 * Copyright (C) 2002-2009  Josh Coalson
 * Copyright (C) 2011-2025  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 "config.h"
#endif

#include "FLAC++/encoder.h"
#include "FLAC++/metadata.h"
#include "FLAC/assert.h"

#ifdef _MSC_VER
// warning C4800: 'int' : forcing to bool 'true' or 'false' (performance warning)
#pragma warning ( disable : 4800 )
#endif

namespace FLAC {
  namespace Encoder {

    // ------------------------------------------------------------
    //
    // Stream
    //
    // ------------------------------------------------------------

    Stream::Stream():
    encoder_(::FLAC__stream_encoder_new())
    { }

    Stream::~Stream()
    {
      if(0 != encoder_) {
        (void)::FLAC__stream_encoder_finish(encoder_);
        ::FLAC__stream_encoder_delete(encoder_);
      }
    }

    bool Stream::is_valid() const
    {
      return 0 != encoder_;
    }

    bool Stream::set_ogg_serial_number(long value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_ogg_serial_number(encoder_, value));
    }

    bool Stream::set_verify(bool value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_verify(encoder_, value));
    }

    bool Stream::set_streamable_subset(bool value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_streamable_subset(encoder_, value));
    }

    bool Stream::set_channels(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_channels(encoder_, value));
    }

    bool Stream::set_bits_per_sample(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_bits_per_sample(encoder_, value));
    }

    bool Stream::set_sample_rate(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_sample_rate(encoder_, value));
    }

    bool Stream::set_compression_level(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_compression_level(encoder_, value));
    }

    bool Stream::set_blocksize(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_blocksize(encoder_, value));
    }

    bool Stream::set_do_mid_side_stereo(bool value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_do_mid_side_stereo(encoder_, value));
    }

    bool Stream::set_loose_mid_side_stereo(bool value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_loose_mid_side_stereo(encoder_, value));
    }

    bool Stream::set_apodization(const char *specification)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_apodization(encoder_, specification));
    }

    bool Stream::set_max_lpc_order(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_max_lpc_order(encoder_, value));
    }

    bool Stream::set_qlp_coeff_precision(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_qlp_coeff_precision(encoder_, value));
    }

    bool Stream::set_do_qlp_coeff_prec_search(bool value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder_, value));
    }

    bool Stream::set_do_escape_coding(bool value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_do_escape_coding(encoder_, value));
    }

    bool Stream::set_do_exhaustive_model_search(bool value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_do_exhaustive_model_search(encoder_, value));
    }

    bool Stream::set_min_residual_partition_order(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_min_residual_partition_order(encoder_, value));
    }

    bool Stream::set_max_residual_partition_order(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_max_residual_partition_order(encoder_, value));
    }

    bool Stream::set_rice_parameter_search_dist(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_rice_parameter_search_dist(encoder_, value));
    }

    bool Stream::set_total_samples_estimate(FLAC__uint64 value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_total_samples_estimate(encoder_, value));
    }

    bool Stream::set_metadata(::FLAC__StreamMetadata **metadata, uint32_t num_blocks)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_metadata(encoder_, metadata, num_blocks));
    }

    bool Stream::set_metadata(FLAC::Metadata::Prototype **metadata, uint32_t num_blocks)
    {
      FLAC__ASSERT(is_valid());
      // because C++ doesn't have VLA's (variable length arrays)
      // this ugly workaround is needed
      ::FLAC__StreamMetadata **m = new ::FLAC__StreamMetadata*[num_blocks];
      for(uint32_t i = 0; i < num_blocks; i++) {
        // we can get away with the const_cast since we know the encoder will only correct the is_last flags
        m[i] = const_cast< ::FLAC__StreamMetadata*>(static_cast<const ::FLAC__StreamMetadata*>(*metadata[i]));
      }
      // complete the hack
      const bool ok = static_cast<bool>(::FLAC__stream_encoder_set_metadata(encoder_, m, num_blocks));
      delete [] m;
      return ok;
    }

    bool Stream::set_limit_min_bitrate(bool value)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_set_limit_min_bitrate(encoder_, value));
    }

    uint32_t Stream::set_num_threads(uint32_t value)
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_set_num_threads(encoder_, value);
    }

    Stream::State Stream::get_state() const
    {
      FLAC__ASSERT(is_valid());
      return State(::FLAC__stream_encoder_get_state(encoder_));
    }

    Decoder::Stream::State Stream::get_verify_decoder_state() const
    {
      FLAC__ASSERT(is_valid());
      return Decoder::Stream::State(::FLAC__stream_encoder_get_verify_decoder_state(encoder_));
    }

    void Stream::get_verify_decoder_error_stats(FLAC__uint64 *absolute_sample, uint32_t *frame_number, uint32_t *channel, uint32_t *sample, FLAC__int32 *expected, FLAC__int32 *got)
    {
      FLAC__ASSERT(is_valid());
      ::FLAC__stream_encoder_get_verify_decoder_error_stats(encoder_, absolute_sample, frame_number, channel, sample, expected, got);
    }

    bool Stream::get_verify() const
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_get_verify(encoder_));
    }

    bool Stream::get_streamable_subset() const
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_get_streamable_subset(encoder_));
    }

    bool Stream::get_do_mid_side_stereo() const
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_get_do_mid_side_stereo(encoder_));
    }

    bool Stream::get_loose_mid_side_stereo() const
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_get_loose_mid_side_stereo(encoder_));
    }

    uint32_t Stream::get_channels() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_channels(encoder_);
    }

    uint32_t Stream::get_bits_per_sample() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_bits_per_sample(encoder_);
    }

    uint32_t Stream::get_sample_rate() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_sample_rate(encoder_);
    }

    uint32_t Stream::get_blocksize() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_blocksize(encoder_);
    }

    uint32_t Stream::get_max_lpc_order() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_max_lpc_order(encoder_);
    }

    uint32_t Stream::get_qlp_coeff_precision() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_qlp_coeff_precision(encoder_);
    }

    bool Stream::get_do_qlp_coeff_prec_search() const
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder_));
    }

    bool Stream::get_do_escape_coding() const
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_get_do_escape_coding(encoder_));
    }

    bool Stream::get_do_exhaustive_model_search() const
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_get_do_exhaustive_model_search(encoder_));
    }

    uint32_t Stream::get_min_residual_partition_order() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_min_residual_partition_order(encoder_);
    }

    uint32_t Stream::get_max_residual_partition_order() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_max_residual_partition_order(encoder_);
    }

    uint32_t Stream::get_rice_parameter_search_dist() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_rice_parameter_search_dist(encoder_);
    }

    FLAC__uint64 Stream::get_total_samples_estimate() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_total_samples_estimate(encoder_);
    }

    bool Stream::get_limit_min_bitrate() const
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_get_limit_min_bitrate(encoder_));
    }

    uint32_t Stream::get_num_threads() const
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_get_num_threads(encoder_);
    }

    ::FLAC__StreamEncoderInitStatus Stream::init()
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_init_stream(encoder_, write_callback_, seek_callback_, tell_callback_, metadata_callback_, /*client_data=*/(void*)this);
    }

    ::FLAC__StreamEncoderInitStatus Stream::init_ogg()
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_init_ogg_stream(encoder_, read_callback_, write_callback_, seek_callback_, tell_callback_, metadata_callback_, /*client_data=*/(void*)this);
    }

    bool Stream::finish()
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_finish(encoder_));
    }

    bool Stream::process(const FLAC__int32 * const buffer[], uint32_t samples)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_process(encoder_, buffer, samples));
    }

    bool Stream::process_interleaved(const FLAC__int32 buffer[], uint32_t samples)
    {
      FLAC__ASSERT(is_valid());
      return static_cast<bool>(::FLAC__stream_encoder_process_interleaved(encoder_, buffer, samples));
    }

    ::FLAC__StreamEncoderReadStatus Stream::read_callback(FLAC__byte buffer[], size_t *bytes)
    {
      (void)buffer, (void)bytes;
      return ::FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED;
    }

    ::FLAC__StreamEncoderSeekStatus Stream::seek_callback(FLAC__uint64 absolute_byte_offset)
    {
      (void)absolute_byte_offset;
      return ::FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED;
    }

    ::FLAC__StreamEncoderTellStatus Stream::tell_callback(FLAC__uint64 *absolute_byte_offset)
    {
      (void)absolute_byte_offset;
      return ::FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED;
    }

    void Stream::metadata_callback(const ::FLAC__StreamMetadata *metadata)
    {
      (void)metadata;
    }

    ::FLAC__StreamEncoderReadStatus Stream::read_callback_(const ::FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
    {
      (void)encoder;
      FLAC__ASSERT(0 != client_data);
      Stream *instance = reinterpret_cast<Stream *>(client_data);
      FLAC__ASSERT(0 != instance);
      return instance->read_callback(buffer, bytes);
    }

    ::FLAC__StreamEncoderWriteStatus Stream::write_callback_(const ::FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame, void *client_data)
    {
      (void)encoder;
      FLAC__ASSERT(0 != client_data);
      Stream *instance = reinterpret_cast<Stream *>(client_data);
      FLAC__ASSERT(0 != instance);
      return instance->write_callback(buffer, bytes, samples, current_frame);
    }

    ::FLAC__StreamEncoderSeekStatus Stream::seek_callback_(const ::FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
    {
      (void)encoder;
      FLAC__ASSERT(0 != client_data);
      Stream *instance = reinterpret_cast<Stream *>(client_data);
      FLAC__ASSERT(0 != instance);
      return instance->seek_callback(absolute_byte_offset);
    }

    ::FLAC__StreamEncoderTellStatus Stream::tell_callback_(const ::FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
    {
      (void)encoder;
      FLAC__ASSERT(0 != client_data);
      Stream *instance = reinterpret_cast<Stream *>(client_data);
      FLAC__ASSERT(0 != instance);
      return instance->tell_callback(absolute_byte_offset);
    }

    void Stream::metadata_callback_(const ::FLAC__StreamEncoder *encoder, const ::FLAC__StreamMetadata *metadata, void *client_data)
    {
      (void)encoder;
      FLAC__ASSERT(0 != client_data);
      Stream *instance = reinterpret_cast<Stream *>(client_data);
      FLAC__ASSERT(0 != instance);
      instance->metadata_callback(metadata);
    }

    // ------------------------------------------------------------
    //
    // File
    //
    // ------------------------------------------------------------

    File::File():
      Stream()
    { }

    File::~File()
    {
    }

    ::FLAC__StreamEncoderInitStatus File::init(FILE *file)
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_init_FILE(encoder_, file, progress_callback_, /*client_data=*/(void*)this);
    }

    ::FLAC__StreamEncoderInitStatus File::init(const char *filename)
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_init_file(encoder_, filename, progress_callback_, /*client_data=*/(void*)this);
    }

    ::FLAC__StreamEncoderInitStatus File::init(const std::string &filename)
    {
      return init(filename.c_str());
    }

    ::FLAC__StreamEncoderInitStatus File::init_ogg(FILE *file)
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_init_ogg_FILE(encoder_, file, progress_callback_, /*client_data=*/(void*)this);
    }

    ::FLAC__StreamEncoderInitStatus File::init_ogg(const char *filename)
    {
      FLAC__ASSERT(is_valid());
      return ::FLAC__stream_encoder_init_ogg_file(encoder_, filename, progress_callback_, /*client_data=*/(void*)this);
    }

    ::FLAC__StreamEncoderInitStatus File::init_ogg(const std::string &filename)
    {
      return init_ogg(filename.c_str());
    }

    // This is a dummy to satisfy the pure virtual from Stream; the
    // read callback will never be called since we are initializing
    // with FLAC__stream_decoder_init_FILE() or
    // FLAC__stream_decoder_init_file() and those supply the read
    // callback internally.
    ::FLAC__StreamEncoderWriteStatus File::write_callback(const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame)
    {
      (void)buffer, (void)bytes, (void)samples, (void)current_frame;
      FLAC__ASSERT(false);
      return ::FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; // double protection
    }

    void File::progress_callback(FLAC__uint64 bytes_written, FLAC__uint64 samples_written, uint32_t frames_written, uint32_t total_frames_estimate)
    {
      (void)bytes_written, (void)samples_written, (void)frames_written, (void)total_frames_estimate;
    }

    void File::progress_callback_(const ::FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, uint32_t frames_written, uint32_t total_frames_estimate, void *client_data)
    {
      (void)encoder;
      FLAC__ASSERT(0 != client_data);
      File *instance = reinterpret_cast<File *>(client_data);
      FLAC__ASSERT(0 != instance);
      instance->progress_callback(bytes_written, samples_written, frames_written, total_frames_estimate);
    }

  } // namespace Encoder
} // namespace FLAC

Coverage Report

Created: 2025-03-11 06:14

Line	Count	Source (jump to first uncovered line)
1		/* libFLAC++ - Free Lossless Audio Codec library
2		* Copyright (C) 2002-2009 Josh Coalson
3		* Copyright (C) 2011-2025 Xiph.Org Foundation
4		*
5		* Redistribution and use in source and binary forms, with or without
6		* modification, are permitted provided that the following conditions
7		* are met:
8		*
9		* - Redistributions of source code must retain the above copyright
10		* notice, this list of conditions and the following disclaimer.
11		*
12		* - Redistributions in binary form must reproduce the above copyright
13		* notice, this list of conditions and the following disclaimer in the
14		* documentation and/or other materials provided with the distribution.
15		*
16		* - Neither the name of the Xiph.org Foundation nor the names of its
17		* contributors may be used to endorse or promote products derived from
18		* this software without specific prior written permission.
19		*
20		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21		* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
24		* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25		* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26		* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27		* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28		* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29		* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30		* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31		*/
32
33		#ifdef HAVE_CONFIG_H
34		#include "config.h"
35		#endif
36
37		#include "FLAC++/encoder.h"
38		#include "FLAC++/metadata.h"
39		#include "FLAC/assert.h"
40
41		#ifdef _MSC_VER
42		// warning C4800: 'int' : forcing to bool 'true' or 'false' (performance warning)
43		#pragma warning ( disable : 4800 )
44		#endif
45
46		namespace FLAC {
47		namespace Encoder {
48
49		// ------------------------------------------------------------
50		//
51		// Stream
52		//
53		// ------------------------------------------------------------
54
55		Stream::Stream():
56	19.8k	encoder_(::FLAC__stream_encoder_new())
57	19.8k	{ }
58
59		Stream::~Stream()
60	19.8k	{
61	19.8k	if(0 != encoder_) {
62	19.8k	(void)::FLAC__stream_encoder_finish(encoder_);
63	19.8k	::FLAC__stream_encoder_delete(encoder_);
64	19.8k	}
65	19.8k	}
66
67		bool Stream::is_valid() const
68	1.32M	{
69	1.32M	return 0 != encoder_;
70	1.32M	}
71
72		bool Stream::set_ogg_serial_number(long value)
73	35.0k	{
74	35.0k	FLAC__ASSERT(is_valid());
75	35.0k	return static_cast<bool>(::FLAC__stream_encoder_set_ogg_serial_number(encoder_, value));
76	35.0k	}
77
78		bool Stream::set_verify(bool value)
79	35.0k	{
80	35.0k	FLAC__ASSERT(is_valid());
81	35.0k	return static_cast<bool>(::FLAC__stream_encoder_set_verify(encoder_, value));
82	35.0k	}
83
84		bool Stream::set_streamable_subset(bool value)
85	35.1k	{
86	35.1k	FLAC__ASSERT(is_valid());
87	35.1k	return static_cast<bool>(::FLAC__stream_encoder_set_streamable_subset(encoder_, value));
88	35.1k	}
89
90		bool Stream::set_channels(uint32_t value)
91	35.1k	{
92	35.1k	FLAC__ASSERT(is_valid());
93	35.1k	return static_cast<bool>(::FLAC__stream_encoder_set_channels(encoder_, value));
94	35.1k	}
95
96		bool Stream::set_bits_per_sample(uint32_t value)
97	35.1k	{
98	35.1k	FLAC__ASSERT(is_valid());
99	35.1k	return static_cast<bool>(::FLAC__stream_encoder_set_bits_per_sample(encoder_, value));
100	35.1k	}
101
102		bool Stream::set_sample_rate(uint32_t value)
103	33.0k	{
104	33.0k	FLAC__ASSERT(is_valid());
105	33.0k	return static_cast<bool>(::FLAC__stream_encoder_set_sample_rate(encoder_, value));
106	33.0k	}
107
108		bool Stream::set_compression_level(uint32_t value)
109	35.0k	{
110	35.0k	FLAC__ASSERT(is_valid());
111	35.0k	return static_cast<bool>(::FLAC__stream_encoder_set_compression_level(encoder_, value));
112	35.0k	}
113
114		bool Stream::set_blocksize(uint32_t value)
115	33.0k	{
116	33.0k	FLAC__ASSERT(is_valid());
117	33.0k	return static_cast<bool>(::FLAC__stream_encoder_set_blocksize(encoder_, value));
118	33.0k	}
119
120		bool Stream::set_do_mid_side_stereo(bool value)
121	35.0k	{
122	35.0k	FLAC__ASSERT(is_valid());
123	35.0k	return static_cast<bool>(::FLAC__stream_encoder_set_do_mid_side_stereo(encoder_, value));
124	35.0k	}
125
126		bool Stream::set_loose_mid_side_stereo(bool value)
127	35.0k	{
128	35.0k	FLAC__ASSERT(is_valid());
129	35.0k	return static_cast<bool>(::FLAC__stream_encoder_set_loose_mid_side_stereo(encoder_, value));
130	35.0k	}
131
132		bool Stream::set_apodization(const char *specification)
133	28.3k	{
134	28.3k	FLAC__ASSERT(is_valid());
135	28.3k	return static_cast<bool>(::FLAC__stream_encoder_set_apodization(encoder_, specification));
136	28.3k	}
137
138		bool Stream::set_max_lpc_order(uint32_t value)
139	33.4k	{
140	33.4k	FLAC__ASSERT(is_valid());
141	33.4k	return static_cast<bool>(::FLAC__stream_encoder_set_max_lpc_order(encoder_, value));
142	33.4k	}
143
144		bool Stream::set_qlp_coeff_precision(uint32_t value)
145	33.3k	{
146	33.3k	FLAC__ASSERT(is_valid());
147	33.3k	return static_cast<bool>(::FLAC__stream_encoder_set_qlp_coeff_precision(encoder_, value));
148	33.3k	}
149
150		bool Stream::set_do_qlp_coeff_prec_search(bool value)
151	25.4k	{
152	25.4k	FLAC__ASSERT(is_valid());
153	25.4k	return static_cast<bool>(::FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder_, value));
154	25.4k	}
155
156		bool Stream::set_do_escape_coding(bool value)
157	33.2k	{
158	33.2k	FLAC__ASSERT(is_valid());
159	33.2k	return static_cast<bool>(::FLAC__stream_encoder_set_do_escape_coding(encoder_, value));
160	33.2k	}
161
162		bool Stream::set_do_exhaustive_model_search(bool value)
163	27.2k	{
164	27.2k	FLAC__ASSERT(is_valid());
165	27.2k	return static_cast<bool>(::FLAC__stream_encoder_set_do_exhaustive_model_search(encoder_, value));
166	27.2k	}
167
168		bool Stream::set_min_residual_partition_order(uint32_t value)
169	33.2k	{
170	33.2k	FLAC__ASSERT(is_valid());
171	33.2k	return static_cast<bool>(::FLAC__stream_encoder_set_min_residual_partition_order(encoder_, value));
172	33.2k	}
173
174		bool Stream::set_max_residual_partition_order(uint32_t value)
175	33.2k	{
176	33.2k	FLAC__ASSERT(is_valid());
177	33.2k	return static_cast<bool>(::FLAC__stream_encoder_set_max_residual_partition_order(encoder_, value));
178	33.2k	}
179
180		bool Stream::set_rice_parameter_search_dist(uint32_t value)
181	25.2k	{
182	25.2k	FLAC__ASSERT(is_valid());
183	25.2k	return static_cast<bool>(::FLAC__stream_encoder_set_rice_parameter_search_dist(encoder_, value));
184	25.2k	}
185
186		bool Stream::set_total_samples_estimate(FLAC__uint64 value)
187	33.2k	{
188	33.2k	FLAC__ASSERT(is_valid());
189	33.2k	return static_cast<bool>(::FLAC__stream_encoder_set_total_samples_estimate(encoder_, value));
190	33.2k	}
191
192		bool Stream::set_metadata(::FLAC__StreamMetadata **metadata, uint32_t num_blocks)
193	897	{
194	897	FLAC__ASSERT(is_valid());
195	897	return static_cast<bool>(::FLAC__stream_encoder_set_metadata(encoder_, metadata, num_blocks));
196	897	}
197
198		bool Stream::set_metadata(FLAC::Metadata::Prototype **metadata, uint32_t num_blocks)
199	0	{
200	0	FLAC__ASSERT(is_valid());
201		// because C++ doesn't have VLA's (variable length arrays)
202		// this ugly workaround is needed
203	0	::FLAC__StreamMetadata *m = new ::FLAC__StreamMetadata[num_blocks];
204	0	for(uint32_t i = 0; i < num_blocks; i++) {
205		// we can get away with the const_cast since we know the encoder will only correct the is_last flags
206	0	m[i] = const_cast< ::FLAC__StreamMetadata>(static_cast<const ::FLAC__StreamMetadata>(*metadata[i]));
207	0	}
208		// complete the hack
209	0	const bool ok = static_cast<bool>(::FLAC__stream_encoder_set_metadata(encoder_, m, num_blocks));
210	0	delete [] m;
211	0	return ok;
212	0	}
213
214		bool Stream::set_limit_min_bitrate(bool value)
215	33.0k	{
216	33.0k	FLAC__ASSERT(is_valid());
217	33.0k	return static_cast<bool>(::FLAC__stream_encoder_set_limit_min_bitrate(encoder_, value));
218	33.0k	}
219
220		uint32_t Stream::set_num_threads(uint32_t value)
221	33.0k	{
222	33.0k	FLAC__ASSERT(is_valid());
223	33.0k	return ::FLAC__stream_encoder_set_num_threads(encoder_, value);
224	33.0k	}
225
226		Stream::State Stream::get_state() const
227	41.1k	{
228	41.1k	FLAC__ASSERT(is_valid());
229	41.1k	return State(::FLAC__stream_encoder_get_state(encoder_));
230	41.1k	}
231
232		Decoder::Stream::State Stream::get_verify_decoder_state() const
233	0	{
234	0	FLAC__ASSERT(is_valid());
235	0	return Decoder::Stream::State(::FLAC__stream_encoder_get_verify_decoder_state(encoder_));
236	0	}
237
238		void Stream::get_verify_decoder_error_stats(FLAC__uint64 absolute_sample, uint32_t frame_number, uint32_t channel, uint32_t sample, FLAC__int32 expected, FLAC__int32 got)
239	0	{
240	0	FLAC__ASSERT(is_valid());
241	0	::FLAC__stream_encoder_get_verify_decoder_error_stats(encoder_, absolute_sample, frame_number, channel, sample, expected, got);
242	0	}
243
244		bool Stream::get_verify() const
245	15.4k	{
246	15.4k	FLAC__ASSERT(is_valid());
247	15.4k	return static_cast<bool>(::FLAC__stream_encoder_get_verify(encoder_));
248	15.4k	}
249
250		bool Stream::get_streamable_subset() const
251	15.4k	{
252	15.4k	FLAC__ASSERT(is_valid());
253	15.4k	return static_cast<bool>(::FLAC__stream_encoder_get_streamable_subset(encoder_));
254	15.4k	}
255
256		bool Stream::get_do_mid_side_stereo() const
257	15.4k	{
258	15.4k	FLAC__ASSERT(is_valid());
259	15.4k	return static_cast<bool>(::FLAC__stream_encoder_get_do_mid_side_stereo(encoder_));
260	15.4k	}
261
262		bool Stream::get_loose_mid_side_stereo() const
263	15.4k	{
264	15.4k	FLAC__ASSERT(is_valid());
265	15.4k	return static_cast<bool>(::FLAC__stream_encoder_get_loose_mid_side_stereo(encoder_));
266	15.4k	}
267
268		uint32_t Stream::get_channels() const
269	56.5k	{
270	56.5k	FLAC__ASSERT(is_valid());
271	56.5k	return ::FLAC__stream_encoder_get_channels(encoder_);
272	56.5k	}
273
274		uint32_t Stream::get_bits_per_sample() const
275	56.5k	{
276	56.5k	FLAC__ASSERT(is_valid());
277	56.5k	return ::FLAC__stream_encoder_get_bits_per_sample(encoder_);
278	56.5k	}
279
280		uint32_t Stream::get_sample_rate() const
281	15.4k	{
282	15.4k	FLAC__ASSERT(is_valid());
283	15.4k	return ::FLAC__stream_encoder_get_sample_rate(encoder_);
284	15.4k	}
285
286		uint32_t Stream::get_blocksize() const
287	15.4k	{
288	15.4k	FLAC__ASSERT(is_valid());
289	15.4k	return ::FLAC__stream_encoder_get_blocksize(encoder_);
290	15.4k	}
291
292		uint32_t Stream::get_max_lpc_order() const
293	15.4k	{
294	15.4k	FLAC__ASSERT(is_valid());
295	15.4k	return ::FLAC__stream_encoder_get_max_lpc_order(encoder_);
296	15.4k	}
297
298		uint32_t Stream::get_qlp_coeff_precision() const
299	15.4k	{
300	15.4k	FLAC__ASSERT(is_valid());
301	15.4k	return ::FLAC__stream_encoder_get_qlp_coeff_precision(encoder_);
302	15.4k	}
303
304		bool Stream::get_do_qlp_coeff_prec_search() const
305	15.4k	{
306	15.4k	FLAC__ASSERT(is_valid());
307	15.4k	return static_cast<bool>(::FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder_));
308	15.4k	}
309
310		bool Stream::get_do_escape_coding() const
311	15.4k	{
312	15.4k	FLAC__ASSERT(is_valid());
313	15.4k	return static_cast<bool>(::FLAC__stream_encoder_get_do_escape_coding(encoder_));
314	15.4k	}
315
316		bool Stream::get_do_exhaustive_model_search() const
317	15.4k	{
318	15.4k	FLAC__ASSERT(is_valid());
319	15.4k	return static_cast<bool>(::FLAC__stream_encoder_get_do_exhaustive_model_search(encoder_));
320	15.4k	}
321
322		uint32_t Stream::get_min_residual_partition_order() const
323	15.4k	{
324	15.4k	FLAC__ASSERT(is_valid());
325	15.4k	return ::FLAC__stream_encoder_get_min_residual_partition_order(encoder_);
326	15.4k	}
327
328		uint32_t Stream::get_max_residual_partition_order() const
329	15.4k	{
330	15.4k	FLAC__ASSERT(is_valid());
331	15.4k	return ::FLAC__stream_encoder_get_max_residual_partition_order(encoder_);
332	15.4k	}
333
334		uint32_t Stream::get_rice_parameter_search_dist() const
335	15.4k	{
336	15.4k	FLAC__ASSERT(is_valid());
337	15.4k	return ::FLAC__stream_encoder_get_rice_parameter_search_dist(encoder_);
338	15.4k	}
339
340		FLAC__uint64 Stream::get_total_samples_estimate() const
341	15.4k	{
342	15.4k	FLAC__ASSERT(is_valid());
343	15.4k	return ::FLAC__stream_encoder_get_total_samples_estimate(encoder_);
344	15.4k	}
345
346		bool Stream::get_limit_min_bitrate() const
347	15.4k	{
348	15.4k	FLAC__ASSERT(is_valid());
349	15.4k	return static_cast<bool>(::FLAC__stream_encoder_get_limit_min_bitrate(encoder_));
350	15.4k	}
351
352		uint32_t Stream::get_num_threads() const
353	15.4k	{
354	15.4k	FLAC__ASSERT(is_valid());
355	15.4k	return ::FLAC__stream_encoder_get_num_threads(encoder_);
356	15.4k	}
357
358		::FLAC__StreamEncoderInitStatus Stream::init()
359	9.99k	{
360	9.99k	FLAC__ASSERT(is_valid());
361	9.99k	return ::FLAC__stream_encoder_init_stream(encoder_, write_callback_, seek_callback_, tell_callback_, metadata_callback_, /client_data=/(void*)this);
362	9.99k	}
363
364		::FLAC__StreamEncoderInitStatus Stream::init_ogg()
365	6.54k	{
366	6.54k	FLAC__ASSERT(is_valid());
367	6.54k	return ::FLAC__stream_encoder_init_ogg_stream(encoder_, read_callback_, write_callback_, seek_callback_, tell_callback_, metadata_callback_, /client_data=/(void*)this);
368	6.54k	}
369
370		bool Stream::finish()
371	19.8k	{
372	19.8k	FLAC__ASSERT(is_valid());
373	19.8k	return static_cast<bool>(::FLAC__stream_encoder_finish(encoder_));
374	19.8k	}
375
376		bool Stream::process(const FLAC__int32 * const buffer[], uint32_t samples)
377	41.0k	{
378	41.0k	FLAC__ASSERT(is_valid());
379	41.0k	return static_cast<bool>(::FLAC__stream_encoder_process(encoder_, buffer, samples));
380	41.0k	}
381
382		bool Stream::process_interleaved(const FLAC__int32 buffer[], uint32_t samples)
383	115k	{
384	115k	FLAC__ASSERT(is_valid());
385	115k	return static_cast<bool>(::FLAC__stream_encoder_process_interleaved(encoder_, buffer, samples));
386	115k	}
387
388		::FLAC__StreamEncoderReadStatus Stream::read_callback(FLAC__byte buffer[], size_t *bytes)
389	0	{
390	0	(void)buffer, (void)bytes;
391	0	return ::FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED;
392	0	}
393
394		::FLAC__StreamEncoderSeekStatus Stream::seek_callback(FLAC__uint64 absolute_byte_offset)
395	15.3k	{
396	15.3k	(void)absolute_byte_offset;
397	15.3k	return ::FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED;
398	15.3k	}
399
400		::FLAC__StreamEncoderTellStatus Stream::tell_callback(FLAC__uint64 *absolute_byte_offset)
401	98.8k	{
402	98.8k	(void)absolute_byte_offset;
403	98.8k	return ::FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED;
404	98.8k	}
405
406		void Stream::metadata_callback(const ::FLAC__StreamMetadata *metadata)
407	15.3k	{
408	15.3k	(void)metadata;
409	15.3k	}
410
411		::FLAC__StreamEncoderReadStatus Stream::read_callback_(const ::FLAC__StreamEncoder encoder, FLAC__byte buffer[], size_t bytes, void *client_data)
412	0	{
413	0	(void)encoder;
414	0	FLAC__ASSERT(0 != client_data);
415	0	Stream instance = reinterpret_cast<Stream >(client_data);
416	0	FLAC__ASSERT(0 != instance);
417	0	return instance->read_callback(buffer, bytes);
418	0	}
419
420		::FLAC__StreamEncoderWriteStatus Stream::write_callback_(const ::FLAC__StreamEncoder encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame, void client_data)
421	3.21M	{
422	3.21M	(void)encoder;
423	3.21M	FLAC__ASSERT(0 != client_data);
424	3.21M	Stream instance = reinterpret_cast<Stream >(client_data);
425	3.21M	FLAC__ASSERT(0 != instance);
426	3.21M	return instance->write_callback(buffer, bytes, samples, current_frame);
427	3.21M	}
428
429		::FLAC__StreamEncoderSeekStatus Stream::seek_callback_(const ::FLAC__StreamEncoder encoder, FLAC__uint64 absolute_byte_offset, void client_data)
430	15.3k	{
431	15.3k	(void)encoder;
432	15.3k	FLAC__ASSERT(0 != client_data);
433	15.3k	Stream instance = reinterpret_cast<Stream >(client_data);
434	15.3k	FLAC__ASSERT(0 != instance);
435	15.3k	return instance->seek_callback(absolute_byte_offset);
436	15.3k	}
437
438		::FLAC__StreamEncoderTellStatus Stream::tell_callback_(const ::FLAC__StreamEncoder encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
439	98.8k	{
440	98.8k	(void)encoder;
441	98.8k	FLAC__ASSERT(0 != client_data);
442	98.8k	Stream instance = reinterpret_cast<Stream >(client_data);
443	98.8k	FLAC__ASSERT(0 != instance);
444	98.8k	return instance->tell_callback(absolute_byte_offset);
445	98.8k	}
446
447		void Stream::metadata_callback_(const ::FLAC__StreamEncoder encoder, const ::FLAC__StreamMetadata metadata, void *client_data)
448	15.3k	{
449	15.3k	(void)encoder;
450	15.3k	FLAC__ASSERT(0 != client_data);
451	15.3k	Stream instance = reinterpret_cast<Stream >(client_data);
452	15.3k	FLAC__ASSERT(0 != instance);
453	15.3k	instance->metadata_callback(metadata);
454	15.3k	}
455
456		// ------------------------------------------------------------
457		//
458		// File
459		//
460		// ------------------------------------------------------------
461
462		File::File():
463	0	Stream()
464	0	{ }
465
466		File::~File()
467		{
468		}
469
470		::FLAC__StreamEncoderInitStatus File::init(FILE *file)
471	0	{
472	0	FLAC__ASSERT(is_valid());
473	0	return ::FLAC__stream_encoder_init_FILE(encoder_, file, progress_callback_, /client_data=/(void*)this);
474	0	}
475
476		::FLAC__StreamEncoderInitStatus File::init(const char *filename)
477	0	{
478	0	FLAC__ASSERT(is_valid());
479	0	return ::FLAC__stream_encoder_init_file(encoder_, filename, progress_callback_, /client_data=/(void*)this);
480	0	}
481
482		::FLAC__StreamEncoderInitStatus File::init(const std::string &filename)
483	0	{
484	0	return init(filename.c_str());
485	0	}
486
487		::FLAC__StreamEncoderInitStatus File::init_ogg(FILE *file)
488	0	{
489	0	FLAC__ASSERT(is_valid());
490	0	return ::FLAC__stream_encoder_init_ogg_FILE(encoder_, file, progress_callback_, /client_data=/(void*)this);
491	0	}
492
493		::FLAC__StreamEncoderInitStatus File::init_ogg(const char *filename)
494	0	{
495	0	FLAC__ASSERT(is_valid());
496	0	return ::FLAC__stream_encoder_init_ogg_file(encoder_, filename, progress_callback_, /client_data=/(void*)this);
497	0	}
498
499		::FLAC__StreamEncoderInitStatus File::init_ogg(const std::string &filename)
500	0	{
501	0	return init_ogg(filename.c_str());
502	0	}
503
504		// This is a dummy to satisfy the pure virtual from Stream; the
505		// read callback will never be called since we are initializing
506		// with FLAC__stream_decoder_init_FILE() or
507		// FLAC__stream_decoder_init_file() and those supply the read
508		// callback internally.
509		::FLAC__StreamEncoderWriteStatus File::write_callback(const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame)
510	0	{
511	0	(void)buffer, (void)bytes, (void)samples, (void)current_frame;
512	0	FLAC__ASSERT(false);
513	0	return ::FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; // double protection
514	0	}
515
516		void File::progress_callback(FLAC__uint64 bytes_written, FLAC__uint64 samples_written, uint32_t frames_written, uint32_t total_frames_estimate)
517	0	{
518	0	(void)bytes_written, (void)samples_written, (void)frames_written, (void)total_frames_estimate;
519	0	}
520
521		void File::progress_callback_(const ::FLAC__StreamEncoder encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, uint32_t frames_written, uint32_t total_frames_estimate, void client_data)
522	0	{
523	0	(void)encoder;
524	0	FLAC__ASSERT(0 != client_data);
525	0	File instance = reinterpret_cast<File >(client_data);
526	0	FLAC__ASSERT(0 != instance);
527	0	instance->progress_callback(bytes_written, samples_written, frames_written, total_frames_estimate);
528	0	}
529
530		} // namespace Encoder
531		} // namespace FLAC