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
unpack_frame(ILBCContext * s)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
index_conv(int16_t * index)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
lsf_dequantization(int16_t * lsfdeq,int16_t * index,int16_t lpc_n)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
lsf_check_stability(int16_t * lsf,int dim,int nb_vectors)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
lsf_interpolate(int16_t * out,int16_t * in1,int16_t * in2,int16_t coef,int size)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
lsf2lsp(int16_t * lsf,int16_t * lsp,int order)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
get_lsp_poly(int16_t * lsp,int32_t * f)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
lsf2poly(int16_t * a,int16_t * lsf)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
lsp_interpolate2polydec(int16_t * a,int16_t * lsf1,int16_t * lsf2,int coef,int length)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
bw_expand(int16_t * out,const int16_t * in,const int16_t * coef,int length)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
lsp_interpolate(int16_t * syntdenum,int16_t * weightdenum,int16_t * lsfdeq,int16_t length,ILBCContext * s)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
filter_mafq12(int16_t * in_ptr,int16_t * out_ptr,int16_t * B,int16_t B_length,int16_t length)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
filter_arfq12(const int16_t * data_in,int16_t * data_out,const int16_t * coefficients,int coefficients_length,int data_length)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
state_construct(int16_t ifm,int16_t * idx,int16_t * synt_denum,int16_t * Out_fix,int16_t len)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
gain_dequantization(int index,int max_in,int stage)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
vector_rmultiplication(int16_t * out,const int16_t * in,const int16_t * win,int length,int shift)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
vector_multiplication(int16_t * out,const int16_t * in,const int16_t * win,int length,int shift)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
add_vector_and_shift(int16_t * out,const int16_t * in1,const int16_t * in2,int length,int shift)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
create_augmented_vector(int index,int16_t * buffer,int16_t * cbVec)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
get_codebook(int16_t * cbvec,int16_t * mem,int16_t index,int16_t lMem,int16_t cbveclen)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
construct_vector(int16_t * decvector,int16_t * index,int16_t * gain_index,int16_t * mem,int16_t lMem,int16_t veclen)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
reverse_memcpy(int16_t * dest,int16_t * source,int length)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
decode_residual(ILBCContext * s,ILBCFrame * encbits,int16_t * decresidual,int16_t * syntdenum)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
max_abs_value_w16(const int16_t * vector,int length)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
get_size_in_bits(uint32_t n)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
scale_dot_product(const int16_t * v1,const int16_t * v2,int length,int scaling)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
correlation(int32_t * corr,int32_t * ener,int16_t * buffer,int16_t lag,int16_t blen,int16_t srange,int16_t scale)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
norm_w32(int32_t a)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
div_w32_w16(int32_t num,int16_t den)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
do_plc(int16_t * plc_residual,int16_t * plc_lpc,int16_t PLI,int16_t * decresidual,int16_t * lpc,int16_t inlag,ILBCContext * s)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
xcorr_coeff(int16_t * target,int16_t * regressor,int16_t subl,int16_t searchLen,int16_t offset,int16_t step)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 = ®ressor[subl];
1234 } else { /* step== -1 */
1235 max = max_abs_value_w16(®ressor[-searchLen], (int16_t) (subl + searchLen - 1));
1236 rp_beg = ®ressor[-1];
1237 rp_end = ®ressor[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 = ®ressor[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
hp_output(int16_t * signal,const int16_t * ba,int16_t * y,int16_t * x,int16_t len)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
ilbc_decode_frame(AVCodecContext * avctx,void * data,int * got_frame_ptr,AVPacket * avpkt)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
ilbc_decode_init(AVCodecContext * avctx)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 };
1490