src/libFLAC/stream_encoder.c

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