src/libFLAC/lpc.c

   1 /* libFLAC - Free Lossless Audio Codec library
   2  * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  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 #if HAVE_CONFIG_H
  33 #  include <config.h>
  34 #endif
  35
  36 #include <math.h>
  37 #include "FLAC/assert.h"
  38 #include "FLAC/format.h"
  39 #include "private/bitmath.h"
  40 #include "private/lpc.h"
  41 #if defined DEBUG || defined FLAC__OVERFLOW_DETECT || defined FLAC__OVERFLOW_DETECT_VERBOSE
  42 #include <stdio.h>
  43 #endif
  44
  45 #ifndef FLAC__INTEGER_ONLY_LIBRARY
  46
  47 #ifndef M_LN2
  48 /* math.h in VC++ doesn't seem to have this (how Microsoft is that?) */
  49 #define M_LN2 0.69314718055994530942
  50 #endif
  51
  52 void FLAC__lpc_window_data(const FLAC__int32 in[], const FLAC__real window[], FLAC__real out[], unsigned data_len)
  53 {
  54         unsigned i;
  55         for(i = 0; i < data_len; i++)
  56                 out[i] = in[i] * window[i];
  57 }
  58
  59 void FLAC__lpc_compute_autocorrelation(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[])
  60 {
  61         /* a readable, but slower, version */
  62 #if 0
  63         FLAC__real d;
  64         unsigned i;
  65
  66         FLAC__ASSERT(lag > 0);
  67         FLAC__ASSERT(lag <= data_len);
  68
  69         /*
  70          * Technically we should subtract the mean first like so:
  71          *   for(i = 0; i < data_len; i++)
  72          *     data[i] -= mean;
  73          * but it appears not to make enough of a difference to matter, and
  74          * most signals are already closely centered around zero
  75          */
  76         while(lag--) {
  77                 for(i = lag, d = 0.0; i < data_len; i++)
  78                         d += data[i] * data[i - lag];
  79                 autoc[lag] = d;
  80         }
  81 #endif
  82
  83         /*
  84          * this version tends to run faster because of better data locality
  85          * ('data_len' is usually much larger than 'lag')
  86          */
  87         FLAC__real d;
  88         unsigned sample, coeff;
  89         const unsigned limit = data_len - lag;
  90
  91         FLAC__ASSERT(lag > 0);
  92         FLAC__ASSERT(lag <= data_len);
  93
  94         for(coeff = 0; coeff < lag; coeff++)
  95                 autoc[coeff] = 0.0;
  96         for(sample = 0; sample <= limit; sample++) {
  97                 d = data[sample];
  98                 for(coeff = 0; coeff < lag; coeff++)
  99                         autoc[coeff] += d * data[sample+coeff];
 100         }
 101         for(; sample < data_len; sample++) {
 102                 d = data[sample];
 103                 for(coeff = 0; coeff < data_len - sample; coeff++)
 104                         autoc[coeff] += d * data[sample+coeff];
 105         }
 106 }
 107
 108 void FLAC__lpc_compute_lp_coefficients(const FLAC__real autoc[], unsigned *max_order, FLAC__real lp_coeff[][FLAC__MAX_LPC_ORDER], FLAC__double error[])
 109 {
 110         unsigned i, j;
 111         FLAC__double r, err, ref[FLAC__MAX_LPC_ORDER], lpc[FLAC__MAX_LPC_ORDER];
 112
 113         FLAC__ASSERT(0 != max_order);
 114         FLAC__ASSERT(0 < *max_order);
 115         FLAC__ASSERT(*max_order <= FLAC__MAX_LPC_ORDER);
 116         FLAC__ASSERT(autoc[0] != 0.0);
 117
 118         err = autoc[0];
 119
 120         for(i = 0; i < *max_order; i++) {
 121                 /* Sum up this iteration's reflection coefficient. */
 122                 r = -autoc[i+1];
 123                 for(j = 0; j < i; j++)
 124                         r -= lpc[j] * autoc[i-j];
 125                 ref[i] = (r/=err);
 126
 127                 /* Update LPC coefficients and total error. */
 128                 lpc[i]=r;
 129                 for(j = 0; j < (i>>1); j++) {
 130                         FLAC__double tmp = lpc[j];
 131                         lpc[j] += r * lpc[i-1-j];
 132                         lpc[i-1-j] += r * tmp;
 133                 }
 134                 if(i & 1)
 135                         lpc[j] += lpc[j] * r;
 136
 137                 err *= (1.0 - r * r);
 138
 139                 /* save this order */
 140                 for(j = 0; j <= i; j++)
 141                         lp_coeff[i][j] = (FLAC__real)(-lpc[j]); /* negate FIR filter coeff to get predictor coeff */
 142                 error[i] = err;
 143
 144                 /* see SF bug #1601812 http://sourceforge.net/tracker/index.php?func=detail&aid=1601812&group_id=13478&atid=113478 */
 145                 if(err == 0.0) {
 146                         *max_order = i+1;
 147                         return;
 148                 }
 149         }
 150 }
 151
 152 int FLAC__lpc_quantize_coefficients(const FLAC__real lp_coeff[], unsigned order, unsigned precision, FLAC__int32 qlp_coeff[], int *shift)
 153 {
 154         unsigned i;
 155         FLAC__double cmax;
 156         FLAC__int32 qmax, qmin;
 157
 158         FLAC__ASSERT(precision > 0);
 159         FLAC__ASSERT(precision >= FLAC__MIN_QLP_COEFF_PRECISION);
 160
 161         /* drop one bit for the sign; from here on out we consider only |lp_coeff[i]| */
 162         precision--;
 163         qmax = 1 << precision;
 164         qmin = -qmax;
 165         qmax--;
 166
 167         /* calc cmax = max( |lp_coeff[i]| ) */
 168         cmax = 0.0;
 169         for(i = 0; i < order; i++) {
 170                 const FLAC__double d = fabs(lp_coeff[i]);
 171                 if(d > cmax)
 172                         cmax = d;
 173         }
 174
 175         if(cmax <= 0.0) {
 176                 /* => coefficients are all 0, which means our constant-detect didn't work */
 177                 return 2;
 178         }
 179         else {
 180                 const int max_shiftlimit = (1 << (FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN-1)) - 1;
 181                 const int min_shiftlimit = -max_shiftlimit - 1;
 182                 int log2cmax;
 183
 184                 (void)frexp(cmax, &log2cmax);
 185                 log2cmax--;
 186                 *shift = (int)precision - log2cmax - 1;
 187
 188                 if(*shift > max_shiftlimit)
 189                         *shift = max_shiftlimit;
 190                 else if(*shift < min_shiftlimit)
 191                         return 1;
 192         }
 193
 194         if(*shift >= 0) {
 195                 FLAC__double error = 0.0;
 196                 FLAC__int32 q;
 197                 for(i = 0; i < order; i++) {
 198                         error += lp_coeff[i] * (1 << *shift);
 199 #if 1 /* unfortunately lround() is C99 */
 200                         if(error >= 0.0)
 201                                 q = (FLAC__int32)(error + 0.5);
 202                         else
 203                                 q = (FLAC__int32)(error - 0.5);
 204 #else
 205                         q = lround(error);
 206 #endif
 207 #ifdef FLAC__OVERFLOW_DETECT
 208                         if(q > qmax+1) /* we expect q==qmax+1 occasionally due to rounding */
 209                                 fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q>qmax %d>%d shift=%d cmax=%f precision=%u lpc[%u]=%f\n",q,qmax,*shift,cmax,precision+1,i,lp_coeff[i]);
 210                         else if(q < qmin)
 211                                 fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q<qmin %d<%d shift=%d cmax=%f precision=%u lpc[%u]=%f\n",q,qmin,*shift,cmax,precision+1,i,lp_coeff[i]);
 212 #endif
 213                         if(q > qmax)
 214                                 q = qmax;
 215                         else if(q < qmin)
 216                                 q = qmin;
 217                         error -= q;
 218                         qlp_coeff[i] = q;
 219                 }
 220         }
 221         /* negative shift is very rare but due to design flaw, negative shift is
 222          * a NOP in the decoder, so it must be handled specially by scaling down
 223          * coeffs
 224          */
 225         else {
 226                 const int nshift = -(*shift);
 227                 FLAC__double error = 0.0;
 228                 FLAC__int32 q;
 229 #ifdef DEBUG
 230                 fprintf(stderr,"FLAC__lpc_quantize_coefficients: negative shift=%d order=%u cmax=%f\n", *shift, order, cmax);
 231 #endif
 232                 for(i = 0; i < order; i++) {
 233                         error += lp_coeff[i] / (1 << nshift);
 234 #if 1 /* unfortunately lround() is C99 */
 235                         if(error >= 0.0)
 236                                 q = (FLAC__int32)(error + 0.5);
 237                         else
 238                                 q = (FLAC__int32)(error - 0.5);
 239 #else
 240                         q = lround(error);
 241 #endif
 242 #ifdef FLAC__OVERFLOW_DETECT
 243                         if(q > qmax+1) /* we expect q==qmax+1 occasionally due to rounding */
 244                                 fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q>qmax %d>%d shift=%d cmax=%f precision=%u lpc[%u]=%f\n",q,qmax,*shift,cmax,precision+1,i,lp_coeff[i]);
 245                         else if(q < qmin)
 246                                 fprintf(stderr,"FLAC__lpc_quantize_coefficients: quantizer overflow: q<qmin %d<%d shift=%d cmax=%f precision=%u lpc[%u]=%f\n",q,qmin,*shift,cmax,precision+1,i,lp_coeff[i]);
 247 #endif
 248                         if(q > qmax)
 249                                 q = qmax;
 250                         else if(q < qmin)
 251                                 q = qmin;
 252                         error -= q;
 253                         qlp_coeff[i] = q;
 254                 }
 255                 *shift = 0;
 256         }
 257
 258         return 0;
 259 }
 260
 261 void FLAC__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[])
 262 #ifdef FLAC__OVERFLOW_DETECT /* this ugly flavor is only for debugging */
 263 {
 264         FLAC__int64 sumo;
 265         unsigned i, j;
 266         FLAC__int32 sum;
 267         const FLAC__int32 *history;
 268
 269 #ifdef FLAC__OVERFLOW_DETECT_VERBOSE
 270         fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
 271         for(i=0;i<order;i++)
 272                 fprintf(stderr,", q[%u]=%d",i,qlp_coeff[i]);
 273         fprintf(stderr,"\n");
 274 #endif
 275         FLAC__ASSERT(order > 0);
 276
 277         for(i = 0; i < data_len; i++) {
 278                 sumo = 0;
 279                 sum = 0;
 280                 history = data;
 281                 for(j = 0; j < order; j++) {
 282                         sum += qlp_coeff[j] * (*(--history));
 283                         sumo += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*history);
 284 #if defined _MSC_VER
 285                         if(sumo > 2147483647I64 || sumo < -2147483648I64)
 286                                 fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients: OVERFLOW, i=%u, j=%u, c=%d, d=%d, sumo=%I64d\n",i,j,qlp_coeff[j],*history,sumo);
 287 #else
 288                         if(sumo > 2147483647ll || sumo < -2147483648ll)
 289                                 fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients: OVERFLOW, i=%u, j=%u, c=%d, d=%d, sumo=%lld\n",i,j,qlp_coeff[j],*history,(long long)sumo);
 290 #endif
 291                 }
 292                 *(residual++) = *(data++) - (sum >> lp_quantization);
 293         }
 294
 295         /* Here's a slower but clearer version:
 296         for(i = 0; i < data_len; i++) {
 297                 sum = 0;
 298                 for(j = 0; j < order; j++)
 299                         sum += qlp_coeff[j] * data[i-j-1];
 300                 residual[i] = data[i] - (sum >> lp_quantization);
 301         }
 302         */
 303 }
 304 #else /* fully unrolled version for normal use */
 305 {
 306         unsigned i;
 307         FLAC__int32 sum;
 308
 309         FLAC__ASSERT(order > 0);
 310         FLAC__ASSERT(order <= 32);
 311
 312         /*
 313          * We do unique versions up to 12th order since that's the subset limit.
 314          * Also they are roughly ordered to match frequency of occurrence to
 315          * minimize branching.
 316          */
 317         if(order <= 12) {
 318                 if(order > 8) {
 319                         if(order > 10) {
 320                                 if(order == 12) {
 321                                         for(i = 0; i < data_len; i++) {
 322                                                 sum = 0;
 323                                                 sum += qlp_coeff[11] * data[i-12];
 324                                                 sum += qlp_coeff[10] * data[i-11];
 325                                                 sum += qlp_coeff[9] * data[i-10];
 326                                                 sum += qlp_coeff[8] * data[i-9];
 327                                                 sum += qlp_coeff[7] * data[i-8];
 328                                                 sum += qlp_coeff[6] * data[i-7];
 329                                                 sum += qlp_coeff[5] * data[i-6];
 330                                                 sum += qlp_coeff[4] * data[i-5];
 331                                                 sum += qlp_coeff[3] * data[i-4];
 332                                                 sum += qlp_coeff[2] * data[i-3];
 333                                                 sum += qlp_coeff[1] * data[i-2];
 334                                                 sum += qlp_coeff[0] * data[i-1];
 335                                                 residual[i] = data[i] - (sum >> lp_quantization);
 336                                         }
 337                                 }
 338                                 else { /* order == 11 */
 339                                         for(i = 0; i < data_len; i++) {
 340                                                 sum = 0;
 341                                                 sum += qlp_coeff[10] * data[i-11];
 342                                                 sum += qlp_coeff[9] * data[i-10];
 343                                                 sum += qlp_coeff[8] * data[i-9];
 344                                                 sum += qlp_coeff[7] * data[i-8];
 345                                                 sum += qlp_coeff[6] * data[i-7];
 346                                                 sum += qlp_coeff[5] * data[i-6];
 347                                                 sum += qlp_coeff[4] * data[i-5];
 348                                                 sum += qlp_coeff[3] * data[i-4];
 349                                                 sum += qlp_coeff[2] * data[i-3];
 350                                                 sum += qlp_coeff[1] * data[i-2];
 351                                                 sum += qlp_coeff[0] * data[i-1];
 352                                                 residual[i] = data[i] - (sum >> lp_quantization);
 353                                         }
 354                                 }
 355                         }
 356                         else {
 357                                 if(order == 10) {
 358                                         for(i = 0; i < data_len; i++) {
 359                                                 sum = 0;
 360                                                 sum += qlp_coeff[9] * data[i-10];
 361                                                 sum += qlp_coeff[8] * data[i-9];
 362                                                 sum += qlp_coeff[7] * data[i-8];
 363                                                 sum += qlp_coeff[6] * data[i-7];
 364                                                 sum += qlp_coeff[5] * data[i-6];
 365                                                 sum += qlp_coeff[4] * data[i-5];
 366                                                 sum += qlp_coeff[3] * data[i-4];
 367                                                 sum += qlp_coeff[2] * data[i-3];
 368                                                 sum += qlp_coeff[1] * data[i-2];
 369                                                 sum += qlp_coeff[0] * data[i-1];
 370                                                 residual[i] = data[i] - (sum >> lp_quantization);
 371                                         }
 372                                 }
 373                                 else { /* order == 9 */
 374                                         for(i = 0; i < data_len; i++) {
 375                                                 sum = 0;
 376                                                 sum += qlp_coeff[8] * data[i-9];
 377                                                 sum += qlp_coeff[7] * data[i-8];
 378                                                 sum += qlp_coeff[6] * data[i-7];
 379                                                 sum += qlp_coeff[5] * data[i-6];
 380                                                 sum += qlp_coeff[4] * data[i-5];
 381                                                 sum += qlp_coeff[3] * data[i-4];
 382                                                 sum += qlp_coeff[2] * data[i-3];
 383                                                 sum += qlp_coeff[1] * data[i-2];
 384                                                 sum += qlp_coeff[0] * data[i-1];
 385                                                 residual[i] = data[i] - (sum >> lp_quantization);
 386                                         }
 387                                 }
 388                         }
 389                 }
 390                 else if(order > 4) {
 391                         if(order > 6) {
 392                                 if(order == 8) {
 393                                         for(i = 0; i < data_len; i++) {
 394                                                 sum = 0;
 395                                                 sum += qlp_coeff[7] * data[i-8];
 396                                                 sum += qlp_coeff[6] * data[i-7];
 397                                                 sum += qlp_coeff[5] * data[i-6];
 398                                                 sum += qlp_coeff[4] * data[i-5];
 399                                                 sum += qlp_coeff[3] * data[i-4];
 400                                                 sum += qlp_coeff[2] * data[i-3];
 401                                                 sum += qlp_coeff[1] * data[i-2];
 402                                                 sum += qlp_coeff[0] * data[i-1];
 403                                                 residual[i] = data[i] - (sum >> lp_quantization);
 404                                         }
 405                                 }
 406                                 else { /* order == 7 */
 407                                         for(i = 0; i < data_len; i++) {
 408                                                 sum = 0;
 409                                                 sum += qlp_coeff[6] * data[i-7];
 410                                                 sum += qlp_coeff[5] * data[i-6];
 411                                                 sum += qlp_coeff[4] * data[i-5];
 412                                                 sum += qlp_coeff[3] * data[i-4];
 413                                                 sum += qlp_coeff[2] * data[i-3];
 414                                                 sum += qlp_coeff[1] * data[i-2];
 415                                                 sum += qlp_coeff[0] * data[i-1];
 416                                                 residual[i] = data[i] - (sum >> lp_quantization);
 417                                         }
 418                                 }
 419                         }
 420                         else {
 421                                 if(order == 6) {
 422                                         for(i = 0; i < data_len; i++) {
 423                                                 sum = 0;
 424                                                 sum += qlp_coeff[5] * data[i-6];
 425                                                 sum += qlp_coeff[4] * data[i-5];
 426                                                 sum += qlp_coeff[3] * data[i-4];
 427                                                 sum += qlp_coeff[2] * data[i-3];
 428                                                 sum += qlp_coeff[1] * data[i-2];
 429                                                 sum += qlp_coeff[0] * data[i-1];
 430                                                 residual[i] = data[i] - (sum >> lp_quantization);
 431                                         }
 432                                 }
 433                                 else { /* order == 5 */
 434                                         for(i = 0; i < data_len; i++) {
 435                                                 sum = 0;
 436                                                 sum += qlp_coeff[4] * data[i-5];
 437                                                 sum += qlp_coeff[3] * data[i-4];
 438                                                 sum += qlp_coeff[2] * data[i-3];
 439                                                 sum += qlp_coeff[1] * data[i-2];
 440                                                 sum += qlp_coeff[0] * data[i-1];
 441                                                 residual[i] = data[i] - (sum >> lp_quantization);
 442                                         }
 443                                 }
 444                         }
 445                 }
 446                 else {
 447                         if(order > 2) {
 448                                 if(order == 4) {
 449                                         for(i = 0; i < data_len; i++) {
 450                                                 sum = 0;
 451                                                 sum += qlp_coeff[3] * data[i-4];
 452                                                 sum += qlp_coeff[2] * data[i-3];
 453                                                 sum += qlp_coeff[1] * data[i-2];
 454                                                 sum += qlp_coeff[0] * data[i-1];
 455                                                 residual[i] = data[i] - (sum >> lp_quantization);
 456                                         }
 457                                 }
 458                                 else { /* order == 3 */
 459                                         for(i = 0; i < data_len; i++) {
 460                                                 sum = 0;
 461                                                 sum += qlp_coeff[2] * data[i-3];
 462                                                 sum += qlp_coeff[1] * data[i-2];
 463                                                 sum += qlp_coeff[0] * data[i-1];
 464                                                 residual[i] = data[i] - (sum >> lp_quantization);
 465                                         }
 466                                 }
 467                         }
 468                         else {
 469                                 if(order == 2) {
 470                                         for(i = 0; i < data_len; i++) {
 471                                                 sum = 0;
 472                                                 sum += qlp_coeff[1] * data[i-2];
 473                                                 sum += qlp_coeff[0] * data[i-1];
 474                                                 residual[i] = data[i] - (sum >> lp_quantization);
 475                                         }
 476                                 }
 477                                 else { /* order == 1 */
 478                                         for(i = 0; i < data_len; i++)
 479                                                 residual[i] = data[i] - ((qlp_coeff[0] * data[i-1]) >> lp_quantization);
 480                                 }
 481                         }
 482                 }
 483         }
 484         else { /* order > 12 */
 485                 for(i = 0; i < data_len; i++) {
 486                         sum = 0;
 487                         switch(order) {
 488                                 case 32: sum += qlp_coeff[31] * data[i-32];
 489                                 case 31: sum += qlp_coeff[30] * data[i-31];
 490                                 case 30: sum += qlp_coeff[29] * data[i-30];
 491                                 case 29: sum += qlp_coeff[28] * data[i-29];
 492                                 case 28: sum += qlp_coeff[27] * data[i-28];
 493                                 case 27: sum += qlp_coeff[26] * data[i-27];
 494                                 case 26: sum += qlp_coeff[25] * data[i-26];
 495                                 case 25: sum += qlp_coeff[24] * data[i-25];
 496                                 case 24: sum += qlp_coeff[23] * data[i-24];
 497                                 case 23: sum += qlp_coeff[22] * data[i-23];
 498                                 case 22: sum += qlp_coeff[21] * data[i-22];
 499                                 case 21: sum += qlp_coeff[20] * data[i-21];
 500                                 case 20: sum += qlp_coeff[19] * data[i-20];
 501                                 case 19: sum += qlp_coeff[18] * data[i-19];
 502                                 case 18: sum += qlp_coeff[17] * data[i-18];
 503                                 case 17: sum += qlp_coeff[16] * data[i-17];
 504                                 case 16: sum += qlp_coeff[15] * data[i-16];
 505                                 case 15: sum += qlp_coeff[14] * data[i-15];
 506                                 case 14: sum += qlp_coeff[13] * data[i-14];
 507                                 case 13: sum += qlp_coeff[12] * data[i-13];
 508                                          sum += qlp_coeff[11] * data[i-12];
 509                                          sum += qlp_coeff[10] * data[i-11];
 510                                          sum += qlp_coeff[ 9] * data[i-10];
 511                                          sum += qlp_coeff[ 8] * data[i- 9];
 512                                          sum += qlp_coeff[ 7] * data[i- 8];
 513                                          sum += qlp_coeff[ 6] * data[i- 7];
 514                                          sum += qlp_coeff[ 5] * data[i- 6];
 515                                          sum += qlp_coeff[ 4] * data[i- 5];
 516                                          sum += qlp_coeff[ 3] * data[i- 4];
 517                                          sum += qlp_coeff[ 2] * data[i- 3];
 518                                          sum += qlp_coeff[ 1] * data[i- 2];
 519                                          sum += qlp_coeff[ 0] * data[i- 1];
 520                         }
 521                         residual[i] = data[i] - (sum >> lp_quantization);
 522                 }
 523         }
 524 }
 525 #endif
 526
 527 void FLAC__lpc_compute_residual_from_qlp_coefficients_wide(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[])
 528 #ifdef FLAC__OVERFLOW_DETECT /* this ugly flavor is only for debugging */
 529 {
 530         unsigned i, j;
 531         FLAC__int64 sum;
 532         const FLAC__int32 *history;
 533
 534 #ifdef FLAC__OVERFLOW_DETECT_VERBOSE
 535         fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients_wide: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
 536         for(i=0;i<order;i++)
 537                 fprintf(stderr,", q[%u]=%d",i,qlp_coeff[i]);
 538         fprintf(stderr,"\n");
 539 #endif
 540         FLAC__ASSERT(order > 0);
 541
 542         for(i = 0; i < data_len; i++) {
 543                 sum = 0;
 544                 history = data;
 545                 for(j = 0; j < order; j++)
 546                         sum += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*(--history));
 547                 if(FLAC__bitmath_silog2_wide(sum >> lp_quantization) > 32) {
 548 #if defined _MSC_VER
 549                         fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients_wide: OVERFLOW, i=%u, sum=%I64d\n", i, sum >> lp_quantization);
 550 #else
 551                         fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients_wide: OVERFLOW, i=%u, sum=%lld\n", i, (long long)(sum >> lp_quantization));
 552 #endif
 553                         break;
 554                 }
 555                 if(FLAC__bitmath_silog2_wide((FLAC__int64)(*data) - (sum >> lp_quantization)) > 32) {
 556 #if defined _MSC_VER
 557                         fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients_wide: OVERFLOW, i=%u, data=%d, sum=%I64d, residual=%I64d\n", i, *data, sum >> lp_quantization, (FLAC__int64)(*data) - (sum >> lp_quantization));
 558 #else
 559                         fprintf(stderr,"FLAC__lpc_compute_residual_from_qlp_coefficients_wide: OVERFLOW, i=%u, data=%d, sum=%lld, residual=%lld\n", i, *data, (long long)(sum >> lp_quantization), (long long)((FLAC__int64)(*data) - (sum >> lp_quantization)));
 560 #endif
 561                         break;
 562                 }
 563                 *(residual++) = *(data++) - (FLAC__int32)(sum >> lp_quantization);
 564         }
 565 }
 566 #else /* fully unrolled version for normal use */
 567 {
 568         unsigned i;
 569         FLAC__int64 sum;
 570
 571         FLAC__ASSERT(order > 0);
 572         FLAC__ASSERT(order <= 32);
 573
 574         /*
 575          * We do unique versions up to 12th order since that's the subset limit.
 576          * Also they are roughly ordered to match frequency of occurrence to
 577          * minimize branching.
 578          */
 579         if(order <= 12) {
 580                 if(order > 8) {
 581                         if(order > 10) {
 582                                 if(order == 12) {
 583                                         for(i = 0; i < data_len; i++) {
 584                                                 sum = 0;
 585                                                 sum += qlp_coeff[11] * (FLAC__int64)data[i-12];
 586                                                 sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
 587                                                 sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
 588                                                 sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
 589                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
 590                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
 591                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
 592                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
 593                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
 594                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 595                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 596                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 597                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 598                                         }
 599                                 }
 600                                 else { /* order == 11 */
 601                                         for(i = 0; i < data_len; i++) {
 602                                                 sum = 0;
 603                                                 sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
 604                                                 sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
 605                                                 sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
 606                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
 607                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
 608                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
 609                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
 610                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
 611                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 612                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 613                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 614                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 615                                         }
 616                                 }
 617                         }
 618                         else {
 619                                 if(order == 10) {
 620                                         for(i = 0; i < data_len; i++) {
 621                                                 sum = 0;
 622                                                 sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
 623                                                 sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
 624                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
 625                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
 626                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
 627                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
 628                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
 629                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 630                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 631                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 632                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 633                                         }
 634                                 }
 635                                 else { /* order == 9 */
 636                                         for(i = 0; i < data_len; i++) {
 637                                                 sum = 0;
 638                                                 sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
 639                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
 640                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
 641                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
 642                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
 643                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
 644                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 645                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 646                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 647                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 648                                         }
 649                                 }
 650                         }
 651                 }
 652                 else if(order > 4) {
 653                         if(order > 6) {
 654                                 if(order == 8) {
 655                                         for(i = 0; i < data_len; i++) {
 656                                                 sum = 0;
 657                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
 658                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
 659                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
 660                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
 661                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
 662                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 663                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 664                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 665                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 666                                         }
 667                                 }
 668                                 else { /* order == 7 */
 669                                         for(i = 0; i < data_len; i++) {
 670                                                 sum = 0;
 671                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
 672                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
 673                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
 674                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
 675                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 676                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 677                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 678                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 679                                         }
 680                                 }
 681                         }
 682                         else {
 683                                 if(order == 6) {
 684                                         for(i = 0; i < data_len; i++) {
 685                                                 sum = 0;
 686                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
 687                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
 688                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
 689                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 690                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 691                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 692                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 693                                         }
 694                                 }
 695                                 else { /* order == 5 */
 696                                         for(i = 0; i < data_len; i++) {
 697                                                 sum = 0;
 698                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
 699                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
 700                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 701                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 702                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 703                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 704                                         }
 705                                 }
 706                         }
 707                 }
 708                 else {
 709                         if(order > 2) {
 710                                 if(order == 4) {
 711                                         for(i = 0; i < data_len; i++) {
 712                                                 sum = 0;
 713                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
 714                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 715                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 716                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 717                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 718                                         }
 719                                 }
 720                                 else { /* order == 3 */
 721                                         for(i = 0; i < data_len; i++) {
 722                                                 sum = 0;
 723                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
 724                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 725                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 726                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 727                                         }
 728                                 }
 729                         }
 730                         else {
 731                                 if(order == 2) {
 732                                         for(i = 0; i < data_len; i++) {
 733                                                 sum = 0;
 734                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
 735                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
 736                                                 residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 737                                         }
 738                                 }
 739                                 else { /* order == 1 */
 740                                         for(i = 0; i < data_len; i++)
 741                                                 residual[i] = data[i] - (FLAC__int32)((qlp_coeff[0] * (FLAC__int64)data[i-1]) >> lp_quantization);
 742                                 }
 743                         }
 744                 }
 745         }
 746         else { /* order > 12 */
 747                 for(i = 0; i < data_len; i++) {
 748                         sum = 0;
 749                         switch(order) {
 750                                 case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32];
 751                                 case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31];
 752                                 case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30];
 753                                 case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29];
 754                                 case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28];
 755                                 case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27];
 756                                 case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26];
 757                                 case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25];
 758                                 case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24];
 759                                 case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23];
 760                                 case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22];
 761                                 case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21];
 762                                 case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20];
 763                                 case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19];
 764                                 case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18];
 765                                 case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17];
 766                                 case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16];
 767                                 case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15];
 768                                 case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14];
 769                                 case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13];
 770                                          sum += qlp_coeff[11] * (FLAC__int64)data[i-12];
 771                                          sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
 772                                          sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10];
 773                                          sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9];
 774                                          sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8];
 775                                          sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7];
 776                                          sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6];
 777                                          sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5];
 778                                          sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4];
 779                                          sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3];
 780                                          sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2];
 781                                          sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1];
 782                         }
 783                         residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
 784                 }
 785         }
 786 }
 787 #endif
 788
 789 #endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
 790
 791 void FLAC__lpc_restore_signal(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[])
 792 #ifdef FLAC__OVERFLOW_DETECT /* this ugly flavor is only for debugging */
 793 {
 794         FLAC__int64 sumo;
 795         unsigned i, j;
 796         FLAC__int32 sum;
 797         const FLAC__int32 *r = residual, *history;
 798
 799 #ifdef FLAC__OVERFLOW_DETECT_VERBOSE
 800         fprintf(stderr,"FLAC__lpc_restore_signal: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
 801         for(i=0;i<order;i++)
 802                 fprintf(stderr,", q[%u]=%d",i,qlp_coeff[i]);
 803         fprintf(stderr,"\n");
 804 #endif
 805         FLAC__ASSERT(order > 0);
 806
 807         for(i = 0; i < data_len; i++) {
 808                 sumo = 0;
 809                 sum = 0;
 810                 history = data;
 811                 for(j = 0; j < order; j++) {
 812                         sum += qlp_coeff[j] * (*(--history));
 813                         sumo += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*history);
 814 #if defined _MSC_VER
 815                         if(sumo > 2147483647I64 || sumo < -2147483648I64)
 816                                 fprintf(stderr,"FLAC__lpc_restore_signal: OVERFLOW, i=%u, j=%u, c=%d, d=%d, sumo=%I64d\n",i,j,qlp_coeff[j],*history,sumo);
 817 #else
 818                         if(sumo > 2147483647ll || sumo < -2147483648ll)
 819                                 fprintf(stderr,"FLAC__lpc_restore_signal: OVERFLOW, i=%u, j=%u, c=%d, d=%d, sumo=%lld\n",i,j,qlp_coeff[j],*history,(long long)sumo);
 820 #endif
 821                 }
 822                 *(data++) = *(r++) + (sum >> lp_quantization);
 823         }
 824
 825         /* Here's a slower but clearer version:
 826         for(i = 0; i < data_len; i++) {
 827                 sum = 0;
 828                 for(j = 0; j < order; j++)
 829                         sum += qlp_coeff[j] * data[i-j-1];
 830                 data[i] = residual[i] + (sum >> lp_quantization);
 831         }
 832         */
 833 }
 834 #else /* fully unrolled version for normal use */
 835 {
 836         unsigned i;
 837         FLAC__int32 sum;
 838
 839         FLAC__ASSERT(order > 0);
 840         FLAC__ASSERT(order <= 32);
 841
 842         /*
 843          * We do unique versions up to 12th order since that's the subset limit.
 844          * Also they are roughly ordered to match frequency of occurrence to
 845          * minimize branching.
 846          */
 847         if(order <= 12) {
 848                 if(order > 8) {
 849                         if(order > 10) {
 850                                 if(order == 12) {
 851                                         for(i = 0; i < data_len; i++) {
 852                                                 sum = 0;
 853                                                 sum += qlp_coeff[11] * data[i-12];
 854                                                 sum += qlp_coeff[10] * data[i-11];
 855                                                 sum += qlp_coeff[9] * data[i-10];
 856                                                 sum += qlp_coeff[8] * data[i-9];
 857                                                 sum += qlp_coeff[7] * data[i-8];
 858                                                 sum += qlp_coeff[6] * data[i-7];
 859                                                 sum += qlp_coeff[5] * data[i-6];
 860                                                 sum += qlp_coeff[4] * data[i-5];
 861                                                 sum += qlp_coeff[3] * data[i-4];
 862                                                 sum += qlp_coeff[2] * data[i-3];
 863                                                 sum += qlp_coeff[1] * data[i-2];
 864                                                 sum += qlp_coeff[0] * data[i-1];
 865                                                 data[i] = residual[i] + (sum >> lp_quantization);
 866                                         }
 867                                 }
 868                                 else { /* order == 11 */
 869                                         for(i = 0; i < data_len; i++) {
 870                                                 sum = 0;
 871                                                 sum += qlp_coeff[10] * data[i-11];
 872                                                 sum += qlp_coeff[9] * data[i-10];
 873                                                 sum += qlp_coeff[8] * data[i-9];
 874                                                 sum += qlp_coeff[7] * data[i-8];
 875                                                 sum += qlp_coeff[6] * data[i-7];
 876                                                 sum += qlp_coeff[5] * data[i-6];
 877                                                 sum += qlp_coeff[4] * data[i-5];
 878                                                 sum += qlp_coeff[3] * data[i-4];
 879                                                 sum += qlp_coeff[2] * data[i-3];
 880                                                 sum += qlp_coeff[1] * data[i-2];
 881                                                 sum += qlp_coeff[0] * data[i-1];
 882                                                 data[i] = residual[i] + (sum >> lp_quantization);
 883                                         }
 884                                 }
 885                         }
 886                         else {
 887                                 if(order == 10) {
 888                                         for(i = 0; i < data_len; i++) {
 889                                                 sum = 0;
 890                                                 sum += qlp_coeff[9] * data[i-10];
 891                                                 sum += qlp_coeff[8] * data[i-9];
 892                                                 sum += qlp_coeff[7] * data[i-8];
 893                                                 sum += qlp_coeff[6] * data[i-7];
 894                                                 sum += qlp_coeff[5] * data[i-6];
 895                                                 sum += qlp_coeff[4] * data[i-5];
 896                                                 sum += qlp_coeff[3] * data[i-4];
 897                                                 sum += qlp_coeff[2] * data[i-3];
 898                                                 sum += qlp_coeff[1] * data[i-2];
 899                                                 sum += qlp_coeff[0] * data[i-1];
 900                                                 data[i] = residual[i] + (sum >> lp_quantization);
 901                                         }
 902                                 }
 903                                 else { /* order == 9 */
 904                                         for(i = 0; i < data_len; i++) {
 905                                                 sum = 0;
 906                                                 sum += qlp_coeff[8] * data[i-9];
 907                                                 sum += qlp_coeff[7] * data[i-8];
 908                                                 sum += qlp_coeff[6] * data[i-7];
 909                                                 sum += qlp_coeff[5] * data[i-6];
 910                                                 sum += qlp_coeff[4] * data[i-5];
 911                                                 sum += qlp_coeff[3] * data[i-4];
 912                                                 sum += qlp_coeff[2] * data[i-3];
 913                                                 sum += qlp_coeff[1] * data[i-2];
 914                                                 sum += qlp_coeff[0] * data[i-1];
 915                                                 data[i] = residual[i] + (sum >> lp_quantization);
 916                                         }
 917                                 }
 918                         }
 919                 }
 920                 else if(order > 4) {
 921                         if(order > 6) {
 922                                 if(order == 8) {
 923                                         for(i = 0; i < data_len; i++) {
 924                                                 sum = 0;
 925                                                 sum += qlp_coeff[7] * data[i-8];
 926                                                 sum += qlp_coeff[6] * data[i-7];
 927                                                 sum += qlp_coeff[5] * data[i-6];
 928                                                 sum += qlp_coeff[4] * data[i-5];
 929                                                 sum += qlp_coeff[3] * data[i-4];
 930                                                 sum += qlp_coeff[2] * data[i-3];
 931                                                 sum += qlp_coeff[1] * data[i-2];
 932                                                 sum += qlp_coeff[0] * data[i-1];
 933                                                 data[i] = residual[i] + (sum >> lp_quantization);
 934                                         }
 935                                 }
 936                                 else { /* order == 7 */
 937                                         for(i = 0; i < data_len; i++) {
 938                                                 sum = 0;
 939                                                 sum += qlp_coeff[6] * data[i-7];
 940                                                 sum += qlp_coeff[5] * data[i-6];
 941                                                 sum += qlp_coeff[4] * data[i-5];
 942                                                 sum += qlp_coeff[3] * data[i-4];
 943                                                 sum += qlp_coeff[2] * data[i-3];
 944                                                 sum += qlp_coeff[1] * data[i-2];
 945                                                 sum += qlp_coeff[0] * data[i-1];
 946                                                 data[i] = residual[i] + (sum >> lp_quantization);
 947                                         }
 948                                 }
 949                         }
 950                         else {
 951                                 if(order == 6) {
 952                                         for(i = 0; i < data_len; i++) {
 953                                                 sum = 0;
 954                                                 sum += qlp_coeff[5] * data[i-6];
 955                                                 sum += qlp_coeff[4] * data[i-5];
 956                                                 sum += qlp_coeff[3] * data[i-4];
 957                                                 sum += qlp_coeff[2] * data[i-3];
 958                                                 sum += qlp_coeff[1] * data[i-2];
 959                                                 sum += qlp_coeff[0] * data[i-1];
 960                                                 data[i] = residual[i] + (sum >> lp_quantization);
 961                                         }
 962                                 }
 963                                 else { /* order == 5 */
 964                                         for(i = 0; i < data_len; i++) {
 965                                                 sum = 0;
 966                                                 sum += qlp_coeff[4] * data[i-5];
 967                                                 sum += qlp_coeff[3] * data[i-4];
 968                                                 sum += qlp_coeff[2] * data[i-3];
 969                                                 sum += qlp_coeff[1] * data[i-2];
 970                                                 sum += qlp_coeff[0] * data[i-1];
 971                                                 data[i] = residual[i] + (sum >> lp_quantization);
 972                                         }
 973                                 }
 974                         }
 975                 }
 976                 else {
 977                         if(order > 2) {
 978                                 if(order == 4) {
 979                                         for(i = 0; i < data_len; i++) {
 980                                                 sum = 0;
 981                                                 sum += qlp_coeff[3] * data[i-4];
 982                                                 sum += qlp_coeff[2] * data[i-3];
 983                                                 sum += qlp_coeff[1] * data[i-2];
 984                                                 sum += qlp_coeff[0] * data[i-1];
 985                                                 data[i] = residual[i] + (sum >> lp_quantization);
 986                                         }
 987                                 }
 988                                 else { /* order == 3 */
 989                                         for(i = 0; i < data_len; i++) {
 990                                                 sum = 0;
 991                                                 sum += qlp_coeff[2] * data[i-3];
 992                                                 sum += qlp_coeff[1] * data[i-2];
 993                                                 sum += qlp_coeff[0] * data[i-1];
 994                                                 data[i] = residual[i] + (sum >> lp_quantization);
 995                                         }
 996                                 }
 997                         }
 998                         else {
 999                                 if(order == 2) {
1000                                         for(i = 0; i < data_len; i++) {
1001                                                 sum = 0;
1002                                                 sum += qlp_coeff[1] * data[i-2];
1003                                                 sum += qlp_coeff[0] * data[i-1];
1004                                                 data[i] = residual[i] + (sum >> lp_quantization);
1005                                         }
1006                                 }
1007                                 else { /* order == 1 */
1008                                         for(i = 0; i < data_len; i++)
1009                                                 data[i] = residual[i] + ((qlp_coeff[0] * data[i-1]) >> lp_quantization);
1010                                 }
1011                         }
1012                 }
1013         }
1014         else { /* order > 12 */
1015                 for(i = 0; i < data_len; i++) {
1016                         sum = 0;
1017                         switch(order) {
1018                                 case 32: sum += qlp_coeff[31] * data[i-32];
1019                                 case 31: sum += qlp_coeff[30] * data[i-31];
1020                                 case 30: sum += qlp_coeff[29] * data[i-30];
1021                                 case 29: sum += qlp_coeff[28] * data[i-29];
1022                                 case 28: sum += qlp_coeff[27] * data[i-28];
1023                                 case 27: sum += qlp_coeff[26] * data[i-27];
1024                                 case 26: sum += qlp_coeff[25] * data[i-26];
1025                                 case 25: sum += qlp_coeff[24] * data[i-25];
1026                                 case 24: sum += qlp_coeff[23] * data[i-24];
1027                                 case 23: sum += qlp_coeff[22] * data[i-23];
1028                                 case 22: sum += qlp_coeff[21] * data[i-22];
1029                                 case 21: sum += qlp_coeff[20] * data[i-21];
1030                                 case 20: sum += qlp_coeff[19] * data[i-20];
1031                                 case 19: sum += qlp_coeff[18] * data[i-19];
1032                                 case 18: sum += qlp_coeff[17] * data[i-18];
1033                                 case 17: sum += qlp_coeff[16] * data[i-17];
1034                                 case 16: sum += qlp_coeff[15] * data[i-16];
1035                                 case 15: sum += qlp_coeff[14] * data[i-15];
1036                                 case 14: sum += qlp_coeff[13] * data[i-14];
1037                                 case 13: sum += qlp_coeff[12] * data[i-13];
1038                                          sum += qlp_coeff[11] * data[i-12];
1039                                          sum += qlp_coeff[10] * data[i-11];
1040                                          sum += qlp_coeff[ 9] * data[i-10];
1041                                          sum += qlp_coeff[ 8] * data[i- 9];
1042                                          sum += qlp_coeff[ 7] * data[i- 8];
1043                                          sum += qlp_coeff[ 6] * data[i- 7];
1044                                          sum += qlp_coeff[ 5] * data[i- 6];
1045                                          sum += qlp_coeff[ 4] * data[i- 5];
1046                                          sum += qlp_coeff[ 3] * data[i- 4];
1047                                          sum += qlp_coeff[ 2] * data[i- 3];
1048                                          sum += qlp_coeff[ 1] * data[i- 2];
1049                                          sum += qlp_coeff[ 0] * data[i- 1];
1050                         }
1051                         data[i] = residual[i] + (sum >> lp_quantization);
1052                 }
1053         }
1054 }
1055 #endif
1056
1057 void FLAC__lpc_restore_signal_wide(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[])
1058 #ifdef FLAC__OVERFLOW_DETECT /* this ugly flavor is only for debugging */
1059 {
1060         unsigned i, j;
1061         FLAC__int64 sum;
1062         const FLAC__int32 *r = residual, *history;
1063
1064 #ifdef FLAC__OVERFLOW_DETECT_VERBOSE
1065         fprintf(stderr,"FLAC__lpc_restore_signal_wide: data_len=%d, order=%u, lpq=%d",data_len,order,lp_quantization);
1066         for(i=0;i<order;i++)
1067                 fprintf(stderr,", q[%u]=%d",i,qlp_coeff[i]);
1068         fprintf(stderr,"\n");
1069 #endif
1070         FLAC__ASSERT(order > 0);
1071
1072         for(i = 0; i < data_len; i++) {
1073                 sum = 0;
1074                 history = data;
1075                 for(j = 0; j < order; j++)
1076                         sum += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*(--history));
1077                 if(FLAC__bitmath_silog2_wide(sum >> lp_quantization) > 32) {
1078 #ifdef _MSC_VER
1079                         fprintf(stderr,"FLAC__lpc_restore_signal_wide: OVERFLOW, i=%u, sum=%I64d\n", i, sum >> lp_quantization);
1080 #else
1081                         fprintf(stderr,"FLAC__lpc_restore_signal_wide: OVERFLOW, i=%u, sum=%lld\n", i, (long long)(sum >> lp_quantization));
1082 #endif
1083                         break;
1084                 }
1085                 if(FLAC__bitmath_silog2_wide((FLAC__int64)(*r) + (sum >> lp_quantization)) > 32) {
1086 #ifdef _MSC_VER
1087                         fprintf(stderr,"FLAC__lpc_restore_signal_wide: OVERFLOW, i=%u, residual=%d, sum=%I64d, data=%I64d\n", i, *r, sum >> lp_quantization, (FLAC__int64)(*r) + (sum >> lp_quantization));
1088 #else
1089                         fprintf(stderr,"FLAC__lpc_restore_signal_wide: OVERFLOW, i=%u, residual=%d, sum=%lld, data=%lld\n", i, *r, (long long)(sum >> lp_quantization), (long long)((FLAC__int64)(*r) + (sum >> lp_quantization)));
1090 #endif
1091                         break;
1092                 }
1093                 *(data++) = *(r++) + (FLAC__int32)(sum >> lp_quantization);
1094         }
1095 }
1096 #else /* fully unrolled version for normal use */
1097 {
1098         unsigned i;
1099         FLAC__int64 sum;
1100
1101         FLAC__ASSERT(order > 0);
1102         FLAC__ASSERT(order <= 32);
1103
1104         /*
1105          * We do unique versions up to 12th order since that's the subset limit.
1106          * Also they are roughly ordered to match frequency of occurrence to
1107          * minimize branching.
1108          */
1109         if(order <= 12) {
1110                 if(order > 8) {
1111                         if(order > 10) {
1112                                 if(order == 12) {
1113                                         for(i = 0; i < data_len; i++) {
1114                                                 sum = 0;
1115                                                 sum += qlp_coeff[11] * (FLAC__int64)data[i-12];
1116                                                 sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
1117                                                 sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
1118                                                 sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
1119                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
1120                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
1121                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
1122                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
1123                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
1124                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1125                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1126                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1127                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1128                                         }
1129                                 }
1130                                 else { /* order == 11 */
1131                                         for(i = 0; i < data_len; i++) {
1132                                                 sum = 0;
1133                                                 sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
1134                                                 sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
1135                                                 sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
1136                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
1137                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
1138                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
1139                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
1140                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
1141                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1142                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1143                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1144                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1145                                         }
1146                                 }
1147                         }
1148                         else {
1149                                 if(order == 10) {
1150                                         for(i = 0; i < data_len; i++) {
1151                                                 sum = 0;
1152                                                 sum += qlp_coeff[9] * (FLAC__int64)data[i-10];
1153                                                 sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
1154                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
1155                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
1156                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
1157                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
1158                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
1159                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1160                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1161                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1162                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1163                                         }
1164                                 }
1165                                 else { /* order == 9 */
1166                                         for(i = 0; i < data_len; i++) {
1167                                                 sum = 0;
1168                                                 sum += qlp_coeff[8] * (FLAC__int64)data[i-9];
1169                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
1170                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
1171                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
1172                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
1173                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
1174                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1175                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1176                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1177                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1178                                         }
1179                                 }
1180                         }
1181                 }
1182                 else if(order > 4) {
1183                         if(order > 6) {
1184                                 if(order == 8) {
1185                                         for(i = 0; i < data_len; i++) {
1186                                                 sum = 0;
1187                                                 sum += qlp_coeff[7] * (FLAC__int64)data[i-8];
1188                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
1189                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
1190                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
1191                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
1192                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1193                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1194                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1195                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1196                                         }
1197                                 }
1198                                 else { /* order == 7 */
1199                                         for(i = 0; i < data_len; i++) {
1200                                                 sum = 0;
1201                                                 sum += qlp_coeff[6] * (FLAC__int64)data[i-7];
1202                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
1203                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
1204                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
1205                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1206                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1207                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1208                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1209                                         }
1210                                 }
1211                         }
1212                         else {
1213                                 if(order == 6) {
1214                                         for(i = 0; i < data_len; i++) {
1215                                                 sum = 0;
1216                                                 sum += qlp_coeff[5] * (FLAC__int64)data[i-6];
1217                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
1218                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
1219                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1220                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1221                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1222                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1223                                         }
1224                                 }
1225                                 else { /* order == 5 */
1226                                         for(i = 0; i < data_len; i++) {
1227                                                 sum = 0;
1228                                                 sum += qlp_coeff[4] * (FLAC__int64)data[i-5];
1229                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
1230                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1231                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1232                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1233                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1234                                         }
1235                                 }
1236                         }
1237                 }
1238                 else {
1239                         if(order > 2) {
1240                                 if(order == 4) {
1241                                         for(i = 0; i < data_len; i++) {
1242                                                 sum = 0;
1243                                                 sum += qlp_coeff[3] * (FLAC__int64)data[i-4];
1244                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1245                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1246                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1247                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1248                                         }
1249                                 }
1250                                 else { /* order == 3 */
1251                                         for(i = 0; i < data_len; i++) {
1252                                                 sum = 0;
1253                                                 sum += qlp_coeff[2] * (FLAC__int64)data[i-3];
1254                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1255                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1256                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1257                                         }
1258                                 }
1259                         }
1260                         else {
1261                                 if(order == 2) {
1262                                         for(i = 0; i < data_len; i++) {
1263                                                 sum = 0;
1264                                                 sum += qlp_coeff[1] * (FLAC__int64)data[i-2];
1265                                                 sum += qlp_coeff[0] * (FLAC__int64)data[i-1];
1266                                                 data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1267                                         }
1268                                 }
1269                                 else { /* order == 1 */
1270                                         for(i = 0; i < data_len; i++)
1271                                                 data[i] = residual[i] + (FLAC__int32)((qlp_coeff[0] * (FLAC__int64)data[i-1]) >> lp_quantization);
1272                                 }
1273                         }
1274                 }
1275         }
1276         else { /* order > 12 */
1277                 for(i = 0; i < data_len; i++) {
1278                         sum = 0;
1279                         switch(order) {
1280                                 case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32];
1281                                 case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31];
1282                                 case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30];
1283                                 case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29];
1284                                 case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28];
1285                                 case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27];
1286                                 case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26];
1287                                 case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25];
1288                                 case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24];
1289                                 case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23];
1290                                 case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22];
1291                                 case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21];
1292                                 case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20];
1293                                 case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19];
1294                                 case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18];
1295                                 case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17];
1296                                 case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16];
1297                                 case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15];
1298                                 case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14];
1299                                 case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13];
1300                                          sum += qlp_coeff[11] * (FLAC__int64)data[i-12];
1301                                          sum += qlp_coeff[10] * (FLAC__int64)data[i-11];
1302                                          sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10];
1303                                          sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9];
1304                                          sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8];
1305                                          sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7];
1306                                          sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6];
1307                                          sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5];
1308                                          sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4];
1309                                          sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3];
1310                                          sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2];
1311                                          sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1];
1312                         }
1313                         data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1314                 }
1315         }
1316 }
1317 #endif
1318
1319 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1320
1321 FLAC__double FLAC__lpc_compute_expected_bits_per_residual_sample(FLAC__double lpc_error, unsigned total_samples)
1322 {
1323         FLAC__double error_scale;
1324
1325         FLAC__ASSERT(total_samples > 0);
1326
1327         error_scale = 0.5 * M_LN2 * M_LN2 / (FLAC__double)total_samples;
1328
1329         return FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error, error_scale);
1330 }
1331
1332 FLAC__double FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(FLAC__double lpc_error, FLAC__double error_scale)
1333 {
1334         if(lpc_error > 0.0) {
1335                 FLAC__double bps = (FLAC__double)0.5 * log(error_scale * lpc_error) / M_LN2;
1336                 if(bps >= 0.0)
1337                         return bps;
1338                 else
1339                         return 0.0;
1340         }
1341         else if(lpc_error < 0.0) { /* error should not be negative but can happen due to inadequate floating-point resolution */
1342                 return 1e32;
1343         }
1344         else {
1345                 return 0.0;
1346         }
1347 }
1348
1349 unsigned FLAC__lpc_compute_best_order(const FLAC__double lpc_error[], unsigned max_order, unsigned total_samples, unsigned overhead_bits_per_order)
1350 {
1351         unsigned order, index, best_index; /* 'index' the index into lpc_error; index==order-1 since lpc_error[0] is for order==1, lpc_error[1] is for order==2, etc */
1352         FLAC__double bits, best_bits, error_scale;
1353
1354         FLAC__ASSERT(max_order > 0);
1355         FLAC__ASSERT(total_samples > 0);
1356
1357         error_scale = 0.5 * M_LN2 * M_LN2 / (FLAC__double)total_samples;
1358
1359         best_index = 0;
1360         best_bits = (unsigned)(-1);
1361
1362         for(index = 0, order = 1; index < max_order; index++, order++) {
1363                 bits = FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error[index], error_scale) * (FLAC__double)(total_samples - order) + (FLAC__double)(order * overhead_bits_per_order);
1364                 if(bits < best_bits) {
1365                         best_index = index;
1366                         best_bits = bits;
1367                 }
1368         }
1369
1370         return best_index+1; /* +1 since index of lpc_error[] is order-1 */
1371 }
1372
1373 #endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */