merge down from merged-API-layer branch: cvs -q up -dP -j API_LAYER_MERGING_BASELINE...
[flac.git] / src / libFLAC / stream_encoder.c
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2000,2001,2002,2003,2004,2005,2006  Josh Coalson
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * - Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *
11  * - Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditions and the following disclaimer in the
13  * documentation and/or other materials provided with the distribution.
14  *
15  * - Neither the name of the Xiph.org Foundation nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 /*@@@@@@*/
33 #undef WINDOW_DEBUG_OUTPUT
34
35 #if HAVE_CONFIG_H
36 #  include <config.h>
37 #endif
38
39 #if defined _MSC_VER || defined __MINGW32__
40 #include <io.h> /* for _setmode() */
41 #include <fcntl.h> /* for _O_BINARY */
42 #endif
43 #if defined __CYGWIN__ || defined __EMX__
44 #include <io.h> /* for setmode(), O_BINARY */
45 #include <fcntl.h> /* for _O_BINARY */
46 #endif
47 #include <limits.h>
48 #include <stdio.h>
49 #include <stdlib.h> /* for malloc() */
50 #include <string.h> /* for memcpy() */
51 #include <sys/types.h> /* for off_t */
52 #if defined _MSC_VER || defined __MINGW32__
53 /*@@@ [2G limit] hacks for MSVC6 */
54 #define fseeko fseek
55 #define ftello ftell
56 #endif
57 #include "FLAC/assert.h"
58 #include "FLAC/stream_decoder.h"
59 #include "protected/stream_encoder.h"
60 #include "private/bitbuffer.h"
61 #include "private/bitmath.h"
62 #include "private/crc.h"
63 #include "private/cpu.h"
64 #include "private/fixed.h"
65 #include "private/format.h"
66 #include "private/lpc.h"
67 #include "private/md5.h"
68 #include "private/memory.h"
69 #include "private/stream_encoder_framing.h"
70 #include "private/window.h"
71
72 #ifdef min
73 #undef min
74 #endif
75 #define min(x,y) ((x)<(y)?(x):(y))
76
77 #ifdef max
78 #undef max
79 #endif
80 #define max(x,y) ((x)>(y)?(x):(y))
81
82 typedef struct {
83         FLAC__int32 *data[FLAC__MAX_CHANNELS];
84         unsigned size; /* of each data[] in samples */
85         unsigned tail;
86 } verify_input_fifo;
87
88 typedef struct {
89         const FLAC__byte *data;
90         unsigned capacity;
91         unsigned bytes;
92 } verify_output;
93
94 typedef enum {
95         ENCODER_IN_MAGIC = 0,
96         ENCODER_IN_METADATA = 1,
97         ENCODER_IN_AUDIO = 2
98 } EncoderStateHint;
99
100 /***********************************************************************
101  *
102  * Private class method prototypes
103  *
104  ***********************************************************************/
105
106 static void set_defaults_(FLAC__StreamEncoder *encoder);
107 static void free_(FLAC__StreamEncoder *encoder);
108 static FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size);
109 static FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples);
110 static FLAC__StreamEncoderWriteStatus write_frame_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples);
111 static void update_metadata_(const FLAC__StreamEncoder *encoder);
112 static FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame);
113 static FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame);
114
115 static FLAC__bool process_subframe_(
116         FLAC__StreamEncoder *encoder,
117         unsigned min_partition_order,
118         unsigned max_partition_order,
119         FLAC__bool precompute_partition_sums,
120         const FLAC__FrameHeader *frame_header,
121         unsigned subframe_bps,
122         const FLAC__int32 integer_signal[],
123 #ifndef FLAC__INTEGER_ONLY_LIBRARY
124         const FLAC__real real_signal[],
125 #endif
126         FLAC__Subframe *subframe[2],
127         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2],
128         FLAC__int32 *residual[2],
129         unsigned *best_subframe,
130         unsigned *best_bits
131 #ifdef WINDOW_DEBUG_OUTPUT
132         ,unsigned subframe_number
133 #endif
134 );
135
136 static FLAC__bool add_subframe_(
137         FLAC__StreamEncoder *encoder,
138         const FLAC__FrameHeader *frame_header,
139         unsigned subframe_bps,
140         const FLAC__Subframe *subframe,
141         FLAC__BitBuffer *frame
142 #ifdef WINDOW_DEBUG_OUTPUT
143 ,unsigned subframe_bits
144 #endif
145 );
146
147 static unsigned evaluate_constant_subframe_(
148         const FLAC__int32 signal,
149         unsigned subframe_bps,
150         FLAC__Subframe *subframe
151 );
152
153 static unsigned evaluate_fixed_subframe_(
154         FLAC__StreamEncoder *encoder,
155         const FLAC__int32 signal[],
156         FLAC__int32 residual[],
157         FLAC__uint32 abs_residual[],
158         FLAC__uint64 abs_residual_partition_sums[],
159         unsigned raw_bits_per_partition[],
160         unsigned blocksize,
161         unsigned subframe_bps,
162         unsigned order,
163         unsigned rice_parameter,
164         unsigned min_partition_order,
165         unsigned max_partition_order,
166         FLAC__bool precompute_partition_sums,
167         FLAC__bool do_escape_coding,
168         unsigned rice_parameter_search_dist,
169         FLAC__Subframe *subframe,
170         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
171 );
172
173 #ifndef FLAC__INTEGER_ONLY_LIBRARY
174 static unsigned evaluate_lpc_subframe_(
175         FLAC__StreamEncoder *encoder,
176         const FLAC__int32 signal[],
177         FLAC__int32 residual[],
178         FLAC__uint32 abs_residual[],
179         FLAC__uint64 abs_residual_partition_sums[],
180         unsigned raw_bits_per_partition[],
181         const FLAC__real lp_coeff[],
182         unsigned blocksize,
183         unsigned subframe_bps,
184         unsigned order,
185         unsigned qlp_coeff_precision,
186         unsigned rice_parameter,
187         unsigned min_partition_order,
188         unsigned max_partition_order,
189         FLAC__bool precompute_partition_sums,
190         FLAC__bool do_escape_coding,
191         unsigned rice_parameter_search_dist,
192         FLAC__Subframe *subframe,
193         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
194 #ifdef WINDOW_DEBUG_OUTPUT
195         ,unsigned frame_number
196         ,unsigned subframe_number
197         ,FLAC__ApodizationSpecification aspec
198 #endif
199 );
200 #endif
201
202 static unsigned evaluate_verbatim_subframe_(
203         const FLAC__int32 signal[],
204         unsigned blocksize,
205         unsigned subframe_bps,
206         FLAC__Subframe *subframe
207 );
208
209 static unsigned find_best_partition_order_(
210         struct FLAC__StreamEncoderPrivate *private_,
211         const FLAC__int32 residual[],
212         FLAC__uint32 abs_residual[],
213         FLAC__uint64 abs_residual_partition_sums[],
214         unsigned raw_bits_per_partition[],
215         unsigned residual_samples,
216         unsigned predictor_order,
217         unsigned rice_parameter,
218         unsigned min_partition_order,
219         unsigned max_partition_order,
220         FLAC__bool precompute_partition_sums,
221         FLAC__bool do_escape_coding,
222         unsigned rice_parameter_search_dist,
223         FLAC__EntropyCodingMethod_PartitionedRice *best_partitioned_rice
224 );
225
226 static void precompute_partition_info_sums_(
227         const FLAC__uint32 abs_residual[],
228         FLAC__uint64 abs_residual_partition_sums[],
229         unsigned residual_samples,
230         unsigned predictor_order,
231         unsigned min_partition_order,
232         unsigned max_partition_order
233 );
234
235 static void precompute_partition_info_escapes_(
236         const FLAC__int32 residual[],
237         unsigned raw_bits_per_partition[],
238         unsigned residual_samples,
239         unsigned predictor_order,
240         unsigned min_partition_order,
241         unsigned max_partition_order
242 );
243
244 #ifdef DONT_ESTIMATE_RICE_BITS
245 static FLAC__bool set_partitioned_rice_(
246         const FLAC__uint32 abs_residual[],
247         const FLAC__int32 residual[],
248         const unsigned residual_samples,
249         const unsigned predictor_order,
250         const unsigned suggested_rice_parameter,
251         const unsigned rice_parameter_search_dist,
252         const unsigned partition_order,
253         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents,
254         unsigned *bits
255 );
256
257 static FLAC__bool set_partitioned_rice_with_precompute_(
258         const FLAC__int32 residual[],
259         const FLAC__uint64 abs_residual_partition_sums[],
260         const unsigned raw_bits_per_partition[],
261         const unsigned residual_samples,
262         const unsigned predictor_order,
263         const unsigned suggested_rice_parameter,
264         const unsigned rice_parameter_search_dist,
265         const unsigned partition_order,
266         const FLAC__bool search_for_escapes,
267         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents,
268         unsigned *bits
269 );
270 #else
271 static FLAC__bool set_partitioned_rice_(
272         const FLAC__uint32 abs_residual[],
273         const unsigned residual_samples,
274         const unsigned predictor_order,
275         const unsigned suggested_rice_parameter,
276         const unsigned rice_parameter_search_dist,
277         const unsigned partition_order,
278         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents,
279         unsigned *bits
280 );
281
282 static FLAC__bool set_partitioned_rice_with_precompute_(
283         const FLAC__uint32 abs_residual[],
284         const FLAC__uint64 abs_residual_partition_sums[],
285         const unsigned raw_bits_per_partition[],
286         const unsigned residual_samples,
287         const unsigned predictor_order,
288         const unsigned suggested_rice_parameter,
289         const unsigned rice_parameter_search_dist,
290         const unsigned partition_order,
291         const FLAC__bool search_for_escapes,
292         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents,
293         unsigned *bits
294 );
295 #endif
296
297 static unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples);
298
299 /* verify-related routines: */
300 static void append_to_verify_fifo_(
301         verify_input_fifo *fifo,
302         const FLAC__int32 * const input[],
303         unsigned input_offset,
304         unsigned channels,
305         unsigned wide_samples
306 );
307
308 static void append_to_verify_fifo_interleaved_(
309         verify_input_fifo *fifo,
310         const FLAC__int32 input[],
311         unsigned input_offset,
312         unsigned channels,
313         unsigned wide_samples
314 );
315
316 static FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
317 static FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
318 static void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
319 static void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
320
321 static FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data);
322 static FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
323 static FLAC__StreamEncoderWriteStatus file_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
324 static FILE *get_binary_stdout_();
325
326 #ifdef WINDOW_DEBUG_OUTPUT
327 static const char * const winstr[] = {
328         "bartlett",
329         "bartlett_hann",
330         "blackman",
331         "blackman_harris_4term_92db_sidelobe",
332         "connes",
333         "flattop",
334         "gauss",
335         "hamming",
336         "hann",
337         "kaiser_bessel",
338         "nuttall",
339         "rectangular",
340         "triangle",
341         "tukey",
342         "welch"
343 };
344 #endif
345
346 /***********************************************************************
347  *
348  * Private class data
349  *
350  ***********************************************************************/
351
352 typedef struct FLAC__StreamEncoderPrivate {
353         unsigned input_capacity;                          /* current size (in samples) of the signal and residual buffers */
354         FLAC__int32 *integer_signal[FLAC__MAX_CHANNELS];  /* the integer version of the input signal */
355         FLAC__int32 *integer_signal_mid_side[2];          /* the integer version of the mid-side input signal (stereo only) */
356 #ifndef FLAC__INTEGER_ONLY_LIBRARY
357         FLAC__real *real_signal[FLAC__MAX_CHANNELS];      /* the floating-point version of the input signal */
358         FLAC__real *real_signal_mid_side[2];              /* the floating-point version of the mid-side input signal (stereo only) */
359         FLAC__real *window[FLAC__MAX_APODIZATION_FUNCTIONS]; /* the pre-computed floating-point window for each apodization function */
360         FLAC__real *windowed_signal;                      /* the real_signal[] * current window[] */
361 #endif
362         unsigned subframe_bps[FLAC__MAX_CHANNELS];        /* the effective bits per sample of the input signal (stream bps - wasted bits) */
363         unsigned subframe_bps_mid_side[2];                /* the effective bits per sample of the mid-side input signal (stream bps - wasted bits + 0/1) */
364         FLAC__int32 *residual_workspace[FLAC__MAX_CHANNELS][2]; /* each channel has a candidate and best workspace where the subframe residual signals will be stored */
365         FLAC__int32 *residual_workspace_mid_side[2][2];
366         FLAC__Subframe subframe_workspace[FLAC__MAX_CHANNELS][2];
367         FLAC__Subframe subframe_workspace_mid_side[2][2];
368         FLAC__Subframe *subframe_workspace_ptr[FLAC__MAX_CHANNELS][2];
369         FLAC__Subframe *subframe_workspace_ptr_mid_side[2][2];
370         FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace[FLAC__MAX_CHANNELS][2];
371         FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace_mid_side[FLAC__MAX_CHANNELS][2];
372         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr[FLAC__MAX_CHANNELS][2];
373         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr_mid_side[FLAC__MAX_CHANNELS][2];
374         unsigned best_subframe[FLAC__MAX_CHANNELS];       /* index into the above workspaces */
375         unsigned best_subframe_mid_side[2];
376         unsigned best_subframe_bits[FLAC__MAX_CHANNELS];  /* size in bits of the best subframe for each channel */
377         unsigned best_subframe_bits_mid_side[2];
378         FLAC__uint32 *abs_residual;                       /* workspace where abs(candidate residual) is stored */
379         FLAC__uint64 *abs_residual_partition_sums;        /* workspace where the sum of abs(candidate residual) for each partition is stored */
380         unsigned *raw_bits_per_partition;                 /* workspace where the sum of silog2(candidate residual) for each partition is stored */
381         FLAC__BitBuffer *frame;                           /* the current frame being worked on */
382         unsigned loose_mid_side_stereo_frames;            /* rounded number of frames the encoder will use before trying both independent and mid/side frames again */
383         unsigned loose_mid_side_stereo_frame_count;       /* number of frames using the current channel assignment */
384         FLAC__ChannelAssignment last_channel_assignment;
385         FLAC__StreamMetadata streaminfo;                  /* scratchpad for STREAMINFO as it is built */
386         FLAC__StreamMetadata_SeekTable *seek_table;       /* pointer into encoder->protected_->metadata_ where the seek table is */
387         unsigned current_sample_number;
388         unsigned current_frame_number;
389         struct FLAC__MD5Context md5context;
390         FLAC__CPUInfo cpuinfo;
391 #ifndef FLAC__INTEGER_ONLY_LIBRARY
392         unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, FLAC__float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
393 #else
394         unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
395 #endif
396 #ifndef FLAC__INTEGER_ONLY_LIBRARY
397         void (*local_lpc_compute_autocorrelation)(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]);
398         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[]);
399         void (*local_lpc_compute_residual_from_qlp_coefficients_64bit)(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
400         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[]);
401 #endif
402         FLAC__bool use_wide_by_block;          /* use slow 64-bit versions of some functions because of the block size */
403         FLAC__bool use_wide_by_partition;      /* use slow 64-bit versions of some functions because of the min partition order and blocksize */
404         FLAC__bool use_wide_by_order;          /* use slow 64-bit versions of some functions because of the lpc order */
405         FLAC__bool precompute_partition_sums;  /* our initial guess as to whether precomputing the partitions sums will be a speed improvement */
406         FLAC__bool disable_constant_subframes;
407         FLAC__bool disable_fixed_subframes;
408         FLAC__bool disable_verbatim_subframes;
409         FLAC__StreamEncoderSeekCallback seek_callback;
410         FLAC__StreamEncoderTellCallback tell_callback;
411         FLAC__StreamEncoderWriteCallback write_callback;
412         FLAC__StreamEncoderMetadataCallback metadata_callback;
413         FLAC__StreamEncoderProgressCallback progress_callback;
414         void *client_data;
415         unsigned first_seekpoint_to_check;
416         FILE *file;                            /* only used when encoding to a file */
417         FLAC__uint64 bytes_written;
418         FLAC__uint64 samples_written;
419         unsigned frames_written;
420         unsigned total_frames_estimate;
421         /* unaligned (original) pointers to allocated data */
422         FLAC__int32 *integer_signal_unaligned[FLAC__MAX_CHANNELS];
423         FLAC__int32 *integer_signal_mid_side_unaligned[2];
424 #ifndef FLAC__INTEGER_ONLY_LIBRARY
425         FLAC__real *real_signal_unaligned[FLAC__MAX_CHANNELS];
426         FLAC__real *real_signal_mid_side_unaligned[2];
427         FLAC__real *window_unaligned[FLAC__MAX_APODIZATION_FUNCTIONS];
428         FLAC__real *windowed_signal_unaligned;
429 #endif
430         FLAC__int32 *residual_workspace_unaligned[FLAC__MAX_CHANNELS][2];
431         FLAC__int32 *residual_workspace_mid_side_unaligned[2][2];
432         FLAC__uint32 *abs_residual_unaligned;
433         FLAC__uint64 *abs_residual_partition_sums_unaligned;
434         unsigned *raw_bits_per_partition_unaligned;
435         /*
436          * These fields have been moved here from private function local
437          * declarations merely to save stack space during encoding.
438          */
439 #ifndef FLAC__INTEGER_ONLY_LIBRARY
440         FLAC__real lp_coeff[FLAC__MAX_LPC_ORDER][FLAC__MAX_LPC_ORDER]; /* from process_subframe_() */
441 #endif
442         FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_extra[2]; /* from find_best_partition_order_() */
443         /*
444          * The data for the verify section
445          */
446         struct {
447                 FLAC__StreamDecoder *decoder;
448                 EncoderStateHint state_hint;
449                 FLAC__bool needs_magic_hack;
450                 verify_input_fifo input_fifo;
451                 verify_output output;
452                 struct {
453                         FLAC__uint64 absolute_sample;
454                         unsigned frame_number;
455                         unsigned channel;
456                         unsigned sample;
457                         FLAC__int32 expected;
458                         FLAC__int32 got;
459                 } error_stats;
460         } verify;
461         FLAC__bool is_being_deleted; /* if true, call to ..._finish() from ..._delete() will not call the callbacks */
462 } FLAC__StreamEncoderPrivate;
463
464 /***********************************************************************
465  *
466  * Public static class data
467  *
468  ***********************************************************************/
469
470 FLAC_API const char * const FLAC__StreamEncoderStateString[] = {
471         "FLAC__STREAM_ENCODER_OK",
472         "FLAC__STREAM_ENCODER_UNINITIALIZED",
473         "FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR",
474         "FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA",
475         "FLAC__STREAM_ENCODER_CLIENT_ERROR",
476         "FLAC__STREAM_ENCODER_IO_ERROR",
477         "FLAC__STREAM_ENCODER_FRAMING_ERROR",
478         "FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR"
479 };
480
481 FLAC_API const char * const FLAC__StreamEncoderInitStatusString[] = {
482         "FLAC__STREAM_ENCODER_INIT_STATUS_OK",
483         "FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR",
484         "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS",
485         "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS",
486         "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE",
487         "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE",
488         "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE",
489         "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER",
490         "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION",
491         "FLAC__STREAM_ENCODER_INIT_STATUS_MID_SIDE_CHANNELS_MISMATCH",
492         "FLAC__STREAM_ENCODER_INIT_STATUS_MID_SIDE_SAMPLE_SIZE_MISMATCH",
493         "FLAC__STREAM_ENCODER_INIT_STATUS_ILLEGAL_MID_SIDE_FORCE",
494         "FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER",
495         "FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE",
496         "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA",
497         "FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED"
498 };
499
500 FLAC_API const char * const FLAC__StreamEncoderWriteStatusString[] = {
501         "FLAC__STREAM_ENCODER_WRITE_STATUS_OK",
502         "FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR"
503 };
504
505 FLAC_API const char * const FLAC__StreamEncoderSeekStatusString[] = {
506         "FLAC__STREAM_ENCODER_SEEK_STATUS_OK",
507         "FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR",
508         "FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED"
509 };
510
511 FLAC_API const char * const FLAC__StreamEncoderTellStatusString[] = {
512         "FLAC__STREAM_ENCODER_TELL_STATUS_OK",
513         "FLAC__STREAM_ENCODER_TELL_STATUS_ERROR",
514         "FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED"
515 };
516
517 /***********************************************************************
518  *
519  * Class constructor/destructor
520  *
521  */
522 FLAC_API FLAC__StreamEncoder *FLAC__stream_encoder_new()
523 {
524         FLAC__StreamEncoder *encoder;
525         unsigned i;
526
527         FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
528
529         encoder = (FLAC__StreamEncoder*)calloc(1, sizeof(FLAC__StreamEncoder));
530         if(encoder == 0) {
531                 return 0;
532         }
533
534         encoder->protected_ = (FLAC__StreamEncoderProtected*)calloc(1, sizeof(FLAC__StreamEncoderProtected));
535         if(encoder->protected_ == 0) {
536                 free(encoder);
537                 return 0;
538         }
539
540         encoder->private_ = (FLAC__StreamEncoderPrivate*)calloc(1, sizeof(FLAC__StreamEncoderPrivate));
541         if(encoder->private_ == 0) {
542                 free(encoder->protected_);
543                 free(encoder);
544                 return 0;
545         }
546
547         encoder->private_->frame = FLAC__bitbuffer_new();
548         if(encoder->private_->frame == 0) {
549                 free(encoder->private_);
550                 free(encoder->protected_);
551                 free(encoder);
552                 return 0;
553         }
554
555         encoder->private_->file = 0;
556
557         set_defaults_(encoder);
558
559         encoder->private_->is_being_deleted = false;
560
561         for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
562                 encoder->private_->subframe_workspace_ptr[i][0] = &encoder->private_->subframe_workspace[i][0];
563                 encoder->private_->subframe_workspace_ptr[i][1] = &encoder->private_->subframe_workspace[i][1];
564         }
565         for(i = 0; i < 2; i++) {
566                 encoder->private_->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->subframe_workspace_mid_side[i][0];
567                 encoder->private_->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->subframe_workspace_mid_side[i][1];
568         }
569         for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
570                 encoder->private_->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->partitioned_rice_contents_workspace[i][0];
571                 encoder->private_->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->partitioned_rice_contents_workspace[i][1];
572         }
573         for(i = 0; i < 2; i++) {
574                 encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][0] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0];
575                 encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][1] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1];
576         }
577
578         for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
579                 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][0]);
580                 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][1]);
581         }
582         for(i = 0; i < 2; i++) {
583                 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]);
584                 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]);
585         }
586         for(i = 0; i < 2; i++)
587                 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_extra[i]);
588
589         encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
590
591         return encoder;
592 }
593
594 FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder)
595 {
596         unsigned i;
597
598         FLAC__ASSERT(0 != encoder);
599         FLAC__ASSERT(0 != encoder->protected_);
600         FLAC__ASSERT(0 != encoder->private_);
601         FLAC__ASSERT(0 != encoder->private_->frame);
602
603         encoder->private_->is_being_deleted = true;
604
605         FLAC__stream_encoder_finish(encoder);
606
607         if(0 != encoder->private_->verify.decoder)
608                 FLAC__stream_decoder_delete(encoder->private_->verify.decoder);
609
610         for(i = 0; i < FLAC__MAX_CHANNELS; i++) {
611                 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][0]);
612                 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][1]);
613         }
614         for(i = 0; i < 2; i++) {
615                 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]);
616                 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]);
617         }
618         for(i = 0; i < 2; i++)
619                 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_extra[i]);
620
621         FLAC__bitbuffer_delete(encoder->private_->frame);
622         free(encoder->private_);
623         free(encoder->protected_);
624         free(encoder);
625 }
626
627 /***********************************************************************
628  *
629  * Public class methods
630  *
631  ***********************************************************************/
632
633 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_stream(FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteCallback write_callback, FLAC__StreamEncoderSeekCallback seek_callback, FLAC__StreamEncoderTellCallback tell_callback, FLAC__StreamEncoderMetadataCallback metadata_callback, void *client_data)
634 {
635         unsigned i;
636         FLAC__bool metadata_has_seektable, metadata_has_vorbis_comment;
637
638         FLAC__ASSERT(0 != encoder);
639
640         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
641                 return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED;
642
643         if(0 == write_callback || (seek_callback && 0 == tell_callback))
644                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS;
645
646         if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS)
647                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS;
648
649         if(encoder->protected_->do_mid_side_stereo && encoder->protected_->channels != 2)
650                 return FLAC__STREAM_ENCODER_INIT_STATUS_MID_SIDE_CHANNELS_MISMATCH;
651
652         if(encoder->protected_->loose_mid_side_stereo && !encoder->protected_->do_mid_side_stereo)
653                 return FLAC__STREAM_ENCODER_INIT_STATUS_ILLEGAL_MID_SIDE_FORCE;
654
655         if(encoder->protected_->bits_per_sample >= 32)
656                 encoder->protected_->do_mid_side_stereo = false; /* since we currenty do 32-bit math, the side channel would have 33 bps and overflow */
657
658         if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE)
659                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE;
660
661         if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate))
662                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE;
663
664         if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE)
665                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE;
666
667         if(encoder->protected_->max_lpc_order > FLAC__MAX_LPC_ORDER)
668                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER;
669
670         if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order)
671                 return FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER;
672
673         if(encoder->protected_->qlp_coeff_precision == 0) {
674                 if(encoder->protected_->bits_per_sample < 16) {
675                         /* @@@ need some data about how to set this here w.r.t. blocksize and sample rate */
676                         /* @@@ until then we'll make a guess */
677                         encoder->protected_->qlp_coeff_precision = max(FLAC__MIN_QLP_COEFF_PRECISION, 2 + encoder->protected_->bits_per_sample / 2);
678                 }
679                 else if(encoder->protected_->bits_per_sample == 16) {
680                         if(encoder->protected_->blocksize <= 192)
681                                 encoder->protected_->qlp_coeff_precision = 7;
682                         else if(encoder->protected_->blocksize <= 384)
683                                 encoder->protected_->qlp_coeff_precision = 8;
684                         else if(encoder->protected_->blocksize <= 576)
685                                 encoder->protected_->qlp_coeff_precision = 9;
686                         else if(encoder->protected_->blocksize <= 1152)
687                                 encoder->protected_->qlp_coeff_precision = 10;
688                         else if(encoder->protected_->blocksize <= 2304)
689                                 encoder->protected_->qlp_coeff_precision = 11;
690                         else if(encoder->protected_->blocksize <= 4608)
691                                 encoder->protected_->qlp_coeff_precision = 12;
692                         else
693                                 encoder->protected_->qlp_coeff_precision = 13;
694                 }
695                 else {
696                         if(encoder->protected_->blocksize <= 384)
697                                 encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-2;
698                         else if(encoder->protected_->blocksize <= 1152)
699                                 encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-1;
700                         else
701                                 encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION;
702                 }
703                 FLAC__ASSERT(encoder->protected_->qlp_coeff_precision <= FLAC__MAX_QLP_COEFF_PRECISION);
704         }
705         else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION)
706                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION;
707
708         if(encoder->protected_->streamable_subset) {
709                 if(
710                         encoder->protected_->blocksize != 192 &&
711                         encoder->protected_->blocksize != 576 &&
712                         encoder->protected_->blocksize != 1152 &&
713                         encoder->protected_->blocksize != 2304 &&
714                         encoder->protected_->blocksize != 4608 &&
715                         encoder->protected_->blocksize != 256 &&
716                         encoder->protected_->blocksize != 512 &&
717                         encoder->protected_->blocksize != 1024 &&
718                         encoder->protected_->blocksize != 2048 &&
719                         encoder->protected_->blocksize != 4096 &&
720                         encoder->protected_->blocksize != 8192 &&
721                         encoder->protected_->blocksize != 16384
722                 )
723                         return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
724                 if(
725                         encoder->protected_->sample_rate != 8000 &&
726                         encoder->protected_->sample_rate != 16000 &&
727                         encoder->protected_->sample_rate != 22050 &&
728                         encoder->protected_->sample_rate != 24000 &&
729                         encoder->protected_->sample_rate != 32000 &&
730                         encoder->protected_->sample_rate != 44100 &&
731                         encoder->protected_->sample_rate != 48000 &&
732                         encoder->protected_->sample_rate != 96000
733                 )
734                         return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
735                 if(
736                         encoder->protected_->bits_per_sample != 8 &&
737                         encoder->protected_->bits_per_sample != 12 &&
738                         encoder->protected_->bits_per_sample != 16 &&
739                         encoder->protected_->bits_per_sample != 20 &&
740                         encoder->protected_->bits_per_sample != 24
741                 )
742                         return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
743                 if(encoder->protected_->max_residual_partition_order > FLAC__SUBSET_MAX_RICE_PARTITION_ORDER)
744                         return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE;
745         }
746
747         if(encoder->protected_->max_residual_partition_order >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
748                 encoder->protected_->max_residual_partition_order = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1;
749         if(encoder->protected_->min_residual_partition_order >= encoder->protected_->max_residual_partition_order)
750                 encoder->protected_->min_residual_partition_order = encoder->protected_->max_residual_partition_order;
751
752         /* validate metadata */
753         if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0)
754                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
755         metadata_has_seektable = false;
756         metadata_has_vorbis_comment = false;
757         for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
758                 if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_STREAMINFO)
759                         return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
760                 else if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
761                         if(metadata_has_seektable) /* only one is allowed */
762                                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
763                         metadata_has_seektable = true;
764                         if(!FLAC__format_seektable_is_legal(&encoder->protected_->metadata[i]->data.seek_table))
765                                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
766                 }
767                 else if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
768                         if(metadata_has_vorbis_comment) /* only one is allowed */
769                                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
770                         metadata_has_vorbis_comment = true;
771                 }
772                 else if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_CUESHEET) {
773                         if(!FLAC__format_cuesheet_is_legal(&encoder->protected_->metadata[i]->data.cue_sheet, encoder->protected_->metadata[i]->data.cue_sheet.is_cd, /*violation=*/0))
774                                 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA;
775                 }
776         }
777
778         encoder->private_->input_capacity = 0;
779         for(i = 0; i < encoder->protected_->channels; i++) {
780                 encoder->private_->integer_signal_unaligned[i] = encoder->private_->integer_signal[i] = 0;
781 #ifndef FLAC__INTEGER_ONLY_LIBRARY
782                 encoder->private_->real_signal_unaligned[i] = encoder->private_->real_signal[i] = 0;
783 #endif
784         }
785         for(i = 0; i < 2; i++) {
786                 encoder->private_->integer_signal_mid_side_unaligned[i] = encoder->private_->integer_signal_mid_side[i] = 0;
787 #ifndef FLAC__INTEGER_ONLY_LIBRARY
788                 encoder->private_->real_signal_mid_side_unaligned[i] = encoder->private_->real_signal_mid_side[i] = 0;
789 #endif
790         }
791 #ifndef FLAC__INTEGER_ONLY_LIBRARY
792         for(i = 0; i < encoder->protected_->num_apodizations; i++)
793                 encoder->private_->window_unaligned[i] = encoder->private_->window[i] = 0;
794         encoder->private_->windowed_signal_unaligned = encoder->private_->windowed_signal = 0;
795 #endif
796         for(i = 0; i < encoder->protected_->channels; i++) {
797                 encoder->private_->residual_workspace_unaligned[i][0] = encoder->private_->residual_workspace[i][0] = 0;
798                 encoder->private_->residual_workspace_unaligned[i][1] = encoder->private_->residual_workspace[i][1] = 0;
799                 encoder->private_->best_subframe[i] = 0;
800         }
801         for(i = 0; i < 2; i++) {
802                 encoder->private_->residual_workspace_mid_side_unaligned[i][0] = encoder->private_->residual_workspace_mid_side[i][0] = 0;
803                 encoder->private_->residual_workspace_mid_side_unaligned[i][1] = encoder->private_->residual_workspace_mid_side[i][1] = 0;
804                 encoder->private_->best_subframe_mid_side[i] = 0;
805         }
806         encoder->private_->abs_residual_unaligned = encoder->private_->abs_residual = 0;
807         encoder->private_->abs_residual_partition_sums_unaligned = encoder->private_->abs_residual_partition_sums = 0;
808         encoder->private_->raw_bits_per_partition_unaligned = encoder->private_->raw_bits_per_partition = 0;
809 #ifndef FLAC__INTEGER_ONLY_LIBRARY
810         encoder->private_->loose_mid_side_stereo_frames = (unsigned)((FLAC__double)encoder->protected_->sample_rate * 0.4 / (FLAC__double)encoder->protected_->blocksize + 0.5);
811 #else
812         /* 26214 is the approximate fixed-point equivalent to 0.4 (0.4 * 2^16) */
813         /* sample rate can be up to 655350 Hz, and thus use 20 bits, so we do the multiply&divide by hand */
814         FLAC__ASSERT(FLAC__MAX_SAMPLE_RATE <= 655350);
815         FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535);
816         FLAC__ASSERT(encoder->protected_->sample_rate <= 655350);
817         FLAC__ASSERT(encoder->protected_->blocksize <= 65535);
818         encoder->private_->loose_mid_side_stereo_frames = (unsigned)FLAC__fixedpoint_trunc((((FLAC__uint64)(encoder->protected_->sample_rate) * (FLAC__uint64)(26214)) << 16) / (encoder->protected_->blocksize<<16) + FLAC__FP_ONE_HALF);
819 #endif
820         if(encoder->private_->loose_mid_side_stereo_frames == 0)
821                 encoder->private_->loose_mid_side_stereo_frames = 1;
822         encoder->private_->loose_mid_side_stereo_frame_count = 0;
823         encoder->private_->current_sample_number = 0;
824         encoder->private_->current_frame_number = 0;
825
826         encoder->private_->use_wide_by_block = (encoder->protected_->bits_per_sample + FLAC__bitmath_ilog2(encoder->protected_->blocksize)+1 > 30);
827         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? */
828         encoder->private_->use_wide_by_partition = (false); /*@@@ need to set this */
829
830         /*
831          * get the CPU info and set the function pointers
832          */
833         FLAC__cpu_info(&encoder->private_->cpuinfo);
834         /* first default to the non-asm routines */
835 #ifndef FLAC__INTEGER_ONLY_LIBRARY
836         encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
837 #endif
838         encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor;
839 #ifndef FLAC__INTEGER_ONLY_LIBRARY
840         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients;
841         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide;
842         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients;
843 #endif
844         /* now override with asm where appropriate */
845 #ifndef FLAC__INTEGER_ONLY_LIBRARY
846 # ifndef FLAC__NO_ASM
847         if(encoder->private_->cpuinfo.use_asm) {
848 #  ifdef FLAC__CPU_IA32
849                 FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32);
850 #   ifdef FLAC__HAS_NASM
851 #    ifdef FLAC__SSE_OS
852                 if(encoder->private_->cpuinfo.data.ia32.sse) {
853                         if(encoder->protected_->max_lpc_order < 4)
854                                 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4;
855                         else if(encoder->protected_->max_lpc_order < 8)
856                                 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8;
857                         else if(encoder->protected_->max_lpc_order < 12)
858                                 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12;
859                         else
860                                 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32;
861                 }
862                 else
863 #    endif /* FLAC__SSE_OS */
864                 if(encoder->private_->cpuinfo.data.ia32._3dnow)
865                         encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_3dnow;
866                 else
867                         encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32;
868                 if(encoder->private_->cpuinfo.data.ia32.mmx) {
869                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
870                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx;
871                 }
872                 else {
873                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
874                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
875                 }
876                 if(encoder->private_->cpuinfo.data.ia32.mmx && encoder->private_->cpuinfo.data.ia32.cmov)
877                         encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov;
878 #   endif /* FLAC__HAS_NASM */
879 #  endif /* FLAC__CPU_IA32 */
880         }
881 # endif /* !FLAC__NO_ASM */
882 #endif /* !FLAC__INTEGER_ONLY_LIBRARY */
883         /* finally override based on wide-ness if necessary */
884         if(encoder->private_->use_wide_by_block) {
885                 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_wide;
886         }
887
888         /* we require precompute_partition_sums if do_escape_coding because of their intertwined nature */
889         encoder->private_->precompute_partition_sums = (encoder->protected_->max_residual_partition_order > encoder->protected_->min_residual_partition_order) || encoder->protected_->do_escape_coding;
890
891         /* set state to OK; from here on, errors are fatal and we'll override the state then */
892         encoder->protected_->state = FLAC__STREAM_ENCODER_OK;
893
894         encoder->private_->write_callback = write_callback;
895         encoder->private_->seek_callback = seek_callback;
896         encoder->private_->tell_callback = tell_callback;
897         encoder->private_->metadata_callback = metadata_callback;
898         encoder->private_->client_data = client_data;
899
900         if(!resize_buffers_(encoder, encoder->protected_->blocksize)) {
901                 /* the above function sets the state for us in case of an error */
902                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
903         }
904
905         if(!FLAC__bitbuffer_init(encoder->private_->frame)) {
906                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
907                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
908         }
909
910         /*
911          * Set up the verify stuff if necessary
912          */
913         if(encoder->protected_->verify) {
914                 /*
915                  * First, set up the fifo which will hold the
916                  * original signal to compare against
917                  */
918                 encoder->private_->verify.input_fifo.size = encoder->protected_->blocksize;
919                 for(i = 0; i < encoder->protected_->channels; i++) {
920                         if(0 == (encoder->private_->verify.input_fifo.data[i] = (FLAC__int32*)malloc(sizeof(FLAC__int32) * encoder->private_->verify.input_fifo.size))) {
921                                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
922                                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
923                         }
924                 }
925                 encoder->private_->verify.input_fifo.tail = 0;
926
927                 /*
928                  * Now set up a stream decoder for verification
929                  */
930                 encoder->private_->verify.decoder = FLAC__stream_decoder_new();
931                 if(0 == encoder->private_->verify.decoder) {
932                         encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
933                         return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
934                 }
935
936                 if(FLAC__stream_decoder_init_stream(encoder->private_->verify.decoder, verify_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, verify_write_callback_, verify_metadata_callback_, verify_error_callback_, /*client_data=*/encoder) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
937                         encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
938                         return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
939                 }
940         }
941         encoder->private_->verify.error_stats.absolute_sample = 0;
942         encoder->private_->verify.error_stats.frame_number = 0;
943         encoder->private_->verify.error_stats.channel = 0;
944         encoder->private_->verify.error_stats.sample = 0;
945         encoder->private_->verify.error_stats.expected = 0;
946         encoder->private_->verify.error_stats.got = 0;
947
948         /*
949          * These must be done before we write any metadata, because that
950          * calls the write_callback, which uses these values.
951          */
952         encoder->private_->first_seekpoint_to_check = 0;
953         encoder->private_->samples_written = 0;
954         encoder->protected_->streaminfo_offset = 0;
955         encoder->protected_->seektable_offset = 0;
956         encoder->protected_->audio_offset = 0;
957
958         /*
959          * write the stream header
960          */
961         if(encoder->protected_->verify)
962                 encoder->private_->verify.state_hint = ENCODER_IN_MAGIC;
963         if(!FLAC__bitbuffer_write_raw_uint32(encoder->private_->frame, FLAC__STREAM_SYNC, FLAC__STREAM_SYNC_LEN)) {
964                 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
965                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
966         }
967         if(!write_bitbuffer_(encoder, 0)) {
968                 /* the above function sets the state for us in case of an error */
969                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
970         }
971
972         /*
973          * write the STREAMINFO metadata block
974          */
975         if(encoder->protected_->verify)
976                 encoder->private_->verify.state_hint = ENCODER_IN_METADATA;
977         encoder->private_->streaminfo.type = FLAC__METADATA_TYPE_STREAMINFO;
978         encoder->private_->streaminfo.is_last = false; /* we will have at a minimum a VORBIS_COMMENT afterwards */
979         encoder->private_->streaminfo.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
980         encoder->private_->streaminfo.data.stream_info.min_blocksize = encoder->protected_->blocksize; /* this encoder uses the same blocksize for the whole stream */
981         encoder->private_->streaminfo.data.stream_info.max_blocksize = encoder->protected_->blocksize;
982         encoder->private_->streaminfo.data.stream_info.min_framesize = 0; /* we don't know this yet; have to fill it in later */
983         encoder->private_->streaminfo.data.stream_info.max_framesize = 0; /* we don't know this yet; have to fill it in later */
984         encoder->private_->streaminfo.data.stream_info.sample_rate = encoder->protected_->sample_rate;
985         encoder->private_->streaminfo.data.stream_info.channels = encoder->protected_->channels;
986         encoder->private_->streaminfo.data.stream_info.bits_per_sample = encoder->protected_->bits_per_sample;
987         encoder->private_->streaminfo.data.stream_info.total_samples = encoder->protected_->total_samples_estimate; /* we will replace this later with the real total */
988         memset(encoder->private_->streaminfo.data.stream_info.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */
989         FLAC__MD5Init(&encoder->private_->md5context);
990         if(!FLAC__bitbuffer_clear(encoder->private_->frame)) {
991                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
992                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
993         }
994         if(!FLAC__add_metadata_block(&encoder->private_->streaminfo, encoder->private_->frame)) {
995                 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
996                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
997         }
998         if(!write_bitbuffer_(encoder, 0)) {
999                 /* the above function sets the state for us in case of an error */
1000                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1001         }
1002
1003         /*
1004          * Now that the STREAMINFO block is written, we can init this to an
1005          * absurdly-high value...
1006          */
1007         encoder->private_->streaminfo.data.stream_info.min_framesize = (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN) - 1;
1008         /* ... and clear this to 0 */
1009         encoder->private_->streaminfo.data.stream_info.total_samples = 0;
1010
1011         /*
1012          * Check to see if the supplied metadata contains a VORBIS_COMMENT;
1013          * if not, we will write an empty one (FLAC__add_metadata_block()
1014          * automatically supplies the vendor string).
1015          *
1016          * WATCHOUT: libOggFLAC depends on us to write this block after the
1017          * STREAMINFO since that's what the mapping requires.  (In the case
1018          * that metadata_has_vorbis_comment is true it will have already
1019          * insured that the metadata list is properly ordered.)
1020          */
1021         if(!metadata_has_vorbis_comment) {
1022                 FLAC__StreamMetadata vorbis_comment;
1023                 vorbis_comment.type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
1024                 vorbis_comment.is_last = (encoder->protected_->num_metadata_blocks == 0);
1025                 vorbis_comment.length = 4 + 4; /* MAGIC NUMBER */
1026                 vorbis_comment.data.vorbis_comment.vendor_string.length = 0;
1027                 vorbis_comment.data.vorbis_comment.vendor_string.entry = 0;
1028                 vorbis_comment.data.vorbis_comment.num_comments = 0;
1029                 vorbis_comment.data.vorbis_comment.comments = 0;
1030                 if(!FLAC__bitbuffer_clear(encoder->private_->frame)) {
1031                         encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1032                         return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1033                 }
1034                 if(!FLAC__add_metadata_block(&vorbis_comment, encoder->private_->frame)) {
1035                         encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1036                         return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1037                 }
1038                 if(!write_bitbuffer_(encoder, 0)) {
1039                         /* the above function sets the state for us in case of an error */
1040                         return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1041                 }
1042         }
1043
1044         /*
1045          * write the user's metadata blocks
1046          */
1047         for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
1048                 encoder->protected_->metadata[i]->is_last = (i == encoder->protected_->num_metadata_blocks - 1);
1049                 if(!FLAC__bitbuffer_clear(encoder->private_->frame)) {
1050                         encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1051                         return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1052                 }
1053                 if(!FLAC__add_metadata_block(encoder->protected_->metadata[i], encoder->private_->frame)) {
1054                         encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1055                         return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1056                 }
1057                 if(!write_bitbuffer_(encoder, 0)) {
1058                         /* the above function sets the state for us in case of an error */
1059                         return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1060                 }
1061         }
1062
1063         /* now that all the metadata is written, we save the stream offset */
1064         if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &encoder->protected_->audio_offset, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) { /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */
1065                 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
1066                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1067         }
1068
1069         if(encoder->protected_->verify)
1070                 encoder->private_->verify.state_hint = ENCODER_IN_AUDIO;
1071
1072         return FLAC__STREAM_ENCODER_INIT_STATUS_OK;
1073 }
1074
1075 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_FILE(FLAC__StreamEncoder *encoder, FILE *file, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data)
1076 {
1077         FLAC__StreamEncoderInitStatus init_status;
1078
1079         FLAC__ASSERT(0 != encoder);
1080         FLAC__ASSERT(0 != file);
1081
1082         /*
1083          * To make sure that our file does not go unclosed after an error, we
1084          * must assign the FILE pointer before any further error can occur in
1085          * this routine.
1086          */
1087         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1088                 return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED;
1089
1090         /* double protection */
1091         if(file == 0) {
1092                 encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
1093                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1094         }
1095
1096         if(file == stdout)
1097                 file = get_binary_stdout_(); /* just to be safe */
1098
1099         encoder->private_->file = file;
1100
1101         encoder->private_->progress_callback = progress_callback;
1102         encoder->private_->bytes_written = 0;
1103         encoder->private_->samples_written = 0;
1104         encoder->private_->frames_written = 0;
1105
1106         init_status = FLAC__stream_encoder_init_stream(encoder, file_write_callback_, file_seek_callback_, file_tell_callback_, /*metadata_callback=*/0, client_data);
1107         if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
1108                 /* the above function sets the state for us in case of an error */
1109                 return init_status;
1110         }
1111
1112         {
1113                 unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder);
1114
1115                 FLAC__ASSERT(blocksize != 0);
1116                 encoder->private_->total_frames_estimate = (unsigned)((FLAC__stream_encoder_get_total_samples_estimate(encoder) + blocksize - 1) / blocksize);
1117         }
1118
1119         return init_status;
1120 }
1121
1122 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_file(FLAC__StreamEncoder *encoder, const char *filename, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data)
1123 {
1124         FILE *file;
1125
1126         FLAC__ASSERT(0 != encoder);
1127
1128         /*
1129          * To make sure that our file does not go unclosed after an error, we
1130          * have to do the same entrance checks here that are later performed
1131          * in FLAC__stream_encoder_init_FILE() before the FILE* is assigned.
1132          */
1133         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1134                 return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED;
1135
1136         file = filename? fopen(filename, "w+b") : stdout;
1137
1138         if(file == 0) {
1139                 encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
1140                 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR;
1141         }
1142
1143         return FLAC__stream_encoder_init_FILE(encoder, file, progress_callback, client_data);
1144 }
1145
1146 FLAC_API void FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder)
1147 {
1148         FLAC__ASSERT(0 != encoder);
1149         FLAC__ASSERT(0 != encoder->private_);
1150         FLAC__ASSERT(0 != encoder->protected_);
1151
1152         if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED)
1153                 return;
1154
1155         if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) {
1156                 if(encoder->private_->current_sample_number != 0) {
1157                         encoder->protected_->blocksize = encoder->private_->current_sample_number;
1158                         process_frame_(encoder, true); /* true => is last frame */
1159                 }
1160         }
1161
1162         FLAC__MD5Final(encoder->private_->streaminfo.data.stream_info.md5sum, &encoder->private_->md5context);
1163
1164         if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) {
1165                 if(encoder->private_->seek_callback)
1166                         update_metadata_(encoder);
1167                 if(encoder->private_->metadata_callback)
1168                         encoder->private_->metadata_callback(encoder, &encoder->private_->streaminfo, encoder->private_->client_data);
1169         }
1170
1171         if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder)
1172                 FLAC__stream_decoder_finish(encoder->private_->verify.decoder);
1173
1174         if(0 != encoder->private_->file) {
1175                 if(encoder->private_->file != stdout)
1176                         fclose(encoder->private_->file);
1177                 encoder->private_->file = 0;
1178         }
1179
1180         free_(encoder);
1181         set_defaults_(encoder);
1182
1183         encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
1184 }
1185
1186 FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value)
1187 {
1188         FLAC__ASSERT(0 != encoder);
1189         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1190                 return false;
1191 #ifndef FLAC__MANDATORY_VERIFY_WHILE_ENCODING
1192         encoder->protected_->verify = value;
1193 #endif
1194         return true;
1195 }
1196
1197 FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value)
1198 {
1199         FLAC__ASSERT(0 != encoder);
1200         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1201                 return false;
1202         encoder->protected_->streamable_subset = value;
1203         return true;
1204 }
1205
1206 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
1207 {
1208         FLAC__ASSERT(0 != encoder);
1209         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1210                 return false;
1211         encoder->protected_->do_mid_side_stereo = value;
1212         return true;
1213 }
1214
1215 FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
1216 {
1217         FLAC__ASSERT(0 != encoder);
1218         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1219                 return false;
1220         encoder->protected_->loose_mid_side_stereo = value;
1221         return true;
1222 }
1223
1224 FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value)
1225 {
1226         FLAC__ASSERT(0 != encoder);
1227         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1228                 return false;
1229         encoder->protected_->channels = value;
1230         return true;
1231 }
1232
1233 FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value)
1234 {
1235         FLAC__ASSERT(0 != encoder);
1236         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1237                 return false;
1238         encoder->protected_->bits_per_sample = value;
1239         return true;
1240 }
1241
1242 FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value)
1243 {
1244         FLAC__ASSERT(0 != encoder);
1245         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1246                 return false;
1247         encoder->protected_->sample_rate = value;
1248         return true;
1249 }
1250
1251 FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value)
1252 {
1253         FLAC__ASSERT(0 != encoder);
1254         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1255                 return false;
1256         encoder->protected_->blocksize = value;
1257         return true;
1258 }
1259
1260 FLAC_API FLAC__bool FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder *encoder, const char *specification)
1261 {
1262         FLAC__ASSERT(0 != encoder);
1263         FLAC__ASSERT(0 != specification);
1264         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1265                 return false;
1266 #ifdef FLAC__INTEGER_ONLY_LIBRARY
1267         (void)specification; /* silently ignore since we haven't integerized; will always use a rectangular window */
1268 #else
1269         encoder->protected_->num_apodizations = 0;
1270         while(1) {
1271                 const char *s = strchr(specification, ';');
1272                 const size_t n = s? (size_t)(s - specification) : strlen(specification);
1273                 if     (n==8  && 0 == strncmp("bartlett"     , specification, n))
1274                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT;
1275                 else if(n==13 && 0 == strncmp("bartlett_hann", specification, n))
1276                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT_HANN;
1277                 else if(n==8  && 0 == strncmp("blackman"     , specification, n))
1278                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN;
1279                 else if(n==26 && 0 == strncmp("blackman_harris_4term_92db", specification, n))
1280                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE;
1281                 else if(n==6  && 0 == strncmp("connes"       , specification, n))
1282                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_CONNES;
1283                 else if(n==7  && 0 == strncmp("flattop"      , specification, n))
1284                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_FLATTOP;
1285                 else if(n>7   && 0 == strncmp("gauss("       , specification, 6)) {
1286                         FLAC__real stddev = (FLAC__real)strtod(specification+6, 0);
1287                         if (stddev > 0.0 && stddev <= 0.5) {
1288                                 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.gauss.stddev = stddev;
1289                                 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_GAUSS;
1290                         }
1291                 }
1292                 else if(n==7  && 0 == strncmp("hamming"      , specification, n))
1293                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HAMMING;
1294                 else if(n==4  && 0 == strncmp("hann"         , specification, n))
1295                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HANN;
1296                 else if(n==13 && 0 == strncmp("kaiser_bessel", specification, n))
1297                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_KAISER_BESSEL;
1298                 else if(n==7  && 0 == strncmp("nuttall"      , specification, n))
1299                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_NUTTALL;
1300                 else if(n==9  && 0 == strncmp("rectangle"    , specification, n))
1301                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_RECTANGLE;
1302                 else if(n==8  && 0 == strncmp("triangle"     , specification, n))
1303                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TRIANGLE;
1304                 else if(n>7   && 0 == strncmp("tukey("       , specification, 6)) {
1305                         FLAC__real p = (FLAC__real)strtod(specification+6, 0);
1306                         if (p >= 0.0 && p <= 1.0) {
1307                                 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = p;
1308                                 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
1309                         }
1310                 }
1311                 else if(n==5  && 0 == strncmp("welch"        , specification, n))
1312                         encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_WELCH;
1313                 if (encoder->protected_->num_apodizations == 32)
1314                         break;
1315                 if (s)
1316                         specification = s+1;
1317                 else
1318                         break;
1319         }
1320         if(encoder->protected_->num_apodizations == 0) {
1321                 encoder->protected_->num_apodizations = 1;
1322                 encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
1323                 encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
1324         }
1325 #ifdef WINDOW_DEBUG_OUTPUT
1326 {unsigned n;for(n=0;n<encoder->protected_->num_apodizations;n++)fprintf(stderr,"@@@@@@ parsed apodization[%zu]: %s\n",n,winstr[encoder->protected_->apodizations[n].type]);}
1327 #endif
1328 #endif
1329         return true;
1330 }
1331
1332 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, unsigned value)
1333 {
1334         FLAC__ASSERT(0 != encoder);
1335         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1336                 return false;
1337         encoder->protected_->max_lpc_order = value;
1338         return true;
1339 }
1340
1341 FLAC_API FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, unsigned value)
1342 {
1343         FLAC__ASSERT(0 != encoder);
1344         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1345                 return false;
1346         encoder->protected_->qlp_coeff_precision = value;
1347         return true;
1348 }
1349
1350 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
1351 {
1352         FLAC__ASSERT(0 != encoder);
1353         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1354                 return false;
1355         encoder->protected_->do_qlp_coeff_prec_search = value;
1356         return true;
1357 }
1358
1359 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder *encoder, FLAC__bool value)
1360 {
1361         FLAC__ASSERT(0 != encoder);
1362         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1363                 return false;
1364 #if 0
1365         /*@@@ deprecated: */
1366         encoder->protected_->do_escape_coding = value;
1367 #else
1368         (void)value;
1369 #endif
1370         return true;
1371 }
1372
1373 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
1374 {
1375         FLAC__ASSERT(0 != encoder);
1376         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1377                 return false;
1378         encoder->protected_->do_exhaustive_model_search = value;
1379         return true;
1380 }
1381
1382 FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
1383 {
1384         FLAC__ASSERT(0 != encoder);
1385         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1386                 return false;
1387         encoder->protected_->min_residual_partition_order = value;
1388         return true;
1389 }
1390
1391 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
1392 {
1393         FLAC__ASSERT(0 != encoder);
1394         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1395                 return false;
1396         encoder->protected_->max_residual_partition_order = value;
1397         return true;
1398 }
1399
1400 FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value)
1401 {
1402         FLAC__ASSERT(0 != encoder);
1403         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1404                 return false;
1405 #if 0
1406         /*@@@ deprecated: */
1407         encoder->protected_->rice_parameter_search_dist = value;
1408 #else
1409         (void)value;
1410 #endif
1411         return true;
1412 }
1413
1414 FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value)
1415 {
1416         FLAC__ASSERT(0 != encoder);
1417         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1418                 return false;
1419         encoder->protected_->total_samples_estimate = value;
1420         return true;
1421 }
1422
1423 FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks)
1424 {
1425         FLAC__ASSERT(0 != encoder);
1426         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1427                 return false;
1428         encoder->protected_->metadata = metadata;
1429         encoder->protected_->num_metadata_blocks = num_blocks;
1430         if(0 != metadata && num_blocks > 0) {
1431                 unsigned i;
1432                 for(i = 0; i < num_blocks; i++) {
1433                         if(0 != metadata[i] && metadata[i]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
1434                                 encoder->private_->seek_table = &metadata[i]->data.seek_table;
1435                                 break; /* take only the first one */
1436                         }
1437                 }
1438         }
1439         return true;
1440 }
1441
1442 /*
1443  * These three functions are not static, but not publically exposed in
1444  * include/FLAC/ either.  They are used by the test suite.
1445  */
1446 FLAC_API FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
1447 {
1448         FLAC__ASSERT(0 != encoder);
1449         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1450                 return false;
1451         encoder->private_->disable_constant_subframes = value;
1452         return true;
1453 }
1454
1455 FLAC_API FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
1456 {
1457         FLAC__ASSERT(0 != encoder);
1458         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1459                 return false;
1460         encoder->private_->disable_fixed_subframes = value;
1461         return true;
1462 }
1463
1464 FLAC_API FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
1465 {
1466         FLAC__ASSERT(0 != encoder);
1467         if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1468                 return false;
1469         encoder->private_->disable_verbatim_subframes = value;
1470         return true;
1471 }
1472
1473 FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder)
1474 {
1475         FLAC__ASSERT(0 != encoder);
1476         return encoder->protected_->state;
1477 }
1478
1479 FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder)
1480 {
1481         FLAC__ASSERT(0 != encoder);
1482         if(encoder->protected_->verify)
1483                 return FLAC__stream_decoder_get_state(encoder->private_->verify.decoder);
1484         else
1485                 return FLAC__STREAM_DECODER_UNINITIALIZED;
1486 }
1487
1488 FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder)
1489 {
1490         if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR)
1491                 return FLAC__StreamEncoderStateString[encoder->protected_->state];
1492         else
1493                 return FLAC__stream_decoder_get_resolved_state_string(encoder->private_->verify.decoder);
1494 }
1495
1496 FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got)
1497 {
1498         FLAC__ASSERT(0 != encoder);
1499         if(0 != absolute_sample)
1500                 *absolute_sample = encoder->private_->verify.error_stats.absolute_sample;
1501         if(0 != frame_number)
1502                 *frame_number = encoder->private_->verify.error_stats.frame_number;
1503         if(0 != channel)
1504                 *channel = encoder->private_->verify.error_stats.channel;
1505         if(0 != sample)
1506                 *sample = encoder->private_->verify.error_stats.sample;
1507         if(0 != expected)
1508                 *expected = encoder->private_->verify.error_stats.expected;
1509         if(0 != got)
1510                 *got = encoder->private_->verify.error_stats.got;
1511 }
1512
1513 FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder)
1514 {
1515         FLAC__ASSERT(0 != encoder);
1516         return encoder->protected_->verify;
1517 }
1518
1519 FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder)
1520 {
1521         FLAC__ASSERT(0 != encoder);
1522         return encoder->protected_->streamable_subset;
1523 }
1524
1525 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
1526 {
1527         FLAC__ASSERT(0 != encoder);
1528         return encoder->protected_->do_mid_side_stereo;
1529 }
1530
1531 FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
1532 {
1533         FLAC__ASSERT(0 != encoder);
1534         return encoder->protected_->loose_mid_side_stereo;
1535 }
1536
1537 FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
1538 {
1539         FLAC__ASSERT(0 != encoder);
1540         return encoder->protected_->channels;
1541 }
1542
1543 FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
1544 {
1545         FLAC__ASSERT(0 != encoder);
1546         return encoder->protected_->bits_per_sample;
1547 }
1548
1549 FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
1550 {
1551         FLAC__ASSERT(0 != encoder);
1552         return encoder->protected_->sample_rate;
1553 }
1554
1555 FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
1556 {
1557         FLAC__ASSERT(0 != encoder);
1558         return encoder->protected_->blocksize;
1559 }
1560
1561 FLAC_API unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder)
1562 {
1563         FLAC__ASSERT(0 != encoder);
1564         return encoder->protected_->max_lpc_order;
1565 }
1566
1567 FLAC_API unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder)
1568 {
1569         FLAC__ASSERT(0 != encoder);
1570         return encoder->protected_->qlp_coeff_precision;
1571 }
1572
1573 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
1574 {
1575         FLAC__ASSERT(0 != encoder);
1576         return encoder->protected_->do_qlp_coeff_prec_search;
1577 }
1578
1579 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder)
1580 {
1581         FLAC__ASSERT(0 != encoder);
1582         return encoder->protected_->do_escape_coding;
1583 }
1584
1585 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
1586 {
1587         FLAC__ASSERT(0 != encoder);
1588         return encoder->protected_->do_exhaustive_model_search;
1589 }
1590
1591 FLAC_API unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder)
1592 {
1593         FLAC__ASSERT(0 != encoder);
1594         return encoder->protected_->min_residual_partition_order;
1595 }
1596
1597 FLAC_API unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder)
1598 {
1599         FLAC__ASSERT(0 != encoder);
1600         return encoder->protected_->max_residual_partition_order;
1601 }
1602
1603 FLAC_API unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder)
1604 {
1605         FLAC__ASSERT(0 != encoder);
1606         return encoder->protected_->rice_parameter_search_dist;
1607 }
1608
1609 FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder)
1610 {
1611         FLAC__ASSERT(0 != encoder);
1612         return encoder->protected_->total_samples_estimate;
1613 }
1614
1615 FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples)
1616 {
1617         unsigned i, j, channel;
1618         FLAC__int32 x, mid, side;
1619         const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
1620
1621         FLAC__ASSERT(0 != encoder);
1622         FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
1623
1624         j = 0;
1625         /*
1626          * we have several flavors of the same basic loop, optimized for
1627          * different conditions:
1628          */
1629         if(encoder->protected_->max_lpc_order > 0) {
1630                 if(encoder->protected_->do_mid_side_stereo && channels == 2) {
1631                         /*
1632                          * stereo coding: unroll channel loop
1633                          * with LPC: calculate floating point version of signal
1634                          */
1635                         do {
1636                                 if(encoder->protected_->verify)
1637                                         append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1638
1639                                 for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1640                                         x = mid = side = buffer[0][j];
1641                                         encoder->private_->integer_signal[0][i] = x;
1642 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1643                                         encoder->private_->real_signal[0][i] = (FLAC__real)x;
1644 #endif
1645                                         x = buffer[1][j];
1646                                         encoder->private_->integer_signal[1][i] = x;
1647 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1648                                         encoder->private_->real_signal[1][i] = (FLAC__real)x;
1649 #endif
1650                                         mid += x;
1651                                         side -= x;
1652                                         mid >>= 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */
1653                                         encoder->private_->integer_signal_mid_side[1][i] = side;
1654                                         encoder->private_->integer_signal_mid_side[0][i] = mid;
1655 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1656                                         encoder->private_->real_signal_mid_side[1][i] = (FLAC__real)side;
1657                                         encoder->private_->real_signal_mid_side[0][i] = (FLAC__real)mid;
1658 #endif
1659                                         encoder->private_->current_sample_number++;
1660                                 }
1661                                 if(i == blocksize) {
1662                                         if(!process_frame_(encoder, false)) /* false => not last frame */
1663                                                 return false;
1664                                 }
1665                         } while(j < samples);
1666                 }
1667                 else {
1668                         /*
1669                          * independent channel coding: buffer each channel in inner loop
1670                          * with LPC: calculate floating point version of signal
1671                          */
1672                         do {
1673                                 if(encoder->protected_->verify)
1674                                         append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1675
1676                                 for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1677                                         for(channel = 0; channel < channels; channel++) {
1678                                                 x = buffer[channel][j];
1679                                                 encoder->private_->integer_signal[channel][i] = x;
1680 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1681                                                 encoder->private_->real_signal[channel][i] = (FLAC__real)x;
1682 #endif
1683                                         }
1684                                         encoder->private_->current_sample_number++;
1685                                 }
1686                                 if(i == blocksize) {
1687                                         if(!process_frame_(encoder, false)) /* false => not last frame */
1688                                                 return false;
1689                                 }
1690                         } while(j < samples);
1691                 }
1692         }
1693         else {
1694                 if(encoder->protected_->do_mid_side_stereo && channels == 2) {
1695                         /*
1696                          * stereo coding: unroll channel loop
1697                          * without LPC: no need to calculate floating point version of signal
1698                          */
1699                         do {
1700                                 if(encoder->protected_->verify)
1701                                         append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1702
1703                                 for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1704                                         encoder->private_->integer_signal[0][i] = mid = side = buffer[0][j];
1705                                         x = buffer[1][j];
1706                                         encoder->private_->integer_signal[1][i] = x;
1707                                         mid += x;
1708                                         side -= x;
1709                                         mid >>= 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */
1710                                         encoder->private_->integer_signal_mid_side[1][i] = side;
1711                                         encoder->private_->integer_signal_mid_side[0][i] = mid;
1712                                         encoder->private_->current_sample_number++;
1713                                 }
1714                                 if(i == blocksize) {
1715                                         if(!process_frame_(encoder, false)) /* false => not last frame */
1716                                                 return false;
1717                                 }
1718                         } while(j < samples);
1719                 }
1720                 else {
1721                         /*
1722                          * independent channel coding: buffer each channel in inner loop
1723                          * without LPC: no need to calculate floating point version of signal
1724                          */
1725                         do {
1726                                 if(encoder->protected_->verify)
1727                                         append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1728
1729                                 for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1730                                         for(channel = 0; channel < channels; channel++)
1731                                                 encoder->private_->integer_signal[channel][i] = buffer[channel][j];
1732                                         encoder->private_->current_sample_number++;
1733                                 }
1734                                 if(i == blocksize) {
1735                                         if(!process_frame_(encoder, false)) /* false => not last frame */
1736                                                 return false;
1737                                 }
1738                         } while(j < samples);
1739                 }
1740         }
1741
1742         return true;
1743 }
1744
1745 FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples)
1746 {
1747         unsigned i, j, k, channel;
1748         FLAC__int32 x, mid, side;
1749         const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
1750
1751         FLAC__ASSERT(0 != encoder);
1752         FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
1753
1754         j = k = 0;
1755         /*
1756          * we have several flavors of the same basic loop, optimized for
1757          * different conditions:
1758          */
1759         if(encoder->protected_->max_lpc_order > 0) {
1760                 if(encoder->protected_->do_mid_side_stereo && channels == 2) {
1761                         /*
1762                          * stereo coding: unroll channel loop
1763                          * with LPC: calculate floating point version of signal
1764                          */
1765                         do {
1766                                 if(encoder->protected_->verify)
1767                                         append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1768
1769                                 for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1770                                         x = mid = side = buffer[k++];
1771                                         encoder->private_->integer_signal[0][i] = x;
1772 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1773                                         encoder->private_->real_signal[0][i] = (FLAC__real)x;
1774 #endif
1775                                         x = buffer[k++];
1776                                         encoder->private_->integer_signal[1][i] = x;
1777 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1778                                         encoder->private_->real_signal[1][i] = (FLAC__real)x;
1779 #endif
1780                                         mid += x;
1781                                         side -= x;
1782                                         mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */
1783                                         encoder->private_->integer_signal_mid_side[1][i] = side;
1784                                         encoder->private_->integer_signal_mid_side[0][i] = mid;
1785 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1786                                         encoder->private_->real_signal_mid_side[1][i] = (FLAC__real)side;
1787                                         encoder->private_->real_signal_mid_side[0][i] = (FLAC__real)mid;
1788 #endif
1789                                         encoder->private_->current_sample_number++;
1790                                 }
1791                                 if(i == blocksize) {
1792                                         if(!process_frame_(encoder, false)) /* false => not last frame */
1793                                                 return false;
1794                                 }
1795                         } while(j < samples);
1796                 }
1797                 else {
1798                         /*
1799                          * independent channel coding: buffer each channel in inner loop
1800                          * with LPC: calculate floating point version of signal
1801                          */
1802                         do {
1803                                 if(encoder->protected_->verify)
1804                                         append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1805
1806                                 for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1807                                         for(channel = 0; channel < channels; channel++) {
1808                                                 x = buffer[k++];
1809                                                 encoder->private_->integer_signal[channel][i] = x;
1810 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1811                                                 encoder->private_->real_signal[channel][i] = (FLAC__real)x;
1812 #endif
1813                                         }
1814                                         encoder->private_->current_sample_number++;
1815                                 }
1816                                 if(i == blocksize) {
1817                                         if(!process_frame_(encoder, false)) /* false => not last frame */
1818                                                 return false;
1819                                 }
1820                         } while(j < samples);
1821                 }
1822         }
1823         else {
1824                 if(encoder->protected_->do_mid_side_stereo && channels == 2) {
1825                         /*
1826                          * stereo coding: unroll channel loop
1827                          * without LPC: no need to calculate floating point version of signal
1828                          */
1829                         do {
1830                                 if(encoder->protected_->verify)
1831                                         append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1832
1833                                 for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1834                                         encoder->private_->integer_signal[0][i] = mid = side = buffer[k++];
1835                                         x = buffer[k++];
1836                                         encoder->private_->integer_signal[1][i] = x;
1837                                         mid += x;
1838                                         side -= x;
1839                                         mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */
1840                                         encoder->private_->integer_signal_mid_side[1][i] = side;
1841                                         encoder->private_->integer_signal_mid_side[0][i] = mid;
1842                                         encoder->private_->current_sample_number++;
1843                                 }
1844                                 if(i == blocksize) {
1845                                         if(!process_frame_(encoder, false)) /* false => not last frame */
1846                                                 return false;
1847                                 }
1848                         } while(j < samples);
1849                 }
1850                 else {
1851                         /*
1852                          * independent channel coding: buffer each channel in inner loop
1853                          * without LPC: no need to calculate floating point version of signal
1854                          */
1855                         do {
1856                                 if(encoder->protected_->verify)
1857                                         append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));
1858
1859                                 for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
1860                                         for(channel = 0; channel < channels; channel++)
1861                                                 encoder->private_->integer_signal[channel][i] = buffer[k++];
1862                                         encoder->private_->current_sample_number++;
1863                                 }
1864                                 if(i == blocksize) {
1865                                         if(!process_frame_(encoder, false)) /* false => not last frame */
1866                                                 return false;
1867                                 }
1868                         } while(j < samples);
1869                 }
1870         }
1871
1872         return true;
1873 }
1874
1875 /***********************************************************************
1876  *
1877  * Private class methods
1878  *
1879  ***********************************************************************/
1880
1881 void set_defaults_(FLAC__StreamEncoder *encoder)
1882 {
1883         FLAC__ASSERT(0 != encoder);
1884
1885 #ifdef FLAC__MANDATORY_VERIFY_WHILE_ENCODING
1886         encoder->protected_->verify = true;
1887 #else
1888         encoder->protected_->verify = false;
1889 #endif
1890         encoder->protected_->streamable_subset = true;
1891         encoder->protected_->do_mid_side_stereo = false;
1892         encoder->protected_->loose_mid_side_stereo = false;
1893         encoder->protected_->channels = 2;
1894         encoder->protected_->bits_per_sample = 16;
1895         encoder->protected_->sample_rate = 44100;
1896         encoder->protected_->blocksize = 1152;
1897 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1898         encoder->protected_->num_apodizations = 1;
1899         encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
1900         encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
1901 #endif
1902         encoder->protected_->max_lpc_order = 0;
1903         encoder->protected_->qlp_coeff_precision = 0;
1904         encoder->protected_->do_qlp_coeff_prec_search = false;
1905         encoder->protected_->do_exhaustive_model_search = false;
1906         encoder->protected_->do_escape_coding = false;
1907         encoder->protected_->min_residual_partition_order = 0;
1908         encoder->protected_->max_residual_partition_order = 0;
1909         encoder->protected_->rice_parameter_search_dist = 0;
1910         encoder->protected_->total_samples_estimate = 0;
1911         encoder->protected_->metadata = 0;
1912         encoder->protected_->num_metadata_blocks = 0;
1913
1914         encoder->private_->seek_table = 0;
1915         encoder->private_->disable_constant_subframes = false;
1916         encoder->private_->disable_fixed_subframes = false;
1917         encoder->private_->disable_verbatim_subframes = false;
1918         encoder->private_->write_callback = 0;
1919         encoder->private_->seek_callback = 0;
1920         encoder->private_->tell_callback = 0;
1921         encoder->private_->metadata_callback = 0;
1922         encoder->private_->progress_callback = 0;
1923         encoder->private_->client_data = 0;
1924 }
1925
1926 void free_(FLAC__StreamEncoder *encoder)
1927 {
1928         unsigned i, channel;
1929
1930         FLAC__ASSERT(0 != encoder);
1931         for(i = 0; i < encoder->protected_->channels; i++) {
1932                 if(0 != encoder->private_->integer_signal_unaligned[i]) {
1933                         free(encoder->private_->integer_signal_unaligned[i]);
1934                         encoder->private_->integer_signal_unaligned[i] = 0;
1935                 }
1936 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1937                 if(0 != encoder->private_->real_signal_unaligned[i]) {
1938                         free(encoder->private_->real_signal_unaligned[i]);
1939                         encoder->private_->real_signal_unaligned[i] = 0;
1940                 }
1941 #endif
1942         }
1943         for(i = 0; i < 2; i++) {
1944                 if(0 != encoder->private_->integer_signal_mid_side_unaligned[i]) {
1945                         free(encoder->private_->integer_signal_mid_side_unaligned[i]);
1946                         encoder->private_->integer_signal_mid_side_unaligned[i] = 0;
1947                 }
1948 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1949                 if(0 != encoder->private_->real_signal_mid_side_unaligned[i]) {
1950                         free(encoder->private_->real_signal_mid_side_unaligned[i]);
1951                         encoder->private_->real_signal_mid_side_unaligned[i] = 0;
1952                 }
1953 #endif
1954         }
1955 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1956         for(i = 0; i < encoder->protected_->num_apodizations; i++) {
1957                 if(0 != encoder->private_->window_unaligned[i]) {
1958                         free(encoder->private_->window_unaligned[i]);
1959                         encoder->private_->window_unaligned[i] = 0;
1960                 }
1961         }
1962         if(0 != encoder->private_->windowed_signal_unaligned) {
1963                 free(encoder->private_->windowed_signal_unaligned);
1964                 encoder->private_->windowed_signal_unaligned = 0;
1965         }
1966 #endif
1967         for(channel = 0; channel < encoder->protected_->channels; channel++) {
1968                 for(i = 0; i < 2; i++) {
1969                         if(0 != encoder->private_->residual_workspace_unaligned[channel][i]) {
1970                                 free(encoder->private_->residual_workspace_unaligned[channel][i]);
1971                                 encoder->private_->residual_workspace_unaligned[channel][i] = 0;
1972                         }
1973                 }
1974         }
1975         for(channel = 0; channel < 2; channel++) {
1976                 for(i = 0; i < 2; i++) {
1977                         if(0 != encoder->private_->residual_workspace_mid_side_unaligned[channel][i]) {
1978                                 free(encoder->private_->residual_workspace_mid_side_unaligned[channel][i]);
1979                                 encoder->private_->residual_workspace_mid_side_unaligned[channel][i] = 0;
1980                         }
1981                 }
1982         }
1983         if(0 != encoder->private_->abs_residual_unaligned) {
1984                 free(encoder->private_->abs_residual_unaligned);
1985                 encoder->private_->abs_residual_unaligned = 0;
1986         }
1987         if(0 != encoder->private_->abs_residual_partition_sums_unaligned) {
1988                 free(encoder->private_->abs_residual_partition_sums_unaligned);
1989                 encoder->private_->abs_residual_partition_sums_unaligned = 0;
1990         }
1991         if(0 != encoder->private_->raw_bits_per_partition_unaligned) {
1992                 free(encoder->private_->raw_bits_per_partition_unaligned);
1993                 encoder->private_->raw_bits_per_partition_unaligned = 0;
1994         }
1995         if(encoder->protected_->verify) {
1996                 for(i = 0; i < encoder->protected_->channels; i++) {
1997                         if(0 != encoder->private_->verify.input_fifo.data[i]) {
1998                                 free(encoder->private_->verify.input_fifo.data[i]);
1999                                 encoder->private_->verify.input_fifo.data[i] = 0;
2000                         }
2001                 }
2002         }
2003         FLAC__bitbuffer_free(encoder->private_->frame);
2004 }
2005
2006 FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size)
2007 {
2008         FLAC__bool ok;
2009         unsigned i, channel;
2010
2011         FLAC__ASSERT(new_size > 0);
2012         FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
2013         FLAC__ASSERT(encoder->private_->current_sample_number == 0);
2014
2015         /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */
2016         if(new_size <= encoder->private_->input_capacity)
2017                 return true;
2018
2019         ok = true;
2020
2021         /* WATCHOUT: FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx()
2022          * requires that the input arrays (in our case the integer signals)
2023          * have a buffer of up to 3 zeroes in front (at negative indices) for
2024          * alignment purposes; we use 4 to keep the data well-aligned.
2025          */
2026
2027         for(i = 0; ok && i < encoder->protected_->channels; i++) {
2028                 ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size+4, &encoder->private_->integer_signal_unaligned[i], &encoder->private_->integer_signal[i]);
2029 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2030                 if(encoder->protected_->max_lpc_order > 0)
2031                         ok = ok && FLAC__memory_alloc_aligned_real_array(new_size, &encoder->private_->real_signal_unaligned[i], &encoder->private_->real_signal[i]);
2032 #endif
2033                 memset(encoder->private_->integer_signal[i], 0, sizeof(FLAC__int32)*4);
2034                 encoder->private_->integer_signal[i] += 4;
2035         }
2036         for(i = 0; ok && i < 2; i++) {
2037                 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]);
2038 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2039                 if(encoder->protected_->max_lpc_order > 0)
2040                         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]);
2041 #endif
2042                 memset(encoder->private_->integer_signal_mid_side[i], 0, sizeof(FLAC__int32)*4);
2043                 encoder->private_->integer_signal_mid_side[i] += 4;
2044         }
2045 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2046         if(ok && encoder->protected_->max_lpc_order > 0) {
2047                 for(i = 0; ok && i < encoder->protected_->num_apodizations; i++)
2048                         ok = ok && FLAC__memory_alloc_aligned_real_array(new_size, &encoder->private_->window_unaligned[i], &encoder->private_->window[i]);
2049                 ok = ok && FLAC__memory_alloc_aligned_real_array(new_size, &encoder->private_->windowed_signal_unaligned, &encoder->private_->windowed_signal);
2050         }
2051 #endif
2052         for(channel = 0; ok && channel < encoder->protected_->channels; channel++) {
2053                 for(i = 0; ok && i < 2; i++) {
2054                         ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size, &encoder->private_->residual_workspace_unaligned[channel][i], &encoder->private_->residual_workspace[channel][i]);
2055                 }
2056         }
2057         for(channel = 0; ok && channel < 2; channel++) {
2058                 for(i = 0; ok && i < 2; i++) {
2059                         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]);
2060                 }
2061         }
2062         ok = ok && FLAC__memory_alloc_aligned_uint32_array(new_size, &encoder->private_->abs_residual_unaligned, &encoder->private_->abs_residual);
2063         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 */
2064                 ok = ok && FLAC__memory_alloc_aligned_uint64_array(new_size * 2, &encoder->private_->abs_residual_partition_sums_unaligned, &encoder->private_->abs_residual_partition_sums);
2065         if(encoder->protected_->do_escape_coding)
2066                 ok = ok && FLAC__memory_alloc_aligned_unsigned_array(new_size * 2, &encoder->private_->raw_bits_per_partition_unaligned, &encoder->private_->raw_bits_per_partition);
2067
2068         if(ok)
2069                 encoder->private_->input_capacity = new_size;
2070         else
2071                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2072
2073 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2074         if(ok && encoder->protected_->max_lpc_order > 0) {
2075                 for(i = 0; ok && i < encoder->protected_->num_apodizations; i++) {
2076                         switch(encoder->protected_->apodizations[i].type) {
2077                                 case FLAC__APODIZATION_BARTLETT:
2078                                         FLAC__window_bartlett(encoder->private_->window[i], new_size);
2079                                         break;
2080                                 case FLAC__APODIZATION_BARTLETT_HANN:
2081                                         FLAC__window_bartlett_hann(encoder->private_->window[i], new_size);
2082                                         break;
2083                                 case FLAC__APODIZATION_BLACKMAN:
2084                                         FLAC__window_blackman(encoder->private_->window[i], new_size);
2085                                         break;
2086                                 case FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE:
2087                                         FLAC__window_blackman_harris_4term_92db_sidelobe(encoder->private_->window[i], new_size);
2088                                         break;
2089                                 case FLAC__APODIZATION_CONNES:
2090                                         FLAC__window_connes(encoder->private_->window[i], new_size);
2091                                         break;
2092                                 case FLAC__APODIZATION_FLATTOP:
2093                                         FLAC__window_flattop(encoder->private_->window[i], new_size);
2094                                         break;
2095                                 case FLAC__APODIZATION_GAUSS:
2096                                         FLAC__window_gauss(encoder->private_->window[i], new_size, encoder->protected_->apodizations[i].parameters.gauss.stddev);
2097                                         break;
2098                                 case FLAC__APODIZATION_HAMMING:
2099                                         FLAC__window_hamming(encoder->private_->window[i], new_size);
2100                                         break;
2101                                 case FLAC__APODIZATION_HANN:
2102                                         FLAC__window_hann(encoder->private_->window[i], new_size);
2103                                         break;
2104                                 case FLAC__APODIZATION_KAISER_BESSEL:
2105                                         FLAC__window_kaiser_bessel(encoder->private_->window[i], new_size);
2106                                         break;
2107                                 case FLAC__APODIZATION_NUTTALL:
2108                                         FLAC__window_nuttall(encoder->private_->window[i], new_size);
2109                                         break;
2110                                 case FLAC__APODIZATION_RECTANGLE:
2111                                         FLAC__window_rectangle(encoder->private_->window[i], new_size);
2112                                         break;
2113                                 case FLAC__APODIZATION_TRIANGLE:
2114                                         FLAC__window_triangle(encoder->private_->window[i], new_size);
2115                                         break;
2116                                 case FLAC__APODIZATION_TUKEY:
2117                                         FLAC__window_tukey(encoder->private_->window[i], new_size, encoder->protected_->apodizations[i].parameters.tukey.p);
2118                                         break;
2119                                 case FLAC__APODIZATION_WELCH:
2120                                         FLAC__window_welch(encoder->private_->window[i], new_size);
2121                                         break;
2122                                 default:
2123                                         FLAC__ASSERT(0);
2124                                         /* double protection */
2125                                         FLAC__window_hann(encoder->private_->window[i], new_size);
2126                                         break;
2127                         }
2128                 }
2129         }
2130 #endif
2131
2132         return ok;
2133 }
2134
2135 FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples)
2136 {
2137         const FLAC__byte *buffer;
2138         unsigned bytes;
2139
2140         FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(encoder->private_->frame));
2141
2142         FLAC__bitbuffer_get_buffer(encoder->private_->frame, &buffer, &bytes);
2143
2144         if(encoder->protected_->verify) {
2145                 encoder->private_->verify.output.data = buffer;
2146                 encoder->private_->verify.output.bytes = bytes;
2147                 if(encoder->private_->verify.state_hint == ENCODER_IN_MAGIC) {
2148                         encoder->private_->verify.needs_magic_hack = true;
2149                 }
2150                 else {
2151                         if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder)) {
2152                                 FLAC__bitbuffer_release_buffer(encoder->private_->frame);
2153                                 if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
2154                                         encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
2155                                 return false;
2156                         }
2157                 }
2158         }
2159
2160         if(write_frame_(encoder, buffer, bytes, samples) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2161                 FLAC__bitbuffer_release_buffer(encoder->private_->frame);
2162                 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2163                 return false;
2164         }
2165
2166         FLAC__bitbuffer_release_buffer(encoder->private_->frame);
2167
2168         if(samples > 0) {
2169                 encoder->private_->streaminfo.data.stream_info.min_framesize = min(bytes, encoder->private_->streaminfo.data.stream_info.min_framesize);
2170                 encoder->private_->streaminfo.data.stream_info.max_framesize = max(bytes, encoder->private_->streaminfo.data.stream_info.max_framesize);
2171         }
2172
2173         return true;
2174 }
2175
2176 FLAC__StreamEncoderWriteStatus write_frame_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples)
2177 {
2178         FLAC__StreamEncoderWriteStatus status;
2179         FLAC__uint64 output_position = 0;
2180
2181         /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */
2182         if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &output_position, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) {
2183                 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2184                 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
2185         }
2186
2187         /*
2188          * Watch for the STREAMINFO block and first SEEKTABLE block to go by and store their offsets.
2189          */
2190         if(samples == 0) {
2191                 FLAC__MetadataType type = (buffer[0] & 0x7f);
2192                 if(type == FLAC__METADATA_TYPE_STREAMINFO)
2193                         encoder->protected_->streaminfo_offset = output_position;
2194                 else if(type == FLAC__METADATA_TYPE_SEEKTABLE && encoder->protected_->seektable_offset == 0)
2195                         encoder->protected_->seektable_offset = output_position;
2196         }
2197
2198         /*
2199          * Mark the current seek point if hit (if audio_offset == 0 that
2200          * means we're still writing metadata and haven't hit the first
2201          * frame yet)
2202          */
2203         if(0 != encoder->private_->seek_table && encoder->protected_->audio_offset > 0 && encoder->private_->seek_table->num_points > 0) {
2204                 const unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder);
2205                 const FLAC__uint64 frame_first_sample = encoder->private_->samples_written;
2206                 const FLAC__uint64 frame_last_sample = frame_first_sample + (FLAC__uint64)blocksize - 1;
2207                 FLAC__uint64 test_sample;
2208                 unsigned i;
2209                 for(i = encoder->private_->first_seekpoint_to_check; i < encoder->private_->seek_table->num_points; i++) {
2210                         test_sample = encoder->private_->seek_table->points[i].sample_number;
2211                         if(test_sample > frame_last_sample) {
2212                                 break;
2213                         }
2214                         else if(test_sample >= frame_first_sample) {
2215                                 encoder->private_->seek_table->points[i].sample_number = frame_first_sample;
2216                                 encoder->private_->seek_table->points[i].stream_offset = output_position - encoder->protected_->audio_offset;
2217                                 encoder->private_->seek_table->points[i].frame_samples = blocksize;
2218                                 encoder->private_->first_seekpoint_to_check++;
2219                                 /* DO NOT: "break;" and here's why:
2220                                  * The seektable template may contain more than one target
2221                                  * sample for any given frame; we will keep looping, generating
2222                                  * duplicate seekpoints for them, and we'll clean it up later,
2223                                  * just before writing the seektable back to the metadata.
2224                                  */
2225                         }
2226                         else {
2227                                 encoder->private_->first_seekpoint_to_check++;
2228                         }
2229                 }
2230         }
2231
2232         status = encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data);
2233
2234         if(status == FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2235                 encoder->private_->bytes_written += bytes;
2236                 encoder->private_->samples_written += samples;
2237                 /* we keep a high watermark on the number of frames written because
2238                  * when the encoder goes back to write metadata, 'current_frame'
2239                  * will drop back to 0.
2240                  */
2241                 encoder->private_->frames_written = max(encoder->private_->frames_written, encoder->private_->current_frame_number+1);
2242         }
2243         else
2244                 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2245
2246         return status;
2247 }
2248
2249 /* Gets called when the encoding process has finished so that we can update the STREAMINFO and SEEKTABLE blocks.  */
2250 void update_metadata_(const FLAC__StreamEncoder *encoder)
2251 {
2252         FLAC__byte b[max(6, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)];
2253         const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo;
2254         const FLAC__uint64 samples = metadata->data.stream_info.total_samples;
2255         const unsigned min_framesize = metadata->data.stream_info.min_framesize;
2256         const unsigned max_framesize = metadata->data.stream_info.max_framesize;
2257         const unsigned bps = metadata->data.stream_info.bits_per_sample;
2258         FLAC__StreamEncoderSeekStatus seek_status;
2259
2260         FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO);
2261
2262         /* All this is based on intimate knowledge of the stream header
2263          * layout, but a change to the header format that would break this
2264          * would also break all streams encoded in the previous format.
2265          */
2266
2267         /*
2268          * Write MD5 signature
2269          */
2270         {
2271                 const unsigned md5_offset =
2272                         FLAC__STREAM_METADATA_HEADER_LENGTH +
2273                         (
2274                                 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
2275                                 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
2276                                 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
2277                                 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
2278                                 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
2279                                 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
2280                                 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN +
2281                                 FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN
2282                         ) / 8;
2283
2284                 if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + md5_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
2285                         if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
2286                                 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2287                         return;
2288                 }
2289                 if(encoder->private_->write_callback(encoder, metadata->data.stream_info.md5sum, 16, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2290                         encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2291                         return;
2292                 }
2293         }
2294
2295         /*
2296          * Write total samples
2297          */
2298         {
2299                 const unsigned total_samples_byte_offset =
2300                         FLAC__STREAM_METADATA_HEADER_LENGTH +
2301                         (
2302                                 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
2303                                 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
2304                                 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
2305                                 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
2306                                 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
2307                                 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
2308                                 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
2309                                 - 4
2310                         ) / 8;
2311
2312                 b[0] = ((FLAC__byte)(bps-1) << 4) | (FLAC__byte)((samples >> 32) & 0x0F);
2313                 b[1] = (FLAC__byte)((samples >> 24) & 0xFF);
2314                 b[2] = (FLAC__byte)((samples >> 16) & 0xFF);
2315                 b[3] = (FLAC__byte)((samples >> 8) & 0xFF);
2316                 b[4] = (FLAC__byte)(samples & 0xFF);
2317                 if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + total_samples_byte_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
2318                         if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
2319                                 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2320                         return;
2321                 }
2322                 if(encoder->private_->write_callback(encoder, b, 5, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2323                         encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2324                         return;
2325                 }
2326         }
2327
2328         /*
2329          * Write min/max framesize
2330          */
2331         {
2332                 const unsigned min_framesize_offset =
2333                         FLAC__STREAM_METADATA_HEADER_LENGTH +
2334                         (
2335                                 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
2336                                 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
2337                         ) / 8;
2338
2339                 b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF);
2340                 b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF);
2341                 b[2] = (FLAC__byte)(min_framesize & 0xFF);
2342                 b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF);
2343                 b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF);
2344                 b[5] = (FLAC__byte)(max_framesize & 0xFF);
2345                 if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + min_framesize_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
2346                         if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
2347                                 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2348                         return;
2349                 }
2350                 if(encoder->private_->write_callback(encoder, b, 6, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2351                         encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2352                         return;
2353                 }
2354         }
2355
2356         /*
2357          * Write seektable
2358          */
2359         if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) {
2360                 unsigned i;
2361
2362                 FLAC__format_seektable_sort(encoder->private_->seek_table);
2363
2364                 FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table));
2365
2366                 if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->seektable_offset + FLAC__STREAM_METADATA_HEADER_LENGTH, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
2367                         if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR)
2368                                 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2369                         return;
2370                 }
2371
2372                 for(i = 0; i < encoder->private_->seek_table->num_points; i++) {
2373                         FLAC__uint64 xx;
2374                         unsigned x;
2375                         xx = encoder->private_->seek_table->points[i].sample_number;
2376                         b[7] = (FLAC__byte)xx; xx >>= 8;
2377                         b[6] = (FLAC__byte)xx; xx >>= 8;
2378                         b[5] = (FLAC__byte)xx; xx >>= 8;
2379                         b[4] = (FLAC__byte)xx; xx >>= 8;
2380                         b[3] = (FLAC__byte)xx; xx >>= 8;
2381                         b[2] = (FLAC__byte)xx; xx >>= 8;
2382                         b[1] = (FLAC__byte)xx; xx >>= 8;
2383                         b[0] = (FLAC__byte)xx; xx >>= 8;
2384                         xx = encoder->private_->seek_table->points[i].stream_offset;
2385                         b[15] = (FLAC__byte)xx; xx >>= 8;
2386                         b[14] = (FLAC__byte)xx; xx >>= 8;
2387                         b[13] = (FLAC__byte)xx; xx >>= 8;
2388                         b[12] = (FLAC__byte)xx; xx >>= 8;
2389                         b[11] = (FLAC__byte)xx; xx >>= 8;
2390                         b[10] = (FLAC__byte)xx; xx >>= 8;
2391                         b[9] = (FLAC__byte)xx; xx >>= 8;
2392                         b[8] = (FLAC__byte)xx; xx >>= 8;
2393                         x = encoder->private_->seek_table->points[i].frame_samples;
2394                         b[17] = (FLAC__byte)x; x >>= 8;
2395                         b[16] = (FLAC__byte)x; x >>= 8;
2396                         if(encoder->private_->write_callback(encoder, b, 18, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2397                                 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2398                                 return;
2399                         }
2400                 }
2401         }
2402 }
2403
2404 FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame)
2405 {
2406         FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
2407
2408         /*
2409          * Accumulate raw signal to the MD5 signature
2410          */
2411         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)) {
2412                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2413                 return false;
2414         }
2415
2416         /*
2417          * Process the frame header and subframes into the frame bitbuffer
2418          */
2419         if(!process_subframes_(encoder, is_last_frame)) {
2420                 /* the above function sets the state for us in case of an error */
2421                 return false;
2422         }
2423
2424         /*
2425          * Zero-pad the frame to a byte_boundary
2426          */
2427         if(!FLAC__bitbuffer_zero_pad_to_byte_boundary(encoder->private_->frame)) {
2428                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2429                 return false;
2430         }
2431
2432         /*
2433          * CRC-16 the whole thing
2434          */
2435         FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(encoder->private_->frame));
2436         FLAC__bitbuffer_write_raw_uint32(encoder->private_->frame, FLAC__bitbuffer_get_write_crc16(encoder->private_->frame), FLAC__FRAME_FOOTER_CRC_LEN);
2437
2438         /*
2439          * Write it
2440          */
2441         if(!write_bitbuffer_(encoder, encoder->protected_->blocksize)) {
2442                 /* the above function sets the state for us in case of an error */
2443                 return false;
2444         }
2445
2446         /*
2447          * Get ready for the next frame
2448          */
2449         encoder->private_->current_sample_number = 0;
2450         encoder->private_->current_frame_number++;
2451         encoder->private_->streaminfo.data.stream_info.total_samples += (FLAC__uint64)encoder->protected_->blocksize;
2452
2453         return true;
2454 }
2455
2456 FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame)
2457 {
2458         FLAC__FrameHeader frame_header;
2459         unsigned channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order;
2460         FLAC__bool do_independent, do_mid_side, precompute_partition_sums;
2461
2462         /*
2463          * Calculate the min,max Rice partition orders
2464          */
2465         if(is_last_frame) {
2466                 max_partition_order = 0;
2467         }
2468         else {
2469                 max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize(encoder->protected_->blocksize);
2470                 max_partition_order = min(max_partition_order, encoder->protected_->max_residual_partition_order);
2471         }
2472         min_partition_order = min(min_partition_order, max_partition_order);
2473
2474         precompute_partition_sums = encoder->private_->precompute_partition_sums && ((max_partition_order > min_partition_order) || encoder->protected_->do_escape_coding);
2475
2476         /*
2477          * Setup the frame
2478          */
2479         if(!FLAC__bitbuffer_clear(encoder->private_->frame)) {
2480                 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2481                 return false;
2482         }
2483         frame_header.blocksize = encoder->protected_->blocksize;
2484         frame_header.sample_rate = encoder->protected_->sample_rate;
2485         frame_header.channels = encoder->protected_->channels;
2486         frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */
2487         frame_header.bits_per_sample = encoder->protected_->bits_per_sample;
2488         frame_header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER;
2489         frame_header.number.frame_number = encoder->private_->current_frame_number;
2490
2491         /*
2492          * Figure out what channel assignments to try
2493          */
2494         if(encoder->protected_->do_mid_side_stereo) {
2495                 if(encoder->protected_->loose_mid_side_stereo) {
2496                         if(encoder->private_->loose_mid_side_stereo_frame_count == 0) {
2497                                 do_independent = true;
2498                                 do_mid_side = true;
2499                         }
2500                         else {
2501                                 do_independent = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT);
2502                                 do_mid_side = !do_independent;
2503                         }
2504                 }
2505                 else {
2506                         do_independent = true;
2507                         do_mid_side = true;
2508                 }
2509         }
2510         else {
2511                 do_independent = true;
2512                 do_mid_side = false;
2513         }
2514
2515         FLAC__ASSERT(do_independent || do_mid_side);
2516
2517         /*
2518          * Check for wasted bits; set effective bps for each subframe
2519          */
2520         if(do_independent) {
2521                 for(channel = 0; channel < encoder->protected_->channels; channel++) {
2522                         const unsigned w = get_wasted_bits_(encoder->private_->integer_signal[channel], encoder->protected_->blocksize);
2523                         encoder->private_->subframe_workspace[channel][0].wasted_bits = encoder->private_->subframe_workspace[channel][1].wasted_bits = w;
2524                         encoder->private_->subframe_bps[channel] = encoder->protected_->bits_per_sample - w;
2525                 }
2526         }
2527         if(do_mid_side) {
2528                 FLAC__ASSERT(encoder->protected_->channels == 2);
2529                 for(channel = 0; channel < 2; channel++) {
2530                         const unsigned w = get_wasted_bits_(encoder->private_->integer_signal_mid_side[channel], encoder->protected_->blocksize);
2531                         encoder->private_->subframe_workspace_mid_side[channel][0].wasted_bits = encoder->private_->subframe_workspace_mid_side[channel][1].wasted_bits = w;
2532                         encoder->private_->subframe_bps_mid_side[channel] = encoder->protected_->bits_per_sample - w + (channel==0? 0:1);
2533                 }
2534         }
2535
2536         /*
2537          * First do a normal encoding pass of each independent channel
2538          */
2539         if(do_independent) {
2540                 for(channel = 0; channel < encoder->protected_->channels; channel++) {
2541                         if(!
2542                                 process_subframe_(
2543                                         encoder,
2544                                         min_partition_order,
2545                                         max_partition_order,
2546                                         precompute_partition_sums,
2547                                         &frame_header,
2548                                         encoder->private_->subframe_bps[channel],
2549                                         encoder->private_->integer_signal[channel],
2550 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2551                                         encoder->private_->real_signal[channel],
2552 #endif
2553                                         encoder->private_->subframe_workspace_ptr[channel],
2554                                         encoder->private_->partitioned_rice_contents_workspace_ptr[channel],
2555                                         encoder->private_->residual_workspace[channel],
2556                                         encoder->private_->best_subframe+channel,
2557                                         encoder->private_->best_subframe_bits+channel
2558 #ifdef WINDOW_DEBUG_OUTPUT
2559                                         ,channel
2560 #endif
2561                                 )
2562                         )
2563                                 return false;
2564                 }
2565         }
2566
2567         /*
2568          * Now do mid and side channels if requested
2569          */
2570         if(do_mid_side) {
2571                 FLAC__ASSERT(encoder->protected_->channels == 2);
2572
2573                 for(channel = 0; channel < 2; channel++) {
2574                         if(!
2575                                 process_subframe_(
2576                                         encoder,
2577                                         min_partition_order,
2578                                         max_partition_order,
2579                                         precompute_partition_sums,
2580                                         &frame_header,
2581                                         encoder->private_->subframe_bps_mid_side[channel],
2582                                         encoder->private_->integer_signal_mid_side[channel],
2583 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2584                                         encoder->private_->real_signal_mid_side[channel],
2585 #endif
2586                                         encoder->private_->subframe_workspace_ptr_mid_side[channel],
2587                                         encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[channel],
2588                                         encoder->private_->residual_workspace_mid_side[channel],
2589                                         encoder->private_->best_subframe_mid_side+channel,
2590                                         encoder->private_->best_subframe_bits_mid_side+channel
2591 #ifdef WINDOW_DEBUG_OUTPUT
2592                                         ,channel
2593 #endif
2594                                 )
2595                         )
2596                                 return false;
2597                 }
2598         }
2599
2600         /*
2601          * Compose the frame bitbuffer
2602          */
2603         if(do_mid_side) {
2604                 unsigned left_bps = 0, right_bps = 0; /* initialized only to prevent superfluous compiler warning */
2605                 FLAC__Subframe *left_subframe = 0, *right_subframe = 0; /* initialized only to prevent superfluous compiler warning */
2606                 FLAC__ChannelAssignment channel_assignment;
2607 #ifdef WINDOW_DEBUG_OUTPUT
2608                 unsigned left_bits = 0, right_bits = 0;
2609 #endif
2610
2611                 FLAC__ASSERT(encoder->protected_->channels == 2);
2612
2613                 if(encoder->protected_->loose_mid_side_stereo && encoder->private_->loose_mid_side_stereo_frame_count > 0) {
2614                         channel_assignment = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT? FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT : FLAC__CHANNEL_ASSIGNMENT_MID_SIDE);
2615                 }
2616                 else {
2617                         unsigned bits[4]; /* WATCHOUT - indexed by FLAC__ChannelAssignment */
2618                         unsigned min_bits;
2619                         FLAC__ChannelAssignment ca;
2620
2621                         FLAC__ASSERT(do_independent && do_mid_side);
2622
2623                         /* We have to figure out which channel assignent results in the smallest frame */
2624                         bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = encoder->private_->best_subframe_bits         [0] + encoder->private_->best_subframe_bits         [1];
2625                         bits[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE  ] = encoder->private_->best_subframe_bits         [0] + encoder->private_->best_subframe_bits_mid_side[1];
2626                         bits[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE ] = encoder->private_->best_subframe_bits         [1] + encoder->private_->best_subframe_bits_mid_side[1];
2627                         bits[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE   ] = encoder->private_->best_subframe_bits_mid_side[0] + encoder->private_->best_subframe_bits_mid_side[1];
2628
2629                         for(channel_assignment = (FLAC__ChannelAssignment)0, min_bits = bits[0], ca = (FLAC__ChannelAssignment)1; (int)ca <= 3; ca = (FLAC__ChannelAssignment)((int)ca + 1)) {
2630                                 if(bits[ca] < min_bits) {
2631                                         min_bits = bits[ca];
2632                                         channel_assignment = ca;
2633                                 }
2634                         }
2635                 }
2636
2637                 frame_header.channel_assignment = channel_assignment;
2638
2639                 if(!FLAC__frame_add_header(&frame_header, encoder->protected_->streamable_subset, encoder->private_->frame)) {
2640                         encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
2641                         return false;
2642                 }
2643
2644                 switch(channel_assignment) {
2645                         case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
2646                                 left_subframe  = &encoder->private_->subframe_workspace         [0][encoder->private_->best_subframe         [0]];
2647                                 right_subframe = &encoder->private_->subframe_workspace         [1][encoder->private_->best_subframe         [1]];
2648 #ifdef WINDOW_DEBUG_OUTPUT
2649                                 left_bits      = encoder->private_->best_subframe_bits          [0];
2650                                 right_bits     = encoder->private_->best_subframe_bits          [1];
2651 #endif
2652                                 break;
2653                         case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
2654                                 left_subframe  = &encoder->private_->subframe_workspace         [0][encoder->private_->best_subframe         [0]];
2655                                 right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
2656 #ifdef WINDOW_DEBUG_OUTPUT
2657                                 left_bits      = encoder->private_->best_subframe_bits          [0];
2658                                 right_bits     = encoder->private_->best_subframe_bits_mid_side [1];
2659 #endif
2660                                 break;
2661                         case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
2662                                 left_subframe  = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
2663                                 right_subframe = &encoder->private_->subframe_workspace         [1][encoder->private_->best_subframe         [1]];
2664 #ifdef WINDOW_DEBUG_OUTPUT
2665                                 left_bits      = encoder->private_->best_subframe_bits_mid_side [1];
2666                                 right_bits     = encoder->private_->best_subframe_bits          [1];
2667 #endif
2668                                 break;
2669                         case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
2670                                 left_subframe  = &encoder->private_->subframe_workspace_mid_side[0][encoder->private_->best_subframe_mid_side[0]];
2671                                 right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
2672 #ifdef WINDOW_DEBUG_OUTPUT
2673                                 left_bits      = encoder->private_->best_subframe_bits_mid_side [0];
2674                                 right_bits     = encoder->private_->best_subframe_bits_mid_side [1];
2675 #endif
2676                                 break;
2677                         default:
2678                                 FLAC__ASSERT(0);
2679                 }
2680
2681                 switch(channel_assignment) {
2682                         case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
2683                                 left_bps  = encoder->private_->subframe_bps         [0];
2684                                 right_bps = encoder->private_->subframe_bps         [1];
2685                                 break;
2686                         case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
2687                                 left_bps  = encoder->private_->subframe_bps         [0];
2688                                 right_bps = encoder->private_->subframe_bps_mid_side[1];
2689                                 break;
2690                         case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
2691                                 left_bps  = encoder->private_->subframe_bps_mid_side[1];
2692                                 right_bps = encoder->private_->subframe_bps         [1];
2693                                 break;
2694                         case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
2695                                 left_bps  = encoder->private_->subframe_bps_mid_side[0];
2696                                 right_bps = encoder->private_->subframe_bps_mid_side[1];
2697                                 break;
2698                         default:
2699                                 FLAC__ASSERT(0);
2700                 }
2701
2702                 /* note that encoder_add_subframe_ sets the state for us in case of an error */
2703 #ifdef WINDOW_DEBUG_OUTPUT
2704                 if(!add_subframe_(encoder, &frame_header, left_bps , left_subframe , encoder->private_->frame, left_bits))
2705                         return false;
2706                 if(!add_subframe_(encoder, &frame_header, right_bps, right_subframe, encoder->private_->frame, right_bits))
2707                         return false;
2708 #else
2709                 if(!add_subframe_(encoder, &frame_header, left_bps , left_subframe , encoder->private_->frame))
2710                         return false;
2711                 if(!add_subframe_(encoder, &frame_header, right_bps, right_subframe, encoder->private_->frame))
2712                         return false;
2713 #endif
2714         }
2715         else {
2716                 if(!FLAC__frame_add_header(&frame_header, encoder->protected_->streamable_subset, encoder->private_->frame)) {
2717                         encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
2718                         return false;
2719                 }
2720
2721                 for(channel = 0; channel < encoder->protected_->channels; channel++) {
2722 #ifdef WINDOW_DEBUG_OUTPUT
2723                         if(!add_subframe_(encoder, &frame_header, encoder->private_->subframe_bps[channel], &encoder->private_->subframe_workspace[channel][encoder->private_->best_subframe[channel]], encoder->private_->frame, encoder->private_->best_subframe_bits[channel]))
2724 #else
2725                         if(!add_subframe_(encoder, &frame_header, encoder->private_->subframe_bps[channel], &encoder->private_->subframe_workspace[channel][encoder->private_->best_subframe[channel]], encoder->private_->frame))
2726 #endif
2727                         {
2728                                 /* the above function sets the state for us in case of an error */
2729                                 return false;
2730                         }
2731                 }
2732         }
2733
2734         if(encoder->protected_->loose_mid_side_stereo) {
2735                 encoder->private_->loose_mid_side_stereo_frame_count++;
2736                 if(encoder->private_->loose_mid_side_stereo_frame_count >= encoder->private_->loose_mid_side_stereo_frames)
2737                         encoder->private_->loose_mid_side_stereo_frame_count = 0;
2738         }
2739
2740         encoder->private_->last_channel_assignment = frame_header.channel_assignment;
2741
2742         return true;
2743 }
2744
2745 FLAC__bool process_subframe_(
2746         FLAC__StreamEncoder *encoder,
2747         unsigned min_partition_order,
2748         unsigned max_partition_order,
2749         FLAC__bool precompute_partition_sums,
2750         const FLAC__FrameHeader *frame_header,
2751         unsigned subframe_bps,
2752         const FLAC__int32 integer_signal[],
2753 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2754         const FLAC__real real_signal[],
2755 #endif
2756         FLAC__Subframe *subframe[2],
2757         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2],
2758         FLAC__int32 *residual[2],
2759         unsigned *best_subframe,
2760         unsigned *best_bits
2761 #ifdef WINDOW_DEBUG_OUTPUT
2762         ,unsigned subframe_number
2763 #endif
2764 )
2765 {
2766 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2767         FLAC__float fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
2768 #else
2769         FLAC__fixedpoint fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
2770 #endif
2771 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2772         FLAC__double lpc_residual_bits_per_sample;
2773         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 */
2774         FLAC__double lpc_error[FLAC__MAX_LPC_ORDER];
2775         unsigned min_lpc_order, max_lpc_order, lpc_order;
2776         unsigned min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision;
2777 #endif
2778         unsigned min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order;
2779         unsigned rice_parameter;
2780         unsigned _candidate_bits, _best_bits;
2781         unsigned _best_subframe;
2782
2783         /* verbatim subframe is the baseline against which we measure other compressed subframes */
2784         _best_subframe = 0;
2785         if(encoder->private_->disable_verbatim_subframes && frame_header->blocksize >= FLAC__MAX_FIXED_ORDER)
2786                 _best_bits = UINT_MAX;
2787         else
2788                 _best_bits = evaluate_verbatim_subframe_(integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
2789
2790         if(frame_header->blocksize >= FLAC__MAX_FIXED_ORDER) {
2791                 unsigned signal_is_constant = false;
2792                 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);
2793                 /* check for constant subframe */
2794                 if(
2795                         !encoder->private_->disable_constant_subframes &&
2796 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2797                         fixed_residual_bits_per_sample[1] == 0.0
2798 #else
2799                         fixed_residual_bits_per_sample[1] == FLAC__FP_ZERO
2800 #endif
2801                 ) {
2802                         /* the above means it's possible all samples are the same value; now double-check it: */
2803                         unsigned i;
2804                         signal_is_constant = true;
2805                         for(i = 1; i < frame_header->blocksize; i++) {
2806                                 if(integer_signal[0] != integer_signal[i]) {
2807                                         signal_is_constant = false;
2808                                         break;
2809                                 }
2810                         }
2811                 }
2812                 if(signal_is_constant) {
2813                         _candidate_bits = evaluate_constant_subframe_(integer_signal[0], subframe_bps, subframe[!_best_subframe]);
2814                         if(_candidate_bits < _best_bits) {
2815                                 _best_subframe = !_best_subframe;
2816                                 _best_bits = _candidate_bits;
2817                         }
2818                 }
2819                 else {
2820                         if(!encoder->private_->disable_fixed_subframes || (encoder->protected_->max_lpc_order == 0 && _best_bits == UINT_MAX)) {
2821                                 /* encode fixed */
2822                                 if(encoder->protected_->do_exhaustive_model_search) {
2823                                         min_fixed_order = 0;
2824                                         max_fixed_order = FLAC__MAX_FIXED_ORDER;
2825                                 }
2826                                 else {
2827                                         min_fixed_order = max_fixed_order = guess_fixed_order;
2828                                 }
2829                                 for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) {
2830 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2831                                         if(fixed_residual_bits_per_sample[fixed_order] >= (FLAC__float)subframe_bps)
2832                                                 continue; /* don't even try */
2833                                         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 */
2834 #else
2835                                         if(FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample[fixed_order]) >= (int)subframe_bps)
2836                                                 continue; /* don't even try */
2837                                         rice_parameter = (fixed_residual_bits_per_sample[fixed_order] > FLAC__FP_ZERO)? (unsigned)FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample[fixed_order]+FLAC__FP_ONE_HALF) : 0; /* 0.5 is for rounding */
2838 #endif
2839                                         rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */
2840                                         if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
2841 #ifdef DEBUG_VERBOSE
2842                                                 fprintf(stderr, "clipping rice_parameter (%u -> %u) @0\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
2843 #endif
2844                                                 rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
2845                                         }
2846                                         _candidate_bits =
2847                                                 evaluate_fixed_subframe_(
2848                                                         encoder,
2849                                                         integer_signal,
2850                                                         residual[!_best_subframe],
2851                                                         encoder->private_->abs_residual,
2852                                                         encoder->private_->abs_residual_partition_sums,
2853                                                         encoder->private_->raw_bits_per_partition,
2854                                                         frame_header->blocksize,
2855                                                         subframe_bps,
2856                                                         fixed_order,
2857                                                         rice_parameter,
2858                                                         min_partition_order,
2859                                                         max_partition_order,
2860                                                         precompute_partition_sums,
2861                                                         encoder->protected_->do_escape_coding,
2862                                                         encoder->protected_->rice_parameter_search_dist,
2863                                                         subframe[!_best_subframe],
2864                                                         partitioned_rice_contents[!_best_subframe]
2865                                                 );
2866                                         if(_candidate_bits < _best_bits) {
2867                                                 _best_subframe = !_best_subframe;
2868                                                 _best_bits = _candidate_bits;
2869                                         }
2870                                 }
2871                         }
2872
2873 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2874                         /* encode lpc */
2875                         if(encoder->protected_->max_lpc_order > 0) {
2876                                 if(encoder->protected_->max_lpc_order >= frame_header->blocksize)
2877                                         max_lpc_order = frame_header->blocksize-1;
2878                                 else
2879                                         max_lpc_order = encoder->protected_->max_lpc_order;
2880                                 if(max_lpc_order > 0) {
2881                                         unsigned a;
2882                                         for (a = 0; a < encoder->protected_->num_apodizations; a++) {
2883                                                 FLAC__lpc_window_data(real_signal, encoder->private_->window[a], encoder->private_->windowed_signal, frame_header->blocksize);
2884                                                 encoder->private_->local_lpc_compute_autocorrelation(encoder->private_->windowed_signal, frame_header->blocksize, max_lpc_order+1, autoc);
2885                                                 /* if autoc[0] == 0.0, the signal is constant and we usually won't get here, but it can happen */
2886                                                 if(autoc[0] != 0.0) {
2887                                                         FLAC__lpc_compute_lp_coefficients(autoc, max_lpc_order, encoder->private_->lp_coeff, lpc_error);
2888                                                         if(encoder->protected_->do_exhaustive_model_search) {
2889                                                                 min_lpc_order = 1;
2890                                                         }
2891                                                         else {
2892                                                                 const unsigned guess_lpc_order =
2893                                                                         FLAC__lpc_compute_best_order(
2894                                                                                 lpc_error,
2895                                                                                 max_lpc_order,
2896                                                                                 frame_header->blocksize,
2897                                                                                 subframe_bps + (
2898                                                                                         encoder->protected_->do_qlp_coeff_prec_search?
2899                                                                                                 FLAC__MIN_QLP_COEFF_PRECISION : /* have to guess; use the min possible size to avoid accidentally favoring lower orders */
2900                                                                                                 encoder->protected_->qlp_coeff_precision
2901                                                                                 )
2902                                                                         );
2903                                                                 min_lpc_order = max_lpc_order = guess_lpc_order;
2904                                                         }
2905                                                         for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order; lpc_order++) {
2906                                                                 lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize-lpc_order);
2907                                                                 if(lpc_residual_bits_per_sample >= (FLAC__double)subframe_bps)
2908                                                                         continue; /* don't even try */
2909                                                                 rice_parameter = (lpc_residual_bits_per_sample > 0.0)? (unsigned)(lpc_residual_bits_per_sample+0.5) : 0; /* 0.5 is for rounding */
2910                                                                 rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */
2911                                                                 if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) {
2912 #ifdef DEBUG_VERBOSE
2913                                                                         fprintf(stderr, "clipping rice_parameter (%u -> %u) @1\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1);
2914 #endif
2915                                                                         rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1;
2916                                                                 }
2917                                                                 if(encoder->protected_->do_qlp_coeff_prec_search) {
2918                                                                         min_qlp_coeff_precision = FLAC__MIN_QLP_COEFF_PRECISION;
2919                                                                         /* try to ensure a 32-bit datapath throughout for 16bps(+1bps for side channel) or less */
2920                                                                         if(subframe_bps <= 17) {
2921                                                                                 max_qlp_coeff_precision = min(32 - subframe_bps - lpc_order, FLAC__MAX_QLP_COEFF_PRECISION);
2922                                                                                 max_qlp_coeff_precision = max(max_qlp_coeff_precision, min_qlp_coeff_precision);
2923                                                                         }
2924                                                                         else
2925                                                                                 max_qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION;
2926                                                                 }
2927                                                                 else {
2928                                                                         min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision;
2929                                                                 }
2930                                                                 for(qlp_coeff_precision = min_qlp_coeff_precision; qlp_coeff_precision <= max_qlp_coeff_precision; qlp_coeff_precision++) {
2931                                                                         _candidate_bits =
2932                                                                                 evaluate_lpc_subframe_(
2933                                                                                         encoder,
2934                                                                                         integer_signal,
2935                                                                                         residual[!_best_subframe],
2936                                                                                         encoder->private_->abs_residual,
2937                                                                                         encoder->private_->abs_residual_partition_sums,
2938                                                                                         encoder->private_->raw_bits_per_partition,
2939                                                                                         encoder->private_->lp_coeff[lpc_order-1],
2940                                                                                         frame_header->blocksize,
2941                                                                                         subframe_bps,
2942                                                                                         lpc_order,
2943                                                                                         qlp_coeff_precision,
2944                                                                                         rice_parameter,
2945                                                                                         min_partition_order,
2946                                                                                         max_partition_order,
2947                                                                                         precompute_partition_sums,
2948                                                                                         encoder->protected_->do_escape_coding,
2949                                                                                         encoder->protected_->rice_parameter_search_dist,
2950                                                                                         subframe[!_best_subframe],
2951                                                                                         partitioned_rice_contents[!_best_subframe]
2952 #ifdef WINDOW_DEBUG_OUTPUT
2953                                                                                         ,frame_header->number.frame_number
2954                                                                                         ,subframe_number
2955                                                                                         ,encoder->protected_->apodizations[a]
2956 #endif
2957                                                                                 );
2958                                                                         if(_candidate_bits > 0) { /* if == 0, there was a problem quantizing the lpcoeffs */
2959                                                                                 if(_candidate_bits < _best_bits) {
2960                                                                                         _best_subframe = !_best_subframe;
2961                                                                                         _best_bits = _candidate_bits;
2962                                                                                 }
2963                                                                         }
2964                                                                 }
2965                                                         }
2966                                                 }
2967                                         }
2968                                 }
2969                         }
2970 #endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
2971                 }
2972         }
2973
2974         /* under rare circumstances this can happen when all but lpc subframe types are disabled: */
2975         if(_best_bits == UINT_MAX) {
2976                 FLAC__ASSERT(_best_subframe == 0);
2977                 _best_bits = evaluate_verbatim_subframe_(integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
2978         }
2979
2980         *best_subframe = _best_subframe;
2981         *best_bits = _best_bits;
2982
2983         return true;
2984 }
2985
2986 FLAC__bool add_subframe_(
2987         FLAC__StreamEncoder *encoder,
2988         const FLAC__FrameHeader *frame_header,
2989         unsigned subframe_bps,
2990         const FLAC__Subframe *subframe,
2991         FLAC__BitBuffer *frame
2992 #ifdef WINDOW_DEBUG_OUTPUT
2993 ,unsigned subframe_bits
2994 #endif
2995 )
2996 {
2997         switch(subframe->type) {
2998                 case FLAC__SUBFRAME_TYPE_CONSTANT:
2999                         if(!FLAC__subframe_add_constant(&(subframe->data.constant), subframe_bps, subframe->wasted_bits, frame)) {
3000                                 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3001                                 return false;
3002                         }
3003                         break;
3004                 case FLAC__SUBFRAME_TYPE_FIXED:
3005                         if(!FLAC__subframe_add_fixed(&(subframe->data.fixed), frame_header->blocksize - subframe->data.fixed.order, subframe_bps, subframe->wasted_bits, frame)) {
3006                                 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3007                                 return false;
3008                         }
3009                         break;
3010                 case FLAC__SUBFRAME_TYPE_LPC:
3011 #ifdef WINDOW_DEBUG_OUTPUT
3012                         fprintf(stderr, "WIN:\tframe=%u\tsubframe=?\torder=%u\twindow=%s\tbits=%u\n", frame_header->number.frame_number, subframe->data.lpc.order, subframe->data.lpc.window_type, subframe_bits);
3013 #endif
3014                         if(!FLAC__subframe_add_lpc(&(subframe->data.lpc), frame_header->blocksize - subframe->data.lpc.order, subframe_bps, subframe->wasted_bits, frame)) {
3015                                 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3016                                 return false;
3017                         }
3018                         break;
3019                 case FLAC__SUBFRAME_TYPE_VERBATIM:
3020                         if(!FLAC__subframe_add_verbatim(&(subframe->data.verbatim), frame_header->blocksize, subframe_bps, subframe->wasted_bits, frame)) {
3021                                 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3022                                 return false;
3023                         }
3024                         break;
3025                 default:
3026                         FLAC__ASSERT(0);
3027         }
3028
3029         return true;
3030 }
3031
3032 unsigned evaluate_constant_subframe_(
3033         const FLAC__int32 signal,
3034         unsigned subframe_bps,
3035         FLAC__Subframe *subframe
3036 )
3037 {
3038         subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT;
3039         subframe->data.constant.value = signal;
3040
3041         return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe_bps;
3042 }
3043
3044 unsigned evaluate_fixed_subframe_(
3045         FLAC__StreamEncoder *encoder,
3046         const FLAC__int32 signal[],
3047         FLAC__int32 residual[],
3048         FLAC__uint32 abs_residual[],
3049         FLAC__uint64 abs_residual_partition_sums[],
3050         unsigned raw_bits_per_partition[],
3051         unsigned blocksize,
3052         unsigned subframe_bps,
3053         unsigned order,
3054         unsigned rice_parameter,
3055         unsigned min_partition_order,
3056         unsigned max_partition_order,
3057         FLAC__bool precompute_partition_sums,
3058         FLAC__bool do_escape_coding,
3059         unsigned rice_parameter_search_dist,
3060         FLAC__Subframe *subframe,
3061         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
3062 )
3063 {
3064         unsigned i, residual_bits;
3065         const unsigned residual_samples = blocksize - order;
3066
3067         FLAC__fixed_compute_residual(signal+order, residual_samples, order, residual);
3068
3069         subframe->type = FLAC__SUBFRAME_TYPE_FIXED;
3070
3071         subframe->data.fixed.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
3072         subframe->data.fixed.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents;
3073         subframe->data.fixed.residual = residual;
3074
3075         residual_bits =
3076                 find_best_partition_order_(
3077                         encoder->private_,
3078                         residual,
3079                         abs_residual,
3080                         abs_residual_partition_sums,
3081                         raw_bits_per_partition,
3082                         residual_samples,
3083                         order,
3084                         rice_parameter,
3085                         min_partition_order,
3086                         max_partition_order,
3087                         precompute_partition_sums,
3088                         do_escape_coding,
3089                         rice_parameter_search_dist,
3090                         &subframe->data.fixed.entropy_coding_method.data.partitioned_rice
3091                 );
3092
3093         subframe->data.fixed.order = order;
3094         for(i = 0; i < order; i++)
3095                 subframe->data.fixed.warmup[i] = signal[i];
3096
3097         return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + (order * subframe_bps) + residual_bits;
3098 }
3099
3100 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3101 unsigned evaluate_lpc_subframe_(
3102         FLAC__StreamEncoder *encoder,
3103         const FLAC__int32 signal[],
3104         FLAC__int32 residual[],
3105         FLAC__uint32 abs_residual[],
3106         FLAC__uint64 abs_residual_partition_sums[],
3107         unsigned raw_bits_per_partition[],
3108         const FLAC__real lp_coeff[],
3109         unsigned blocksize,
3110         unsigned subframe_bps,
3111         unsigned order,
3112         unsigned qlp_coeff_precision,
3113         unsigned rice_parameter,
3114         unsigned min_partition_order,
3115         unsigned max_partition_order,
3116         FLAC__bool precompute_partition_sums,
3117         FLAC__bool do_escape_coding,
3118         unsigned rice_parameter_search_dist,
3119         FLAC__Subframe *subframe,
3120         FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents
3121 #ifdef WINDOW_DEBUG_OUTPUT
3122         ,unsigned frame_number
3123         ,unsigned subframe_number
3124         ,FLAC__ApodizationSpecification aspec
3125 #endif
3126 )
3127 {
3128         FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER];
3129         unsigned i, residual_bits;
3130         int quantization, ret;
3131         const unsigned residual_samples = blocksize - order;
3132
3133         /* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps streams */
3134         if(subframe_bps <= 16) {
3135                 FLAC__ASSERT(order > 0);
3136                 FLAC__ASSERT(order <= FLAC__MAX_LPC_ORDER);
3137                 qlp_coeff_precision = min(qlp_coeff_precision, 32 - subframe_bps - FLAC__bitmath_ilog2(order));
3138         }
3139
3140 #ifdef WINDOW_DEBUG_OUTPUT
3141         if (aspec.type == FLAC__APODIZATION_GAUSS)
3142                 snprintf(subframe->data.lpc.window_type, sizeof subframe->data.lpc.window_type, "%s(%0.5f)", winstr[aspec.type], aspec.parameters.gauss.stddev);
3143         else if (aspec.type == FLAC__APODIZATION_TUKEY)
3144                 snprintf(subframe->data.lpc.window_type, sizeof subframe->data.lpc.window_type, "%s(%0.5f)", winstr[aspec.type], aspec.parameters.tukey.p);
3145         else
3146                 strncpy(subframe->data.lpc.window_type, winstr[aspec.type], sizeof subframe->data.lpc.window_type);
3147 #endif
3148
3149         ret = FLAC__lpc_quantize_coefficients(lp_coeff, order, qlp_coeff_precision, qlp_coeff, &quantization);
3150         if(ret != 0)
3151                 return 0; /* this is a hack to indicate to the caller that we can't do lp at this order on this subframe */
3152
3153         if(subframe_bps + qlp_coeff_precision + FLAC__bitmath_ilog2(order) <= 32)
3154                 if(subframe_bps <= 16 && qlp_coeff_precision <= 16)
3155                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3156                 else
3157                         encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3158         else
3159                 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3160
3161         subframe->type = FLAC__SUBFRAME_TYPE_LPC;
3162
3163         subframe->data.lpc.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
3164         subframe->data.lpc.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents;
3165         subframe->data.lpc.residual = residual;
3166
3167         residual_bits =
3168                 find_best_partition_order_(
3169                         encoder->private_,
3170                         residual,
3171                         abs_residual,
3172                         abs_residual_partition_sums,
3173                         raw_bits_per_partition,
3174                         residual_samples,
3175                         order,
3176                         rice_parameter,
3177                         min_partition_order,
3178                         max_partition_order,
3179                         precompute_partition_sums,
3180                         do_escape_coding,
3181                         rice_parameter_search_dist,
3182                         &subframe->data.fixed.entropy_coding_method.data.partitioned_rice
3183                 );
3184
3185         subframe->data.lpc.order = order;
3186         subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision;
3187         subframe->data.lpc.quantization_level = quantization;
3188         memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(FLAC__int32)*FLAC__MAX_LPC_ORDER);
3189         for(i = 0; i < order; i++)
3190                 subframe->data.lpc.warmup[i] = signal[i];
3191
3192 #ifdef WINDOW_DEBUG_OUTPUT
3193         fprintf(stderr, "SWIN:\tframe=%u\tsubframe=%u\torder=%u\twindow=%s\tbits=%u\n", frame_number, subframe_number, order, subframe->data.lpc.window_type, 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);
3194 #endif
3195         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;
3196 }
3197 #endif
3198
3199 unsigned evaluate_verbatim_subframe_(
3200         const FLAC__int32 signal[],
3201         unsigned blocksize,
3202         unsigned subframe_bps,
3203         FLAC__Subframe *subframe
3204 )
3205 {
3206         subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM;
3207
3208         subframe->data.verbatim.data = signal;
3209
3210         return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + (blocksize * subframe_bps);
3211 }
3212
3213 unsigned find_best_partition_order_(
3214         FLAC__StreamEncoderPrivate *private_,
3215         const FLAC__int32 residual[],
3216         FLAC__uint32 abs_residual[],
3217         FLAC__uint64 abs_residual_partition_sums[],
3218         unsigned raw_bits_per_partition[],
3219         unsigned residual_samples,
3220         unsigned predictor_order,
3221         unsigned rice_parameter,
3222         unsigned min_partition_order,
3223         unsigned max_partition_order,
3224         FLAC__bool precompute_partition_sums,
3225         FLAC__bool do_escape_coding,
3226         unsigned rice_parameter_search_dist,
3227         FLAC__EntropyCodingMethod_PartitionedRice *best_partitioned_rice
3228 )
3229 {
3230         FLAC__int32 r;
3231         unsigned residual_bits, best_residual_bits = 0;
3232         unsigned residual_sample;
3233         unsigned best_parameters_index = 0;
3234         const unsigned blocksize = residual_samples + predictor_order;
3235
3236         /* compute abs(residual) for use later */
3237         for(residual_sample = 0; residual_sample < residual_samples; residual_sample++) {
3238                 r = residual[residual_sample];
3239                 abs_residual[residual_sample] = (FLAC__uint32)(r<0? -r : r);
3240         }
3241
3242         max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(max_partition_order, blocksize, predictor_order);
3243         min_partition_order = min(min_partition_order, max_partition_order);
3244
3245         if(precompute_partition_sums) {
3246                 int partition_order;
3247                 unsigned sum;
3248
3249                 precompute_partition_info_sums_(abs_residual, abs_residual_partition_sums, residual_samples, predictor_order, min_partition_order, max_partition_order);
3250
3251                 if(do_escape_coding)
3252                         precompute_partition_info_escapes_(residual, raw_bits_per_partition, residual_samples, predictor_order, min_partition_order, max_partition_order);
3253
3254                 for(partition_order = (int)max_partition_order, sum = 0; partition_order >= (int)min_partition_order; partition_order--) {
3255 #ifdef DONT_ESTIMATE_RICE_BITS
3256                         if(!
3257                                 set_partitioned_rice_with_precompute_(
3258                                         residual,
3259                                         abs_residual_partition_sums+sum,
3260                                         raw_bits_per_partition+sum,
3261                                         residual_samples,
3262                                         predictor_order,
3263                                         rice_parameter,
3264                                         rice_parameter_search_dist,
3265                                         (unsigned)partition_order,
3266                                         do_escape_coding,
3267                                         &private_->partitioned_rice_contents_extra[!best_parameters_index],
3268                                         &residual_bits
3269                                 )
3270                         )
3271 #else
3272                         if(!
3273                                 set_partitioned_rice_with_precompute_(
3274                                         abs_residual,
3275                                         abs_residual_partition_sums+sum,
3276                                         raw_bits_per_partition+sum,
3277                                         residual_samples,
3278                                         predictor_order,
3279                                         rice_parameter,
3280                                         rice_parameter_search_dist,
3281                                         (unsigned)partition_order,
3282                                         do_escape_coding,
3283                                         &private_->partitioned_rice_contents_extra[!best_parameters_index],
3284                                         &residual_bits
3285                                 )
3286                         )
3287 #endif
3288                         {
3289                                 FLAC__ASSERT(best_residual_bits != 0);
3290                                 break;
3291                         }
3292                         sum += 1u << partition_order;
3293                         if(best_residual_bits == 0 || residual_bits < best_residual_bits) {
3294                                 best_residual_bits = residual_bits;
3295                                 best_parameters_index = !best_parameters_index;
3296                                 best_partitioned_rice->order = partition_order;
3297                         }
3298                 }
3299         }
3300         else {
3301                 unsigned partition_order;
3302                 for(partition_order = min_partition_order; partition_order <= max_partition_order; partition_order++) {
3303 #ifdef DONT_ESTIMATE_RICE_BITS
3304                         if(!
3305                                 set_partitioned_rice_(
3306                                         abs_residual,
3307                                         residual,
3308                                         residual_samples,
3309                                         predictor_order,
3310                                         rice_parameter,
3311                                         rice_parameter_search_dist,
3312                                         partition_order,
3313                                         &private_->partitioned_rice_contents_extra[!best_parameters_index],
3314                                         &residual_bits
3315                                 )
3316                         )
3317 #else
3318                         if(!
3319                                 set_partitioned_rice_(
3320                                         abs_residual,
3321                                         residual_samples,
3322                                         predictor_order,
3323                                         rice_parameter,
3324                                         rice_parameter_search_dist,
3325                                         partition_order,
3326                                         &private_->partitioned_rice_contents_extra[!best_parameters_index],
3327                                         &residual_bits
3328                                 )
3329                         )
3330 #endif
3331                         {
3332                                 FLAC__ASSERT(best_residual_bits != 0);
3333                                 break;
3334                         }
3335                         if(best_residual_bits == 0 || residual_bits < best_residual_bits) {
3336                                 best_residual_bits = residual_bits;
3337                                 best_parameters_index = !best_parameters_index;
3338                                 best_partitioned_rice->order = partition_order;
3339                         }
3340                 }
3341         }
3342
3343         /*
3344          * We are allowed to de-const the pointer based on our special knowledge;
3345          * it is const to the outside world.
3346          */
3347         {
3348                 FLAC__EntropyCodingMethod_PartitionedRiceContents* best_partitioned_rice_contents = (FLAC__EntropyCodingMethod_PartitionedRiceContents*)best_partitioned_rice->contents;
3349                 FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(best_partitioned_rice_contents, max(6, best_partitioned_rice->order));
3350                 memcpy(best_partitioned_rice_contents->parameters, private_->partitioned_rice_contents_extra[best_parameters_index].parameters, sizeof(unsigned)*(1<<(best_partitioned_rice->order)));
3351                 memcpy(best_partitioned_rice_contents->raw_bits, private_->partitioned_rice_contents_extra[best_parameters_index].raw_bits, sizeof(unsigned)*(1<<(best_partitioned_rice->order)));
3352         }
3353
3354         return best_residual_bits;
3355 }
3356
3357 void precompute_partition_info_sums_(
3358         const FLAC__uint32 abs_residual[],
3359         FLAC__uint64 abs_residual_partition_sums[],
3360         unsigned residual_samples,
3361         unsigned predictor_order,
3362         unsigned min_partition_order,
3363         unsigned max_partition_order
3364 )
3365 {
3366         int partition_order;
3367         unsigned from_partition, to_partition = 0;
3368         const unsigned blocksize = residual_samples + predictor_order;
3369
3370         /* first do max_partition_order */
3371         for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) {
3372                 FLAC__uint64 abs_residual_partition_sum;
3373                 FLAC__uint32 abs_r;
3374                 unsigned partition, partition_sample, partition_samples, residual_sample;
3375                 const unsigned partitions = 1u << partition_order;
3376                 const unsigned default_partition_samples = blocksize >> partition_order;
3377
3378                 FLAC__ASSERT(default_partition_samples > predictor_order);
3379
3380                 for(partition = residual_sample = 0; partition < partitions; partition++) {
3381                         partition_samples = default_partition_samples;
3382                         if(partition == 0)
3383                                 partition_samples -= predictor_order;
3384                         abs_residual_partition_sum = 0;
3385                         for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) {
3386                                 abs_r = abs_residual[residual_sample];
3387                                 abs_residual_partition_sum += abs_r;
3388                                 residual_sample++;
3389                         }