rework so that rice parameters and raw_bits from the entropy coding method struct...
[flac.git] / src / libFLAC / stream_encoder.c
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2000,2001,2002  Josh Coalson
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA  02111-1307, USA.
18  */
19
20 #include <stdio.h>
21 #include <stdlib.h> /* for malloc() */
22 #include <string.h> /* for memcpy() */
23 #include "FLAC/assert.h"
24 #include "FLAC/stream_decoder.h"
25 #include "protected/stream_encoder.h"
26 #include "private/bitbuffer.h"
27 #include "private/bitmath.h"
28 #include "private/crc.h"
29 #include "private/cpu.h"
30 #include "private/fixed.h"
31 #include "private/format.h"
32 #include "private/lpc.h"
33 #include "private/md5.h"
34 #include "private/memory.h"
35 #include "private/stream_encoder_framing.h"
36
37 #ifdef min
38 #undef min
39 #endif
40 #define min(x,y) ((x)<(y)?(x):(y))
41
42 #ifdef max
43 #undef max
44 #endif
45 #define max(x,y) ((x)>(y)?(x):(y))
46
47 typedef struct {
48         FLAC__int32 *data[FLAC__MAX_CHANNELS];
49         unsigned size; /* of each data[] in samples */
50         unsigned tail;
51 } verify_input_fifo;
52
53 typedef struct {
54         const FLAC__byte *data;
55         unsigned capacity;
56         unsigned bytes;
57 } verify_output;
58
59 typedef enum {
60         ENCODER_IN_MAGIC = 0,
61         ENCODER_IN_METADATA = 1,
62         ENCODER_IN_AUDIO = 2
63 } EncoderStateHint;
64
65 /***********************************************************************
66  *
67  * Private class method prototypes
68  *
69  ***********************************************************************/
70
71 static void set_defaults_(FLAC__StreamEncoder *encoder);
72 static void free_(FLAC__StreamEncoder *encoder);
73 static FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size);
74 static FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples);
75 static FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame);
76 static FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame);
77 static FLAC__bool process_subframe_(FLAC__StreamEncoder *encoder, unsigned min_partition_order, unsigned max_partition_order, FLAC__bool precompute_partition_sums, FLAC__bool verbatim_only, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__int32 integer_signal[], const FLAC__real real_signal[], FLAC__Subframe *subframe[2], FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice[2], FLAC__int32 *residual[2], unsigned *best_subframe, unsigned *best_bits);
78 static FLAC__bool add_subframe_(FLAC__StreamEncoder *encoder, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__Subframe *subframe, FLAC__BitBuffer *frame);
79 static unsigned evaluate_constant_subframe_(const FLAC__int32 signal, unsigned subframe_bps, FLAC__Subframe *subframe);
80 static unsigned evaluate_fixed_subframe_(FLAC__StreamEncoder *encoder, const FLAC__int32 signal[], FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint64 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, FLAC__bool precompute_partition_sums, FLAC__bool do_escape_coding, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice);
81 static unsigned evaluate_lpc_subframe_(FLAC__StreamEncoder *encoder, const FLAC__int32 signal[], FLAC__int32 residual[], FLAC__uint32 abs_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 min_partition_order, unsigned max_partition_order, FLAC__bool precompute_partition_sums, FLAC__bool do_escape_coding, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice);
82 static unsigned evaluate_verbatim_subframe_(const FLAC__int32 signal[], unsigned blocksize, unsigned subframe_bps, FLAC__Subframe *subframe);
83 static unsigned find_best_partition_order_(struct FLAC__StreamEncoderPrivate *private_, const FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint64 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, FLAC__bool precompute_partition_sums, FLAC__bool do_escape_coding, unsigned rice_parameter_search_dist, FLAC__EntropyCodingMethod_PartitionedRice *best_partitioned_rice);
84 static void precompute_partition_info_sums_(const FLAC__uint32 abs_residual[], FLAC__uint64 abs_residual_partition_sums[], unsigned residual_samples, unsigned predictor_order, unsigned min_partition_order, unsigned max_partition_order);
85 static void 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);
86 #ifdef DONT_ESTIMATE_RICE_BITS
87 static FLAC__bool set_partitioned_rice_(const FLAC__uint32 abs_residual[], const FLAC__int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned suggested_rice_parameter, const unsigned rice_parameter_search_dist, const unsigned partition_order, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice, unsigned *bits);
88 static FLAC__bool set_partitioned_rice_with_precompute_(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_search_dist, const unsigned partition_order, const FLAC__bool search_for_escapes, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice, unsigned *bits);
89 #else
90 static FLAC__bool set_partitioned_rice_(const FLAC__uint32 abs_residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned suggested_rice_parameter, const unsigned rice_parameter_search_dist, const unsigned partition_order, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice, unsigned *bits);
91 static FLAC__bool set_partitioned_rice_with_precompute_(const FLAC__uint32 abs_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_search_dist, const unsigned partition_order, const FLAC__bool search_for_escapes, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice, unsigned *bits);
92 #endif
93 static unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples);
94 /* verify-related routines: */
95 static void append_to_verify_fifo_(verify_input_fifo *fifo, const FLAC__int32 * const input[], unsigned input_offset, unsigned channels, unsigned wide_samples);
96 static void append_to_verify_fifo_interleaved_(verify_input_fifo *fifo, const FLAC__int32 input[], unsigned input_offset, unsigned channels, unsigned wide_samples);
97 static FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
98 static FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
99 static void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
100 static void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
101
102 /***********************************************************************
103  *
104  * Private class data
105  *
106  ***********************************************************************/
107
108 typedef struct FLAC__StreamEncoderPrivate {
109         unsigned input_capacity;                          /* current size (in samples) of the signal and residual buffers */
110         FLAC__int32 *integer_signal[FLAC__MAX_CHANNELS];  /* the integer version of the input signal */
111         FLAC__int32 *integer_signal_mid_side[2];          /* the integer version of the mid-side input signal (stereo only) */
112         FLAC__real *real_signal[FLAC__MAX_CHANNELS];      /* the floating-point version of the input signal */
113         FLAC__real *real_signal_mid_side[2];              /* the floating-point version of the mid-side input signal (stereo only) */
114         unsigned subframe_bps[FLAC__MAX_CHANNELS];        /* the effective bits per sample of the input signal (stream bps - wasted bits) */
115         unsigned subframe_bps_mid_side[2];                /* the effective bits per sample of the mid-side input signal (stream bps - wasted bits + 0/1) */
116         FLAC__int32 *residual_workspace[FLAC__MAX_CHANNELS][2]; /* each channel has a candidate and best workspace where the subframe residual signals will be stored */
117         FLAC__int32 *residual_workspace_mid_side[2][2];
118         FLAC__Subframe subframe_workspace[FLAC__MAX_CHANNELS][2];
119         FLAC__Subframe subframe_workspace_mid_side[2][2];
120         FLAC__Subframe *subframe_workspace_ptr[FLAC__MAX_CHANNELS][2];
121         FLAC__Subframe *subframe_workspace_ptr_mid_side[2][2];
122         FLAC__EntropyCodingMethod_PartitionedRice partitioned_rice_workspace[FLAC__MAX_CHANNELS][2];
123         FLAC__EntropyCodingMethod_PartitionedRice partitioned_rice_workspace_mid_side[FLAC__MAX_CHANNELS][2];
124         FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice_workspace_ptr[FLAC__MAX_CHANNELS][2];
125         FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice_workspace_ptr_mid_side[FLAC__MAX_CHANNELS][2];
126         unsigned best_subframe[FLAC__MAX_CHANNELS];       /* index into the above workspaces */
127         unsigned best_subframe_mid_side[2];
128         unsigned best_subframe_bits[FLAC__MAX_CHANNELS];  /* size in bits of the best subframe for each channel */
129         unsigned best_subframe_bits_mid_side[2];
130         FLAC__uint32 *abs_residual;                       /* workspace where abs(candidate residual) is stored */
131         FLAC__uint64 *abs_residual_partition_sums;        /* workspace where the sum of abs(candidate residual) for each partition is stored */
132         unsigned *raw_bits_per_partition;                 /* workspace where the sum of silog2(candidate residual) for each partition is stored */
133         FLAC__BitBuffer *frame;                           /* the current frame being worked on */
134         double loose_mid_side_stereo_frames_exact;        /* exact number of frames the encoder will use before trying both independent and mid/side frames again */
135         unsigned loose_mid_side_stereo_frames;            /* rounded number of frames the encoder will use before trying both independent and mid/side frames again */
136         unsigned loose_mid_side_stereo_frame_count;       /* number of frames using the current channel assignment */
137         FLAC__ChannelAssignment last_channel_assignment;
138         FLAC__StreamMetadata metadata;
139         unsigned current_sample_number;
140         unsigned current_frame_number;
141         struct MD5Context md5context;
142         FLAC__CPUInfo cpuinfo;
143         unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, FLAC__real residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
144         void (*local_lpc_compute_autocorrelation)(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
145         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[]);
146         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[]);
147         FLAC__bool use_wide_by_block;          /* use slow 64-bit versions of some functions because of the block size */
148         FLAC__bool use_wide_by_partition;      /* use slow 64-bit versions of some functions because of the min partition order and blocksize */
149         FLAC__bool use_wide_by_order;          /* use slow 64-bit versions of some functions because of the lpc order */
150         FLAC__bool precompute_partition_sums;  /* our initial guess as to whether precomputing the partitions sums will be a speed improvement */
151         FLAC__StreamEncoderWriteCallback write_callback;
152         FLAC__StreamEncoderMetadataCallback metadata_callback;
153         void *client_data;
154         /* unaligned (original) pointers to allocated data */
155         FLAC__int32 *integer_signal_unaligned[FLAC__MAX_CHANNELS];
156         FLAC__int32 *integer_signal_mid_side_unaligned[2];
157         FLAC__real *real_signal_unaligned[FLAC__MAX_CHANNELS];
158         FLAC__real *real_signal_mid_side_unaligned[2];
159         FLAC__int32 *residual_workspace_unaligned[FLAC__MAX_CHANNELS][2];
160         FLAC__int32 *residual_workspace_mid_side_unaligned[2][2];
161         FLAC__uint32 *abs_residual_unaligned;
162         FLAC__uint64 *abs_residual_partition_sums_unaligned;
163         unsigned *raw_bits_per_partition_unaligned;
164         /*
165          * These fields have been moved here from private function local
166          * declarations merely to save stack space during encoding.
167          */
168         FLAC__real lp_coeff[FLAC__MAX_LPC_ORDER][FLAC__MAX_LPC_ORDER]; /* from process_subframe_() */
169         FLAC__EntropyCodingMethod_PartitionedRice partitioned_rice_extra[2]; /* from find_best_partition_order_() */
170         /*
171          * The data for the verify section
172          */
173         struct {
174                 FLAC__StreamDecoder *decoder;
175                 EncoderStateHint state_hint;
176                 FLAC__bool needs_magic_hack;
177                 verify_input_fifo input_fifo;
178                 verify_output output;
179                 struct {
180                         FLAC__uint64 absolute_sample;
181                         unsigned frame_number;
182                         unsigned channel;
183                         unsigned sample;
184                         FLAC__int32 expected;
185                         FLAC__int32 got;
186                 } error_stats;
187         } verify;
188         FLAC__bool is_being_deleted; /* if true, call to ..._finish() from ..._delete() will not call the callbacks */
189 } FLAC__StreamEncoderPrivate;
190
191 /***********************************************************************
192  *
193  * Public static class data
194  *
195  ***********************************************************************/
196
197 const char * const FLAC__StreamEncoderStateString[] = {
198         "FLAC__STREAM_ENCODER_OK",
199         "FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR",
200         "FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA",
201         "FLAC__STREAM_ENCODER_INVALID_CALLBACK",
202         "FLAC__STREAM_ENCODER_INVALID_NUMBER_OF_CHANNELS",
203         "FLAC__STREAM_ENCODER_INVALID_BITS_PER_SAMPLE",
204         "FLAC__STREAM_ENCODER_INVALID_SAMPLE_RATE",
205         "FLAC__STREAM_ENCODER_INVALID_BLOCK_SIZE",
206         "FLAC__STREAM_ENCODER_INVALID_QLP_COEFF_PRECISION",
207         "FLAC__STREAM_ENCODER_MID_SIDE_CHANNELS_MISMATCH",
208         "FLAC__STREAM_ENCODER_MID_SIDE_SAMPLE_SIZE_MISMATCH",
209         "FLAC__STREAM_ENCODER_ILLEGAL_MID_SIDE_FORCE",
210         "FLAC__STREAM_ENCODER_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER",
211         "FLAC__STREAM_ENCODER_NOT_STREAMABLE",
212         "FLAC__STREAM_ENCODER_FRAMING_ERROR",
213         "FLAC__STREAM_ENCODER_INVALID_METADATA",
214         "FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING",
215         "FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_WRITING",
216         "FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR",
217         "FLAC__STREAM_ENCODER_ALREADY_INITIALIZED",
218         "FLAC__STREAM_ENCODER_UNINITIALIZED"
219 };
220
221 const char * const FLAC__StreamEncoderWriteStatusString[] = {
222         "FLAC__STREAM_ENCODER_WRITE_STATUS_OK",
223         "FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR"
224 };
225
226 /***********************************************************************
227  *
228  * Class constructor/destructor
229  *
230  */
231 FLAC__StreamEncoder *FLAC__stream_encoder_new()
232 {
233         FLAC__StreamEncoder *encoder;
234         unsigned i;
235
236         FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
237
238         encoder = (FLAC__StreamEncoder*)malloc(sizeof(FLAC__StreamEncoder));
239         if(encoder == 0) {
240                 return 0;
241         }
242         memset(encoder, 0, sizeof(FLAC__StreamEncoder));
243
244         encoder->protected_ = (FLAC__StreamEncoderProtected*)malloc(sizeof(FLAC__StreamEncoderProtected));
245         if(encoder->protected_ == 0) {
246                 free(encoder);
247                 return 0;
248         }
249         memset(encoder->protected_, 0, sizeof(FLAC__StreamEncoderProtected));
250
251         encoder->private_ = (FLAC__StreamEncoderPrivate*)malloc(sizeof(FLAC__StreamEncoderPrivate));
252         if(encoder->private_ == 0) {
253                 free(encoder->protected_);
254                 free(encoder);
255                 return 0;
256         }
257         memset(encoder->private_, 0, sizeof(FLAC__StreamEncoderPrivate));
258
259         encoder->private_->frame = FLAC__bitbuffer_new();
260         if(encoder->private_->frame == 0) {
261                 free(encoder->private_);
262                 free(encoder->protected_);
263                 free(encoder);
264                 return 0;
265         }
266
267         set_defaults_(encoder);
268
269         encoder->private_->is_being_deleted = false;
270
271         for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
272                 encoder->private_->subframe_workspace_ptr[i][0] = &encoder->private_->subframe_workspace[i][0];
273                 encoder->private_->subframe_workspace_ptr[i][1] = &encoder->private_->subframe_workspace[i][1];
274         }
275         for(i = 0; i < 2; i++) {
276                 encoder->private_->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->subframe_workspace_mid_side[i][0];
277                 encoder->private_->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->subframe_workspace_mid_side[i][1];
278         }
279         for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
280                 encoder->private_->partitioned_rice_workspace_ptr[i][0] = &encoder->private_->partitioned_rice_workspace[i][0];
281                 encoder->private_->partitioned_rice_workspace_ptr[i][1] = &encoder->private_->partitioned_rice_workspace[i][1];
282         }
283         for(i = 0; i < 2; i++) {
284                 encoder->private_->partitioned_rice_workspace_ptr_mid_side[i][0] = &encoder->private_->partitioned_rice_workspace_mid_side[i][0];
285                 encoder->private_->partitioned_rice_workspace_ptr_mid_side[i][1] = &encoder->private_->partitioned_rice_workspace_mid_side[i][1];
286         }
287
288         for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
289                 FLAC__format_entropy_coding_method_partitioned_rice_init(&encoder->private_->partitioned_rice_workspace[i][0]);
290                 FLAC__format_entropy_coding_method_partitioned_rice_init(&encoder->private_->partitioned_rice_workspace[i][1]);
291         }
292         for(i = 0; i < 2; i++) {
293                 FLAC__format_entropy_coding_method_partitioned_rice_init(&encoder->private_->partitioned_rice_workspace_mid_side[i][0]);
294                 FLAC__format_entropy_coding_method_partitioned_rice_init(&encoder->private_->partitioned_rice_workspace_mid_side[i][1]);
295         }
296         for(i = 0; i < 2; i++)
297                 FLAC__format_entropy_coding_method_partitioned_rice_init(&encoder->private_->partitioned_rice_extra[i]);
298
299         encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
300
301         return encoder;
302 }
303
304 void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder)
305 {
306         unsigned i;
307
308         FLAC__ASSERT(0 != encoder);
309         FLAC__ASSERT(0 != encoder->protected_);
310         FLAC__ASSERT(0 != encoder->private_);
311         FLAC__ASSERT(0 != encoder->private_->frame);
312
313         encoder->private_->is_being_deleted = true;
314
315         FLAC__stream_encoder_finish(encoder);
316
317         if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder)
318                 FLAC__stream_decoder_delete(encoder->private_->verify.decoder);
319
320         for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
321                 FLAC__format_entropy_coding_method_partitioned_rice_clear(&encoder->private_->partitioned_rice_workspace[i][0]);
322                 FLAC__format_entropy_coding_method_partitioned_rice_clear(&encoder->private_->partitioned_rice_workspace[i][1]);
323         }
324         for(i = 0; i < 2; i++) {
325                 FLAC__format_entropy_coding_method_partitioned_rice_clear(&encoder->private_->partitioned_rice_workspace_mid_side[i][0]);
326                 FLAC__format_entropy_coding_method_partitioned_rice_clear(&encoder->private_->partitioned_rice_workspace_mid_side[i][1]);
327         }
328         for(i = 0; i < 2; i++)
329                 FLAC__format_entropy_coding_method_partitioned_rice_clear(&encoder->private_->partitioned_rice_extra[i]);
330
331         FLAC__bitbuffer_delete(encoder->private_->frame);
332         free(encoder->private_);
333         free(encoder->protected_);
334         free(encoder);
335 }
336
337 /***********************************************************************
338  *
339  * Public class methods
340  *
341  ***********************************************************************/
342
343 FLAC__StreamEncoderState FLAC__stream_encoder_init(FLAC__StreamEncoder *encoder)
344 {
345         unsigned i;
346
347         FLAC__ASSERT(0 != encoder);
348
349         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
350                 return encoder->protected_->state = FLAC__STREAM_ENCODER_ALREADY_INITIALIZED;
351
352         encoder->protected_->state = FLAC__STREAM_ENCODER_OK;
353
354         if(0 == encoder->private_->write_callback || 0 == encoder->private_->metadata_callback)
355                 return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_CALLBACK;
356
357         if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS)
358                 return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_NUMBER_OF_CHANNELS;
359
360         if(encoder->protected_->do_mid_side_stereo && encoder->protected_->channels != 2)
361                 return encoder->protected_->state = FLAC__STREAM_ENCODER_MID_SIDE_CHANNELS_MISMATCH;
362
363         if(encoder->protected_->loose_mid_side_stereo && !encoder->protected_->do_mid_side_stereo)
364                 return encoder->protected_->state = FLAC__STREAM_ENCODER_ILLEGAL_MID_SIDE_FORCE;
365
366         if(encoder->protected_->bits_per_sample >= 32)
367                 encoder->protected_->do_mid_side_stereo = false; /* since we do 32-bit math, the side channel would have 33 bps and overflow */
368
369         if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE)
370                 return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_BITS_PER_SAMPLE;
371
372         if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate))
373                 return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_SAMPLE_RATE;
374
375         if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE)
376                 return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_BLOCK_SIZE;
377
378         if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order)
379                 return encoder->protected_->state = FLAC__STREAM_ENCODER_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER;
380
381         if(encoder->protected_->qlp_coeff_precision == 0) {
382                 if(encoder->protected_->bits_per_sample < 16) {
383                         /* @@@ need some data about how to set this here w.r.t. blocksize and sample rate */
384                         /* @@@ until then we'll make a guess */
385                         encoder->protected_->qlp_coeff_precision = max(5, 2 + encoder->protected_->bits_per_sample / 2);
386                 }
387                 else if(encoder->protected_->bits_per_sample == 16) {
388                         if(encoder->protected_->blocksize <= 192)
389                                 encoder->protected_->qlp_coeff_precision = 7;
390                         else if(encoder->protected_->blocksize <= 384)
391                                 encoder->protected_->qlp_coeff_precision = 8;
392                         else if(encoder->protected_->blocksize <= 576)
393                                 encoder->protected_->qlp_coeff_precision = 9;
394                         else if(encoder->protected_->blocksize <= 1152)
395                                 encoder->protected_->qlp_coeff_precision = 10;
396                         else if(encoder->protected_->blocksize <= 2304)
397                                 encoder->protected_->qlp_coeff_precision = 11;
398                         else if(encoder->protected_->blocksize <= 4608)
399                                 encoder->protected_->qlp_coeff_precision = 12;
400                         else
401                                 encoder->protected_->qlp_coeff_precision = 13;
402                 }
403                 else {
404                         encoder->protected_->qlp_coeff_precision = min(13, 8*sizeof(FLAC__int32) - encoder->protected_->bits_per_sample - 1 - 2); /* @@@ -2 to keep things 32-bit safe */
405                 }
406         }
407         else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision + encoder->protected_->bits_per_sample >= 8*sizeof(FLAC__uint32) || encoder->protected_->qlp_coeff_precision >= (1u<<FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN))
408                 return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_QLP_COEFF_PRECISION;
409
410         if(encoder->protected_->streamable_subset) {
411                 /*@@@ add check for blocksize here */
412                 if(encoder->protected_->bits_per_sample != 8 && encoder->protected_->bits_per_sample != 12 && encoder->protected_->bits_per_sample != 16 && encoder->protected_->bits_per_sample != 20 && encoder->protected_->bits_per_sample != 24)
413                         return encoder->protected_->state = FLAC__STREAM_ENCODER_NOT_STREAMABLE;
414                 if(encoder->protected_->sample_rate > 655350)
415                         return encoder->protected_->state = FLAC__STREAM_ENCODER_NOT_STREAMABLE;
416         }
417
418         if(encoder->protected_->max_residual_partition_order >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
419                 encoder->protected_->max_residual_partition_order = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1;
420         if(encoder->protected_->min_residual_partition_order >= encoder->protected_->max_residual_partition_order)
421                 encoder->protected_->min_residual_partition_order = encoder->protected_->max_residual_partition_order;
422
423         /* validate metadata */
424         if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0)
425                 return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_METADATA;
426         for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
427                 if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_STREAMINFO)
428                         return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_METADATA;
429                 else if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
430                         if(!FLAC__format_seektable_is_legal(&encoder->protected_->metadata[i]->data.seek_table))
431                                 return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_METADATA;
432                 }
433         }
434
435         encoder->private_->input_capacity = 0;
436         for(i = 0; i < encoder->protected_->channels; i++) {
437                 encoder->private_->integer_signal_unaligned[i] = encoder->private_->integer_signal[i] = 0;
438                 encoder->private_->real_signal_unaligned[i] = encoder->private_->real_signal[i] = 0;
439         }
440         for(i = 0; i < 2; i++) {
441                 encoder->private_->integer_signal_mid_side_unaligned[i] = encoder->private_->integer_signal_mid_side[i] = 0;
442                 encoder->private_->real_signal_mid_side_unaligned[i] = encoder->private_->real_signal_mid_side[i] = 0;
443         }
444         for(i = 0; i < encoder->protected_->channels; i++) {
445                 encoder->private_->residual_workspace_unaligned[i][0] = encoder->private_->residual_workspace[i][0] = 0;
446                 encoder->private_->residual_workspace_unaligned[i][1] = encoder->private_->residual_workspace[i][1] = 0;
447                 encoder->private_->best_subframe[i] = 0;
448         }
449         for(i = 0; i < 2; i++) {
450                 encoder->private_->residual_workspace_mid_side_unaligned[i][0] = encoder->private_->residual_workspace_mid_side[i][0] = 0;
451                 encoder->private_->residual_workspace_mid_side_unaligned[i][1] = encoder->private_->residual_workspace_mid_side[i][1] = 0;
452                 encoder->private_->best_subframe_mid_side[i] = 0;
453         }
454         encoder->private_->abs_residual_unaligned = encoder->private_->abs_residual = 0;
455         encoder->private_->abs_residual_partition_sums_unaligned = encoder->private_->abs_residual_partition_sums = 0;
456         encoder->private_->raw_bits_per_partition_unaligned = encoder->private_->raw_bits_per_partition = 0;
457         encoder->private_->loose_mid_side_stereo_frames_exact = (double)encoder->protected_->sample_rate * 0.4 / (double)encoder->protected_->blocksize;
458         encoder->private_->loose_mid_side_stereo_frames = (unsigned)(encoder->private_->loose_mid_side_stereo_frames_exact + 0.5);
459         if(encoder->private_->loose_mid_side_stereo_frames == 0)
460                 encoder->private_->loose_mid_side_stereo_frames = 1;
461         encoder->private_->loose_mid_side_stereo_frame_count = 0;
462         encoder->private_->current_sample_number = 0;
463         encoder->private_->current_frame_number = 0;
464
465         encoder->private_->use_wide_by_block = (encoder->protected_->bits_per_sample + FLAC__bitmath_ilog2(encoder->protected_->blocksize)+1 > 30);
466         encoder->private_->use_wide_by_order = (encoder->protected_->bits_per_sample + FLAC__bitmath_ilog2(max(encoder->protected_->max_lpc_order, FLAC__MAX_FIXED_ORDER))+1 > 30); /*@@@ need to use this? */
467         encoder->private_->use_wide_by_partition = (false); /*@@@ need to set this */
468
469         /*
470          * get the CPU info and set the function pointers
471          */
472         FLAC__cpu_info(&encoder->private_->cpuinfo);
473         /* first default to the non-asm routines */
474         encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
475         encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor;
476         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients;
477         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients;
478         /* now override with asm where appropriate */
479 #ifndef FLAC__NO_ASM
480         if(encoder->private_->cpuinfo.use_asm) {
481 #ifdef FLAC__CPU_IA32
482                 FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32);
483 #ifdef FLAC__HAS_NASM
484                 if(0 && encoder->private_->cpuinfo.data.ia32.sse) {
485                         if(encoder->protected_->max_lpc_order < 4)
486                                 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4;
487                         else if(encoder->protected_->max_lpc_order < 8)
488                                 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8;
489                         else if(encoder->protected_->max_lpc_order < 12)
490                                 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12;
491                         else
492                                 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32;
493                 }
494                 else if(encoder->private_->cpuinfo.data.ia32._3dnow)
495                         encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_3dnow;
496                 else
497                         encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32;
498                 if(encoder->private_->cpuinfo.data.ia32.mmx && encoder->private_->cpuinfo.data.ia32.cmov)
499                         encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov;
500                 if(encoder->private_->cpuinfo.data.ia32.mmx) {
501                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
502                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx;
503                 }
504                 else {
505                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
506                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
507                 }
508 #endif
509 #endif
510         }
511 #endif
512         /* finally override based on wide-ness if necessary */
513         if(encoder->private_->use_wide_by_block) {
514                 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_wide;
515         }
516
517         /* we require precompute_partition_sums if do_escape_coding because of their intertwined nature */
518         encoder->private_->precompute_partition_sums = (encoder->protected_->max_residual_partition_order > encoder->protected_->min_residual_partition_order) || encoder->protected_->do_escape_coding;
519
520         if(!resize_buffers_(encoder, encoder->protected_->blocksize)) {
521                 /* the above function sets the state for us in case of an error */
522                 return encoder->protected_->state;
523         }
524
525         if(!FLAC__bitbuffer_init(encoder->private_->frame))
526                 return encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
527
528         /*
529          * Set up the verify stuff if necessary
530          */
531         if(encoder->protected_->verify) {
532                 /*
533                  * First, set up the fifo which will hold the
534                  * original signal to compare against
535                  */
536                 encoder->private_->verify.input_fifo.size = encoder->protected_->blocksize;
537                 for(i = 0; i < encoder->protected_->channels; i++) {
538                         if(0 == (encoder->private_->verify.input_fifo.data[i] = (FLAC__int32*)malloc(sizeof(FLAC__int32) * encoder->private_->verify.input_fifo.size)))
539                                 return encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
540                 }
541                 encoder->private_->verify.input_fifo.tail = 0;
542
543                 /*
544                  * Now set up a stream decoder for verification
545                  */
546                 encoder->private_->verify.decoder = FLAC__stream_decoder_new();
547                 if(0 == encoder->private_->verify.decoder)
548                         return encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
549
550                 FLAC__stream_decoder_set_read_callback(encoder->private_->verify.decoder, verify_read_callback_);
551                 FLAC__stream_decoder_set_write_callback(encoder->private_->verify.decoder, verify_write_callback_);
552                 FLAC__stream_decoder_set_metadata_callback(encoder->private_->verify.decoder, verify_metadata_callback_);
553                 FLAC__stream_decoder_set_error_callback(encoder->private_->verify.decoder, verify_error_callback_);
554                 FLAC__stream_decoder_set_client_data(encoder->private_->verify.decoder, encoder);
555                 if(FLAC__stream_decoder_init(encoder->private_->verify.decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
556                         return encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
557         }
558         encoder->private_->verify.error_stats.absolute_sample = 0;
559         encoder->private_->verify.error_stats.frame_number = 0;
560         encoder->private_->verify.error_stats.channel = 0;
561         encoder->private_->verify.error_stats.sample = 0;
562         encoder->private_->verify.error_stats.expected = 0;
563         encoder->private_->verify.error_stats.got = 0;
564
565         /*
566          * write the stream header
567          */
568         if(encoder->protected_->verify)
569                 encoder->private_->verify.state_hint = ENCODER_IN_MAGIC;
570         if(!FLAC__bitbuffer_write_raw_uint32(encoder->private_->frame, FLAC__STREAM_SYNC, FLAC__STREAM_SYNC_LEN))
571                 return encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
572         if(!write_bitbuffer_(encoder, 0)) {
573                 /* the above function sets the state for us in case of an error */
574                 return encoder->protected_->state;
575         }
576
577         /*
578          * write the STREAMINFO metadata block
579          */
580         if(encoder->protected_->verify)
581                 encoder->private_->verify.state_hint = ENCODER_IN_METADATA;
582         encoder->private_->metadata.type = FLAC__METADATA_TYPE_STREAMINFO;
583         encoder->private_->metadata.is_last = (encoder->protected_->num_metadata_blocks == 0);
584         encoder->private_->metadata.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
585         encoder->private_->metadata.data.stream_info.min_blocksize = encoder->protected_->blocksize; /* this encoder uses the same blocksize for the whole stream */
586         encoder->private_->metadata.data.stream_info.max_blocksize = encoder->protected_->blocksize;
587         encoder->private_->metadata.data.stream_info.min_framesize = 0; /* we don't know this yet; have to fill it in later */
588         encoder->private_->metadata.data.stream_info.max_framesize = 0; /* we don't know this yet; have to fill it in later */
589         encoder->private_->metadata.data.stream_info.sample_rate = encoder->protected_->sample_rate;
590         encoder->private_->metadata.data.stream_info.channels = encoder->protected_->channels;
591         encoder->private_->metadata.data.stream_info.bits_per_sample = encoder->protected_->bits_per_sample;
592         encoder->private_->metadata.data.stream_info.total_samples = encoder->protected_->total_samples_estimate; /* we will replace this later with the real total */
593         memset(encoder->private_->metadata.data.stream_info.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */
594         MD5Init(&encoder->private_->md5context);
595         if(!FLAC__bitbuffer_clear(encoder->private_->frame)) {
596                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
597                 return false;
598         }
599         if(!FLAC__add_metadata_block(&encoder->private_->metadata, encoder->private_->frame))
600                 return encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
601         if(!write_bitbuffer_(encoder, 0)) {
602                 /* the above function sets the state for us in case of an error */
603                 return encoder->protected_->state;
604         }
605
606         /*
607          * Now that the STREAMINFO block is written, we can init this to an
608          * absurdly-high value...
609          */
610         encoder->private_->metadata.data.stream_info.min_framesize = (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN) - 1;
611         /* ... and clear this to 0 */
612         encoder->private_->metadata.data.stream_info.total_samples = 0;
613
614         /*
615          * write the user's metadata blocks
616          */
617         for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
618                 encoder->protected_->metadata[i]->is_last = (i == encoder->protected_->num_metadata_blocks - 1);
619                 if(!FLAC__bitbuffer_clear(encoder->private_->frame)) {
620                         encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
621                         return false;
622                 }
623                 if(!FLAC__add_metadata_block(encoder->protected_->metadata[i], encoder->private_->frame))
624                         return encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
625                 if(!write_bitbuffer_(encoder, 0)) {
626                         /* the above function sets the state for us in case of an error */
627                         return encoder->protected_->state;
628                 }
629         }
630
631         if(encoder->protected_->verify)
632                 encoder->private_->verify.state_hint = ENCODER_IN_AUDIO;
633
634         return encoder->protected_->state;
635 }
636
637 void FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder)
638 {
639         FLAC__ASSERT(0 != encoder);
640
641         if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED)
642                 return;
643
644         if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) {
645                 if(encoder->private_->current_sample_number != 0) {
646                         encoder->protected_->blocksize = encoder->private_->current_sample_number;
647                         process_frame_(encoder, true); /* true => is last frame */
648                 }
649         }
650
651         MD5Final(encoder->private_->metadata.data.stream_info.md5sum, &encoder->private_->md5context);
652
653         if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) {
654                 encoder->private_->metadata_callback(encoder, &encoder->private_->metadata, encoder->private_->client_data);
655         }
656
657         if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder)
658                 FLAC__stream_decoder_finish(encoder->private_->verify.decoder);
659
660         free_(encoder);
661         set_defaults_(encoder);
662
663         encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
664 }
665
666 FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value)
667 {
668         FLAC__ASSERT(0 != encoder);
669         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
670                 return false;
671         encoder->protected_->verify = value;
672         return true;
673 }
674
675 FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value)
676 {
677         FLAC__ASSERT(0 != encoder);
678         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
679                 return false;
680         encoder->protected_->streamable_subset = value;
681         return true;
682 }
683
684 FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
685 {
686         FLAC__ASSERT(0 != encoder);
687         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
688                 return false;
689         encoder->protected_->do_mid_side_stereo = value;
690         return true;
691 }
692
693 FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
694 {
695         FLAC__ASSERT(0 != encoder);
696         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
697                 return false;
698         encoder->protected_->loose_mid_side_stereo = value;
699         return true;
700 }
701
702 FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value)
703 {
704         FLAC__ASSERT(0 != encoder);
705         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
706                 return false;
707         encoder->protected_->channels = value;
708         return true;
709 }
710
711 FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value)
712 {
713         FLAC__ASSERT(0 != encoder);
714         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
715                 return false;
716         encoder->protected_->bits_per_sample = value;
717         return true;
718 }
719
720 FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value)
721 {
722         FLAC__ASSERT(0 != encoder);
723         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
724                 return false;
725         encoder->protected_->sample_rate = value;
726         return true;
727 }
728
729 FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value)
730 {
731         FLAC__ASSERT(0 != encoder);
732         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
733                 return false;
734         encoder->protected_->blocksize = value;
735         return true;
736 }
737
738 FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, unsigned value)
739 {
740         FLAC__ASSERT(0 != encoder);
741         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
742                 return false;
743         encoder->protected_->max_lpc_order = value;
744         return true;
745 }
746
747 FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, unsigned value)
748 {
749         FLAC__ASSERT(0 != encoder);
750         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
751                 return false;
752         encoder->protected_->qlp_coeff_precision = value;
753         return true;
754 }
755
756 FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
757 {
758         FLAC__ASSERT(0 != encoder);
759         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
760                 return false;
761         encoder->protected_->do_qlp_coeff_prec_search = value;
762         return true;
763 }
764
765 FLAC__bool FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder *encoder, FLAC__bool value)
766 {
767         FLAC__ASSERT(0 != encoder);
768         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
769                 return false;
770 #if 0
771         /*@@@ deprecated: */
772         encoder->protected_->do_escape_coding = value;
773 #else
774         (void)value;
775 #endif
776         return true;
777 }
778
779 FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
780 {
781         FLAC__ASSERT(0 != encoder);
782         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
783                 return false;
784         encoder->protected_->do_exhaustive_model_search = value;
785         return true;
786 }
787
788 FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
789 {
790         FLAC__ASSERT(0 != encoder);
791         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
792                 return false;
793         encoder->protected_->min_residual_partition_order = value;
794         return true;
795 }
796
797 FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
798 {
799         FLAC__ASSERT(0 != encoder);
800         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
801                 return false;
802         encoder->protected_->max_residual_partition_order = value;
803         return true;
804 }
805
806 FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value)
807 {
808         FLAC__ASSERT(0 != encoder);
809         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
810                 return false;
811 #if 0
812         /*@@@ deprecated: */
813         encoder->protected_->rice_parameter_search_dist = value;
814 #else
815         (void)value;
816 #endif
817         return true;
818 }
819
820 FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value)
821 {
822         FLAC__ASSERT(0 != encoder);
823         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
824                 return false;
825         encoder->protected_->total_samples_estimate = value;
826         return true;
827 }
828
829 FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks)
830 {
831         FLAC__ASSERT(0 != encoder);
832         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
833                 return false;
834         encoder->protected_->metadata = metadata;
835         encoder->protected_->num_metadata_blocks = num_blocks;
836         return true;
837 }
838
839 FLAC__bool FLAC__stream_encoder_set_write_callback(FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteCallback value)
840 {
841         FLAC__ASSERT(0 != encoder);
842         FLAC__ASSERT(0 != value);
843         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
844                 return false;
845         encoder->private_->write_callback = value;
846         return true;
847 }
848
849 FLAC__bool FLAC__stream_encoder_set_metadata_callback(FLAC__StreamEncoder *encoder, FLAC__StreamEncoderMetadataCallback value)
850 {
851         FLAC__ASSERT(0 != encoder);
852         FLAC__ASSERT(0 != value);
853         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
854                 return false;
855         encoder->private_->metadata_callback = value;
856         return true;
857 }
858
859 FLAC__bool FLAC__stream_encoder_set_client_data(FLAC__StreamEncoder *encoder, void *value)
860 {
861         FLAC__ASSERT(0 != encoder);
862         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
863                 return false;
864         encoder->private_->client_data = value;
865         return true;
866 }
867
868 FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder)
869 {
870         FLAC__ASSERT(0 != encoder);
871         return encoder->protected_->state;
872 }
873
874 FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder)
875 {
876         FLAC__ASSERT(0 != encoder);
877         if(encoder->protected_->verify)
878                 return FLAC__stream_decoder_get_state(encoder->private_->verify.decoder);
879         else
880                 return FLAC__STREAM_DECODER_UNINITIALIZED;
881 }
882
883 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)
884 {
885         FLAC__ASSERT(0 != encoder);
886         if(0 != absolute_sample)
887                 *absolute_sample = encoder->private_->verify.error_stats.absolute_sample;
888         if(0 != frame_number)
889                 *frame_number = encoder->private_->verify.error_stats.frame_number;
890         if(0 != channel)
891                 *channel = encoder->private_->verify.error_stats.channel;
892         if(0 != sample)
893                 *sample = encoder->private_->verify.error_stats.sample;
894         if(0 != expected)
895                 *expected = encoder->private_->verify.error_stats.expected;
896         if(0 != got)
897                 *got = encoder->private_->verify.error_stats.got;
898 }
899
900 FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder)
901 {
902         FLAC__ASSERT(0 != encoder);
903         return encoder->protected_->verify;
904 }
905
906 FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder)
907 {
908         FLAC__ASSERT(0 != encoder);
909         return encoder->protected_->streamable_subset;
910 }
911
912 FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
913 {
914         FLAC__ASSERT(0 != encoder);
915         return encoder->protected_->do_mid_side_stereo;
916 }
917
918 FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
919 {
920         FLAC__ASSERT(0 != encoder);
921         return encoder->protected_->loose_mid_side_stereo;
922 }
923
924 unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
925 {
926         FLAC__ASSERT(0 != encoder);
927         return encoder->protected_->channels;
928 }
929
930 unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
931 {
932         FLAC__ASSERT(0 != encoder);
933         return encoder->protected_->bits_per_sample;
934 }
935
936 unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
937 {
938         FLAC__ASSERT(0 != encoder);
939         return encoder->protected_->sample_rate;
940 }
941
942 unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
943 {
944         FLAC__ASSERT(0 != encoder);
945         return encoder->protected_->blocksize;
946 }
947
948 unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder)
949 {
950         FLAC__ASSERT(0 != encoder);
951         return encoder->protected_->max_lpc_order;
952 }
953
954 unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder)
955 {
956         FLAC__ASSERT(0 != encoder);
957         return encoder->protected_->qlp_coeff_precision;
958 }
959
960 FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
961 {
962         FLAC__ASSERT(0 != encoder);
963         return encoder->protected_->do_qlp_coeff_prec_search;
964 }
965
966 FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder)
967 {
968         FLAC__ASSERT(0 != encoder);
969         return encoder->protected_->do_escape_coding;
970 }
971
972 FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
973 {
974         FLAC__ASSERT(0 != encoder);
975         return encoder->protected_->do_exhaustive_model_search;
976 }
977
978 unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder)
979 {
980         FLAC__ASSERT(0 != encoder);
981         return encoder->protected_->min_residual_partition_order;
982 }
983
984 unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder)
985 {
986         FLAC__ASSERT(0 != encoder);
987         return encoder->protected_->max_residual_partition_order;
988 }
989
990 unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder)
991 {
992         FLAC__ASSERT(0 != encoder);
993         return encoder->protected_->rice_parameter_search_dist;
994 }
995
996 FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder)
997 {
998         FLAC__ASSERT(0 != encoder);
999         return encoder->protected_->total_samples_estimate;
1000 }
1001
1002 FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples)
1003 {
1004         unsigned i, j, channel;
1005         FLAC__int32 x, mid, side;
1006         const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
1007
1008         FLAC__ASSERT(0 != encoder);
1009         FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
1010
1011         j = 0;
1012         if(encoder->protected_->do_mid_side_stereo && channels == 2) {
1013                 do {
1014                         if(encoder->protected_->verify)
1015                                 append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1016
1017                         for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1018                                 x = mid = side = buffer[0][j];
1019                                 encoder->private_->integer_signal[0][i] = x;
1020                                 encoder->private_->real_signal[0][i] = (FLAC__real)x;
1021                                 x = buffer[1][j];
1022                                 encoder->private_->integer_signal[1][i] = x;
1023                                 encoder->private_->real_signal[1][i] = (FLAC__real)x;
1024                                 mid += x;
1025                                 side -= x;
1026                                 mid >>= 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */
1027                                 encoder->private_->integer_signal_mid_side[1][i] = side;
1028                                 encoder->private_->integer_signal_mid_side[0][i] = mid;
1029                                 encoder->private_->real_signal_mid_side[1][i] = (FLAC__real)side;
1030                                 encoder->private_->real_signal_mid_side[0][i] = (FLAC__real)mid;
1031                                 encoder->private_->current_sample_number++;
1032                         }
1033                         if(i == blocksize) {
1034                                 if(!process_frame_(encoder, false)) /* false => not last frame */
1035                                         return false;
1036                         }
1037                 } while(j < samples);
1038         }
1039         else {
1040                 do {
1041                         if(encoder->protected_->verify)
1042                                 append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1043
1044                         for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1045                                 for(channel = 0; channel < channels; channel++) {
1046                                         x = buffer[channel][j];
1047                                         encoder->private_->integer_signal[channel][i] = x;
1048                                         encoder->private_->real_signal[channel][i] = (FLAC__real)x;
1049                                 }
1050                                 encoder->private_->current_sample_number++;
1051                         }
1052                         if(i == blocksize) {
1053                                 if(!process_frame_(encoder, false)) /* false => not last frame */
1054                                         return false;
1055                         }
1056                 } while(j < samples);
1057         }
1058
1059         return true;
1060 }
1061
1062 FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples)
1063 {
1064         unsigned i, j, k, channel;
1065         FLAC__int32 x, mid, side;
1066         const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
1067
1068         FLAC__ASSERT(0 != encoder);
1069         FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
1070
1071         j = k = 0;
1072         if(encoder->protected_->do_mid_side_stereo && channels == 2) {
1073                 do {
1074                         if(encoder->protected_->verify)
1075                                 append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1076
1077                         for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1078                                 x = mid = side = buffer[k++];
1079                                 encoder->private_->integer_signal[0][i] = x;
1080                                 encoder->private_->real_signal[0][i] = (FLAC__real)x;
1081                                 x = buffer[k++];
1082                                 encoder->private_->integer_signal[1][i] = x;
1083                                 encoder->private_->real_signal[1][i] = (FLAC__real)x;
1084                                 mid += x;
1085                                 side -= x;
1086                                 mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */
1087                                 encoder->private_->integer_signal_mid_side[1][i] = side;
1088                                 encoder->private_->integer_signal_mid_side[0][i] = mid;
1089                                 encoder->private_->real_signal_mid_side[1][i] = (FLAC__real)side;
1090                                 encoder->private_->real_signal_mid_side[0][i] = (FLAC__real)mid;
1091                                 encoder->private_->current_sample_number++;
1092                         }
1093                         if(i == blocksize) {
1094                                 if(!process_frame_(encoder, false)) /* false => not last frame */
1095                                         return false;
1096                         }
1097                 } while(j < samples);
1098         }
1099         else {
1100                 do {
1101                         if(encoder->protected_->verify)
1102                                 append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1103
1104                         for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1105                                 for(channel = 0; channel < channels; channel++) {
1106                                         x = buffer[k++];
1107                                         encoder->private_->integer_signal[channel][i] = x;
1108                                         encoder->private_->real_signal[channel][i] = (FLAC__real)x;
1109                                 }
1110                                 encoder->private_->current_sample_number++;
1111                         }
1112                         if(i == blocksize) {
1113                                 if(!process_frame_(encoder, false)) /* false => not last frame */
1114                                         return false;
1115                         }
1116                 } while(j < samples);
1117         }
1118
1119         return true;
1120 }
1121
1122 /***********************************************************************
1123  *
1124  * Private class methods
1125  *
1126  ***********************************************************************/
1127
1128 void set_defaults_(FLAC__StreamEncoder *encoder)
1129 {
1130         FLAC__ASSERT(0 != encoder);
1131
1132         encoder->protected_->verify = false;
1133         encoder->protected_->streamable_subset = true;
1134         encoder->protected_->do_mid_side_stereo = false;
1135         encoder->protected_->loose_mid_side_stereo = false;
1136         encoder->protected_->channels = 2;
1137         encoder->protected_->bits_per_sample = 16;
1138         encoder->protected_->sample_rate = 44100;
1139         encoder->protected_->blocksize = 1152;
1140         encoder->protected_->max_lpc_order = 0;
1141         encoder->protected_->qlp_coeff_precision = 0;
1142         encoder->protected_->do_qlp_coeff_prec_search = false;
1143         encoder->protected_->do_exhaustive_model_search = false;
1144         encoder->protected_->do_escape_coding = false;
1145         encoder->protected_->min_residual_partition_order = 0;
1146         encoder->protected_->max_residual_partition_order = 0;
1147         encoder->protected_->rice_parameter_search_dist = 0;
1148         encoder->protected_->total_samples_estimate = 0;
1149         encoder->protected_->metadata = 0;
1150         encoder->protected_->num_metadata_blocks = 0;
1151
1152         encoder->private_->write_callback = 0;
1153         encoder->private_->metadata_callback = 0;
1154         encoder->private_->client_data = 0;
1155 }
1156
1157 void free_(FLAC__StreamEncoder *encoder)
1158 {
1159         unsigned i, channel;
1160
1161         FLAC__ASSERT(0 != encoder);
1162         for(i = 0; i < encoder->protected_->channels; i++) {
1163                 if(0 != encoder->private_->integer_signal_unaligned[i]) {
1164                         free(encoder->private_->integer_signal_unaligned[i]);
1165                         encoder->private_->integer_signal_unaligned[i] = 0;
1166                 }
1167                 if(0 != encoder->private_->real_signal_unaligned[i]) {
1168                         free(encoder->private_->real_signal_unaligned[i]);
1169                         encoder->private_->real_signal_unaligned[i] = 0;
1170                 }
1171         }
1172         for(i = 0; i < 2; i++) {
1173                 if(0 != encoder->private_->integer_signal_mid_side_unaligned[i]) {
1174                         free(encoder->private_->integer_signal_mid_side_unaligned[i]);
1175                         encoder->private_->integer_signal_mid_side_unaligned[i] = 0;
1176                 }
1177                 if(0 != encoder->private_->real_signal_mid_side_unaligned[i]) {
1178                         free(encoder->private_->real_signal_mid_side_unaligned[i]);
1179                         encoder->private_->real_signal_mid_side_unaligned[i] = 0;
1180                 }
1181         }
1182         for(channel = 0; channel < encoder->protected_->channels; channel++) {
1183                 for(i = 0; i < 2; i++) {
1184                         if(0 != encoder->private_->residual_workspace_unaligned[channel][i]) {
1185                                 free(encoder->private_->residual_workspace_unaligned[channel][i]);
1186                                 encoder->private_->residual_workspace_unaligned[channel][i] = 0;
1187                         }
1188                 }
1189         }
1190         for(channel = 0; channel < 2; channel++) {
1191                 for(i = 0; i < 2; i++) {
1192                         if(0 != encoder->private_->residual_workspace_mid_side_unaligned[channel][i]) {
1193                                 free(encoder->private_->residual_workspace_mid_side_unaligned[channel][i]);
1194                                 encoder->private_->residual_workspace_mid_side_unaligned[channel][i] = 0;
1195                         }
1196                 }
1197         }
1198         if(0 != encoder->private_->abs_residual_unaligned) {
1199                 free(encoder->private_->abs_residual_unaligned);
1200                 encoder->private_->abs_residual_unaligned = 0;
1201         }
1202         if(0 != encoder->private_->abs_residual_partition_sums_unaligned) {
1203                 free(encoder->private_->abs_residual_partition_sums_unaligned);
1204                 encoder->private_->abs_residual_partition_sums_unaligned = 0;
1205         }
1206         if(0 != encoder->private_->raw_bits_per_partition_unaligned) {
1207                 free(encoder->private_->raw_bits_per_partition_unaligned);
1208                 encoder->private_->raw_bits_per_partition_unaligned = 0;
1209         }
1210         if(encoder->protected_->verify) {
1211                 for(i = 0; i < encoder->protected_->channels; i++) {
1212                         if(0 != encoder->private_->verify.input_fifo.data[i]) {
1213                                 free(encoder->private_->verify.input_fifo.data[i]);
1214                                 encoder->private_->verify.input_fifo.data[i] = 0;
1215                         }
1216                 }
1217         }
1218         FLAC__bitbuffer_free(encoder->private_->frame);
1219 }
1220
1221 FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size)
1222 {
1223         FLAC__bool ok;
1224         unsigned i, channel;
1225
1226         FLAC__ASSERT(new_size > 0);
1227         FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
1228         FLAC__ASSERT(encoder->private_->current_sample_number == 0);
1229
1230         /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */
1231         if(new_size <= encoder->private_->input_capacity)
1232                 return true;
1233
1234         ok = true;
1235
1236         /* WATCHOUT: FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx() requires that the input arrays (in our case the integer signals) have a buffer of up to 3 zeroes in front (at negative indices) for alignment purposes; we use 4 to keep the data well-aligned. */
1237
1238         for(i = 0; ok && i < encoder->protected_->channels; i++) {
1239                 ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size+4, &encoder->private_->integer_signal_unaligned[i], &encoder->private_->integer_signal[i]);
1240                 ok = ok && FLAC__memory_alloc_aligned_real_array(new_size, &encoder->private_->real_signal_unaligned[i], &encoder->private_->real_signal[i]);
1241                 memset(encoder->private_->integer_signal[i], 0, sizeof(FLAC__int32)*4);
1242                 encoder->private_->integer_signal[i] += 4;
1243         }
1244         for(i = 0; ok && i < 2; i++) {
1245                 ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size+4, &encoder->private_->integer_signal_mid_side_unaligned[i], &encoder->private_->integer_signal_mid_side[i]);
1246                 ok = ok && FLAC__memory_alloc_aligned_real_array(new_size, &encoder->private_->real_signal_mid_side_unaligned[i], &encoder->private_->real_signal_mid_side[i]);
1247                 memset(encoder->private_->integer_signal_mid_side[i], 0, sizeof(FLAC__int32)*4);
1248                 encoder->private_->integer_signal_mid_side[i] += 4;
1249         }
1250         for(channel = 0; ok && channel < encoder->protected_->channels; channel++) {
1251                 for(i = 0; ok && i < 2; i++) {
1252                         ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size, &encoder->private_->residual_workspace_unaligned[channel][i], &encoder->private_->residual_workspace[channel][i]);
1253                 }
1254         }
1255         for(channel = 0; ok && channel < 2; channel++) {
1256                 for(i = 0; ok && i < 2; i++) {
1257                         ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size, &encoder->private_->residual_workspace_mid_side_unaligned[channel][i], &encoder->private_->residual_workspace_mid_side[channel][i]);
1258                 }
1259         }
1260         ok = ok && FLAC__memory_alloc_aligned_uint32_array(new_size, &encoder->private_->abs_residual_unaligned, &encoder->private_->abs_residual);
1261         if(encoder->private_->precompute_partition_sums || encoder->protected_->do_escape_coding) /* we require precompute_partition_sums if do_escape_coding because of their intertwined nature */
1262                 ok = ok && FLAC__memory_alloc_aligned_uint64_array(new_size * 2, &encoder->private_->abs_residual_partition_sums_unaligned, &encoder->private_->abs_residual_partition_sums);
1263         if(encoder->protected_->do_escape_coding)
1264                 ok = ok && FLAC__memory_alloc_aligned_unsigned_array(new_size * 2, &encoder->private_->raw_bits_per_partition_unaligned, &encoder->private_->raw_bits_per_partition);
1265
1266         if(ok)
1267                 encoder->private_->input_capacity = new_size;
1268         else
1269                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1270
1271         return ok;
1272 }
1273
1274 FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples)
1275 {
1276         const FLAC__byte *buffer;
1277         unsigned bytes;
1278
1279         FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(encoder->private_->frame));
1280
1281         FLAC__bitbuffer_get_buffer(encoder->private_->frame, &buffer, &bytes);
1282
1283         if(encoder->protected_->verify) {
1284                 encoder->private_->verify.output.data = buffer;
1285                 encoder->private_->verify.output.bytes = bytes;
1286                 if(encoder->private_->verify.state_hint == ENCODER_IN_MAGIC) {
1287                         encoder->private_->verify.needs_magic_hack = true;
1288                 }
1289                 else {
1290                         if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder)) {
1291                                 FLAC__bitbuffer_release_buffer(encoder->private_->frame);
1292                                 if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
1293                                         encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
1294                                 return false;
1295                         }
1296                 }
1297         }
1298
1299         if(encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
1300                 encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_WRITING;
1301                 return false;
1302         }
1303
1304         FLAC__bitbuffer_release_buffer(encoder->private_->frame);
1305
1306         if(samples > 0) {
1307                 encoder->private_->metadata.data.stream_info.min_framesize = min(bytes, encoder->private_->metadata.data.stream_info.min_framesize);
1308                 encoder->private_->metadata.data.stream_info.max_framesize = max(bytes, encoder->private_->metadata.data.stream_info.max_framesize);
1309         }
1310
1311         return true;
1312 }
1313
1314 FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame)
1315 {
1316         FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
1317
1318         /*
1319          * Accumulate raw signal to the MD5 signature
1320          */
1321         if(!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)) {
1322                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1323                 return false;
1324         }
1325
1326         /*
1327          * Process the frame header and subframes into the frame bitbuffer
1328          */
1329         if(!process_subframes_(encoder, is_last_frame)) {
1330                 /* the above function sets the state for us in case of an error */
1331                 return false;
1332         }
1333
1334         /*
1335          * Zero-pad the frame to a byte_boundary
1336          */
1337         if(!FLAC__bitbuffer_zero_pad_to_byte_boundary(encoder->private_->frame)) {
1338                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1339                 return false;
1340         }
1341
1342         /*
1343          * CRC-16 the whole thing
1344          */
1345         FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(encoder->private_->frame));
1346         FLAC__bitbuffer_write_raw_uint32(encoder->private_->frame, FLAC__bitbuffer_get_write_crc16(encoder->private_->frame), FLAC__FRAME_FOOTER_CRC_LEN);
1347
1348         /*
1349          * Write it
1350          */
1351         if(!write_bitbuffer_(encoder, encoder->protected_->blocksize)) {
1352                 /* the above function sets the state for us in case of an error */
1353                 return false;
1354         }
1355
1356         /*
1357          * Get ready for the next frame
1358          */
1359         encoder->private_->current_sample_number = 0;
1360         encoder->private_->current_frame_number++;
1361         encoder->private_->metadata.data.stream_info.total_samples += (FLAC__uint64)encoder->protected_->blocksize;
1362
1363         return true;
1364 }
1365
1366 FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame)
1367 {
1368         FLAC__FrameHeader frame_header;
1369         unsigned channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order;
1370         FLAC__bool do_independent, do_mid_side, precompute_partition_sums;
1371
1372         /*
1373          * Calculate the min,max Rice partition orders
1374          */
1375         if(is_last_frame) {
1376                 max_partition_order = 0;
1377         }
1378         else {
1379                 max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize(encoder->protected_->blocksize);
1380                 max_partition_order = min(max_partition_order, encoder->protected_->max_residual_partition_order);
1381         }
1382         min_partition_order = min(min_partition_order, max_partition_order);
1383
1384         precompute_partition_sums = encoder->private_->precompute_partition_sums && ((max_partition_order > min_partition_order) || encoder->protected_->do_escape_coding);
1385
1386         /*
1387          * Setup the frame
1388          */
1389         if(!FLAC__bitbuffer_clear(encoder->private_->frame)) {
1390                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1391                 return false;
1392         }
1393         frame_header.blocksize = encoder->protected_->blocksize;
1394         frame_header.sample_rate = encoder->protected_->sample_rate;
1395         frame_header.channels = encoder->protected_->channels;
1396         frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */
1397         frame_header.bits_per_sample = encoder->protected_->bits_per_sample;
1398         frame_header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER;
1399         frame_header.number.frame_number = encoder->private_->current_frame_number;
1400
1401         /*
1402          * Figure out what channel assignments to try
1403          */
1404         if(encoder->protected_->do_mid_side_stereo) {
1405                 if(encoder->protected_->loose_mid_side_stereo) {
1406                         if(encoder->private_->loose_mid_side_stereo_frame_count == 0) {
1407                                 do_independent = true;
1408                                 do_mid_side = true;
1409                         }
1410                         else {
1411                                 do_independent = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT);
1412                                 do_mid_side = !do_independent;
1413                         }
1414                 }
1415                 else {
1416                         do_independent = true;
1417                         do_mid_side = true;
1418                 }
1419         }
1420         else {
1421                 do_independent = true;
1422                 do_mid_side = false;
1423         }
1424
1425         FLAC__ASSERT(do_independent || do_mid_side);
1426
1427         /*
1428          * Check for wasted bits; set effective bps for each subframe
1429          */
1430         if(do_independent) {
1431                 for(channel = 0; channel < encoder->protected_->channels; channel++) {
1432                         const unsigned w = get_wasted_bits_(encoder->private_->integer_signal[channel], encoder->protected_->blocksize);
1433                         encoder->private_->subframe_workspace[channel][0].wasted_bits = encoder->private_->subframe_workspace[channel][1].wasted_bits = w;
1434                         encoder->private_->subframe_bps[channel] = encoder->protected_->bits_per_sample - w;
1435                 }
1436         }
1437         if(do_mid_side) {
1438                 FLAC__ASSERT(encoder->protected_->channels == 2);
1439                 for(channel = 0; channel < 2; channel++) {
1440                         const unsigned w = get_wasted_bits_(encoder->private_->integer_signal_mid_side[channel], encoder->protected_->blocksize);
1441                         encoder->private_->subframe_workspace_mid_side[channel][0].wasted_bits = encoder->private_->subframe_workspace_mid_side[channel][1].wasted_bits = w;
1442                         encoder->private_->subframe_bps_mid_side[channel] = encoder->protected_->bits_per_sample - w + (channel==0? 0:1);
1443                 }
1444         }
1445
1446         /*
1447          * First do a normal encoding pass of each independent channel
1448          */
1449         if(do_independent) {
1450                 for(channel = 0; channel < encoder->protected_->channels; channel++) {
1451                         if(!process_subframe_(encoder, min_partition_order, max_partition_order, precompute_partition_sums, false, &frame_header, encoder->private_->subframe_bps[channel], encoder->private_->integer_signal[channel], encoder->private_->real_signal[channel], encoder->private_->subframe_workspace_ptr[channel], encoder->private_->partitioned_rice_workspace_ptr[channel], encoder->private_->residual_workspace[channel], encoder->private_->best_subframe+channel, encoder->private_->best_subframe_bits+channel))
1452                                 return false;
1453                 }
1454         }
1455
1456         /*
1457          * Now do mid and side channels if requested
1458          */
1459         if(do_mid_side) {
1460                 FLAC__ASSERT(encoder->protected_->channels == 2);
1461
1462                 for(channel = 0; channel < 2; channel++) {
1463                         if(!process_subframe_(encoder, min_partition_order, max_partition_order, precompute_partition_sums, false, &frame_header, encoder->private_->subframe_bps_mid_side[channel], encoder->private_->integer_signal_mid_side[channel], encoder->private_->real_signal_mid_side[channel], encoder->private_->subframe_workspace_ptr_mid_side[channel], encoder->private_->partitioned_rice_workspace_ptr_mid_side[channel], encoder->private_->residual_workspace_mid_side[channel], encoder->private_->best_subframe_mid_side+channel, encoder->private_->best_subframe_bits_mid_side+channel))
1464                                 return false;
1465                 }
1466         }
1467
1468         /*
1469          * Compose the frame bitbuffer
1470          */
1471         if(do_mid_side) {
1472                 unsigned left_bps = 0, right_bps = 0; /* initialized only to prevent superfluous compiler warning */
1473                 FLAC__Subframe *left_subframe = 0, *right_subframe = 0; /* initialized only to prevent superfluous compiler warning */
1474                 FLAC__ChannelAssignment channel_assignment;
1475
1476                 FLAC__ASSERT(encoder->protected_->channels == 2);
1477
1478                 if(encoder->protected_->loose_mid_side_stereo && encoder->private_->loose_mid_side_stereo_frame_count > 0) {
1479                         channel_assignment = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT? FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT : FLAC__CHANNEL_ASSIGNMENT_MID_SIDE);
1480                 }
1481                 else {
1482                         unsigned bits[4]; /* WATCHOUT - indexed by FLAC__ChannelAssignment */
1483                         unsigned min_bits;
1484                         FLAC__ChannelAssignment ca;
1485
1486                         FLAC__ASSERT(do_independent && do_mid_side);
1487
1488                         /* We have to figure out which channel assignent results in the smallest frame */
1489                         bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = encoder->private_->best_subframe_bits         [0] + encoder->private_->best_subframe_bits         [1];
1490                         bits[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE  ] = encoder->private_->best_subframe_bits         [0] + encoder->private_->best_subframe_bits_mid_side[1];
1491                         bits[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE ] = encoder->private_->best_subframe_bits         [1] + encoder->private_->best_subframe_bits_mid_side[1];
1492                         bits[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE   ] = encoder->private_->best_subframe_bits_mid_side[0] + encoder->private_->best_subframe_bits_mid_side[1];
1493
1494                         for(channel_assignment = 0, min_bits = bits[0], ca = 1; ca <= 3; ca++) {
1495                                 if(bits[ca] < min_bits) {
1496                                         min_bits = bits[ca];
1497                                         channel_assignment = ca;
1498                                 }
1499                         }
1500                 }
1501
1502                 frame_header.channel_assignment = channel_assignment;
1503
1504                 if(!FLAC__frame_add_header(&frame_header, encoder->protected_->streamable_subset, is_last_frame, encoder->private_->frame)) {
1505                         encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1506                         return false;
1507                 }
1508
1509                 switch(channel_assignment) {
1510                         case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
1511                                 left_subframe  = &encoder->private_->subframe_workspace         [0][encoder->private_->best_subframe         [0]];
1512                                 right_subframe = &encoder->private_->subframe_workspace         [1][encoder->private_->best_subframe         [1]];
1513                                 break;
1514                         case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
1515                                 left_subframe  = &encoder->private_->subframe_workspace         [0][encoder->private_->best_subframe         [0]];
1516                                 right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
1517                                 break;
1518                         case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
1519                                 left_subframe  = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
1520                                 right_subframe = &encoder->private_->subframe_workspace         [1][encoder->private_->best_subframe         [1]];
1521                                 break;
1522                         case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
1523                                 left_subframe  = &encoder->private_->subframe_workspace_mid_side[0][encoder->private_->best_subframe_mid_side[0]];
1524                                 right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
1525                                 break;
1526                         default:
1527                                 FLAC__ASSERT(0);
1528                 }
1529
1530                 switch(channel_assignment) {
1531                         case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
1532                                 left_bps  = encoder->private_->subframe_bps         [0];
1533                                 right_bps = encoder->private_->subframe_bps         [1];
1534                                 break;
1535                         case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
1536                                 left_bps  = encoder->private_->subframe_bps         [0];
1537                                 right_bps = encoder->private_->subframe_bps_mid_side[1];
1538                                 break;
1539                         case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
1540                                 left_bps  = encoder->private_->subframe_bps_mid_side[1];
1541                                 right_bps = encoder->private_->subframe_bps         [1];
1542                                 break;
1543                         case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
1544                                 left_bps  = encoder->private_->subframe_bps_mid_side[0];
1545                                 right_bps = encoder->private_->subframe_bps_mid_side[1];
1546                                 break;
1547                         default:
1548                                 FLAC__ASSERT(0);
1549                 }
1550
1551                 /* note that encoder_add_subframe_ sets the state for us in case of an error */
1552                 if(!add_subframe_(encoder, &frame_header, left_bps , left_subframe , encoder->private_->frame))
1553                         return false;
1554                 if(!add_subframe_(encoder, &frame_header, right_bps, right_subframe, encoder->private_->frame))
1555                         return false;
1556         }
1557         else {
1558                 if(!FLAC__frame_add_header(&frame_header, encoder->protected_->streamable_subset, is_last_frame, encoder->private_->frame)) {
1559                         encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1560                         return false;
1561                 }
1562
1563                 for(channel = 0; channel < encoder->protected_->channels; channel++) {
1564                         if(!add_subframe_(encoder, &frame_header, encoder->private_->subframe_bps[channel], &encoder->private_->subframe_workspace[channel][encoder->private_->best_subframe[channel]], encoder->private_->frame)) {
1565                                 /* the above function sets the state for us in case of an error */
1566                                 return false;
1567                         }
1568                 }
1569         }
1570
1571         if(encoder->protected_->loose_mid_side_stereo) {
1572                 encoder->private_->loose_mid_side_stereo_frame_count++;
1573                 if(encoder->private_->loose_mid_side_stereo_frame_count >= encoder->private_->loose_mid_side_stereo_frames)
1574                         encoder->private_->loose_mid_side_stereo_frame_count = 0;
1575         }
1576
1577         encoder->private_->last_channel_assignment = frame_header.channel_assignment;
1578
1579         return true;
1580 }
1581
1582 FLAC__bool process_subframe_(FLAC__StreamEncoder *encoder, unsigned min_partition_order, unsigned max_partition_order, FLAC__bool precompute_partition_sums, FLAC__bool verbatim_only, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__int32 integer_signal[], const FLAC__real real_signal[], FLAC__Subframe *subframe[2], FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice[2], FLAC__int32 *residual[2], unsigned *best_subframe, unsigned *best_bits)
1583 {
1584         FLAC__real fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
1585         FLAC__real lpc_residual_bits_per_sample;
1586         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 routines need all the space */
1587         FLAC__real lpc_error[FLAC__MAX_LPC_ORDER];
1588         unsigned min_lpc_order, max_lpc_order, lpc_order;
1589         unsigned min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order;
1590         unsigned min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision;
1591         unsigned rice_parameter;
1592         unsigned _candidate_bits, _best_bits;
1593         unsigned _best_subframe;
1594
1595         /* verbatim subframe is the baseline against which we measure other compressed subframes */
1596         _best_subframe = 0;
1597         _best_bits = evaluate_verbatim_subframe_(integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
1598
1599         if(!verbatim_only && frame_header->blocksize >= FLAC__MAX_FIXED_ORDER) {
1600                 /* check for constant subframe */
1601                 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);
1602                 if(fixed_residual_bits_per_sample[1] == 0.0) {
1603                         /* the above means integer_signal+FLAC__MAX_FIXED_ORDER is constant, now we just have to check the warmup samples */
1604                         unsigned i, signal_is_constant = true;
1605                         for(i = 1; i <= FLAC__MAX_FIXED_ORDER; i++) {
1606                                 if(integer_signal[0] != integer_signal[i]) {
1607                                         signal_is_constant = false;
1608                                         break;
1609                                 }
1610                         }
1611                         if(signal_is_constant) {
1612                                 _candidate_bits = evaluate_constant_subframe_(integer_signal[0], subframe_bps, subframe[!_best_subframe]);
1613                                 if(_candidate_bits < _best_bits) {
1614                                         _best_subframe = !_best_subframe;
1615                                         _best_bits = _candidate_bits;
1616                                 }
1617                         }
1618                 }
1619                 else {
1620                         /* encode fixed */
1621                         if(encoder->protected_->do_exhaustive_model_search) {
1622                                 min_fixed_order = 0;
1623                                 max_fixed_order = FLAC__MAX_FIXED_ORDER;
1624                         }
1625                         else {
1626                                 min_fixed_order = max_fixed_order = guess_fixed_order;
1627                         }
1628                         for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) {
1629                                 if(fixed_residual_bits_per_sample[fixed_order] >= (FLAC__real)subframe_bps)
1630                                         continue; /* don't even try */
1631                                 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 */
1632 #ifndef FLAC__SYMMETRIC_RICE
1633                                 rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */
1634 #endif
1635                                 if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
1636 #ifdef DEBUG_VERBOSE
1637                                         fprintf(stderr, "clipping rice_parameter (%u -> %u) @0\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
1638 #endif
1639                                         rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
1640                                 }
1641                                 _candidate_bits = evaluate_fixed_subframe_(encoder, integer_signal, residual[!_best_subframe], encoder->private_->abs_residual, encoder->private_->abs_residual_partition_sums, encoder->private_->raw_bits_per_partition, frame_header->blocksize, subframe_bps, fixed_order, rice_parameter, min_partition_order, max_partition_order, precompute_partition_sums, encoder->protected_->do_escape_coding, encoder->protected_->rice_parameter_search_dist, subframe[!_best_subframe], partitioned_rice[!_best_subframe]);
1642                                 if(_candidate_bits < _best_bits) {
1643                                         _best_subframe = !_best_subframe;
1644                                         _best_bits = _candidate_bits;
1645                                 }
1646                         }
1647
1648                         /* encode lpc */
1649                         if(encoder->protected_->max_lpc_order > 0) {
1650                                 if(encoder->protected_->max_lpc_order >= frame_header->blocksize)
1651                                         max_lpc_order = frame_header->blocksize-1;
1652                                 else
1653                                         max_lpc_order = encoder->protected_->max_lpc_order;
1654                                 if(max_lpc_order > 0) {
1655                                         encoder->private_->local_lpc_compute_autocorrelation(real_signal, frame_header->blocksize, max_lpc_order+1, autoc);
1656                                         /* if autoc[0] == 0.0, the signal is constant and we usually won't get here, but it can happen */
1657                                         if(autoc[0] != 0.0) {
1658                                                 FLAC__lpc_compute_lp_coefficients(autoc, max_lpc_order, encoder->private_->lp_coeff, lpc_error);
1659                                                 if(encoder->protected_->do_exhaustive_model_search) {
1660                                                         min_lpc_order = 1;
1661                                                 }
1662                                                 else {
1663                                                         unsigned guess_lpc_order = FLAC__lpc_compute_best_order(lpc_error, max_lpc_order, frame_header->blocksize, subframe_bps);
1664                                                         min_lpc_order = max_lpc_order = guess_lpc_order;
1665                                                 }
1666                                                 if(encoder->protected_->do_qlp_coeff_prec_search) {
1667                                                         min_qlp_coeff_precision = FLAC__MIN_QLP_COEFF_PRECISION;
1668                                                         max_qlp_coeff_precision = min(8*sizeof(FLAC__int32) - subframe_bps - 1 - 2, (1u<<FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN)-1); /* -2 to keep things 32-bit safe */
1669                                                 }
1670                                                 else {
1671                                                         min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision;
1672                                                 }
1673                                                 for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order; lpc_order++) {
1674                                                         lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize-lpc_order);
1675                                                         if(lpc_residual_bits_per_sample >= (FLAC__real)subframe_bps)
1676                                                                 continue; /* don't even try */
1677                                                         rice_parameter = (lpc_residual_bits_per_sample > 0.0)? (unsigned)(lpc_residual_bits_per_sample+0.5) : 0; /* 0.5 is for rounding */
1678 #ifndef FLAC__SYMMETRIC_RICE
1679                                                         rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */
1680 #endif
1681                                                         if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
1682 #ifdef DEBUG_VERBOSE
1683                                                                 fprintf(stderr, "clipping rice_parameter (%u -> %u) @1\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
1684 #endif
1685                                                                 rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
1686                                                         }
1687                                                         for(qlp_coeff_precision = min_qlp_coeff_precision; qlp_coeff_precision <= max_qlp_coeff_precision; qlp_coeff_precision++) {
1688                                                                 _candidate_bits = evaluate_lpc_subframe_(encoder, integer_signal, residual[!_best_subframe], encoder->private_->abs_residual, encoder->private_->abs_residual_partition_sums, encoder->private_->raw_bits_per_partition, encoder->private_->lp_coeff[lpc_order-1], frame_header->blocksize, subframe_bps, lpc_order, qlp_coeff_precision, rice_parameter, min_partition_order, max_partition_order, precompute_partition_sums, encoder->protected_->do_escape_coding, encoder->protected_->rice_parameter_search_dist, subframe[!_best_subframe], partitioned_rice[!_best_subframe]);
1689                                                                 if(_candidate_bits > 0) { /* if == 0, there was a problem quantizing the lpcoeffs */
1690                                                                         if(_candidate_bits < _best_bits) {
1691                                                                                 _best_subframe = !_best_subframe;
1692                                                                                 _best_bits = _candidate_bits;
1693                                                                         }
1694                                                                 }
1695                                                         }
1696                                                 }
1697                                         }
1698                                 }
1699                         }
1700                 }
1701         }
1702
1703         *best_subframe = _best_subframe;
1704         *best_bits = _best_bits;
1705
1706         return true;
1707 }
1708
1709 FLAC__bool add_subframe_(FLAC__StreamEncoder *encoder, const FLAC__FrameHeader *frame_header, unsigned subframe_bps, const FLAC__Subframe *subframe, FLAC__BitBuffer *frame)
1710 {
1711         switch(subframe->type) {
1712                 case FLAC__SUBFRAME_TYPE_CONSTANT:
1713                         if(!FLAC__subframe_add_constant(&(subframe->data.constant), subframe_bps, subframe->wasted_bits, frame)) {
1714                                 encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING;
1715                                 return false;
1716                         }
1717                         break;
1718                 case FLAC__SUBFRAME_TYPE_FIXED:
1719                         if(!FLAC__subframe_add_fixed(&(subframe->data.fixed), frame_header->blocksize - subframe->data.fixed.order, subframe_bps, subframe->wasted_bits, frame)) {
1720                                 encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING;
1721                                 return false;
1722                         }
1723                         break;
1724                 case FLAC__SUBFRAME_TYPE_LPC:
1725                         if(!FLAC__subframe_add_lpc(&(subframe->data.lpc), frame_header->blocksize - subframe->data.lpc.order, subframe_bps, subframe->wasted_bits, frame)) {
1726                                 encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING;
1727                                 return false;
1728                         }
1729                         break;
1730                 case FLAC__SUBFRAME_TYPE_VERBATIM:
1731                         if(!FLAC__subframe_add_verbatim(&(subframe->data.verbatim), frame_header->blocksize, subframe_bps, subframe->wasted_bits, frame)) {
1732                                 encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING;
1733                                 return false;
1734                         }
1735                         break;
1736                 default:
1737                         FLAC__ASSERT(0);
1738         }
1739
1740         return true;
1741 }
1742
1743 unsigned evaluate_constant_subframe_(const FLAC__int32 signal, unsigned subframe_bps, FLAC__Subframe *subframe)
1744 {
1745         subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT;
1746         subframe->data.constant.value = signal;
1747
1748         return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe_bps;
1749 }
1750
1751 unsigned evaluate_fixed_subframe_(FLAC__StreamEncoder *encoder, const FLAC__int32 signal[], FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint64 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned blocksize, unsigned subframe_bps, unsigned order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, FLAC__bool precompute_partition_sums, FLAC__bool do_escape_coding, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice)
1752 {
1753         unsigned i, residual_bits;
1754         const unsigned residual_samples = blocksize - order;
1755
1756         FLAC__fixed_compute_residual(signal+order, residual_samples, order, residual);
1757
1758         subframe->type = FLAC__SUBFRAME_TYPE_FIXED;
1759
1760         subframe->data.fixed.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
1761         subframe->data.fixed.residual = residual;
1762
1763         residual_bits = find_best_partition_order_(encoder->private_, residual, abs_residual, abs_residual_partition_sums, raw_bits_per_partition, residual_samples, order, rice_parameter, min_partition_order, max_partition_order, precompute_partition_sums, do_escape_coding, rice_parameter_search_dist, partitioned_rice);
1764
1765         subframe->data.fixed.entropy_coding_method.data.partitioned_rice = *partitioned_rice;
1766
1767         subframe->data.fixed.order = order;
1768         for(i = 0; i < order; i++)
1769                 subframe->data.fixed.warmup[i] = signal[i];
1770
1771         return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + (order * subframe_bps) + residual_bits;
1772 }
1773
1774 unsigned evaluate_lpc_subframe_(FLAC__StreamEncoder *encoder, const FLAC__int32 signal[], FLAC__int32 residual[], FLAC__uint32 abs_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 min_partition_order, unsigned max_partition_order, FLAC__bool precompute_partition_sums, FLAC__bool do_escape_coding, unsigned rice_parameter_search_dist, FLAC__Subframe *subframe, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice)
1775 {
1776         FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER];
1777         unsigned i, residual_bits;
1778         int quantization, ret;
1779         const unsigned residual_samples = blocksize - order;
1780
1781         ret = FLAC__lpc_quantize_coefficients(lp_coeff, order, qlp_coeff_precision, subframe_bps, qlp_coeff, &quantization);
1782         if(ret != 0)
1783                 return 0; /* this is a hack to indicate to the caller that we can't do lp at this order on this subframe */
1784
1785         if(subframe_bps <= 16 && qlp_coeff_precision <= 16)
1786                 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
1787         else
1788                 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
1789
1790         subframe->type = FLAC__SUBFRAME_TYPE_LPC;
1791
1792         subframe->data.lpc.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
1793         subframe->data.lpc.residual = residual;
1794
1795         residual_bits = find_best_partition_order_(encoder->private_, residual, abs_residual, abs_residual_partition_sums, raw_bits_per_partition, residual_samples, order, rice_parameter, min_partition_order, max_partition_order, precompute_partition_sums, do_escape_coding, rice_parameter_search_dist, partitioned_rice);
1796
1797         subframe->data.fixed.entropy_coding_method.data.partitioned_rice = *partitioned_rice;
1798
1799         subframe->data.lpc.order = order;
1800         subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision;
1801         subframe->data.lpc.quantization_level = quantization;
1802         memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(FLAC__int32)*FLAC__MAX_LPC_ORDER);
1803         for(i = 0; i < order; i++)
1804                 subframe->data.lpc.warmup[i] = signal[i];
1805
1806         return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN + FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN + (order * (qlp_coeff_precision + subframe_bps)) + residual_bits;
1807 }
1808
1809 unsigned evaluate_verbatim_subframe_(const FLAC__int32 signal[], unsigned blocksize, unsigned subframe_bps, FLAC__Subframe *subframe)
1810 {
1811         subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM;
1812
1813         subframe->data.verbatim.data = signal;
1814
1815         return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + (blocksize * subframe_bps);
1816 }
1817
1818 unsigned find_best_partition_order_(FLAC__StreamEncoderPrivate *private_, const FLAC__int32 residual[], FLAC__uint32 abs_residual[], FLAC__uint64 abs_residual_partition_sums[], unsigned raw_bits_per_partition[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned min_partition_order, unsigned max_partition_order, FLAC__bool precompute_partition_sums, FLAC__bool do_escape_coding, unsigned rice_parameter_search_dist, FLAC__EntropyCodingMethod_PartitionedRice *best_partitioned_rice)
1819 {
1820         FLAC__int32 r;
1821         unsigned residual_bits, best_residual_bits = 0;
1822         unsigned residual_sample;
1823         unsigned best_parameters_index = 0;
1824         const unsigned blocksize = residual_samples + predictor_order;
1825
1826         /* compute abs(residual) for use later */
1827         for(residual_sample = 0; residual_sample < residual_samples; residual_sample++) {
1828                 r = residual[residual_sample];
1829                 abs_residual[residual_sample] = (FLAC__uint32)(r<0? -r : r);
1830         }
1831
1832         max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(max_partition_order, blocksize, predictor_order);
1833         min_partition_order = min(min_partition_order, max_partition_order);
1834
1835         if(precompute_partition_sums) {
1836                 int partition_order;
1837                 unsigned sum;
1838
1839                 precompute_partition_info_sums_(abs_residual, abs_residual_partition_sums, residual_samples, predictor_order, min_partition_order, max_partition_order);
1840
1841                 if(do_escape_coding)
1842                         precompute_partition_info_escapes_(residual, raw_bits_per_partition, residual_samples, predictor_order, min_partition_order, max_partition_order);
1843
1844                 for(partition_order = (int)max_partition_order, sum = 0; partition_order >= (int)min_partition_order; partition_order--) {
1845 #ifdef DONT_ESTIMATE_RICE_BITS
1846                         if(!set_partitioned_rice_with_precompute_(residual, abs_residual_partition_sums+sum, raw_bits_per_partition+sum, residual_samples, predictor_order, rice_parameter, rice_parameter_search_dist, (unsigned)partition_order, do_escape_coding, &private_->partitioned_rice_extra[!best_parameters_index], &residual_bits))
1847 #else
1848                         if(!set_partitioned_rice_with_precompute_(abs_residual, abs_residual_partition_sums+sum, raw_bits_per_partition+sum, residual_samples, predictor_order, rice_parameter, rice_parameter_search_dist, (unsigned)partition_order, do_escape_coding, &private_->partitioned_rice_extra[!best_parameters_index], &residual_bits))
1849 #endif
1850                         {
1851                                 FLAC__ASSERT(best_residual_bits != 0);
1852                                 break;
1853                         }
1854                         sum += 1u << partition_order;
1855                         if(best_residual_bits == 0 || residual_bits < best_residual_bits) {
1856                                 best_residual_bits = residual_bits;
1857                                 best_parameters_index = !best_parameters_index;
1858                                 best_partitioned_rice->order = partition_order;
1859                         }
1860                 }
1861         }
1862         else {
1863                 unsigned partition_order;
1864                 for(partition_order = min_partition_order; partition_order <= max_partition_order; partition_order++) {
1865 #ifdef DONT_ESTIMATE_RICE_BITS
1866                         if(!set_partitioned_rice_(abs_residual, residual, residual_samples, predictor_order, rice_parameter, rice_parameter_search_dist, partition_order, &private_->partitioned_rice_extra[!best_parameters_index], &residual_bits))
1867 #else
1868                         if(!set_partitioned_rice_(abs_residual, residual_samples, predictor_order, rice_parameter, rice_parameter_search_dist, partition_order, &private_->partitioned_rice_extra[!best_parameters_index], &residual_bits))
1869 #endif
1870                         {
1871                                 FLAC__ASSERT(best_residual_bits != 0);
1872                                 break;
1873                         }
1874                         if(best_residual_bits == 0 || residual_bits < best_residual_bits) {
1875                                 best_residual_bits = residual_bits;
1876                                 best_parameters_index = !best_parameters_index;
1877                                 best_partitioned_rice->order = partition_order;
1878                         }
1879                 }
1880         }
1881
1882         FLAC__format_entropy_coding_method_partitioned_rice_ensure_size(best_partitioned_rice, max(6, best_partitioned_rice->order));
1883         memcpy(best_partitioned_rice->parameters, private_->partitioned_rice_extra[best_parameters_index].parameters, sizeof(unsigned)*(1<<(best_partitioned_rice->order)));
1884         memcpy(best_partitioned_rice->raw_bits, private_->partitioned_rice_extra[best_parameters_index].raw_bits, sizeof(unsigned)*(1<<(best_partitioned_rice->order)));
1885
1886         return best_residual_bits;
1887 }
1888
1889 void precompute_partition_info_sums_(const FLAC__uint32 abs_residual[], FLAC__uint64 abs_residual_partition_sums[], unsigned residual_samples, unsigned predictor_order, unsigned min_partition_order, unsigned max_partition_order)
1890 {
1891         int partition_order;
1892         unsigned from_partition, to_partition = 0;
1893         const unsigned blocksize = residual_samples + predictor_order;
1894
1895         /* first do max_partition_order */
1896         for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) {
1897                 FLAC__uint64 abs_residual_partition_sum;
1898                 FLAC__uint32 abs_r;
1899                 unsigned partition, partition_sample, partition_samples, residual_sample;
1900                 const unsigned partitions = 1u << partition_order;
1901                 const unsigned default_partition_samples = blocksize >> partition_order;
1902
1903                 FLAC__ASSERT(default_partition_samples > predictor_order);
1904
1905                 for(partition = residual_sample = 0; partition < partitions; partition++) {
1906                         partition_samples = default_partition_samples;
1907                         if(partition == 0)
1908                                 partition_samples -= predictor_order;
1909                         abs_residual_partition_sum = 0;
1910                         for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) {
1911                                 abs_r = abs_residual[residual_sample];
1912                                 abs_residual_partition_sum += abs_r;
1913                                 residual_sample++;
1914                         }
1915                         abs_residual_partition_sums[partition] = abs_residual_partition_sum;
1916                 }
1917                 to_partition = partitions;
1918                 break;
1919         }
1920
1921         /* now merge partitions for lower orders */
1922         for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) {
1923                 FLAC__uint64 s;
1924                 unsigned i;
1925                 const unsigned partitions = 1u << partition_order;
1926                 for(i = 0; i < partitions; i++) {
1927                         s = abs_residual_partition_sums[from_partition];
1928                         from_partition++;
1929                         abs_residual_partition_sums[to_partition] = s + abs_residual_partition_sums[from_partition];
1930                         from_partition++;
1931                         to_partition++;
1932                 }
1933         }
1934 }
1935
1936 void 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)
1937 {
1938         int partition_order;
1939         unsigned from_partition, to_partition = 0;
1940         const unsigned blocksize = residual_samples + predictor_order;
1941
1942         /* first do max_partition_order */
1943         for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) {
1944                 FLAC__int32 r, residual_partition_min, residual_partition_max;
1945                 unsigned silog2_min, silog2_max;
1946                 unsigned partition, partition_sample, partition_samples, residual_sample;
1947                 const unsigned partitions = 1u << partition_order;
1948                 const unsigned default_partition_samples = blocksize >> partition_order;
1949
1950                 FLAC__ASSERT(default_partition_samples > predictor_order);
1951
1952                 for(partition = residual_sample = 0; partition < partitions; partition++) {
1953                         partition_samples = default_partition_samples;
1954                         if(partition == 0)
1955                                 partition_samples -= predictor_order;
1956                         residual_partition_min = residual_partition_max = 0;
1957                         for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) {
1958                                 r = residual[residual_sample];
1959                                 if(r < residual_partition_min)
1960                                         residual_partition_min = r;
1961                                 else if(r > residual_partition_max)
1962                                         residual_partition_max = r;
1963                                 residual_sample++;
1964                         }
1965                         silog2_min = FLAC__bitmath_silog2(residual_partition_min);
1966                         silog2_max = FLAC__bitmath_silog2(residual_partition_max);
1967                         raw_bits_per_partition[partition] = max(silog2_min, silog2_max);
1968                 }
1969                 to_partition = partitions;
1970                 break;
1971         }
1972
1973         /* now merge partitions for lower orders */
1974         for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) {
1975                 unsigned m;
1976                 unsigned i;
1977                 const unsigned partitions = 1u << partition_order;
1978                 for(i = 0; i < partitions; i++) {
1979                         m = raw_bits_per_partition[from_partition];
1980                         from_partition++;
1981                         raw_bits_per_partition[to_partition] = max(m, raw_bits_per_partition[from_partition]);
1982                         from_partition++;
1983                         to_partition++;
1984                 }
1985         }
1986 }
1987
1988 #ifdef VARIABLE_RICE_BITS
1989 #undef VARIABLE_RICE_BITS
1990 #endif
1991 #ifndef DONT_ESTIMATE_RICE_BITS
1992 #define VARIABLE_RICE_BITS(value, parameter) ((value) >> (parameter))
1993 #endif
1994
1995 #ifdef DONT_ESTIMATE_RICE_BITS
1996 FLAC__bool set_partitioned_rice_(const FLAC__uint32 abs_residual[], const FLAC__int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned suggested_rice_parameter, const unsigned rice_parameter_search_dist, const unsigned partition_order, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice, unsigned *bits)
1997 #else
1998 FLAC__bool set_partitioned_rice_(const FLAC__uint32 abs_residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned suggested_rice_parameter, const unsigned rice_parameter_search_dist, const unsigned partition_order, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice, unsigned *bits)
1999 #endif
2000 {
2001         unsigned rice_parameter, partition_bits;
2002 #ifndef NO_RICE_SEARCH
2003         unsigned best_partition_bits;
2004         unsigned min_rice_parameter, max_rice_parameter, best_rice_parameter = 0;
2005 #endif
2006         unsigned bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN;
2007         unsigned *parameters;
2008
2009         FLAC__ASSERT(suggested_rice_parameter < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER);
2010
2011         partitioned_rice->order = partition_order;
2012         FLAC__format_entropy_coding_method_partitioned_rice_ensure_size(partitioned_rice, max(6, partition_order));
2013         parameters = partitioned_rice->parameters;
2014
2015         if(partition_order == 0) {
2016                 unsigned i;
2017
2018 #ifndef NO_RICE_SEARCH
2019                 if(rice_parameter_search_dist) {
2020                         if(suggested_rice_parameter < rice_parameter_search_dist)
2021                                 min_rice_parameter = 0;
2022                         else
2023                                 min_rice_parameter = suggested_rice_parameter - rice_parameter_search_dist;
2024                         max_rice_parameter = suggested_rice_parameter + rice_parameter_search_dist;
2025                         if(max_rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
2026 #ifdef DEBUG_VERBOSE
2027                                 fprintf(stderr, "clipping rice_parameter (%u -> %u) @2\n", max_rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
2028 #endif
2029                                 max_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
2030                         }
2031                 }
2032                 else
2033                         min_rice_parameter = max_rice_parameter = suggested_rice_parameter;
2034
2035                 best_partition_bits = 0xffffffff;
2036                 for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) {
2037 #endif
2038 #ifdef VARIABLE_RICE_BITS
2039 #ifdef FLAC__SYMMETRIC_RICE
2040                         partition_bits = (2+rice_parameter) * residual_samples;
2041 #else
2042                         const unsigned rice_parameter_estimate = rice_parameter-1;
2043                         partition_bits = (1+rice_parameter) * residual_samples;
2044 #endif
2045 #else
2046                         partition_bits = 0;
2047 #endif
2048                         partition_bits += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN;
2049                         for(i = 0; i < residual_samples; i++) {
2050 #ifdef VARIABLE_RICE_BITS
2051 #ifdef FLAC__SYMMETRIC_RICE
2052                                 partition_bits += VARIABLE_RICE_BITS(abs_residual[i], rice_parameter);
2053 #else
2054                                 partition_bits += VARIABLE_RICE_BITS(abs_residual[i], rice_parameter_estimate);
2055 #endif
2056 #else
2057                                 partition_bits += FLAC__bitbuffer_rice_bits(residual[i], rice_parameter); /* NOTE: we will need to pass in residual[] in addition to abs_residual[] */
2058 #endif
2059                         }
2060 #ifndef NO_RICE_SEARCH
2061                         if(partition_bits < best_partition_bits) {
2062                                 best_rice_parameter = rice_parameter;
2063                                 best_partition_bits = partition_bits;
2064                         }
2065                 }
2066 #endif
2067                 parameters[0] = best_rice_parameter;
2068                 bits_ += best_partition_bits;
2069         }
2070         else {
2071                 unsigned partition, residual_sample, save_residual_sample, partition_sample;
2072                 unsigned partition_samples;
2073                 FLAC__uint64 mean, k;
2074                 const unsigned partitions = 1u << partition_order;
2075                 for(partition = residual_sample = 0; partition < partitions; partition++) {
2076                         partition_samples = (residual_samples+predictor_order) >> partition_order;
2077                         if(partition == 0) {
2078                                 if(partition_samples <= predictor_order)
2079                                         return false;
2080                                 else
2081                                         partition_samples -= predictor_order;
2082                         }
2083                         mean = 0;
2084                         save_residual_sample = residual_sample;
2085                         for(partition_sample = 0; partition_sample < partition_samples; residual_sample++, partition_sample++)
2086                                 mean += abs_residual[residual_sample];
2087                         residual_sample = save_residual_sample;
2088 #ifdef FLAC__SYMMETRIC_RICE
2089                         mean += partition_samples >> 1; /* for rounding effect */
2090                         mean /= partition_samples;
2091
2092                         /* calc rice_parameter = floor(log2(mean)) */
2093                         rice_parameter = 0;
2094                         mean>>=1;
2095                         while(mean) {
2096                                 rice_parameter++;
2097                                 mean >>= 1;
2098                         }
2099 #else
2100                         /* calc rice_parameter ala LOCO-I */
2101                         for(rice_parameter = 0, k = partition_samples; k < mean; rice_parameter++, k <<= 1)
2102                                 ;
2103 #endif
2104                         if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
2105 #ifdef DEBUG_VERBOSE
2106                                 fprintf(stderr, "clipping rice_parameter (%u -> %u) @3\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
2107 #endif
2108                                 rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
2109                         }
2110
2111 #ifndef NO_RICE_SEARCH
2112                         if(rice_parameter_search_dist) {
2113                                 if(rice_parameter < rice_parameter_search_dist)
2114                                         min_rice_parameter = 0;
2115                                 else
2116                                         min_rice_parameter = rice_parameter - rice_parameter_search_dist;
2117                                 max_rice_parameter = rice_parameter + rice_parameter_search_dist;
2118                                 if(max_rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
2119 #ifdef DEBUG_VERBOSE
2120                                         fprintf(stderr, "clipping rice_parameter (%u -> %u) @4\n", max_rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
2121 #endif
2122                                         max_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
2123                                 }
2124                         }
2125                         else
2126                                 min_rice_parameter = max_rice_parameter = rice_parameter;
2127
2128                         best_partition_bits = 0xffffffff;
2129                         for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) {
2130 #endif
2131 #ifdef VARIABLE_RICE_BITS
2132 #ifdef FLAC__SYMMETRIC_RICE
2133                                 partition_bits = (2+rice_parameter) * partition_samples;
2134 #else
2135                                 const unsigned rice_parameter_estimate = rice_parameter-1;
2136                                 partition_bits = (1+rice_parameter) * partition_samples;
2137 #endif
2138 #else
2139                                 partition_bits = 0;
2140 #endif
2141                                 partition_bits += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN;
2142                                 save_residual_sample = residual_sample;
2143                                 for(partition_sample = 0; partition_sample < partition_samples; residual_sample++, partition_sample++) {
2144 #ifdef VARIABLE_RICE_BITS
2145 #ifdef FLAC__SYMMETRIC_RICE
2146                                         partition_bits += VARIABLE_RICE_BITS(abs_residual[residual_sample], rice_parameter);
2147 #else
2148                                         partition_bits += VARIABLE_RICE_BITS(abs_residual[residual_sample], rice_parameter_estimate);
2149 #endif
2150 #else
2151                                         partition_bits += FLAC__bitbuffer_rice_bits(residual[residual_sample], rice_parameter); /* NOTE: we will need to pass in residual[] in addition to abs_residual[] */
2152 #endif
2153                                 }
2154 #ifndef NO_RICE_SEARCH
2155                                 if(rice_parameter != max_rice_parameter)
2156                                         residual_sample = save_residual_sample;
2157                                 if(partition_bits < best_partition_bits) {
2158                                         best_rice_parameter = rice_parameter;
2159                                         best_partition_bits = partition_bits;
2160                                 }
2161                         }
2162 #endif
2163                         parameters[partition] = best_rice_parameter;
2164                         bits_ += best_partition_bits;
2165                 }
2166         }
2167
2168         *bits = bits_;
2169         return true;
2170 }
2171
2172 #ifdef DONT_ESTIMATE_RICE_BITS
2173 FLAC__bool set_partitioned_rice_with_precompute_(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_search_dist, const unsigned partition_order, const FLAC__bool search_for_escapes, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice, unsigned *bits)
2174 #else
2175 FLAC__bool set_partitioned_rice_with_precompute_(const FLAC__uint32 abs_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_search_dist, const unsigned partition_order, const FLAC__bool search_for_escapes, FLAC__EntropyCodingMethod_PartitionedRice *partitioned_rice, unsigned *bits)
2176 #endif
2177 {
2178         unsigned rice_parameter, partition_bits;
2179 #ifndef NO_RICE_SEARCH
2180         unsigned best_partition_bits;
2181         unsigned min_rice_parameter, max_rice_parameter, best_rice_parameter = 0;
2182 #endif
2183         unsigned flat_bits;
2184         unsigned bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN;
2185         unsigned *parameters, *raw_bits;
2186
2187         FLAC__ASSERT(suggested_rice_parameter < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER);
2188
2189         partitioned_rice->order = partition_order;
2190         FLAC__format_entropy_coding_method_partitioned_rice_ensure_size(partitioned_rice, max(6, partition_order));
2191         parameters = partitioned_rice->parameters;
2192         raw_bits = partitioned_rice->raw_bits;
2193
2194         if(partition_order == 0) {
2195                 unsigned i;
2196
2197 #ifndef NO_RICE_SEARCH
2198                 if(rice_parameter_search_dist) {
2199                         if(suggested_rice_parameter < rice_parameter_search_dist)
2200                                 min_rice_parameter = 0;
2201                         else
2202                                 min_rice_parameter = suggested_rice_parameter - rice_parameter_search_dist;
2203                         max_rice_parameter = suggested_rice_parameter + rice_parameter_search_dist;
2204                         if(max_rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
2205 #ifdef DEBUG_VERBOSE
2206                                 fprintf(stderr, "clipping rice_parameter (%u -> %u) @5\n", max_rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
2207 #endif
2208                                 max_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
2209                         }
2210                 }
2211                 else
2212                         min_rice_parameter = max_rice_parameter = suggested_rice_parameter;
2213
2214                 best_partition_bits = 0xffffffff;
2215                 for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) {
2216 #endif
2217 #ifdef VARIABLE_RICE_BITS
2218 #ifdef FLAC__SYMMETRIC_RICE
2219                         partition_bits = (2+rice_parameter) * residual_samples;
2220 #else
2221                         const unsigned rice_parameter_estimate = rice_parameter-1;
2222                         partition_bits = (1+rice_parameter) * residual_samples;
2223 #endif
2224 #else
2225                         partition_bits = 0;
2226 #endif
2227                         partition_bits += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN;
2228                         for(i = 0; i < residual_samples; i++) {
2229 #ifdef VARIABLE_RICE_BITS
2230 #ifdef FLAC__SYMMETRIC_RICE
2231                                 partition_bits += VARIABLE_RICE_BITS(abs_residual[i], rice_parameter);
2232 #else
2233                                 partition_bits += VARIABLE_RICE_BITS(abs_residual[i], rice_parameter_estimate);
2234 #endif
2235 #else
2236                                 partition_bits += FLAC__bitbuffer_rice_bits(residual[i], rice_parameter); /* NOTE: we will need to pass in residual[] instead of abs_residual[] */
2237 #endif
2238                         }
2239 #ifndef NO_RICE_SEARCH
2240                         if(partition_bits < best_partition_bits) {
2241                                 best_rice_parameter = rice_parameter;
2242                                 best_partition_bits = partition_bits;
2243                         }
2244                 }
2245 #endif
2246                 if(search_for_escapes) {
2247                         flat_bits = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN + raw_bits_per_partition[0] * residual_samples;
2248                         if(flat_bits <= best_partition_bits) {
2249                                 raw_bits[0] = raw_bits_per_partition[0];
2250                                 best_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER;
2251                                 best_partition_bits = flat_bits;
2252                         }
2253                 }
2254                 parameters[0] = best_rice_parameter;
2255                 bits_ += best_partition_bits;
2256         }
2257         else {
2258                 unsigned partition, residual_sample, save_residual_sample, partition_sample;
2259                 unsigned partition_samples;
2260                 FLAC__uint64 mean, k;
2261                 const unsigned partitions = 1u << partition_order;
2262                 for(partition = residual_sample = 0; partition < partitions; partition++) {
2263                         partition_samples = (residual_samples+predictor_order) >> partition_order;
2264                         if(partition == 0) {
2265                                 if(partition_samples <= predictor_order)
2266                                         return false;
2267                                 else
2268                                         partition_samples -= predictor_order;
2269                         }
2270                         mean = abs_residual_partition_sums[partition];
2271 #ifdef FLAC__SYMMETRIC_RICE
2272                         mean += partition_samples >> 1; /* for rounding effect */
2273                         mean /= partition_samples;
2274
2275                         /* calc rice_parameter = floor(log2(mean)) */
2276                         rice_parameter = 0;
2277                         mean>>=1;
2278                         while(mean) {
2279                                 rice_parameter++;
2280                                 mean >>= 1;
2281                         }
2282 #else
2283                         /* calc rice_parameter ala LOCO-I */
2284                         for(rice_parameter = 0, k = partition_samples; k < mean; rice_parameter++, k <<= 1)
2285                                 ;
2286 #endif
2287                         if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
2288 #ifdef DEBUG_VERBOSE
2289                                 fprintf(stderr, "clipping rice_parameter (%u -> %u) @6\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
2290 #endif
2291                                 rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
2292                         }
2293
2294 #ifndef NO_RICE_SEARCH
2295                         if(rice_parameter_search_dist) {
2296                                 if(rice_parameter < rice_parameter_search_dist)
2297                                         min_rice_parameter = 0;
2298                                 else
2299                                         min_rice_parameter = rice_parameter - rice_parameter_search_dist;
2300                                 max_rice_parameter = rice_parameter + rice_parameter_search_dist;
2301                                 if(max_rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
2302 #ifdef DEBUG_VERBOSE
2303                                         fprintf(stderr, "clipping rice_parameter (%u -> %u) @7\n", max_rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
2304 #endif
2305                                         max_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
2306                                 }
2307                         }
2308                         else
2309                                 min_rice_parameter = max_rice_parameter = rice_parameter;
2310
2311                         best_partition_bits = 0xffffffff;
2312                         for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) {
2313 #endif
2314 #ifdef VARIABLE_RICE_BITS
2315 #ifdef FLAC__SYMMETRIC_RICE
2316                                 partition_bits = (2+rice_parameter) * partition_samples;
2317 #else
2318                                 const unsigned rice_parameter_estimate = rice_parameter-1;
2319                                 partition_bits = (1+rice_parameter) * partition_samples;
2320 #endif
2321 #else
2322                                 partition_bits = 0;
2323 #endif
2324                                 partition_bits += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN;
2325                                 save_residual_sample = residual_sample;
2326                                 for(partition_sample = 0; partition_sample < partition_samples; residual_sample++, partition_sample++) {
2327 #ifdef VARIABLE_RICE_BITS
2328 #ifdef FLAC__SYMMETRIC_RICE
2329                                         partition_bits += VARIABLE_RICE_BITS(abs_residual[residual_sample], rice_parameter);
2330 #else
2331                                         partition_bits += VARIABLE_RICE_BITS(abs_residual[residual_sample], rice_parameter_estimate);
2332 #endif
2333 #else
2334                                         partition_bits += FLAC__bitbuffer_rice_bits(residual[residual_sample], rice_parameter); /* NOTE: we will need to pass in residual[] instead of abs_residual[] */
2335 #endif
2336                                 }
2337 #ifndef NO_RICE_SEARCH
2338                                 if(rice_parameter != max_rice_parameter)
2339                                         residual_sample = save_residual_sample;
2340                                 if(partition_bits < best_partition_bits) {
2341                                         best_rice_parameter = rice_parameter;
2342                                         best_partition_bits = partition_bits;
2343                                 }
2344                         }
2345 #endif
2346                         if(search_for_escapes) {
2347                                 flat_bits = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN + raw_bits_per_partition[partition] * partition_samples;
2348                                 if(flat_bits <= best_partition_bits) {
2349                                         raw_bits[partition] = raw_bits_per_partition[partition];
2350                                         best_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER;
2351                                         best_partition_bits = flat_bits;
2352                                 }
2353                         }
2354                         parameters[partition] = best_rice_parameter;
2355                         bits_ += best_partition_bits;
2356                 }
2357         }
2358
2359         *bits = bits_;
2360         return true;
2361 }
2362
2363 unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples)
2364 {
2365         unsigned i, shift;
2366         FLAC__int32 x = 0;
2367
2368         for(i = 0; i < samples && !(x&1); i++)
2369                 x |= signal[i];
2370
2371         if(x == 0) {
2372                 shift = 0;
2373         }
2374         else {
2375                 for(shift = 0; !(x&1); shift++)
2376                         x >>= 1;
2377         }
2378
2379         if(shift > 0) {
2380                 for(i = 0; i < samples; i++)
2381                          signal[i] >>= shift;
2382         }
2383
2384         return shift;
2385 }
2386
2387 void append_to_verify_fifo_(verify_input_fifo *fifo, const FLAC__int32 * const input[], unsigned input_offset, unsigned channels, unsigned wide_samples)
2388 {
2389         unsigned channel;
2390
2391         for(channel = 0; channel < channels; channel++)
2392                 memcpy(&fifo->data[channel][fifo->tail], &input[channel][input_offset], sizeof(FLAC__int32) * wide_samples);
2393
2394         fifo->tail += wide_samples;
2395
2396         FLAC__ASSERT(fifo->tail <= fifo->size);
2397 }
2398
2399 void append_to_verify_fifo_interleaved_(verify_input_fifo *fifo, const FLAC__int32 input[], unsigned input_offset, unsigned channels, unsigned wide_samples)
2400 {
2401         unsigned channel;
2402         unsigned sample, wide_sample;
2403         unsigned tail = fifo->tail;
2404
2405         sample = input_offset * channels;
2406         for(wide_sample = 0; wide_sample < wide_samples; wide_sample++) {
2407                 for(channel = 0; channel < channels; channel++)
2408                         fifo->data[channel][tail] = input[sample++];
2409                 tail++;
2410         }
2411         fifo->tail = tail;
2412
2413         FLAC__ASSERT(fifo->tail <= fifo->size);
2414 }
2415
2416 FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
2417 {
2418         FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
2419         const unsigned encoded_bytes = encoder->private_->verify.output.bytes;
2420         (void)decoder;
2421
2422         if(encoder->private_->verify.needs_magic_hack) {
2423                 FLAC__ASSERT(*bytes >= FLAC__STREAM_SYNC_LENGTH);
2424                 *bytes = FLAC__STREAM_SYNC_LENGTH;
2425                 memcpy(buffer, FLAC__STREAM_SYNC_STRING, *bytes);
2426                 encoder->private_->verify.needs_magic_hack = false;
2427         }
2428         else {
2429                 if(encoded_bytes == 0) {
2430                         /*
2431                          * If we get here, a FIFO underflow has occurred,
2432                          * which means there is a bug somewhere.
2433                          */
2434                         FLAC__ASSERT(0);
2435                         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
2436                 }
2437                 else if(encoded_bytes < *bytes)
2438                         *bytes = encoded_bytes;
2439                 memcpy(buffer, encoder->private_->verify.output.data, *bytes);
2440                 encoder->private_->verify.output.data += *bytes;
2441                 encoder->private_->verify.output.bytes -= *bytes;
2442         }
2443
2444         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
2445 }
2446
2447 FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
2448 {
2449         FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder *)client_data;
2450         unsigned channel;
2451         const unsigned channels = FLAC__stream_decoder_get_channels(decoder);
2452         const unsigned blocksize = frame->header.blocksize;
2453         const unsigned bytes_per_block = sizeof(FLAC__int32) * blocksize;
2454
2455         for(channel = 0; channel < channels; channel++) {
2456                 if(0 != memcmp(buffer[channel], encoder->private_->verify.input_fifo.data[channel], bytes_per_block)) {
2457                         unsigned i, sample = 0;
2458                         FLAC__int32 expect = 0, got = 0;
2459
2460                         for(i = 0; i < blocksize; i++) {
2461                                 if(buffer[channel][i] != encoder->private_->verify.input_fifo.data[channel][i]) {
2462                                         sample = i;
2463                                         expect = (FLAC__int32)encoder->private_->verify.input_fifo.data[channel][i];
2464                                         got = (FLAC__int32)buffer[channel][i];
2465                                         break;
2466                                 }
2467                         }
2468                         FLAC__ASSERT(i < blocksize);
2469                         FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
2470                         encoder->private_->verify.error_stats.absolute_sample = frame->header.number.sample_number + sample;
2471                         encoder->private_->verify.error_stats.frame_number = frame->header.number.sample_number / blocksize;
2472                         encoder->private_->verify.error_stats.channel = channel;
2473                         encoder->private_->verify.error_stats.sample = sample;
2474                         encoder->private_->verify.error_stats.expected = expect;
2475                         encoder->private_->verify.error_stats.got = got;
2476                         encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA;
2477                         return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
2478                 }
2479         }
2480         /* dequeue the frame from the fifo */
2481         for(channel = 0; channel < channels; channel++) {
2482                 memmove(&encoder->private_->verify.input_fifo.data[channel][0], &encoder->private_->verify.input_fifo.data[channel][blocksize], encoder->private_->verify.input_fifo.tail - blocksize);
2483         }
2484         encoder->private_->verify.input_fifo.tail -= blocksize;
2485         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
2486 }
2487
2488 void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
2489 {
2490         (void)decoder, (void)metadata, (void)client_data;
2491 }
2492
2493 void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
2494 {
2495         FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
2496         (void)decoder, (void)status;
2497         encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
2498 }