src/third_party/webrtc/modules/audio_coding/codecs/isac/fix/source/entropy_coding.c

   1 /*
   2  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 /*
  12  * entropy_coding.c
  13  *
  14  * This file contains all functions used to arithmetically
  15  * encode the iSAC bistream.
  16  *
  17  */
  18
  19 #include <stddef.h>
  20
  21 #include "arith_routins.h"
  22 #include "spectrum_ar_model_tables.h"
  23 #include "pitch_gain_tables.h"
  24 #include "pitch_lag_tables.h"
  25 #include "entropy_coding.h"
  26 #include "lpc_tables.h"
  27 #include "settings.h"
  28 #include "signal_processing_library.h"
  29
  30 /*
  31  * Eenumerations for arguments to functions WebRtcIsacfix_MatrixProduct1()
  32  * and WebRtcIsacfix_MatrixProduct2().
  33 */
  34
  35 enum matrix_index_factor {
  36   kTIndexFactor1 = 1,
  37   kTIndexFactor2 = 2,
  38   kTIndexFactor3 = SUBFRAMES,
  39   kTIndexFactor4 = LPC_SHAPE_ORDER
  40 };
  41
  42 enum matrix_index_step {
  43   kTIndexStep1 = 1,
  44   kTIndexStep2 = SUBFRAMES,
  45   kTIndexStep3 = LPC_SHAPE_ORDER
  46 };
  47
  48 enum matrixprod_loop_count {
  49   kTLoopCount1 = SUBFRAMES,
  50   kTLoopCount2 = 2,
  51   kTLoopCount3 = LPC_SHAPE_ORDER
  52 };
  53
  54 enum matrix1_shift_value {
  55   kTMatrix1_shift0 = 0,
  56   kTMatrix1_shift1 = 1,
  57   kTMatrix1_shift5 = 5
  58 };
  59
  60 enum matrixprod_init_case {
  61   kTInitCase0 = 0,
  62   kTInitCase1 = 1
  63 };
  64
  65 /*
  66   This function implements the fix-point correspondant function to lrint.
  67
  68   FLP: (int32_t)floor(flt+.499999999999)
  69   FIP: (fixVal+roundVal)>>qDomain
  70
  71   where roundVal = 2^(qDomain-1) = 1<<(qDomain-1)
  72
  73 */
  74 static __inline int32_t CalcLrIntQ(int32_t fixVal, int16_t qDomain) {
  75   int32_t intgr;
  76   int32_t roundVal;
  77
  78   roundVal = WEBRTC_SPL_LSHIFT_W32((int32_t)1, qDomain-1);
  79   intgr = WEBRTC_SPL_RSHIFT_W32(fixVal+roundVal, qDomain);
  80
  81   return intgr;
  82 }
  83
  84 /*
  85   __inline uint32_t stepwise(int32_t dinQ10) {
  86
  87   int32_t ind, diQ10, dtQ10;
  88
  89   diQ10 = dinQ10;
  90   if (diQ10 < DPMIN_Q10)
  91   diQ10 = DPMIN_Q10;
  92   if (diQ10 >= DPMAX_Q10)
  93   diQ10 = DPMAX_Q10 - 1;
  94
  95   dtQ10 = diQ10 - DPMIN_Q10;*/ /* Q10 + Q10 = Q10 */
  96 /* ind = (dtQ10 * 5) >> 10;  */ /* 2^10 / 5 = 0.2 in Q10  */
  97 /* Q10 -> Q0 */
  98
  99 /* return rpointsFIX_Q10[ind];
 100
 101    }
 102 */
 103
 104 /* logN(x) = logN(2)*log2(x) = 0.6931*log2(x). Output in Q8. */
 105 /* The input argument X to logN(X) is 2^17 times higher than the
 106    input floating point argument Y to log(Y), since the X value
 107    is a Q17 value. This can be compensated for after the call, by
 108    subraction a value Z for each Q-step. One Q-step means that
 109    X gets 2 thimes higher, i.e. Z = logN(2)*256 = 0.693147180559*256 =
 110    177.445678 should be subtracted (since logN() returns a Q8 value).
 111    For a X value in Q17, the value 177.445678*17 = 3017 should be
 112    subtracted */
 113 static int16_t CalcLogN(int32_t arg) {
 114   int16_t zeros, log2, frac, logN;
 115
 116   zeros=WebRtcSpl_NormU32(arg);
 117   frac=(int16_t)WEBRTC_SPL_RSHIFT_U32(WEBRTC_SPL_LSHIFT_W32(arg, zeros)&0x7FFFFFFF, 23);
 118   log2=(int16_t)(WEBRTC_SPL_LSHIFT_W32(31-zeros, 8)+frac); // log2(x) in Q8
 119   logN=(int16_t)WEBRTC_SPL_MUL_16_16_RSFT(log2,22713,15); //Q8*Q15 log(2) = 0.693147 = 22713 in Q15
 120   logN=logN+11; //Scalar compensation which minimizes the (log(x)-logN(x))^2 error over all x.
 121
 122   return logN;
 123 }
 124
 125
 126 /*
 127   expN(x) = 2^(a*x), where a = log2(e) ~= 1.442695
 128
 129   Input:  Q8  (int16_t)
 130   Output: Q17 (int32_t)
 131
 132   a = log2(e) = log2(exp(1)) ~= 1.442695  ==>  a = 23637 in Q14 (1.442688)
 133   To this value, 700 is added or subtracted in order to get an average error
 134   nearer zero, instead of always same-sign.
 135 */
 136
 137 static int32_t CalcExpN(int16_t x) {
 138   int16_t ax, axINT, axFRAC;
 139   int16_t exp16;
 140   int32_t exp;
 141
 142   if (x>=0) {
 143     //  ax=(int16_t)WEBRTC_SPL_MUL_16_16_RSFT(x, 23637-700, 14); //Q8
 144     ax=(int16_t)WEBRTC_SPL_MUL_16_16_RSFT(x, 23637, 14); //Q8
 145     axINT = WEBRTC_SPL_RSHIFT_W16(ax, 8); //Q0
 146     axFRAC = ax&0x00FF;
 147     exp16 = WEBRTC_SPL_LSHIFT_W32(1, axINT); //Q0
 148     axFRAC = axFRAC+256; //Q8
 149     exp = WEBRTC_SPL_MUL_16_16(exp16, axFRAC); // Q0*Q8 = Q8
 150     exp = WEBRTC_SPL_LSHIFT_W32(exp, 9); //Q17
 151   } else {
 152     //  ax=(int16_t)WEBRTC_SPL_MUL_16_16_RSFT(x, 23637+700, 14); //Q8
 153     ax=(int16_t)WEBRTC_SPL_MUL_16_16_RSFT(x, 23637, 14); //Q8
 154     ax = -ax;
 155     axINT = 1 + WEBRTC_SPL_RSHIFT_W16(ax, 8); //Q0
 156     axFRAC = 0x00FF - (ax&0x00FF);
 157     exp16 = (int16_t) WEBRTC_SPL_RSHIFT_W32(32768, axINT); //Q15
 158     axFRAC = axFRAC+256; //Q8
 159     exp = WEBRTC_SPL_MUL_16_16(exp16, axFRAC); // Q15*Q8 = Q23
 160     exp = WEBRTC_SPL_RSHIFT_W32(exp, 6); //Q17
 161   }
 162
 163   return exp;
 164 }
 165
 166
 167 /* compute correlation from power spectrum */
 168 static void CalcCorrelation(int32_t *PSpecQ12, int32_t *CorrQ7)
 169 {
 170   int32_t summ[FRAMESAMPLES/8];
 171   int32_t diff[FRAMESAMPLES/8];
 172   int32_t sum;
 173   int k, n;
 174
 175   for (k = 0; k < FRAMESAMPLES/8; k++) {
 176     summ[k] = WEBRTC_SPL_RSHIFT_W32(PSpecQ12[k] + PSpecQ12[FRAMESAMPLES/4-1 - k] + 16, 5);
 177     diff[k] = WEBRTC_SPL_RSHIFT_W32(PSpecQ12[k] - PSpecQ12[FRAMESAMPLES/4-1 - k] + 16, 5);
 178   }
 179
 180   sum = 2;
 181   for (n = 0; n < FRAMESAMPLES/8; n++)
 182     sum += summ[n];
 183   CorrQ7[0] = sum;
 184
 185   for (k = 0; k < AR_ORDER; k += 2) {
 186     sum = 0;
 187     for (n = 0; n < FRAMESAMPLES/8; n++)
 188       sum += WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(WebRtcIsacfix_kCos[k][n], diff[n]) + 256, 9);
 189     CorrQ7[k+1] = sum;
 190   }
 191
 192   for (k=1; k<AR_ORDER; k+=2) {
 193     sum = 0;
 194     for (n = 0; n < FRAMESAMPLES/8; n++)
 195       sum += WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(WebRtcIsacfix_kCos[k][n], summ[n]) + 256, 9);
 196     CorrQ7[k+1] = sum;
 197   }
 198 }
 199
 200
 201 /* compute inverse AR power spectrum */
 202 static void CalcInvArSpec(const int16_t *ARCoefQ12,
 203                           const int32_t gainQ10,
 204                           int32_t *CurveQ16)
 205 {
 206   int32_t CorrQ11[AR_ORDER+1];
 207   int32_t sum, tmpGain;
 208   int32_t diffQ16[FRAMESAMPLES/8];
 209   const int16_t *CS_ptrQ9;
 210   int k, n;
 211   int16_t round, shftVal = 0, sh;
 212
 213   sum = 0;
 214   for (n = 0; n < AR_ORDER+1; n++)
 215     sum += WEBRTC_SPL_MUL(ARCoefQ12[n], ARCoefQ12[n]);    /* Q24 */
 216   sum = WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(WEBRTC_SPL_RSHIFT_W32(sum, 6), 65) + 32768, 16);    /* result in Q8 */
 217   CorrQ11[0] = WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(sum, gainQ10) + 256, 9);
 218
 219   /* To avoid overflow, we shift down gainQ10 if it is large. We will not lose any precision */
 220   if(gainQ10>400000){
 221     tmpGain = WEBRTC_SPL_RSHIFT_W32(gainQ10, 3);
 222     round = 32;
 223     shftVal = 6;
 224   } else {
 225     tmpGain = gainQ10;
 226     round = 256;
 227     shftVal = 9;
 228   }
 229
 230   for (k = 1; k < AR_ORDER+1; k++) {
 231     sum = 16384;
 232     for (n = k; n < AR_ORDER+1; n++)
 233       sum += WEBRTC_SPL_MUL(ARCoefQ12[n-k], ARCoefQ12[n]);  /* Q24 */
 234     sum = WEBRTC_SPL_RSHIFT_W32(sum, 15);
 235     CorrQ11[k] = WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(sum, tmpGain) + round, shftVal);
 236   }
 237   sum = WEBRTC_SPL_LSHIFT_W32(CorrQ11[0], 7);
 238   for (n = 0; n < FRAMESAMPLES/8; n++)
 239     CurveQ16[n] = sum;
 240
 241   for (k = 1; k < AR_ORDER; k += 2) {
 242     for (n = 0; n < FRAMESAMPLES/8; n++)
 243       CurveQ16[n] += WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(WebRtcIsacfix_kCos[k][n], CorrQ11[k+1]) + 2, 2);
 244   }
 245
 246   CS_ptrQ9 = WebRtcIsacfix_kCos[0];
 247
 248   /* If CorrQ11[1] too large we avoid getting overflow in the calculation by shifting */
 249   sh=WebRtcSpl_NormW32(CorrQ11[1]);
 250   if (CorrQ11[1]==0) /* Use next correlation */
 251     sh=WebRtcSpl_NormW32(CorrQ11[2]);
 252
 253   if (sh<9)
 254     shftVal = 9 - sh;
 255   else
 256     shftVal = 0;
 257
 258   for (n = 0; n < FRAMESAMPLES/8; n++)
 259     diffQ16[n] = WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(CS_ptrQ9[n], WEBRTC_SPL_RSHIFT_W32(CorrQ11[1], shftVal)) + 2, 2);
 260   for (k = 2; k < AR_ORDER; k += 2) {
 261     CS_ptrQ9 = WebRtcIsacfix_kCos[k];
 262     for (n = 0; n < FRAMESAMPLES/8; n++)
 263       diffQ16[n] += WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(CS_ptrQ9[n], WEBRTC_SPL_RSHIFT_W32(CorrQ11[k+1], shftVal)) + 2, 2);
 264   }
 265
 266   for (k=0; k<FRAMESAMPLES/8; k++) {
 267     CurveQ16[FRAMESAMPLES/4-1 - k] = CurveQ16[k] - WEBRTC_SPL_LSHIFT_W32(diffQ16[k], shftVal);
 268     CurveQ16[k] += WEBRTC_SPL_LSHIFT_W32(diffQ16[k], shftVal);
 269   }
 270 }
 271
 272 static void CalcRootInvArSpec(const int16_t *ARCoefQ12,
 273                               const int32_t gainQ10,
 274                               uint16_t *CurveQ8)
 275 {
 276   int32_t CorrQ11[AR_ORDER+1];
 277   int32_t sum, tmpGain;
 278   int32_t summQ16[FRAMESAMPLES/8];
 279   int32_t diffQ16[FRAMESAMPLES/8];
 280
 281   const int16_t *CS_ptrQ9;
 282   int k, n, i;
 283   int16_t round, shftVal = 0, sh;
 284   int32_t res, in_sqrt, newRes;
 285
 286   sum = 0;
 287   for (n = 0; n < AR_ORDER+1; n++)
 288     sum += WEBRTC_SPL_MUL(ARCoefQ12[n], ARCoefQ12[n]);    /* Q24 */
 289   sum = WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(WEBRTC_SPL_RSHIFT_W32(sum, 6), 65) + 32768, 16);    /* result in Q8 */
 290   CorrQ11[0] = WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(sum, gainQ10) + 256, 9);
 291
 292   /* To avoid overflow, we shift down gainQ10 if it is large. We will not lose any precision */
 293   if(gainQ10>400000){
 294     tmpGain = WEBRTC_SPL_RSHIFT_W32(gainQ10, 3);
 295     round = 32;
 296     shftVal = 6;
 297   } else {
 298     tmpGain = gainQ10;
 299     round = 256;
 300     shftVal = 9;
 301   }
 302
 303   for (k = 1; k < AR_ORDER+1; k++) {
 304     sum = 16384;
 305     for (n = k; n < AR_ORDER+1; n++)
 306       sum += WEBRTC_SPL_MUL(ARCoefQ12[n-k], ARCoefQ12[n]);  /* Q24 */
 307     sum = WEBRTC_SPL_RSHIFT_W32(sum, 15);
 308     CorrQ11[k] = WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(sum, tmpGain) + round, shftVal);
 309   }
 310   sum = WEBRTC_SPL_LSHIFT_W32(CorrQ11[0], 7);
 311   for (n = 0; n < FRAMESAMPLES/8; n++)
 312     summQ16[n] = sum;
 313
 314   for (k = 1; k < (AR_ORDER); k += 2) {
 315     for (n = 0; n < FRAMESAMPLES/8; n++)
 316       summQ16[n] += ((CorrQ11[k + 1] * WebRtcIsacfix_kCos[k][n]) + 2) >> 2;
 317   }
 318
 319   CS_ptrQ9 = WebRtcIsacfix_kCos[0];
 320
 321   /* If CorrQ11[1] too large we avoid getting overflow in the calculation by shifting */
 322   sh=WebRtcSpl_NormW32(CorrQ11[1]);
 323   if (CorrQ11[1]==0) /* Use next correlation */
 324     sh=WebRtcSpl_NormW32(CorrQ11[2]);
 325
 326   if (sh<9)
 327     shftVal = 9 - sh;
 328   else
 329     shftVal = 0;
 330
 331   for (n = 0; n < FRAMESAMPLES/8; n++)
 332     diffQ16[n] = WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(CS_ptrQ9[n], WEBRTC_SPL_RSHIFT_W32(CorrQ11[1], shftVal)) + 2, 2);
 333   for (k = 2; k < AR_ORDER; k += 2) {
 334     CS_ptrQ9 = WebRtcIsacfix_kCos[k];
 335     for (n = 0; n < FRAMESAMPLES/8; n++)
 336       diffQ16[n] += WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(CS_ptrQ9[n], WEBRTC_SPL_RSHIFT_W32(CorrQ11[k+1], shftVal)) + 2, 2);
 337   }
 338
 339   in_sqrt = summQ16[0] + WEBRTC_SPL_LSHIFT_W32(diffQ16[0], shftVal);
 340
 341   /* convert to magnitude spectrum, by doing square-roots (modified from SPLIB)  */
 342   res = WEBRTC_SPL_LSHIFT_W32(1, WEBRTC_SPL_RSHIFT_W16(WebRtcSpl_GetSizeInBits(in_sqrt), 1));
 343
 344   for (k = 0; k < FRAMESAMPLES/8; k++)
 345   {
 346     in_sqrt = summQ16[k] + WEBRTC_SPL_LSHIFT_W32(diffQ16[k], shftVal);
 347     i = 10;
 348
 349     /* make in_sqrt positive to prohibit sqrt of negative values */
 350     if(in_sqrt<0)
 351       in_sqrt=-in_sqrt;
 352
 353     newRes = (in_sqrt / res + res) >> 1;
 354     do
 355     {
 356       res = newRes;
 357       newRes = (in_sqrt / res + res) >> 1;
 358     } while (newRes != res && i-- > 0);
 359
 360     CurveQ8[k] = (int16_t)newRes;
 361   }
 362   for (k = FRAMESAMPLES/8; k < FRAMESAMPLES/4; k++) {
 363
 364     in_sqrt = summQ16[FRAMESAMPLES/4-1 - k] - WEBRTC_SPL_LSHIFT_W32(diffQ16[FRAMESAMPLES/4-1 - k], shftVal);
 365     i = 10;
 366
 367     /* make in_sqrt positive to prohibit sqrt of negative values */
 368     if(in_sqrt<0)
 369       in_sqrt=-in_sqrt;
 370
 371     newRes = (in_sqrt / res + res) >> 1;
 372     do
 373     {
 374       res = newRes;
 375       newRes = (in_sqrt / res + res) >> 1;
 376     } while (newRes != res && i-- > 0);
 377
 378     CurveQ8[k] = (int16_t)newRes;
 379   }
 380
 381 }
 382
 383
 384
 385 /* generate array of dither samples in Q7 */
 386 static void GenerateDitherQ7(int16_t *bufQ7,
 387                              uint32_t seed,
 388                              int16_t length,
 389                              int16_t AvgPitchGain_Q12)
 390 {
 391   int   k;
 392   int16_t dither1_Q7, dither2_Q7, dither_gain_Q14, shft;
 393
 394   if (AvgPitchGain_Q12 < 614)  /* this threshold should be equal to that in decode_spec() */
 395   {
 396     for (k = 0; k < length-2; k += 3)
 397     {
 398       /* new random unsigned int32_t */
 399       seed = WEBRTC_SPL_UMUL(seed, 196314165) + 907633515;
 400
 401       /* fixed-point dither sample between -64 and 64 (Q7) */
 402       dither1_Q7 = (int16_t)WEBRTC_SPL_RSHIFT_W32((int32_t)seed + 16777216, 25); // * 128/4294967295
 403
 404       /* new random unsigned int32_t */
 405       seed = WEBRTC_SPL_UMUL(seed, 196314165) + 907633515;
 406
 407       /* fixed-point dither sample between -64 and 64 */
 408       dither2_Q7 = (int16_t)WEBRTC_SPL_RSHIFT_W32(seed + 16777216, 25);
 409
 410       shft = (int16_t)(WEBRTC_SPL_RSHIFT_U32(seed, 25) & 15);
 411       if (shft < 5)
 412       {
 413         bufQ7[k]   = dither1_Q7;
 414         bufQ7[k+1] = dither2_Q7;
 415         bufQ7[k+2] = 0;
 416       }
 417       else if (shft < 10)
 418       {
 419         bufQ7[k]   = dither1_Q7;
 420         bufQ7[k+1] = 0;
 421         bufQ7[k+2] = dither2_Q7;
 422       }
 423       else
 424       {
 425         bufQ7[k]   = 0;
 426         bufQ7[k+1] = dither1_Q7;
 427         bufQ7[k+2] = dither2_Q7;
 428       }
 429     }
 430   }
 431   else
 432   {
 433     dither_gain_Q14 = (int16_t)(22528 - WEBRTC_SPL_MUL(10, AvgPitchGain_Q12));
 434
 435     /* dither on half of the coefficients */
 436     for (k = 0; k < length-1; k += 2)
 437     {
 438       /* new random unsigned int32_t */
 439       seed = WEBRTC_SPL_UMUL(seed, 196314165) + 907633515;
 440
 441       /* fixed-point dither sample between -64 and 64 */
 442       dither1_Q7 = (int16_t)WEBRTC_SPL_RSHIFT_W32((int32_t)seed + 16777216, 25);
 443
 444       /* dither sample is placed in either even or odd index */
 445       shft = (int16_t)(WEBRTC_SPL_RSHIFT_U32(seed, 25) & 1);     /* either 0 or 1 */
 446
 447       bufQ7[k + shft] = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(dither_gain_Q14, dither1_Q7) + 8192, 14);
 448       bufQ7[k + 1 - shft] = 0;
 449     }
 450   }
 451 }
 452
 453
 454
 455
 456 /*
 457  * function to decode the complex spectrum from the bitstream
 458  * returns the total number of bytes in the stream
 459  */
 460 int16_t WebRtcIsacfix_DecodeSpec(Bitstr_dec *streamdata,
 461                                  int16_t *frQ7,
 462                                  int16_t *fiQ7,
 463                                  int16_t AvgPitchGain_Q12)
 464 {
 465   int16_t  data[FRAMESAMPLES];
 466   int32_t  invARSpec2_Q16[FRAMESAMPLES/4];
 467   int16_t  ARCoefQ12[AR_ORDER+1];
 468   int16_t  RCQ15[AR_ORDER];
 469   int16_t  gainQ10;
 470   int32_t  gain2_Q10;
 471   int16_t  len;
 472   int          k;
 473
 474   /* create dither signal */
 475   GenerateDitherQ7(data, streamdata->W_upper, FRAMESAMPLES, AvgPitchGain_Q12); /* Dither is output in vector 'Data' */
 476
 477   /* decode model parameters */
 478   if (WebRtcIsacfix_DecodeRcCoef(streamdata, RCQ15) < 0)
 479     return -ISAC_RANGE_ERROR_DECODE_SPECTRUM;
 480
 481
 482   WebRtcSpl_ReflCoefToLpc(RCQ15, AR_ORDER, ARCoefQ12);
 483
 484   if (WebRtcIsacfix_DecodeGain2(streamdata, &gain2_Q10) < 0)
 485     return -ISAC_RANGE_ERROR_DECODE_SPECTRUM;
 486
 487   /* compute inverse AR power spectrum */
 488   CalcInvArSpec(ARCoefQ12, gain2_Q10, invARSpec2_Q16);
 489
 490   /* arithmetic decoding of spectrum */
 491   /* 'data' input and output. Input = Dither */
 492   len = WebRtcIsacfix_DecLogisticMulti2(data, streamdata, invARSpec2_Q16, (int16_t)FRAMESAMPLES);
 493
 494   if (len<1)
 495     return -ISAC_RANGE_ERROR_DECODE_SPECTRUM;
 496
 497   /* subtract dither and scale down spectral samples with low SNR */
 498   if (AvgPitchGain_Q12 <= 614)
 499   {
 500     for (k = 0; k < FRAMESAMPLES; k += 4)
 501     {
 502       gainQ10 = WebRtcSpl_DivW32W16ResW16(WEBRTC_SPL_LSHIFT_W32((int32_t)30, 10),
 503                                               (int16_t)WEBRTC_SPL_RSHIFT_U32(invARSpec2_Q16[k>>2] + (uint32_t)2195456, 16));
 504       *frQ7++ = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(data[ k ], gainQ10) + 512, 10);
 505       *fiQ7++ = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(data[k+1], gainQ10) + 512, 10);
 506       *frQ7++ = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(data[k+2], gainQ10) + 512, 10);
 507       *fiQ7++ = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(data[k+3], gainQ10) + 512, 10);
 508     }
 509   }
 510   else
 511   {
 512     for (k = 0; k < FRAMESAMPLES; k += 4)
 513     {
 514       gainQ10 = WebRtcSpl_DivW32W16ResW16(WEBRTC_SPL_LSHIFT_W32((int32_t)36, 10),
 515                                               (int16_t)WEBRTC_SPL_RSHIFT_U32(invARSpec2_Q16[k>>2] + (uint32_t)2654208, 16));
 516       *frQ7++ = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(data[ k ], gainQ10) + 512, 10);
 517       *fiQ7++ = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(data[k+1], gainQ10) + 512, 10);
 518       *frQ7++ = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(data[k+2], gainQ10) + 512, 10);
 519       *fiQ7++ = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(data[k+3], gainQ10) + 512, 10);
 520     }
 521   }
 522
 523   return len;
 524 }
 525
 526
 527 int WebRtcIsacfix_EncodeSpec(const int16_t *fr,
 528                              const int16_t *fi,
 529                              Bitstr_enc *streamdata,
 530                              int16_t AvgPitchGain_Q12)
 531 {
 532   int16_t  dataQ7[FRAMESAMPLES];
 533   int32_t  PSpec[FRAMESAMPLES/4];
 534   uint16_t invARSpecQ8[FRAMESAMPLES/4];
 535   int32_t  CorrQ7[AR_ORDER+1];
 536   int32_t  CorrQ7_norm[AR_ORDER+1];
 537   int16_t  RCQ15[AR_ORDER];
 538   int16_t  ARCoefQ12[AR_ORDER+1];
 539   int32_t  gain2_Q10;
 540   int16_t  val;
 541   int32_t  nrg;
 542   uint32_t sum;
 543   int16_t  lft_shft;
 544   int16_t  status;
 545   int          k, n, j;
 546
 547
 548   /* create dither_float signal */
 549   GenerateDitherQ7(dataQ7, streamdata->W_upper, FRAMESAMPLES, AvgPitchGain_Q12);
 550
 551   /* add dither and quantize, and compute power spectrum */
 552   /* Vector dataQ7 contains Dither in Q7 */
 553   for (k = 0; k < FRAMESAMPLES; k += 4)
 554   {
 555     val = ((*fr++ + dataQ7[k]   + 64) & 0xFF80) - dataQ7[k]; /* Data = Dither */
 556     dataQ7[k] = val;            /* New value in Data */
 557     sum = WEBRTC_SPL_UMUL(val, val);
 558
 559     val = ((*fi++ + dataQ7[k+1] + 64) & 0xFF80) - dataQ7[k+1]; /* Data = Dither */
 560     dataQ7[k+1] = val;            /* New value in Data */
 561     sum += WEBRTC_SPL_UMUL(val, val);
 562
 563     val = ((*fr++ + dataQ7[k+2] + 64) & 0xFF80) - dataQ7[k+2]; /* Data = Dither */
 564     dataQ7[k+2] = val;            /* New value in Data */
 565     sum += WEBRTC_SPL_UMUL(val, val);
 566
 567     val = ((*fi++ + dataQ7[k+3] + 64) & 0xFF80) - dataQ7[k+3]; /* Data = Dither */
 568     dataQ7[k+3] = val;            /* New value in Data */
 569     sum += WEBRTC_SPL_UMUL(val, val);
 570
 571     PSpec[k>>2] = WEBRTC_SPL_RSHIFT_U32(sum, 2);
 572   }
 573
 574   /* compute correlation from power spectrum */
 575   CalcCorrelation(PSpec, CorrQ7);
 576
 577
 578   /* find AR coefficients */
 579   /* number of bit shifts to 14-bit normalize CorrQ7[0] (leaving room for sign) */
 580   lft_shft = WebRtcSpl_NormW32(CorrQ7[0]) - 18;
 581
 582   if (lft_shft > 0) {
 583     for (k=0; k<AR_ORDER+1; k++)
 584       CorrQ7_norm[k] = WEBRTC_SPL_LSHIFT_W32(CorrQ7[k], lft_shft);
 585   } else {
 586     for (k=0; k<AR_ORDER+1; k++)
 587       CorrQ7_norm[k] = WEBRTC_SPL_RSHIFT_W32(CorrQ7[k], -lft_shft);
 588   }
 589
 590   /* find RC coefficients */
 591   WebRtcSpl_AutoCorrToReflCoef(CorrQ7_norm, AR_ORDER, RCQ15);
 592
 593   /* quantize & code RC Coef */
 594   status = WebRtcIsacfix_EncodeRcCoef(RCQ15, streamdata);
 595   if (status < 0) {
 596     return status;
 597   }
 598
 599   /* RC -> AR coefficients */
 600   WebRtcSpl_ReflCoefToLpc(RCQ15, AR_ORDER, ARCoefQ12);
 601
 602   /* compute ARCoef' * Corr * ARCoef in Q19 */
 603   nrg = 0;
 604   for (j = 0; j <= AR_ORDER; j++) {
 605     for (n = 0; n <= j; n++)
 606       nrg += WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(ARCoefQ12[j], WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(CorrQ7_norm[j-n], ARCoefQ12[n]) + 256, 9)) + 4, 3);
 607     for (n = j+1; n <= AR_ORDER; n++)
 608       nrg += WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(ARCoefQ12[j], WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(CorrQ7_norm[n-j], ARCoefQ12[n]) + 256, 9)) + 4, 3);
 609   }
 610
 611   if (lft_shft > 0)
 612     nrg = WEBRTC_SPL_RSHIFT_W32(nrg, lft_shft);
 613   else
 614     nrg = WEBRTC_SPL_LSHIFT_W32(nrg, -lft_shft);
 615
 616   if(nrg>131072)
 617     gain2_Q10 = WebRtcSpl_DivResultInQ31(FRAMESAMPLES >> 2, nrg);  /* also shifts 31 bits to the left! */
 618   else
 619     gain2_Q10 = WEBRTC_SPL_RSHIFT_W32(FRAMESAMPLES, 2);
 620
 621   /* quantize & code gain2_Q10 */
 622   if (WebRtcIsacfix_EncodeGain2(&gain2_Q10, streamdata))
 623     return -1;
 624
 625   /* compute inverse AR magnitude spectrum */
 626   CalcRootInvArSpec(ARCoefQ12, gain2_Q10, invARSpecQ8);
 627
 628
 629   /* arithmetic coding of spectrum */
 630   status = WebRtcIsacfix_EncLogisticMulti2(streamdata, dataQ7, invARSpecQ8, (int16_t)FRAMESAMPLES);
 631   if ( status )
 632     return( status );
 633
 634   return 0;
 635 }
 636
 637
 638 /* Matlab's LAR definition */
 639 static void Rc2LarFix(const int16_t *rcQ15, int32_t *larQ17, int16_t order) {
 640
 641   /*
 642
 643     This is a piece-wise implemenetation of a rc2lar-function (all values in the comment
 644     are Q15 values and  are based on [0 24956/32768 30000/32768 32500/32768], i.e.
 645     [0.76159667968750   0.91552734375000   0.99182128906250]
 646
 647     x0  x1           a                 k              x0(again)         b
 648     ==================================================================================
 649     0.00 0.76:   0                  2.625997508581   0                  0
 650     0.76 0.91:   2.000012018559     7.284502668663   0.761596679688    -3.547841027073
 651     0.91 0.99:   3.121320351712    31.115835041229   0.915527343750   -25.366077452148
 652     0.99 1.00:   5.495270168700   686.663805654056   0.991821289063  -675.552510708011
 653
 654     The implementation is y(x)= a + (x-x0)*k, but this can be simplified to
 655
 656     y(x) = a-x0*k + x*k = b + x*k, where b = a-x0*k
 657
 658     akx=[0                 2.625997508581   0
 659     2.000012018559     7.284502668663   0.761596679688
 660     3.121320351712    31.115835041229   0.915527343750
 661     5.495270168700   686.663805654056   0.991821289063];
 662
 663     b = akx(:,1) - akx(:,3).*akx(:,2)
 664
 665     [ 0.0
 666     -3.547841027073
 667     -25.366077452148
 668     -675.552510708011]
 669
 670   */
 671
 672   int k;
 673   int16_t rc;
 674   int32_t larAbsQ17;
 675
 676   for (k = 0; k < order; k++) {
 677
 678     rc = WEBRTC_SPL_ABS_W16(rcQ15[k]); //Q15
 679
 680     /* Calculate larAbsQ17 in Q17 from rc in Q15 */
 681
 682     if (rc<24956) {  //0.7615966 in Q15
 683       // (Q15*Q13)>>11 = Q17
 684       larAbsQ17 = WEBRTC_SPL_MUL_16_16_RSFT(rc, 21512, 11);
 685     } else if (rc<30000) { //0.91552734375 in Q15
 686       // Q17 + (Q15*Q12)>>10 = Q17
 687       larAbsQ17 = -465024 + WEBRTC_SPL_MUL_16_16_RSFT(rc, 29837, 10);
 688     } else if (rc<32500) { //0.99182128906250 in Q15
 689       // Q17 + (Q15*Q10)>>8 = Q17
 690       larAbsQ17 = -3324784 + WEBRTC_SPL_MUL_16_16_RSFT(rc, 31863, 8);
 691     } else  {
 692       // Q17 + (Q15*Q5)>>3 = Q17
 693       larAbsQ17 = -88546020 + WEBRTC_SPL_MUL_16_16_RSFT(rc, 21973, 3);
 694     }
 695
 696     if (rcQ15[k]>0) {
 697       larQ17[k] = larAbsQ17;
 698     } else {
 699       larQ17[k] = -larAbsQ17;
 700     }
 701   }
 702 }
 703
 704
 705 static void Lar2RcFix(const int32_t *larQ17, int16_t *rcQ15,  int16_t order) {
 706
 707   /*
 708     This is a piece-wise implemenetation of a lar2rc-function
 709     See comment in Rc2LarFix() about details.
 710   */
 711
 712   int k;
 713   int16_t larAbsQ11;
 714   int32_t rc;
 715
 716   for (k = 0; k < order; k++) {
 717
 718     larAbsQ11 = (int16_t) WEBRTC_SPL_ABS_W32(WEBRTC_SPL_RSHIFT_W32(larQ17[k]+32,6)); //Q11
 719
 720     if (larAbsQ11<4097) { //2.000012018559 in Q11
 721       // Q11*Q16>>12 = Q15
 722       rc = WEBRTC_SPL_MUL_16_16_RSFT(larAbsQ11, 24957, 12);
 723     } else if (larAbsQ11<6393) { //3.121320351712 in Q11
 724       // (Q11*Q17 + Q13)>>13 = Q15
 725       rc = WEBRTC_SPL_RSHIFT_W32((WEBRTC_SPL_MUL_16_16(larAbsQ11, 17993) + 130738688), 13);
 726     } else if (larAbsQ11<11255) { //5.495270168700 in Q11
 727       // (Q11*Q19 + Q30)>>15 = Q15
 728       rc = WEBRTC_SPL_RSHIFT_W32((WEBRTC_SPL_MUL_16_16(larAbsQ11, 16850) + 875329820), 15);
 729     } else  {
 730       // (Q11*Q24>>16 + Q19)>>4 = Q15
 731       rc = WEBRTC_SPL_RSHIFT_W32(((WEBRTC_SPL_MUL_16_16_RSFT(larAbsQ11, 24433, 16)) + 515804), 4);
 732     }
 733
 734     if (larQ17[k]<=0) {
 735       rc = -rc;
 736     }
 737
 738     rcQ15[k] = (int16_t) rc;  // Q15
 739   }
 740 }
 741
 742 static void Poly2LarFix(int16_t *lowbandQ15,
 743                         int16_t orderLo,
 744                         int16_t *hibandQ15,
 745                         int16_t orderHi,
 746                         int16_t Nsub,
 747                         int32_t *larsQ17) {
 748
 749   int k, n;
 750   int32_t *outpQ17;
 751   int16_t orderTot;
 752   int32_t larQ17[MAX_ORDER];   // Size 7+6 is enough
 753
 754   orderTot = (orderLo + orderHi);
 755   outpQ17 = larsQ17;
 756   for (k = 0; k < Nsub; k++) {
 757
 758     Rc2LarFix(lowbandQ15, larQ17, orderLo);
 759
 760     for (n = 0; n < orderLo; n++)
 761       outpQ17[n] = larQ17[n]; //Q17
 762
 763     Rc2LarFix(hibandQ15, larQ17, orderHi);
 764
 765     for (n = 0; n < orderHi; n++)
 766       outpQ17[n + orderLo] = larQ17[n]; //Q17;
 767
 768     outpQ17 += orderTot;
 769     lowbandQ15 += orderLo;
 770     hibandQ15 += orderHi;
 771   }
 772 }
 773
 774
 775 static void Lar2polyFix(int32_t *larsQ17,
 776                         int16_t *lowbandQ15,
 777                         int16_t orderLo,
 778                         int16_t *hibandQ15,
 779                         int16_t orderHi,
 780                         int16_t Nsub) {
 781
 782   int k, n;
 783   int16_t orderTot;
 784   int16_t *outplQ15, *outphQ15;
 785   int32_t *inpQ17;
 786   int16_t rcQ15[7+6];
 787
 788   orderTot = (orderLo + orderHi);
 789   outplQ15 = lowbandQ15;
 790   outphQ15 = hibandQ15;
 791   inpQ17 = larsQ17;
 792   for (k = 0; k < Nsub; k++) {
 793
 794     /* gains not handled here as in the FLP version */
 795
 796     /* Low band */
 797     Lar2RcFix(&inpQ17[0], rcQ15, orderLo);
 798     for (n = 0; n < orderLo; n++)
 799       outplQ15[n] = rcQ15[n]; // Refl. coeffs
 800
 801     /* High band */
 802     Lar2RcFix(&inpQ17[orderLo], rcQ15, orderHi);
 803     for (n = 0; n < orderHi; n++)
 804       outphQ15[n] = rcQ15[n]; // Refl. coeffs
 805
 806     inpQ17 += orderTot;
 807     outplQ15 += orderLo;
 808     outphQ15 += orderHi;
 809   }
 810 }
 811
 812 /*
 813 Function WebRtcIsacfix_MatrixProduct1C() does one form of matrix multiplication.
 814 It first shifts input data of one matrix, determines the right indexes for the
 815 two matrixes, multiply them, and write the results into an output buffer.
 816
 817 Note that two factors (or, multipliers) determine the initialization values of
 818 the variable |matrix1_index| in the code. The relationship is
 819 |matrix1_index| = |matrix1_index_factor1| * |matrix1_index_factor2|, where
 820 |matrix1_index_factor1| is given by the argument while |matrix1_index_factor2|
 821 is determined by the value of argument |matrix1_index_init_case|;
 822 |matrix1_index_factor2| is the value of the outmost loop counter j (when
 823 |matrix1_index_init_case| is 0), or the value of the middle loop counter k (when
 824 |matrix1_index_init_case| is non-zero).
 825
 826 |matrix0_index| is determined the same way.
 827
 828 Arguments:
 829   matrix0[]:                 matrix0 data in Q15 domain.
 830   matrix1[]:                 matrix1 data.
 831   matrix_product[]:          output data (matrix product).
 832   matrix1_index_factor1:     The first of two factors determining the
 833                              initialization value of matrix1_index.
 834   matrix0_index_factor1:     The first of two factors determining the
 835                              initialization value of matrix0_index.
 836   matrix1_index_init_case:   Case number for selecting the second of two
 837                              factors determining the initialization value
 838                              of matrix1_index and matrix0_index.
 839   matrix1_index_step:        Incremental step for matrix1_index.
 840   matrix0_index_step:        Incremental step for matrix0_index.
 841   inner_loop_count:          Maximum count of the inner loop.
 842   mid_loop_count:            Maximum count of the intermediate loop.
 843   shift:                     Left shift value for matrix1.
 844 */
 845 void WebRtcIsacfix_MatrixProduct1C(const int16_t matrix0[],
 846                                    const int32_t matrix1[],
 847                                    int32_t matrix_product[],
 848                                    const int matrix1_index_factor1,
 849                                    const int matrix0_index_factor1,
 850                                    const int matrix1_index_init_case,
 851                                    const int matrix1_index_step,
 852                                    const int matrix0_index_step,
 853                                    const int inner_loop_count,
 854                                    const int mid_loop_count,
 855                                    const int shift) {
 856   int j = 0, k = 0, n = 0;
 857   int matrix0_index = 0, matrix1_index = 0, matrix_prod_index = 0;
 858   int* matrix0_index_factor2 = &k;
 859   int* matrix1_index_factor2 = &j;
 860   if (matrix1_index_init_case != 0) {
 861     matrix0_index_factor2 = &j;
 862     matrix1_index_factor2 = &k;
 863   }
 864
 865   for (j = 0; j < SUBFRAMES; j++) {
 866     matrix_prod_index = mid_loop_count * j;
 867     for (k = 0; k < mid_loop_count; k++) {
 868       int32_t sum32 = 0;
 869       matrix0_index = matrix0_index_factor1 * (*matrix0_index_factor2);
 870       matrix1_index = matrix1_index_factor1 * (*matrix1_index_factor2);
 871       for (n = 0; n < inner_loop_count; n++) {
 872         sum32 += (WEBRTC_SPL_MUL_16_32_RSFT16(matrix0[matrix0_index],
 873                                               matrix1[matrix1_index] << shift));
 874         matrix0_index += matrix0_index_step;
 875         matrix1_index += matrix1_index_step;
 876       }
 877       matrix_product[matrix_prod_index] = sum32;
 878       matrix_prod_index++;
 879     }
 880   }
 881 }
 882
 883 /*
 884 Function WebRtcIsacfix_MatrixProduct2C() returns the product of two matrixes,
 885 one of which has two columns. It first has to determine the correct index of
 886 the first matrix before doing the actual element multiplication.
 887
 888 Arguments:
 889   matrix0[]:                 A matrix in Q15 domain.
 890   matrix1[]:                 A matrix in Q21 domain.
 891   matrix_product[]:          Output data in Q17 domain.
 892   matrix0_index_factor:      A factor determining the initialization value
 893                              of matrix0_index.
 894   matrix0_index_step:        Incremental step for matrix0_index.
 895 */
 896 void WebRtcIsacfix_MatrixProduct2C(const int16_t matrix0[],
 897                                    const int32_t matrix1[],
 898                                    int32_t matrix_product[],
 899                                    const int matrix0_index_factor,
 900                                    const int matrix0_index_step) {
 901   int j = 0, n = 0;
 902   int matrix1_index = 0, matrix0_index = 0, matrix_prod_index = 0;
 903   for (j = 0; j < SUBFRAMES; j++) {
 904     int32_t sum32 = 0, sum32_2 = 0;
 905     matrix1_index = 0;
 906     matrix0_index = matrix0_index_factor * j;
 907     for (n = SUBFRAMES; n > 0; n--) {
 908       sum32 += (WEBRTC_SPL_MUL_16_32_RSFT16(matrix0[matrix0_index],
 909                                             matrix1[matrix1_index]));
 910       sum32_2 += (WEBRTC_SPL_MUL_16_32_RSFT16(matrix0[matrix0_index],
 911                                             matrix1[matrix1_index + 1]));
 912       matrix1_index += 2;
 913       matrix0_index += matrix0_index_step;
 914     }
 915     matrix_product[matrix_prod_index] = sum32 >> 3;
 916     matrix_product[matrix_prod_index + 1] = sum32_2 >> 3;
 917     matrix_prod_index += 2;
 918   }
 919 }
 920
 921 int WebRtcIsacfix_DecodeLpc(int32_t *gain_lo_hiQ17,
 922                             int16_t *LPCCoef_loQ15,
 923                             int16_t *LPCCoef_hiQ15,
 924                             Bitstr_dec *streamdata,
 925                             int16_t *outmodel) {
 926
 927   int32_t larsQ17[KLT_ORDER_SHAPE]; // KLT_ORDER_GAIN+KLT_ORDER_SHAPE == (ORDERLO+ORDERHI)*SUBFRAMES
 928   int err;
 929
 930   err = WebRtcIsacfix_DecodeLpcCoef(streamdata, larsQ17, gain_lo_hiQ17, outmodel);
 931   if (err<0)  // error check
 932     return -ISAC_RANGE_ERROR_DECODE_LPC;
 933
 934   Lar2polyFix(larsQ17, LPCCoef_loQ15, ORDERLO, LPCCoef_hiQ15, ORDERHI, SUBFRAMES);
 935
 936   return 0;
 937 }
 938
 939 /* decode & dequantize LPC Coef */
 940 int WebRtcIsacfix_DecodeLpcCoef(Bitstr_dec *streamdata,
 941                                 int32_t *LPCCoefQ17,
 942                                 int32_t *gain_lo_hiQ17,
 943                                 int16_t *outmodel)
 944 {
 945   int j, k, n;
 946   int err;
 947   int16_t pos, pos2, posg, poss;
 948   int16_t gainpos;
 949   int16_t model;
 950   int16_t index_QQ[KLT_ORDER_SHAPE];
 951   int32_t tmpcoeffs_gQ17[KLT_ORDER_GAIN];
 952   int32_t tmpcoeffs2_gQ21[KLT_ORDER_GAIN];
 953   int16_t tmpcoeffs_sQ10[KLT_ORDER_SHAPE];
 954   int32_t tmpcoeffs_sQ17[KLT_ORDER_SHAPE];
 955   int32_t tmpcoeffs2_sQ18[KLT_ORDER_SHAPE];
 956   int32_t sumQQ;
 957   int16_t sumQQ16;
 958   int32_t tmp32;
 959
 960
 961
 962   /* entropy decoding of model number */
 963   err = WebRtcIsacfix_DecHistOneStepMulti(&model, streamdata, WebRtcIsacfix_kModelCdfPtr, WebRtcIsacfix_kModelInitIndex, 1);
 964   if (err<0)  // error check
 965     return err;
 966
 967   /* entropy decoding of quantization indices */
 968   err = WebRtcIsacfix_DecHistOneStepMulti(index_QQ, streamdata, WebRtcIsacfix_kCdfShapePtr[model], WebRtcIsacfix_kInitIndexShape[model], KLT_ORDER_SHAPE);
 969   if (err<0)  // error check
 970     return err;
 971   /* find quantization levels for coefficients */
 972   for (k=0; k<KLT_ORDER_SHAPE; k++) {
 973     tmpcoeffs_sQ10[WebRtcIsacfix_kSelIndShape[k]] = WebRtcIsacfix_kLevelsShapeQ10[WebRtcIsacfix_kOfLevelsShape[model]+WebRtcIsacfix_kOffsetShape[model][k] + index_QQ[k]];
 974   }
 975
 976   err = WebRtcIsacfix_DecHistOneStepMulti(index_QQ, streamdata, WebRtcIsacfix_kCdfGainPtr[model], WebRtcIsacfix_kInitIndexGain[model], KLT_ORDER_GAIN);
 977   if (err<0)  // error check
 978     return err;
 979   /* find quantization levels for coefficients */
 980   for (k=0; k<KLT_ORDER_GAIN; k++) {
 981     tmpcoeffs_gQ17[WebRtcIsacfix_kSelIndGain[k]] = WebRtcIsacfix_kLevelsGainQ17[WebRtcIsacfix_kOfLevelsGain[model]+ WebRtcIsacfix_kOffsetGain[model][k] + index_QQ[k]];
 982   }
 983
 984
 985   /* inverse KLT  */
 986
 987   /* left transform */  // Transpose matrix!
 988   WebRtcIsacfix_MatrixProduct1(WebRtcIsacfix_kT1GainQ15[model], tmpcoeffs_gQ17,
 989                                tmpcoeffs2_gQ21, kTIndexFactor2, kTIndexFactor2,
 990                                kTInitCase0, kTIndexStep1, kTIndexStep1,
 991                                kTLoopCount2, kTLoopCount2, kTMatrix1_shift5);
 992
 993   poss = 0;
 994   for (j=0; j<SUBFRAMES; j++) {
 995     for (k=0; k<LPC_SHAPE_ORDER; k++) {
 996       sumQQ = 0;
 997       pos = LPC_SHAPE_ORDER * j;
 998       pos2 = LPC_SHAPE_ORDER * k;
 999       for (n=0; n<LPC_SHAPE_ORDER; n++) {
1000         sumQQ += WEBRTC_SPL_MUL_16_16_RSFT(tmpcoeffs_sQ10[pos], WebRtcIsacfix_kT1ShapeQ15[model][pos2], 7); // (Q10*Q15)>>7 = Q18
1001         pos++;
1002         pos2++;
1003       }
1004       tmpcoeffs2_sQ18[poss] = sumQQ; //Q18
1005       poss++;
1006     }
1007   }
1008
1009   /* right transform */ // Transpose matrix
1010   WebRtcIsacfix_MatrixProduct2(WebRtcIsacfix_kT2GainQ15[0], tmpcoeffs2_gQ21,
1011                                tmpcoeffs_gQ17, kTIndexFactor1, kTIndexStep2);
1012   WebRtcIsacfix_MatrixProduct1(WebRtcIsacfix_kT2ShapeQ15[model],
1013       tmpcoeffs2_sQ18, tmpcoeffs_sQ17, kTIndexFactor1, kTIndexFactor1,
1014       kTInitCase1, kTIndexStep3, kTIndexStep2, kTLoopCount1, kTLoopCount3,
1015       kTMatrix1_shift0);
1016
1017   /* scaling, mean addition, and gain restoration */
1018   gainpos = 0;
1019   posg = 0;poss = 0;pos=0;
1020   for (k=0; k<SUBFRAMES; k++) {
1021
1022     /* log gains */
1023     sumQQ16 = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmpcoeffs_gQ17[posg], 2+9); //Divide by 4 and get Q17 to Q8, i.e. shift 2+9
1024     sumQQ16 += WebRtcIsacfix_kMeansGainQ8[model][posg];
1025     sumQQ = CalcExpN(sumQQ16); // Q8 in and Q17 out
1026     gain_lo_hiQ17[gainpos] = sumQQ; //Q17
1027     gainpos++;
1028     posg++;
1029
1030     sumQQ16 = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmpcoeffs_gQ17[posg], 2+9); //Divide by 4 and get Q17 to Q8, i.e. shift 2+9
1031     sumQQ16 += WebRtcIsacfix_kMeansGainQ8[model][posg];
1032     sumQQ = CalcExpN(sumQQ16); // Q8 in and Q17 out
1033     gain_lo_hiQ17[gainpos] = sumQQ; //Q17
1034     gainpos++;
1035     posg++;
1036
1037     /* lo band LAR coeffs */
1038     for (n=0; n<ORDERLO; n++, pos++, poss++) {
1039       tmp32 = WEBRTC_SPL_MUL_16_32_RSFT16(31208, tmpcoeffs_sQ17[poss]); // (Q16*Q17)>>16 = Q17, with 1/2.1 = 0.47619047619 ~= 31208 in Q16
1040       tmp32 = tmp32 + WebRtcIsacfix_kMeansShapeQ17[model][poss]; // Q17+Q17 = Q17
1041       LPCCoefQ17[pos] = tmp32;
1042     }
1043
1044     /* hi band LAR coeffs */
1045     for (n=0; n<ORDERHI; n++, pos++, poss++) {
1046       tmp32 = WEBRTC_SPL_LSHIFT_W32(WEBRTC_SPL_MUL_16_32_RSFT16(18204, tmpcoeffs_sQ17[poss]), 3); // ((Q13*Q17)>>16)<<3 = Q17, with 1/0.45 = 2.222222222222 ~= 18204 in Q13
1047       tmp32 = tmp32 + WebRtcIsacfix_kMeansShapeQ17[model][poss]; // Q17+Q17 = Q17
1048       LPCCoefQ17[pos] = tmp32;
1049     }
1050   }
1051
1052
1053   *outmodel=model;
1054
1055   return 0;
1056 }
1057
1058 /* estimate codel length of LPC Coef */
1059 static int EstCodeLpcCoef(int32_t *LPCCoefQ17,
1060                           int32_t *gain_lo_hiQ17,
1061                           int16_t *model,
1062                           int32_t *sizeQ11,
1063                           Bitstr_enc *streamdata,
1064                           ISAC_SaveEncData_t* encData,
1065                           transcode_obj *transcodingParam) {
1066   int j, k, n;
1067   int16_t posQQ, pos2QQ, gainpos;
1068   int16_t  pos, poss, posg, offsg;
1069   int16_t index_gQQ[KLT_ORDER_GAIN], index_sQQ[KLT_ORDER_SHAPE];
1070   int16_t index_ovr_gQQ[KLT_ORDER_GAIN], index_ovr_sQQ[KLT_ORDER_SHAPE];
1071   int32_t BitsQQ;
1072
1073   int16_t tmpcoeffs_gQ6[KLT_ORDER_GAIN];
1074   int32_t tmpcoeffs_gQ17[KLT_ORDER_GAIN];
1075   int32_t tmpcoeffs_sQ17[KLT_ORDER_SHAPE];
1076   int32_t tmpcoeffs2_gQ21[KLT_ORDER_GAIN];
1077   int32_t tmpcoeffs2_sQ17[KLT_ORDER_SHAPE];
1078   int32_t sumQQ;
1079   int32_t tmp32;
1080   int16_t sumQQ16;
1081   int status = 0;
1082
1083   /* write LAR coefficients to statistics file */
1084   /* Save data for creation of multiple bitstreams (and transcoding) */
1085   if (encData != NULL) {
1086     for (k=0; k<KLT_ORDER_GAIN; k++) {
1087       encData->LPCcoeffs_g[KLT_ORDER_GAIN*encData->startIdx + k] = gain_lo_hiQ17[k];
1088     }
1089   }
1090
1091   /* log gains, mean removal and scaling */
1092   posg = 0;poss = 0;pos=0; gainpos=0;
1093
1094   for (k=0; k<SUBFRAMES; k++) {
1095     /* log gains */
1096
1097     /* The input argument X to logN(X) is 2^17 times higher than the
1098        input floating point argument Y to log(Y), since the X value
1099        is a Q17 value. This can be compensated for after the call, by
1100        subraction a value Z for each Q-step. One Q-step means that
1101        X gets 2 times higher, i.e. Z = logN(2)*256 = 0.693147180559*256 =
1102        177.445678 should be subtracted (since logN() returns a Q8 value).
1103        For a X value in Q17, the value 177.445678*17 = 3017 should be
1104        subtracted */
1105     tmpcoeffs_gQ6[posg] = CalcLogN(gain_lo_hiQ17[gainpos])-3017; //Q8
1106     tmpcoeffs_gQ6[posg] -= WebRtcIsacfix_kMeansGainQ8[0][posg]; //Q8, but Q6 after not-needed mult. by 4
1107     posg++; gainpos++;
1108
1109     tmpcoeffs_gQ6[posg] = CalcLogN(gain_lo_hiQ17[gainpos])-3017; //Q8
1110     tmpcoeffs_gQ6[posg] -= WebRtcIsacfix_kMeansGainQ8[0][posg]; //Q8, but Q6 after not-needed mult. by 4
1111     posg++; gainpos++;
1112
1113     /* lo band LAR coeffs */
1114     for (n=0; n<ORDERLO; n++, poss++, pos++) {
1115       tmp32 = LPCCoefQ17[pos] - WebRtcIsacfix_kMeansShapeQ17[0][poss]; //Q17
1116       tmp32 = WEBRTC_SPL_MUL_16_32_RSFT16(17203, tmp32<<3); // tmp32 = 2.1*tmp32
1117       tmpcoeffs_sQ17[poss] = tmp32; //Q17
1118     }
1119
1120     /* hi band LAR coeffs */
1121     for (n=0; n<ORDERHI; n++, poss++, pos++) {
1122       tmp32 = LPCCoefQ17[pos] - WebRtcIsacfix_kMeansShapeQ17[0][poss]; //Q17
1123       tmp32 = WEBRTC_SPL_MUL_16_32_RSFT16(14746, tmp32<<1); // tmp32 = 0.45*tmp32
1124       tmpcoeffs_sQ17[poss] = tmp32; //Q17
1125     }
1126
1127   }
1128
1129
1130   /* KLT  */
1131
1132   /* left transform */
1133   offsg = 0;
1134   posg = 0;
1135   for (j=0; j<SUBFRAMES; j++) {
1136     // Q21 = Q6 * Q15
1137     sumQQ = WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[offsg],
1138         WebRtcIsacfix_kT1GainQ15[0][0]);
1139     sumQQ += WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[offsg + 1],
1140         WebRtcIsacfix_kT1GainQ15[0][2]);
1141     tmpcoeffs2_gQ21[posg] = sumQQ;
1142     posg++;
1143
1144     // Q21 = Q6 * Q15
1145     sumQQ = WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[offsg],
1146         WebRtcIsacfix_kT1GainQ15[0][1]);
1147     sumQQ += WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[offsg + 1],
1148         WebRtcIsacfix_kT1GainQ15[0][3]);
1149     tmpcoeffs2_gQ21[posg] = sumQQ;
1150     posg++;
1151
1152     offsg += 2;
1153   }
1154
1155   WebRtcIsacfix_MatrixProduct1(WebRtcIsacfix_kT1ShapeQ15[0], tmpcoeffs_sQ17,
1156       tmpcoeffs2_sQ17, kTIndexFactor4, kTIndexFactor1, kTInitCase0,
1157       kTIndexStep1, kTIndexStep3, kTLoopCount3, kTLoopCount3, kTMatrix1_shift1);
1158
1159   /* right transform */
1160   WebRtcIsacfix_MatrixProduct2(WebRtcIsacfix_kT2GainQ15[0], tmpcoeffs2_gQ21,
1161                                tmpcoeffs_gQ17, kTIndexFactor3, kTIndexStep1);
1162
1163   WebRtcIsacfix_MatrixProduct1(WebRtcIsacfix_kT2ShapeQ15[0], tmpcoeffs2_sQ17,
1164       tmpcoeffs_sQ17, kTIndexFactor1, kTIndexFactor3, kTInitCase1, kTIndexStep3,
1165       kTIndexStep1, kTLoopCount1, kTLoopCount3, kTMatrix1_shift1);
1166
1167   /* quantize coefficients */
1168
1169   BitsQQ = 0;
1170   for (k=0; k<KLT_ORDER_GAIN; k++) //ATTN: ok?
1171   {
1172     posQQ = WebRtcIsacfix_kSelIndGain[k];
1173     pos2QQ= (int16_t)CalcLrIntQ(tmpcoeffs_gQ17[posQQ], 17);
1174
1175     index_gQQ[k] = pos2QQ + WebRtcIsacfix_kQuantMinGain[k]; //ATTN: ok?
1176     if (index_gQQ[k] < 0) {
1177       index_gQQ[k] = 0;
1178     }
1179     else if (index_gQQ[k] > WebRtcIsacfix_kMaxIndGain[k]) {
1180       index_gQQ[k] = WebRtcIsacfix_kMaxIndGain[k];
1181     }
1182     index_ovr_gQQ[k] = WebRtcIsacfix_kOffsetGain[0][k]+index_gQQ[k];
1183     posQQ = WebRtcIsacfix_kOfLevelsGain[0] + index_ovr_gQQ[k];
1184
1185     /* Save data for creation of multiple bitstreams */
1186     if (encData != NULL) {
1187       encData->LPCindex_g[KLT_ORDER_GAIN*encData->startIdx + k] = index_gQQ[k];
1188     }
1189
1190     /* determine number of bits */
1191     sumQQ = WebRtcIsacfix_kCodeLenGainQ11[posQQ]; //Q11
1192     BitsQQ += sumQQ;
1193   }
1194
1195   for (k=0; k<KLT_ORDER_SHAPE; k++) //ATTN: ok?
1196   {
1197     index_sQQ[k] = (int16_t)(CalcLrIntQ(tmpcoeffs_sQ17[WebRtcIsacfix_kSelIndShape[k]], 17) + WebRtcIsacfix_kQuantMinShape[k]); //ATTN: ok?
1198
1199     if (index_sQQ[k] < 0)
1200       index_sQQ[k] = 0;
1201     else if (index_sQQ[k] > WebRtcIsacfix_kMaxIndShape[k])
1202       index_sQQ[k] = WebRtcIsacfix_kMaxIndShape[k];
1203     index_ovr_sQQ[k] = WebRtcIsacfix_kOffsetShape[0][k]+index_sQQ[k];
1204
1205     posQQ = WebRtcIsacfix_kOfLevelsShape[0] + index_ovr_sQQ[k];
1206     sumQQ = WebRtcIsacfix_kCodeLenShapeQ11[posQQ]; //Q11
1207     BitsQQ += sumQQ;
1208   }
1209
1210
1211
1212   *model = 0;
1213   *sizeQ11=BitsQQ;
1214
1215   /* entropy coding of model number */
1216   status = WebRtcIsacfix_EncHistMulti(streamdata, model, WebRtcIsacfix_kModelCdfPtr, 1);
1217   if (status < 0) {
1218     return status;
1219   }
1220
1221   /* entropy coding of quantization indices - shape only */
1222   status = WebRtcIsacfix_EncHistMulti(streamdata, index_sQQ, WebRtcIsacfix_kCdfShapePtr[0], KLT_ORDER_SHAPE);
1223   if (status < 0) {
1224     return status;
1225   }
1226
1227   /* Save data for creation of multiple bitstreams */
1228   if (encData != NULL) {
1229     for (k=0; k<KLT_ORDER_SHAPE; k++)
1230     {
1231       encData->LPCindex_s[KLT_ORDER_SHAPE*encData->startIdx + k] = index_sQQ[k];
1232     }
1233   }
1234   /* save the state of the bitstream object 'streamdata' for the possible bit-rate reduction */
1235   transcodingParam->full         = streamdata->full;
1236   transcodingParam->stream_index = streamdata->stream_index;
1237   transcodingParam->streamval    = streamdata->streamval;
1238   transcodingParam->W_upper      = streamdata->W_upper;
1239   transcodingParam->beforeLastWord     = streamdata->stream[streamdata->stream_index-1];
1240   transcodingParam->lastWord     = streamdata->stream[streamdata->stream_index];
1241
1242   /* entropy coding of index */
1243   status = WebRtcIsacfix_EncHistMulti(streamdata, index_gQQ, WebRtcIsacfix_kCdfGainPtr[0], KLT_ORDER_GAIN);
1244   if (status < 0) {
1245     return status;
1246   }
1247
1248   /* find quantization levels for shape coefficients */
1249   for (k=0; k<KLT_ORDER_SHAPE; k++) {
1250     tmpcoeffs_sQ17[WebRtcIsacfix_kSelIndShape[k]] = WEBRTC_SPL_MUL(128, WebRtcIsacfix_kLevelsShapeQ10[WebRtcIsacfix_kOfLevelsShape[0]+index_ovr_sQQ[k]]);
1251
1252   }
1253   /* inverse KLT  */
1254
1255   /* left transform */  // Transpose matrix!
1256   WebRtcIsacfix_MatrixProduct1(WebRtcIsacfix_kT1ShapeQ15[0], tmpcoeffs_sQ17,
1257       tmpcoeffs2_sQ17, kTIndexFactor4, kTIndexFactor4, kTInitCase0,
1258       kTIndexStep1, kTIndexStep1, kTLoopCount3, kTLoopCount3, kTMatrix1_shift1);
1259
1260   /* right transform */ // Transpose matrix
1261   WebRtcIsacfix_MatrixProduct1(WebRtcIsacfix_kT2ShapeQ15[0], tmpcoeffs2_sQ17,
1262       tmpcoeffs_sQ17, kTIndexFactor1, kTIndexFactor1, kTInitCase1, kTIndexStep3,
1263       kTIndexStep2, kTLoopCount1, kTLoopCount3, kTMatrix1_shift1);
1264
1265   /* scaling, mean addition, and gain restoration */
1266   poss = 0;pos=0;
1267   for (k=0; k<SUBFRAMES; k++) {
1268
1269     /* lo band LAR coeffs */
1270     for (n=0; n<ORDERLO; n++, pos++, poss++) {
1271       tmp32 = WEBRTC_SPL_MUL_16_32_RSFT16(31208, tmpcoeffs_sQ17[poss]); // (Q16*Q17)>>16 = Q17, with 1/2.1 = 0.47619047619 ~= 31208 in Q16
1272       tmp32 = tmp32 + WebRtcIsacfix_kMeansShapeQ17[0][poss]; // Q17+Q17 = Q17
1273       LPCCoefQ17[pos] = tmp32;
1274     }
1275
1276     /* hi band LAR coeffs */
1277     for (n=0; n<ORDERHI; n++, pos++, poss++) {
1278       tmp32 = WEBRTC_SPL_LSHIFT_W32(WEBRTC_SPL_MUL_16_32_RSFT16(18204, tmpcoeffs_sQ17[poss]), 3); // ((Q13*Q17)>>16)<<3 = Q17, with 1/0.45 = 2.222222222222 ~= 18204 in Q13
1279       tmp32 = tmp32 + WebRtcIsacfix_kMeansShapeQ17[0][poss]; // Q17+Q17 = Q17
1280       LPCCoefQ17[pos] = tmp32;
1281     }
1282
1283   }
1284
1285   //to update tmpcoeffs_gQ17 to the proper state
1286   for (k=0; k<KLT_ORDER_GAIN; k++) {
1287     tmpcoeffs_gQ17[WebRtcIsacfix_kSelIndGain[k]] = WebRtcIsacfix_kLevelsGainQ17[WebRtcIsacfix_kOfLevelsGain[0]+index_ovr_gQQ[k]];
1288   }
1289
1290
1291
1292   /* find quantization levels for coefficients */
1293
1294   /* left transform */
1295   offsg = 0;
1296   posg = 0;
1297   for (j=0; j<SUBFRAMES; j++) {
1298     // (Q15 * Q17) >> (16 - 1) = Q17; Q17 << 4 = Q21.
1299     sumQQ = (WEBRTC_SPL_MUL_16_32_RSFT16(WebRtcIsacfix_kT1GainQ15[0][0],
1300                                          tmpcoeffs_gQ17[offsg]) << 1);
1301     sumQQ += (WEBRTC_SPL_MUL_16_32_RSFT16(WebRtcIsacfix_kT1GainQ15[0][1],
1302                                           tmpcoeffs_gQ17[offsg + 1]) << 1);
1303     tmpcoeffs2_gQ21[posg] = WEBRTC_SPL_LSHIFT_W32(sumQQ, 4);
1304     posg++;
1305
1306     sumQQ = (WEBRTC_SPL_MUL_16_32_RSFT16(WebRtcIsacfix_kT1GainQ15[0][2],
1307                                          tmpcoeffs_gQ17[offsg]) << 1);
1308     sumQQ += (WEBRTC_SPL_MUL_16_32_RSFT16(WebRtcIsacfix_kT1GainQ15[0][3],
1309                                           tmpcoeffs_gQ17[offsg + 1]) << 1);
1310     tmpcoeffs2_gQ21[posg] = WEBRTC_SPL_LSHIFT_W32(sumQQ, 4);
1311     posg++;
1312     offsg += 2;
1313   }
1314
1315   /* right transform */ // Transpose matrix
1316   WebRtcIsacfix_MatrixProduct2(WebRtcIsacfix_kT2GainQ15[0], tmpcoeffs2_gQ21,
1317                                tmpcoeffs_gQ17, kTIndexFactor1, kTIndexStep2);
1318
1319   /* scaling, mean addition, and gain restoration */
1320   posg = 0;
1321   gainpos = 0;
1322   for (k=0; k<2*SUBFRAMES; k++) {
1323
1324     sumQQ16 = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmpcoeffs_gQ17[posg], 2+9); //Divide by 4 and get Q17 to Q8, i.e. shift 2+9
1325     sumQQ16 += WebRtcIsacfix_kMeansGainQ8[0][posg];
1326     sumQQ = CalcExpN(sumQQ16); // Q8 in and Q17 out
1327     gain_lo_hiQ17[gainpos] = sumQQ; //Q17
1328
1329     gainpos++;
1330     pos++;posg++;
1331   }
1332
1333   return 0;
1334 }
1335
1336 int WebRtcIsacfix_EstCodeLpcGain(int32_t *gain_lo_hiQ17,
1337                                  Bitstr_enc *streamdata,
1338                                  ISAC_SaveEncData_t* encData) {
1339   int j, k;
1340   int16_t posQQ, pos2QQ, gainpos;
1341   int16_t posg;
1342   int16_t index_gQQ[KLT_ORDER_GAIN];
1343
1344   int16_t tmpcoeffs_gQ6[KLT_ORDER_GAIN];
1345   int32_t tmpcoeffs_gQ17[KLT_ORDER_GAIN];
1346   int32_t tmpcoeffs2_gQ21[KLT_ORDER_GAIN];
1347   int32_t sumQQ;
1348   int status = 0;
1349
1350   /* write LAR coefficients to statistics file */
1351   /* Save data for creation of multiple bitstreams (and transcoding) */
1352   if (encData != NULL) {
1353     for (k=0; k<KLT_ORDER_GAIN; k++) {
1354       encData->LPCcoeffs_g[KLT_ORDER_GAIN*encData->startIdx + k] = gain_lo_hiQ17[k];
1355     }
1356   }
1357
1358   /* log gains, mean removal and scaling */
1359   posg = 0; gainpos = 0;
1360
1361   for (k=0; k<SUBFRAMES; k++) {
1362     /* log gains */
1363
1364     /* The input argument X to logN(X) is 2^17 times higher than the
1365        input floating point argument Y to log(Y), since the X value
1366        is a Q17 value. This can be compensated for after the call, by
1367        subraction a value Z for each Q-step. One Q-step means that
1368        X gets 2 times higher, i.e. Z = logN(2)*256 = 0.693147180559*256 =
1369        177.445678 should be subtracted (since logN() returns a Q8 value).
1370        For a X value in Q17, the value 177.445678*17 = 3017 should be
1371        subtracted */
1372     tmpcoeffs_gQ6[posg] = CalcLogN(gain_lo_hiQ17[gainpos])-3017; //Q8
1373     tmpcoeffs_gQ6[posg] -= WebRtcIsacfix_kMeansGainQ8[0][posg]; //Q8, but Q6 after not-needed mult. by 4
1374     posg++; gainpos++;
1375
1376     tmpcoeffs_gQ6[posg] = CalcLogN(gain_lo_hiQ17[gainpos])-3017; //Q8
1377     tmpcoeffs_gQ6[posg] -= WebRtcIsacfix_kMeansGainQ8[0][posg]; //Q8, but Q6 after not-needed mult. by 4
1378     posg++; gainpos++;
1379   }
1380
1381
1382   /* KLT  */
1383
1384   /* left transform */
1385   posg = 0;
1386   for (j=0; j<SUBFRAMES; j++) {
1387       // Q21 = Q6 * Q15
1388       sumQQ = WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[j * 2],
1389                                    WebRtcIsacfix_kT1GainQ15[0][0]);
1390       sumQQ += WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[j * 2 + 1],
1391                                     WebRtcIsacfix_kT1GainQ15[0][2]);
1392       tmpcoeffs2_gQ21[posg] = sumQQ;
1393       posg++;
1394
1395       sumQQ = WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[j * 2],
1396                                    WebRtcIsacfix_kT1GainQ15[0][1]);
1397       sumQQ += WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[j * 2 + 1],
1398                                     WebRtcIsacfix_kT1GainQ15[0][3]);
1399       tmpcoeffs2_gQ21[posg] = sumQQ;
1400       posg++;
1401   }
1402
1403   /* right transform */
1404   WebRtcIsacfix_MatrixProduct2(WebRtcIsacfix_kT2GainQ15[0], tmpcoeffs2_gQ21,
1405                                tmpcoeffs_gQ17, kTIndexFactor3, kTIndexStep1);
1406
1407   /* quantize coefficients */
1408
1409   for (k=0; k<KLT_ORDER_GAIN; k++) //ATTN: ok?
1410   {
1411     posQQ = WebRtcIsacfix_kSelIndGain[k];
1412     pos2QQ= (int16_t)CalcLrIntQ(tmpcoeffs_gQ17[posQQ], 17);
1413
1414     index_gQQ[k] = pos2QQ + WebRtcIsacfix_kQuantMinGain[k]; //ATTN: ok?
1415     if (index_gQQ[k] < 0) {
1416       index_gQQ[k] = 0;
1417     }
1418     else if (index_gQQ[k] > WebRtcIsacfix_kMaxIndGain[k]) {
1419       index_gQQ[k] = WebRtcIsacfix_kMaxIndGain[k];
1420     }
1421
1422     /* Save data for creation of multiple bitstreams */
1423     if (encData != NULL) {
1424       encData->LPCindex_g[KLT_ORDER_GAIN*encData->startIdx + k] = index_gQQ[k];
1425     }
1426   }
1427
1428   /* entropy coding of index */
1429   status = WebRtcIsacfix_EncHistMulti(streamdata, index_gQQ, WebRtcIsacfix_kCdfGainPtr[0], KLT_ORDER_GAIN);
1430   if (status < 0) {
1431     return status;
1432   }
1433
1434   return 0;
1435 }
1436
1437
1438 int WebRtcIsacfix_EncodeLpc(int32_t *gain_lo_hiQ17,
1439                             int16_t *LPCCoef_loQ15,
1440                             int16_t *LPCCoef_hiQ15,
1441                             int16_t *model,
1442                             int32_t *sizeQ11,
1443                             Bitstr_enc *streamdata,
1444                             ISAC_SaveEncData_t* encData,
1445                             transcode_obj *transcodeParam)
1446 {
1447   int status = 0;
1448   int32_t larsQ17[KLT_ORDER_SHAPE]; // KLT_ORDER_SHAPE == (ORDERLO+ORDERHI)*SUBFRAMES
1449   // = (6+12)*6 == 108
1450
1451   Poly2LarFix(LPCCoef_loQ15, ORDERLO, LPCCoef_hiQ15, ORDERHI, SUBFRAMES, larsQ17);
1452
1453   status = EstCodeLpcCoef(larsQ17, gain_lo_hiQ17, model, sizeQ11,
1454                           streamdata, encData, transcodeParam);
1455   if (status < 0) {
1456     return (status);
1457   }
1458
1459   Lar2polyFix(larsQ17, LPCCoef_loQ15, ORDERLO, LPCCoef_hiQ15, ORDERHI, SUBFRAMES);
1460
1461   return 0;
1462 }
1463
1464
1465 /* decode & dequantize RC */
1466 int WebRtcIsacfix_DecodeRcCoef(Bitstr_dec *streamdata, int16_t *RCQ15)
1467 {
1468   int k, err;
1469   int16_t index[AR_ORDER];
1470
1471   /* entropy decoding of quantization indices */
1472   err = WebRtcIsacfix_DecHistOneStepMulti(index, streamdata, WebRtcIsacfix_kRcCdfPtr, WebRtcIsacfix_kRcInitInd, AR_ORDER);
1473   if (err<0)  // error check
1474     return err;
1475
1476   /* find quantization levels for reflection coefficients */
1477   for (k=0; k<AR_ORDER; k++)
1478   {
1479     RCQ15[k] = *(WebRtcIsacfix_kRcLevPtr[k] + index[k]);
1480   }
1481
1482   return 0;
1483 }
1484
1485
1486
1487 /* quantize & code RC */
1488 int WebRtcIsacfix_EncodeRcCoef(int16_t *RCQ15, Bitstr_enc *streamdata)
1489 {
1490   int k;
1491   int16_t index[AR_ORDER];
1492   int status;
1493
1494   /* quantize reflection coefficients (add noise feedback?) */
1495   for (k=0; k<AR_ORDER; k++)
1496   {
1497     index[k] = WebRtcIsacfix_kRcInitInd[k];
1498
1499     if (RCQ15[k] > WebRtcIsacfix_kRcBound[index[k]])
1500     {
1501       while (RCQ15[k] > WebRtcIsacfix_kRcBound[index[k] + 1])
1502         index[k]++;
1503     }
1504     else
1505     {
1506       while (RCQ15[k] < WebRtcIsacfix_kRcBound[--index[k]]) ;
1507     }
1508
1509     RCQ15[k] = *(WebRtcIsacfix_kRcLevPtr[k] + index[k]);
1510   }
1511
1512
1513   /* entropy coding of quantization indices */
1514   status = WebRtcIsacfix_EncHistMulti(streamdata, index, WebRtcIsacfix_kRcCdfPtr, AR_ORDER);
1515
1516   /* If error in WebRtcIsacfix_EncHistMulti(), status will be negative, otherwise 0 */
1517   return status;
1518 }
1519
1520
1521 /* decode & dequantize squared Gain */
1522 int WebRtcIsacfix_DecodeGain2(Bitstr_dec *streamdata, int32_t *gainQ10)
1523 {
1524   int err;
1525   int16_t index;
1526
1527   /* entropy decoding of quantization index */
1528   err = WebRtcIsacfix_DecHistOneStepMulti(
1529       &index,
1530       streamdata,
1531       WebRtcIsacfix_kGainPtr,
1532       WebRtcIsacfix_kGainInitInd,
1533       1);
1534   /* error check */
1535   if (err<0) {
1536     return err;
1537   }
1538
1539   /* find quantization level */
1540   *gainQ10 = WebRtcIsacfix_kGain2Lev[index];
1541
1542   return 0;
1543 }
1544
1545
1546
1547 /* quantize & code squared Gain */
1548 int WebRtcIsacfix_EncodeGain2(int32_t *gainQ10, Bitstr_enc *streamdata)
1549 {
1550   int16_t index;
1551   int status = 0;
1552
1553   /* find quantization index */
1554   index = WebRtcIsacfix_kGainInitInd[0];
1555   if (*gainQ10 > WebRtcIsacfix_kGain2Bound[index])
1556   {
1557     while (*gainQ10 > WebRtcIsacfix_kGain2Bound[index + 1])
1558       index++;
1559   }
1560   else
1561   {
1562     while (*gainQ10 < WebRtcIsacfix_kGain2Bound[--index]) ;
1563   }
1564
1565   /* dequantize */
1566   *gainQ10 = WebRtcIsacfix_kGain2Lev[index];
1567
1568   /* entropy coding of quantization index */
1569   status = WebRtcIsacfix_EncHistMulti(streamdata, &index, WebRtcIsacfix_kGainPtr, 1);
1570
1571   /* If error in WebRtcIsacfix_EncHistMulti(), status will be negative, otherwise 0 */
1572   return status;
1573 }
1574
1575
1576 /* code and decode Pitch Gains and Lags functions */
1577
1578 /* decode & dequantize Pitch Gains */
1579 int WebRtcIsacfix_DecodePitchGain(Bitstr_dec *streamdata, int16_t *PitchGains_Q12)
1580 {
1581   int err;
1582   int16_t index_comb;
1583   const uint16_t *pitch_gain_cdf_ptr[1];
1584
1585   /* entropy decoding of quantization indices */
1586   *pitch_gain_cdf_ptr = WebRtcIsacfix_kPitchGainCdf;
1587   err = WebRtcIsacfix_DecHistBisectMulti(&index_comb, streamdata, pitch_gain_cdf_ptr, WebRtcIsacfix_kCdfTableSizeGain, 1);
1588   /* error check, Q_mean_Gain.. tables are of size 144 */
1589   if ((err < 0) || (index_comb < 0) || (index_comb >= 144))
1590     return -ISAC_RANGE_ERROR_DECODE_PITCH_GAIN;
1591
1592   /* unquantize back to pitch gains by table look-up */
1593   PitchGains_Q12[0] = WebRtcIsacfix_kPitchGain1[index_comb];
1594   PitchGains_Q12[1] = WebRtcIsacfix_kPitchGain2[index_comb];
1595   PitchGains_Q12[2] = WebRtcIsacfix_kPitchGain3[index_comb];
1596   PitchGains_Q12[3] = WebRtcIsacfix_kPitchGain4[index_comb];
1597
1598   return 0;
1599 }
1600
1601
1602 /* quantize & code Pitch Gains */
1603 int WebRtcIsacfix_EncodePitchGain(int16_t *PitchGains_Q12, Bitstr_enc *streamdata, ISAC_SaveEncData_t* encData)
1604 {
1605   int k,j;
1606   int16_t SQ15[PITCH_SUBFRAMES];
1607   int16_t index[3];
1608   int16_t index_comb;
1609   const uint16_t *pitch_gain_cdf_ptr[1];
1610   int32_t CQ17;
1611   int status = 0;
1612
1613
1614   /* get the approximate arcsine (almost linear)*/
1615   for (k=0; k<PITCH_SUBFRAMES; k++)
1616     SQ15[k] = (int16_t) WEBRTC_SPL_MUL_16_16_RSFT(PitchGains_Q12[k],33,2); //Q15
1617
1618
1619   /* find quantization index; only for the first three transform coefficients */
1620   for (k=0; k<3; k++)
1621   {
1622     /*  transform */
1623     CQ17=0;
1624     for (j=0; j<PITCH_SUBFRAMES; j++) {
1625       CQ17 += WEBRTC_SPL_MUL_16_16_RSFT(WebRtcIsacfix_kTransform[k][j], SQ15[j],10); // Q17
1626     }
1627
1628     index[k] = (int16_t)((CQ17 + 8192)>>14); // Rounding and scaling with stepsize (=1/0.125=8)
1629
1630     /* check that the index is not outside the boundaries of the table */
1631     if (index[k] < WebRtcIsacfix_kLowerlimiGain[k]) index[k] = WebRtcIsacfix_kLowerlimiGain[k];
1632     else if (index[k] > WebRtcIsacfix_kUpperlimitGain[k]) index[k] = WebRtcIsacfix_kUpperlimitGain[k];
1633     index[k] -= WebRtcIsacfix_kLowerlimiGain[k];
1634   }
1635
1636   /* calculate unique overall index */
1637   index_comb = (int16_t)(WEBRTC_SPL_MUL(WebRtcIsacfix_kMultsGain[0], index[0]) +
1638                                WEBRTC_SPL_MUL(WebRtcIsacfix_kMultsGain[1], index[1]) + index[2]);
1639
1640   /* unquantize back to pitch gains by table look-up */
1641   // (Y)
1642   PitchGains_Q12[0] = WebRtcIsacfix_kPitchGain1[index_comb];
1643   PitchGains_Q12[1] = WebRtcIsacfix_kPitchGain2[index_comb];
1644   PitchGains_Q12[2] = WebRtcIsacfix_kPitchGain3[index_comb];
1645   PitchGains_Q12[3] = WebRtcIsacfix_kPitchGain4[index_comb];
1646
1647
1648   /* entropy coding of quantization pitch gains */
1649   *pitch_gain_cdf_ptr = WebRtcIsacfix_kPitchGainCdf;
1650   status = WebRtcIsacfix_EncHistMulti(streamdata, &index_comb, pitch_gain_cdf_ptr, 1);
1651   if (status < 0) {
1652     return status;
1653   }
1654
1655   /* Save data for creation of multiple bitstreams */
1656   if (encData != NULL) {
1657     encData->pitchGain_index[encData->startIdx] = index_comb;
1658   }
1659
1660   return 0;
1661 }
1662
1663
1664
1665 /* Pitch LAG */
1666
1667
1668 /* decode & dequantize Pitch Lags */
1669 int WebRtcIsacfix_DecodePitchLag(Bitstr_dec *streamdata,
1670                                  int16_t *PitchGain_Q12,
1671                                  int16_t *PitchLags_Q7)
1672 {
1673   int k, err;
1674   int16_t index[PITCH_SUBFRAMES];
1675   const int16_t *mean_val2Q10, *mean_val4Q10;
1676
1677   const int16_t *lower_limit;
1678   const uint16_t *init_index;
1679   const uint16_t *cdf_size;
1680   const uint16_t **cdf;
1681
1682   int32_t meangainQ12;
1683   int32_t CQ11, CQ10,tmp32a,tmp32b;
1684   int16_t shft,tmp16a,tmp16c;
1685
1686   meangainQ12=0;
1687   for (k = 0; k < 4; k++)
1688     meangainQ12 += PitchGain_Q12[k];
1689
1690   meangainQ12 = WEBRTC_SPL_RSHIFT_W32(meangainQ12, 2);  // Get average
1691
1692   /* voicing classificiation */
1693   if (meangainQ12 <= 819) {                 // mean_gain < 0.2
1694     shft = -1;        // StepSize=2.0;
1695     cdf = WebRtcIsacfix_kPitchLagPtrLo;
1696     cdf_size = WebRtcIsacfix_kPitchLagSizeLo;
1697     mean_val2Q10 = WebRtcIsacfix_kMeanLag2Lo;
1698     mean_val4Q10 = WebRtcIsacfix_kMeanLag4Lo;
1699     lower_limit = WebRtcIsacfix_kLowerLimitLo;
1700     init_index = WebRtcIsacfix_kInitIndLo;
1701   } else if (meangainQ12 <= 1638) {            // mean_gain < 0.4
1702     shft = 0;        // StepSize=1.0;
1703     cdf = WebRtcIsacfix_kPitchLagPtrMid;
1704     cdf_size = WebRtcIsacfix_kPitchLagSizeMid;
1705     mean_val2Q10 = WebRtcIsacfix_kMeanLag2Mid;
1706     mean_val4Q10 = WebRtcIsacfix_kMeanLag4Mid;
1707     lower_limit = WebRtcIsacfix_kLowerLimitMid;
1708     init_index = WebRtcIsacfix_kInitIndMid;
1709   } else {
1710     shft = 1;        // StepSize=0.5;
1711     cdf = WebRtcIsacfix_kPitchLagPtrHi;
1712     cdf_size = WebRtcIsacfix_kPitchLagSizeHi;
1713     mean_val2Q10 = WebRtcIsacfix_kMeanLag2Hi;
1714     mean_val4Q10 = WebRtcIsacfix_kMeanLag4Hi;
1715     lower_limit = WebRtcIsacfix_kLowerLimitHi;
1716     init_index = WebRtcIsacfix_kInitIndHi;
1717   }
1718
1719   /* entropy decoding of quantization indices */
1720   err = WebRtcIsacfix_DecHistBisectMulti(index, streamdata, cdf, cdf_size, 1);
1721   if ((err<0) || (index[0]<0))  // error check
1722     return -ISAC_RANGE_ERROR_DECODE_PITCH_LAG;
1723
1724   err = WebRtcIsacfix_DecHistOneStepMulti(index+1, streamdata, cdf+1, init_index, 3);
1725   if (err<0)  // error check
1726     return -ISAC_RANGE_ERROR_DECODE_PITCH_LAG;
1727
1728
1729   /* unquantize back to transform coefficients and do the inverse transform: S = T'*C */
1730   CQ11 = ((int32_t)index[0] + lower_limit[0]);  // Q0
1731   CQ11 = WEBRTC_SPL_SHIFT_W32(CQ11,11-shft); // Scale with StepSize, Q11
1732   for (k=0; k<PITCH_SUBFRAMES; k++) {
1733     tmp32a =  WEBRTC_SPL_MUL_16_32_RSFT11(WebRtcIsacfix_kTransform[0][k], CQ11);
1734     tmp16a = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmp32a, 5);
1735     PitchLags_Q7[k] = tmp16a;
1736   }
1737
1738   CQ10 = mean_val2Q10[index[1]];
1739   for (k=0; k<PITCH_SUBFRAMES; k++) {
1740     tmp32b =  (int32_t) WEBRTC_SPL_MUL_16_16_RSFT((int16_t) WebRtcIsacfix_kTransform[1][k], (int16_t) CQ10,10);
1741     tmp16c = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmp32b, 5);
1742     PitchLags_Q7[k] += tmp16c;
1743   }
1744
1745   CQ10 = mean_val4Q10[index[3]];
1746   for (k=0; k<PITCH_SUBFRAMES; k++) {
1747     tmp32b =  (int32_t) WEBRTC_SPL_MUL_16_16_RSFT((int16_t) WebRtcIsacfix_kTransform[3][k], (int16_t) CQ10,10);
1748     tmp16c = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmp32b, 5);
1749     PitchLags_Q7[k] += tmp16c;
1750   }
1751
1752   return 0;
1753 }
1754
1755
1756
1757 /* quantize & code Pitch Lags */
1758 int WebRtcIsacfix_EncodePitchLag(int16_t *PitchLagsQ7,int16_t *PitchGain_Q12,
1759                                  Bitstr_enc *streamdata, ISAC_SaveEncData_t* encData)
1760 {
1761   int k, j;
1762   int16_t index[PITCH_SUBFRAMES];
1763   int32_t meangainQ12, CQ17;
1764   int32_t CQ11, CQ10,tmp32a;
1765
1766   const int16_t *mean_val2Q10,*mean_val4Q10;
1767   const int16_t *lower_limit, *upper_limit;
1768   const uint16_t **cdf;
1769   int16_t shft, tmp16a, tmp16b, tmp16c;
1770   int32_t tmp32b;
1771   int status = 0;
1772
1773   /* compute mean pitch gain */
1774   meangainQ12=0;
1775   for (k = 0; k < 4; k++)
1776     meangainQ12 += PitchGain_Q12[k];
1777
1778   meangainQ12 = WEBRTC_SPL_RSHIFT_W32(meangainQ12, 2);
1779
1780   /* Save data for creation of multiple bitstreams */
1781   if (encData != NULL) {
1782     encData->meanGain[encData->startIdx] = meangainQ12;
1783   }
1784
1785   /* voicing classificiation */
1786   if (meangainQ12 <= 819) {                 // mean_gain < 0.2
1787     shft = -1;        // StepSize=2.0;
1788     cdf = WebRtcIsacfix_kPitchLagPtrLo;
1789     mean_val2Q10 = WebRtcIsacfix_kMeanLag2Lo;
1790     mean_val4Q10 = WebRtcIsacfix_kMeanLag4Lo;
1791     lower_limit = WebRtcIsacfix_kLowerLimitLo;
1792     upper_limit = WebRtcIsacfix_kUpperLimitLo;
1793   } else if (meangainQ12 <= 1638) {            // mean_gain < 0.4
1794     shft = 0;        // StepSize=1.0;
1795     cdf = WebRtcIsacfix_kPitchLagPtrMid;
1796     mean_val2Q10 = WebRtcIsacfix_kMeanLag2Mid;
1797     mean_val4Q10 = WebRtcIsacfix_kMeanLag4Mid;
1798     lower_limit = WebRtcIsacfix_kLowerLimitMid;
1799     upper_limit = WebRtcIsacfix_kUpperLimitMid;
1800   } else {
1801     shft = 1;        // StepSize=0.5;
1802     cdf = WebRtcIsacfix_kPitchLagPtrHi;
1803     mean_val2Q10 = WebRtcIsacfix_kMeanLag2Hi;
1804     mean_val4Q10 = WebRtcIsacfix_kMeanLag4Hi;
1805     lower_limit = WebRtcIsacfix_kLowerLimitHi;
1806     upper_limit = WebRtcIsacfix_kUpperLimitHi;
1807   }
1808
1809   /* find quantization index */
1810   for (k=0; k<4; k++)
1811   {
1812     /*  transform */
1813     CQ17=0;
1814     for (j=0; j<PITCH_SUBFRAMES; j++)
1815       CQ17 += WEBRTC_SPL_MUL_16_16_RSFT(WebRtcIsacfix_kTransform[k][j], PitchLagsQ7[j],2); // Q17
1816
1817     CQ17 = WEBRTC_SPL_SHIFT_W32(CQ17,shft); // Scale with StepSize
1818
1819     /* quantize */
1820     tmp16b = (int16_t) WEBRTC_SPL_RSHIFT_W32(CQ17 + 65536, 17 );
1821     index[k] =  tmp16b;
1822
1823     /* check that the index is not outside the boundaries of the table */
1824     if (index[k] < lower_limit[k]) index[k] = lower_limit[k];
1825     else if (index[k] > upper_limit[k]) index[k] = upper_limit[k];
1826     index[k] -= lower_limit[k];
1827
1828     /* Save data for creation of multiple bitstreams */
1829     if(encData != NULL) {
1830       encData->pitchIndex[PITCH_SUBFRAMES*encData->startIdx + k] = index[k];
1831     }
1832   }
1833
1834   /* unquantize back to transform coefficients and do the inverse transform: S = T'*C */
1835   CQ11 = (index[0] + lower_limit[0]);  // Q0
1836   CQ11 = WEBRTC_SPL_SHIFT_W32(CQ11,11-shft); // Scale with StepSize, Q11
1837
1838   for (k=0; k<PITCH_SUBFRAMES; k++) {
1839     tmp32a =  WEBRTC_SPL_MUL_16_32_RSFT11(WebRtcIsacfix_kTransform[0][k], CQ11); // Q12
1840     tmp16a = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmp32a, 5);// Q7
1841     PitchLagsQ7[k] = tmp16a;
1842   }
1843
1844   CQ10 = mean_val2Q10[index[1]];
1845   for (k=0; k<PITCH_SUBFRAMES; k++) {
1846     tmp32b =  (int32_t) WEBRTC_SPL_MUL_16_16_RSFT((int16_t) WebRtcIsacfix_kTransform[1][k], (int16_t) CQ10,10);
1847     tmp16c = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmp32b, 5); // Q7
1848     PitchLagsQ7[k] += tmp16c;
1849   }
1850
1851   CQ10 = mean_val4Q10[index[3]];
1852   for (k=0; k<PITCH_SUBFRAMES; k++) {
1853     tmp32b =  (int32_t) WEBRTC_SPL_MUL_16_16_RSFT((int16_t) WebRtcIsacfix_kTransform[3][k], (int16_t) CQ10,10);
1854     tmp16c = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmp32b, 5); // Q7
1855     PitchLagsQ7[k] += tmp16c;
1856   }
1857
1858   /* entropy coding of quantization pitch lags */
1859   status = WebRtcIsacfix_EncHistMulti(streamdata, index, cdf, PITCH_SUBFRAMES);
1860
1861   /* If error in WebRtcIsacfix_EncHistMulti(), status will be negative, otherwise 0 */
1862   return status;
1863 }
1864
1865
1866
1867 /* Routines for inband signaling of bandwitdh estimation */
1868 /* Histograms based on uniform distribution of indices */
1869 /* Move global variables later! */
1870
1871
1872 /* cdf array for frame length indicator */
1873 const uint16_t kFrameLenCdf[4] = {
1874   0, 21845, 43690, 65535};
1875
1876 /* pointer to cdf array for frame length indicator */
1877 const uint16_t *kFrameLenCdfPtr[1] = {kFrameLenCdf};
1878
1879 /* initial cdf index for decoder of frame length indicator */
1880 const uint16_t kFrameLenInitIndex[1] = {1};
1881
1882
1883 int WebRtcIsacfix_DecodeFrameLen(Bitstr_dec *streamdata,
1884                                  int16_t *framesamples)
1885 {
1886
1887   int err;
1888   int16_t frame_mode;
1889
1890   err = 0;
1891   /* entropy decoding of frame length [1:30ms,2:60ms] */
1892   err = WebRtcIsacfix_DecHistOneStepMulti(&frame_mode, streamdata, kFrameLenCdfPtr, kFrameLenInitIndex, 1);
1893   if (err<0)  // error check
1894     return -ISAC_RANGE_ERROR_DECODE_FRAME_LENGTH;
1895
1896   switch(frame_mode) {
1897     case 1:
1898       *framesamples = 480; /* 30ms */
1899       break;
1900     case 2:
1901       *framesamples = 960; /* 60ms */
1902       break;
1903     default:
1904       err = -ISAC_DISALLOWED_FRAME_MODE_DECODER;
1905   }
1906
1907   return err;
1908 }
1909
1910
1911 int WebRtcIsacfix_EncodeFrameLen(int16_t framesamples, Bitstr_enc *streamdata) {
1912
1913   int status;
1914   int16_t frame_mode;
1915
1916   status = 0;
1917   frame_mode = 0;
1918   /* entropy coding of frame length [1:480 samples,2:960 samples] */
1919   switch(framesamples) {
1920     case 480:
1921       frame_mode = 1;
1922       break;
1923     case 960:
1924       frame_mode = 2;
1925       break;
1926     default:
1927       status = - ISAC_DISALLOWED_FRAME_MODE_ENCODER;
1928   }
1929
1930   if (status < 0)
1931     return status;
1932
1933   status = WebRtcIsacfix_EncHistMulti(streamdata, &frame_mode, kFrameLenCdfPtr, 1);
1934
1935   return status;
1936 }
1937
1938 /* cdf array for estimated bandwidth */
1939 const uint16_t kBwCdf[25] = {
1940   0, 2731, 5461, 8192, 10923, 13653, 16384, 19114, 21845, 24576, 27306, 30037,
1941   32768, 35498, 38229, 40959, 43690, 46421, 49151, 51882, 54613, 57343, 60074,
1942   62804, 65535};
1943
1944 /* pointer to cdf array for estimated bandwidth */
1945 const uint16_t *kBwCdfPtr[1] = {kBwCdf};
1946
1947 /* initial cdf index for decoder of estimated bandwidth*/
1948 const uint16_t kBwInitIndex[1] = {7};
1949
1950
1951 int WebRtcIsacfix_DecodeSendBandwidth(Bitstr_dec *streamdata, int16_t *BWno) {
1952
1953   int err;
1954   int16_t BWno32;
1955
1956   /* entropy decoding of sender's BW estimation [0..23] */
1957   err = WebRtcIsacfix_DecHistOneStepMulti(&BWno32, streamdata, kBwCdfPtr, kBwInitIndex, 1);
1958   if (err<0)  // error check
1959     return -ISAC_RANGE_ERROR_DECODE_BANDWIDTH;
1960   *BWno = (int16_t)BWno32;
1961   return err;
1962
1963 }
1964
1965
1966 int WebRtcIsacfix_EncodeReceiveBandwidth(int16_t *BWno, Bitstr_enc *streamdata)
1967 {
1968   int status = 0;
1969   /* entropy encoding of receiver's BW estimation [0..23] */
1970   status = WebRtcIsacfix_EncHistMulti(streamdata, BWno, kBwCdfPtr, 1);
1971
1972   return status;
1973 }
1974
1975 /* estimate codel length of LPC Coef */
1976 void WebRtcIsacfix_TranscodeLpcCoef(int32_t *gain_lo_hiQ17,
1977                                     int16_t *index_gQQ) {
1978   int j, k;
1979   int16_t posQQ, pos2QQ;
1980   int16_t posg, offsg, gainpos;
1981   int32_t tmpcoeffs_gQ6[KLT_ORDER_GAIN];
1982   int32_t tmpcoeffs_gQ17[KLT_ORDER_GAIN];
1983   int32_t tmpcoeffs2_gQ21[KLT_ORDER_GAIN];
1984   int32_t sumQQ;
1985
1986
1987   /* log gains, mean removal and scaling */
1988   posg = 0; gainpos=0;
1989
1990   for (k=0; k<SUBFRAMES; k++) {
1991     /* log gains */
1992
1993     /* The input argument X to logN(X) is 2^17 times higher than the
1994        input floating point argument Y to log(Y), since the X value
1995        is a Q17 value. This can be compensated for after the call, by
1996        subraction a value Z for each Q-step. One Q-step means that
1997        X gets 2 times higher, i.e. Z = logN(2)*256 = 0.693147180559*256 =
1998        177.445678 should be subtracted (since logN() returns a Q8 value).
1999        For a X value in Q17, the value 177.445678*17 = 3017 should be
2000        subtracted */
2001     tmpcoeffs_gQ6[posg] = CalcLogN(gain_lo_hiQ17[gainpos])-3017; //Q8
2002     tmpcoeffs_gQ6[posg] -= WebRtcIsacfix_kMeansGainQ8[0][posg]; //Q8, but Q6 after not-needed mult. by 4
2003     posg++; gainpos++;
2004
2005     tmpcoeffs_gQ6[posg] = CalcLogN(gain_lo_hiQ17[gainpos])-3017; //Q8
2006     tmpcoeffs_gQ6[posg] -= WebRtcIsacfix_kMeansGainQ8[0][posg]; //Q8, but Q6 after not-needed mult. by 4
2007     posg++; gainpos++;
2008
2009   }
2010
2011
2012   /* KLT  */
2013
2014   /* left transform */
2015   for (j = 0, offsg = 0; j < SUBFRAMES; j++, offsg += 2) {
2016     // Q21 = Q6 * Q15
2017     sumQQ = WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[offsg],
2018                                  WebRtcIsacfix_kT1GainQ15[0][0]);
2019     sumQQ += WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[offsg + 1],
2020                                   WebRtcIsacfix_kT1GainQ15[0][2]);
2021     tmpcoeffs2_gQ21[offsg] = sumQQ;
2022
2023     // Q21 = Q6 * Q15
2024     sumQQ = WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[offsg],
2025                                  WebRtcIsacfix_kT1GainQ15[0][1]);
2026     sumQQ += WEBRTC_SPL_MUL_16_16(tmpcoeffs_gQ6[offsg + 1],
2027                                   WebRtcIsacfix_kT1GainQ15[0][3]);
2028     tmpcoeffs2_gQ21[offsg + 1] = sumQQ;
2029   }
2030
2031   /* right transform */
2032   WebRtcIsacfix_MatrixProduct2(WebRtcIsacfix_kT2GainQ15[0], tmpcoeffs2_gQ21,
2033                                tmpcoeffs_gQ17, kTIndexFactor3, kTIndexStep1);
2034
2035   /* quantize coefficients */
2036   for (k=0; k<KLT_ORDER_GAIN; k++) //ATTN: ok?
2037   {
2038     posQQ = WebRtcIsacfix_kSelIndGain[k];
2039     pos2QQ= (int16_t)CalcLrIntQ(tmpcoeffs_gQ17[posQQ], 17);
2040
2041     index_gQQ[k] = pos2QQ + WebRtcIsacfix_kQuantMinGain[k]; //ATTN: ok?
2042     if (index_gQQ[k] < 0) {
2043       index_gQQ[k] = 0;
2044     }
2045     else if (index_gQQ[k] > WebRtcIsacfix_kMaxIndGain[k]) {
2046       index_gQQ[k] = WebRtcIsacfix_kMaxIndGain[k];
2047     }
2048   }
2049 }