git.sesse.net Git - ffmpeg/blob - libavcodec/ilbcdec.c

   1 /*
   2  * Copyright (c) 2013, The WebRTC project authors. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * 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
  13  *     the documentation and/or other materials provided with the
  14  *     distribution.
  15  *
  16  *   * Neither the name of Google nor the names of its contributors may
  17  *     be used to endorse or promote products derived from this software
  18  *     without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include "avcodec.h"
  34 #include "internal.h"
  35 #include "get_bits.h"
  36 #include "ilbcdata.h"
  37
  38 #define LPC_N_20MS            1
  39 #define LPC_N_30MS            2
  40 #define LPC_N_MAX             2
  41 #define LSF_NSPLIT            3
  42 #define NASUB_MAX             4
  43 #define LPC_FILTERORDER       10
  44 #define NSUB_MAX              6
  45 #define SUBL                  40
  46
  47 #define ST_MEM_L_TBL          85
  48 #define MEM_LF_TBL            147
  49 #define STATE_SHORT_LEN_20MS  57
  50 #define STATE_SHORT_LEN_30MS  58
  51
  52 #define BLOCKL_MAX            240
  53 #define CB_MEML               147
  54 #define CB_NSTAGES            3
  55 #define CB_HALFFILTERLEN      4
  56 #define CB_FILTERLEN          8
  57
  58 #define ENH_NBLOCKS_TOT 8
  59 #define ENH_BLOCKL     80
  60 #define ENH_BUFL     (ENH_NBLOCKS_TOT)*ENH_BLOCKL
  61 #define ENH_BUFL_FILTEROVERHEAD  3
  62 #define BLOCKL_MAX      240
  63 #define NSUB_20MS         4
  64 #define NSUB_30MS         6
  65 #define NSUB_MAX          6
  66 #define NASUB_20MS        2
  67 #define NASUB_30MS        4
  68 #define NASUB_MAX         4
  69 #define STATE_LEN        80
  70 #define STATE_SHORT_LEN_30MS  58
  71 #define STATE_SHORT_LEN_20MS  57
  72
  73 #define SPL_MUL_16_16(a, b) ((int32_t) (((int16_t)(a)) * ((int16_t)(b))))
  74 #define SPL_MUL_16_16_RSFT(a, b, c) (SPL_MUL_16_16(a, b) >> (c))
  75
  76 typedef struct ILBCFrame {
  77     int16_t  lsf[LSF_NSPLIT*LPC_N_MAX];
  78     int16_t  cb_index[CB_NSTAGES*(NASUB_MAX + 1)];
  79     int16_t  gain_index[CB_NSTAGES*(NASUB_MAX + 1)];
  80     int16_t  ifm;
  81     int16_t  state_first;
  82     int16_t  idx[STATE_SHORT_LEN_30MS];
  83     int16_t  firstbits;
  84     int16_t  start;
  85 } ILBCFrame;
  86
  87 typedef struct ILBCContext {
  88     AVClass         *class;
  89     int              enhancer;
  90
  91     int              mode;
  92     GetBitContext    gb;
  93     ILBCFrame        frame;
  94
  95     int              prev_enh_pl;
  96     int              consPLICount;
  97     int              last_lag;
  98     int              state_short_len;
  99     int              lpc_n;
 100     int16_t          nasub;
 101     int16_t          nsub;
 102     int              block_samples;
 103     int16_t          no_of_words;
 104     int16_t          no_of_bytes;
 105     int16_t          lsfdeq[LPC_FILTERORDER*LPC_N_MAX];
 106     int16_t          lsfold[LPC_FILTERORDER];
 107     int16_t          syntMem[LPC_FILTERORDER];
 108     int16_t          lsfdeqold[LPC_FILTERORDER];
 109     int16_t          weightdenum[(LPC_FILTERORDER + 1) * NSUB_MAX];
 110     int16_t          syntdenum[NSUB_MAX * (LPC_FILTERORDER + 1)];
 111     int16_t          old_syntdenum[NSUB_MAX * (LPC_FILTERORDER + 1)];
 112     int16_t          enh_buf[ENH_BUFL+ENH_BUFL_FILTEROVERHEAD];
 113     int16_t          enh_period[ENH_NBLOCKS_TOT];
 114     int16_t          prevResidual[NSUB_MAX*SUBL];
 115     int16_t          decresidual[BLOCKL_MAX];
 116     int16_t          plc_residual[BLOCKL_MAX + LPC_FILTERORDER];
 117     int16_t          seed;
 118     int16_t          prevPLI;
 119     int16_t          prevScale;
 120     int16_t          prevLag;
 121     int16_t          per_square;
 122     int16_t          prev_lpc[LPC_FILTERORDER + 1];
 123     int16_t          plc_lpc[LPC_FILTERORDER + 1];
 124     int16_t          hpimemx[2];
 125     int16_t          hpimemy[4];
 126 } ILBCContext;
 127
 128 static int unpack_frame(ILBCContext *s)
 129 {
 130     ILBCFrame *frame = &s->frame;
 131     GetBitContext *gb = &s->gb;
 132     int j;
 133
 134     frame->lsf[0] = get_bits(gb, 6);
 135     frame->lsf[1] = get_bits(gb, 7);
 136     frame->lsf[2] = get_bits(gb, 7);
 137
 138     if (s->mode == 20) {
 139         frame->start          = get_bits(gb, 2);
 140         frame->state_first    = get_bits1(gb);
 141         frame->ifm            = get_bits(gb, 6);
 142         frame->cb_index[0]    = get_bits(gb, 6) << 1;
 143         frame->gain_index[0]  = get_bits(gb, 2) << 3;
 144         frame->gain_index[1]  = get_bits1(gb) << 3;
 145         frame->cb_index[3]    = get_bits(gb, 7) << 1;
 146         frame->gain_index[3]  = get_bits1(gb) << 4;
 147         frame->gain_index[4]  = get_bits1(gb) << 3;
 148         frame->gain_index[6]  = get_bits1(gb) << 4;
 149     } else {
 150         frame->lsf[3]         = get_bits(gb, 6);
 151         frame->lsf[4]         = get_bits(gb, 7);
 152         frame->lsf[5]         = get_bits(gb, 7);
 153         frame->start          = get_bits(gb, 3);
 154         frame->state_first    = get_bits1(gb);
 155         frame->ifm            = get_bits(gb, 6);
 156         frame->cb_index[0]    = get_bits(gb, 4) << 3;
 157         frame->gain_index[0]  = get_bits1(gb) << 4;
 158         frame->gain_index[1]  = get_bits1(gb) << 3;
 159         frame->cb_index[3]    = get_bits(gb, 6) << 2;
 160         frame->gain_index[3]  = get_bits1(gb) << 4;
 161         frame->gain_index[4]  = get_bits1(gb) << 3;
 162     }
 163
 164     for (j = 0; j < 48; j++)
 165         frame->idx[j] = get_bits1(gb) << 2;
 166
 167     if (s->mode == 20) {
 168         for (; j < 57; j++)
 169             frame->idx[j] = get_bits1(gb) << 2;
 170
 171         frame->gain_index[1] |= get_bits1(gb) << 2;
 172         frame->gain_index[3] |= get_bits(gb, 2) << 2;
 173         frame->gain_index[4] |= get_bits1(gb) << 2;
 174         frame->gain_index[6] |= get_bits1(gb) << 3;
 175         frame->gain_index[7]  = get_bits(gb, 2) << 2;
 176     } else {
 177         for (; j < 58; j++)
 178             frame->idx[j] = get_bits1(gb) << 2;
 179
 180         frame->cb_index[0]    |= get_bits(gb, 2) << 1;
 181         frame->gain_index[0]  |= get_bits1(gb) << 3;
 182         frame->gain_index[1]  |= get_bits1(gb) << 2;
 183         frame->cb_index[3]    |= get_bits1(gb) << 1;
 184         frame->cb_index[6]     = get_bits1(gb) << 7;
 185         frame->cb_index[6]    |= get_bits(gb, 6) << 1;
 186         frame->cb_index[9]     = get_bits(gb, 7) << 1;
 187         frame->cb_index[12]    = get_bits(gb, 3) << 5;
 188         frame->cb_index[12]   |= get_bits(gb, 4) << 1;
 189         frame->gain_index[3]  |= get_bits(gb, 2) << 2;
 190         frame->gain_index[4]  |= get_bits(gb, 2) << 1;
 191         frame->gain_index[6]   = get_bits(gb, 2) << 3;
 192         frame->gain_index[7]   = get_bits(gb, 2) << 2;
 193         frame->gain_index[9]   = get_bits1(gb) << 4;
 194         frame->gain_index[10]  = get_bits1(gb) << 3;
 195         frame->gain_index[12]  = get_bits1(gb) << 4;
 196         frame->gain_index[13]  = get_bits1(gb) << 3;
 197     }
 198
 199     for (j = 0; j < 56; j++)
 200         frame->idx[j] |= get_bits(gb, 2);
 201
 202     if (s->mode == 20) {
 203         frame->idx[56]        |= get_bits(gb, 2);
 204         frame->cb_index[0]    |= get_bits1(gb);
 205         frame->cb_index[1]     = get_bits(gb, 7);
 206         frame->cb_index[2]     = get_bits(gb, 6) << 1;
 207         frame->cb_index[2]    |= get_bits1(gb);
 208         frame->gain_index[0]  |= get_bits(gb, 3);
 209         frame->gain_index[1]  |= get_bits(gb, 2);
 210         frame->gain_index[2]   = get_bits(gb, 3);
 211         frame->cb_index[3]    |= get_bits1(gb);
 212         frame->cb_index[4]     = get_bits(gb, 6) << 1;
 213         frame->cb_index[4]    |= get_bits1(gb);
 214         frame->cb_index[5]     = get_bits(gb, 7);
 215         frame->cb_index[6]     = get_bits(gb, 8);
 216         frame->cb_index[7]     = get_bits(gb, 8);
 217         frame->cb_index[8]     = get_bits(gb, 8);
 218         frame->gain_index[3]  |= get_bits(gb, 2);
 219         frame->gain_index[4]  |= get_bits(gb, 2);
 220         frame->gain_index[5]   = get_bits(gb, 3);
 221         frame->gain_index[6]  |= get_bits(gb, 3);
 222         frame->gain_index[7]  |= get_bits(gb, 2);
 223         frame->gain_index[8]   = get_bits(gb, 3);
 224     } else {
 225         frame->idx[56]        |= get_bits(gb, 2);
 226         frame->idx[57]        |= get_bits(gb, 2);
 227         frame->cb_index[0]    |= get_bits1(gb);
 228         frame->cb_index[1]     = get_bits(gb, 7);
 229         frame->cb_index[2]     = get_bits(gb, 4) << 3;
 230         frame->cb_index[2]    |= get_bits(gb, 3);
 231         frame->gain_index[0]  |= get_bits(gb, 3);
 232         frame->gain_index[1]  |= get_bits(gb, 2);
 233         frame->gain_index[2]   = get_bits(gb, 3);
 234         frame->cb_index[3]    |= get_bits1(gb);
 235         frame->cb_index[4]     = get_bits(gb, 4) << 3;
 236         frame->cb_index[4]    |= get_bits(gb, 3);
 237         frame->cb_index[5]     = get_bits(gb, 7);
 238         frame->cb_index[6]    |= get_bits1(gb);
 239         frame->cb_index[7]     = get_bits(gb, 5) << 3;
 240         frame->cb_index[7]    |= get_bits(gb, 3);
 241         frame->cb_index[8]     = get_bits(gb, 8);
 242         frame->cb_index[9]    |= get_bits1(gb);
 243         frame->cb_index[10]    = get_bits(gb, 4) << 4;
 244         frame->cb_index[10]   |= get_bits(gb, 4);
 245         frame->cb_index[11]    = get_bits(gb, 8);
 246         frame->cb_index[12]   |= get_bits1(gb);
 247         frame->cb_index[13]    = get_bits(gb, 3) << 5;
 248         frame->cb_index[13]   |= get_bits(gb, 5);
 249         frame->cb_index[14]    = get_bits(gb, 8);
 250         frame->gain_index[3]  |= get_bits(gb, 2);
 251         frame->gain_index[4]  |= get_bits1(gb);
 252         frame->gain_index[5]   = get_bits(gb, 3);
 253         frame->gain_index[6]  |= get_bits(gb, 3);
 254         frame->gain_index[7]  |= get_bits(gb, 2);
 255         frame->gain_index[8]   = get_bits(gb, 3);
 256         frame->gain_index[9]  |= get_bits(gb, 4);
 257         frame->gain_index[10] |= get_bits1(gb) << 2;
 258         frame->gain_index[10] |= get_bits(gb, 2);
 259         frame->gain_index[11]  = get_bits(gb, 3);
 260         frame->gain_index[12] |= get_bits(gb, 4);
 261         frame->gain_index[13] |= get_bits(gb, 3);
 262         frame->gain_index[14]  = get_bits(gb, 3);
 263     }
 264
 265     return get_bits1(gb);
 266 }
 267
 268 static void index_conv(int16_t *index)
 269 {
 270     int k;
 271
 272     for (k = 4; k < 6; k++) {
 273         if (index[k] >= 44 && index[k] < 108) {
 274             index[k] += 64;
 275         } else if (index[k] >= 108 && index[k] < 128) {
 276             index[k] += 128;
 277         }
 278     }
 279 }
 280
 281 static void lsf_dequantization(int16_t *lsfdeq, int16_t *index, int16_t lpc_n)
 282 {
 283     int i, j, pos = 0, cb_pos = 0;
 284
 285     for (i = 0; i < LSF_NSPLIT; i++) {
 286         for (j = 0; j < lsf_dim_codebook[i]; j++) {
 287             lsfdeq[pos + j] = lsf_codebook[cb_pos + index[i] * lsf_dim_codebook[i] + j];
 288         }
 289
 290         pos    += lsf_dim_codebook[i];
 291         cb_pos += lsf_size_codebook[i] * lsf_dim_codebook[i];
 292     }
 293
 294     if (lpc_n > 1) {
 295         pos = 0;
 296         cb_pos = 0;
 297         for (i = 0; i < LSF_NSPLIT; i++) {
 298             for (j = 0; j < lsf_dim_codebook[i]; j++) {
 299                 lsfdeq[LPC_FILTERORDER + pos + j] = lsf_codebook[cb_pos +
 300                     index[LSF_NSPLIT + i] * lsf_dim_codebook[i] + j];
 301             }
 302
 303             pos    += lsf_dim_codebook[i];
 304             cb_pos += lsf_size_codebook[i] * lsf_dim_codebook[i];
 305         }
 306     }
 307 }
 308
 309 static void lsf_check_stability(int16_t *lsf, int dim, int nb_vectors)
 310 {
 311     for (int n = 0; n < 2; n++) {
 312         for (int m = 0; m < nb_vectors; m++) {
 313             for (int k = 0; k < dim - 1; k++) {
 314                 int i = m * dim + k;
 315
 316                 if ((lsf[i + 1] - lsf[i]) < 319) {
 317                     if (lsf[i + 1] < lsf[i]) {
 318                         lsf[i + 1] = lsf[i] + 160;
 319                         lsf[i]     = lsf[i + 1] - 160;
 320                     } else {
 321                         lsf[i]     -= 160;
 322                         lsf[i + 1] += 160;
 323                     }
 324                 }
 325
 326                 lsf[i] = av_clip(lsf[i], 82, 25723);
 327             }
 328         }
 329     }
 330 }
 331
 332 static void lsf_interpolate(int16_t *out, int16_t *in1,
 333                             int16_t *in2, int16_t coef,
 334                             int size)
 335 {
 336     int invcoef = 16384 - coef, i;
 337
 338     for (i = 0; i < size; i++)
 339         out[i] = (coef * in1[i] + invcoef * in2[i] + 8192) >> 14;
 340 }
 341
 342 static void lsf2lsp(int16_t *lsf, int16_t *lsp, int order)
 343 {
 344     int16_t diff, freq;
 345     int32_t tmp;
 346     int i, k;
 347
 348     for (i = 0; i < order; i++) {
 349         freq = (lsf[i] * 20861) >> 15;
 350         /* 20861: 1.0/(2.0*PI) in Q17 */
 351         /*
 352            Upper 8 bits give the index k and
 353            Lower 8 bits give the difference, which needs
 354            to be approximated linearly
 355          */
 356         k = FFMIN(freq >> 8, 63);
 357         diff = freq & 0xFF;
 358
 359         /* Calculate linear approximation */
 360         tmp = cos_derivative_tbl[k] * diff;
 361         lsp[i] = cos_tbl[k] + (tmp >> 12);
 362     }
 363 }
 364
 365 static void get_lsp_poly(int16_t *lsp, int32_t *f)
 366 {
 367     int16_t high, low;
 368     int i, j, k, l;
 369     int32_t tmp;
 370
 371     f[0] = 16777216;
 372     f[1] = lsp[0] * -1024;
 373
 374     for (i = 2, k = 2, l = 2; i <= 5; i++, k += 2) {
 375         f[l] = f[l - 2];
 376
 377         for (j = i; j > 1; j--, l--) {
 378             high = f[l - 1] >> 16;
 379             low = (f[l - 1] - (high * (1 << 16))) >> 1;
 380
 381             tmp = ((high * lsp[k]) * 4) + (((low * lsp[k]) >> 15) * 4);
 382
 383             f[l] += f[l - 2];
 384             f[l] -= (unsigned)tmp;
 385         }
 386
 387         f[l] -= lsp[k] * (1 << 10);
 388         l += i;
 389     }
 390 }
 391
 392 static void lsf2poly(int16_t *a, int16_t *lsf)
 393 {
 394     int32_t f[2][6];
 395     int16_t lsp[10];
 396     int32_t tmp;
 397     int i;
 398
 399     lsf2lsp(lsf, lsp, LPC_FILTERORDER);
 400
 401     get_lsp_poly(&lsp[0], f[0]);
 402     get_lsp_poly(&lsp[1], f[1]);
 403
 404     for (i = 5; i > 0; i--) {
 405         f[0][i] += (unsigned)f[0][i - 1];
 406         f[1][i] -= (unsigned)f[1][i - 1];
 407     }
 408
 409     a[0] = 4096;
 410     for (i = 5; i > 0; i--) {
 411         tmp = f[0][6 - i] + (unsigned)f[1][6 - i] + 4096;
 412         a[6 - i] = tmp >> 13;
 413
 414         tmp = f[0][6 - i] - (unsigned)f[1][6 - i] + 4096;
 415         a[5 + i] = tmp >> 13;
 416     }
 417 }
 418
 419 static void lsp_interpolate2polydec(int16_t *a, int16_t *lsf1,
 420                                    int16_t *lsf2, int coef, int length)
 421 {
 422     int16_t lsftmp[LPC_FILTERORDER];
 423
 424     lsf_interpolate(lsftmp, lsf1, lsf2, coef, length);
 425     lsf2poly(a, lsftmp);
 426 }
 427
 428 static void bw_expand(int16_t *out, const int16_t *in, const int16_t *coef, int length)
 429 {
 430     int i;
 431
 432     out[0] = in[0];
 433     for (i = 1; i < length; i++)
 434         out[i] = (coef[i] * in[i] + 16384) >> 15;
 435 }
 436
 437 static void lsp_interpolate(int16_t *syntdenum, int16_t *weightdenum,
 438                             int16_t *lsfdeq, int16_t length,
 439                             ILBCContext *s)
 440 {
 441     int16_t lp[LPC_FILTERORDER + 1], *lsfdeq2;
 442     int i, pos, lp_length;
 443
 444     lsfdeq2 = lsfdeq + length;
 445     lp_length = length + 1;
 446
 447     if (s->mode == 30) {
 448         lsp_interpolate2polydec(lp, (*s).lsfdeqold, lsfdeq, lsf_weight_30ms[0], length);
 449         memcpy(syntdenum, lp, lp_length * 2);
 450         bw_expand(weightdenum, lp, kLpcChirpSyntDenum, lp_length);
 451
 452         pos = lp_length;
 453         for (i = 1; i < 6; i++) {
 454             lsp_interpolate2polydec(lp, lsfdeq, lsfdeq2,
 455                                                  lsf_weight_30ms[i],
 456                                                  length);
 457             memcpy(syntdenum + pos, lp, lp_length * 2);
 458             bw_expand(weightdenum + pos, lp, kLpcChirpSyntDenum, lp_length);
 459             pos += lp_length;
 460         }
 461     } else {
 462         pos = 0;
 463         for (i = 0; i < s->nsub; i++) {
 464             lsp_interpolate2polydec(lp, s->lsfdeqold, lsfdeq,
 465                                     lsf_weight_20ms[i], length);
 466             memcpy(syntdenum + pos, lp, lp_length * 2);
 467             bw_expand(weightdenum + pos, lp, kLpcChirpSyntDenum, lp_length);
 468             pos += lp_length;
 469         }
 470     }
 471
 472     if (s->mode == 30) {
 473         memcpy(s->lsfdeqold, lsfdeq2, length * 2);
 474     } else {
 475         memcpy(s->lsfdeqold, lsfdeq, length * 2);
 476     }
 477 }
 478
 479 static void filter_mafq12(int16_t *in_ptr, int16_t *out_ptr,
 480                           int16_t *B, int16_t B_length,
 481                           int16_t length)
 482 {
 483     int o, i, j;
 484
 485     for (i = 0; i < length; i++) {
 486         const int16_t *b_ptr = &B[0];
 487         const int16_t *x_ptr = &in_ptr[i];
 488
 489         o = 0;
 490         for (j = 0; j < B_length; j++)
 491             o += b_ptr[j] * *x_ptr--;
 492
 493         o = av_clip(o, -134217728, 134215679);
 494
 495         out_ptr[i] = ((o + 2048) >> 12);
 496     }
 497 }
 498
 499 static void filter_arfq12(const int16_t *data_in,
 500                           int16_t *data_out,
 501                           const int16_t *coefficients,
 502                           int coefficients_length,
 503                           int data_length)
 504 {
 505     int i, j;
 506
 507     for (i = 0; i < data_length; i++) {
 508         int output = 0, sum = 0;
 509
 510         for (j = coefficients_length - 1; j > 0; j--) {
 511             sum += (unsigned)(coefficients[j] * data_out[i - j]);
 512         }
 513
 514         output = coefficients[0] * data_in[i] - (unsigned)sum;
 515         output = av_clip(output, -134217728, 134215679);
 516
 517         data_out[i] = (output + 2048) >> 12;
 518     }
 519 }
 520
 521 static void state_construct(int16_t ifm, int16_t *idx,
 522                            int16_t *synt_denum, int16_t *Out_fix,
 523                            int16_t len)
 524 {
 525     int k;
 526     int16_t maxVal;
 527     int16_t *tmp1, *tmp2, *tmp3;
 528     /* Stack based */
 529     int16_t numerator[1 + LPC_FILTERORDER];
 530     int16_t sampleValVec[2 * STATE_SHORT_LEN_30MS + LPC_FILTERORDER];
 531     int16_t sampleMaVec[2 * STATE_SHORT_LEN_30MS + LPC_FILTERORDER];
 532     int16_t *sampleVal = &sampleValVec[LPC_FILTERORDER];
 533     int16_t *sampleMa = &sampleMaVec[LPC_FILTERORDER];
 534     int16_t *sampleAr = &sampleValVec[LPC_FILTERORDER];
 535
 536     /* initialization of coefficients */
 537
 538     for (k = 0; k < LPC_FILTERORDER + 1; k++) {
 539         numerator[k] = synt_denum[LPC_FILTERORDER - k];
 540     }
 541
 542     /* decoding of the maximum value */
 543
 544     maxVal = frg_quant_mod[ifm];
 545
 546     /* decoding of the sample values */
 547     tmp1 = sampleVal;
 548     tmp2 = &idx[len - 1];
 549
 550     if (ifm < 37) {
 551         for (k = 0; k < len; k++) {
 552             /*the shifting is due to the Q13 in sq4_fixQ13[i], also the adding of 2097152 (= 0.5 << 22)
 553                maxVal is in Q8 and result is in Q(-1) */
 554             (*tmp1) = (int16_t) ((SPL_MUL_16_16(maxVal, ilbc_state[(*tmp2)]) + 2097152) >> 22);
 555             tmp1++;
 556             tmp2--;
 557         }
 558     } else if (ifm < 59) {
 559         for (k = 0; k < len; k++) {
 560             /*the shifting is due to the Q13 in sq4_fixQ13[i], also the adding of 262144 (= 0.5 << 19)
 561                maxVal is in Q5 and result is in Q(-1) */
 562             (*tmp1) = (int16_t) ((SPL_MUL_16_16(maxVal, ilbc_state[(*tmp2)]) + 262144) >> 19);
 563             tmp1++;
 564             tmp2--;
 565         }
 566     } else {
 567         for (k = 0; k < len; k++) {
 568             /*the shifting is due to the Q13 in sq4_fixQ13[i], also the adding of 65536 (= 0.5 << 17)
 569                maxVal is in Q3 and result is in Q(-1) */
 570             (*tmp1) = (int16_t) ((SPL_MUL_16_16(maxVal, ilbc_state[(*tmp2)]) + 65536) >> 17);
 571             tmp1++;
 572             tmp2--;
 573         }
 574     }
 575
 576     /* Set the rest of the data to zero */
 577     memset(&sampleVal[len], 0, len * 2);
 578
 579     /* circular convolution with all-pass filter */
 580
 581     /* Set the state to zero */
 582     memset(sampleValVec, 0, LPC_FILTERORDER * 2);
 583
 584     /* Run MA filter + AR filter */
 585     filter_mafq12(sampleVal, sampleMa, numerator, LPC_FILTERORDER + 1, len + LPC_FILTERORDER);
 586     memset(&sampleMa[len + LPC_FILTERORDER], 0, (len - LPC_FILTERORDER) * 2);
 587     filter_arfq12(sampleMa, sampleAr, synt_denum, LPC_FILTERORDER + 1, 2 * len);
 588
 589     tmp1 = &sampleAr[len - 1];
 590     tmp2 = &sampleAr[2 * len - 1];
 591     tmp3 = Out_fix;
 592     for (k = 0; k < len; k++) {
 593         (*tmp3) = (*tmp1) + (*tmp2);
 594         tmp1--;
 595         tmp2--;
 596         tmp3++;
 597     }
 598 }
 599
 600 static int16_t gain_dequantization(int index, int max_in, int stage)
 601 {
 602     int16_t scale = FFMAX(1638, FFABS(max_in));
 603
 604     return ((scale * ilbc_gain[stage][index]) + 8192) >> 14;
 605 }
 606
 607 static void vector_rmultiplication(int16_t *out, const int16_t *in,
 608                                    const int16_t *win,
 609                                    int length, int shift)
 610 {
 611     for (int i = 0; i < length; i++)
 612         out[i] = (in[i] * win[-i]) >> shift;
 613 }
 614
 615 static void vector_multiplication(int16_t *out, const int16_t *in,
 616                                   const int16_t *win, int length,
 617                                   int shift)
 618 {
 619     for (int i = 0; i < length; i++)
 620         out[i] = (in[i] * win[i]) >> shift;
 621 }
 622
 623 static void add_vector_and_shift(int16_t *out, const int16_t *in1,
 624                                  const int16_t *in2, int length,
 625                                  int shift)
 626 {
 627     for (int i = 0; i < length; i++)
 628         out[i] = (in1[i] + in2[i]) >> shift;
 629 }
 630
 631 static void create_augmented_vector(int index, int16_t *buffer, int16_t *cbVec)
 632 {
 633     int16_t cbVecTmp[4];
 634     int interpolation_length = FFMIN(4, index);
 635     int16_t ilow = index - interpolation_length;
 636
 637     memcpy(cbVec, buffer - index, index * 2);
 638
 639     vector_multiplication(&cbVec[ilow], buffer - index - interpolation_length, alpha, interpolation_length, 15);
 640     vector_rmultiplication(cbVecTmp, buffer - interpolation_length, &alpha[interpolation_length - 1], interpolation_length, 15);
 641     add_vector_and_shift(&cbVec[ilow], &cbVec[ilow], cbVecTmp, interpolation_length, 0);
 642
 643     memcpy(cbVec + index, buffer - index, FFMIN(SUBL - index, index) * sizeof(*cbVec));
 644 }
 645
 646 static void get_codebook(int16_t * cbvec,   /* (o) Constructed codebook vector */
 647                      int16_t * mem,     /* (i) Codebook buffer */
 648                      int16_t index,     /* (i) Codebook index */
 649                      int16_t lMem,      /* (i) Length of codebook buffer */
 650                      int16_t cbveclen   /* (i) Codebook vector length */
 651 )
 652 {
 653     int16_t k, base_size;
 654     int16_t lag;
 655     /* Stack based */
 656     int16_t tempbuff2[SUBL + 5];
 657
 658     /* Determine size of codebook sections */
 659     base_size = lMem - cbveclen + 1;
 660
 661     if (cbveclen == SUBL) {
 662         base_size += cbveclen / 2;
 663     }
 664
 665     /* No filter -> First codebook section */
 666     if (index < lMem - cbveclen + 1) {
 667         /* first non-interpolated vectors */
 668
 669         k = index + cbveclen;
 670         /* get vector */
 671         memcpy(cbvec, mem + lMem - k, cbveclen * 2);
 672     } else if (index < base_size) {
 673
 674         /* Calculate lag */
 675
 676         k = (int16_t) SPL_MUL_16_16(2, (index - (lMem - cbveclen + 1))) + cbveclen;
 677
 678         lag = k / 2;
 679
 680         create_augmented_vector(lag, mem + lMem, cbvec);
 681     } else {
 682         int16_t memIndTest;
 683
 684         /* first non-interpolated vectors */
 685
 686         if (index - base_size < lMem - cbveclen + 1) {
 687
 688             /* Set up filter memory, stuff zeros outside memory buffer */
 689
 690             memIndTest = lMem - (index - base_size + cbveclen);
 691
 692             memset(mem - CB_HALFFILTERLEN, 0, CB_HALFFILTERLEN * 2);
 693             memset(mem + lMem, 0, CB_HALFFILTERLEN * 2);
 694
 695             /* do filtering to get the codebook vector */
 696
 697             filter_mafq12(&mem[memIndTest + 4], cbvec, (int16_t *) kCbFiltersRev, CB_FILTERLEN, cbveclen);
 698         } else {
 699             /* interpolated vectors */
 700             /* Stuff zeros outside memory buffer  */
 701             memIndTest = lMem - cbveclen - CB_FILTERLEN;
 702             memset(mem + lMem, 0, CB_HALFFILTERLEN * 2);
 703
 704             /* do filtering */
 705             filter_mafq12(&mem[memIndTest + 7], tempbuff2, (int16_t *) kCbFiltersRev, CB_FILTERLEN, (int16_t) (cbveclen + 5));
 706
 707             /* Calculate lag index */
 708             lag = (cbveclen << 1) - 20 + index - base_size - lMem - 1;
 709
 710             create_augmented_vector(lag, tempbuff2 + SUBL + 5, cbvec);
 711         }
 712     }
 713 }
 714
 715 static void construct_vector (
 716     int16_t *decvector,   /* (o) Decoded vector */
 717     int16_t *index,       /* (i) Codebook indices */
 718     int16_t *gain_index,  /* (i) Gain quantization indices */
 719     int16_t *mem,         /* (i) Buffer for codevector construction */
 720     int16_t lMem,         /* (i) Length of buffer */
 721     int16_t veclen)
 722 {
 723     int16_t gain[CB_NSTAGES];
 724     int16_t cbvec0[SUBL];
 725     int16_t cbvec1[SUBL];
 726     int16_t cbvec2[SUBL];
 727     unsigned a32;
 728     int16_t *gainPtr;
 729     int j;
 730
 731     /* gain de-quantization */
 732
 733     gain[0] = gain_dequantization(gain_index[0], 16384, 0);
 734     gain[1] = gain_dequantization(gain_index[1], gain[0], 1);
 735     gain[2] = gain_dequantization(gain_index[2], gain[1], 2);
 736
 737     /* codebook vector construction and construction of total vector */
 738
 739     /* Stack based */
 740     get_codebook(cbvec0, mem, index[0], lMem, veclen);
 741     get_codebook(cbvec1, mem, index[1], lMem, veclen);
 742     get_codebook(cbvec2, mem, index[2], lMem, veclen);
 743
 744     gainPtr = &gain[0];
 745     for (j = 0; j < veclen; j++) {
 746         a32 = SPL_MUL_16_16(*gainPtr++, cbvec0[j]);
 747         a32 += SPL_MUL_16_16(*gainPtr++, cbvec1[j]);
 748         a32 += SPL_MUL_16_16(*gainPtr, cbvec2[j]);
 749         gainPtr -= 2;
 750         decvector[j] = (int)(a32 + 8192) >> 14;
 751     }
 752 }
 753
 754 static void reverse_memcpy(int16_t *dest, int16_t *source, int length)
 755 {
 756     int16_t* destPtr = dest;
 757     int16_t* sourcePtr = source;
 758     int j;
 759
 760     for (j = 0; j < length; j++)
 761         *destPtr-- = *sourcePtr++;
 762 }
 763
 764 static void decode_residual(ILBCContext *s,
 765                             ILBCFrame *encbits,
 766                             int16_t *decresidual,
 767                             int16_t *syntdenum)
 768 {
 769     int16_t meml_gotten, Nfor, Nback, diff, start_pos;
 770     int16_t subcount, subframe;
 771     int16_t *reverseDecresidual = s->enh_buf;        /* Reversed decoded data, used for decoding backwards in time (reuse memory in state) */
 772     int16_t *memVec = s->prevResidual;
 773     int16_t *mem = &memVec[CB_HALFFILTERLEN];   /* Memory for codebook */
 774
 775     diff = STATE_LEN - s->state_short_len;
 776
 777     if (encbits->state_first == 1) {
 778         start_pos = (encbits->start - 1) * SUBL;
 779     } else {
 780         start_pos = (encbits->start - 1) * SUBL + diff;
 781     }
 782
 783     /* decode scalar part of start state */
 784
 785     state_construct(encbits->ifm, encbits->idx, &syntdenum[(encbits->start - 1) * (LPC_FILTERORDER + 1)], &decresidual[start_pos], s->state_short_len);
 786
 787     if (encbits->state_first) { /* put adaptive part in the end */
 788         /* setup memory */
 789         memset(mem, 0, (int16_t) (CB_MEML - s->state_short_len) * 2);
 790         memcpy(mem + CB_MEML - s->state_short_len, decresidual + start_pos, s->state_short_len * 2);
 791
 792         /* construct decoded vector */
 793
 794         construct_vector(&decresidual[start_pos + s->state_short_len], encbits->cb_index, encbits->gain_index, mem + CB_MEML - ST_MEM_L_TBL, ST_MEM_L_TBL, (int16_t) diff);
 795
 796     } else { /* put adaptive part in the beginning */
 797         /* setup memory */
 798         meml_gotten = s->state_short_len;
 799         reverse_memcpy(mem + CB_MEML - 1, decresidual + start_pos, meml_gotten);
 800         memset(mem, 0, (int16_t) (CB_MEML - meml_gotten) * 2);
 801
 802         /* construct decoded vector */
 803         construct_vector(reverseDecresidual, encbits->cb_index, encbits->gain_index, mem + CB_MEML - ST_MEM_L_TBL, ST_MEM_L_TBL, diff);
 804
 805         /* get decoded residual from reversed vector */
 806         reverse_memcpy(&decresidual[start_pos - 1], reverseDecresidual, diff);
 807     }
 808
 809     /* counter for predicted subframes */
 810     subcount = 1;
 811
 812     /* forward prediction of subframes */
 813     Nfor = s->nsub - encbits->start - 1;
 814
 815     if (Nfor > 0) {
 816         /* setup memory */
 817         memset(mem, 0, (CB_MEML - STATE_LEN) * 2);
 818         memcpy(mem + CB_MEML - STATE_LEN, decresidual + (encbits->start - 1) * SUBL, STATE_LEN * 2);
 819
 820         /* loop over subframes to encode */
 821         for (subframe = 0; subframe < Nfor; subframe++) {
 822             /* construct decoded vector */
 823             construct_vector(&decresidual[(encbits->start + 1 + subframe) * SUBL], encbits->cb_index + subcount * CB_NSTAGES, encbits->gain_index + subcount * CB_NSTAGES, mem, MEM_LF_TBL, SUBL);
 824
 825             /* update memory */
 826             memmove(mem, mem + SUBL, (CB_MEML - SUBL) * sizeof(*mem));
 827             memcpy(mem + CB_MEML - SUBL, &decresidual[(encbits->start + 1 + subframe) * SUBL], SUBL * 2);
 828
 829             subcount++;
 830         }
 831
 832     }
 833
 834     /* backward prediction of subframes */
 835     Nback = encbits->start - 1;
 836
 837     if (Nback > 0) {
 838         /* setup memory */
 839         meml_gotten = SUBL * (s->nsub + 1 - encbits->start);
 840         if (meml_gotten > CB_MEML) {
 841             meml_gotten = CB_MEML;
 842         }
 843
 844         reverse_memcpy(mem + CB_MEML - 1, decresidual + (encbits->start - 1) * SUBL, meml_gotten);
 845         memset(mem, 0, (int16_t) (CB_MEML - meml_gotten) * 2);
 846
 847         /* loop over subframes to decode */
 848         for (subframe = 0; subframe < Nback; subframe++) {
 849             /* construct decoded vector */
 850             construct_vector(&reverseDecresidual[subframe * SUBL], encbits->cb_index + subcount * CB_NSTAGES,
 851                         encbits->gain_index + subcount * CB_NSTAGES, mem, MEM_LF_TBL, SUBL);
 852
 853             /* update memory */
 854             memmove(mem, mem + SUBL, (CB_MEML - SUBL) * sizeof(*mem));
 855             memcpy(mem + CB_MEML - SUBL, &reverseDecresidual[subframe * SUBL], SUBL * 2);
 856
 857             subcount++;
 858         }
 859
 860         /* get decoded residual from reversed vector */
 861         reverse_memcpy(decresidual + SUBL * Nback - 1, reverseDecresidual, SUBL * Nback);
 862     }
 863 }
 864
 865 static int16_t max_abs_value_w16(const int16_t* vector, int length)
 866 {
 867     int i = 0, absolute = 0, maximum = 0;
 868
 869     if (vector == NULL || length <= 0) {
 870         return -1;
 871     }
 872
 873     for (i = 0; i < length; i++) {
 874         absolute = FFABS(vector[i]);
 875         if (absolute > maximum)
 876             maximum = absolute;
 877     }
 878
 879     // Guard the case for abs(-32768).
 880     return FFMIN(maximum, INT16_MAX);
 881 }
 882
 883 static int16_t get_size_in_bits(uint32_t n)
 884 {
 885     int16_t bits;
 886
 887     if (0xFFFF0000 & n) {
 888         bits = 16;
 889     } else {
 890         bits = 0;
 891     }
 892
 893     if (0x0000FF00 & (n >> bits)) bits += 8;
 894     if (0x000000F0 & (n >> bits)) bits += 4;
 895     if (0x0000000C & (n >> bits)) bits += 2;
 896     if (0x00000002 & (n >> bits)) bits += 1;
 897     if (0x00000001 & (n >> bits)) bits += 1;
 898
 899     return bits;
 900 }
 901
 902 static int32_t scale_dot_product(const int16_t *v1, const int16_t *v2, int length, int scaling)
 903 {
 904     int64_t sum = 0;
 905
 906     for (int i = 0; i < length; i++)
 907         sum += (v1[i] * v2[i]) >> scaling;
 908
 909     return av_clipl_int32(sum);
 910 }
 911
 912 static void correlation(int32_t *corr, int32_t *ener, int16_t *buffer,
 913                         int16_t lag, int16_t blen, int16_t srange, int16_t scale)
 914 {
 915     int16_t *w16ptr;
 916
 917     w16ptr = &buffer[blen - srange - lag];
 918
 919     *corr = scale_dot_product(&buffer[blen - srange], w16ptr, srange, scale);
 920     *ener = scale_dot_product(w16ptr, w16ptr, srange, scale);
 921
 922     if (*ener == 0) {
 923         *corr = 0;
 924         *ener = 1;
 925     }
 926 }
 927
 928 #define SPL_SHIFT_W32(x, c) (((c) >= 0) ? ((x) << (c)) : ((x) >> (-(c))))
 929
 930 static int16_t norm_w32(int32_t a)
 931 {
 932     if (a == 0) {
 933         return 0;
 934     } else if (a < 0) {
 935         a = ~a;
 936     }
 937
 938     return ff_clz(a);
 939 }
 940
 941 static int32_t div_w32_w16(int32_t num, int16_t den)
 942 {
 943     if (den != 0)
 944         return num / den;
 945     else
 946         return 0x7FFFFFFF;
 947 }
 948
 949 static void do_plc(int16_t *plc_residual,      /* (o) concealed residual */
 950                    int16_t *plc_lpc,           /* (o) concealed LP parameters */
 951                    int16_t PLI,                /* (i) packet loss indicator
 952                                                       0 - no PL, 1 = PL */
 953                    int16_t *decresidual,       /* (i) decoded residual */
 954                    int16_t *lpc,               /* (i) decoded LPC (only used for no PL) */
 955                    int16_t inlag,              /* (i) pitch lag */
 956                    ILBCContext *s)             /* (i/o) decoder instance */
 957 {
 958     int16_t i, pick;
 959     int32_t cross, ener, cross_comp, ener_comp = 0;
 960     int32_t measure, max_measure, energy;
 961     int16_t max, cross_square_max, cross_square;
 962     int16_t j, lag, tmp1, tmp2, randlag;
 963     int16_t shift1, shift2, shift3, shift_max;
 964     int16_t scale3;
 965     int16_t corrLen;
 966     int32_t tmpW32, tmp2W32;
 967     int16_t use_gain;
 968     int16_t tot_gain;
 969     int16_t max_perSquare;
 970     int16_t scale1, scale2;
 971     int16_t totscale;
 972     int32_t nom;
 973     int16_t denom;
 974     int16_t pitchfact;
 975     int16_t use_lag;
 976     int ind;
 977     int16_t randvec[BLOCKL_MAX];
 978
 979     /* Packet Loss */
 980     if (PLI == 1) {
 981
 982         s->consPLICount += 1;
 983
 984         /* if previous frame not lost,
 985            determine pitch pred. gain */
 986
 987         if (s->prevPLI != 1) {
 988
 989             /* Maximum 60 samples are correlated, preserve as high accuracy
 990                as possible without getting overflow */
 991             max = max_abs_value_w16(s->prevResidual, s->block_samples);
 992             scale3 = (get_size_in_bits(max) << 1) - 25;
 993             if (scale3 < 0) {
 994                 scale3 = 0;
 995             }
 996
 997             /* Store scale for use when interpolating between the
 998              * concealment and the received packet */
 999             s->prevScale = scale3;
1000
1001             /* Search around the previous lag +/-3 to find the
1002                best pitch period */
1003             lag = inlag - 3;
1004
1005             /* Guard against getting outside the frame */
1006             corrLen = FFMIN(60, s->block_samples - (inlag + 3));
1007
1008             correlation(&cross, &ener, s->prevResidual, lag, s->block_samples, corrLen, scale3);
1009
1010             /* Normalize and store cross^2 and the number of shifts */
1011             shift_max = get_size_in_bits(FFABS(cross)) - 15;
1012             cross_square_max = (int16_t) SPL_MUL_16_16_RSFT(SPL_SHIFT_W32(cross, -shift_max), SPL_SHIFT_W32(cross, -shift_max), 15);
1013
1014             for (j = inlag - 2; j <= inlag + 3; j++) {
1015                 correlation(&cross_comp, &ener_comp, s->prevResidual, j, s->block_samples, corrLen, scale3);
1016
1017                 /* Use the criteria (corr*corr)/energy to compare if
1018                    this lag is better or not. To avoid the division,
1019                    do a cross multiplication */
1020                 shift1 = get_size_in_bits(FFABS(cross_comp)) - 15;
1021                 cross_square = (int16_t) SPL_MUL_16_16_RSFT(SPL_SHIFT_W32(cross_comp, -shift1), SPL_SHIFT_W32(cross_comp, -shift1), 15);
1022
1023                 shift2 = get_size_in_bits(ener) - 15;
1024                 measure = SPL_MUL_16_16(SPL_SHIFT_W32(ener, -shift2), cross_square);
1025
1026                 shift3 = get_size_in_bits(ener_comp) - 15;
1027                 max_measure = SPL_MUL_16_16(SPL_SHIFT_W32(ener_comp, -shift3), cross_square_max);
1028
1029                 /* Calculate shift value, so that the two measures can
1030                    be put in the same Q domain */
1031                 if (((shift_max << 1) + shift3) > ((shift1 << 1) + shift2)) {
1032                     tmp1 = FFMIN(31, (shift_max << 1) + shift3 - (shift1 << 1) - shift2);
1033                     tmp2 = 0;
1034                 } else {
1035                     tmp1 = 0;
1036                     tmp2 = FFMIN(31, (shift1 << 1) + shift2 - (shift_max << 1) - shift3);
1037                 }
1038
1039                 if ((measure >> tmp1) > (max_measure >> tmp2)) {
1040                     /* New lag is better => record lag, measure and domain */
1041                     lag = j;
1042                     cross_square_max = cross_square;
1043                     cross = cross_comp;
1044                     shift_max = shift1;
1045                     ener = ener_comp;
1046                 }
1047             }
1048
1049             /* Calculate the periodicity for the lag with the maximum correlation.
1050
1051                Definition of the periodicity:
1052                abs(corr(vec1, vec2))/(sqrt(energy(vec1))*sqrt(energy(vec2)))
1053
1054                Work in the Square domain to simplify the calculations
1055                max_perSquare is less than 1 (in Q15)
1056              */
1057             tmp2W32 = scale_dot_product(&s->prevResidual[s->block_samples - corrLen], &s->prevResidual[s->block_samples - corrLen], corrLen, scale3);
1058
1059             if ((tmp2W32 > 0) && (ener_comp > 0)) {
1060                 /* norm energies to int16_t, compute the product of the energies and
1061                    use the upper int16_t as the denominator */
1062
1063                 scale1 = norm_w32(tmp2W32) - 16;
1064                 tmp1 = SPL_SHIFT_W32(tmp2W32, scale1);
1065
1066                 scale2 = norm_w32(ener) - 16;
1067                 tmp2 =  SPL_SHIFT_W32(ener, scale2);
1068                 denom = SPL_MUL_16_16_RSFT(tmp1, tmp2, 16);    /* denom in Q(scale1+scale2-16) */
1069
1070                 /* Square the cross correlation and norm it such that max_perSquare
1071                    will be in Q15 after the division */
1072
1073                 totscale = scale1 + scale2 - 1;
1074                 tmp1 = SPL_SHIFT_W32(cross, (totscale >> 1));
1075                 tmp2 = SPL_SHIFT_W32(cross, totscale - (totscale >> 1));
1076
1077                 nom = SPL_MUL_16_16(tmp1, tmp2);
1078                 max_perSquare = div_w32_w16(nom, denom);
1079             } else {
1080                 max_perSquare = 0;
1081             }
1082         } else {
1083             /* previous frame lost, use recorded lag and gain */
1084             lag = s->prevLag;
1085             max_perSquare = s->per_square;
1086         }
1087
1088         /* Attenuate signal and scale down pitch pred gain if
1089            several frames lost consecutively */
1090
1091         use_gain = 32767;       /* 1.0 in Q15 */
1092
1093         if (s->consPLICount * s->block_samples > 320) {
1094             use_gain = 29491;   /* 0.9 in Q15 */
1095         } else if (s->consPLICount * s->block_samples > 640) {
1096             use_gain = 22938;   /* 0.7 in Q15 */
1097         } else if (s->consPLICount * s->block_samples > 960) {
1098             use_gain = 16384;   /* 0.5 in Q15 */
1099         } else if (s->consPLICount * s->block_samples > 1280) {
1100             use_gain = 0;       /* 0.0 in Q15 */
1101         }
1102
1103         /* Compute mixing factor of picth repeatition and noise:
1104            for max_per>0.7 set periodicity to 1.0
1105            0.4<max_per<0.7 set periodicity to (maxper-0.4)/0.7-0.4)
1106            max_per<0.4 set periodicity to 0.0
1107          */
1108
1109         if (max_perSquare > 7868) {     /* periodicity > 0.7  (0.7^4=0.2401 in Q15) */
1110             pitchfact = 32767;
1111         } else if (max_perSquare > 839) {       /* 0.4 < periodicity < 0.7 (0.4^4=0.0256 in Q15) */
1112             /* find best index and interpolate from that */
1113             ind = 5;
1114             while ((max_perSquare < kPlcPerSqr[ind]) && (ind > 0)) {
1115                 ind--;
1116             }
1117             /* pitch fact is approximated by first order */
1118             tmpW32 = kPlcPitchFact[ind] + SPL_MUL_16_16_RSFT(kPlcPfSlope[ind], (max_perSquare - kPlcPerSqr[ind]), 11);
1119
1120             pitchfact = FFMIN(tmpW32, 32767); /* guard against overflow */
1121
1122         } else {                /* periodicity < 0.4 */
1123             pitchfact = 0;
1124         }
1125
1126         /* avoid repetition of same pitch cycle (buzzyness) */
1127         use_lag = lag;
1128         if (lag < 80) {
1129             use_lag = 2 * lag;
1130         }
1131
1132         /* compute concealed residual */
1133         energy = 0;
1134
1135         for (i = 0; i < s->block_samples; i++) {
1136             /* noise component -  52 < randlagFIX < 117 */
1137             s->seed = SPL_MUL_16_16(s->seed, 31821) + 13849;
1138             randlag = 53 + (s->seed & 63);
1139
1140             pick = i - randlag;
1141
1142             if (pick < 0) {
1143                 randvec[i] = s->prevResidual[s->block_samples + pick];
1144             } else {
1145                 randvec[i] = s->prevResidual[pick];
1146             }
1147
1148             /* pitch repeatition component */
1149             pick = i - use_lag;
1150
1151             if (pick < 0) {
1152                 plc_residual[i] = s->prevResidual[s->block_samples + pick];
1153             } else {
1154                 plc_residual[i] = plc_residual[pick];
1155             }
1156
1157             /* Attinuate total gain for each 10 ms */
1158             if (i < 80) {
1159                 tot_gain = use_gain;
1160             } else if (i < 160) {
1161                 tot_gain = SPL_MUL_16_16_RSFT(31130, use_gain, 15);    /* 0.95*use_gain */
1162             } else {
1163                 tot_gain = SPL_MUL_16_16_RSFT(29491, use_gain, 15);    /* 0.9*use_gain */
1164             }
1165
1166             /* mix noise and pitch repeatition */
1167             plc_residual[i] = SPL_MUL_16_16_RSFT(tot_gain, (pitchfact * plc_residual[i] + (32767 - pitchfact) * randvec[i] + 16384) >> 15, 15);
1168
1169             /* Shifting down the result one step extra to ensure that no overflow
1170                will occur */
1171             energy += SPL_MUL_16_16_RSFT(plc_residual[i], plc_residual[i], (s->prevScale + 1));
1172
1173         }
1174
1175         /* less than 30 dB, use only noise */
1176         if (energy < SPL_SHIFT_W32(s->block_samples * 900, -s->prevScale - 1)) {
1177             energy = 0;
1178             for (i = 0; i < s->block_samples; i++) {
1179                 plc_residual[i] = randvec[i];
1180             }
1181         }
1182
1183         /* use the old LPC */
1184         memcpy(plc_lpc, (*s).prev_lpc, (LPC_FILTERORDER + 1) * 2);
1185
1186         /* Update state in case there are multiple frame losses */
1187         s->prevLag = lag;
1188         s->per_square = max_perSquare;
1189     } else { /* no packet loss, copy input */
1190         memcpy(plc_residual, decresidual, s->block_samples * 2);
1191         memcpy(plc_lpc, lpc, (LPC_FILTERORDER + 1) * 2);
1192         s->consPLICount = 0;
1193     }
1194
1195     /* update state */
1196     s->prevPLI = PLI;
1197     memcpy(s->prev_lpc, plc_lpc, (LPC_FILTERORDER + 1) * 2);
1198     memcpy(s->prevResidual, plc_residual, s->block_samples * 2);
1199
1200     return;
1201 }
1202
1203 static int xcorr_coeff(int16_t *target, int16_t *regressor,
1204                        int16_t subl, int16_t searchLen,
1205                        int16_t offset, int16_t step)
1206 {
1207     int16_t maxlag;
1208     int16_t pos;
1209     int16_t max;
1210     int16_t cross_corr_scale, energy_scale;
1211     int16_t cross_corr_sg_mod, cross_corr_sg_mod_max;
1212     int32_t cross_corr, energy;
1213     int16_t cross_corr_mod, energy_mod, enery_mod_max;
1214     int16_t *tp, *rp;
1215     int16_t *rp_beg, *rp_end;
1216     int16_t totscale, totscale_max;
1217     int16_t scalediff;
1218     int32_t new_crit, max_crit;
1219     int shifts;
1220     int k;
1221
1222     /* Initializations, to make sure that the first one is selected */
1223     cross_corr_sg_mod_max = 0;
1224     enery_mod_max = INT16_MAX;
1225     totscale_max = -500;
1226     maxlag = 0;
1227     pos = 0;
1228
1229     /* Find scale value and start position */
1230     if (step == 1) {
1231         max = max_abs_value_w16(regressor, (int16_t) (subl + searchLen - 1));
1232         rp_beg = regressor;
1233         rp_end = &regressor[subl];
1234     } else {                    /* step== -1 */
1235         max = max_abs_value_w16(&regressor[-searchLen], (int16_t) (subl + searchLen - 1));
1236         rp_beg = &regressor[-1];
1237         rp_end = &regressor[subl - 1];
1238     }
1239
1240     /* Introduce a scale factor on the energy in int32_t in
1241        order to make sure that the calculation does not
1242        overflow */
1243
1244     if (max > 5000) {
1245         shifts = 2;
1246     } else {
1247         shifts = 0;
1248     }
1249
1250     /* Calculate the first energy, then do a +/- to get the other energies */
1251     energy = scale_dot_product(regressor, regressor, subl, shifts);
1252
1253     for (k = 0; k < searchLen; k++) {
1254         tp = target;
1255         rp = &regressor[pos];
1256
1257         cross_corr = scale_dot_product(tp, rp, subl, shifts);
1258
1259         if ((energy > 0) && (cross_corr > 0)) {
1260             /* Put cross correlation and energy on 16 bit word */
1261             cross_corr_scale = norm_w32(cross_corr) - 16;
1262             cross_corr_mod = (int16_t) SPL_SHIFT_W32(cross_corr, cross_corr_scale);
1263             energy_scale = norm_w32(energy) - 16;
1264             energy_mod = (int16_t) SPL_SHIFT_W32(energy, energy_scale);
1265
1266             /* Square cross correlation and store upper int16_t */
1267             cross_corr_sg_mod = (int16_t) SPL_MUL_16_16_RSFT(cross_corr_mod, cross_corr_mod, 16);
1268
1269             /* Calculate the total number of (dynamic) right shifts that have
1270                been performed on (cross_corr*cross_corr)/energy
1271              */
1272             totscale = energy_scale - (cross_corr_scale * 2);
1273
1274             /* Calculate the shift difference in order to be able to compare the two
1275                (cross_corr*cross_corr)/energy in the same domain
1276              */
1277             scalediff = totscale - totscale_max;
1278             scalediff = FFMIN(scalediff, 31);
1279             scalediff = FFMAX(scalediff, -31);
1280
1281             /* Compute the cross multiplication between the old best criteria
1282                and the new one to be able to compare them without using a
1283                division */
1284
1285             if (scalediff < 0) {
1286                 new_crit = ((int32_t) cross_corr_sg_mod * enery_mod_max) >> (-scalediff);
1287                 max_crit = ((int32_t) cross_corr_sg_mod_max * energy_mod);
1288             } else {
1289                 new_crit = ((int32_t) cross_corr_sg_mod * enery_mod_max);
1290                 max_crit = ((int32_t) cross_corr_sg_mod_max * energy_mod) >> scalediff;
1291             }
1292
1293             /* Store the new lag value if the new criteria is larger
1294                than previous largest criteria */
1295
1296             if (new_crit > max_crit) {
1297                 cross_corr_sg_mod_max = cross_corr_sg_mod;
1298                 enery_mod_max = energy_mod;
1299                 totscale_max = totscale;
1300                 maxlag = k;
1301             }
1302         }
1303         pos += step;
1304
1305         /* Do a +/- to get the next energy */
1306         energy += (unsigned)step * ((*rp_end * *rp_end - *rp_beg * *rp_beg) >> shifts);
1307
1308         rp_beg += step;
1309         rp_end += step;
1310     }
1311
1312     return maxlag + offset;
1313 }
1314
1315 static void hp_output(int16_t *signal, const int16_t *ba, int16_t *y,
1316                       int16_t *x, int16_t len)
1317 {
1318     int32_t tmp;
1319
1320     for (int i = 0; i < len; i++) {
1321         tmp = SPL_MUL_16_16(y[1], ba[3]);     /* (-a[1])*y[i-1] (low part) */
1322         tmp += SPL_MUL_16_16(y[3], ba[4]);    /* (-a[2])*y[i-2] (low part) */
1323         tmp = (tmp >> 15);
1324         tmp += SPL_MUL_16_16(y[0], ba[3]);    /* (-a[1])*y[i-1] (high part) */
1325         tmp += SPL_MUL_16_16(y[2], ba[4]);    /* (-a[2])*y[i-2] (high part) */
1326         tmp = (tmp * 2);
1327
1328         tmp += SPL_MUL_16_16(signal[i], ba[0]);       /* b[0]*x[0] */
1329         tmp += SPL_MUL_16_16(x[0], ba[1]);    /* b[1]*x[i-1] */
1330         tmp += SPL_MUL_16_16(x[1], ba[2]);    /* b[2]*x[i-2] */
1331
1332         /* Update state (input part) */
1333         x[1] = x[0];
1334         x[0] = signal[i];
1335
1336         /* Convert back to Q0 and multiply with 2 */
1337         signal[i] = av_clip_intp2(tmp + 1024, 26) >> 11;
1338
1339         /* Update state (filtered part) */
1340         y[2] = y[0];
1341         y[3] = y[1];
1342
1343         /* upshift tmp by 3 with saturation */
1344         if (tmp > 268435455) {
1345             tmp = INT32_MAX;
1346         } else if (tmp < -268435456) {
1347             tmp = INT32_MIN;
1348         } else {
1349             tmp = tmp * 8;
1350         }
1351
1352         y[0] = tmp >> 16;
1353         y[1] = (tmp - (y[0] * (1 << 16))) >> 1;
1354     }
1355 }
1356
1357 static int ilbc_decode_frame(AVCodecContext *avctx, void *data,
1358                              int *got_frame_ptr, AVPacket *avpkt)
1359 {
1360     const uint8_t *buf = avpkt->data;
1361     AVFrame *frame     = data;
1362     ILBCContext *s     = avctx->priv_data;
1363     int mode = s->mode, ret;
1364     int16_t *plc_data = &s->plc_residual[LPC_FILTERORDER];
1365
1366     if ((ret = init_get_bits8(&s->gb, buf, avpkt->size)) < 0)
1367         return ret;
1368     memset(&s->frame, 0, sizeof(ILBCFrame));
1369
1370     frame->nb_samples = s->block_samples;
1371     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1372         return ret;
1373
1374     if (unpack_frame(s))
1375         mode = 0;
1376     if (s->frame.start < 1 || s->frame.start > 5)
1377         mode = 0;
1378
1379     if (mode) {
1380         index_conv(s->frame.cb_index);
1381
1382         lsf_dequantization(s->lsfdeq, s->frame.lsf, s->lpc_n);
1383         lsf_check_stability(s->lsfdeq, LPC_FILTERORDER, s->lpc_n);
1384         lsp_interpolate(s->syntdenum, s->weightdenum,
1385                         s->lsfdeq, LPC_FILTERORDER, s);
1386         decode_residual(s, &s->frame, s->decresidual, s->syntdenum);
1387
1388         do_plc(s->plc_residual, s->plc_lpc, 0,
1389                                s->decresidual, s->syntdenum + (LPC_FILTERORDER + 1) * (s->nsub - 1),
1390                                s->last_lag, s);
1391
1392         memcpy(s->decresidual, s->plc_residual, s->block_samples * 2);
1393     }
1394
1395     if (s->enhancer) {
1396         /* TODO */
1397     } else {
1398         int16_t lag, i;
1399
1400         /* Find last lag (since the enhancer is not called to give this info) */
1401         if (s->mode == 20) {
1402             lag = xcorr_coeff(&s->decresidual[s->block_samples-60], &s->decresidual[s->block_samples-80],
1403                               60, 80, 20, -1);
1404         } else {
1405             lag = xcorr_coeff(&s->decresidual[s->block_samples-ENH_BLOCKL],
1406                               &s->decresidual[s->block_samples-ENH_BLOCKL-20],
1407                               ENH_BLOCKL, 100, 20, -1);
1408         }
1409
1410         /* Store lag (it is needed if next packet is lost) */
1411         s->last_lag = lag;
1412
1413         /* copy data and run synthesis filter */
1414         memcpy(plc_data, s->decresidual, s->block_samples * 2);
1415
1416         /* Set up the filter state */
1417         memcpy(&plc_data[-LPC_FILTERORDER], s->syntMem, LPC_FILTERORDER * 2);
1418
1419         for (i = 0; i < s->nsub; i++) {
1420             filter_arfq12(plc_data+i*SUBL, plc_data+i*SUBL,
1421                                       s->syntdenum + i*(LPC_FILTERORDER + 1),
1422                                       LPC_FILTERORDER + 1, SUBL);
1423         }
1424
1425         /* Save the filter state */
1426         memcpy(s->syntMem, &plc_data[s->block_samples-LPC_FILTERORDER], LPC_FILTERORDER * 2);
1427     }
1428
1429     memcpy(frame->data[0], plc_data, s->block_samples * 2);
1430
1431     hp_output((int16_t *)frame->data[0], hp_out_coeffs,
1432               s->hpimemy, s->hpimemx, s->block_samples);
1433
1434     memcpy(s->old_syntdenum, s->syntdenum, s->nsub*(LPC_FILTERORDER + 1) * 2);
1435
1436     s->prev_enh_pl = 0;
1437     if (mode == 0)
1438         s->prev_enh_pl = 1;
1439
1440     *got_frame_ptr = 1;
1441
1442     return avpkt->size;
1443 }
1444
1445 static av_cold int ilbc_decode_init(AVCodecContext *avctx)
1446 {
1447     ILBCContext *s  = avctx->priv_data;
1448
1449     if (avctx->block_align == 38)
1450         s->mode = 20;
1451     else if (avctx->block_align == 50)
1452         s->mode = 30;
1453     else if (avctx->bit_rate > 0)
1454         s->mode = avctx->bit_rate <= 14000 ? 30 : 20;
1455     else
1456         return AVERROR_INVALIDDATA;
1457
1458     avctx->channels       = 1;
1459     avctx->channel_layout = AV_CH_LAYOUT_MONO;
1460     avctx->sample_rate    = 8000;
1461     avctx->sample_fmt     = AV_SAMPLE_FMT_S16;
1462
1463     if (s->mode == 30) {
1464         s->block_samples = 240;
1465         s->nsub = NSUB_30MS;
1466         s->nasub = NASUB_30MS;
1467         s->lpc_n = LPC_N_30MS;
1468         s->state_short_len = STATE_SHORT_LEN_30MS;
1469     } else {
1470         s->block_samples = 160;
1471         s->nsub = NSUB_20MS;
1472         s->nasub = NASUB_20MS;
1473         s->lpc_n = LPC_N_20MS;
1474         s->state_short_len = STATE_SHORT_LEN_20MS;
1475     }
1476
1477     return 0;
1478 }
1479
1480 AVCodec ff_ilbc_decoder = {
1481     .name           = "ilbc",
1482     .long_name      = NULL_IF_CONFIG_SMALL("iLBC (Internet Low Bitrate Codec)"),
1483     .type           = AVMEDIA_TYPE_AUDIO,
1484     .id             = AV_CODEC_ID_ILBC,
1485     .init           = ilbc_decode_init,
1486     .decode         = ilbc_decode_frame,
1487     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1488     .priv_data_size = sizeof(ILBCContext),
1489 };