GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/ilbcdec.c Lines: 0 664 0.0 %
Date: 2019-11-22 03:34:36 Branches: 0 278 0.0 %

Line Branch Exec Source
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,
1488
    .priv_data_size = sizeof(ILBCContext),
1489
};