FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ilbcdec.c
Go to the documentation of this file.
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 {
78  int16_t cb_index[CB_NSTAGES*(NASUB_MAX + 1)];
80  int16_t ifm;
81  int16_t state_first;
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;
94 
97  int last_lag;
99  int lpc_n;
100  int16_t nasub;
101  int16_t nsub;
103  int16_t no_of_words;
104  int16_t no_of_bytes;
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 
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];
412  a[6 - i] = (tmp + 4096) >> 13;
413 
414  tmp = f[0][6 - i] - (unsigned)f[1][6 - i];
415  a[5 + i] = (tmp + 4096) >> 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  int32_t 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] = (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 
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 */
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 += step * ((*rp_end * *rp_end - *rp_beg * *rp_beg) >> shifts);
1307  rp_beg += step;
1308  rp_end += step;
1309  }
1310 
1311  return maxlag + offset;
1312 }
1313 
1314 static void hp_output(int16_t *signal, const int16_t *ba, int16_t *y,
1315  int16_t *x, int16_t len)
1316 {
1317  int32_t tmp;
1318 
1319  for (int i = 0; i < len; i++) {
1320  tmp = SPL_MUL_16_16(y[1], ba[3]); /* (-a[1])*y[i-1] (low part) */
1321  tmp += SPL_MUL_16_16(y[3], ba[4]); /* (-a[2])*y[i-2] (low part) */
1322  tmp = (tmp >> 15);
1323  tmp += SPL_MUL_16_16(y[0], ba[3]); /* (-a[1])*y[i-1] (high part) */
1324  tmp += SPL_MUL_16_16(y[2], ba[4]); /* (-a[2])*y[i-2] (high part) */
1325  tmp = (tmp * 2);
1326 
1327  tmp += SPL_MUL_16_16(signal[i], ba[0]); /* b[0]*x[0] */
1328  tmp += SPL_MUL_16_16(x[0], ba[1]); /* b[1]*x[i-1] */
1329  tmp += SPL_MUL_16_16(x[1], ba[2]); /* b[2]*x[i-2] */
1330 
1331  /* Update state (input part) */
1332  x[1] = x[0];
1333  x[0] = signal[i];
1334 
1335  /* Convert back to Q0 and multiply with 2 */
1336  signal[i] = av_clip_intp2(tmp + 1024, 26) >> 11;
1337 
1338  /* Update state (filtered part) */
1339  y[2] = y[0];
1340  y[3] = y[1];
1341 
1342  /* upshift tmp by 3 with saturation */
1343  if (tmp > 268435455) {
1344  tmp = INT32_MAX;
1345  } else if (tmp < -268435456) {
1346  tmp = INT32_MIN;
1347  } else {
1348  tmp = tmp * 8;
1349  }
1350 
1351  y[0] = tmp >> 16;
1352  y[1] = (tmp - (y[0] * (1 << 16))) >> 1;
1353  }
1354 }
1355 
1356 static int ilbc_decode_frame(AVCodecContext *avctx, void *data,
1357  int *got_frame_ptr, AVPacket *avpkt)
1358 {
1359  const uint8_t *buf = avpkt->data;
1360  AVFrame *frame = data;
1361  ILBCContext *s = avctx->priv_data;
1362  int mode = s->mode, ret;
1363  int16_t *plc_data = &s->plc_residual[LPC_FILTERORDER];
1364 
1365  if ((ret = init_get_bits8(&s->gb, buf, avpkt->size)) < 0)
1366  return ret;
1367  memset(&s->frame, 0, sizeof(ILBCFrame));
1368 
1369  frame->nb_samples = s->block_samples;
1370  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1371  return ret;
1372 
1373  if (unpack_frame(s))
1374  mode = 0;
1375  if (s->frame.start < 1 || s->frame.start > 5)
1376  mode = 0;
1377 
1378  if (mode) {
1380 
1381  lsf_dequantization(s->lsfdeq, s->frame.lsf, s->lpc_n);
1384  s->lsfdeq, LPC_FILTERORDER, s);
1385  decode_residual(s, &s->frame, s->decresidual, s->syntdenum);
1386 
1387  do_plc(s->plc_residual, s->plc_lpc, 0,
1388  s->decresidual, s->syntdenum + (LPC_FILTERORDER + 1) * (s->nsub - 1),
1389  s->last_lag, s);
1390 
1391  memcpy(s->decresidual, s->plc_residual, s->block_samples * 2);
1392  }
1393 
1394  if (s->enhancer) {
1395  /* TODO */
1396  } else {
1397  int16_t lag, i;
1398 
1399  /* Find last lag (since the enhancer is not called to give this info) */
1400  if (s->mode == 20) {
1401  lag = xcorr_coeff(&s->decresidual[s->block_samples-60], &s->decresidual[s->block_samples-80],
1402  60, 80, 20, -1);
1403  } else {
1406  ENH_BLOCKL, 100, 20, -1);
1407  }
1408 
1409  /* Store lag (it is needed if next packet is lost) */
1410  s->last_lag = lag;
1411 
1412  /* copy data and run synthesis filter */
1413  memcpy(plc_data, s->decresidual, s->block_samples * 2);
1414 
1415  /* Set up the filter state */
1416  memcpy(&plc_data[-LPC_FILTERORDER], s->syntMem, LPC_FILTERORDER * 2);
1417 
1418  for (i = 0; i < s->nsub; i++) {
1419  filter_arfq12(plc_data+i*SUBL, plc_data+i*SUBL,
1420  s->syntdenum + i*(LPC_FILTERORDER + 1),
1421  LPC_FILTERORDER + 1, SUBL);
1422  }
1423 
1424  /* Save the filter state */
1425  memcpy(s->syntMem, &plc_data[s->block_samples-LPC_FILTERORDER], LPC_FILTERORDER * 2);
1426  }
1427 
1428  memcpy(frame->data[0], plc_data, s->block_samples * 2);
1429 
1430  hp_output((int16_t *)frame->data[0], hp_out_coeffs,
1431  s->hpimemy, s->hpimemx, s->block_samples);
1432 
1433  memcpy(s->old_syntdenum, s->syntdenum, s->nsub*(LPC_FILTERORDER + 1) * 2);
1434 
1435  s->prev_enh_pl = 0;
1436  if (mode == 0)
1437  s->prev_enh_pl = 1;
1438 
1439  *got_frame_ptr = 1;
1440 
1441  return avpkt->size;
1442 }
1443 
1445 {
1446  ILBCContext *s = avctx->priv_data;
1447 
1448  if (avctx->block_align == 38)
1449  s->mode = 20;
1450  else if (avctx->block_align == 50)
1451  s->mode = 30;
1452  else if (avctx->bit_rate > 0)
1453  s->mode = avctx->bit_rate <= 14000 ? 30 : 20;
1454  else
1455  return AVERROR_INVALIDDATA;
1456 
1457  avctx->channels = 1;
1459  avctx->sample_rate = 8000;
1460  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1461 
1462  if (s->mode == 30) {
1463  s->block_samples = 240;
1464  s->nsub = NSUB_30MS;
1465  s->nasub = NASUB_30MS;
1466  s->lpc_n = LPC_N_30MS;
1468  } else {
1469  s->block_samples = 160;
1470  s->nsub = NSUB_20MS;
1471  s->nasub = NASUB_20MS;
1472  s->lpc_n = LPC_N_20MS;
1474  }
1475 
1476  return 0;
1477 }
1478 
1480  .name = "ilbc",
1481  .long_name = NULL_IF_CONFIG_SMALL("iLBC (Internet Low Bitrate Codec)"),
1482  .type = AVMEDIA_TYPE_AUDIO,
1483  .id = AV_CODEC_ID_ILBC,
1484  .init = ilbc_decode_init,
1485  .decode = ilbc_decode_frame,
1486  .capabilities = AV_CODEC_CAP_DR1,
1487  .priv_data_size = sizeof(ILBCContext),
1488 };
int16_t prevPLI
Definition: ilbcdec.c:118
int enhancer
Definition: ilbcdec.c:89
#define NULL
Definition: coverity.c:32
#define SUBL
Definition: ilbcdec.c:45
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int shift(int a, int b)
Definition: sonic.c:82
This structure describes decoded (raw) audio or video data.
Definition: frame.h:226
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
int16_t nasub
Definition: ilbcdec.c:100
static const int16_t cos_derivative_tbl[64]
Definition: ilbcdata.h:78
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:381
int block_samples
Definition: ilbcdec.c:102
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1583
#define CB_NSTAGES
Definition: ilbcdec.c:54
static float win(SuperEqualizerContext *s, float n, int N)
#define NSUB_20MS
Definition: ilbcdec.c:63
GetBitContext gb
Definition: ilbcdec.c:92
#define CB_FILTERLEN
Definition: ilbcdec.c:56
int16_t start
Definition: ilbcdec.c:84
int size
Definition: avcodec.h:1446
int16_t lsfold[LPC_FILTERORDER]
Definition: ilbcdec.c:106
static void state_construct(int16_t ifm, int16_t *idx, int16_t *synt_denum, int16_t *Out_fix, int16_t len)
Definition: ilbcdec.c:521
#define STATE_LEN
Definition: ilbcdec.c:69
int16_t hpimemx[2]
Definition: ilbcdec.c:124
AVCodec.
Definition: avcodec.h:3424
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2226
static const int16_t hp_out_coeffs[]
Definition: ilbcdata.h:43
int16_t lsf[LSF_NSPLIT *LPC_N_MAX]
Definition: ilbcdec.c:77
int16_t hpimemy[4]
Definition: ilbcdec.c:125
static const int16_t frg_quant_mod[64]
Definition: ilbcdata.h:225
ILBCFrame frame
Definition: ilbcdec.c:93
#define STATE_SHORT_LEN_30MS
Definition: ilbcdec.c:70
static void decode_residual(ILBCContext *s, ILBCFrame *encbits, int16_t *decresidual, int16_t *syntdenum)
Definition: ilbcdec.c:764
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2197
int mem
Definition: avisynth_c.h:821
uint8_t
#define av_cold
Definition: attributes.h:82
static void construct_vector(int16_t *decvector, int16_t *index, int16_t *gain_index, int16_t *mem, int16_t lMem, int16_t veclen)
Definition: ilbcdec.c:715
int prev_enh_pl
Definition: ilbcdec.c:95
static void lsf_dequantization(int16_t *lsfdeq, int16_t *index, int16_t lpc_n)
Definition: ilbcdec.c:281
static void index_conv(int16_t *index)
Definition: ilbcdec.c:268
#define f(width, name)
Definition: cbs_vp9.c:255
static AVFrame * frame
uint8_t * data
Definition: avcodec.h:1445
int16_t lsfdeq[LPC_FILTERORDER *LPC_N_MAX]
Definition: ilbcdec.c:105
int16_t lsfdeqold[LPC_FILTERORDER]
Definition: ilbcdec.c:108
bitstream reader API header.
int mode
Definition: ilbcdec.c:91
ptrdiff_t size
Definition: opengl_enc.c:101
#define SPL_MUL_16_16_RSFT(a, b, c)
Definition: ilbcdec.c:74
#define MEM_LF_TBL
Definition: ilbcdec.c:48
static void vector_multiplication(int16_t *out, const int16_t *in, const int16_t *win, int length, int shift)
Definition: ilbcdec.c:615
static const int16_t kPlcPfSlope[]
Definition: ilbcdata.h:45
int state_short_len
Definition: ilbcdec.c:98
#define SPL_MUL_16_16(a, b)
Definition: ilbcdec.c:73
AVCodec ff_ilbc_decoder
Definition: ilbcdec.c:1479
static int32_t scale_dot_product(const int16_t *v1, const int16_t *v2, int length, int scaling)
Definition: ilbcdec.c:902
static const int shift1[6]
Definition: dxa.c:50
#define LPC_N_20MS
Definition: ilbcdec.c:38
#define SPL_SHIFT_W32(x, c)
Definition: ilbcdec.c:928
static const uint8_t lsf_size_codebook[]
Definition: ilbcdata.h:39
#define B
Definition: huffyuvdsp.h:32
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int last_lag
Definition: ilbcdec.c:97
int16_t seed
Definition: ilbcdec.c:117
static void vector_rmultiplication(int16_t *out, const int16_t *in, const int16_t *win, int length, int shift)
Definition: ilbcdec.c:607
static int16_t get_size_in_bits(uint32_t n)
Definition: ilbcdec.c:883
GLsizei GLsizei * length
Definition: opengl_enc.c:115
const char * name
Name of the codec implementation.
Definition: avcodec.h:3431
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
static int16_t norm_w32(int32_t a)
Definition: ilbcdec.c:930
#define FFMAX(a, b)
Definition: common.h:94
int16_t old_syntdenum[NSUB_MAX *(LPC_FILTERORDER+1)]
Definition: ilbcdec.c:111
static const int16_t cos_tbl[64]
Definition: ilbcdata.h:67
#define BLOCKL_MAX
Definition: ilbcdec.c:62
int16_t prevLag
Definition: ilbcdec.c:120
int16_t per_square
Definition: ilbcdec.c:121
static void create_augmented_vector(int index, int16_t *buffer, int16_t *cbVec)
Definition: ilbcdec.c:631
static void lsf2lsp(int16_t *lsf, int16_t *lsp, int order)
Definition: ilbcdec.c:342
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2240
#define NASUB_30MS
Definition: ilbcdec.c:67
int16_t plc_lpc[LPC_FILTERORDER+1]
Definition: ilbcdec.c:123
#define FFMIN(a, b)
Definition: common.h:96
#define ff_clz
Definition: intmath.h:142
static int32_t div_w32_w16(int32_t num, int16_t den)
Definition: ilbcdec.c:941
int32_t
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
#define ST_MEM_L_TBL
Definition: ilbcdec.c:47
int n
Definition: avisynth_c.h:684
#define CB_HALFFILTERLEN
Definition: ilbcdec.c:55
static double coefficients[8 *8]
Definition: dctref.c:35
int16_t enh_buf[ENH_BUFL+ENH_BUFL_FILTEROVERHEAD]
Definition: ilbcdec.c:112
int16_t plc_residual[BLOCKL_MAX+LPC_FILTERORDER]
Definition: ilbcdec.c:116
static void lsf_check_stability(int16_t *lsf, int dim, int nb_vectors)
Definition: ilbcdec.c:309
static int16_t max_abs_value_w16(const int16_t *vector, int length)
Definition: ilbcdec.c:865
static void add_vector_and_shift(int16_t *out, const int16_t *in1, const int16_t *in2, int length, int shift)
Definition: ilbcdec.c:623
static void get_codebook(int16_t *cbvec, int16_t *mem, int16_t index, int16_t lMem, int16_t cbveclen)
Definition: ilbcdec.c:646
Libavcodec external API header.
static const int16_t kPlcPitchFact[]
Definition: ilbcdata.h:47
int sample_rate
samples per second
Definition: avcodec.h:2189
static int16_t gain_dequantization(int index, int max_in, int stage)
Definition: ilbcdec.c:600
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:650
int16_t prevScale
Definition: ilbcdec.c:119
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:1533
#define STATE_SHORT_LEN_20MS
Definition: ilbcdec.c:71
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1918
int16_t no_of_bytes
Definition: ilbcdec.c:104
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
static void correlation(int32_t *corr, int32_t *ener, int16_t *buffer, int16_t lag, int16_t blen, int16_t srange, int16_t scale)
Definition: ilbcdec.c:912
int16_t prev_lpc[LPC_FILTERORDER+1]
Definition: ilbcdec.c:122
void * buf
Definition: avisynth_c.h:690
#define NSUB_MAX
Definition: ilbcdec.c:65
static const int16_t lsf_codebook[64 *3+128 *3+128 *4]
Definition: ilbcdata.h:89
static void bw_expand(int16_t *out, const int16_t *in, const int16_t *coef, int length)
Definition: ilbcdec.c:428
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:487
Describe the class of an AVClass context structure.
Definition: log.h:67
int16_t cb_index[CB_NSTAGES *(NASUB_MAX+1)]
Definition: ilbcdec.c:78
int index
Definition: gxfenc.c:89
int16_t decresidual[BLOCKL_MAX]
Definition: ilbcdec.c:115
int dim
int16_t weightdenum[(LPC_FILTERORDER+1)*NSUB_MAX]
Definition: ilbcdec.c:109
static void lsf_interpolate(int16_t *out, int16_t *in1, int16_t *in2, int16_t coef, int size)
Definition: ilbcdec.c:332
int lpc_n
Definition: ilbcdec.c:99
static void lsf2poly(int16_t *a, int16_t *lsf)
Definition: ilbcdec.c:392
#define ENH_BLOCKL
Definition: ilbcdec.c:59
static void get_lsp_poly(int16_t *lsp, int32_t *f)
Definition: ilbcdec.c:365
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
#define ENH_BUFL_FILTEROVERHEAD
Definition: ilbcdec.c:61
int consPLICount
Definition: ilbcdec.c:96
static const int16_t *const ilbc_gain[]
Definition: ilbcdata.h:217
int16_t firstbits
Definition: ilbcdec.c:83
#define LPC_N_30MS
Definition: ilbcdec.c:39
common internal api header.
int16_t syntdenum[NSUB_MAX *(LPC_FILTERORDER+1)]
Definition: ilbcdec.c:110
#define NASUB_20MS
Definition: ilbcdec.c:66
int16_t idx[STATE_SHORT_LEN_30MS]
Definition: ilbcdec.c:82
static const int16_t kPlcPerSqr[]
Definition: ilbcdata.h:53
static const int shift2[6]
Definition: dxa.c:51
signed 16 bits
Definition: samplefmt.h:61
static av_cold int ilbc_decode_init(AVCodecContext *avctx)
Definition: ilbcdec.c:1444
static const int16_t kCbFiltersRev[]
Definition: ilbcdata.h:49
static const uint8_t shifts[2][12]
Definition: camellia.c:174
static void do_plc(int16_t *plc_residual, int16_t *plc_lpc, int16_t PLI, int16_t *decresidual, int16_t *lpc, int16_t inlag, ILBCContext *s)
Definition: ilbcdec.c:949
#define ENH_NBLOCKS_TOT
Definition: ilbcdec.c:58
void * priv_data
Definition: avcodec.h:1560
static const int16_t kLpcChirpSyntDenum[]
Definition: ilbcdata.h:59
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int16_t state_first
Definition: ilbcdec.c:81
#define ENH_BUFL
Definition: ilbcdec.c:60
static void reverse_memcpy(int16_t *dest, int16_t *source, int length)
Definition: ilbcdec.c:754
int len
int channels
number of audio channels
Definition: avcodec.h:2190
static const int16_t lsf_weight_30ms[]
Definition: ilbcdata.h:41
int16_t syntMem[LPC_FILTERORDER]
Definition: ilbcdec.c:107
#define LPC_N_MAX
Definition: ilbcdec.c:40
static void lsp_interpolate2polydec(int16_t *a, int16_t *lsf1, int16_t *lsf2, int coef, int length)
Definition: ilbcdec.c:419
#define NSUB_30MS
Definition: ilbcdec.c:64
static const int16_t ilbc_state[8]
Definition: ilbcdata.h:221
static int xcorr_coeff(int16_t *target, int16_t *regressor, int16_t subl, int16_t searchLen, int16_t offset, int16_t step)
Definition: ilbcdec.c:1203
#define CB_MEML
Definition: ilbcdec.c:53
FILE * out
Definition: movenc.c:54
static void filter_arfq12(const int16_t *data_in, int16_t *data_out, const int16_t *coefficients, int coefficients_length, int data_length)
Definition: ilbcdec.c:499
static void lsp_interpolate(int16_t *syntdenum, int16_t *weightdenum, int16_t *lsfdeq, int16_t length, ILBCContext *s)
Definition: ilbcdec.c:437
static void hp_output(int16_t *signal, const int16_t *ba, int16_t *y, int16_t *x, int16_t len)
Definition: ilbcdec.c:1314
int16_t nsub
Definition: ilbcdec.c:101
#define LSF_NSPLIT
Definition: ilbcdec.c:41
static const uint8_t lsf_dim_codebook[]
Definition: ilbcdata.h:38
int16_t enh_period[ENH_NBLOCKS_TOT]
Definition: ilbcdec.c:113
#define NASUB_MAX
Definition: ilbcdec.c:68
static int unpack_frame(ILBCContext *s)
Definition: ilbcdec.c:128
int16_t ifm
Definition: ilbcdec.c:80
#define AV_CH_LAYOUT_MONO
static const int16_t lsf_weight_20ms[]
Definition: ilbcdata.h:40
int16_t gain_index[CB_NSTAGES *(NASUB_MAX+1)]
Definition: ilbcdec.c:79
This structure stores compressed data.
Definition: avcodec.h:1422
static void filter_mafq12(int16_t *in_ptr, int16_t *out_ptr, int16_t *B, int16_t B_length, int16_t length)
Definition: ilbcdec.c:479
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:292
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:968
int16_t prevResidual[NSUB_MAX *SUBL]
Definition: ilbcdec.c:114
static int ilbc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: ilbcdec.c:1356
#define LPC_FILTERORDER
Definition: ilbcdec.c:43
GLuint buffer
Definition: opengl_enc.c:102
int16_t no_of_words
Definition: ilbcdec.c:103
static uint8_t tmp[11]
Definition: aes_ctr.c:26