1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2000-2009  Josh Coalson
3  * Copyright (C) 2011-2014  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 <limits.h>
38 #include <stdio.h>
39 #include <stdlib.h> /* for malloc() */
40 #include <string.h> /* for memcpy() */
41 #include <sys/types.h> /* for off_t */
42 #include "share/compat.h"
43 #include "FLAC/assert.h"
44 #include "FLAC/stream_decoder.h"
45 #include "protected/stream_encoder.h"
46 #include "private/bitwriter.h"
47 #include "private/bitmath.h"
48 #include "private/crc.h"
49 #include "private/cpu.h"
50 #include "private/fixed.h"
51 #include "private/format.h"
52 #include "private/lpc.h"
53 #include "private/md5.h"
54 #include "private/memory.h"
55 #include "private/macros.h"
56 #if FLAC__HAS_OGG
57 #include "private/ogg_helper.h"
58 #include "private/ogg_mapping.h"
59 #endif
60 #include "private/stream_encoder.h"
61 #include "private/stream_encoder_framing.h"
62 #include "private/window.h"
63 #include "share/alloc.h"
64 #include "share/private.h"
65 
66 
67 /* Exact Rice codeword length calculation is off by default.  The simple
68  * (and fast) estimation (of how many bits a residual value will be
69  * encoded with) in this encoder is very good, almost always yielding
70  * compression within 0.1% of exact calculation.
71  */
72 #undef EXACT_RICE_BITS_CALCULATION
73 /* Rice parameter searching is off by default.  The simple (and fast)
74  * parameter estimation in this encoder is very good, almost always
75  * yielding compression within 0.1% of the optimal parameters.
76  */
77 #undef ENABLE_RICE_PARAMETER_SEARCH
78 
79 
80 typedef struct {
81 	FLAC__int32 *data[FLAC__MAX_CHANNELS];
82 	unsigned size; /* of each data[] in samples */
83 	unsigned tail;
84 } verify_input_fifo;
85 
86 typedef struct {
87 	const FLAC__byte *data;
88 	unsigned capacity;
89 	unsigned bytes;
90 } verify_output;
91 
92 typedef enum {
93 	ENCODER_IN_MAGIC = 0,
94 	ENCODER_IN_METADATA = 1,
95 	ENCODER_IN_AUDIO = 2
96 } EncoderStateHint;
97 
98 static struct CompressionLevels {
99 	FLAC__bool do_mid_side_stereo;
100 	FLAC__bool loose_mid_side_stereo;
101 	unsigned max_lpc_order;
102 	unsigned qlp_coeff_precision;
103 	FLAC__bool do_qlp_coeff_prec_search;
104 	FLAC__bool do_escape_coding;
105 	FLAC__bool do_exhaustive_model_search;
106 	unsigned min_residual_partition_order;
107 	unsigned max_residual_partition_order;
108 	unsigned rice_parameter_search_dist;
109 	const char *apodization;
110 } compression_levels_[] = {
111 	{ false, false,  0, 0, false, false, false, 0, 3, 0, "tukey(5e-1)" },
112 	{ true , true ,  0, 0, false, false, false, 0, 3, 0, "tukey(5e-1)" },
113 	{ true , false,  0, 0, false, false, false, 0, 3, 0, "tukey(5e-1)" },
114 	{ false, false,  6, 0, false, false, false, 0, 4, 0, "tukey(5e-1)" },
115 	{ true , true ,  8, 0, false, false, false, 0, 4, 0, "tukey(5e-1)" },
116 	{ true , false,  8, 0, false, false, false, 0, 5, 0, "tukey(5e-1)" },
117 	{ true , false,  8, 0, false, false, false, 0, 6, 0, "tukey(5e-1);partial_tukey(2)" },
118 	{ true , false, 12, 0, false, false, false, 0, 6, 0, "tukey(5e-1);partial_tukey(2)" },
119 	{ true , false, 12, 0, false, false, false, 0, 6, 0, "tukey(5e-1);partial_tukey(2);punchout_tukey(3)" }
120 	/* here we use locale-independent 5e-1 instead of 0.5 or 0,5 */
121 };
122 
123 
124 /***********************************************************************
125  *
126  * Private class method prototypes
127  *
128  ***********************************************************************/
129 
130 static void set_defaults_(FLAC__StreamEncoder *encoder);
131 static void free_(FLAC__StreamEncoder *encoder);
132 static FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_blocksize);
133 static FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples, FLAC__bool is_last_block);
134 static FLAC__StreamEncoderWriteStatus write_frame_(FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, FLAC__bool is_last_block);
135 static void update_metadata_(const FLAC__StreamEncoder *encoder);
136 #if FLAC__HAS_OGG
137 static void update_ogg_metadata_(FLAC__StreamEncoder *encoder);
138 #endif
139 static FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block, FLAC__bool is_last_block);
140 static FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block);
141 
142 static FLAC__bool process_subframe_(
143 	FLAC__StreamEncoder *encoder,
144 	unsigned min_partition_order,
145 	unsigned max_partition_order,
146 	const FLAC__FrameHeader *frame_header,
147 	unsigned subframe_bps,
148 	const FLAC__int32 integer_signal[],
149 	FLAC__Subframe *subframe[2],
150 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2],
151 	FLAC__int32 *residual[2],
152 	unsigned *best_subframe,
153 	unsigned *best_bits
154 );
155 
156 static FLAC__bool add_subframe_(
157 	FLAC__StreamEncoder *encoder,
158 	unsigned blocksize,
159 	unsigned subframe_bps,
160 	const FLAC__Subframe *subframe,
161 	FLAC__BitWriter *frame
162 );
163 
164 static unsigned evaluate_constant_subframe_(
165 	FLAC__StreamEncoder *encoder,
166 	const FLAC__int32 signal,
167 	unsigned blocksize,
168 	unsigned subframe_bps,
169 	FLAC__Subframe *subframe
170 );
171 
172 static unsigned evaluate_fixed_subframe_(
173 	FLAC__StreamEncoder *encoder,
174 	const FLAC__int32 signal[],
175 	FLAC__int32 residual[],
176 	FLAC__uint64 abs_residual_partition_sums[],
177 	unsigned raw_bits_per_partition[],
178 	unsigned blocksize,
179 	unsigned subframe_bps,
180 	unsigned order,
181 	unsigned rice_parameter,
182 	unsigned rice_parameter_limit,
183 	unsigned min_partition_order,
184 	unsigned max_partition_order,
185 	FLAC__bool do_escape_coding,
186 	unsigned rice_parameter_search_dist,
187 	FLAC__Subframe *subframe,
188 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
189 );
190 
191 #ifndef FLAC__INTEGER_ONLY_LIBRARY
192 static unsigned evaluate_lpc_subframe_(
193 	FLAC__StreamEncoder *encoder,
194 	const FLAC__int32 signal[],
195 	FLAC__int32 residual[],
196 	FLAC__uint64 abs_residual_partition_sums[],
197 	unsigned raw_bits_per_partition[],
198 	const FLAC__real lp_coeff[],
199 	unsigned blocksize,
200 	unsigned subframe_bps,
201 	unsigned order,
202 	unsigned qlp_coeff_precision,
203 	unsigned rice_parameter,
204 	unsigned rice_parameter_limit,
205 	unsigned min_partition_order,
206 	unsigned max_partition_order,
207 	FLAC__bool do_escape_coding,
208 	unsigned rice_parameter_search_dist,
209 	FLAC__Subframe *subframe,
210 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
211 );
212 #endif
213 
214 static unsigned evaluate_verbatim_subframe_(
215 	FLAC__StreamEncoder *encoder,
216 	const FLAC__int32 signal[],
217 	unsigned blocksize,
218 	unsigned subframe_bps,
219 	FLAC__Subframe *subframe
220 );
221 
222 static unsigned find_best_partition_order_(
223 	struct FLAC__StreamEncoderPrivate *private_,
224 	const FLAC__int32 residual[],
225 	FLAC__uint64 abs_residual_partition_sums[],
226 	unsigned raw_bits_per_partition[],
227 	unsigned residual_samples,
228 	unsigned predictor_order,
229 	unsigned rice_parameter,
230 	unsigned rice_parameter_limit,
231 	unsigned min_partition_order,
232 	unsigned max_partition_order,
233 	unsigned bps,
234 	FLAC__bool do_escape_coding,
235 	unsigned rice_parameter_search_dist,
236 	FLAC__EntropyCodingMethod *best_ecm
237 );
238 
239 static void precompute_partition_info_sums_(
240 	const FLAC__int32 residual[],
241 	FLAC__uint64 abs_residual_partition_sums[],
242 	unsigned residual_samples,
243 	unsigned predictor_order,
244 	unsigned min_partition_order,
245 	unsigned max_partition_order,
246 	unsigned bps
247 );
248 
249 static void precompute_partition_info_escapes_(
250 	const FLAC__int32 residual[],
251 	unsigned raw_bits_per_partition[],
252 	unsigned residual_samples,
253 	unsigned predictor_order,
254 	unsigned min_partition_order,
255 	unsigned max_partition_order
256 );
257 
258 static FLAC__bool set_partitioned_rice_(
259 #ifdef EXACT_RICE_BITS_CALCULATION
260 	const FLAC__int32 residual[],
261 #endif
262 	const FLAC__uint64 abs_residual_partition_sums[],
263 	const unsigned raw_bits_per_partition[],
264 	const unsigned residual_samples,
265 	const unsigned predictor_order,
266 	const unsigned suggested_rice_parameter,
267 	const unsigned rice_parameter_limit,
268 	const unsigned rice_parameter_search_dist,
269 	const unsigned partition_order,
270 	const FLAC__bool search_for_escapes,
271 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents,
272 	unsigned *bits
273 );
274 
275 static unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples);
276 
277 /* verify-related routines: */
278 static void append_to_verify_fifo_(
279 	verify_input_fifo *fifo,
280 	const FLAC__int32 * const input[],
281 	unsigned input_offset,
282 	unsigned channels,
283 	unsigned wide_samples
284 );
285 
286 static void append_to_verify_fifo_interleaved_(
287 	verify_input_fifo *fifo,
288 	const FLAC__int32 input[],
289 	unsigned input_offset,
290 	unsigned channels,
291 	unsigned wide_samples
292 );
293 
294 static FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
295 static FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
296 static void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
297 static void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
298 
299 static FLAC__StreamEncoderReadStatus file_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
300 static FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data);
301 static FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
302 static FLAC__StreamEncoderWriteStatus file_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data);
303 static FILE *get_binary_stdout_(void);
304 
305 
306 /***********************************************************************
307  *
308  * Private class data
309  *
310  ***********************************************************************/
311 
312 typedef struct FLAC__StreamEncoderPrivate {
313 	unsigned input_capacity;                          /* current size (in samples) of the signal and residual buffers */
314 	FLAC__int32 *integer_signal[FLAC__MAX_CHANNELS];  /* the integer version of the input signal */
315 	FLAC__int32 *integer_signal_mid_side[2];          /* the integer version of the mid-side input signal (stereo only) */
316 #ifndef FLAC__INTEGER_ONLY_LIBRARY
317 	FLAC__real *real_signal[FLAC__MAX_CHANNELS];      /* (@@@ currently unused) the floating-point version of the input signal */
318 	FLAC__real *real_signal_mid_side[2];              /* (@@@ currently unused) the floating-point version of the mid-side input signal (stereo only) */
319 	FLAC__real *window[FLAC__MAX_APODIZATION_FUNCTIONS]; /* the pre-computed floating-point window for each apodization function */
320 	FLAC__real *windowed_signal;                      /* the integer_signal[] * current window[] */
321 #endif
322 	unsigned subframe_bps[FLAC__MAX_CHANNELS];        /* the effective bits per sample of the input signal (stream bps - wasted bits) */
323 	unsigned subframe_bps_mid_side[2];                /* the effective bits per sample of the mid-side input signal (stream bps - wasted bits + 0/1) */
324 	FLAC__int32 *residual_workspace[FLAC__MAX_CHANNELS][2]; /* each channel has a candidate and best workspace where the subframe residual signals will be stored */
325 	FLAC__int32 *residual_workspace_mid_side[2][2];
326 	FLAC__Subframe subframe_workspace[FLAC__MAX_CHANNELS][2];
327 	FLAC__Subframe subframe_workspace_mid_side[2][2];
328 	FLAC__Subframe *subframe_workspace_ptr[FLAC__MAX_CHANNELS][2];
329 	FLAC__Subframe *subframe_workspace_ptr_mid_side[2][2];
330 	FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace[FLAC__MAX_CHANNELS][2];
331 	FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace_mid_side[FLAC__MAX_CHANNELS][2];
332 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr[FLAC__MAX_CHANNELS][2];
333 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr_mid_side[FLAC__MAX_CHANNELS][2];
334 	unsigned best_subframe[FLAC__MAX_CHANNELS];       /* index (0 or 1) into 2nd dimension of the above workspaces */
335 	unsigned best_subframe_mid_side[2];
336 	unsigned best_subframe_bits[FLAC__MAX_CHANNELS];  /* size in bits of the best subframe for each channel */
337 	unsigned best_subframe_bits_mid_side[2];
338 	FLAC__uint64 *abs_residual_partition_sums;        /* workspace where the sum of abs(candidate residual) for each partition is stored */
339 	unsigned *raw_bits_per_partition;                 /* workspace where the sum of silog2(candidate residual) for each partition is stored */
340 	FLAC__BitWriter *frame;                           /* the current frame being worked on */
341 	unsigned loose_mid_side_stereo_frames;            /* rounded number of frames the encoder will use before trying both independent and mid/side frames again */
342 	unsigned loose_mid_side_stereo_frame_count;       /* number of frames using the current channel assignment */
343 	FLAC__ChannelAssignment last_channel_assignment;
344 	FLAC__StreamMetadata streaminfo;                  /* scratchpad for STREAMINFO as it is built */
345 	FLAC__StreamMetadata_SeekTable *seek_table;       /* pointer into encoder->protected_->metadata_ where the seek table is */
346 	unsigned current_sample_number;
347 	unsigned current_frame_number;
348 	FLAC__MD5Context md5context;
349 	FLAC__CPUInfo cpuinfo;
350 	void (*local_precompute_partition_info_sums)(const FLAC__int32 residual[], FLAC__uint64 abs_residual_partition_sums[], unsigned residual_samples, unsigned predictor_order, unsigned min_partition_order, unsigned max_partition_order, unsigned bps);
351 #ifndef FLAC__INTEGER_ONLY_LIBRARY
352 	unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, FLAC__float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
353 	unsigned (*local_fixed_compute_best_predictor_wide)(const FLAC__int32 data[], unsigned data_len, FLAC__float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
354 #else
355 	unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
356 	unsigned (*local_fixed_compute_best_predictor_wide)(const FLAC__int32 data[], unsigned data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
357 #endif
358 #ifndef FLAC__INTEGER_ONLY_LIBRARY
359 	void (*local_lpc_compute_autocorrelation)(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
360 	void (*local_lpc_compute_residual_from_qlp_coefficients)(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
361 	void (*local_lpc_compute_residual_from_qlp_coefficients_64bit)(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
362 	void (*local_lpc_compute_residual_from_qlp_coefficients_16bit)(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
363 #endif
364 	FLAC__bool use_wide_by_block;          /* use slow 64-bit versions of some functions because of the block size */
365 	FLAC__bool use_wide_by_partition;      /* use slow 64-bit versions of some functions because of the min partition order and blocksize */
366 	FLAC__bool use_wide_by_order;          /* use slow 64-bit versions of some functions because of the lpc order */
367 	FLAC__bool disable_constant_subframes;
368 	FLAC__bool disable_fixed_subframes;
369 	FLAC__bool disable_verbatim_subframes;
370 #if FLAC__HAS_OGG
371 	FLAC__bool is_ogg;
372 #endif
373 	FLAC__StreamEncoderReadCallback read_callback; /* currently only needed for Ogg FLAC */
374 	FLAC__StreamEncoderSeekCallback seek_callback;
375 	FLAC__StreamEncoderTellCallback tell_callback;
376 	FLAC__StreamEncoderWriteCallback write_callback;
377 	FLAC__StreamEncoderMetadataCallback metadata_callback;
378 	FLAC__StreamEncoderProgressCallback progress_callback;
379 	void *client_data;
380 	unsigned first_seekpoint_to_check;
381 	FILE *file;                            /* only used when encoding to a file */
382 	FLAC__uint64 bytes_written;
383 	FLAC__uint64 samples_written;
384 	unsigned frames_written;
385 	unsigned total_frames_estimate;
386 	/* unaligned (original) pointers to allocated data */
387 	FLAC__int32 *integer_signal_unaligned[FLAC__MAX_CHANNELS];
388 	FLAC__int32 *integer_signal_mid_side_unaligned[2];
389 #ifndef FLAC__INTEGER_ONLY_LIBRARY
390 	FLAC__real *real_signal_unaligned[FLAC__MAX_CHANNELS]; /* (@@@ currently unused) */
391 	FLAC__real *real_signal_mid_side_unaligned[2]; /* (@@@ currently unused) */
392 	FLAC__real *window_unaligned[FLAC__MAX_APODIZATION_FUNCTIONS];
393 	FLAC__real *windowed_signal_unaligned;
394 #endif
395 	FLAC__int32 *residual_workspace_unaligned[FLAC__MAX_CHANNELS][2];
396 	FLAC__int32 *residual_workspace_mid_side_unaligned[2][2];
397 	FLAC__uint64 *abs_residual_partition_sums_unaligned;
398 	unsigned *raw_bits_per_partition_unaligned;
399 	/*
400 	 * These fields have been moved here from private function local
401 	 * declarations merely to save stack space during encoding.
402 	 */
403 #ifndef FLAC__INTEGER_ONLY_LIBRARY
404 	FLAC__real lp_coeff[FLAC__MAX_LPC_ORDER][FLAC__MAX_LPC_ORDER]; /* from process_subframe_() */
405 #endif
406 	FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_extra[2]; /* from find_best_partition_order_() */
407 	/*
408 	 * The data for the verify section
409 	 */
410 	struct {
411 		FLAC__StreamDecoder *decoder;
412 		EncoderStateHint state_hint;
413 		FLAC__bool needs_magic_hack;
414 		verify_input_fifo input_fifo;
415 		verify_output output;
416 		struct {
417 			FLAC__uint64 absolute_sample;
418 			unsigned frame_number;
419 			unsigned channel;
420 			unsigned sample;
421 			FLAC__int32 expected;
422 			FLAC__int32 got;
423 		} error_stats;
424 	} verify;
425 	FLAC__bool is_being_deleted; /* if true, call to ..._finish() from ..._delete() will not call the callbacks */
426 } FLAC__StreamEncoderPrivate;
427 
428 /***********************************************************************
429  *
430  * Public static class data
431  *
432  ***********************************************************************/
433 
434 FLAC_API const char * const FLAC__StreamEncoderStateString[] = {
435 	"FLAC__STREAM_ENCODER_OK",
436 	"FLAC__STREAM_ENCODER_UNINITIALIZED",
437 	"FLAC__STREAM_ENCODER_OGG_ERROR",
438 	"FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR",
439 	"FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA",
440 	"FLAC__STREAM_ENCODER_CLIENT_ERROR",
441 	"FLAC__STREAM_ENCODER_IO_ERROR",
442 	"FLAC__STREAM_ENCODER_FRAMING_ERROR",
443 	"FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR"
444 };
445 
446 FLAC_API const char * const FLAC__StreamEncoderInitStatusString[] = {
447 	"FLAC__STREAM_ENCODER_INIT_STATUS_OK",
448 	"FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR",
449 	"FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER",
450 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS",
451 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS",
452 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE",
453 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE",
454 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE",
455 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER",
456 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION",
457 	"FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER",
458 	"FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE",
459 	"FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA",
460 	"FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED"
461 };
462 
463 FLAC_API const char * const FLAC__StreamEncoderReadStatusString[] = {
464 	"FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE",
465 	"FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM",
466 	"FLAC__STREAM_ENCODER_READ_STATUS_ABORT",
467 	"FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED"
468 };
469 
470 FLAC_API const char * const FLAC__StreamEncoderWriteStatusString[] = {
471 	"FLAC__STREAM_ENCODER_WRITE_STATUS_OK",
472 	"FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR"
473 };
474 
475 FLAC_API const char * const FLAC__StreamEncoderSeekStatusString[] = {
476 	"FLAC__STREAM_ENCODER_SEEK_STATUS_OK",
477 	"FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR",
478 	"FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED"
479 };
480 
481 FLAC_API const char * const FLAC__StreamEncoderTellStatusString[] = {
482 	"FLAC__STREAM_ENCODER_TELL_STATUS_OK",
483 	"FLAC__STREAM_ENCODER_TELL_STATUS_ERROR",
484 	"FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED"
485 };
486 
487 /* Number of samples that will be overread to watch for end of stream.  By
488  * 'overread', we mean that the FLAC__stream_encoder_process*() calls will
489  * always try to read blocksize+1 samples before encoding a block, so that
490  * even if the stream has a total sample count that is an integral multiple
491  * of the blocksize, we will still notice when we are encoding the last
492  * block.  This is needed, for example, to correctly set the end-of-stream
493  * marker in Ogg FLAC.
494  *
495  * WATCHOUT: some parts of the code assert that OVERREAD_ == 1 and there's
496  * not really any reason to change it.
497  */
498 static const unsigned OVERREAD_ = 1;
499 
500 /***********************************************************************
501  *
502  * Class constructor/destructor
503  *
504  */
FLAC__stream_encoder_new(void)505 FLAC_API FLAC__StreamEncoder *FLAC__stream_encoder_new(void)
506 {
507 	FLAC__StreamEncoder *encoder;
508 	unsigned i;
509 
510 	FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
511 
512 	encoder = calloc(1, sizeof(FLAC__StreamEncoder));
513 	if(encoder == 0) {
514 		return 0;
515 	}
516 
517 	encoder->protected_ = calloc(1, sizeof(FLAC__StreamEncoderProtected));
518 	if(encoder->protected_ == 0) {
519 		free(encoder);
520 		return 0;
521 	}
522 
523 	encoder->private_ = calloc(1, sizeof(FLAC__StreamEncoderPrivate));
524 	if(encoder->private_ == 0) {
525 		free(encoder->protected_);
526 		free(encoder);
527 		return 0;
528 	}
529 
530 	encoder->private_->frame = FLAC__bitwriter_new();
531 	if(encoder->private_->frame == 0) {
532 		free(encoder->private_);
533 		free(encoder->protected_);
534 		free(encoder);
535 		return 0;
536 	}
537 
538 	encoder->private_->file = 0;
539 
540 	set_defaults_(encoder);
541 
542 	encoder->private_->is_being_deleted = false;
543 
544 	for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
545 		encoder->private_->subframe_workspace_ptr[i][0] = &encoder->private_->subframe_workspace[i][0];
546 		encoder->private_->subframe_workspace_ptr[i][1] = &encoder->private_->subframe_workspace[i][1];
547 	}
548 	for(i = 0; i < 2; i++) {
549 		encoder->private_->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->subframe_workspace_mid_side[i][0];
550 		encoder->private_->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->subframe_workspace_mid_side[i][1];
551 	}
552 	for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
553 		encoder->private_->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->partitioned_rice_contents_workspace[i][0];
554 		encoder->private_->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->partitioned_rice_contents_workspace[i][1];
555 	}
556 	for(i = 0; i < 2; i++) {
557 		encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][0] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0];
558 		encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][1] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1];
559 	}
560 
561 	for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
562 		FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][0]);
563 		FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][1]);
564 	}
565 	for(i = 0; i < 2; i++) {
566 		FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]);
567 		FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]);
568 	}
569 	for(i = 0; i < 2; i++)
570 		FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_extra[i]);
571 
572 	encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
573 
574 	return encoder;
575 }
576 
FLAC__stream_encoder_delete(FLAC__StreamEncoder * encoder)577 FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder)
578 {
579 	unsigned i;
580 
581 	if (encoder == NULL)
582 		return ;
583 
584 	FLAC__ASSERT(0 != encoder->protected_);
585 	FLAC__ASSERT(0 != encoder->private_);
586 	FLAC__ASSERT(0 != encoder->private_->frame);
587 
588 	encoder->private_->is_being_deleted = true;
589 
590 	(void)FLAC__stream_encoder_finish(encoder);
591 
592 	if(0 != encoder->private_->verify.decoder)
593 		FLAC__stream_decoder_delete(encoder->private_->verify.decoder);
594 
595 	for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
596 		FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][0]);
597 		FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][1]);
598 	}
599 	for(i = 0; i < 2; i++) {
600 		FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]);
601 		FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]);
602 	}
603 	for(i = 0; i < 2; i++)
604 		FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_extra[i]);
605 
606 	FLAC__bitwriter_delete(encoder->private_->frame);
607 	free(encoder->private_);
608 	free(encoder->protected_);
609 	free(encoder);
610 }
611 
612 /***********************************************************************
613  *
614  * Public class methods
615  *
616  ***********************************************************************/
617 
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)618 static FLAC__StreamEncoderInitStatus init_stream_internal_(
619 	FLAC__StreamEncoder *encoder,
620 	FLAC__StreamEncoderReadCallback read_callback,
621 	FLAC__StreamEncoderWriteCallback write_callback,
622 	FLAC__StreamEncoderSeekCallback seek_callback,
623 	FLAC__StreamEncoderTellCallback tell_callback,
624 	FLAC__StreamEncoderMetadataCallback metadata_callback,
625 	void *client_data,
626 	FLAC__bool is_ogg
627 )
628 {
629 	unsigned i;
630 	FLAC__bool metadata_has_seektable, metadata_has_vorbis_comment, metadata_picture_has_type1, metadata_picture_has_type2;
631 
632 	FLAC__ASSERT(0 != encoder);
633 
634 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
635 		return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED;
636 
637 #if !FLAC__HAS_OGG
638 	if(is_ogg)
639 		return FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER;
640 #endif
641 
642 	if(0 == write_callback || (seek_callback && 0 == tell_callback))
643 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS;
644 
645 	if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS)
646 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS;
647 
648 	if(encoder->protected_->channels != 2) {
649 		encoder->protected_->do_mid_side_stereo = false;
650 		encoder->protected_->loose_mid_side_stereo = false;
651 	}
652 	else if(!encoder->protected_->do_mid_side_stereo)
653 		encoder->protected_->loose_mid_side_stereo = false;
654 
655 	if(encoder->protected_->bits_per_sample >= 32)
656 		encoder->protected_->do_mid_side_stereo = false; /* since we currenty do 32-bit math, the side channel would have 33 bps and overflow */
657 
658 	if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE)
659 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE;
660 
661 	if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate))
662 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE;
663 
664 	if(encoder->protected_->blocksize == 0) {
665 		if(encoder->protected_->max_lpc_order == 0)
666 			encoder->protected_->blocksize = 1152;
667 		else
668 			encoder->protected_->blocksize = 4096;
669 	}
670 
671 	if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE)
672 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE;
673 
674 	if(encoder->protected_->max_lpc_order > FLAC__MAX_LPC_ORDER)
675 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER;
676 
677 	if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order)
678 		return FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER;
679 
680 	if(encoder->protected_->qlp_coeff_precision == 0) {
681 		if(encoder->protected_->bits_per_sample < 16) {
682 			/* @@@ need some data about how to set this here w.r.t. blocksize and sample rate */
683 			/* @@@ until then we'll make a guess */
684 			encoder->protected_->qlp_coeff_precision = flac_max(FLAC__MIN_QLP_COEFF_PRECISION, 2 + encoder->protected_->bits_per_sample / 2);
685 		}
686 		else if(encoder->protected_->bits_per_sample == 16) {
687 			if(encoder->protected_->blocksize <= 192)
688 				encoder->protected_->qlp_coeff_precision = 7;
689 			else if(encoder->protected_->blocksize <= 384)
690 				encoder->protected_->qlp_coeff_precision = 8;
691 			else if(encoder->protected_->blocksize <= 576)
692 				encoder->protected_->qlp_coeff_precision = 9;
693 			else if(encoder->protected_->blocksize <= 1152)
694 				encoder->protected_->qlp_coeff_precision = 10;
695 			else if(encoder->protected_->blocksize <= 2304)
696 				encoder->protected_->qlp_coeff_precision = 11;
697 			else if(encoder->protected_->blocksize <= 4608)
698 				encoder->protected_->qlp_coeff_precision = 12;
699 			else
700 				encoder->protected_->qlp_coeff_precision = 13;
701 		}
702 		else {
703 			if(encoder->protected_->blocksize <= 384)
704 				encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-2;
705 			else if(encoder->protected_->blocksize <= 1152)
706 				encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-1;
707 			else
708 				encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION;
709 		}
710 		FLAC__ASSERT(encoder->protected_->qlp_coeff_precision <= FLAC__MAX_QLP_COEFF_PRECISION);
711 	}
712 	else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION)
713 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION;
714 
715 	if(encoder->protected_->streamable_subset) {
716 		if(!FLAC__format_blocksize_is_subset(encoder->protected_->blocksize, encoder->protected_->sample_rate))
717 			return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
718 		if(!FLAC__format_sample_rate_is_subset(encoder->protected_->sample_rate))
719 			return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
720 		if(
721 			encoder->protected_->bits_per_sample != 8 &&
722 			encoder->protected_->bits_per_sample != 12 &&
723 			encoder->protected_->bits_per_sample != 16 &&
724 			encoder->protected_->bits_per_sample != 20 &&
725 			encoder->protected_->bits_per_sample != 24
726 		)
727 			return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
728 		if(encoder->protected_->max_residual_partition_order > FLAC__SUBSET_MAX_RICE_PARTITION_ORDER)
729 			return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
730 		if(
731 			encoder->protected_->sample_rate <= 48000 &&
732 			(
733 				encoder->protected_->blocksize > FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ ||
734 				encoder->protected_->max_lpc_order > FLAC__SUBSET_MAX_LPC_ORDER_48000HZ
735 			)
736 		) {
737 			return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
738 		}
739 	}
740 
741 	if(encoder->protected_->max_residual_partition_order >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
742 		encoder->protected_->max_residual_partition_order = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1;
743 	if(encoder->protected_->min_residual_partition_order >= encoder->protected_->max_residual_partition_order)
744 		encoder->protected_->min_residual_partition_order = encoder->protected_->max_residual_partition_order;
745 
746 #if FLAC__HAS_OGG
747 	/* reorder metadata if necessary to ensure that any VORBIS_COMMENT is the first, according to the mapping spec */
748 	if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 1) {
749 		unsigned i1;
750 		for(i1 = 1; i1 < encoder->protected_->num_metadata_blocks; i1++) {
751 			if(0 != encoder->protected_->metadata[i1] && encoder->protected_->metadata[i1]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
752 				FLAC__StreamMetadata *vc = encoder->protected_->metadata[i1];
753 				for( ; i1 > 0; i1--)
754 					encoder->protected_->metadata[i1] = encoder->protected_->metadata[i1-1];
755 				encoder->protected_->metadata[0] = vc;
756 				break;
757 			}
758 		}
759 	}
760 #endif
761 	/* keep track of any SEEKTABLE block */
762 	if(0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) {
763 		unsigned i2;
764 		for(i2 = 0; i2 < encoder->protected_->num_metadata_blocks; i2++) {
765 			if(0 != encoder->protected_->metadata[i2] && encoder->protected_->metadata[i2]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
766 				encoder->private_->seek_table = &encoder->protected_->metadata[i2]->data.seek_table;
767 				break; /* take only the first one */
768 			}
769 		}
770 	}
771 
772 	/* validate metadata */
773 	if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0)
774 		return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
775 	metadata_has_seektable = false;
776 	metadata_has_vorbis_comment = false;
777 	metadata_picture_has_type1 = false;
778 	metadata_picture_has_type2 = false;
779 	for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
780 		const FLAC__StreamMetadata *m = encoder->protected_->metadata[i];
781 		if(m->type == FLAC__METADATA_TYPE_STREAMINFO)
782 			return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
783 		else if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) {
784 			if(metadata_has_seektable) /* only one is allowed */
785 				return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
786 			metadata_has_seektable = true;
787 			if(!FLAC__format_seektable_is_legal(&m->data.seek_table))
788 				return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
789 		}
790 		else if(m->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
791 			if(metadata_has_vorbis_comment) /* only one is allowed */
792 				return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
793 			metadata_has_vorbis_comment = true;
794 		}
795 		else if(m->type == FLAC__METADATA_TYPE_CUESHEET) {
796 			if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0))
797 				return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
798 		}
799 		else if(m->type == FLAC__METADATA_TYPE_PICTURE) {
800 			if(!FLAC__format_picture_is_legal(&m->data.picture, /*violation=*/0))
801 				return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
802 			if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
803 				if(metadata_picture_has_type1) /* there should only be 1 per stream */
804 					return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
805 				metadata_picture_has_type1 = true;
806 				/* standard icon must be 32x32 pixel PNG */
807 				if(
808 					m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD &&
809 					(
810 						(strcmp(m->data.picture.mime_type, "image/png") && strcmp(m->data.picture.mime_type, "-->")) ||
811 						m->data.picture.width != 32 ||
812 						m->data.picture.height != 32
813 					)
814 				)
815 					return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
816 			}
817 			else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
818 				if(metadata_picture_has_type2) /* there should only be 1 per stream */
819 					return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
820 				metadata_picture_has_type2 = true;
821 			}
822 		}
823 	}
824 
825 	encoder->private_->input_capacity = 0;
826 	for(i = 0; i < encoder->protected_->channels; i++) {
827 		encoder->private_->integer_signal_unaligned[i] = encoder->private_->integer_signal[i] = 0;
828 #ifndef FLAC__INTEGER_ONLY_LIBRARY
829 		encoder->private_->real_signal_unaligned[i] = encoder->private_->real_signal[i] = 0;
830 #endif
831 	}
832 	for(i = 0; i < 2; i++) {
833 		encoder->private_->integer_signal_mid_side_unaligned[i] = encoder->private_->integer_signal_mid_side[i] = 0;
834 #ifndef FLAC__INTEGER_ONLY_LIBRARY
835 		encoder->private_->real_signal_mid_side_unaligned[i] = encoder->private_->real_signal_mid_side[i] = 0;
836 #endif
837 	}
838 #ifndef FLAC__INTEGER_ONLY_LIBRARY
839 	for(i = 0; i < encoder->protected_->num_apodizations; i++)
840 		encoder->private_->window_unaligned[i] = encoder->private_->window[i] = 0;
841 	encoder->private_->windowed_signal_unaligned = encoder->private_->windowed_signal = 0;
842 #endif
843 	for(i = 0; i < encoder->protected_->channels; i++) {
844 		encoder->private_->residual_workspace_unaligned[i][0] = encoder->private_->residual_workspace[i][0] = 0;
845 		encoder->private_->residual_workspace_unaligned[i][1] = encoder->private_->residual_workspace[i][1] = 0;
846 		encoder->private_->best_subframe[i] = 0;
847 	}
848 	for(i = 0; i < 2; i++) {
849 		encoder->private_->residual_workspace_mid_side_unaligned[i][0] = encoder->private_->residual_workspace_mid_side[i][0] = 0;
850 		encoder->private_->residual_workspace_mid_side_unaligned[i][1] = encoder->private_->residual_workspace_mid_side[i][1] = 0;
851 		encoder->private_->best_subframe_mid_side[i] = 0;
852 	}
853 	encoder->private_->abs_residual_partition_sums_unaligned = encoder->private_->abs_residual_partition_sums = 0;
854 	encoder->private_->raw_bits_per_partition_unaligned = encoder->private_->raw_bits_per_partition = 0;
855 #ifndef FLAC__INTEGER_ONLY_LIBRARY
856 	encoder->private_->loose_mid_side_stereo_frames = (unsigned)((FLAC__double)encoder->protected_->sample_rate * 0.4 / (FLAC__double)encoder->protected_->blocksize + 0.5);
857 #else
858 	/* 26214 is the approximate fixed-point equivalent to 0.4 (0.4 * 2^16) */
859 	/* sample rate can be up to 655350 Hz, and thus use 20 bits, so we do the multiply&divide by hand */
860 	FLAC__ASSERT(FLAC__MAX_SAMPLE_RATE <= 655350);
861 	FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535);
862 	FLAC__ASSERT(encoder->protected_->sample_rate <= 655350);
863 	FLAC__ASSERT(encoder->protected_->blocksize <= 65535);
864 	encoder->private_->loose_mid_side_stereo_frames = (unsigned)FLAC__fixedpoint_trunc((((FLAC__uint64)(encoder->protected_->sample_rate) * (FLAC__uint64)(26214)) << 16) / (encoder->protected_->blocksize<<16) + FLAC__FP_ONE_HALF);
865 #endif
866 	if(encoder->private_->loose_mid_side_stereo_frames == 0)
867 		encoder->private_->loose_mid_side_stereo_frames = 1;
868 	encoder->private_->loose_mid_side_stereo_frame_count = 0;
869 	encoder->private_->current_sample_number = 0;
870 	encoder->private_->current_frame_number = 0;
871 
872 	encoder->private_->use_wide_by_block = (encoder->protected_->bits_per_sample + FLAC__bitmath_ilog2(encoder->protected_->blocksize)+1 > 30);
873 	encoder->private_->use_wide_by_order = (encoder->protected_->bits_per_sample + FLAC__bitmath_ilog2(flac_max(encoder->protected_->max_lpc_order, FLAC__MAX_FIXED_ORDER))+1 > 30); /*@@@ need to use this? */
874 	encoder->private_->use_wide_by_partition = (false); /*@@@ need to set this */
875 
876 	/*
877 	 * get the CPU info and set the function pointers
878 	 */
879 	FLAC__cpu_info(&encoder->private_->cpuinfo);
880 	/* first default to the non-asm routines */
881 #ifndef FLAC__INTEGER_ONLY_LIBRARY
882 	encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
883 #endif
884 	encoder->private_->local_precompute_partition_info_sums = precompute_partition_info_sums_;
885 	encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor;
886 	encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide;
887 #ifndef FLAC__INTEGER_ONLY_LIBRARY
888 	encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients;
889 	encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide;
890 	encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients;
891 #endif
892 	/* now override with asm where appropriate */
893 #ifndef FLAC__INTEGER_ONLY_LIBRARY
894 # ifndef FLAC__NO_ASM
895 	if(encoder->private_->cpuinfo.use_asm) {
896 #  ifdef FLAC__CPU_IA32
897 		FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32);
898 #   ifdef FLAC__HAS_NASM
899 		if(encoder->private_->cpuinfo.ia32.sse) {
900 			if(encoder->protected_->max_lpc_order < 4)
901 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4_old;
902 			else if(encoder->protected_->max_lpc_order < 8)
903 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8_old;
904 			else if(encoder->protected_->max_lpc_order < 12)
905 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12_old;
906 			else if(encoder->protected_->max_lpc_order < 16)
907 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_16_old;
908 			else
909 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32;
910 		}
911 		else
912 			encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32;
913 
914 		encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_asm_ia32; /* OPT_IA32: was really necessary for GCC < 4.9 */
915 		if(encoder->private_->cpuinfo.ia32.mmx) {
916 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
917 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx;
918 		}
919 		else {
920 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
921 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
922 		}
923 
924 		if(encoder->private_->cpuinfo.ia32.mmx && encoder->private_->cpuinfo.ia32.cmov)
925 			encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov;
926 #   endif /* FLAC__HAS_NASM */
927 #   ifdef FLAC__HAS_X86INTRIN
928 #    if defined FLAC__SSE_SUPPORTED
929 		if(encoder->private_->cpuinfo.ia32.sse) {
930 			if(encoder->private_->cpuinfo.ia32.sse42 || !encoder->private_->cpuinfo.ia32.intel) { /* use new autocorrelation functions */
931 				if(encoder->protected_->max_lpc_order < 4)
932 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_new;
933 				else if(encoder->protected_->max_lpc_order < 8)
934 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_new;
935 				else if(encoder->protected_->max_lpc_order < 12)
936 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_new;
937 				else if(encoder->protected_->max_lpc_order < 16)
938 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_new;
939 				else
940 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
941 			}
942 			else { /* use old autocorrelation functions */
943 				if(encoder->protected_->max_lpc_order < 4)
944 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_old;
945 				else if(encoder->protected_->max_lpc_order < 8)
946 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_old;
947 				else if(encoder->protected_->max_lpc_order < 12)
948 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_old;
949 				else if(encoder->protected_->max_lpc_order < 16)
950 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_old;
951 				else
952 					encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
953 			}
954 		}
955 #    endif
956 
957 #    ifdef FLAC__SSE2_SUPPORTED
958 		if(encoder->private_->cpuinfo.ia32.sse2) {
959 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients       = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse2;
960 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2;
961 		}
962 #    endif
963 #    ifdef FLAC__SSE4_1_SUPPORTED
964 		if(encoder->private_->cpuinfo.ia32.sse41) {
965 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients       = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41;
966 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_sse41;
967 		}
968 #    endif
969 #    ifdef FLAC__AVX2_SUPPORTED
970 		if(encoder->private_->cpuinfo.ia32.avx2) {
971 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2;
972 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients       = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2;
973 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2;
974 		}
975 #    endif
976 
977 #    ifdef FLAC__SSE2_SUPPORTED
978 		if (encoder->private_->cpuinfo.ia32.sse2) {
979 			encoder->private_->local_fixed_compute_best_predictor      = FLAC__fixed_compute_best_predictor_intrin_sse2;
980 			encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_sse2;
981 		}
982 #    endif
983 #    ifdef FLAC__SSSE3_SUPPORTED
984 		if (encoder->private_->cpuinfo.ia32.ssse3) {
985 			encoder->private_->local_fixed_compute_best_predictor      = FLAC__fixed_compute_best_predictor_intrin_ssse3;
986 			encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_ssse3;
987 		}
988 #    endif
989 #   endif /* FLAC__HAS_X86INTRIN */
990 #  elif defined FLAC__CPU_X86_64
991 		FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_X86_64);
992 #   ifdef FLAC__HAS_X86INTRIN
993 #    ifdef FLAC__SSE_SUPPORTED
994 		if(encoder->private_->cpuinfo.x86.sse42 || !encoder->private_->cpuinfo.x86.intel) { /* use new autocorrelation functions */
995 			if(encoder->protected_->max_lpc_order < 4)
996 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_new;
997 			else if(encoder->protected_->max_lpc_order < 8)
998 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_new;
999 			else if(encoder->protected_->max_lpc_order < 12)
1000 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_new;
1001 			else if(encoder->protected_->max_lpc_order < 16)
1002 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_new;
1003 		}
1004 		else {
1005 			if(encoder->protected_->max_lpc_order < 4)
1006 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_old;
1007 			else if(encoder->protected_->max_lpc_order < 8)
1008 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_old;
1009 			else if(encoder->protected_->max_lpc_order < 12)
1010 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_old;
1011 			else if(encoder->protected_->max_lpc_order < 16)
1012 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_old;
1013 		}
1014 #    endif
1015 
1016 #    ifdef FLAC__SSE2_SUPPORTED
1017 		encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2;
1018 #    endif
1019 #    ifdef FLAC__SSE4_1_SUPPORTED
1020 		if(encoder->private_->cpuinfo.x86.sse41) {
1021 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41;
1022 		}
1023 #    endif
1024 #    ifdef FLAC__AVX2_SUPPORTED
1025 		if(encoder->private_->cpuinfo.x86.avx2) {
1026 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2;
1027 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients       = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2;
1028 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2;
1029 		}
1030 #    endif
1031 
1032 #    ifdef FLAC__SSE2_SUPPORTED
1033 		encoder->private_->local_fixed_compute_best_predictor      = FLAC__fixed_compute_best_predictor_intrin_sse2;
1034 		encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_sse2;
1035 #    endif
1036 #    ifdef FLAC__SSSE3_SUPPORTED
1037 		if (encoder->private_->cpuinfo.x86.ssse3) {
1038 			encoder->private_->local_fixed_compute_best_predictor      = FLAC__fixed_compute_best_predictor_intrin_ssse3;
1039 			encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_ssse3;
1040 		}
1041 #    endif
1042 #   endif /* FLAC__HAS_X86INTRIN */
1043 #  endif /* FLAC__CPU_... */
1044 	}
1045 # endif /* !FLAC__NO_ASM */
1046 #endif /* !FLAC__INTEGER_ONLY_LIBRARY */
1047 #if !defined FLAC__NO_ASM && defined FLAC__HAS_X86INTRIN
1048 	if(encoder->private_->cpuinfo.use_asm) {
1049 # if defined FLAC__CPU_IA32
1050 #  ifdef FLAC__SSE2_SUPPORTED
1051 		if(encoder->private_->cpuinfo.ia32.sse2)
1052 			encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_sse2;
1053 #  endif
1054 #  ifdef FLAC__SSSE3_SUPPORTED
1055 		if(encoder->private_->cpuinfo.ia32.ssse3)
1056 			encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_ssse3;
1057 #  endif
1058 #  ifdef FLAC__AVX2_SUPPORTED
1059 		if(encoder->private_->cpuinfo.ia32.avx2)
1060 			encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_avx2;
1061 #  endif
1062 # elif defined FLAC__CPU_X86_64
1063 #  ifdef FLAC__SSE2_SUPPORTED
1064 		encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_sse2;
1065 #  endif
1066 #  ifdef FLAC__SSSE3_SUPPORTED
1067 		if(encoder->private_->cpuinfo.x86.ssse3)
1068 			encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_ssse3;
1069 #  endif
1070 #  ifdef FLAC__AVX2_SUPPORTED
1071 		if(encoder->private_->cpuinfo.x86.avx2)
1072 			encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_avx2;
1073 #  endif
1074 # endif /* FLAC__CPU_... */
1075 	}
1076 #endif /* !FLAC__NO_ASM && FLAC__HAS_X86INTRIN */
1077 	/* finally override based on wide-ness if necessary */
1078 	if(encoder->private_->use_wide_by_block) {
1079 		encoder->private_->local_fixed_compute_best_predictor = encoder->private_->local_fixed_compute_best_predictor_wide;
1080 	}
1081 
1082 	/* set state to OK; from here on, errors are fatal and we'll override the state then */
1083 	encoder->protected_->state = FLAC__STREAM_ENCODER_OK;
1084 
1085 #if FLAC__HAS_OGG
1086 	encoder->private_->is_ogg = is_ogg;
1087 	if(is_ogg && !FLAC__ogg_encoder_aspect_init(&encoder->protected_->ogg_encoder_aspect)) {
1088 		encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
1089 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1090 	}
1091 #endif
1092 
1093 	encoder->private_->read_callback = read_callback;
1094 	encoder->private_->write_callback = write_callback;
1095 	encoder->private_->seek_callback = seek_callback;
1096 	encoder->private_->tell_callback = tell_callback;
1097 	encoder->private_->metadata_callback = metadata_callback;
1098 	encoder->private_->client_data = client_data;
1099 
1100 	if(!resize_buffers_(encoder, encoder->protected_->blocksize)) {
1101 		/* the above function sets the state for us in case of an error */
1102 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1103 	}
1104 
1105 	if(!FLAC__bitwriter_init(encoder->private_->frame)) {
1106 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1107 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1108 	}
1109 
1110 	/*
1111 	 * Set up the verify stuff if necessary
1112 	 */
1113 	if(encoder->protected_->verify) {
1114 		/*
1115 		 * First, set up the fifo which will hold the
1116 		 * original signal to compare against
1117 		 */
1118 		encoder->private_->verify.input_fifo.size = encoder->protected_->blocksize+OVERREAD_;
1119 		for(i = 0; i < encoder->protected_->channels; i++) {
1120 			if(0 == (encoder->private_->verify.input_fifo.data[i] = safe_malloc_mul_2op_p(sizeof(FLAC__int32), /*times*/encoder->private_->verify.input_fifo.size))) {
1121 				encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1122 				return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1123 			}
1124 		}
1125 		encoder->private_->verify.input_fifo.tail = 0;
1126 
1127 		/*
1128 		 * Now set up a stream decoder for verification
1129 		 */
1130 		if(0 == encoder->private_->verify.decoder) {
1131 			encoder->private_->verify.decoder = FLAC__stream_decoder_new();
1132 			if(0 == encoder->private_->verify.decoder) {
1133 				encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
1134 				return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1135 			}
1136 		}
1137 
1138 		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) {
1139 			encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
1140 			return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1141 		}
1142 	}
1143 	encoder->private_->verify.error_stats.absolute_sample = 0;
1144 	encoder->private_->verify.error_stats.frame_number = 0;
1145 	encoder->private_->verify.error_stats.channel = 0;
1146 	encoder->private_->verify.error_stats.sample = 0;
1147 	encoder->private_->verify.error_stats.expected = 0;
1148 	encoder->private_->verify.error_stats.got = 0;
1149 
1150 	/*
1151 	 * These must be done before we write any metadata, because that
1152 	 * calls the write_callback, which uses these values.
1153 	 */
1154 	encoder->private_->first_seekpoint_to_check = 0;
1155 	encoder->private_->samples_written = 0;
1156 	encoder->protected_->streaminfo_offset = 0;
1157 	encoder->protected_->seektable_offset = 0;
1158 	encoder->protected_->audio_offset = 0;
1159 
1160 	/*
1161 	 * write the stream header
1162 	 */
1163 	if(encoder->protected_->verify)
1164 		encoder->private_->verify.state_hint = ENCODER_IN_MAGIC;
1165 	if(!FLAC__bitwriter_write_raw_uint32(encoder->private_->frame, FLAC__STREAM_SYNC, FLAC__STREAM_SYNC_LEN)) {
1166 		encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1167 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1168 	}
1169 	if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
1170 		/* the above function sets the state for us in case of an error */
1171 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1172 	}
1173 
1174 	/*
1175 	 * write the STREAMINFO metadata block
1176 	 */
1177 	if(encoder->protected_->verify)
1178 		encoder->private_->verify.state_hint = ENCODER_IN_METADATA;
1179 	encoder->private_->streaminfo.type = FLAC__METADATA_TYPE_STREAMINFO;
1180 	encoder->private_->streaminfo.is_last = false; /* we will have at a minimum a VORBIS_COMMENT afterwards */
1181 	encoder->private_->streaminfo.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
1182 	encoder->private_->streaminfo.data.stream_info.min_blocksize = encoder->protected_->blocksize; /* this encoder uses the same blocksize for the whole stream */
1183 	encoder->private_->streaminfo.data.stream_info.max_blocksize = encoder->protected_->blocksize;
1184 	encoder->private_->streaminfo.data.stream_info.min_framesize = 0; /* we don't know this yet; have to fill it in later */
1185 	encoder->private_->streaminfo.data.stream_info.max_framesize = 0; /* we don't know this yet; have to fill it in later */
1186 	encoder->private_->streaminfo.data.stream_info.sample_rate = encoder->protected_->sample_rate;
1187 	encoder->private_->streaminfo.data.stream_info.channels = encoder->protected_->channels;
1188 	encoder->private_->streaminfo.data.stream_info.bits_per_sample = encoder->protected_->bits_per_sample;
1189 	encoder->private_->streaminfo.data.stream_info.total_samples = encoder->protected_->total_samples_estimate; /* we will replace this later with the real total */
1190 	memset(encoder->private_->streaminfo.data.stream_info.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */
1191 	if(encoder->protected_->do_md5)
1192 		FLAC__MD5Init(&encoder->private_->md5context);
1193 	if(!FLAC__add_metadata_block(&encoder->private_->streaminfo, encoder->private_->frame)) {
1194 		encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1195 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1196 	}
1197 	if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
1198 		/* the above function sets the state for us in case of an error */
1199 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1200 	}
1201 
1202 	/*
1203 	 * Now that the STREAMINFO block is written, we can init this to an
1204 	 * absurdly-high value...
1205 	 */
1206 	encoder->private_->streaminfo.data.stream_info.min_framesize = (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN) - 1;
1207 	/* ... and clear this to 0 */
1208 	encoder->private_->streaminfo.data.stream_info.total_samples = 0;
1209 
1210 	/*
1211 	 * Check to see if the supplied metadata contains a VORBIS_COMMENT;
1212 	 * if not, we will write an empty one (FLAC__add_metadata_block()
1213 	 * automatically supplies the vendor string).
1214 	 *
1215 	 * WATCHOUT: the Ogg FLAC mapping requires us to write this block after
1216 	 * the STREAMINFO.  (In the case that metadata_has_vorbis_comment is
1217 	 * true it will have already insured that the metadata list is properly
1218 	 * ordered.)
1219 	 */
1220 	if(!metadata_has_vorbis_comment) {
1221 		FLAC__StreamMetadata vorbis_comment;
1222 		vorbis_comment.type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
1223 		vorbis_comment.is_last = (encoder->protected_->num_metadata_blocks == 0);
1224 		vorbis_comment.length = 4 + 4; /* MAGIC NUMBER */
1225 		vorbis_comment.data.vorbis_comment.vendor_string.length = 0;
1226 		vorbis_comment.data.vorbis_comment.vendor_string.entry = 0;
1227 		vorbis_comment.data.vorbis_comment.num_comments = 0;
1228 		vorbis_comment.data.vorbis_comment.comments = 0;
1229 		if(!FLAC__add_metadata_block(&vorbis_comment, encoder->private_->frame)) {
1230 			encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1231 			return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1232 		}
1233 		if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
1234 			/* the above function sets the state for us in case of an error */
1235 			return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1236 		}
1237 	}
1238 
1239 	/*
1240 	 * write the user's metadata blocks
1241 	 */
1242 	for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
1243 		encoder->protected_->metadata[i]->is_last = (i == encoder->protected_->num_metadata_blocks - 1);
1244 		if(!FLAC__add_metadata_block(encoder->protected_->metadata[i], encoder->private_->frame)) {
1245 			encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1246 			return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1247 		}
1248 		if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
1249 			/* the above function sets the state for us in case of an error */
1250 			return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1251 		}
1252 	}
1253 
1254 	/* now that all the metadata is written, we save the stream offset */
1255 	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 */
1256 		encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
1257 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1258 	}
1259 
1260 	if(encoder->protected_->verify)
1261 		encoder->private_->verify.state_hint = ENCODER_IN_AUDIO;
1262 
1263 	return FLAC__STREAM_ENCODER_INIT_STATUS_OK;
1264 }
1265 
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)1266 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_stream(
1267 	FLAC__StreamEncoder *encoder,
1268 	FLAC__StreamEncoderWriteCallback write_callback,
1269 	FLAC__StreamEncoderSeekCallback seek_callback,
1270 	FLAC__StreamEncoderTellCallback tell_callback,
1271 	FLAC__StreamEncoderMetadataCallback metadata_callback,
1272 	void *client_data
1273 )
1274 {
1275 	return init_stream_internal_(
1276 		encoder,
1277 		/*read_callback=*/0,
1278 		write_callback,
1279 		seek_callback,
1280 		tell_callback,
1281 		metadata_callback,
1282 		client_data,
1283 		/*is_ogg=*/false
1284 	);
1285 }
1286 
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)1287 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_stream(
1288 	FLAC__StreamEncoder *encoder,
1289 	FLAC__StreamEncoderReadCallback read_callback,
1290 	FLAC__StreamEncoderWriteCallback write_callback,
1291 	FLAC__StreamEncoderSeekCallback seek_callback,
1292 	FLAC__StreamEncoderTellCallback tell_callback,
1293 	FLAC__StreamEncoderMetadataCallback metadata_callback,
1294 	void *client_data
1295 )
1296 {
1297 	return init_stream_internal_(
1298 		encoder,
1299 		read_callback,
1300 		write_callback,
1301 		seek_callback,
1302 		tell_callback,
1303 		metadata_callback,
1304 		client_data,
1305 		/*is_ogg=*/true
1306 	);
1307 }
1308 
init_FILE_internal_(FLAC__StreamEncoder * encoder,FILE * file,FLAC__StreamEncoderProgressCallback progress_callback,void * client_data,FLAC__bool is_ogg)1309 static FLAC__StreamEncoderInitStatus init_FILE_internal_(
1310 	FLAC__StreamEncoder *encoder,
1311 	FILE *file,
1312 	FLAC__StreamEncoderProgressCallback progress_callback,
1313 	void *client_data,
1314 	FLAC__bool is_ogg
1315 )
1316 {
1317 	FLAC__StreamEncoderInitStatus init_status;
1318 
1319 	FLAC__ASSERT(0 != encoder);
1320 	FLAC__ASSERT(0 != file);
1321 
1322 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1323 		return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED;
1324 
1325 	/* double protection */
1326 	if(file == 0) {
1327 		encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
1328 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1329 	}
1330 
1331 	/*
1332 	 * To make sure that our file does not go unclosed after an error, we
1333 	 * must assign the FILE pointer before any further error can occur in
1334 	 * this routine.
1335 	 */
1336 	if(file == stdout)
1337 		file = get_binary_stdout_(); /* just to be safe */
1338 
1339 #ifdef _WIN32
1340 	/*
1341 	 * Windows can suffer quite badly from disk fragmentation. This can be
1342 	 * reduced significantly by setting the output buffer size to be 10MB.
1343 	 */
1344 	setvbuf(file, NULL, _IOFBF, 10*1024*1024);
1345 #endif
1346 	encoder->private_->file = file;
1347 
1348 	encoder->private_->progress_callback = progress_callback;
1349 	encoder->private_->bytes_written = 0;
1350 	encoder->private_->samples_written = 0;
1351 	encoder->private_->frames_written = 0;
1352 
1353 	init_status = init_stream_internal_(
1354 		encoder,
1355 		encoder->private_->file == stdout? 0 : is_ogg? file_read_callback_ : 0,
1356 		file_write_callback_,
1357 		encoder->private_->file == stdout? 0 : file_seek_callback_,
1358 		encoder->private_->file == stdout? 0 : file_tell_callback_,
1359 		/*metadata_callback=*/0,
1360 		client_data,
1361 		is_ogg
1362 	);
1363 	if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
1364 		/* the above function sets the state for us in case of an error */
1365 		return init_status;
1366 	}
1367 
1368 	{
1369 		unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder);
1370 
1371 		FLAC__ASSERT(blocksize != 0);
1372 		encoder->private_->total_frames_estimate = (unsigned)((FLAC__stream_encoder_get_total_samples_estimate(encoder) + blocksize - 1) / blocksize);
1373 	}
1374 
1375 	return init_status;
1376 }
1377 
FLAC__stream_encoder_init_FILE(FLAC__StreamEncoder * encoder,FILE * file,FLAC__StreamEncoderProgressCallback progress_callback,void * client_data)1378 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_FILE(
1379 	FLAC__StreamEncoder *encoder,
1380 	FILE *file,
1381 	FLAC__StreamEncoderProgressCallback progress_callback,
1382 	void *client_data
1383 )
1384 {
1385 	return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/false);
1386 }
1387 
FLAC__stream_encoder_init_ogg_FILE(FLAC__StreamEncoder * encoder,FILE * file,FLAC__StreamEncoderProgressCallback progress_callback,void * client_data)1388 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_FILE(
1389 	FLAC__StreamEncoder *encoder,
1390 	FILE *file,
1391 	FLAC__StreamEncoderProgressCallback progress_callback,
1392 	void *client_data
1393 )
1394 {
1395 	return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/true);
1396 }
1397 
init_file_internal_(FLAC__StreamEncoder * encoder,const char * filename,FLAC__StreamEncoderProgressCallback progress_callback,void * client_data,FLAC__bool is_ogg)1398 static FLAC__StreamEncoderInitStatus init_file_internal_(
1399 	FLAC__StreamEncoder *encoder,
1400 	const char *filename,
1401 	FLAC__StreamEncoderProgressCallback progress_callback,
1402 	void *client_data,
1403 	FLAC__bool is_ogg
1404 )
1405 {
1406 	FILE *file;
1407 
1408 	FLAC__ASSERT(0 != encoder);
1409 
1410 	/*
1411 	 * To make sure that our file does not go unclosed after an error, we
1412 	 * have to do the same entrance checks here that are later performed
1413 	 * in FLAC__stream_encoder_init_FILE() before the FILE* is assigned.
1414 	 */
1415 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1416 		return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED;
1417 
1418 	file = filename? flac_fopen(filename, "w+b") : stdout;
1419 
1420 	if(file == 0) {
1421 		encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
1422 		return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1423 	}
1424 
1425 	return init_FILE_internal_(encoder, file, progress_callback, client_data, is_ogg);
1426 }
1427 
FLAC__stream_encoder_init_file(FLAC__StreamEncoder * encoder,const char * filename,FLAC__StreamEncoderProgressCallback progress_callback,void * client_data)1428 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_file(
1429 	FLAC__StreamEncoder *encoder,
1430 	const char *filename,
1431 	FLAC__StreamEncoderProgressCallback progress_callback,
1432 	void *client_data
1433 )
1434 {
1435 	return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/false);
1436 }
1437 
FLAC__stream_encoder_init_ogg_file(FLAC__StreamEncoder * encoder,const char * filename,FLAC__StreamEncoderProgressCallback progress_callback,void * client_data)1438 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_file(
1439 	FLAC__StreamEncoder *encoder,
1440 	const char *filename,
1441 	FLAC__StreamEncoderProgressCallback progress_callback,
1442 	void *client_data
1443 )
1444 {
1445 	return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/true);
1446 }
1447 
FLAC__stream_encoder_finish(FLAC__StreamEncoder * encoder)1448 FLAC_API FLAC__bool FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder)
1449 {
1450 	FLAC__bool error = false;
1451 
1452 	FLAC__ASSERT(0 != encoder);
1453 	FLAC__ASSERT(0 != encoder->private_);
1454 	FLAC__ASSERT(0 != encoder->protected_);
1455 
1456 	if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED)
1457 		return true;
1458 
1459 	if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) {
1460 		if(encoder->private_->current_sample_number != 0) {
1461 			const FLAC__bool is_fractional_block = encoder->protected_->blocksize != encoder->private_->current_sample_number;
1462 			encoder->protected_->blocksize = encoder->private_->current_sample_number;
1463 			if(!process_frame_(encoder, is_fractional_block, /*is_last_block=*/true))
1464 				error = true;
1465 		}
1466 	}
1467 
1468 	if(encoder->protected_->do_md5)
1469 		FLAC__MD5Final(encoder->private_->streaminfo.data.stream_info.md5sum, &encoder->private_->md5context);
1470 
1471 	if(!encoder->private_->is_being_deleted) {
1472 		if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK) {
1473 			if(encoder->private_->seek_callback) {
1474 #if FLAC__HAS_OGG
1475 				if(encoder->private_->is_ogg)
1476 					update_ogg_metadata_(encoder);
1477 				else
1478 #endif
1479 				update_metadata_(encoder);
1480 
1481 				/* check if an error occurred while updating metadata */
1482 				if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK)
1483 					error = true;
1484 			}
1485 			if(encoder->private_->metadata_callback)
1486 				encoder->private_->metadata_callback(encoder, &encoder->private_->streaminfo, encoder->private_->client_data);
1487 		}
1488 
1489 		if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder && !FLAC__stream_decoder_finish(encoder->private_->verify.decoder)) {
1490 			if(!error)
1491 				encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA;
1492 			error = true;
1493 		}
1494 	}
1495 
1496 	if(0 != encoder->private_->file) {
1497 		if(encoder->private_->file != stdout)
1498 			fclose(encoder->private_->file);
1499 		encoder->private_->file = 0;
1500 	}
1501 
1502 #if FLAC__HAS_OGG
1503 	if(encoder->private_->is_ogg)
1504 		FLAC__ogg_encoder_aspect_finish(&encoder->protected_->ogg_encoder_aspect);
1505 #endif
1506 
1507 	free_(encoder);
1508 	set_defaults_(encoder);
1509 
1510 	if(!error)
1511 		encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
1512 
1513 	return !error;
1514 }
1515 
FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder * encoder,long value)1516 FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder *encoder, long value)
1517 {
1518 	FLAC__ASSERT(0 != encoder);
1519 	FLAC__ASSERT(0 != encoder->private_);
1520 	FLAC__ASSERT(0 != encoder->protected_);
1521 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1522 		return false;
1523 #if FLAC__HAS_OGG
1524 	/* can't check encoder->private_->is_ogg since that's not set until init time */
1525 	FLAC__ogg_encoder_aspect_set_serial_number(&encoder->protected_->ogg_encoder_aspect, value);
1526 	return true;
1527 #else
1528 	(void)value;
1529 	return false;
1530 #endif
1531 }
1532 
FLAC__stream_encoder_set_verify(FLAC__StreamEncoder * encoder,FLAC__bool value)1533 FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value)
1534 {
1535 	FLAC__ASSERT(0 != encoder);
1536 	FLAC__ASSERT(0 != encoder->private_);
1537 	FLAC__ASSERT(0 != encoder->protected_);
1538 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1539 		return false;
1540 #ifndef FLAC__MANDATORY_VERIFY_WHILE_ENCODING
1541 	encoder->protected_->verify = value;
1542 #endif
1543 	return true;
1544 }
1545 
FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder * encoder,FLAC__bool value)1546 FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value)
1547 {
1548 	FLAC__ASSERT(0 != encoder);
1549 	FLAC__ASSERT(0 != encoder->private_);
1550 	FLAC__ASSERT(0 != encoder->protected_);
1551 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1552 		return false;
1553 	encoder->protected_->streamable_subset = value;
1554 	return true;
1555 }
1556 
FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder * encoder,FLAC__bool value)1557 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder *encoder, FLAC__bool value)
1558 {
1559 	FLAC__ASSERT(0 != encoder);
1560 	FLAC__ASSERT(0 != encoder->private_);
1561 	FLAC__ASSERT(0 != encoder->protected_);
1562 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1563 		return false;
1564 	encoder->protected_->do_md5 = value;
1565 	return true;
1566 }
1567 
FLAC__stream_encoder_set_channels(FLAC__StreamEncoder * encoder,unsigned value)1568 FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value)
1569 {
1570 	FLAC__ASSERT(0 != encoder);
1571 	FLAC__ASSERT(0 != encoder->private_);
1572 	FLAC__ASSERT(0 != encoder->protected_);
1573 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1574 		return false;
1575 	encoder->protected_->channels = value;
1576 	return true;
1577 }
1578 
FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder * encoder,unsigned value)1579 FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value)
1580 {
1581 	FLAC__ASSERT(0 != encoder);
1582 	FLAC__ASSERT(0 != encoder->private_);
1583 	FLAC__ASSERT(0 != encoder->protected_);
1584 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1585 		return false;
1586 	encoder->protected_->bits_per_sample = value;
1587 	return true;
1588 }
1589 
FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder * encoder,unsigned value)1590 FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value)
1591 {
1592 	FLAC__ASSERT(0 != encoder);
1593 	FLAC__ASSERT(0 != encoder->private_);
1594 	FLAC__ASSERT(0 != encoder->protected_);
1595 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1596 		return false;
1597 	encoder->protected_->sample_rate = value;
1598 	return true;
1599 }
1600 
FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder * encoder,unsigned value)1601 FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, unsigned value)
1602 {
1603 	FLAC__bool ok = true;
1604 	FLAC__ASSERT(0 != encoder);
1605 	FLAC__ASSERT(0 != encoder->private_);
1606 	FLAC__ASSERT(0 != encoder->protected_);
1607 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1608 		return false;
1609 	if(value >= sizeof(compression_levels_)/sizeof(compression_levels_[0]))
1610 		value = sizeof(compression_levels_)/sizeof(compression_levels_[0]) - 1;
1611 	ok &= FLAC__stream_encoder_set_do_mid_side_stereo          (encoder, compression_levels_[value].do_mid_side_stereo);
1612 	ok &= FLAC__stream_encoder_set_loose_mid_side_stereo       (encoder, compression_levels_[value].loose_mid_side_stereo);
1613 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1614 #if 1
1615 	ok &= FLAC__stream_encoder_set_apodization                 (encoder, compression_levels_[value].apodization);
1616 #else
1617 	/* equivalent to -A tukey(0.5) */
1618 	encoder->protected_->num_apodizations = 1;
1619 	encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
1620 	encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
1621 #endif
1622 #endif
1623 	ok &= FLAC__stream_encoder_set_max_lpc_order               (encoder, compression_levels_[value].max_lpc_order);
1624 	ok &= FLAC__stream_encoder_set_qlp_coeff_precision         (encoder, compression_levels_[value].qlp_coeff_precision);
1625 	ok &= FLAC__stream_encoder_set_do_qlp_coeff_prec_search    (encoder, compression_levels_[value].do_qlp_coeff_prec_search);
1626 	ok &= FLAC__stream_encoder_set_do_escape_coding            (encoder, compression_levels_[value].do_escape_coding);
1627 	ok &= FLAC__stream_encoder_set_do_exhaustive_model_search  (encoder, compression_levels_[value].do_exhaustive_model_search);
1628 	ok &= FLAC__stream_encoder_set_min_residual_partition_order(encoder, compression_levels_[value].min_residual_partition_order);
1629 	ok &= FLAC__stream_encoder_set_max_residual_partition_order(encoder, compression_levels_[value].max_residual_partition_order);
1630 	ok &= FLAC__stream_encoder_set_rice_parameter_search_dist  (encoder, compression_levels_[value].rice_parameter_search_dist);
1631 	return ok;
1632 }
1633 
FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder * encoder,unsigned value)1634 FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value)
1635 {
1636 	FLAC__ASSERT(0 != encoder);
1637 	FLAC__ASSERT(0 != encoder->private_);
1638 	FLAC__ASSERT(0 != encoder->protected_);
1639 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1640 		return false;
1641 	encoder->protected_->blocksize = value;
1642 	return true;
1643 }
1644 
FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder * encoder,FLAC__bool value)1645 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
1646 {
1647 	FLAC__ASSERT(0 != encoder);
1648 	FLAC__ASSERT(0 != encoder->private_);
1649 	FLAC__ASSERT(0 != encoder->protected_);
1650 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1651 		return false;
1652 	encoder->protected_->do_mid_side_stereo = value;
1653 	return true;
1654 }
1655 
FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder * encoder,FLAC__bool value)1656 FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
1657 {
1658 	FLAC__ASSERT(0 != encoder);
1659 	FLAC__ASSERT(0 != encoder->private_);
1660 	FLAC__ASSERT(0 != encoder->protected_);
1661 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1662 		return false;
1663 	encoder->protected_->loose_mid_side_stereo = value;
1664 	return true;
1665 }
1666 
1667 /*@@@@add to tests*/
FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder * encoder,const char * specification)1668 FLAC_API FLAC__bool FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder *encoder, const char *specification)
1669 {
1670 	FLAC__ASSERT(0 != encoder);
1671 	FLAC__ASSERT(0 != encoder->private_);
1672 	FLAC__ASSERT(0 != encoder->protected_);
1673 	FLAC__ASSERT(0 != specification);
1674 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1675 		return false;
1676 #ifdef FLAC__INTEGER_ONLY_LIBRARY
1677 	(void)specification; /* silently ignore since we haven't integerized; will always use a rectangular window */
1678 #else
1679 	encoder->protected_->num_apodizations = 0;
1680 	while(1) {
1681 		const char *s = strchr(specification, ';');
1682 		const size_t n = s? (size_t)(s - specification) : strlen(specification);
1683 		if     (n==8  && 0 == strncmp("bartlett"     , specification, n))
1684 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT;
1685 		else if(n==13 && 0 == strncmp("bartlett_hann", specification, n))
1686 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT_HANN;
1687 		else if(n==8  && 0 == strncmp("blackman"     , specification, n))
1688 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN;
1689 		else if(n==26 && 0 == strncmp("blackman_harris_4term_92db", specification, n))
1690 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE;
1691 		else if(n==6  && 0 == strncmp("connes"       , specification, n))
1692 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_CONNES;
1693 		else if(n==7  && 0 == strncmp("flattop"      , specification, n))
1694 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_FLATTOP;
1695 		else if(n>7   && 0 == strncmp("gauss("       , specification, 6)) {
1696 			FLAC__real stddev = (FLAC__real)strtod(specification+6, 0);
1697 			if (stddev > 0.0 && stddev <= 0.5) {
1698 				encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.gauss.stddev = stddev;
1699 				encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_GAUSS;
1700 			}
1701 		}
1702 		else if(n==7  && 0 == strncmp("hamming"      , specification, n))
1703 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HAMMING;
1704 		else if(n==4  && 0 == strncmp("hann"         , specification, n))
1705 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HANN;
1706 		else if(n==13 && 0 == strncmp("kaiser_bessel", specification, n))
1707 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_KAISER_BESSEL;
1708 		else if(n==7  && 0 == strncmp("nuttall"      , specification, n))
1709 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_NUTTALL;
1710 		else if(n==9  && 0 == strncmp("rectangle"    , specification, n))
1711 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_RECTANGLE;
1712 		else if(n==8  && 0 == strncmp("triangle"     , specification, n))
1713 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TRIANGLE;
1714 		else if(n>7   && 0 == strncmp("tukey("       , specification, 6)) {
1715 			FLAC__real p = (FLAC__real)strtod(specification+6, 0);
1716 			if (p >= 0.0 && p <= 1.0) {
1717 				encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = p;
1718 				encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
1719 			}
1720 		}
1721 		else if(n>15   && 0 == strncmp("partial_tukey("       , specification, 14)) {
1722 			FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+14, 0);
1723 			const char *si_1 = strchr(specification, '/');
1724 			FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.1f;
1725 			FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f;
1726 			const char *si_2 = strchr((si_1?(si_1+1):specification), '/');
1727 			FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f;
1728 
1729 			if (tukey_parts <= 1) {
1730 				encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p;
1731 				encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
1732 			}else if (encoder->protected_->num_apodizations + tukey_parts < 32){
1733 				FLAC__int32 m;
1734 				for(m = 0; m < tukey_parts; m++){
1735 					encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p;
1736 					encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units);
1737 					encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units);
1738 					encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PARTIAL_TUKEY;
1739 				}
1740 			}
1741 		}
1742 		else if(n>16   && 0 == strncmp("punchout_tukey("       , specification, 15)) {
1743 			FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+15, 0);
1744 			const char *si_1 = strchr(specification, '/');
1745 			FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.2f;
1746 			FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f;
1747 			const char *si_2 = strchr((si_1?(si_1+1):specification), '/');
1748 			FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f;
1749 
1750 			if (tukey_parts <= 1) {
1751 				encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p;
1752 				encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
1753 			}else if (encoder->protected_->num_apodizations + tukey_parts < 32){
1754 				FLAC__int32 m;
1755 				for(m = 0; m < tukey_parts; m++){
1756 					encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p;
1757 					encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units);
1758 					encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units);
1759 					encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PUNCHOUT_TUKEY;
1760 				}
1761 			}
1762 		}
1763 		else if(n==5  && 0 == strncmp("welch"        , specification, n))
1764 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_WELCH;
1765 		if (encoder->protected_->num_apodizations == 32)
1766 			break;
1767 		if (s)
1768 			specification = s+1;
1769 		else
1770 			break;
1771 	}
1772 	if(encoder->protected_->num_apodizations == 0) {
1773 		encoder->protected_->num_apodizations = 1;
1774 		encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
1775 		encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
1776 	}
1777 #endif
1778 	return true;
1779 }
1780 
FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder * encoder,unsigned value)1781 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, unsigned value)
1782 {
1783 	FLAC__ASSERT(0 != encoder);
1784 	FLAC__ASSERT(0 != encoder->private_);
1785 	FLAC__ASSERT(0 != encoder->protected_);
1786 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1787 		return false;
1788 	encoder->protected_->max_lpc_order = value;
1789 	return true;
1790 }
1791 
FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder * encoder,unsigned value)1792 FLAC_API FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, unsigned value)
1793 {
1794 	FLAC__ASSERT(0 != encoder);
1795 	FLAC__ASSERT(0 != encoder->private_);
1796 	FLAC__ASSERT(0 != encoder->protected_);
1797 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1798 		return false;
1799 	encoder->protected_->qlp_coeff_precision = value;
1800 	return true;
1801 }
1802 
FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder * encoder,FLAC__bool value)1803 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
1804 {
1805 	FLAC__ASSERT(0 != encoder);
1806 	FLAC__ASSERT(0 != encoder->private_);
1807 	FLAC__ASSERT(0 != encoder->protected_);
1808 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1809 		return false;
1810 	encoder->protected_->do_qlp_coeff_prec_search = value;
1811 	return true;
1812 }
1813 
FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder * encoder,FLAC__bool value)1814 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder *encoder, FLAC__bool value)
1815 {
1816 	FLAC__ASSERT(0 != encoder);
1817 	FLAC__ASSERT(0 != encoder->private_);
1818 	FLAC__ASSERT(0 != encoder->protected_);
1819 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1820 		return false;
1821 #if 0
1822 	/*@@@ deprecated: */
1823 	encoder->protected_->do_escape_coding = value;
1824 #else
1825 	(void)value;
1826 #endif
1827 	return true;
1828 }
1829 
FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder * encoder,FLAC__bool value)1830 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
1831 {
1832 	FLAC__ASSERT(0 != encoder);
1833 	FLAC__ASSERT(0 != encoder->private_);
1834 	FLAC__ASSERT(0 != encoder->protected_);
1835 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1836 		return false;
1837 	encoder->protected_->do_exhaustive_model_search = value;
1838 	return true;
1839 }
1840 
FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder * encoder,unsigned value)1841 FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
1842 {
1843 	FLAC__ASSERT(0 != encoder);
1844 	FLAC__ASSERT(0 != encoder->private_);
1845 	FLAC__ASSERT(0 != encoder->protected_);
1846 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1847 		return false;
1848 	encoder->protected_->min_residual_partition_order = value;
1849 	return true;
1850 }
1851 
FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder * encoder,unsigned value)1852 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
1853 {
1854 	FLAC__ASSERT(0 != encoder);
1855 	FLAC__ASSERT(0 != encoder->private_);
1856 	FLAC__ASSERT(0 != encoder->protected_);
1857 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1858 		return false;
1859 	encoder->protected_->max_residual_partition_order = value;
1860 	return true;
1861 }
1862 
FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder * encoder,unsigned value)1863 FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value)
1864 {
1865 	FLAC__ASSERT(0 != encoder);
1866 	FLAC__ASSERT(0 != encoder->private_);
1867 	FLAC__ASSERT(0 != encoder->protected_);
1868 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1869 		return false;
1870 #if 0
1871 	/*@@@ deprecated: */
1872 	encoder->protected_->rice_parameter_search_dist = value;
1873 #else
1874 	(void)value;
1875 #endif
1876 	return true;
1877 }
1878 
FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder * encoder,FLAC__uint64 value)1879 FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value)
1880 {
1881 	FLAC__ASSERT(0 != encoder);
1882 	FLAC__ASSERT(0 != encoder->private_);
1883 	FLAC__ASSERT(0 != encoder->protected_);
1884 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1885 		return false;
1886 	encoder->protected_->total_samples_estimate = value;
1887 	return true;
1888 }
1889 
FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder * encoder,FLAC__StreamMetadata ** metadata,unsigned num_blocks)1890 FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks)
1891 {
1892 	FLAC__ASSERT(0 != encoder);
1893 	FLAC__ASSERT(0 != encoder->private_);
1894 	FLAC__ASSERT(0 != encoder->protected_);
1895 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1896 		return false;
1897 	if(0 == metadata)
1898 		num_blocks = 0;
1899 	if(0 == num_blocks)
1900 		metadata = 0;
1901 	/* realloc() does not do exactly what we want so... */
1902 	if(encoder->protected_->metadata) {
1903 		free(encoder->protected_->metadata);
1904 		encoder->protected_->metadata = 0;
1905 		encoder->protected_->num_metadata_blocks = 0;
1906 	}
1907 	if(num_blocks) {
1908 		FLAC__StreamMetadata **m;
1909 		if(0 == (m = safe_malloc_mul_2op_p(sizeof(m[0]), /*times*/num_blocks)))
1910 			return false;
1911 		memcpy(m, metadata, sizeof(m[0]) * num_blocks);
1912 		encoder->protected_->metadata = m;
1913 		encoder->protected_->num_metadata_blocks = num_blocks;
1914 	}
1915 #if FLAC__HAS_OGG
1916 	if(!FLAC__ogg_encoder_aspect_set_num_metadata(&encoder->protected_->ogg_encoder_aspect, num_blocks))
1917 		return false;
1918 #endif
1919 	return true;
1920 }
1921 
1922 /*
1923  * These three functions are not static, but not publically exposed in
1924  * include/FLAC/ either.  They are used by the test suite.
1925  */
FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder * encoder,FLAC__bool value)1926 FLAC_API FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
1927 {
1928 	FLAC__ASSERT(0 != encoder);
1929 	FLAC__ASSERT(0 != encoder->private_);
1930 	FLAC__ASSERT(0 != encoder->protected_);
1931 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1932 		return false;
1933 	encoder->private_->disable_constant_subframes = value;
1934 	return true;
1935 }
1936 
FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder * encoder,FLAC__bool value)1937 FLAC_API FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
1938 {
1939 	FLAC__ASSERT(0 != encoder);
1940 	FLAC__ASSERT(0 != encoder->private_);
1941 	FLAC__ASSERT(0 != encoder->protected_);
1942 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1943 		return false;
1944 	encoder->private_->disable_fixed_subframes = value;
1945 	return true;
1946 }
1947 
FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder * encoder,FLAC__bool value)1948 FLAC_API FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
1949 {
1950 	FLAC__ASSERT(0 != encoder);
1951 	FLAC__ASSERT(0 != encoder->private_);
1952 	FLAC__ASSERT(0 != encoder->protected_);
1953 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1954 		return false;
1955 	encoder->private_->disable_verbatim_subframes = value;
1956 	return true;
1957 }
1958 
FLAC__stream_encoder_get_state(const FLAC__StreamEncoder * encoder)1959 FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder)
1960 {
1961 	FLAC__ASSERT(0 != encoder);
1962 	FLAC__ASSERT(0 != encoder->private_);
1963 	FLAC__ASSERT(0 != encoder->protected_);
1964 	return encoder->protected_->state;
1965 }
1966 
FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder * encoder)1967 FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder)
1968 {
1969 	FLAC__ASSERT(0 != encoder);
1970 	FLAC__ASSERT(0 != encoder->private_);
1971 	FLAC__ASSERT(0 != encoder->protected_);
1972 	if(encoder->protected_->verify)
1973 		return FLAC__stream_decoder_get_state(encoder->private_->verify.decoder);
1974 	else
1975 		return FLAC__STREAM_DECODER_UNINITIALIZED;
1976 }
1977 
FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder * encoder)1978 FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder)
1979 {
1980 	FLAC__ASSERT(0 != encoder);
1981 	FLAC__ASSERT(0 != encoder->private_);
1982 	FLAC__ASSERT(0 != encoder->protected_);
1983 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR)
1984 		return FLAC__StreamEncoderStateString[encoder->protected_->state];
1985 	else
1986 		return FLAC__stream_decoder_get_resolved_state_string(encoder->private_->verify.decoder);
1987 }
1988 
FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder * encoder,FLAC__uint64 * absolute_sample,unsigned * frame_number,unsigned * channel,unsigned * sample,FLAC__int32 * expected,FLAC__int32 * got)1989 FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got)
1990 {
1991 	FLAC__ASSERT(0 != encoder);
1992 	FLAC__ASSERT(0 != encoder->private_);
1993 	FLAC__ASSERT(0 != encoder->protected_);
1994 	if(0 != absolute_sample)
1995 		*absolute_sample = encoder->private_->verify.error_stats.absolute_sample;
1996 	if(0 != frame_number)
1997 		*frame_number = encoder->private_->verify.error_stats.frame_number;
1998 	if(0 != channel)
1999 		*channel = encoder->private_->verify.error_stats.channel;
2000 	if(0 != sample)
2001 		*sample = encoder->private_->verify.error_stats.sample;
2002 	if(0 != expected)
2003 		*expected = encoder->private_->verify.error_stats.expected;
2004 	if(0 != got)
2005 		*got = encoder->private_->verify.error_stats.got;
2006 }
2007 
FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder * encoder)2008 FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder)
2009 {
2010 	FLAC__ASSERT(0 != encoder);
2011 	FLAC__ASSERT(0 != encoder->private_);
2012 	FLAC__ASSERT(0 != encoder->protected_);
2013 	return encoder->protected_->verify;
2014 }
2015 
FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder * encoder)2016 FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder)
2017 {
2018 	FLAC__ASSERT(0 != encoder);
2019 	FLAC__ASSERT(0 != encoder->private_);
2020 	FLAC__ASSERT(0 != encoder->protected_);
2021 	return encoder->protected_->streamable_subset;
2022 }
2023 
FLAC__stream_encoder_get_do_md5(const FLAC__StreamEncoder * encoder)2024 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_md5(const FLAC__StreamEncoder *encoder)
2025 {
2026 	FLAC__ASSERT(0 != encoder);
2027 	FLAC__ASSERT(0 != encoder->private_);
2028 	FLAC__ASSERT(0 != encoder->protected_);
2029 	return encoder->protected_->do_md5;
2030 }
2031 
FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder * encoder)2032 FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
2033 {
2034 	FLAC__ASSERT(0 != encoder);
2035 	FLAC__ASSERT(0 != encoder->private_);
2036 	FLAC__ASSERT(0 != encoder->protected_);
2037 	return encoder->protected_->channels;
2038 }
2039 
FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder * encoder)2040 FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
2041 {
2042 	FLAC__ASSERT(0 != encoder);
2043 	FLAC__ASSERT(0 != encoder->private_);
2044 	FLAC__ASSERT(0 != encoder->protected_);
2045 	return encoder->protected_->bits_per_sample;
2046 }
2047 
FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder * encoder)2048 FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
2049 {
2050 	FLAC__ASSERT(0 != encoder);
2051 	FLAC__ASSERT(0 != encoder->private_);
2052 	FLAC__ASSERT(0 != encoder->protected_);
2053 	return encoder->protected_->sample_rate;
2054 }
2055 
FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder * encoder)2056 FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
2057 {
2058 	FLAC__ASSERT(0 != encoder);
2059 	FLAC__ASSERT(0 != encoder->private_);
2060 	FLAC__ASSERT(0 != encoder->protected_);
2061 	return encoder->protected_->blocksize;
2062 }
2063 
FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder * encoder)2064 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
2065 {
2066 	FLAC__ASSERT(0 != encoder);
2067 	FLAC__ASSERT(0 != encoder->private_);
2068 	FLAC__ASSERT(0 != encoder->protected_);
2069 	return encoder->protected_->do_mid_side_stereo;
2070 }
2071 
FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder * encoder)2072 FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
2073 {
2074 	FLAC__ASSERT(0 != encoder);
2075 	FLAC__ASSERT(0 != encoder->private_);
2076 	FLAC__ASSERT(0 != encoder->protected_);
2077 	return encoder->protected_->loose_mid_side_stereo;
2078 }
2079 
FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder * encoder)2080 FLAC_API unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder)
2081 {
2082 	FLAC__ASSERT(0 != encoder);
2083 	FLAC__ASSERT(0 != encoder->private_);
2084 	FLAC__ASSERT(0 != encoder->protected_);
2085 	return encoder->protected_->max_lpc_order;
2086 }
2087 
FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder * encoder)2088 FLAC_API unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder)
2089 {
2090 	FLAC__ASSERT(0 != encoder);
2091 	FLAC__ASSERT(0 != encoder->private_);
2092 	FLAC__ASSERT(0 != encoder->protected_);
2093 	return encoder->protected_->qlp_coeff_precision;
2094 }
2095 
FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder * encoder)2096 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
2097 {
2098 	FLAC__ASSERT(0 != encoder);
2099 	FLAC__ASSERT(0 != encoder->private_);
2100 	FLAC__ASSERT(0 != encoder->protected_);
2101 	return encoder->protected_->do_qlp_coeff_prec_search;
2102 }
2103 
FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder * encoder)2104 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder)
2105 {
2106 	FLAC__ASSERT(0 != encoder);
2107 	FLAC__ASSERT(0 != encoder->private_);
2108 	FLAC__ASSERT(0 != encoder->protected_);
2109 	return encoder->protected_->do_escape_coding;
2110 }
2111 
FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder * encoder)2112 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
2113 {
2114 	FLAC__ASSERT(0 != encoder);
2115 	FLAC__ASSERT(0 != encoder->private_);
2116 	FLAC__ASSERT(0 != encoder->protected_);
2117 	return encoder->protected_->do_exhaustive_model_search;
2118 }
2119 
FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder * encoder)2120 FLAC_API unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder)
2121 {
2122 	FLAC__ASSERT(0 != encoder);
2123 	FLAC__ASSERT(0 != encoder->private_);
2124 	FLAC__ASSERT(0 != encoder->protected_);
2125 	return encoder->protected_->min_residual_partition_order;
2126 }
2127 
FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder * encoder)2128 FLAC_API unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder)
2129 {
2130 	FLAC__ASSERT(0 != encoder);
2131 	FLAC__ASSERT(0 != encoder->private_);
2132 	FLAC__ASSERT(0 != encoder->protected_);
2133 	return encoder->protected_->max_residual_partition_order;
2134 }
2135 
FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder * encoder)2136 FLAC_API unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder)
2137 {
2138 	FLAC__ASSERT(0 != encoder);
2139 	FLAC__ASSERT(0 != encoder->private_);
2140 	FLAC__ASSERT(0 != encoder->protected_);
2141 	return encoder->protected_->rice_parameter_search_dist;
2142 }
2143 
FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder * encoder)2144 FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder)
2145 {
2146 	FLAC__ASSERT(0 != encoder);
2147 	FLAC__ASSERT(0 != encoder->private_);
2148 	FLAC__ASSERT(0 != encoder->protected_);
2149 	return encoder->protected_->total_samples_estimate;
2150 }
2151 
FLAC__stream_encoder_process(FLAC__StreamEncoder * encoder,const FLAC__int32 * const buffer[],unsigned samples)2152 FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples)
2153 {
2154 	unsigned i, j = 0, channel;
2155 	const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
2156 
2157 	FLAC__ASSERT(0 != encoder);
2158 	FLAC__ASSERT(0 != encoder->private_);
2159 	FLAC__ASSERT(0 != encoder->protected_);
2160 	FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
2161 
2162 //	FLAC__ASSERT(samples <= blocksize);
2163 
2164 	do {
2165 		const unsigned n = flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j);
2166 
2167 		if(encoder->protected_->verify)
2168 			append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, n);
2169 
2170 		for(channel = 0; channel < channels; channel++) {
2171 			if (buffer[channel] == NULL) {
2172 				encoder->protected_->state = FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
2173 				return false;
2174 			}
2175 			memcpy(&encoder->private_->integer_signal[channel][encoder->private_->current_sample_number], &buffer[channel][j], sizeof(buffer[channel][0]) * n);
2176 		}
2177 
2178 		if(encoder->protected_->do_mid_side_stereo) {
2179 			FLAC__ASSERT(channels == 2);
2180 			/* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */
2181 			for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) {
2182 				encoder->private_->integer_signal_mid_side[1][i] = buffer[0][j] - buffer[1][j];
2183 				encoder->private_->integer_signal_mid_side[0][i] = (buffer[0][j] + buffer[1][j]) >> 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */
2184 			}
2185 		}
2186 		else
2187 			j += n;
2188 
2189 		encoder->private_->current_sample_number += n;
2190 
2191 		/* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */
2192 		if(encoder->private_->current_sample_number > blocksize) {
2193 			FLAC__ASSERT(encoder->private_->current_sample_number == blocksize+OVERREAD_);
2194 			FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */
2195 			if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false))
2196 				return false;
2197 			/* move unprocessed overread samples to beginnings of arrays */
2198 			for(channel = 0; channel < channels; channel++)
2199 				encoder->private_->integer_signal[channel][0] = encoder->private_->integer_signal[channel][blocksize];
2200 			if(encoder->protected_->do_mid_side_stereo) {
2201 				encoder->private_->integer_signal_mid_side[0][0] = encoder->private_->integer_signal_mid_side[0][blocksize];
2202 				encoder->private_->integer_signal_mid_side[1][0] = encoder->private_->integer_signal_mid_side[1][blocksize];
2203 			}
2204 			encoder->private_->current_sample_number = 1;
2205 		}
2206 	} while(j < samples);
2207 
2208 	return true;
2209 }
2210 
FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder * encoder,const FLAC__int32 buffer[],unsigned samples)2211 FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples)
2212 {
2213 	unsigned i, j, k, channel;
2214 	FLAC__int32 x, mid, side;
2215 	const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
2216 
2217 	FLAC__ASSERT(0 != encoder);
2218 	FLAC__ASSERT(0 != encoder->private_);
2219 	FLAC__ASSERT(0 != encoder->protected_);
2220 	FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
2221 
2222 	j = k = 0;
2223 	/*
2224 	 * we have several flavors of the same basic loop, optimized for
2225 	 * different conditions:
2226 	 */
2227 	if(encoder->protected_->do_mid_side_stereo && channels == 2) {
2228 		/*
2229 		 * stereo coding: unroll channel loop
2230 		 */
2231 		do {
2232 			if(encoder->protected_->verify)
2233 				append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j));
2234 
2235 			/* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */
2236 			for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) {
2237 				encoder->private_->integer_signal[0][i] = mid = side = buffer[k++];
2238 				x = buffer[k++];
2239 				encoder->private_->integer_signal[1][i] = x;
2240 				mid += x;
2241 				side -= x;
2242 				mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */
2243 				encoder->private_->integer_signal_mid_side[1][i] = side;
2244 				encoder->private_->integer_signal_mid_side[0][i] = mid;
2245 			}
2246 			encoder->private_->current_sample_number = i;
2247 			/* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */
2248 			if(i > blocksize) {
2249 				if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false))
2250 					return false;
2251 				/* move unprocessed overread samples to beginnings of arrays */
2252 				FLAC__ASSERT(i == blocksize+OVERREAD_);
2253 				FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */
2254 				encoder->private_->integer_signal[0][0] = encoder->private_->integer_signal[0][blocksize];
2255 				encoder->private_->integer_signal[1][0] = encoder->private_->integer_signal[1][blocksize];
2256 				encoder->private_->integer_signal_mid_side[0][0] = encoder->private_->integer_signal_mid_side[0][blocksize];
2257 				encoder->private_->integer_signal_mid_side[1][0] = encoder->private_->integer_signal_mid_side[1][blocksize];
2258 				encoder->private_->current_sample_number = 1;
2259 			}
2260 		} while(j < samples);
2261 	}
2262 	else {
2263 		/*
2264 		 * independent channel coding: buffer each channel in inner loop
2265 		 */
2266 		do {
2267 			if(encoder->protected_->verify)
2268 				append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j));
2269 
2270 			/* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */
2271 			for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) {
2272 				for(channel = 0; channel < channels; channel++)
2273 					encoder->private_->integer_signal[channel][i] = buffer[k++];
2274 			}
2275 			encoder->private_->current_sample_number = i;
2276 			/* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */
2277 			if(i > blocksize) {
2278 				if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false))
2279 					return false;
2280 				/* move unprocessed overread samples to beginnings of arrays */
2281 				FLAC__ASSERT(i == blocksize+OVERREAD_);
2282 				FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */
2283 				for(channel = 0; channel < channels; channel++)
2284 					encoder->private_->integer_signal[channel][0] = encoder->private_->integer_signal[channel][blocksize];
2285 				encoder->private_->current_sample_number = 1;
2286 			}
2287 		} while(j < samples);
2288 	}
2289 
2290 	return true;
2291 }
2292 
2293 /***********************************************************************
2294  *
2295  * Private class methods
2296  *
2297  ***********************************************************************/
2298 
set_defaults_(FLAC__StreamEncoder * encoder)2299 void set_defaults_(FLAC__StreamEncoder *encoder)
2300 {
2301 	FLAC__ASSERT(0 != encoder);
2302 
2303 #ifdef FLAC__MANDATORY_VERIFY_WHILE_ENCODING
2304 	encoder->protected_->verify = true;
2305 #else
2306 	encoder->protected_->verify = false;
2307 #endif
2308 	encoder->protected_->streamable_subset = true;
2309 	encoder->protected_->do_md5 = true;
2310 	encoder->protected_->do_mid_side_stereo = false;
2311 	encoder->protected_->loose_mid_side_stereo = false;
2312 	encoder->protected_->channels = 2;
2313 	encoder->protected_->bits_per_sample = 16;
2314 	encoder->protected_->sample_rate = 44100;
2315 	encoder->protected_->blocksize = 0;
2316 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2317 	encoder->protected_->num_apodizations = 1;
2318 	encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
2319 	encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
2320 #endif
2321 	encoder->protected_->max_lpc_order = 0;
2322 	encoder->protected_->qlp_coeff_precision = 0;
2323 	encoder->protected_->do_qlp_coeff_prec_search = false;
2324 	encoder->protected_->do_exhaustive_model_search = false;
2325 	encoder->protected_->do_escape_coding = false;
2326 	encoder->protected_->min_residual_partition_order = 0;
2327 	encoder->protected_->max_residual_partition_order = 0;
2328 	encoder->protected_->rice_parameter_search_dist = 0;
2329 	encoder->protected_->total_samples_estimate = 0;
2330 	encoder->protected_->metadata = 0;
2331 	encoder->protected_->num_metadata_blocks = 0;
2332 
2333 	encoder->private_->seek_table = 0;
2334 	encoder->private_->disable_constant_subframes = false;
2335 	encoder->private_->disable_fixed_subframes = false;
2336 	encoder->private_->disable_verbatim_subframes = false;
2337 #if FLAC__HAS_OGG
2338 	encoder->private_->is_ogg = false;
2339 #endif
2340 	encoder->private_->read_callback = 0;
2341 	encoder->private_->write_callback = 0;
2342 	encoder->private_->seek_callback = 0;
2343 	encoder->private_->tell_callback = 0;
2344 	encoder->private_->metadata_callback = 0;
2345 	encoder->private_->progress_callback = 0;
2346 	encoder->private_->client_data = 0;
2347 
2348 #if FLAC__HAS_OGG
2349 	FLAC__ogg_encoder_aspect_set_defaults(&encoder->protected_->ogg_encoder_aspect);
2350 #endif
2351 
2352 	FLAC__stream_encoder_set_compression_level(encoder, 5);
2353 }
2354 
free_(FLAC__StreamEncoder * encoder)2355 void free_(FLAC__StreamEncoder *encoder)
2356 {
2357 	unsigned i, channel;
2358 
2359 	FLAC__ASSERT(0 != encoder);
2360 	if(encoder->protected_->metadata) {
2361 		free(encoder->protected_->metadata);
2362 		encoder->protected_->metadata = 0;
2363 		encoder->protected_->num_metadata_blocks = 0;
2364 	}
2365 	for(i = 0; i < encoder->protected_->channels; i++) {
2366 		if(0 != encoder->private_->integer_signal_unaligned[i]) {
2367 			free(encoder->private_->integer_signal_unaligned[i]);
2368 			encoder->private_->integer_signal_unaligned[i] = 0;
2369 		}
2370 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2371 		if(0 != encoder->private_->real_signal_unaligned[i]) {
2372 			free(encoder->private_->real_signal_unaligned[i]);
2373 			encoder->private_->real_signal_unaligned[i] = 0;
2374 		}
2375 #endif
2376 	}
2377 	for(i = 0; i < 2; i++) {
2378 		if(0 != encoder->private_->integer_signal_mid_side_unaligned[i]) {
2379 			free(encoder->private_->integer_signal_mid_side_unaligned[i]);
2380 			encoder->private_->integer_signal_mid_side_unaligned[i] = 0;
2381 		}
2382 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2383 		if(0 != encoder->private_->real_signal_mid_side_unaligned[i]) {
2384 			free(encoder->private_->real_signal_mid_side_unaligned[i]);
2385 			encoder->private_->real_signal_mid_side_unaligned[i] = 0;
2386 		}
2387 #endif
2388 	}
2389 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2390 	for(i = 0; i < encoder->protected_->num_apodizations; i++) {
2391 		if(0 != encoder->private_->window_unaligned[i]) {
2392 			free(encoder->private_->window_unaligned[i]);
2393 			encoder->private_->window_unaligned[i] = 0;
2394 		}
2395 	}
2396 	if(0 != encoder->private_->windowed_signal_unaligned) {
2397 		free(encoder->private_->windowed_signal_unaligned);
2398 		encoder->private_->windowed_signal_unaligned = 0;
2399 	}
2400 #endif
2401 	for(channel = 0; channel < encoder->protected_->channels; channel++) {
2402 		for(i = 0; i < 2; i++) {
2403 			if(0 != encoder->private_->residual_workspace_unaligned[channel][i]) {
2404 				free(encoder->private_->residual_workspace_unaligned[channel][i]);
2405 				encoder->private_->residual_workspace_unaligned[channel][i] = 0;
2406 			}
2407 		}
2408 	}
2409 	for(channel = 0; channel < 2; channel++) {
2410 		for(i = 0; i < 2; i++) {
2411 			if(0 != encoder->private_->residual_workspace_mid_side_unaligned[channel][i]) {
2412 				free(encoder->private_->residual_workspace_mid_side_unaligned[channel][i]);
2413 				encoder->private_->residual_workspace_mid_side_unaligned[channel][i] = 0;
2414 			}
2415 		}
2416 	}
2417 	if(0 != encoder->private_->abs_residual_partition_sums_unaligned) {
2418 		free(encoder->private_->abs_residual_partition_sums_unaligned);
2419 		encoder->private_->abs_residual_partition_sums_unaligned = 0;
2420 	}
2421 	if(0 != encoder->private_->raw_bits_per_partition_unaligned) {
2422 		free(encoder->private_->raw_bits_per_partition_unaligned);
2423 		encoder->private_->raw_bits_per_partition_unaligned = 0;
2424 	}
2425 	if(encoder->protected_->verify) {
2426 		for(i = 0; i < encoder->protected_->channels; i++) {
2427 			if(0 != encoder->private_->verify.input_fifo.data[i]) {
2428 				free(encoder->private_->verify.input_fifo.data[i]);
2429 				encoder->private_->verify.input_fifo.data[i] = 0;
2430 			}
2431 		}
2432 	}
2433 	FLAC__bitwriter_free(encoder->private_->frame);
2434 }
2435 
resize_buffers_(FLAC__StreamEncoder * encoder,unsigned new_blocksize)2436 FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_blocksize)
2437 {
2438 	FLAC__bool ok;
2439 	unsigned i, channel;
2440 
2441 	FLAC__ASSERT(new_blocksize > 0);
2442 	FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
2443 	FLAC__ASSERT(encoder->private_->current_sample_number == 0);
2444 
2445 	/* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */
2446 	if(new_blocksize <= encoder->private_->input_capacity)
2447 		return true;
2448 
2449 	ok = true;
2450 
2451 	/* WATCHOUT: FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx() and ..._intrin_sse2()
2452 	 * require that the input arrays (in our case the integer signals)
2453 	 * have a buffer of up to 3 zeroes in front (at negative indices) for
2454 	 * alignment purposes; we use 4 in front to keep the data well-aligned.
2455 	 */
2456 
2457 	for(i = 0; ok && i < encoder->protected_->channels; i++) {
2458 		ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize+4+OVERREAD_, &encoder->private_->integer_signal_unaligned[i], &encoder->private_->integer_signal[i]);
2459 		memset(encoder->private_->integer_signal[i], 0, sizeof(FLAC__int32)*4);
2460 		encoder->private_->integer_signal[i] += 4;
2461 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2462 #if 0 /* @@@ currently unused */
2463 		if(encoder->protected_->max_lpc_order > 0)
2464 			ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize+OVERREAD_, &encoder->private_->real_signal_unaligned[i], &encoder->private_->real_signal[i]);
2465 #endif
2466 #endif
2467 	}
2468 	for(i = 0; ok && i < 2; i++) {
2469 		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]);
2470 		memset(encoder->private_->integer_signal_mid_side[i], 0, sizeof(FLAC__int32)*4);
2471 		encoder->private_->integer_signal_mid_side[i] += 4;
2472 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2473 #if 0 /* @@@ currently unused */
2474 		if(encoder->protected_->max_lpc_order > 0)
2475 			ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize+OVERREAD_, &encoder->private_->real_signal_mid_side_unaligned[i], &encoder->private_->real_signal_mid_side[i]);
2476 #endif
2477 #endif
2478 	}
2479 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2480 	if(ok && encoder->protected_->max_lpc_order > 0) {
2481 		for(i = 0; ok && i < encoder->protected_->num_apodizations; i++)
2482 			ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->window_unaligned[i], &encoder->private_->window[i]);
2483 		ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->windowed_signal_unaligned, &encoder->private_->windowed_signal);
2484 	}
2485 #endif
2486 	for(channel = 0; ok && channel < encoder->protected_->channels; channel++) {
2487 		for(i = 0; ok && i < 2; i++) {
2488 			ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize, &encoder->private_->residual_workspace_unaligned[channel][i], &encoder->private_->residual_workspace[channel][i]);
2489 		}
2490 	}
2491 	for(channel = 0; ok && channel < 2; channel++) {
2492 		for(i = 0; ok && i < 2; i++) {
2493 			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]);
2494 		}
2495 	}
2496 	/* the *2 is an approximation to the series 1 + 1/2 + 1/4 + ... that sums tree occupies in a flat array */
2497 	/*@@@ 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) */
2498 	ok = ok && FLAC__memory_alloc_aligned_uint64_array(new_blocksize * 2, &encoder->private_->abs_residual_partition_sums_unaligned, &encoder->private_->abs_residual_partition_sums);
2499 	if(encoder->protected_->do_escape_coding)
2500 		ok = ok && FLAC__memory_alloc_aligned_unsigned_array(new_blocksize * 2, &encoder->private_->raw_bits_per_partition_unaligned, &encoder->private_->raw_bits_per_partition);
2501 
2502 	/* now adjust the windows if the blocksize has changed */
2503 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2504 	if(ok && new_blocksize != encoder->private_->input_capacity && encoder->protected_->max_lpc_order > 0) {
2505 		for(i = 0; ok && i < encoder->protected_->num_apodizations; i++) {
2506 			switch(encoder->protected_->apodizations[i].type) {
2507 				case FLAC__APODIZATION_BARTLETT:
2508 					FLAC__window_bartlett(encoder->private_->window[i], new_blocksize);
2509 					break;
2510 				case FLAC__APODIZATION_BARTLETT_HANN:
2511 					FLAC__window_bartlett_hann(encoder->private_->window[i], new_blocksize);
2512 					break;
2513 				case FLAC__APODIZATION_BLACKMAN:
2514 					FLAC__window_blackman(encoder->private_->window[i], new_blocksize);
2515 					break;
2516 				case FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE:
2517 					FLAC__window_blackman_harris_4term_92db_sidelobe(encoder->private_->window[i], new_blocksize);
2518 					break;
2519 				case FLAC__APODIZATION_CONNES:
2520 					FLAC__window_connes(encoder->private_->window[i], new_blocksize);
2521 					break;
2522 				case FLAC__APODIZATION_FLATTOP:
2523 					FLAC__window_flattop(encoder->private_->window[i], new_blocksize);
2524 					break;
2525 				case FLAC__APODIZATION_GAUSS:
2526 					FLAC__window_gauss(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.gauss.stddev);
2527 					break;
2528 				case FLAC__APODIZATION_HAMMING:
2529 					FLAC__window_hamming(encoder->private_->window[i], new_blocksize);
2530 					break;
2531 				case FLAC__APODIZATION_HANN:
2532 					FLAC__window_hann(encoder->private_->window[i], new_blocksize);
2533 					break;
2534 				case FLAC__APODIZATION_KAISER_BESSEL:
2535 					FLAC__window_kaiser_bessel(encoder->private_->window[i], new_blocksize);
2536 					break;
2537 				case FLAC__APODIZATION_NUTTALL:
2538 					FLAC__window_nuttall(encoder->private_->window[i], new_blocksize);
2539 					break;
2540 				case FLAC__APODIZATION_RECTANGLE:
2541 					FLAC__window_rectangle(encoder->private_->window[i], new_blocksize);
2542 					break;
2543 				case FLAC__APODIZATION_TRIANGLE:
2544 					FLAC__window_triangle(encoder->private_->window[i], new_blocksize);
2545 					break;
2546 				case FLAC__APODIZATION_TUKEY:
2547 					FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p);
2548 					break;
2549 				case FLAC__APODIZATION_PARTIAL_TUKEY:
2550 					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);
2551 					break;
2552 				case FLAC__APODIZATION_PUNCHOUT_TUKEY:
2553 					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);
2554 					break;
2555 				case FLAC__APODIZATION_WELCH:
2556 					FLAC__window_welch(encoder->private_->window[i], new_blocksize);
2557 					break;
2558 				default:
2559 					FLAC__ASSERT(0);
2560 					/* double protection */
2561 					FLAC__window_hann(encoder->private_->window[i], new_blocksize);
2562 					break;
2563 			}
2564 		}
2565 	}
2566 #endif
2567 
2568 	if(ok)
2569 		encoder->private_->input_capacity = new_blocksize;
2570 	else
2571 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2572 
2573 	return ok;
2574 }
2575 
write_bitbuffer_(FLAC__StreamEncoder * encoder,unsigned samples,FLAC__bool is_last_block)2576 FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples, FLAC__bool is_last_block)
2577 {
2578 	const FLAC__byte *buffer;
2579 	size_t bytes;
2580 
2581 	FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame));
2582 
2583 	if(!FLAC__bitwriter_get_buffer(encoder->private_->frame, &buffer, &bytes)) {
2584 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2585 		return false;
2586 	}
2587 
2588 	if(encoder->protected_->verify) {
2589 		encoder->private_->verify.output.data = buffer;
2590 		encoder->private_->verify.output.bytes = bytes;
2591 		if(encoder->private_->verify.state_hint == ENCODER_IN_MAGIC) {
2592 			encoder->private_->verify.needs_magic_hack = true;
2593 		}
2594 		else {
2595 			if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder)) {
2596 				FLAC__bitwriter_release_buffer(encoder->private_->frame);
2597 				FLAC__bitwriter_clear(encoder->private_->frame);
2598 				if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
2599 					encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
2600 				return false;
2601 			}
2602 		}
2603 	}
2604 
2605 	if(write_frame_(encoder, buffer, bytes, samples, is_last_block) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2606 		FLAC__bitwriter_release_buffer(encoder->private_->frame);
2607 		FLAC__bitwriter_clear(encoder->private_->frame);
2608 		encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2609 		return false;
2610 	}
2611 
2612 	FLAC__bitwriter_release_buffer(encoder->private_->frame);
2613 	FLAC__bitwriter_clear(encoder->private_->frame);
2614 
2615 	if(samples > 0) {
2616 		encoder->private_->streaminfo.data.stream_info.min_framesize = flac_min(bytes, encoder->private_->streaminfo.data.stream_info.min_framesize);
2617 		encoder->private_->streaminfo.data.stream_info.max_framesize = flac_max(bytes, encoder->private_->streaminfo.data.stream_info.max_framesize);
2618 	}
2619 
2620 	return true;
2621 }
2622 
write_frame_(FLAC__StreamEncoder * encoder,const FLAC__byte buffer[],size_t bytes,unsigned samples,FLAC__bool is_last_block)2623 FLAC__StreamEncoderWriteStatus write_frame_(FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, FLAC__bool is_last_block)
2624 {
2625 	FLAC__StreamEncoderWriteStatus status;
2626 	FLAC__uint64 output_position = 0;
2627 
2628 #if FLAC__HAS_OGG == 0
2629 	(void)is_last_block;
2630 #endif
2631 
2632 	/* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */
2633 	if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &output_position, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) {
2634 		encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2635 		return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
2636 	}
2637 
2638 	/*
2639 	 * Watch for the STREAMINFO block and first SEEKTABLE block to go by and store their offsets.
2640 	 */
2641 	if(samples == 0) {
2642 		FLAC__MetadataType type = (buffer[0] & 0x7f);
2643 		if(type == FLAC__METADATA_TYPE_STREAMINFO)
2644 			encoder->protected_->streaminfo_offset = output_position;
2645 		else if(type == FLAC__METADATA_TYPE_SEEKTABLE && encoder->protected_->seektable_offset == 0)
2646 			encoder->protected_->seektable_offset = output_position;
2647 	}
2648 
2649 	/*
2650 	 * Mark the current seek point if hit (if audio_offset == 0 that
2651 	 * means we're still writing metadata and haven't hit the first
2652 	 * frame yet)
2653 	 */
2654 	if(0 != encoder->private_->seek_table && encoder->protected_->audio_offset > 0 && encoder->private_->seek_table->num_points > 0) {
2655 		const unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder);
2656 		const FLAC__uint64 frame_first_sample = encoder->private_->samples_written;
2657 		const FLAC__uint64 frame_last_sample = frame_first_sample + (FLAC__uint64)blocksize - 1;
2658 		FLAC__uint64 test_sample;
2659 		unsigned i;
2660 		for(i = encoder->private_->first_seekpoint_to_check; i < encoder->private_->seek_table->num_points; i++) {
2661 			test_sample = encoder->private_->seek_table->points[i].sample_number;
2662 			if(test_sample > frame_last_sample) {
2663 				break;
2664 			}
2665 			else if(test_sample >= frame_first_sample) {
2666 				encoder->private_->seek_table->points[i].sample_number = frame_first_sample;
2667 				encoder->private_->seek_table->points[i].stream_offset = output_position - encoder->protected_->audio_offset;
2668 				encoder->private_->seek_table->points[i].frame_samples = blocksize;
2669 				encoder->private_->first_seekpoint_to_check++;
2670 				/* DO NOT: "break;" and here's why:
2671 				 * The seektable template may contain more than one target
2672 				 * sample for any given frame; we will keep looping, generating
2673 				 * duplicate seekpoints for them, and we'll clean it up later,
2674 				 * just before writing the seektable back to the metadata.
2675 				 */
2676 			}
2677 			else {
2678 				encoder->private_->first_seekpoint_to_check++;
2679 			}
2680 		}
2681 	}
2682 
2683 #if FLAC__HAS_OGG
2684 	if(encoder->private_->is_ogg) {
2685 		status = FLAC__ogg_encoder_aspect_write_callback_wrapper(
2686 			&encoder->protected_->ogg_encoder_aspect,
2687 			buffer,
2688 			bytes,
2689 			samples,
2690 			encoder->private_->current_frame_number,
2691 			is_last_block,
2692 			(FLAC__OggEncoderAspectWriteCallbackProxy)encoder->private_->write_callback,
2693 			encoder,
2694 			encoder->private_->client_data
2695 		);
2696 	}
2697 	else
2698 #endif
2699 	status = encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data);
2700 
2701 	if(status == FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2702 		encoder->private_->bytes_written += bytes;
2703 		encoder->private_->samples_written += samples;
2704 		/* we keep a high watermark on the number of frames written because
2705 		 * when the encoder goes back to write metadata, 'current_frame'
2706 		 * will drop back to 0.
2707 		 */
2708 		encoder->private_->frames_written = flac_max(encoder->private_->frames_written, encoder->private_->current_frame_number+1);
2709 	}
2710 	else
2711 		encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2712 
2713 	return status;
2714 }
2715 
2716 /* Gets called when the encoding process has finished so that we can update the STREAMINFO and SEEKTABLE blocks.  */
update_metadata_(const FLAC__StreamEncoder * encoder)2717 void update_metadata_(const FLAC__StreamEncoder *encoder)
2718 {
2719 	FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)];
2720 	const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo;
2721 	const FLAC__uint64 samples = metadata->data.stream_info.total_samples;
2722 	const unsigned min_framesize = metadata->data.stream_info.min_framesize;
2723 	const unsigned max_framesize = metadata->data.stream_info.max_framesize;
2724 	const unsigned bps = metadata->data.stream_info.bits_per_sample;
2725 	FLAC__StreamEncoderSeekStatus seek_status;
2726 
2727 	FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO);
2728 
2729 	/* All this is based on intimate knowledge of the stream header
2730 	 * layout, but a change to the header format that would break this
2731 	 * would also break all streams encoded in the previous format.
2732 	 */
2733 
2734 	/*
2735 	 * Write MD5 signature
2736 	 */
2737 	{
2738 		const unsigned md5_offset =
2739 			FLAC__STREAM_METADATA_HEADER_LENGTH +
2740 			(
2741 				FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
2742 				FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
2743 				FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
2744 				FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
2745 				FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
2746 				FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
2747 				FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN +
2748 				FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN
2749 			) / 8;
2750 
2751 		if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + md5_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
2752 			if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
2753 				encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2754 			return;
2755 		}
2756 		if(encoder->private_->write_callback(encoder, metadata->data.stream_info.md5sum, 16, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2757 			encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2758 			return;
2759 		}
2760 	}
2761 
2762 	/*
2763 	 * Write total samples
2764 	 */
2765 	{
2766 		const unsigned total_samples_byte_offset =
2767 			FLAC__STREAM_METADATA_HEADER_LENGTH +
2768 			(
2769 				FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
2770 				FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
2771 				FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
2772 				FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
2773 				FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
2774 				FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
2775 				FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
2776 				- 4
2777 			) / 8;
2778 
2779 		b[0] = ((FLAC__byte)(bps-1) << 4) | (FLAC__byte)((samples >> 32) & 0x0F);
2780 		b[1] = (FLAC__byte)((samples >> 24) & 0xFF);
2781 		b[2] = (FLAC__byte)((samples >> 16) & 0xFF);
2782 		b[3] = (FLAC__byte)((samples >> 8) & 0xFF);
2783 		b[4] = (FLAC__byte)(samples & 0xFF);
2784 		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) {
2785 			if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
2786 				encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2787 			return;
2788 		}
2789 		if(encoder->private_->write_callback(encoder, b, 5, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2790 			encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2791 			return;
2792 		}
2793 	}
2794 
2795 	/*
2796 	 * Write min/max framesize
2797 	 */
2798 	{
2799 		const unsigned min_framesize_offset =
2800 			FLAC__STREAM_METADATA_HEADER_LENGTH +
2801 			(
2802 				FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
2803 				FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
2804 			) / 8;
2805 
2806 		b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF);
2807 		b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF);
2808 		b[2] = (FLAC__byte)(min_framesize & 0xFF);
2809 		b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF);
2810 		b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF);
2811 		b[5] = (FLAC__byte)(max_framesize & 0xFF);
2812 		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) {
2813 			if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
2814 				encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2815 			return;
2816 		}
2817 		if(encoder->private_->write_callback(encoder, b, 6, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2818 			encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2819 			return;
2820 		}
2821 	}
2822 
2823 	/*
2824 	 * Write seektable
2825 	 */
2826 	if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) {
2827 		unsigned i;
2828 
2829 		FLAC__format_seektable_sort(encoder->private_->seek_table);
2830 
2831 		FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table));
2832 
2833 		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) {
2834 			if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
2835 				encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2836 			return;
2837 		}
2838 
2839 		for(i = 0; i < encoder->private_->seek_table->num_points; i++) {
2840 			FLAC__uint64 xx;
2841 			unsigned x;
2842 			xx = encoder->private_->seek_table->points[i].sample_number;
2843 			b[7] = (FLAC__byte)xx; xx >>= 8;
2844 			b[6] = (FLAC__byte)xx; xx >>= 8;
2845 			b[5] = (FLAC__byte)xx; xx >>= 8;
2846 			b[4] = (FLAC__byte)xx; xx >>= 8;
2847 			b[3] = (FLAC__byte)xx; xx >>= 8;
2848 			b[2] = (FLAC__byte)xx; xx >>= 8;
2849 			b[1] = (FLAC__byte)xx; xx >>= 8;
2850 			b[0] = (FLAC__byte)xx; xx >>= 8;
2851 			xx = encoder->private_->seek_table->points[i].stream_offset;
2852 			b[15] = (FLAC__byte)xx; xx >>= 8;
2853 			b[14] = (FLAC__byte)xx; xx >>= 8;
2854 			b[13] = (FLAC__byte)xx; xx >>= 8;
2855 			b[12] = (FLAC__byte)xx; xx >>= 8;
2856 			b[11] = (FLAC__byte)xx; xx >>= 8;
2857 			b[10] = (FLAC__byte)xx; xx >>= 8;
2858 			b[9] = (FLAC__byte)xx; xx >>= 8;
2859 			b[8] = (FLAC__byte)xx; xx >>= 8;
2860 			x = encoder->private_->seek_table->points[i].frame_samples;
2861 			b[17] = (FLAC__byte)x; x >>= 8;
2862 			b[16] = (FLAC__byte)x; x >>= 8;
2863 			if(encoder->private_->write_callback(encoder, b, 18, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2864 				encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2865 				return;
2866 			}
2867 		}
2868 	}
2869 }
2870 
2871 #if FLAC__HAS_OGG
2872 /* Gets called when the encoding process has finished so that we can update the STREAMINFO and SEEKTABLE blocks.  */
update_ogg_metadata_(FLAC__StreamEncoder * encoder)2873 void update_ogg_metadata_(FLAC__StreamEncoder *encoder)
2874 {
2875 	/* the # of bytes in the 1st packet that precede the STREAMINFO */
2876 	static const unsigned FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH =
2877 		FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH +
2878 		FLAC__OGG_MAPPING_MAGIC_LENGTH +
2879 		FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH +
2880 		FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH +
2881 		FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH +
2882 		FLAC__STREAM_SYNC_LENGTH
2883 	;
2884 	FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)];
2885 	const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo;
2886 	const FLAC__uint64 samples = metadata->data.stream_info.total_samples;
2887 	const unsigned min_framesize = metadata->data.stream_info.min_framesize;
2888 	const unsigned max_framesize = metadata->data.stream_info.max_framesize;
2889 	ogg_page page;
2890 
2891 	FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO);
2892 	FLAC__ASSERT(0 != encoder->private_->seek_callback);
2893 
2894 	/* Pre-check that client supports seeking, since we don't want the
2895 	 * ogg_helper code to ever have to deal with this condition.
2896 	 */
2897 	if(encoder->private_->seek_callback(encoder, 0, encoder->private_->client_data) == FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED)
2898 		return;
2899 
2900 	/* All this is based on intimate knowledge of the stream header
2901 	 * layout, but a change to the header format that would break this
2902 	 * would also break all streams encoded in the previous format.
2903 	 */
2904 
2905 	/**
2906 	 ** Write STREAMINFO stats
2907 	 **/
2908 	simple_ogg_page__init(&page);
2909 	if(!simple_ogg_page__get_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->read_callback, encoder->private_->client_data)) {
2910 		simple_ogg_page__clear(&page);
2911 		return; /* state already set */
2912 	}
2913 
2914 	/*
2915 	 * Write MD5 signature
2916 	 */
2917 	{
2918 		const unsigned md5_offset =
2919 			FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH +
2920 			FLAC__STREAM_METADATA_HEADER_LENGTH +
2921 			(
2922 				FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
2923 				FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
2924 				FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
2925 				FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
2926 				FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
2927 				FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
2928 				FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN +
2929 				FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN
2930 			) / 8;
2931 
2932 		if(md5_offset + 16 > (unsigned)page.body_len) {
2933 			encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
2934 			simple_ogg_page__clear(&page);
2935 			return;
2936 		}
2937 		memcpy(page.body + md5_offset, metadata->data.stream_info.md5sum, 16);
2938 	}
2939 
2940 	/*
2941 	 * Write total samples
2942 	 */
2943 	{
2944 		const unsigned total_samples_byte_offset =
2945 			FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH +
2946 			FLAC__STREAM_METADATA_HEADER_LENGTH +
2947 			(
2948 				FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
2949 				FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
2950 				FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
2951 				FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
2952 				FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
2953 				FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
2954 				FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
2955 				- 4
2956 			) / 8;
2957 
2958 		if(total_samples_byte_offset + 5 > (unsigned)page.body_len) {
2959 			encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
2960 			simple_ogg_page__clear(&page);
2961 			return;
2962 		}
2963 		b[0] = (FLAC__byte)page.body[total_samples_byte_offset] & 0xF0;
2964 		b[0] |= (FLAC__byte)((samples >> 32) & 0x0F);
2965 		b[1] = (FLAC__byte)((samples >> 24) & 0xFF);
2966 		b[2] = (FLAC__byte)((samples >> 16) & 0xFF);
2967 		b[3] = (FLAC__byte)((samples >> 8) & 0xFF);
2968 		b[4] = (FLAC__byte)(samples & 0xFF);
2969 		memcpy(page.body + total_samples_byte_offset, b, 5);
2970 	}
2971 
2972 	/*
2973 	 * Write min/max framesize
2974 	 */
2975 	{
2976 		const unsigned min_framesize_offset =
2977 			FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH +
2978 			FLAC__STREAM_METADATA_HEADER_LENGTH +
2979 			(
2980 				FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
2981 				FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
2982 			) / 8;
2983 
2984 		if(min_framesize_offset + 6 > (unsigned)page.body_len) {
2985 			encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
2986 			simple_ogg_page__clear(&page);
2987 			return;
2988 		}
2989 		b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF);
2990 		b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF);
2991 		b[2] = (FLAC__byte)(min_framesize & 0xFF);
2992 		b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF);
2993 		b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF);
2994 		b[5] = (FLAC__byte)(max_framesize & 0xFF);
2995 		memcpy(page.body + min_framesize_offset, b, 6);
2996 	}
2997 	if(!simple_ogg_page__set_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->write_callback, encoder->private_->client_data)) {
2998 		simple_ogg_page__clear(&page);
2999 		return; /* state already set */
3000 	}
3001 	simple_ogg_page__clear(&page);
3002 
3003 	/*
3004 	 * Write seektable
3005 	 */
3006 	if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) {
3007 		unsigned i;
3008 		FLAC__byte *p;
3009 
3010 		FLAC__format_seektable_sort(encoder->private_->seek_table);
3011 
3012 		FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table));
3013 
3014 		simple_ogg_page__init(&page);
3015 		if(!simple_ogg_page__get_at(encoder, encoder->protected_->seektable_offset, &page, encoder->private_->seek_callback, encoder->private_->read_callback, encoder->private_->client_data)) {
3016 			simple_ogg_page__clear(&page);
3017 			return; /* state already set */
3018 		}
3019 
3020 		if((FLAC__STREAM_METADATA_HEADER_LENGTH + 18*encoder->private_->seek_table->num_points) != (unsigned)page.body_len) {
3021 			encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
3022 			simple_ogg_page__clear(&page);
3023 			return;
3024 		}
3025 
3026 		for(i = 0, p = page.body + FLAC__STREAM_METADATA_HEADER_LENGTH; i < encoder->private_->seek_table->num_points; i++, p += 18) {
3027 			FLAC__uint64 xx;
3028 			unsigned x;
3029 			xx = encoder->private_->seek_table->points[i].sample_number;
3030 			b[7] = (FLAC__byte)xx; xx >>= 8;
3031 			b[6] = (FLAC__byte)xx; xx >>= 8;
3032 			b[5] = (FLAC__byte)xx; xx >>= 8;
3033 			b[4] = (FLAC__byte)xx; xx >>= 8;
3034 			b[3] = (FLAC__byte)xx; xx >>= 8;
3035 			b[2] = (FLAC__byte)xx; xx >>= 8;
3036 			b[1] = (FLAC__byte)xx; xx >>= 8;
3037 			b[0] = (FLAC__byte)xx; xx >>= 8;
3038 			xx = encoder->private_->seek_table->points[i].stream_offset;
3039 			b[15] = (FLAC__byte)xx; xx >>= 8;
3040 			b[14] = (FLAC__byte)xx; xx >>= 8;
3041 			b[13] = (FLAC__byte)xx; xx >>= 8;
3042 			b[12] = (FLAC__byte)xx; xx >>= 8;
3043 			b[11] = (FLAC__byte)xx; xx >>= 8;
3044 			b[10] = (FLAC__byte)xx; xx >>= 8;
3045 			b[9] = (FLAC__byte)xx; xx >>= 8;
3046 			b[8] = (FLAC__byte)xx; xx >>= 8;
3047 			x = encoder->private_->seek_table->points[i].frame_samples;
3048 			b[17] = (FLAC__byte)x; x >>= 8;
3049 			b[16] = (FLAC__byte)x; x >>= 8;
3050 			memcpy(p, b, 18);
3051 		}
3052 
3053 		if(!simple_ogg_page__set_at(encoder, encoder->protected_->seektable_offset, &page, encoder->private_->seek_callback, encoder->private_->write_callback, encoder->private_->client_data)) {
3054 			simple_ogg_page__clear(&page);
3055 			return; /* state already set */
3056 		}
3057 		simple_ogg_page__clear(&page);
3058 	}
3059 }
3060 #endif
3061 
process_frame_(FLAC__StreamEncoder * encoder,FLAC__bool is_fractional_block,FLAC__bool is_last_block)3062 FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block, FLAC__bool is_last_block)
3063 {
3064 	FLAC__uint16 crc;
3065 	FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
3066 
3067 	/*
3068 	 * Accumulate raw signal to the MD5 signature
3069 	 */
3070 	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)) {
3071 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
3072 		return false;
3073 	}
3074 
3075 	/*
3076 	 * Process the frame header and subframes into the frame bitbuffer
3077 	 */
3078 	if(!process_subframes_(encoder, is_fractional_block)) {
3079 		/* the above function sets the state for us in case of an error */
3080 		return false;
3081 	}
3082 
3083 	/*
3084 	 * Zero-pad the frame to a byte_boundary
3085 	 */
3086 	if(!FLAC__bitwriter_zero_pad_to_byte_boundary(encoder->private_->frame)) {
3087 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
3088 		return false;
3089 	}
3090 
3091 	/*
3092 	 * CRC-16 the whole thing
3093 	 */
3094 	FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame));
3095 	if(
3096 		!FLAC__bitwriter_get_write_crc16(encoder->private_->frame, &crc) ||
3097 		!FLAC__bitwriter_write_raw_uint32(encoder->private_->frame, crc, FLAC__FRAME_FOOTER_CRC_LEN)
3098 	) {
3099 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
3100 		return false;
3101 	}
3102 
3103 	/*
3104 	 * Write it
3105 	 */
3106 	if(!write_bitbuffer_(encoder, encoder->protected_->blocksize, is_last_block)) {
3107 		/* the above function sets the state for us in case of an error */
3108 		return false;
3109 	}
3110 
3111 	/*
3112 	 * Get ready for the next frame
3113 	 */
3114 	encoder->private_->current_sample_number = 0;
3115 	encoder->private_->current_frame_number++;
3116 	encoder->private_->streaminfo.data.stream_info.total_samples += (FLAC__uint64)encoder->protected_->blocksize;
3117 
3118 	return true;
3119 }
3120 
process_subframes_(FLAC__StreamEncoder * encoder,FLAC__bool is_fractional_block)3121 FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block)
3122 {
3123 	FLAC__FrameHeader frame_header;
3124 	unsigned channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order;
3125 	FLAC__bool do_independent, do_mid_side;
3126 
3127 	/*
3128 	 * Calculate the min,max Rice partition orders
3129 	 */
3130 	if(is_fractional_block) {
3131 		max_partition_order = 0;
3132 	}
3133 	else {
3134 		max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize(encoder->protected_->blocksize);
3135 		max_partition_order = flac_min(max_partition_order, encoder->protected_->max_residual_partition_order);
3136 	}
3137 	min_partition_order = flac_min(min_partition_order, max_partition_order);
3138 
3139 	/*
3140 	 * Setup the frame
3141 	 */
3142 	frame_header.blocksize = encoder->protected_->blocksize;
3143 	frame_header.sample_rate = encoder->protected_->sample_rate;
3144 	frame_header.channels = encoder->protected_->channels;
3145 	frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */
3146 	frame_header.bits_per_sample = encoder->protected_->bits_per_sample;
3147 	frame_header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER;
3148 	frame_header.number.frame_number = encoder->private_->current_frame_number;
3149 
3150 	/*
3151 	 * Figure out what channel assignments to try
3152 	 */
3153 	if(encoder->protected_->do_mid_side_stereo) {
3154 		if(encoder->protected_->loose_mid_side_stereo) {
3155 			if(encoder->private_->loose_mid_side_stereo_frame_count == 0) {
3156 				do_independent = true;
3157 				do_mid_side = true;
3158 			}
3159 			else {
3160 				do_independent = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT);
3161 				do_mid_side = !do_independent;
3162 			}
3163 		}
3164 		else {
3165 			do_independent = true;
3166 			do_mid_side = true;
3167 		}
3168 	}
3169 	else {
3170 		do_independent = true;
3171 		do_mid_side = false;
3172 	}
3173 
3174 	FLAC__ASSERT(do_independent || do_mid_side);
3175 
3176 	/*
3177 	 * Check for wasted bits; set effective bps for each subframe
3178 	 */
3179 	if(do_independent) {
3180 		for(channel = 0; channel < encoder->protected_->channels; channel++) {
3181 			const unsigned w = get_wasted_bits_(encoder->private_->integer_signal[channel], encoder->protected_->blocksize);
3182 			encoder->private_->subframe_workspace[channel][0].wasted_bits = encoder->private_->subframe_workspace[channel][1].wasted_bits = w;
3183 			encoder->private_->subframe_bps[channel] = encoder->protected_->bits_per_sample - w;
3184 		}
3185 	}
3186 	if(do_mid_side) {
3187 		FLAC__ASSERT(encoder->protected_->channels == 2);
3188 		for(channel = 0; channel < 2; channel++) {
3189 			const unsigned w = get_wasted_bits_(encoder->private_->integer_signal_mid_side[channel], encoder->protected_->blocksize);
3190 			encoder->private_->subframe_workspace_mid_side[channel][0].wasted_bits = encoder->private_->subframe_workspace_mid_side[channel][1].wasted_bits = w;
3191 			encoder->private_->subframe_bps_mid_side[channel] = encoder->protected_->bits_per_sample - w + (channel==0? 0:1);
3192 		}
3193 	}
3194 
3195 	/*
3196 	 * First do a normal encoding pass of each independent channel
3197 	 */
3198 	if(do_independent) {
3199 		for(channel = 0; channel < encoder->protected_->channels; channel++) {
3200 			if(!
3201 				process_subframe_(
3202 					encoder,
3203 					min_partition_order,
3204 					max_partition_order,
3205 					&frame_header,
3206 					encoder->private_->subframe_bps[channel],
3207 					encoder->private_->integer_signal[channel],
3208 					encoder->private_->subframe_workspace_ptr[channel],
3209 					encoder->private_->partitioned_rice_contents_workspace_ptr[channel],
3210 					encoder->private_->residual_workspace[channel],
3211 					encoder->private_->best_subframe+channel,
3212 					encoder->private_->best_subframe_bits+channel
3213 				)
3214 			)
3215 				return false;
3216 		}
3217 	}
3218 
3219 	/*
3220 	 * Now do mid and side channels if requested
3221 	 */
3222 	if(do_mid_side) {
3223 		FLAC__ASSERT(encoder->protected_->channels == 2);
3224 
3225 		for(channel = 0; channel < 2; channel++) {
3226 			if(!
3227 				process_subframe_(
3228 					encoder,
3229 					min_partition_order,
3230 					max_partition_order,
3231 					&frame_header,
3232 					encoder->private_->subframe_bps_mid_side[channel],
3233 					encoder->private_->integer_signal_mid_side[channel],
3234 					encoder->private_->subframe_workspace_ptr_mid_side[channel],
3235 					encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[channel],
3236 					encoder->private_->residual_workspace_mid_side[channel],
3237 					encoder->private_->best_subframe_mid_side+channel,
3238 					encoder->private_->best_subframe_bits_mid_side+channel
3239 				)
3240 			)
3241 				return false;
3242 		}
3243 	}
3244 
3245 	/*
3246 	 * Compose the frame bitbuffer
3247 	 */
3248 	if(do_mid_side) {
3249 		unsigned left_bps = 0, right_bps = 0; /* initialized only to prevent superfluous compiler warning */
3250 		FLAC__Subframe *left_subframe = 0, *right_subframe = 0; /* initialized only to prevent superfluous compiler warning */
3251 		FLAC__ChannelAssignment channel_assignment;
3252 
3253 		FLAC__ASSERT(encoder->protected_->channels == 2);
3254 
3255 		if(encoder->protected_->loose_mid_side_stereo && encoder->private_->loose_mid_side_stereo_frame_count > 0) {
3256 			channel_assignment = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT? FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT : FLAC__CHANNEL_ASSIGNMENT_MID_SIDE);
3257 		}
3258 		else {
3259 			unsigned bits[4]; /* WATCHOUT - indexed by FLAC__ChannelAssignment */
3260 			unsigned min_bits;
3261 			int ca;
3262 
3263 			FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT == 0);
3264 			FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE   == 1);
3265 			FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE  == 2);
3266 			FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_MID_SIDE    == 3);
3267 			FLAC__ASSERT(do_independent && do_mid_side);
3268 
3269 			/* We have to figure out which channel assignent results in the smallest frame */
3270 			bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = encoder->private_->best_subframe_bits         [0] + encoder->private_->best_subframe_bits         [1];
3271 			bits[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE  ] = encoder->private_->best_subframe_bits         [0] + encoder->private_->best_subframe_bits_mid_side[1];
3272 			bits[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE ] = encoder->private_->best_subframe_bits         [1] + encoder->private_->best_subframe_bits_mid_side[1];
3273 			bits[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE   ] = encoder->private_->best_subframe_bits_mid_side[0] + encoder->private_->best_subframe_bits_mid_side[1];
3274 
3275 			channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT;
3276 			min_bits = bits[channel_assignment];
3277 			for(ca = 1; ca <= 3; ca++) {
3278 				if(bits[ca] < min_bits) {
3279 					min_bits = bits[ca];
3280 					channel_assignment = (FLAC__ChannelAssignment)ca;
3281 				}
3282 			}
3283 		}
3284 
3285 		frame_header.channel_assignment = channel_assignment;
3286 
3287 		if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) {
3288 			encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3289 			return false;
3290 		}
3291 
3292 		switch(channel_assignment) {
3293 			case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
3294 				left_subframe  = &encoder->private_->subframe_workspace         [0][encoder->private_->best_subframe         [0]];
3295 				right_subframe = &encoder->private_->subframe_workspace         [1][encoder->private_->best_subframe         [1]];
3296 				break;
3297 			case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
3298 				left_subframe  = &encoder->private_->subframe_workspace         [0][encoder->private_->best_subframe         [0]];
3299 				right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
3300 				break;
3301 			case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
3302 				left_subframe  = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
3303 				right_subframe = &encoder->private_->subframe_workspace         [1][encoder->private_->best_subframe         [1]];
3304 				break;
3305 			case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
3306 				left_subframe  = &encoder->private_->subframe_workspace_mid_side[0][encoder->private_->best_subframe_mid_side[0]];
3307 				right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
3308 				break;
3309 			default:
3310 				FLAC__ASSERT(0);
3311 		}
3312 
3313 		switch(channel_assignment) {
3314 			case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
3315 				left_bps  = encoder->private_->subframe_bps         [0];
3316 				right_bps = encoder->private_->subframe_bps         [1];
3317 				break;
3318 			case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
3319 				left_bps  = encoder->private_->subframe_bps         [0];
3320 				right_bps = encoder->private_->subframe_bps_mid_side[1];
3321 				break;
3322 			case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
3323 				left_bps  = encoder->private_->subframe_bps_mid_side[1];
3324 				right_bps = encoder->private_->subframe_bps         [1];
3325 				break;
3326 			case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
3327 				left_bps  = encoder->private_->subframe_bps_mid_side[0];
3328 				right_bps = encoder->private_->subframe_bps_mid_side[1];
3329 				break;
3330 			default:
3331 				FLAC__ASSERT(0);
3332 		}
3333 
3334 		/* note that encoder_add_subframe_ sets the state for us in case of an error */
3335 		if(!add_subframe_(encoder, frame_header.blocksize, left_bps , left_subframe , encoder->private_->frame))
3336 			return false;
3337 		if(!add_subframe_(encoder, frame_header.blocksize, right_bps, right_subframe, encoder->private_->frame))
3338 			return false;
3339 	}
3340 	else {
3341 		if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) {
3342 			encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3343 			return false;
3344 		}
3345 
3346 		for(channel = 0; channel < encoder->protected_->channels; channel++) {
3347 			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)) {
3348 				/* the above function sets the state for us in case of an error */
3349 				return false;
3350 			}
3351 		}
3352 	}
3353 
3354 	if(encoder->protected_->loose_mid_side_stereo) {
3355 		encoder->private_->loose_mid_side_stereo_frame_count++;
3356 		if(encoder->private_->loose_mid_side_stereo_frame_count >= encoder->private_->loose_mid_side_stereo_frames)
3357 			encoder->private_->loose_mid_side_stereo_frame_count = 0;
3358 	}
3359 
3360 	encoder->private_->last_channel_assignment = frame_header.channel_assignment;
3361 
3362 	return true;
3363 }
3364 
process_subframe_(FLAC__StreamEncoder * encoder,unsigned min_partition_order,unsigned max_partition_order,const FLAC__FrameHeader * frame_header,unsigned subframe_bps,const FLAC__int32 integer_signal[],FLAC__Subframe * subframe[2],FLAC__EntropyCodingMethod_PartitionedRiceContents * partitioned_rice_contents[2],FLAC__int32 * residual[2],unsigned * best_subframe,unsigned * best_bits)3365 FLAC__bool process_subframe_(
3366 	FLAC__StreamEncoder *encoder,
3367 	unsigned min_partition_order,
3368 	unsigned max_partition_order,
3369 	const FLAC__FrameHeader *frame_header,
3370 	unsigned subframe_bps,
3371 	const FLAC__int32 integer_signal[],
3372 	FLAC__Subframe *subframe[2],
3373 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2],
3374 	FLAC__int32 *residual[2],
3375 	unsigned *best_subframe,
3376 	unsigned *best_bits
3377 )
3378 {
3379 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3380 	FLAC__float fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
3381 #else
3382 	FLAC__fixedpoint fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
3383 #endif
3384 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3385 	FLAC__double lpc_residual_bits_per_sample;
3386 	FLAC__real autoc[FLAC__MAX_LPC_ORDER+1]; /* WATCHOUT: the size is important even though encoder->protected_->max_lpc_order might be less; some asm and x86 intrinsic routines need all the space */
3387 	FLAC__double lpc_error[FLAC__MAX_LPC_ORDER];
3388 	unsigned min_lpc_order, max_lpc_order, lpc_order;
3389 	unsigned min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision;
3390 #endif
3391 	unsigned min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order;
3392 	unsigned rice_parameter;
3393 	unsigned _candidate_bits, _best_bits;
3394 	unsigned _best_subframe;
3395 	/* only use RICE2 partitions if stream bps > 16 */
3396 	const unsigned 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;
3397 
3398 	FLAC__ASSERT(frame_header->blocksize > 0);
3399 
3400 	/* verbatim subframe is the baseline against which we measure other compressed subframes */
3401 	_best_subframe = 0;
3402 	if(encoder->private_->disable_verbatim_subframes && frame_header->blocksize >= FLAC__MAX_FIXED_ORDER)
3403 		_best_bits = UINT_MAX;
3404 	else
3405 		_best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
3406 
3407 	if(frame_header->blocksize >= FLAC__MAX_FIXED_ORDER) {
3408 		unsigned signal_is_constant = false;
3409 		guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor(integer_signal+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample);
3410 		/* check for constant subframe */
3411 		if(
3412 			!encoder->private_->disable_constant_subframes &&
3413 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3414 			fixed_residual_bits_per_sample[1] == 0.0
3415 #else
3416 			fixed_residual_bits_per_sample[1] == FLAC__FP_ZERO
3417 #endif
3418 		) {
3419 			/* the above means it's possible all samples are the same value; now double-check it: */
3420 			unsigned i;
3421 			signal_is_constant = true;
3422 			for(i = 1; i < frame_header->blocksize; i++) {
3423 				if(integer_signal[0] != integer_signal[i]) {
3424 					signal_is_constant = false;
3425 					break;
3426 				}
3427 			}
3428 		}
3429 		if(signal_is_constant) {
3430 			_candidate_bits = evaluate_constant_subframe_(encoder, integer_signal[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]);
3431 			if(_candidate_bits < _best_bits) {
3432 				_best_subframe = !_best_subframe;
3433 				_best_bits = _candidate_bits;
3434 			}
3435 		}
3436 		else {
3437 			if(!encoder->private_->disable_fixed_subframes || (encoder->protected_->max_lpc_order == 0 && _best_bits == UINT_MAX)) {
3438 				/* encode fixed */
3439 				if(encoder->protected_->do_exhaustive_model_search) {
3440 					min_fixed_order = 0;
3441 					max_fixed_order = FLAC__MAX_FIXED_ORDER;
3442 				}
3443 				else {
3444 					min_fixed_order = max_fixed_order = guess_fixed_order;
3445 				}
3446 				if(max_fixed_order >= frame_header->blocksize)
3447 					max_fixed_order = frame_header->blocksize - 1;
3448 				for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) {
3449 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3450 					if(fixed_residual_bits_per_sample[fixed_order] >= (FLAC__float)subframe_bps)
3451 						continue; /* don't even try */
3452 					rice_parameter = (fixed_residual_bits_per_sample[fixed_order] > 0.0)? (unsigned)(fixed_residual_bits_per_sample[fixed_order]+0.5) : 0; /* 0.5 is for rounding */
3453 #else
3454 					if(FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample[fixed_order]) >= (int)subframe_bps)
3455 						continue; /* don't even try */
3456 					rice_parameter = (fixed_residual_bits_per_sample[fixed_order] > FLAC__FP_ZERO)? (unsigned)FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample[fixed_order]+FLAC__FP_ONE_HALF) : 0; /* 0.5 is for rounding */
3457 #endif
3458 					rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */
3459 					if(rice_parameter >= rice_parameter_limit) {
3460 #ifdef DEBUG_VERBOSE
3461 						fprintf(stderr, "clipping rice_parameter (%u -> %u) @0\n", rice_parameter, rice_parameter_limit - 1);
3462 #endif
3463 						rice_parameter = rice_parameter_limit - 1;
3464 					}
3465 					_candidate_bits =
3466 						evaluate_fixed_subframe_(
3467 							encoder,
3468 							integer_signal,
3469 							residual[!_best_subframe],
3470 							encoder->private_->abs_residual_partition_sums,
3471 							encoder->private_->raw_bits_per_partition,
3472 							frame_header->blocksize,
3473 							subframe_bps,
3474 							fixed_order,
3475 							rice_parameter,
3476 							rice_parameter_limit,
3477 							min_partition_order,
3478 							max_partition_order,
3479 							encoder->protected_->do_escape_coding,
3480 							encoder->protected_->rice_parameter_search_dist,
3481 							subframe[!_best_subframe],
3482 							partitioned_rice_contents[!_best_subframe]
3483 						);
3484 					if(_candidate_bits < _best_bits) {
3485 						_best_subframe = !_best_subframe;
3486 						_best_bits = _candidate_bits;
3487 					}
3488 				}
3489 			}
3490 
3491 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3492 			/* encode lpc */
3493 			if(encoder->protected_->max_lpc_order > 0) {
3494 				if(encoder->protected_->max_lpc_order >= frame_header->blocksize)
3495 					max_lpc_order = frame_header->blocksize-1;
3496 				else
3497 					max_lpc_order = encoder->protected_->max_lpc_order;
3498 				if(max_lpc_order > 0) {
3499 					unsigned a;
3500 					for (a = 0; a < encoder->protected_->num_apodizations; a++) {
3501 						FLAC__lpc_window_data(integer_signal, encoder->private_->window[a], encoder->private_->windowed_signal, frame_header->blocksize);
3502 						encoder->private_->local_lpc_compute_autocorrelation(encoder->private_->windowed_signal, frame_header->blocksize, max_lpc_order+1, autoc);
3503 						/* if autoc[0] == 0.0, the signal is constant and we usually won't get here, but it can happen */
3504 						if(autoc[0] != 0.0) {
3505 							FLAC__lpc_compute_lp_coefficients(autoc, &max_lpc_order, encoder->private_->lp_coeff, lpc_error);
3506 							if(encoder->protected_->do_exhaustive_model_search) {
3507 								min_lpc_order = 1;
3508 							}
3509 							else {
3510 								const unsigned guess_lpc_order =
3511 									FLAC__lpc_compute_best_order(
3512 										lpc_error,
3513 										max_lpc_order,
3514 										frame_header->blocksize,
3515 										subframe_bps + (
3516 											encoder->protected_->do_qlp_coeff_prec_search?
3517 												FLAC__MIN_QLP_COEFF_PRECISION : /* have to guess; use the min possible size to avoid accidentally favoring lower orders */
3518 												encoder->protected_->qlp_coeff_precision
3519 										)
3520 									);
3521 								min_lpc_order = max_lpc_order = guess_lpc_order;
3522 							}
3523 							if(max_lpc_order >= frame_header->blocksize)
3524 								max_lpc_order = frame_header->blocksize - 1;
3525 							for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order; lpc_order++) {
3526 								lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize-lpc_order);
3527 								if(lpc_residual_bits_per_sample >= (FLAC__double)subframe_bps)
3528 									continue; /* don't even try */
3529 								rice_parameter = (lpc_residual_bits_per_sample > 0.0)? (unsigned)(lpc_residual_bits_per_sample+0.5) : 0; /* 0.5 is for rounding */
3530 								rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */
3531 								if(rice_parameter >= rice_parameter_limit) {
3532 #ifdef DEBUG_VERBOSE
3533 									fprintf(stderr, "clipping rice_parameter (%u -> %u) @1\n", rice_parameter, rice_parameter_limit - 1);
3534 #endif
3535 									rice_parameter = rice_parameter_limit - 1;
3536 								}
3537 								if(encoder->protected_->do_qlp_coeff_prec_search) {
3538 									min_qlp_coeff_precision = FLAC__MIN_QLP_COEFF_PRECISION;
3539 									/* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps streams */
3540 									if(subframe_bps <= 16) {
3541 										max_qlp_coeff_precision = flac_min(32 - subframe_bps - FLAC__bitmath_ilog2(lpc_order), FLAC__MAX_QLP_COEFF_PRECISION);
3542 										max_qlp_coeff_precision = flac_max(max_qlp_coeff_precision, min_qlp_coeff_precision);
3543 									}
3544 									else
3545 										max_qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION;
3546 								}
3547 								else {
3548 									min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision;
3549 								}
3550 								for(qlp_coeff_precision = min_qlp_coeff_precision; qlp_coeff_precision <= max_qlp_coeff_precision; qlp_coeff_precision++) {
3551 									_candidate_bits =
3552 										evaluate_lpc_subframe_(
3553 											encoder,
3554 											integer_signal,
3555 											residual[!_best_subframe],
3556 											encoder->private_->abs_residual_partition_sums,
3557 											encoder->private_->raw_bits_per_partition,
3558 											encoder->private_->lp_coeff[lpc_order-1],
3559 											frame_header->blocksize,
3560 											subframe_bps,
3561 											lpc_order,
3562 											qlp_coeff_precision,
3563 											rice_parameter,
3564 											rice_parameter_limit,
3565 											min_partition_order,
3566 											max_partition_order,
3567 											encoder->protected_->do_escape_coding,
3568 											encoder->protected_->rice_parameter_search_dist,
3569 											subframe[!_best_subframe],
3570 											partitioned_rice_contents[!_best_subframe]
3571 										);
3572 									if(_candidate_bits > 0) { /* if == 0, there was a problem quantizing the lpcoeffs */
3573 										if(_candidate_bits < _best_bits) {
3574 											_best_subframe = !_best_subframe;
3575 											_best_bits = _candidate_bits;
3576 										}
3577 									}
3578 								}
3579 							}
3580 						}
3581 					}
3582 				}
3583 			}
3584 #endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
3585 		}
3586 	}
3587 
3588 	/* under rare circumstances this can happen when all but lpc subframe types are disabled: */
3589 	if(_best_bits == UINT_MAX) {
3590 		FLAC__ASSERT(_best_subframe == 0);
3591 		_best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
3592 	}
3593 
3594 	*best_subframe = _best_subframe;
3595 	*best_bits = _best_bits;
3596 
3597 	return true;
3598 }
3599 
add_subframe_(FLAC__StreamEncoder * encoder,unsigned blocksize,unsigned subframe_bps,const FLAC__Subframe * subframe,FLAC__BitWriter * frame)3600 FLAC__bool add_subframe_(
3601 	FLAC__StreamEncoder *encoder,
3602 	unsigned blocksize,
3603 	unsigned subframe_bps,
3604 	const FLAC__Subframe *subframe,
3605 	FLAC__BitWriter *frame
3606 )
3607 {
3608 	switch(subframe->type) {
3609 		case FLAC__SUBFRAME_TYPE_CONSTANT:
3610 			if(!FLAC__subframe_add_constant(&(subframe->data.constant), subframe_bps, subframe->wasted_bits, frame)) {
3611 				encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3612 				return false;
3613 			}
3614 			break;
3615 		case FLAC__SUBFRAME_TYPE_FIXED:
3616 			if(!FLAC__subframe_add_fixed(&(subframe->data.fixed), blocksize - subframe->data.fixed.order, subframe_bps, subframe->wasted_bits, frame)) {
3617 				encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3618 				return false;
3619 			}
3620 			break;
3621 		case FLAC__SUBFRAME_TYPE_LPC:
3622 			if(!FLAC__subframe_add_lpc(&(subframe->data.lpc), blocksize - subframe->data.lpc.order, subframe_bps, subframe->wasted_bits, frame)) {
3623 				encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3624 				return false;
3625 			}
3626 			break;
3627 		case FLAC__SUBFRAME_TYPE_VERBATIM:
3628 			if(!FLAC__subframe_add_verbatim(&(subframe->data.verbatim), blocksize, subframe_bps, subframe->wasted_bits, frame)) {
3629 				encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3630 				return false;
3631 			}
3632 			break;
3633 		default:
3634 			FLAC__ASSERT(0);
3635 	}
3636 
3637 	return true;
3638 }
3639 
3640 #define SPOTCHECK_ESTIMATE 0
3641 #if SPOTCHECK_ESTIMATE
spotcheck_subframe_estimate_(FLAC__StreamEncoder * encoder,unsigned blocksize,unsigned subframe_bps,const FLAC__Subframe * subframe,unsigned estimate)3642 static void spotcheck_subframe_estimate_(
3643 	FLAC__StreamEncoder *encoder,
3644 	unsigned blocksize,
3645 	unsigned subframe_bps,
3646 	const FLAC__Subframe *subframe,
3647 	unsigned estimate
3648 )
3649 {
3650 	FLAC__bool ret;
3651 	FLAC__BitWriter *frame = FLAC__bitwriter_new();
3652 	if(frame == 0) {
3653 		fprintf(stderr, "EST: can't allocate frame\n");
3654 		return;
3655 	}
3656 	if(!FLAC__bitwriter_init(frame)) {
3657 		fprintf(stderr, "EST: can't init frame\n");
3658 		return;
3659 	}
3660 	ret = add_subframe_(encoder, blocksize, subframe_bps, subframe, frame);
3661 	FLAC__ASSERT(ret);
3662 	{
3663 		const unsigned actual = FLAC__bitwriter_get_input_bits_unconsumed(frame);
3664 		if(estimate != actual)
3665 			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);
3666 	}
3667 	FLAC__bitwriter_delete(frame);
3668 }
3669 #endif
3670 
evaluate_constant_subframe_(FLAC__StreamEncoder * encoder,const FLAC__int32 signal,unsigned blocksize,unsigned subframe_bps,FLAC__Subframe * subframe)3671 unsigned evaluate_constant_subframe_(
3672 	FLAC__StreamEncoder *encoder,
3673 	const FLAC__int32 signal,
3674 	unsigned blocksize,
3675 	unsigned subframe_bps,
3676 	FLAC__Subframe *subframe
3677 )
3678 {
3679 	unsigned estimate;
3680 	subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT;
3681 	subframe->data.constant.value = signal;
3682 
3683 	estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + subframe_bps;
3684 
3685 #if SPOTCHECK_ESTIMATE
3686 	spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3687 #else
3688 	(void)encoder, (void)blocksize;
3689 #endif
3690 
3691 	return estimate;
3692 }
3693 
evaluate_fixed_subframe_(FLAC__StreamEncoder * encoder,const FLAC__int32 signal[],FLAC__int32 residual[],FLAC__uint64 abs_residual_partition_sums[],unsigned raw_bits_per_partition[],unsigned blocksize,unsigned subframe_bps,unsigned order,unsigned rice_parameter,unsigned rice_parameter_limit,unsigned min_partition_order,unsigned max_partition_order,FLAC__bool do_escape_coding,unsigned rice_parameter_search_dist,FLAC__Subframe * subframe,FLAC__EntropyCodingMethod_PartitionedRiceContents * partitioned_rice_contents)3694 unsigned evaluate_fixed_subframe_(
3695 	FLAC__StreamEncoder *encoder,
3696 	const FLAC__int32 signal[],
3697 	FLAC__int32 residual[],
3698 	FLAC__uint64 abs_residual_partition_sums[],
3699 	unsigned raw_bits_per_partition[],
3700 	unsigned blocksize,
3701 	unsigned subframe_bps,
3702 	unsigned order,
3703 	unsigned rice_parameter,
3704 	unsigned rice_parameter_limit,
3705 	unsigned min_partition_order,
3706 	unsigned max_partition_order,
3707 	FLAC__bool do_escape_coding,
3708 	unsigned rice_parameter_search_dist,
3709 	FLAC__Subframe *subframe,
3710 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
3711 )
3712 {
3713 	unsigned i, residual_bits, estimate;
3714 	const unsigned residual_samples = blocksize - order;
3715 
3716 	FLAC__fixed_compute_residual(signal+order, residual_samples, order, residual);
3717 
3718 	subframe->type = FLAC__SUBFRAME_TYPE_FIXED;
3719 
3720 	subframe->data.fixed.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
3721 	subframe->data.fixed.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents;
3722 	subframe->data.fixed.residual = residual;
3723 
3724 	residual_bits =
3725 		find_best_partition_order_(
3726 			encoder->private_,
3727 			residual,
3728 			abs_residual_partition_sums,
3729 			raw_bits_per_partition,
3730 			residual_samples,
3731 			order,
3732 			rice_parameter,
3733 			rice_parameter_limit,
3734 			min_partition_order,
3735 			max_partition_order,
3736 			subframe_bps,
3737 			do_escape_coding,
3738 			rice_parameter_search_dist,
3739 			&subframe->data.fixed.entropy_coding_method
3740 		);
3741 
3742 	subframe->data.fixed.order = order;
3743 	for(i = 0; i < order; i++)
3744 		subframe->data.fixed.warmup[i] = signal[i];
3745 
3746 	estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + (order * subframe_bps) + residual_bits;
3747 
3748 #if SPOTCHECK_ESTIMATE
3749 	spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3750 #endif
3751 
3752 	return estimate;
3753 }
3754 
3755 #ifndef FLAC__INTEGER_ONLY_LIBRARY
evaluate_lpc_subframe_(FLAC__StreamEncoder * encoder,const FLAC__int32 signal[],FLAC__int32 residual[],FLAC__uint64 abs_residual_partition_sums[],unsigned raw_bits_per_partition[],const FLAC__real lp_coeff[],unsigned blocksize,unsigned subframe_bps,unsigned order,unsigned qlp_coeff_precision,unsigned rice_parameter,unsigned rice_parameter_limit,unsigned min_partition_order,unsigned max_partition_order,FLAC__bool do_escape_coding,unsigned rice_parameter_search_dist,FLAC__Subframe * subframe,FLAC__EntropyCodingMethod_PartitionedRiceContents * partitioned_rice_contents)3756 unsigned evaluate_lpc_subframe_(
3757 	FLAC__StreamEncoder *encoder,
3758 	const FLAC__int32 signal[],
3759 	FLAC__int32 residual[],
3760 	FLAC__uint64 abs_residual_partition_sums[],
3761 	unsigned raw_bits_per_partition[],
3762 	const FLAC__real lp_coeff[],
3763 	unsigned blocksize,
3764 	unsigned subframe_bps,
3765 	unsigned order,
3766 	unsigned qlp_coeff_precision,
3767 	unsigned rice_parameter,
3768 	unsigned rice_parameter_limit,
3769 	unsigned min_partition_order,
3770 	unsigned max_partition_order,
3771 	FLAC__bool do_escape_coding,
3772 	unsigned rice_parameter_search_dist,
3773 	FLAC__Subframe *subframe,
3774 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
3775 )
3776 {
3777 	FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; /* WATCHOUT: the size is important; some x86 intrinsic routines need more than lpc order elements */
3778 	unsigned i, residual_bits, estimate;
3779 	int quantization, ret;
3780 	const unsigned residual_samples = blocksize - order;
3781 
3782 	/* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps streams */
3783 	if(subframe_bps <= 16) {
3784 		FLAC__ASSERT(order > 0);
3785 		FLAC__ASSERT(order <= FLAC__MAX_LPC_ORDER);
3786 		qlp_coeff_precision = flac_min(qlp_coeff_precision, 32 - subframe_bps - FLAC__bitmath_ilog2(order));
3787 	}
3788 
3789 	ret = FLAC__lpc_quantize_coefficients(lp_coeff, order, qlp_coeff_precision, qlp_coeff, &quantization);
3790 	if(ret != 0)
3791 		return 0; /* this is a hack to indicate to the caller that we can't do lp at this order on this subframe */
3792 
3793 	if(subframe_bps + qlp_coeff_precision + FLAC__bitmath_ilog2(order) <= 32)
3794 		if(subframe_bps <= 16 && qlp_coeff_precision <= 16)
3795 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3796 		else
3797 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3798 	else
3799 		encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3800 
3801 	subframe->type = FLAC__SUBFRAME_TYPE_LPC;
3802 
3803 	subframe->data.lpc.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
3804 	subframe->data.lpc.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents;
3805 	subframe->data.lpc.residual = residual;
3806 
3807 	residual_bits =
3808 		find_best_partition_order_(
3809 			encoder->private_,
3810 			residual,
3811 			abs_residual_partition_sums,
3812 			raw_bits_per_partition,
3813 			residual_samples,
3814 			order,
3815 			rice_parameter,
3816 			rice_parameter_limit,
3817 			min_partition_order,
3818 			max_partition_order,
3819 			subframe_bps,
3820 			do_escape_coding,
3821 			rice_parameter_search_dist,
3822 			&subframe->data.lpc.entropy_coding_method
3823 		);
3824 
3825 	subframe->data.lpc.order = order;
3826 	subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision;
3827 	subframe->data.lpc.quantization_level = quantization;
3828 	memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(FLAC__int32)*FLAC__MAX_LPC_ORDER);
3829 	for(i = 0; i < order; i++)
3830 		subframe->data.lpc.warmup[i] = signal[i];
3831 
3832 	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)) + residual_bits;
3833 
3834 #if SPOTCHECK_ESTIMATE
3835 	spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3836 #endif
3837 
3838 	return estimate;
3839 }
3840 #endif
3841 
evaluate_verbatim_subframe_(FLAC__StreamEncoder * encoder,const FLAC__int32 signal[],unsigned blocksize,unsigned subframe_bps,FLAC__Subframe * subframe)3842 unsigned evaluate_verbatim_subframe_(
3843 	FLAC__StreamEncoder *encoder,
3844 	const FLAC__int32 signal[],
3845 	unsigned blocksize,
3846 	unsigned subframe_bps,
3847 	FLAC__Subframe *subframe
3848 )
3849 {
3850 	unsigned estimate;
3851 
3852 	subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM;
3853 
3854 	subframe->data.verbatim.data = signal;
3855 
3856 	estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + (blocksize * subframe_bps);
3857 
3858 #if SPOTCHECK_ESTIMATE
3859 	spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3860 #else
3861 	(void)encoder;
3862 #endif
3863 
3864 	return estimate;
3865 }
3866 
find_best_partition_order_(FLAC__StreamEncoderPrivate * private_,const FLAC__int32 residual[],FLAC__uint64 abs_residual_partition_sums[],unsigned raw_bits_per_partition[],unsigned residual_samples,unsigned predictor_order,unsigned rice_parameter,unsigned rice_parameter_limit,unsigned min_partition_order,unsigned max_partition_order,unsigned bps,FLAC__bool do_escape_coding,unsigned rice_parameter_search_dist,FLAC__EntropyCodingMethod * best_ecm)3867 unsigned find_best_partition_order_(
3868 	FLAC__StreamEncoderPrivate *private_,
3869 	const FLAC__int32 residual[],
3870 	FLAC__uint64 abs_residual_partition_sums[],
3871 	unsigned raw_bits_per_partition[],
3872 	unsigned residual_samples,
3873 	unsigned predictor_order,
3874 	unsigned rice_parameter,
3875 	unsigned rice_parameter_limit,
3876 	unsigned min_partition_order,
3877 	unsigned max_partition_order,
3878 	unsigned bps,
3879 	FLAC__bool do_escape_coding,
3880 	unsigned rice_parameter_search_dist,
3881 	FLAC__EntropyCodingMethod *best_ecm
3882 )
3883 {
3884 	unsigned residual_bits, best_residual_bits = 0;
3885 	unsigned best_parameters_index = 0;
3886 	unsigned best_partition_order = 0;
3887 	const unsigned blocksize = residual_samples + predictor_order;
3888 
3889 	max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(max_partition_order, blocksize, predictor_order);
3890 	min_partition_order = flac_min(min_partition_order, max_partition_order);
3891 
3892 	private_->local_precompute_partition_info_sums(residual, abs_residual_partition_sums, residual_samples, predictor_order, min_partition_order, max_partition_order, bps);
3893 
3894 	if(do_escape_coding)
3895 		precompute_partition_info_escapes_(residual, raw_bits_per_partition, residual_samples, predictor_order, min_partition_order, max_partition_order);
3896 
3897 	{
3898 		int partition_order;
3899 		unsigned sum;
3900 
3901 		for(partition_order = (int)max_partition_order, sum = 0; partition_order >= (int)min_partition_order; partition_order--) {
3902 			if(!
3903 				set_partitioned_rice_(
3904 #ifdef EXACT_RICE_BITS_CALCULATION
3905 					residual,
3906 #endif
3907 					abs_residual_partition_sums+sum,
3908 					raw_bits_per_partition+sum,
3909 					residual_samples,
3910 					predictor_order,
3911 					rice_parameter,
3912 					rice_parameter_limit,
3913 					rice_parameter_search_dist,
3914 					(unsigned)partition_order,
3915 					do_escape_coding,
3916 					&private_->partitioned_rice_contents_extra[!best_parameters_index],
3917 					&residual_bits
3918 				)
3919 			)
3920 			{
3921 				FLAC__ASSERT(best_residual_bits != 0);
3922 				break;
3923 			}
3924 			sum += 1u << partition_order;
3925 			if(best_residual_bits == 0 || residual_bits < best_residual_bits) {
3926 				best_residual_bits = residual_bits;
3927 				best_parameters_index = !best_parameters_index;
3928 				best_partition_order = partition_order;
3929 			}
3930 		}
3931 	}
3932 
3933 	best_ecm->data.partitioned_rice.order = best_partition_order;
3934 
3935 	{
3936 		/*
3937 		 * We are allowed to de-const the pointer based on our special
3938 		 * knowledge; it is const to the outside world.
3939 		 */
3940 		FLAC__EntropyCodingMethod_PartitionedRiceContents* prc = (FLAC__EntropyCodingMethod_PartitionedRiceContents*)best_ecm->data.partitioned_rice.contents;
3941 		unsigned partition;
3942 
3943 		/* save best parameters and raw_bits */
3944 		FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(prc, flac_max(6u, best_partition_order));
3945 		memcpy(prc->parameters, private_->partitioned_rice_contents_extra[best_parameters_index].parameters, sizeof(unsigned)*(1<<(best_partition_order)));
3946 		if(do_escape_coding)
3947 			memcpy(prc->raw_bits, private_->partitioned_rice_contents_extra[best_parameters_index].raw_bits, sizeof(unsigned)*(1<<(best_partition_order)));
3948 		/*
3949 		 * Now need to check if the type should be changed to
3950 		 * FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 based on the
3951 		 * size of the rice parameters.
3952 		 */
3953 		for(partition = 0; partition < (1u<<best_partition_order); partition++) {
3954 			if(prc->parameters[partition] >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
3955 				best_ecm->type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2;
3956 				break;
3957 			}
3958 		}
3959 	}
3960 
3961 	return best_residual_bits;
3962 }
3963 
precompute_partition_info_sums_(const FLAC__int32 residual[],FLAC__uint64 abs_residual_partition_sums[],unsigned residual_samples,unsigned predictor_order,unsigned min_partition_order,unsigned max_partition_order,unsigned bps)3964 void precompute_partition_info_sums_(
3965 	const FLAC__int32 residual[],
3966 	FLAC__uint64 abs_residual_partition_sums[],
3967 	unsigned residual_samples,
3968 	unsigned predictor_order,
3969 	unsigned min_partition_order,
3970 	unsigned max_partition_order,
3971 	unsigned bps
3972 )
3973 {
3974 	const unsigned default_partition_samples = (residual_samples + predictor_order) >> max_partition_order;
3975 	unsigned partitions = 1u << max_partition_order;
3976 
3977 	FLAC__ASSERT(default_partition_samples > predictor_order);
3978 
3979 	/* first do max_partition_order */
3980 	{
3981 		unsigned partition, residual_sample, end = (unsigned)(-(int)predictor_order);
3982 		/* WATCHOUT: "+ bps + FLAC__MAX_EXTRA_RESIDUAL_BPS" is the maximum
3983 		 * assumed size of the average residual magnitude */
3984 		if(FLAC__bitmath_ilog2(default_partition_samples) + bps + FLAC__MAX_EXTRA_RESIDUAL_BPS < 32) {
3985 			FLAC__uint32 abs_residual_partition_sum;
3986 
3987 			for(partition = residual_sample = 0; partition < partitions; partition++) {
3988 				end += default_partition_samples;
3989 				abs_residual_partition_sum = 0;
3990 				for( ; residual_sample < end; residual_sample++)
3991 					abs_residual_partition_sum += abs(residual[residual_sample]); /* abs(INT_MIN) is undefined, but if the residual is INT_MIN we have bigger problems */
3992 				abs_residual_partition_sums[partition] = abs_residual_partition_sum;
3993 			}
3994 		}
3995 		else { /* have to pessimistically use 64 bits for accumulator */
3996 			FLAC__uint64 abs_residual_partition_sum;
3997 
3998 			for(partition = residual_sample = 0; partition < partitions; partition++) {
3999 				end += default_partition_samples;
4000 				abs_residual_partition_sum = 0;
4001 				for( ; residual_sample < end; residual_sample++)
4002 					abs_residual_partition_sum += abs(residual[residual_sample]); /* abs(INT_MIN) is undefined, but if the residual is INT_MIN we have bigger problems */
4003 				abs_residual_partition_sums[partition] = abs_residual_partition_sum;
4004 			}
4005 		}
4006 	}
4007 
4008 	/* now merge partitions for lower orders */
4009 	{
4010 		unsigned from_partition = 0, to_partition = partitions;
4011 		int partition_order;
4012 		for(partition_order = (int)max_partition_order - 1; partition_order >= (int)min_partition_order; partition_order--) {
4013 			unsigned i;
4014 			partitions >>= 1;
4015 			for(i = 0; i < partitions; i++) {
4016 				abs_residual_partition_sums[to_partition++] =
4017 					abs_residual_partition_sums[from_partition  ] +
4018 					abs_residual_partition_sums[from_partition+1];
4019 				from_partition += 2;
4020 			}
4021 		}
4022 	}
4023 }
4024 
precompute_partition_info_escapes_(const FLAC__int32 residual[],unsigned raw_bits_per_partition[],unsigned residual_samples,unsigned predictor_order,unsigned min_partition_order,unsigned max_partition_order)4025 void precompute_partition_info_escapes_(
4026 	const FLAC__int32 residual[],
4027 	unsigned raw_bits_per_partition[],
4028 	unsigned residual_samples,
4029 	unsigned predictor_order,
4030 	unsigned min_partition_order,
4031 	unsigned max_partition_order
4032 )
4033 {
4034 	int partition_order;
4035 	unsigned from_partition, to_partition = 0;
4036 	const unsigned blocksize = residual_samples + predictor_order;
4037 
4038 	/* first do max_partition_order */
4039 	for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) {
4040 		FLAC__int32 r;
4041 		FLAC__uint32 rmax;
4042 		unsigned partition, partition_sample, partition_samples, residual_sample;
4043 		const unsigned partitions = 1u << partition_order;
4044 		const unsigned default_partition_samples = blocksize >> partition_order;
4045 
4046 		FLAC__ASSERT(default_partition_samples > predictor_order);
4047 
4048 		for(partition = residual_sample = 0; partition < partitions; partition++) {
4049 			partition_samples = default_partition_samples;
4050 			if(partition == 0)
4051 				partition_samples -= predictor_order;
4052 			rmax = 0;
4053 			for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) {
4054 				r = residual[residual_sample++];
4055 				/* OPT: maybe faster: rmax |= r ^ (r>>31) */
4056 				if(r < 0)
4057 					rmax |= ~r;
4058 				else
4059 					rmax |= r;
4060 			}
4061 			/* now we know all residual values are in the range [-rmax-1,rmax] */
4062 			raw_bits_per_partition[partition] = rmax? FLAC__bitmath_ilog2(rmax) + 2 : 1;
4063 		}
4064 		to_partition = partitions;
4065 		break; /*@@@ yuck, should remove the 'for' loop instead */
4066 	}
4067 
4068 	/* now merge partitions for lower orders */
4069 	for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) {
4070 		unsigned m;
4071 		unsigned i;
4072 		const unsigned partitions = 1u << partition_order;
4073 		for(i = 0; i < partitions; i++) {
4074 			m = raw_bits_per_partition[from_partition];
4075 			from_partition++;
4076 			raw_bits_per_partition[to_partition] = flac_max(m, raw_bits_per_partition[from_partition]);
4077 			from_partition++;
4078 			to_partition++;
4079 		}
4080 	}
4081 }
4082 
4083 #ifdef EXACT_RICE_BITS_CALCULATION
count_rice_bits_in_partition_(const unsigned rice_parameter,const unsigned partition_samples,const FLAC__int32 * residual)4084 static inline unsigned count_rice_bits_in_partition_(
4085 	const unsigned rice_parameter,
4086 	const unsigned partition_samples,
4087 	const FLAC__int32 *residual
4088 )
4089 {
4090 	unsigned i, partition_bits =
4091 		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 */
4092 		(1+rice_parameter) * partition_samples /* 1 for unary stop bit + rice_parameter for the binary portion */
4093 	;
4094 	for(i = 0; i < partition_samples; i++)
4095 		partition_bits += ( (FLAC__uint32)((residual[i]<<1)^(residual[i]>>31)) >> rice_parameter );
4096 	return partition_bits;
4097 }
4098 #else
count_rice_bits_in_partition_(const unsigned rice_parameter,const unsigned partition_samples,const FLAC__uint64 abs_residual_partition_sum)4099 static inline unsigned count_rice_bits_in_partition_(
4100 	const unsigned rice_parameter,
4101 	const unsigned partition_samples,
4102 	const FLAC__uint64 abs_residual_partition_sum
4103 )
4104 {
4105 	return
4106 		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 */
4107 		(1+rice_parameter) * partition_samples + /* 1 for unary stop bit + rice_parameter for the binary portion */
4108 		(
4109 			rice_parameter?
4110 				(unsigned)(abs_residual_partition_sum >> (rice_parameter-1)) /* rice_parameter-1 because the real coder sign-folds instead of using a sign bit */
4111 				: (unsigned)(abs_residual_partition_sum << 1) /* can't shift by negative number, so reverse */
4112 		)
4113 		- (partition_samples >> 1)
4114 		/* -(partition_samples>>1) to subtract out extra contributions to the abs_residual_partition_sum.
4115 		 * The actual number of bits used is closer to the sum(for all i in the partition) of  abs(residual[i])>>(rice_parameter-1)
4116 		 * By using the abs_residual_partition sum, we also add in bits in the LSBs that would normally be shifted out.
4117 		 * So the subtraction term tries to guess how many extra bits were contributed.
4118 		 * If the LSBs are randomly distributed, this should average to 0.5 extra bits per sample.
4119 		 */
4120 	;
4121 }
4122 #endif
4123 
set_partitioned_rice_(const FLAC__int32 residual[],const FLAC__uint64 abs_residual_partition_sums[],const unsigned raw_bits_per_partition[],const unsigned residual_samples,const unsigned predictor_order,const unsigned suggested_rice_parameter,const unsigned rice_parameter_limit,const unsigned rice_parameter_search_dist,const unsigned partition_order,const FLAC__bool search_for_escapes,FLAC__EntropyCodingMethod_PartitionedRiceContents * partitioned_rice_contents,unsigned * bits)4124 FLAC__bool set_partitioned_rice_(
4125 #ifdef EXACT_RICE_BITS_CALCULATION
4126 	const FLAC__int32 residual[],
4127 #endif
4128 	const FLAC__uint64 abs_residual_partition_sums[],
4129 	const unsigned raw_bits_per_partition[],
4130 	const unsigned residual_samples,
4131 	const unsigned predictor_order,
4132 	const unsigned suggested_rice_parameter,
4133 	const unsigned rice_parameter_limit,
4134 	const unsigned rice_parameter_search_dist,
4135 	const unsigned partition_order,
4136 	const FLAC__bool search_for_escapes,
4137 	FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents,
4138 	unsigned *bits
4139 )
4140 {
4141 	unsigned rice_parameter, partition_bits;
4142 	unsigned best_partition_bits, best_rice_parameter = 0;
4143 	unsigned bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN;
4144 	unsigned *parameters, *raw_bits;
4145 #ifdef ENABLE_RICE_PARAMETER_SEARCH
4146 	unsigned min_rice_parameter, max_rice_parameter;
4147 #else
4148 	(void)rice_parameter_search_dist;
4149 #endif
4150 
4151 	FLAC__ASSERT(suggested_rice_parameter < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER);
4152 	FLAC__ASSERT(rice_parameter_limit <= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER);
4153 
4154 	FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(partitioned_rice_contents, flac_max(6u, partition_order));
4155 	parameters = partitioned_rice_contents->parameters;
4156 	raw_bits = partitioned_rice_contents->raw_bits;
4157 
4158 	if(partition_order == 0) {
4159 		best_partition_bits = (unsigned)(-1);
4160 #ifdef ENABLE_RICE_PARAMETER_SEARCH
4161 		if(rice_parameter_search_dist) {
4162 			if(suggested_rice_parameter < rice_parameter_search_dist)
4163 				min_rice_parameter = 0;
4164 			else
4165 				min_rice_parameter = suggested_rice_parameter - rice_parameter_search_dist;
4166 			max_rice_parameter = suggested_rice_parameter + rice_parameter_search_dist;
4167 			if(max_rice_parameter >= rice_parameter_limit) {
4168 #ifdef DEBUG_VERBOSE
4169 				fprintf(stderr, "clipping rice_parameter (%u -> %u) @5\n", max_rice_parameter, rice_parameter_limit - 1);
4170 #endif
4171 				max_rice_parameter = rice_parameter_limit - 1;
4172 			}
4173 		}
4174 		else
4175 			min_rice_parameter = max_rice_parameter = suggested_rice_parameter;
4176 
4177 		for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) {
4178 #else
4179 			rice_parameter = suggested_rice_parameter;
4180 #endif
4181 #ifdef EXACT_RICE_BITS_CALCULATION
4182 			partition_bits = count_rice_bits_in_partition_(rice_parameter, residual_samples, residual);
4183 #else
4184 			partition_bits = count_rice_bits_in_partition_(rice_parameter, residual_samples, abs_residual_partition_sums[0]);
4185 #endif
4186 			if(partition_bits < best_partition_bits) {
4187 				best_rice_parameter = rice_parameter;
4188 				best_partition_bits = partition_bits;
4189 			}
4190 #ifdef ENABLE_RICE_PARAMETER_SEARCH
4191 		}
4192 #endif
4193 		if(search_for_escapes) {
4194 			partition_bits = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN + raw_bits_per_partition[0] * residual_samples;
4195 			if(partition_bits <= best_partition_bits) {
4196 				raw_bits[0] = raw_bits_per_partition[0];
4197 				best_rice_parameter = 0; /* will be converted to appropriate escape parameter later */
4198 				best_partition_bits = partition_bits;
4199 			}
4200 			else
4201 				raw_bits[0] = 0;
4202 		}
4203 		parameters[0] = best_rice_parameter;
4204 		bits_ += best_partition_bits;
4205 	}
4206 	else {
4207 		unsigned partition, residual_sample;
4208 		unsigned partition_samples;
4209 		FLAC__uint64 mean, k;
4210 		const unsigned partitions = 1u << partition_order;
4211 		for(partition = residual_sample = 0; partition < partitions; partition++) {
4212 			partition_samples = (residual_samples+predictor_order) >> partition_order;
4213 			if(partition == 0) {
4214 				if(partition_samples <= predictor_order)
4215 					return false;
4216 				else
4217 					partition_samples -= predictor_order;
4218 			}
4219 			mean = abs_residual_partition_sums[partition];
4220 			/* we are basically calculating the size in bits of the
4221 			 * average residual magnitude in the partition:
4222 			 *   rice_parameter = floor(log2(mean/partition_samples))
4223 			 * 'mean' is not a good name for the variable, it is
4224 			 * actually the sum of magnitudes of all residual values
4225 			 * in the partition, so the actual mean is
4226 			 * mean/partition_samples
4227 			 */
4228 #if 0 /* old simple code */
4229 			for(rice_parameter = 0, k = partition_samples; k < mean; rice_parameter++, k <<= 1)
4230 				;
4231 #else
4232 #if defined FLAC__CPU_X86_64 /* and other 64-bit arch, too */
4233 			if(mean <= 0x80000000/512) { /* 512: more or less optimal for both 16- and 24-bit input */
4234 #else
4235 			if(mean <= 0x80000000/8) { /* 32-bit arch: use 32-bit math if possible */
4236 #endif
4237 				FLAC__uint32 k2, mean2 = (FLAC__uint32) mean;
4238 				rice_parameter = 0; k2 = partition_samples;
4239 				while(k2*8 < mean2) { /* requires: mean <= (2^31)/8 */
4240 					rice_parameter += 4; k2 <<= 4; /* tuned for 16-bit input */
4241 				}
4242 				while(k2 < mean2) { /* requires: mean <= 2^31 */
4243 					rice_parameter++; k2 <<= 1;
4244 				}
4245 			}
4246 			else {
4247 				rice_parameter = 0; k = partition_samples;
4248 				if(mean <= FLAC__U64L(0x8000000000000000)/128) /* usually mean is _much_ smaller than this value */
4249 					while(k*128 < mean) { /* requires: mean <= (2^63)/128 */
4250 						rice_parameter += 8; k <<= 8; /* tuned for 24-bit input */
4251 					}
4252 				while(k < mean) { /* requires: mean <= 2^63 */
4253 					rice_parameter++; k <<= 1;
4254 				}
4255 			}
4256 #endif
4257 			if(rice_parameter >= rice_parameter_limit) {
4258 #ifdef DEBUG_VERBOSE
4259 				fprintf(stderr, "clipping rice_parameter (%u -> %u) @6\n", rice_parameter, rice_parameter_limit - 1);
4260 #endif
4261 				rice_parameter = rice_parameter_limit - 1;
4262 			}
4263 
4264 			best_partition_bits = (unsigned)(-1);
4265 #ifdef ENABLE_RICE_PARAMETER_SEARCH
4266 			if(rice_parameter_search_dist) {
4267 				if(rice_parameter < rice_parameter_search_dist)
4268 					min_rice_parameter = 0;
4269 				else
4270 					min_rice_parameter = rice_parameter - rice_parameter_search_dist;
4271 				max_rice_parameter = rice_parameter + rice_parameter_search_dist;
4272 				if(max_rice_parameter >= rice_parameter_limit) {
4273 #ifdef DEBUG_VERBOSE
4274 					fprintf(stderr, "clipping rice_parameter (%u -> %u) @7\n", max_rice_parameter, rice_parameter_limit - 1);
4275 #endif
4276 					max_rice_parameter = rice_parameter_limit - 1;
4277 				}
4278 			}
4279 			else
4280 				min_rice_parameter = max_rice_parameter = rice_parameter;
4281 
4282 			for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) {
4283 #endif
4284 #ifdef EXACT_RICE_BITS_CALCULATION
4285 				partition_bits = count_rice_bits_in_partition_(rice_parameter, partition_samples, residual+residual_sample);
4286 #else
4287 				partition_bits = count_rice_bits_in_partition_(rice_parameter, partition_samples, abs_residual_partition_sums[partition]);
4288 #endif
4289 				if(partition_bits < best_partition_bits) {
4290 					best_rice_parameter = rice_parameter;
4291 					best_partition_bits = partition_bits;
4292 				}
4293 #ifdef ENABLE_RICE_PARAMETER_SEARCH
4294 			}
4295 #endif
4296 			if(search_for_escapes) {
4297 				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;
4298 				if(partition_bits <= best_partition_bits) {
4299 					raw_bits[partition] = raw_bits_per_partition[partition];
4300 					best_rice_parameter = 0; /* will be converted to appropriate escape parameter later */
4301 					best_partition_bits = partition_bits;
4302 				}
4303 				else
4304 					raw_bits[partition] = 0;
4305 			}
4306 			parameters[partition] = best_rice_parameter;
4307 			bits_ += best_partition_bits;
4308 			residual_sample += partition_samples;
4309 		}
4310 	}
4311 
4312 	*bits = bits_;
4313 	return true;
4314 }
4315 
4316 unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples)
4317 {
4318 	unsigned i, shift;
4319 	FLAC__int32 x = 0;
4320 
4321 	for(i = 0; i < samples && !(x&1); i++)
4322 		x |= signal[i];
4323 
4324 	if(x == 0) {
4325 		shift = 0;
4326 	}
4327 	else {
4328 		for(shift = 0; !(x&1); shift++)
4329 			x >>= 1;
4330 	}
4331 
4332 	if(shift > 0) {
4333 		for(i = 0; i < samples; i++)
4334 			 signal[i] >>= shift;
4335 	}
4336 
4337 	return shift;
4338 }
4339 
4340 void append_to_verify_fifo_(verify_input_fifo *fifo, const FLAC__int32 * const input[], unsigned input_offset, unsigned channels, unsigned wide_samples)
4341 {
4342 	unsigned channel;
4343 
4344 	for(channel = 0; channel < channels; channel++)
4345 		memcpy(&fifo->data[channel][fifo->tail], &input[channel][input_offset], sizeof(FLAC__int32) * wide_samples);
4346 
4347 	fifo->tail += wide_samples;
4348 
4349 	FLAC__ASSERT(fifo->tail <= fifo->size);
4350 }
4351 
4352 void append_to_verify_fifo_interleaved_(verify_input_fifo *fifo, const FLAC__int32 input[], unsigned input_offset, unsigned channels, unsigned wide_samples)
4353 {
4354 	unsigned channel;
4355 	unsigned sample, wide_sample;
4356 	unsigned tail = fifo->tail;
4357 
4358 	sample = input_offset * channels;
4359 	for(wide_sample = 0; wide_sample < wide_samples; wide_sample++) {
4360 		for(channel = 0; channel < channels; channel++)
4361 			fifo->data[channel][tail] = input[sample++];
4362 		tail++;
4363 	}
4364 	fifo->tail = tail;
4365 
4366 	FLAC__ASSERT(fifo->tail <= fifo->size);
4367 }
4368 
4369 FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
4370 {
4371 	FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
4372 	const size_t encoded_bytes = encoder->private_->verify.output.bytes;
4373 	(void)decoder;
4374 
4375 	if(encoder->private_->verify.needs_magic_hack) {
4376 		FLAC__ASSERT(*bytes >= FLAC__STREAM_SYNC_LENGTH);
4377 		*bytes = FLAC__STREAM_SYNC_LENGTH;
4378 		memcpy(buffer, FLAC__STREAM_SYNC_STRING, *bytes);
4379 		encoder->private_->verify.needs_magic_hack = false;
4380 	}
4381 	else {
4382 		if(encoded_bytes == 0) {
4383 			/*
4384 			 * If we get here, a FIFO underflow has occurred,
4385 			 * which means there is a bug somewhere.
4386 			 */
4387 			FLAC__ASSERT(0);
4388 			return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
4389 		}
4390 		else if(encoded_bytes < *bytes)
4391 			*bytes = encoded_bytes;
4392 		memcpy(buffer, encoder->private_->verify.output.data, *bytes);
4393 		encoder->private_->verify.output.data += *bytes;
4394 		encoder->private_->verify.output.bytes -= *bytes;
4395 	}
4396 
4397 	return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
4398 }
4399 
4400 FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
4401 {
4402 	FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder *)client_data;
4403 	unsigned channel;
4404 	const unsigned channels = frame->header.channels;
4405 	const unsigned blocksize = frame->header.blocksize;
4406 	const unsigned bytes_per_block = sizeof(FLAC__int32) * blocksize;
4407 
4408 	(void)decoder;
4409 
4410 	for(channel = 0; channel < channels; channel++) {
4411 		if(0 != memcmp(buffer[channel], encoder->private_->verify.input_fifo.data[channel], bytes_per_block)) {
4412 			unsigned i, sample = 0;
4413 			FLAC__int32 expect = 0, got = 0;
4414 
4415 			for(i = 0; i < blocksize; i++) {
4416 				if(buffer[channel][i] != encoder->private_->verify.input_fifo.data[channel][i]) {
4417 					sample = i;
4418 					expect = (FLAC__int32)encoder->private_->verify.input_fifo.data[channel][i];
4419 					got = (FLAC__int32)buffer[channel][i];
4420 					break;
4421 				}
4422 			}
4423 			FLAC__ASSERT(i < blocksize);
4424 			FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
4425 			encoder->private_->verify.error_stats.absolute_sample = frame->header.number.sample_number + sample;
4426 			encoder->private_->verify.error_stats.frame_number = (unsigned)(frame->header.number.sample_number / blocksize);
4427 			encoder->private_->verify.error_stats.channel = channel;
4428 			encoder->private_->verify.error_stats.sample = sample;
4429 			encoder->private_->verify.error_stats.expected = expect;
4430 			encoder->private_->verify.error_stats.got = got;
4431 			encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA;
4432 			return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
4433 		}
4434 	}
4435 	/* dequeue the frame from the fifo */
4436 	encoder->private_->verify.input_fifo.tail -= blocksize;
4437 	FLAC__ASSERT(encoder->private_->verify.input_fifo.tail <= OVERREAD_);
4438 	for(channel = 0; channel < channels; channel++)
4439 		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]));
4440 	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
4441 }
4442 
4443 void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
4444 {
4445 	(void)decoder, (void)metadata, (void)client_data;
4446 }
4447 
4448 void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
4449 {
4450 	FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
4451 	(void)decoder, (void)status;
4452 	encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
4453 }
4454 
4455 FLAC__StreamEncoderReadStatus file_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
4456 {
4457 	(void)client_data;
4458 
4459 	*bytes = fread(buffer, 1, *bytes, encoder->private_->file);
4460 	if (*bytes == 0) {
4461 		if (feof(encoder->private_->file))
4462 			return FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM;
4463 		else if (ferror(encoder->private_->file))
4464 			return FLAC__STREAM_ENCODER_READ_STATUS_ABORT;
4465 	}
4466 	return FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE;
4467 }
4468 
4469 FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
4470 {
4471 	(void)client_data;
4472 
4473 	if(fseeko(encoder->private_->file, (FLAC__off_t)absolute_byte_offset, SEEK_SET) < 0)
4474 		return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR;
4475 	else
4476 		return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
4477 }
4478 
4479 FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
4480 {
4481 	FLAC__off_t offset;
4482 
4483 	(void)client_data;
4484 
4485 	offset = ftello(encoder->private_->file);
4486 
4487 	if(offset < 0) {
4488 		return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR;
4489 	}
4490 	else {
4491 		*absolute_byte_offset = (FLAC__uint64)offset;
4492 		return FLAC__STREAM_ENCODER_TELL_STATUS_OK;
4493 	}
4494 }
4495 
4496 #ifdef FLAC__VALGRIND_TESTING
4497 static size_t local__fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
4498 {
4499 	size_t ret = fwrite(ptr, size, nmemb, stream);
4500 	if(!ferror(stream))
4501 		fflush(stream);
4502 	return ret;
4503 }
4504 #else
4505 #define local__fwrite fwrite
4506 #endif
4507 
4508 FLAC__StreamEncoderWriteStatus file_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data)
4509 {
4510 	(void)client_data, (void)current_frame;
4511 
4512 	if(local__fwrite(buffer, sizeof(FLAC__byte), bytes, encoder->private_->file) == bytes) {
4513 		FLAC__bool call_it = 0 != encoder->private_->progress_callback && (
4514 #if FLAC__HAS_OGG
4515 			/* We would like to be able to use 'samples > 0' in the
4516 			 * clause here but currently because of the nature of our
4517 			 * Ogg writing implementation, 'samples' is always 0 (see
4518 			 * ogg_encoder_aspect.c).  The downside is extra progress
4519 			 * callbacks.
4520 			 */
4521 			encoder->private_->is_ogg? true :
4522 #endif
4523 			samples > 0
4524 		);
4525 		if(call_it) {
4526 			/* NOTE: We have to add +bytes, +samples, and +1 to the stats
4527 			 * because at this point in the callback chain, the stats
4528 			 * have not been updated.  Only after we return and control
4529 			 * gets back to write_frame_() are the stats updated
4530 			 */
4531 			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);
4532 		}
4533 		return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
4534 	}
4535 	else
4536 		return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
4537 }
4538 
4539 /*
4540  * This will forcibly set stdout to binary mode (for OSes that require it)
4541  */
4542 FILE *get_binary_stdout_(void)
4543 {
4544 	/* if something breaks here it is probably due to the presence or
4545 	 * absence of an underscore before the identifiers 'setmode',
4546 	 * 'fileno', and/or 'O_BINARY'; check your system header files.
4547 	 */
4548 #if defined _MSC_VER || defined __MINGW32__
4549 	_setmode(_fileno(stdout), _O_BINARY);
4550 #elif defined __CYGWIN__
4551 	/* almost certainly not needed for any modern Cygwin, but let's be safe... */
4552 	setmode(_fileno(stdout), _O_BINARY);
4553 #elif defined __EMX__
4554 	setmode(fileno(stdout), O_BINARY);
4555 #endif
4556 
4557 	return stdout;
4558 }
4559