src/libFLAC/encoder.c

   1 /* libFLAC - Free Lossless Audio Coder library
   2  * Copyright (C) 2000,2001  Josh Coalson
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA  02111-1307, USA.
  18  */
  19
  20 #include <assert.h>
  21 #include <stdio.h>
  22 #include <stdlib.h> /* for malloc() */
  23 #include <string.h> /* for memcpy() */
  24 #include "FLAC/encoder.h"
  25 #include "private/bitbuffer.h"
  26 #include "private/encoder_framing.h"
  27 #include "private/fixed.h"
  28 #include "private/lpc.h"
  29 #include "private/md5.h"
  30
  31 #ifdef min
  32 #undef min
  33 #endif
  34 #define min(x,y) ((x)<(y)?(x):(y))
  35
  36 #ifdef max
  37 #undef max
  38 #endif
  39 #define max(x,y) ((x)>(y)?(x):(y))
  40
  41 #ifdef ESTIMATE_RICE_BITS
  42 #undef ESTIMATE_RICE_BITS
  43 #endif
  44 #define ESTIMATE_RICE_BITS(value, parameter) (2 + (parameter) + (((unsigned)((value) < 0? -(value) : (value))) >> (parameter)))
  45
  46 typedef struct FLAC__EncoderPrivate {
  47         unsigned input_capacity;                    /* current size (in samples) of the signal and residual buffers */
  48         int32 *integer_signal[FLAC__MAX_CHANNELS];  /* the integer version of the input signal */
  49         int32 *integer_signal_mid_side[2];          /* the integer version of the mid-side input signal (stereo only) */
  50         real *real_signal[FLAC__MAX_CHANNELS];      /* the floating-point version of the input signal */
  51         real *real_signal_mid_side[2];              /* the floating-point version of the mid-side input signal (stereo only) */
  52         int32 *residual[2];                         /* where the candidate and best subframe residual signals will be stored */
  53         unsigned best_residual;                     /* index into the above */
  54         FLAC__BitBuffer frame;                      /* the current frame being worked on */
  55         FLAC__BitBuffer frame_mid_side;             /* special parallel workspace for the mid-side coded version of the current frame */
  56         FLAC__BitBuffer frame_left_side;            /* special parallel workspace for the left-side coded version of the current frame */
  57         FLAC__BitBuffer frame_right_side;           /* special parallel workspace for the right-side coded version of the current frame */
  58         FLAC__SubframeHeader best_subframe, candidate_subframe;
  59         bool current_frame_can_do_mid_side;         /* encoder sets this false when any given sample of a frame's side channel exceeds 16 bits */
  60         FLAC__StreamMetaData metadata;
  61         unsigned current_sample_number;
  62         unsigned current_frame_number;
  63         struct MD5Context md5context;
  64         FLAC__EncoderWriteStatus (*write_callback)(const FLAC__Encoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
  65         void (*metadata_callback)(const FLAC__Encoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data);
  66         void *client_data;
  67 } FLAC__EncoderPrivate;
  68
  69 static bool encoder_resize_buffers_(FLAC__Encoder *encoder, unsigned new_size);
  70 static bool encoder_process_frame_(FLAC__Encoder *encoder, bool is_last_frame);
  71 static bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame, const FLAC__FrameHeader *frame_header, unsigned channels, const int32 *integer_signal[], const real *real_signal[], FLAC__BitBuffer *bitbuffer);
  72 static unsigned encoder_evaluate_constant_subframe_(const int32 signal, unsigned bits_per_sample, FLAC__SubframeHeader *subframe);
  73 static unsigned encoder_evaluate_fixed_subframe_(const int32 signal[], int32 residual[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned rice_parameter, unsigned max_partition_order, FLAC__SubframeHeader *subframe);
  74 static unsigned encoder_evaluate_lpc_subframe_(const int32 signal[], int32 residual[], const real lp_coeff[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned max_partition_order, FLAC__SubframeHeader *subframe);
  75 static unsigned encoder_evaluate_verbatim_subframe_(unsigned blocksize, unsigned bits_per_sample, FLAC__SubframeHeader *subframe);
  76 static unsigned encoder_find_best_partition_order_(int32 residual[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned max_partition_order, unsigned *best_partition_order, unsigned best_parameters[]);
  77 static bool encoder_generate_constant_subframe_(const FLAC__SubframeHeader *header, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer);
  78 static bool encoder_generate_fixed_subframe_(const FLAC__SubframeHeader *header, int32 residual[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer);
  79 static bool encoder_generate_lpc_subframe_(const FLAC__SubframeHeader *header, int32 residual[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer);
  80 static bool encoder_generate_verbatim_subframe_(const FLAC__SubframeHeader *header, const int32 signal[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer);
  81 static void encoder_promote_candidate_subframe_(FLAC__Encoder *encoder);
  82 static bool encoder_set_partitioned_rice_(const int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameter, const unsigned partition_order, unsigned parameters[], unsigned *bits);
  83
  84 const char *FLAC__EncoderWriteStatusString[] = {
  85         "FLAC__ENCODER_WRITE_OK",
  86         "FLAC__ENCODER_WRITE_FATAL_ERROR"
  87 };
  88
  89 const char *FLAC__EncoderStateString[] = {
  90         "FLAC__ENCODER_OK",
  91         "FLAC__ENCODER_UNINITIALIZED",
  92         "FLAC__ENCODER_INVALID_NUMBER_OF_CHANNELS",
  93         "FLAC__ENCODER_INVALID_BITS_PER_SAMPLE",
  94         "FLAC__ENCODER_INVALID_SAMPLE_RATE",
  95         "FLAC__ENCODER_INVALID_BLOCK_SIZE",
  96         "FLAC__ENCODER_INVALID_QLP_COEFF_PRECISION",
  97         "FLAC__ENCODER_MID_SIDE_CHANNELS_MISMATCH",
  98         "FLAC__ENCODER_MID_SIDE_SAMPLE_SIZE_MISMATCH",
  99         "FLAC__ENCODER_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER",
 100         "FLAC__ENCODER_NOT_STREAMABLE",
 101         "FLAC__ENCODER_FRAMING_ERROR",
 102         "FLAC__ENCODER_FATAL_ERROR_WHILE_ENCODING",
 103         "FLAC__ENCODER_FATAL_ERROR_WHILE_WRITING",
 104         "FLAC__ENCODER_MEMORY_ALLOCATION_ERROR"
 105 };
 106
 107
 108 bool encoder_resize_buffers_(FLAC__Encoder *encoder, unsigned new_size)
 109 {
 110         bool ok;
 111         unsigned i;
 112         int32 *previous_is, *current_is;
 113         real *previous_rs, *current_rs;
 114         int32 *residual;
 115
 116         assert(new_size > 0);
 117         assert(encoder->state == FLAC__ENCODER_OK);
 118         assert(encoder->guts->current_sample_number == 0);
 119
 120         /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */
 121         if(new_size <= encoder->guts->input_capacity)
 122                 return true;
 123
 124         ok = 1;
 125         if(ok) {
 126                 for(i = 0; ok && i < encoder->channels; i++) {
 127                         /* integer version of the signal */
 128                         previous_is = encoder->guts->integer_signal[i];
 129                         current_is = (int32*)malloc(sizeof(int32) * new_size);
 130                         if(0 == current_is) {
 131                                 encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 132                                 ok = 0;
 133                         }
 134                         else {
 135                                 encoder->guts->integer_signal[i] = current_is;
 136                                 if(previous_is != 0)
 137                                         free(previous_is);
 138                         }
 139                         /* real version of the signal */
 140                         previous_rs = encoder->guts->real_signal[i];
 141                         current_rs = (real*)malloc(sizeof(real) * new_size);
 142                         if(0 == current_rs) {
 143                                 encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 144                                 ok = 0;
 145                         }
 146                         else {
 147                                 encoder->guts->real_signal[i] = current_rs;
 148                                 if(previous_rs != 0)
 149                                         free(previous_rs);
 150                         }
 151                 }
 152         }
 153         if(ok) {
 154                 for(i = 0; ok && i < 2; i++) {
 155                         /* integer version of the signal */
 156                         previous_is = encoder->guts->integer_signal_mid_side[i];
 157                         current_is = (int32*)malloc(sizeof(int32) * new_size);
 158                         if(0 == current_is) {
 159                                 encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 160                                 ok = 0;
 161                         }
 162                         else {
 163                                 encoder->guts->integer_signal_mid_side[i] = current_is;
 164                                 if(previous_is != 0)
 165                                         free(previous_is);
 166                         }
 167                         /* real version of the signal */
 168                         previous_rs = encoder->guts->real_signal_mid_side[i];
 169                         current_rs = (real*)malloc(sizeof(real) * new_size);
 170                         if(0 == current_rs) {
 171                                 encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 172                                 ok = 0;
 173                         }
 174                         else {
 175                                 encoder->guts->real_signal_mid_side[i] = current_rs;
 176                                 if(previous_rs != 0)
 177                                         free(previous_rs);
 178                         }
 179                 }
 180         }
 181         if(ok) {
 182                 for(i = 0; i < 2; i++) {
 183                         residual = (int32*)malloc(sizeof(int32) * new_size);
 184                         if(0 == residual) {
 185                                 encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 186                                 ok = 0;
 187                         }
 188                         else {
 189                                 if(encoder->guts->residual[i] != 0)
 190                                         free(encoder->guts->residual[i]);
 191                                 encoder->guts->residual[i] = residual;
 192                         }
 193                 }
 194         }
 195         if(ok)
 196                 encoder->guts->input_capacity = new_size;
 197
 198         return ok;
 199 }
 200
 201 FLAC__Encoder *FLAC__encoder_get_new_instance()
 202 {
 203         FLAC__Encoder *encoder = (FLAC__Encoder*)malloc(sizeof(FLAC__Encoder));
 204         if(encoder != 0) {
 205                 encoder->state = FLAC__ENCODER_UNINITIALIZED;
 206                 encoder->guts = 0;
 207         }
 208         return encoder;
 209 }
 210
 211 void FLAC__encoder_free_instance(FLAC__Encoder *encoder)
 212 {
 213         assert(encoder != 0);
 214         free(encoder);
 215 }
 216
 217 FLAC__EncoderState FLAC__encoder_init(FLAC__Encoder *encoder, FLAC__EncoderWriteStatus (*write_callback)(const FLAC__Encoder *encoder, const byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data), void (*metadata_callback)(const FLAC__Encoder *encoder, const FLAC__StreamMetaData *metadata, void *client_data), void *client_data)
 218 {
 219         unsigned i;
 220
 221         assert(sizeof(int) >= 4); /* we want to die right away if this is not true */
 222         assert(encoder != 0);
 223         assert(write_callback != 0);
 224         assert(metadata_callback != 0);
 225         assert(encoder->state == FLAC__ENCODER_UNINITIALIZED);
 226         assert(encoder->guts == 0);
 227
 228         encoder->state = FLAC__ENCODER_OK;
 229
 230         if(encoder->channels == 0 || encoder->channels > FLAC__MAX_CHANNELS)
 231                 return encoder->state = FLAC__ENCODER_INVALID_NUMBER_OF_CHANNELS;
 232
 233         if(encoder->do_mid_side_stereo && encoder->channels != 2)
 234                 return encoder->state = FLAC__ENCODER_MID_SIDE_CHANNELS_MISMATCH;
 235
 236         if(encoder->do_mid_side_stereo && encoder->bits_per_sample > 16)
 237                 return encoder->state = FLAC__ENCODER_MID_SIDE_SAMPLE_SIZE_MISMATCH;
 238
 239         if(encoder->bits_per_sample == 0 || encoder->bits_per_sample > FLAC__MAX_BITS_PER_SAMPLE)
 240                 return encoder->state = FLAC__ENCODER_INVALID_BITS_PER_SAMPLE;
 241
 242         if(encoder->sample_rate == 0 || encoder->sample_rate > FLAC__MAX_SAMPLE_RATE)
 243                 return encoder->state = FLAC__ENCODER_INVALID_SAMPLE_RATE;
 244
 245         if(encoder->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->blocksize > FLAC__MAX_BLOCK_SIZE)
 246                 return encoder->state = FLAC__ENCODER_INVALID_BLOCK_SIZE;
 247
 248         if(encoder->blocksize < encoder->max_lpc_order)
 249                 return encoder->state = FLAC__ENCODER_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER;
 250
 251         if(encoder->qlp_coeff_precision == 0) {
 252                 if(encoder->bits_per_sample < 16) {
 253                         /* @@@ need some data about how to set this here w.r.t. blocksize and sample rate */
 254                         /* @@@ until then we'll make a guess */
 255                         encoder->qlp_coeff_precision = max(5, 2 + encoder->bits_per_sample / 2);
 256                 }
 257                 else if(encoder->bits_per_sample == 16) {
 258                         if(encoder->blocksize <= 192)
 259                                 encoder->qlp_coeff_precision = 7;
 260                         else if(encoder->blocksize <= 384)
 261                                 encoder->qlp_coeff_precision = 8;
 262                         else if(encoder->blocksize <= 576)
 263                                 encoder->qlp_coeff_precision = 9;
 264                         else if(encoder->blocksize <= 1152)
 265                                 encoder->qlp_coeff_precision = 10;
 266                         else if(encoder->blocksize <= 2304)
 267                                 encoder->qlp_coeff_precision = 11;
 268                         else if(encoder->blocksize <= 4608)
 269                                 encoder->qlp_coeff_precision = 12;
 270                         else
 271                                 encoder->qlp_coeff_precision = 13;
 272                 }
 273                 else {
 274                         encoder->qlp_coeff_precision = min(13, 8*sizeof(int32) - encoder->bits_per_sample - 1);
 275                 }
 276         }
 277         else if(encoder->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->qlp_coeff_precision + encoder->bits_per_sample >= 8*sizeof(uint32))
 278                 return encoder->state = FLAC__ENCODER_INVALID_QLP_COEFF_PRECISION;
 279
 280         if(encoder->streamable_subset) {
 281                 if(encoder->bits_per_sample != 8 && encoder->bits_per_sample != 12 && encoder->bits_per_sample != 16 && encoder->bits_per_sample != 20 && encoder->bits_per_sample != 24)
 282                         return encoder->state = FLAC__ENCODER_NOT_STREAMABLE;
 283                 if(encoder->sample_rate > 655350)
 284                         return encoder->state = FLAC__ENCODER_NOT_STREAMABLE;
 285         }
 286
 287         if(encoder->rice_optimization_level >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
 288                 encoder->rice_optimization_level = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1;
 289
 290         encoder->guts = (FLAC__EncoderPrivate*)malloc(sizeof(FLAC__EncoderPrivate));
 291         if(encoder->guts == 0)
 292                 return encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 293
 294         encoder->guts->input_capacity = 0;
 295         for(i = 0; i < encoder->channels; i++) {
 296                 encoder->guts->integer_signal[i] = 0;
 297                 encoder->guts->real_signal[i] = 0;
 298         }
 299         for(i = 0; i < 2; i++) {
 300                 encoder->guts->integer_signal_mid_side[i] = 0;
 301                 encoder->guts->real_signal_mid_side[i] = 0;
 302         }
 303         encoder->guts->residual[0] = 0;
 304         encoder->guts->residual[1] = 0;
 305         encoder->guts->best_residual = 0;
 306         encoder->guts->current_frame_can_do_mid_side = true;
 307         encoder->guts->current_sample_number = 0;
 308         encoder->guts->current_frame_number = 0;
 309
 310         if(!encoder_resize_buffers_(encoder, encoder->blocksize)) {
 311                 /* the above function sets the state for us in case of an error */
 312                 return encoder->state;
 313         }
 314         FLAC__bitbuffer_init(&encoder->guts->frame);
 315         encoder->guts->write_callback = write_callback;
 316         encoder->guts->metadata_callback = metadata_callback;
 317         encoder->guts->client_data = client_data;
 318
 319         /*
 320          * write the stream header
 321          */
 322         if(!FLAC__bitbuffer_clear(&encoder->guts->frame))
 323                 return encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 324
 325         if(!FLAC__bitbuffer_write_raw_uint32(&encoder->guts->frame, FLAC__STREAM_SYNC, FLAC__STREAM_SYNC_LEN))
 326                 return encoder->state = FLAC__ENCODER_FRAMING_ERROR;
 327
 328         encoder->guts->metadata.type = FLAC__METADATA_TYPE_ENCODING;
 329         encoder->guts->metadata.is_last = true;
 330         encoder->guts->metadata.length = FLAC__STREAM_METADATA_ENCODING_LENGTH;
 331         encoder->guts->metadata.data.encoding.min_blocksize = encoder->blocksize; /* this encoder uses the same blocksize for the whole stream */
 332         encoder->guts->metadata.data.encoding.max_blocksize = encoder->blocksize;
 333         encoder->guts->metadata.data.encoding.min_framesize = 0; /* we don't know this yet; have to fill it in later */
 334         encoder->guts->metadata.data.encoding.max_framesize = 0; /* we don't know this yet; have to fill it in later */
 335         encoder->guts->metadata.data.encoding.sample_rate = encoder->sample_rate;
 336         encoder->guts->metadata.data.encoding.channels = encoder->channels;
 337         encoder->guts->metadata.data.encoding.bits_per_sample = encoder->bits_per_sample;
 338         encoder->guts->metadata.data.encoding.total_samples = 0; /* we don't know this yet; have to fill it in later */
 339         memset(encoder->guts->metadata.data.encoding.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */
 340         MD5Init(&encoder->guts->md5context);
 341         if(!FLAC__add_metadata_block(&encoder->guts->metadata, &encoder->guts->frame))
 342                 return encoder->state = FLAC__ENCODER_FRAMING_ERROR;
 343
 344         assert(encoder->guts->frame.bits == 0); /* assert that we're byte-aligned before writing */
 345         assert(encoder->guts->frame.total_consumed_bits == 0); /* assert that no reading of the buffer was done */
 346         if(encoder->guts->write_callback(encoder, encoder->guts->frame.buffer, encoder->guts->frame.bytes, 0, encoder->guts->current_frame_number, encoder->guts->client_data) != FLAC__ENCODER_WRITE_OK)
 347                 return encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_WRITING;
 348
 349         /* now that the metadata block is written, we can init this to an absurdly-high value */
 350         encoder->guts->metadata.data.encoding.min_framesize = (1u << FLAC__STREAM_METADATA_ENCODING_MIN_FRAME_SIZE_LEN) - 1;
 351
 352         return encoder->state;
 353 }
 354
 355 void FLAC__encoder_finish(FLAC__Encoder *encoder)
 356 {
 357         unsigned i;
 358
 359         assert(encoder != 0);
 360         if(encoder->state == FLAC__ENCODER_UNINITIALIZED)
 361                 return;
 362         if(encoder->guts->current_sample_number != 0) {
 363                 encoder->blocksize = encoder->guts->current_sample_number;
 364                 encoder_process_frame_(encoder, true); /* true => is last frame */
 365         }
 366         MD5Final(encoder->guts->metadata.data.encoding.md5sum, &encoder->guts->md5context);
 367         encoder->guts->metadata_callback(encoder, &encoder->guts->metadata, encoder->guts->client_data);
 368         if(encoder->guts != 0) {
 369                 for(i = 0; i < encoder->channels; i++) {
 370                         if(encoder->guts->integer_signal[i] != 0) {
 371                                 free(encoder->guts->integer_signal[i]);
 372                                 encoder->guts->integer_signal[i] = 0;
 373                         }
 374                         if(encoder->guts->real_signal[i] != 0) {
 375                                 free(encoder->guts->real_signal[i]);
 376                                 encoder->guts->real_signal[i] = 0;
 377                         }
 378                 }
 379                 for(i = 0; i < 2; i++) {
 380                         if(encoder->guts->integer_signal_mid_side[i] != 0) {
 381                                 free(encoder->guts->integer_signal_mid_side[i]);
 382                                 encoder->guts->integer_signal_mid_side[i] = 0;
 383                         }
 384                         if(encoder->guts->real_signal_mid_side[i] != 0) {
 385                                 free(encoder->guts->real_signal_mid_side[i]);
 386                                 encoder->guts->real_signal_mid_side[i] = 0;
 387                         }
 388                 }
 389                 for(i = 0; i < 2; i++) {
 390                         if(encoder->guts->residual[i] != 0) {
 391                                 free(encoder->guts->residual[i]);
 392                                 encoder->guts->residual[i] = 0;
 393                         }
 394                 }
 395                 FLAC__bitbuffer_free(&encoder->guts->frame);
 396                 free(encoder->guts);
 397                 encoder->guts = 0;
 398         }
 399         encoder->state = FLAC__ENCODER_UNINITIALIZED;
 400 }
 401
 402 bool FLAC__encoder_process(FLAC__Encoder *encoder, const int32 *buf[], unsigned samples)
 403 {
 404         unsigned i, j, channel;
 405         int32 x, mid, side;
 406         const bool ms = encoder->do_mid_side_stereo && encoder->channels == 2;
 407         const int32 min_side = -((int64)1 << (encoder->bits_per_sample-1));
 408         const int32 max_side =  ((int64)1 << (encoder->bits_per_sample-1)) - 1;
 409
 410         assert(encoder != 0);
 411         assert(encoder->state == FLAC__ENCODER_OK);
 412
 413         j = 0;
 414         do {
 415                 for(i = encoder->guts->current_sample_number; i < encoder->blocksize && j < samples; i++, j++) {
 416                         for(channel = 0; channel < encoder->channels; channel++) {
 417                                 x = buf[channel][j];
 418                                 encoder->guts->integer_signal[channel][i] = x;
 419                                 encoder->guts->real_signal[channel][i] = (real)x;
 420                         }
 421                         if(ms && encoder->guts->current_frame_can_do_mid_side) {
 422                                 side = buf[0][j] - buf[1][j];
 423                                 if(side < min_side || side > max_side) {
 424                                         encoder->guts->current_frame_can_do_mid_side = false;
 425                                 }
 426                                 else {
 427                                         mid = (buf[0][j] + buf[1][j]) >> 1; /* NOTE: not the same as divide-by-two ! */
 428                                         encoder->guts->integer_signal_mid_side[0][i] = mid;
 429                                         encoder->guts->integer_signal_mid_side[1][i] = side;
 430                                         encoder->guts->real_signal_mid_side[0][i] = (real)mid;
 431                                         encoder->guts->real_signal_mid_side[1][i] = (real)side;
 432                                 }
 433                         }
 434                         encoder->guts->current_sample_number++;
 435                 }
 436                 if(i == encoder->blocksize) {
 437                         if(!encoder_process_frame_(encoder, false)) /* false => not last frame */
 438                                 return false;
 439                 }
 440         } while(j < samples);
 441
 442         return true;
 443 }
 444
 445 /* 'samples' is channel-wide samples, e.g. for 1 second at 44100Hz, 'samples' = 44100 regardless of the number of channels */
 446 bool FLAC__encoder_process_interleaved(FLAC__Encoder *encoder, const int32 buf[], unsigned samples)
 447 {
 448         unsigned i, j, k, channel;
 449         int32 x, left = 0, mid, side;
 450         const bool ms = encoder->do_mid_side_stereo && encoder->channels == 2;
 451         const int32 min_side = -((int64)1 << (encoder->bits_per_sample-1));
 452         const int32 max_side =  ((int64)1 << (encoder->bits_per_sample-1)) - 1;
 453
 454         assert(encoder != 0);
 455         assert(encoder->state == FLAC__ENCODER_OK);
 456
 457         j = k = 0;
 458         do {
 459                 for(i = encoder->guts->current_sample_number; i < encoder->blocksize && j < samples; i++, j++, k++) {
 460                         for(channel = 0; channel < encoder->channels; channel++, k++) {
 461                                 x = buf[k];
 462                                 encoder->guts->integer_signal[channel][i] = x;
 463                                 encoder->guts->real_signal[channel][i] = (real)x;
 464                                 if(ms && encoder->guts->current_frame_can_do_mid_side) {
 465                                         if(channel == 0) {
 466                                                 left = x;
 467                                         }
 468                                         else {
 469                                                 side = left - x;
 470                                                 if(side < min_side || side > max_side) {
 471                                                         encoder->guts->current_frame_can_do_mid_side = false;
 472                                                 }
 473                                                 else {
 474                                                         mid = (left + x) >> 1; /* NOTE: not the same as divide-by-two ! */
 475                                                         encoder->guts->integer_signal_mid_side[0][i] = mid;
 476                                                         encoder->guts->integer_signal_mid_side[1][i] = side;
 477                                                         encoder->guts->real_signal_mid_side[0][i] = (real)mid;
 478                                                         encoder->guts->real_signal_mid_side[1][i] = (real)side;
 479                                                 }
 480                                         }
 481                                 }
 482                         }
 483                         encoder->guts->current_sample_number++;
 484                 }
 485                 if(i == encoder->blocksize) {
 486                         if(!encoder_process_frame_(encoder, false)) /* false => not last frame */
 487                                 return false;
 488                 }
 489         } while(j < samples);
 490
 491         return true;
 492 }
 493
 494 bool encoder_process_frame_(FLAC__Encoder *encoder, bool is_last_frame)
 495 {
 496         FLAC__FrameHeader frame_header;
 497         FLAC__BitBuffer *smallest_frame;
 498
 499         assert(encoder->state == FLAC__ENCODER_OK);
 500
 501         /*
 502          * Accumulate raw signal to the MD5 signature
 503          */
 504         if(!FLAC__MD5Accumulate(&encoder->guts->md5context, encoder->guts->integer_signal, encoder->channels, encoder->blocksize, (encoder->bits_per_sample+7) / 8)) {
 505                 encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 506                 return false;
 507         }
 508
 509         /*
 510          * First do a normal encoding pass
 511          */
 512         frame_header.blocksize = encoder->blocksize;
 513         frame_header.sample_rate = encoder->sample_rate;
 514         frame_header.channels = encoder->channels;
 515         frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */
 516         frame_header.bits_per_sample = encoder->bits_per_sample;
 517         frame_header.number.frame_number = encoder->guts->current_frame_number;
 518
 519         if(!FLAC__bitbuffer_clear(&encoder->guts->frame)) {
 520                 encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 521                 return false;
 522         }
 523         if(!FLAC__frame_add_header(&frame_header, encoder->streamable_subset, is_last_frame, &encoder->guts->frame)) {
 524                 encoder->state = FLAC__ENCODER_FRAMING_ERROR;
 525                 return false;
 526         }
 527
 528         if(!encoder_process_subframes_(encoder, is_last_frame, &frame_header, encoder->channels, encoder->guts->integer_signal, encoder->guts->real_signal, &encoder->guts->frame))
 529                 return false;
 530
 531         smallest_frame = &encoder->guts->frame;
 532
 533         /*
 534          * Now try a mid-side version if necessary; otherwise, just use the previous step's frame
 535          */
 536         if(encoder->do_mid_side_stereo && encoder->guts->current_frame_can_do_mid_side) {
 537                 int32 *integer_signal[2];
 538                 real *real_signal[2];
 539
 540                 assert(encoder->channels == 2);
 541
 542                 /* mid-side */
 543                 frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
 544                 if(!FLAC__bitbuffer_clear(&encoder->guts->frame_mid_side)) {
 545                         encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 546                         return false;
 547                 }
 548                 if(!FLAC__frame_add_header(&frame_header, encoder->streamable_subset, is_last_frame, &encoder->guts->frame_mid_side)) {
 549                         encoder->state = FLAC__ENCODER_FRAMING_ERROR;
 550                         return false;
 551                 }
 552                 integer_signal[0] = encoder->guts->integer_signal_mid_side[0]; /* mid channel */
 553                 integer_signal[1] = encoder->guts->integer_signal_mid_side[1]; /* side channel */
 554                 real_signal[0] = encoder->guts->real_signal_mid_side[0]; /* mid channel */
 555                 real_signal[1] = encoder->guts->real_signal_mid_side[1]; /* side channel */
 556                 if(!encoder_process_subframes_(encoder, is_last_frame, &frame_header, encoder->channels, integer_signal, real_signal, &encoder->guts->frame_mid_side))
 557                         return false;
 558                 if(encoder->guts->frame_mid_side.total_bits < smallest_frame->total_bits)
 559                         smallest_frame = &encoder->guts->frame_mid_side;
 560
 561                 /* left-side */
 562                 frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
 563                 if(!FLAC__bitbuffer_clear(&encoder->guts->frame_left_side)) {
 564                         encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 565                         return false;
 566                 }
 567                 if(!FLAC__frame_add_header(&frame_header, encoder->streamable_subset, is_last_frame, &encoder->guts->frame_left_side)) {
 568                         encoder->state = FLAC__ENCODER_FRAMING_ERROR;
 569                         return false;
 570                 }
 571                 integer_signal[0] = encoder->guts->integer_signal[0]; /* left channel */
 572                 integer_signal[1] = encoder->guts->integer_signal_mid_side[1]; /* side channel */
 573                 real_signal[0] = encoder->guts->real_signal[0]; /* left channel */
 574                 real_signal[1] = encoder->guts->real_signal_mid_side[1]; /* side channel */
 575                 if(!encoder_process_subframes_(encoder, is_last_frame, &frame_header, encoder->channels, integer_signal, real_signal, &encoder->guts->frame_left_side))
 576                         return false;
 577                 if(encoder->guts->frame_left_side.total_bits < smallest_frame->total_bits)
 578                         smallest_frame = &encoder->guts->frame_left_side;
 579
 580                 /* right-side */
 581                 frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
 582                 if(!FLAC__bitbuffer_clear(&encoder->guts->frame_right_side)) {
 583                         encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 584                         return false;
 585                 }
 586                 if(!FLAC__frame_add_header(&frame_header, encoder->streamable_subset, is_last_frame, &encoder->guts->frame_right_side)) {
 587                         encoder->state = FLAC__ENCODER_FRAMING_ERROR;
 588                         return false;
 589                 }
 590                 integer_signal[0] = encoder->guts->integer_signal_mid_side[1]; /* side channel */
 591                 integer_signal[1] = encoder->guts->integer_signal[1]; /* right channel */
 592                 real_signal[0] = encoder->guts->real_signal_mid_side[1]; /* side channel */
 593                 real_signal[1] = encoder->guts->real_signal[1]; /* right channel */
 594                 if(!encoder_process_subframes_(encoder, is_last_frame, &frame_header, encoder->channels, integer_signal, real_signal, &encoder->guts->frame_right_side))
 595                         return false;
 596                 if(encoder->guts->frame_right_side.total_bits < smallest_frame->total_bits)
 597                         smallest_frame = &encoder->guts->frame_right_side;
 598         }
 599
 600         /*
 601          * Zero-pad the frame to a byte_boundary
 602          */
 603         if(!FLAC__bitbuffer_zero_pad_to_byte_boundary(smallest_frame)) {
 604                 encoder->state = FLAC__ENCODER_MEMORY_ALLOCATION_ERROR;
 605                 return false;
 606         }
 607
 608         /*
 609          * Write it
 610          */
 611         assert(smallest_frame->bits == 0); /* assert that we're byte-aligned before writing */
 612         assert(smallest_frame->total_consumed_bits == 0); /* assert that no reading of the buffer was done */
 613         if(encoder->guts->write_callback(encoder, smallest_frame->buffer, smallest_frame->bytes, encoder->blocksize, encoder->guts->current_frame_number, encoder->guts->client_data) != FLAC__ENCODER_WRITE_OK) {
 614                 encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_WRITING;
 615                 return false;
 616         }
 617
 618         /*
 619          * Get ready for the next frame
 620          */
 621         encoder->guts->current_frame_can_do_mid_side = true;
 622         encoder->guts->current_sample_number = 0;
 623         encoder->guts->current_frame_number++;
 624         encoder->guts->metadata.data.encoding.total_samples += (uint64)encoder->blocksize;
 625         encoder->guts->metadata.data.encoding.min_framesize = min(smallest_frame->bytes, encoder->guts->metadata.data.encoding.min_framesize);
 626         encoder->guts->metadata.data.encoding.max_framesize = max(smallest_frame->bytes, encoder->guts->metadata.data.encoding.max_framesize);
 627
 628         return true;
 629 }
 630
 631 bool encoder_process_subframes_(FLAC__Encoder *encoder, bool is_last_frame, const FLAC__FrameHeader *frame_header, unsigned channels, const int32 *integer_signal[], const real *real_signal[], FLAC__BitBuffer *frame)
 632 {
 633         real fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1];
 634         real lpc_residual_bits_per_sample;
 635         real autoc[FLAC__MAX_LPC_ORDER+1];
 636         real lp_coeff[FLAC__MAX_LPC_ORDER][FLAC__MAX_LPC_ORDER];
 637         real lpc_error[FLAC__MAX_LPC_ORDER];
 638         unsigned channel;
 639         unsigned min_lpc_order, max_lpc_order, lpc_order;
 640         unsigned min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order;
 641         unsigned max_partition_order;
 642         unsigned min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision;
 643         unsigned rice_parameter;
 644         unsigned candidate_bits, best_bits;
 645
 646         if(is_last_frame) {
 647                 max_partition_order = 0;
 648         }
 649         else {
 650                 unsigned limit = 0, b = encoder->blocksize;
 651                 while(!(b & 1)) {
 652                         limit++;
 653                         b >>= 1;
 654                 }
 655                 max_partition_order = min(encoder->rice_optimization_level, limit);
 656         }
 657
 658         for(channel = 0; channel < channels; channel++) {
 659                 /* verbatim subframe is the baseline against which we measure other compressed subframes */
 660                 best_bits = encoder_evaluate_verbatim_subframe_(frame_header->blocksize, frame_header->bits_per_sample, &(encoder->guts->best_subframe));
 661
 662                 if(frame_header->blocksize >= FLAC__MAX_FIXED_ORDER) {
 663                         /* check for constant subframe */
 664                         guess_fixed_order = FLAC__fixed_compute_best_predictor(integer_signal[channel]+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample);
 665                         if(fixed_residual_bits_per_sample[1] == 0.0) {
 666                                 /* the above means integer_signal[channel]+FLAC__MAX_FIXED_ORDER is constant, now we just have to check the warmup samples */
 667                                 unsigned i, signal_is_constant = true;
 668                                 for(i = 1; i <= FLAC__MAX_FIXED_ORDER; i++) {
 669                                         if(integer_signal[channel][0] != integer_signal[channel][i]) {
 670                                                 signal_is_constant = false;
 671                                                 break;
 672                                         }
 673                                 }
 674                                 if(signal_is_constant) {
 675                                         candidate_bits = encoder_evaluate_constant_subframe_(integer_signal[channel][0], frame_header->bits_per_sample, &(encoder->guts->candidate_subframe));
 676                                         if(candidate_bits < best_bits) {
 677                                                 encoder_promote_candidate_subframe_(encoder);
 678                                                 best_bits = candidate_bits;
 679                                         }
 680                                 }
 681                         }
 682                         else {
 683                                 /* encode fixed */
 684                                 if(encoder->do_exhaustive_model_search) {
 685                                         min_fixed_order = 0;
 686                                         max_fixed_order = FLAC__MAX_FIXED_ORDER;
 687                                 }
 688                                 else {
 689                                         min_fixed_order = max_fixed_order = guess_fixed_order;
 690                                 }
 691                                 for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) {
 692                                         if(fixed_residual_bits_per_sample[fixed_order] >= (real)frame_header->bits_per_sample)
 693                                                 continue; /* don't even try */
 694                                         /* 0.5 is for rounding, another 1.0 is to account for the signed->unsigned conversion during rice coding */
 695                                         rice_parameter = (fixed_residual_bits_per_sample[fixed_order] > 0.0)? (unsigned)(fixed_residual_bits_per_sample[fixed_order]+1.5) : 0;
 696                                         if(rice_parameter >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN))
 697                                                 rice_parameter = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN) - 1;
 698                                         candidate_bits = encoder_evaluate_fixed_subframe_(integer_signal[channel], encoder->guts->residual[!encoder->guts->best_residual], frame_header->blocksize, frame_header->bits_per_sample, fixed_order, rice_parameter, max_partition_order, &(encoder->guts->candidate_subframe));
 699                                         if(candidate_bits < best_bits) {
 700                                                 encoder_promote_candidate_subframe_(encoder);
 701                                                 best_bits = candidate_bits;
 702                                         }
 703                                 }
 704
 705                                 /* encode lpc */
 706                                 if(encoder->max_lpc_order > 0) {
 707                                         if(encoder->max_lpc_order >= frame_header->blocksize)
 708                                                 max_lpc_order = frame_header->blocksize-1;
 709                                         else
 710                                                 max_lpc_order = encoder->max_lpc_order;
 711                                         if(max_lpc_order > 0) {
 712                                                 FLAC__lpc_compute_autocorrelation(real_signal[channel], frame_header->blocksize, max_lpc_order+1, autoc);
 713                                                 FLAC__lpc_compute_lp_coefficients(autoc, max_lpc_order, lp_coeff, lpc_error);
 714                                                 if(encoder->do_exhaustive_model_search) {
 715                                                         min_lpc_order = 1;
 716                                                 }
 717                                                 else {
 718                                                         unsigned guess_lpc_order = FLAC__lpc_compute_best_order(lpc_error, max_lpc_order, frame_header->blocksize, frame_header->bits_per_sample);
 719                                                         min_lpc_order = max_lpc_order = guess_lpc_order;
 720                                                 }
 721                                                 if(encoder->do_qlp_coeff_prec_search) {
 722                                                         min_qlp_coeff_precision = FLAC__MIN_QLP_COEFF_PRECISION;
 723                                                         max_qlp_coeff_precision = 32 - frame_header->bits_per_sample - 1;
 724                                                 }
 725                                                 else {
 726                                                         min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->qlp_coeff_precision;
 727                                                 }
 728                                                 for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order; lpc_order++) {
 729                                                         lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize);
 730                                                         if(lpc_residual_bits_per_sample >= (real)frame_header->bits_per_sample)
 731                                                                 continue; /* don't even try */
 732                                                         /* 0.5 is for rounding, another 1.0 is to account for the signed->unsigned conversion during rice coding */
 733                                                         rice_parameter = (lpc_residual_bits_per_sample > 0.0)? (unsigned)(lpc_residual_bits_per_sample+1.5) : 0;
 734                                                         if(rice_parameter >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN))
 735                                                                 rice_parameter = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN) - 1;
 736                                                         for(qlp_coeff_precision = min_qlp_coeff_precision; qlp_coeff_precision <= max_qlp_coeff_precision; qlp_coeff_precision++) {
 737                                                                 candidate_bits = encoder_evaluate_lpc_subframe_(integer_signal[channel], encoder->guts->residual[!encoder->guts->best_residual], lp_coeff[lpc_order-1], frame_header->blocksize, frame_header->bits_per_sample, lpc_order, qlp_coeff_precision, rice_parameter, max_partition_order, &(encoder->guts->candidate_subframe));
 738                                                                 if(candidate_bits > 0) { /* if == 0, there was a problem quantizing the lpcoeffs */
 739                                                                         if(candidate_bits < best_bits) {
 740                                                                                 encoder_promote_candidate_subframe_(encoder);
 741                                                                                 best_bits = candidate_bits;
 742                                                                         }
 743                                                                 }
 744                                                         }
 745                                                 }
 746                                         }
 747                                 }
 748                         }
 749                 }
 750
 751                 /* add the best subframe */
 752                 switch(encoder->guts->best_subframe.type) {
 753                         case FLAC__SUBFRAME_TYPE_CONSTANT:
 754                                 if(!encoder_generate_constant_subframe_(&(encoder->guts->best_subframe), frame_header->bits_per_sample, frame)) {
 755                                         encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_ENCODING;
 756                                         return false;
 757                                 }
 758                                 break;
 759                         case FLAC__SUBFRAME_TYPE_FIXED:
 760                                 if(!encoder_generate_fixed_subframe_(&(encoder->guts->best_subframe), encoder->guts->residual[encoder->guts->best_residual], frame_header->blocksize, frame_header->bits_per_sample, frame)) {
 761                                         encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_ENCODING;
 762                                         return false;
 763                                 }
 764                                 break;
 765                         case FLAC__SUBFRAME_TYPE_LPC:
 766                                 if(!encoder_generate_lpc_subframe_(&(encoder->guts->best_subframe), encoder->guts->residual[encoder->guts->best_residual], frame_header->blocksize, frame_header->bits_per_sample, frame)) {
 767                                         encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_ENCODING;
 768                                         return false;
 769                                 }
 770                                 break;
 771                         case FLAC__SUBFRAME_TYPE_VERBATIM:
 772                                 if(!encoder_generate_verbatim_subframe_(&(encoder->guts->best_subframe), integer_signal[channel], frame_header->blocksize, frame_header->bits_per_sample, frame)) {
 773                                         encoder->state = FLAC__ENCODER_FATAL_ERROR_WHILE_ENCODING;
 774                                         return false;
 775                                 }
 776                                 break;
 777                 }
 778         }
 779
 780         return true;
 781 }
 782
 783 unsigned encoder_evaluate_constant_subframe_(const int32 signal, unsigned bits_per_sample, FLAC__SubframeHeader *subframe)
 784 {
 785         subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT;
 786         subframe->data.constant.value = signal;
 787
 788         return FLAC__SUBFRAME_HEADER_TYPE_LEN + bits_per_sample;
 789 }
 790
 791 unsigned encoder_evaluate_fixed_subframe_(const int32 signal[], int32 residual[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned rice_parameter, unsigned max_partition_order, FLAC__SubframeHeader *subframe)
 792 {
 793         unsigned i, residual_bits;
 794         const unsigned residual_samples = blocksize - order;
 795
 796         FLAC__fixed_compute_residual(signal+order, residual_samples, order, residual);
 797
 798         subframe->type = FLAC__SUBFRAME_TYPE_FIXED;
 799
 800         subframe->data.fixed.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
 801
 802         residual_bits = encoder_find_best_partition_order_(residual, residual_samples, order, rice_parameter, max_partition_order, &subframe->data.fixed.entropy_coding_method.data.partitioned_rice.order, subframe->data.fixed.entropy_coding_method.data.partitioned_rice.parameters);
 803
 804         subframe->data.fixed.order = order;
 805         for(i = 0; i < order; i++)
 806                 subframe->data.fixed.warmup[i] = signal[i];
 807
 808         return FLAC__SUBFRAME_HEADER_TYPE_LEN + (order * bits_per_sample) + residual_bits;
 809 }
 810
 811 unsigned encoder_evaluate_lpc_subframe_(const int32 signal[], int32 residual[], const real lp_coeff[], unsigned blocksize, unsigned bits_per_sample, unsigned order, unsigned qlp_coeff_precision, unsigned rice_parameter, unsigned max_partition_order, FLAC__SubframeHeader *subframe)
 812 {
 813         int32 qlp_coeff[FLAC__MAX_LPC_ORDER];
 814         unsigned i, residual_bits;
 815         int quantization, ret;
 816         const unsigned residual_samples = blocksize - order;
 817
 818         ret = FLAC__lpc_quantize_coefficients(lp_coeff, order, qlp_coeff_precision, bits_per_sample, qlp_coeff, &quantization);
 819         if(ret != 0)
 820                 return 0; /* this is a hack to indicate to the caller that we can't do lp at this order on this subframe */
 821
 822         FLAC__lpc_compute_residual_from_qlp_coefficients(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
 823
 824         subframe->type = FLAC__SUBFRAME_TYPE_LPC;
 825
 826         subframe->data.lpc.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE;
 827
 828         residual_bits = encoder_find_best_partition_order_(residual, residual_samples, order, rice_parameter, max_partition_order, &subframe->data.lpc.entropy_coding_method.data.partitioned_rice.order, subframe->data.lpc.entropy_coding_method.data.partitioned_rice.parameters);
 829
 830         subframe->data.lpc.order = order;
 831         subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision;
 832         subframe->data.lpc.quantization_level = quantization;
 833         memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(int32)*FLAC__MAX_LPC_ORDER);
 834         for(i = 0; i < order; i++)
 835                 subframe->data.lpc.warmup[i] = signal[i];
 836
 837         return FLAC__SUBFRAME_HEADER_TYPE_LEN + FLAC__SUBFRAME_HEADER_LPC_QLP_COEFF_PRECISION_LEN + FLAC__SUBFRAME_HEADER_LPC_QLP_SHIFT_LEN + (order * (qlp_coeff_precision + bits_per_sample)) + residual_bits;
 838 }
 839
 840 unsigned encoder_evaluate_verbatim_subframe_(unsigned blocksize, unsigned bits_per_sample, FLAC__SubframeHeader *subframe)
 841 {
 842         subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM;
 843
 844         return FLAC__SUBFRAME_HEADER_TYPE_LEN + (blocksize * bits_per_sample);
 845 }
 846
 847 unsigned encoder_find_best_partition_order_(int32 residual[], unsigned residual_samples, unsigned predictor_order, unsigned rice_parameter, unsigned max_partition_order, unsigned *best_partition_order, unsigned best_parameters[])
 848 {
 849         unsigned residual_bits, best_residual_bits = 0;
 850         unsigned partition_order;
 851         unsigned best_parameters_index = 0, parameters[2][1 << FLAC__MAX_RICE_PARTITION_ORDER];
 852
 853         for(partition_order = 0; partition_order <= max_partition_order; partition_order++) {
 854                 if(!encoder_set_partitioned_rice_(residual, residual_samples, predictor_order, rice_parameter, partition_order, parameters[!best_parameters_index], &residual_bits)) {
 855                         assert(best_residual_bits != 0);
 856                         break;
 857                 }
 858                 if(best_residual_bits == 0 || residual_bits < best_residual_bits) {
 859                         best_residual_bits = residual_bits;
 860                         *best_partition_order = partition_order;
 861                         best_parameters_index = !best_parameters_index;
 862                 }
 863         }
 864         memcpy(best_parameters, parameters[best_parameters_index], sizeof(unsigned)*(1<<(*best_partition_order)));
 865
 866         return best_residual_bits;
 867 }
 868
 869 bool encoder_generate_constant_subframe_(const FLAC__SubframeHeader *header, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer)
 870 {
 871         assert(header->type == FLAC__SUBFRAME_TYPE_CONSTANT);
 872         return FLAC__subframe_add_constant(bits_per_sample, header, bitbuffer);
 873 }
 874
 875 bool encoder_generate_fixed_subframe_(const FLAC__SubframeHeader *header, int32 residual[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer)
 876 {
 877         assert(header->type == FLAC__SUBFRAME_TYPE_FIXED);
 878         return FLAC__subframe_add_fixed(residual, blocksize - header->data.fixed.order, bits_per_sample, header, bitbuffer);
 879 }
 880
 881 bool encoder_generate_lpc_subframe_(const FLAC__SubframeHeader *header, int32 residual[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer)
 882 {
 883         assert(header->type == FLAC__SUBFRAME_TYPE_LPC);
 884         return FLAC__subframe_add_lpc(residual, blocksize - header->data.lpc.order, bits_per_sample, header, bitbuffer);
 885 }
 886
 887 bool encoder_generate_verbatim_subframe_(const FLAC__SubframeHeader *header, const int32 signal[], unsigned blocksize, unsigned bits_per_sample, FLAC__BitBuffer *bitbuffer)
 888 {
 889         assert(header->type == FLAC__SUBFRAME_TYPE_VERBATIM);
 890 #ifdef NDEBUG
 891         (void)header; /* silence compiler warning about unused parameter */
 892 #endif
 893         return FLAC__subframe_add_verbatim(signal, blocksize, bits_per_sample, bitbuffer);
 894 }
 895
 896 void encoder_promote_candidate_subframe_(FLAC__Encoder *encoder)
 897 {
 898         assert(encoder->state == FLAC__ENCODER_OK);
 899         encoder->guts->best_subframe = encoder->guts->candidate_subframe;
 900         encoder->guts->best_residual = !encoder->guts->best_residual;
 901 }
 902
 903 bool encoder_set_partitioned_rice_(const int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameter, const unsigned partition_order, unsigned parameters[], unsigned *bits)
 904 {
 905         unsigned bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN;
 906
 907         if(partition_order == 0) {
 908                 unsigned i;
 909                 parameters[0] = rice_parameter;
 910                 bits_ += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN;
 911 #ifdef ESTIMATE_RICE_BITS
 912                 --rice_parameter;
 913 #endif
 914                 for(i = 0; i < residual_samples; i++)
 915 #ifdef ESTIMATE_RICE_BITS
 916                         bits_ += ESTIMATE_RICE_BITS(residual[i], rice_parameter);
 917 #else
 918                         bits_ += FLAC__bitbuffer_rice_bits(residual[i], rice_parameter);
 919 #endif
 920         }
 921         else {
 922                 unsigned i, j, k = 0, k_last = 0;
 923                 unsigned mean, parameter, partition_samples;
 924                 const unsigned max_parameter = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN) - 1;
 925                 for(i = 0; i < (1u<<partition_order); i++) {
 926                         partition_samples = (residual_samples+predictor_order) >> partition_order;
 927                         if(i == 0) {
 928                                 if(partition_samples <= predictor_order)
 929                                         return false;
 930                                 else
 931                                         partition_samples -= predictor_order;
 932                         }
 933                         mean = partition_samples >> 1;
 934                         for(j = 0; j < partition_samples; j++, k++)
 935                                 mean += ((residual[k] < 0)? (unsigned)(-residual[k]) : (unsigned)residual[k]);
 936                         mean /= partition_samples;
 937                         /* calc parameter = floor(log2(mean)) + 1 */
 938                         parameter = 0;
 939                         while(mean) {
 940                                 parameter++;
 941                                 mean >>= 1;
 942                         }
 943                         if(parameter > max_parameter)
 944                                 parameter = max_parameter;
 945                         parameters[i] = parameter;
 946                         bits_ += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN;
 947 #ifdef ESTIMATE_RICE_BITS
 948                         --parameter;
 949 #endif
 950                         for(j = k_last; j < k; j++)
 951 #ifdef ESTIMATE_RICE_BITS
 952                                 bits_ += ESTIMATE_RICE_BITS(residual[j], parameter);
 953 #else
 954                                 bits_ += FLAC__bitbuffer_rice_bits(residual[j], parameter);
 955 #endif
 956                         k_last = k;
 957                 }
 958         }
 959
 960         *bits = bits_;
 961         return true;
 962 }