FFmpeg
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;
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)];
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 
129 {
130  ILBCFrame *frame = &s->frame;
131  GetBitContext *gb = &s->gb;
132  int j;
133 
134  frame->lsf[0] = get_bits(gb, 6);
135  frame->lsf[1] = get_bits(gb, 7);
136  frame->lsf[2] = get_bits(gb, 7);
137 
138  if (s->mode == 20) {
139  frame->start = get_bits(gb, 2);
140  frame->state_first = get_bits1(gb);
141  frame->ifm = get_bits(gb, 6);
142  frame->cb_index[0] = get_bits(gb, 6) << 1;
143  frame->gain_index[0] = get_bits(gb, 2) << 3;
144  frame->gain_index[1] = get_bits1(gb) << 3;
145  frame->cb_index[3] = get_bits(gb, 7) << 1;
146  frame->gain_index[3] = get_bits1(gb) << 4;
147  frame->gain_index[4] = get_bits1(gb) << 3;
148  frame->gain_index[6] = get_bits1(gb) << 4;
149  } else {
150  frame->lsf[3] = get_bits(gb, 6);
151  frame->lsf[4] = get_bits(gb, 7);
152  frame->lsf[5] = get_bits(gb, 7);
153  frame->start = get_bits(gb, 3);
154  frame->state_first = get_bits1(gb);
155  frame->ifm = get_bits(gb, 6);
156  frame->cb_index[0] = get_bits(gb, 4) << 3;
157  frame->gain_index[0] = get_bits1(gb) << 4;
158  frame->gain_index[1] = get_bits1(gb) << 3;
159  frame->cb_index[3] = get_bits(gb, 6) << 2;
160  frame->gain_index[3] = get_bits1(gb) << 4;
161  frame->gain_index[4] = get_bits1(gb) << 3;
162  }
163 
164  for (j = 0; j < 48; j++)
165  frame->idx[j] = get_bits1(gb) << 2;
166 
167  if (s->mode == 20) {
168  for (; j < 57; j++)
169  frame->idx[j] = get_bits1(gb) << 2;
170 
171  frame->gain_index[1] |= get_bits1(gb) << 2;
172  frame->gain_index[3] |= get_bits(gb, 2) << 2;
173  frame->gain_index[4] |= get_bits1(gb) << 2;
174  frame->gain_index[6] |= get_bits1(gb) << 3;
175  frame->gain_index[7] = get_bits(gb, 2) << 2;
176  } else {
177  for (; j < 58; j++)
178  frame->idx[j] = get_bits1(gb) << 2;
179 
180  frame->cb_index[0] |= get_bits(gb, 2) << 1;
181  frame->gain_index[0] |= get_bits1(gb) << 3;
182  frame->gain_index[1] |= get_bits1(gb) << 2;
183  frame->cb_index[3] |= get_bits1(gb) << 1;
184  frame->cb_index[6] = get_bits1(gb) << 7;
185  frame->cb_index[6] |= get_bits(gb, 6) << 1;
186  frame->cb_index[9] = get_bits(gb, 7) << 1;
187  frame->cb_index[12] = get_bits(gb, 3) << 5;
188  frame->cb_index[12] |= get_bits(gb, 4) << 1;
189  frame->gain_index[3] |= get_bits(gb, 2) << 2;
190  frame->gain_index[4] |= get_bits(gb, 2) << 1;
191  frame->gain_index[6] = get_bits(gb, 2) << 3;
192  frame->gain_index[7] = get_bits(gb, 2) << 2;
193  frame->gain_index[9] = get_bits1(gb) << 4;
194  frame->gain_index[10] = get_bits1(gb) << 3;
195  frame->gain_index[12] = get_bits1(gb) << 4;
196  frame->gain_index[13] = get_bits1(gb) << 3;
197  }
198 
199  for (j = 0; j < 56; j++)
200  frame->idx[j] |= get_bits(gb, 2);
201 
202  if (s->mode == 20) {
203  frame->idx[56] |= get_bits(gb, 2);
204  frame->cb_index[0] |= get_bits1(gb);
205  frame->cb_index[1] = get_bits(gb, 7);
206  frame->cb_index[2] = get_bits(gb, 6) << 1;
207  frame->cb_index[2] |= get_bits1(gb);
208  frame->gain_index[0] |= get_bits(gb, 3);
209  frame->gain_index[1] |= get_bits(gb, 2);
210  frame->gain_index[2] = get_bits(gb, 3);
211  frame->cb_index[3] |= get_bits1(gb);
212  frame->cb_index[4] = get_bits(gb, 6) << 1;
213  frame->cb_index[4] |= get_bits1(gb);
214  frame->cb_index[5] = get_bits(gb, 7);
215  frame->cb_index[6] = get_bits(gb, 8);
216  frame->cb_index[7] = get_bits(gb, 8);
217  frame->cb_index[8] = get_bits(gb, 8);
218  frame->gain_index[3] |= get_bits(gb, 2);
219  frame->gain_index[4] |= get_bits(gb, 2);
220  frame->gain_index[5] = get_bits(gb, 3);
221  frame->gain_index[6] |= get_bits(gb, 3);
222  frame->gain_index[7] |= get_bits(gb, 2);
223  frame->gain_index[8] = get_bits(gb, 3);
224  } else {
225  frame->idx[56] |= get_bits(gb, 2);
226  frame->idx[57] |= get_bits(gb, 2);
227  frame->cb_index[0] |= get_bits1(gb);
228  frame->cb_index[1] = get_bits(gb, 7);
229  frame->cb_index[2] = get_bits(gb, 4) << 3;
230  frame->cb_index[2] |= get_bits(gb, 3);
231  frame->gain_index[0] |= get_bits(gb, 3);
232  frame->gain_index[1] |= get_bits(gb, 2);
233  frame->gain_index[2] = get_bits(gb, 3);
234  frame->cb_index[3] |= get_bits1(gb);
235  frame->cb_index[4] = get_bits(gb, 4) << 3;
236  frame->cb_index[4] |= get_bits(gb, 3);
237  frame->cb_index[5] = get_bits(gb, 7);
238  frame->cb_index[6] |= get_bits1(gb);
239  frame->cb_index[7] = get_bits(gb, 5) << 3;
240  frame->cb_index[7] |= get_bits(gb, 3);
241  frame->cb_index[8] = get_bits(gb, 8);
242  frame->cb_index[9] |= get_bits1(gb);
243  frame->cb_index[10] = get_bits(gb, 4) << 4;
244  frame->cb_index[10] |= get_bits(gb, 4);
245  frame->cb_index[11] = get_bits(gb, 8);
246  frame->cb_index[12] |= get_bits1(gb);
247  frame->cb_index[13] = get_bits(gb, 3) << 5;
248  frame->cb_index[13] |= get_bits(gb, 5);
249  frame->cb_index[14] = get_bits(gb, 8);
250  frame->gain_index[3] |= get_bits(gb, 2);
251  frame->gain_index[4] |= get_bits1(gb);
252  frame->gain_index[5] = get_bits(gb, 3);
253  frame->gain_index[6] |= get_bits(gb, 3);
254  frame->gain_index[7] |= get_bits(gb, 2);
255  frame->gain_index[8] = get_bits(gb, 3);
256  frame->gain_index[9] |= get_bits(gb, 4);
257  frame->gain_index[10] |= get_bits1(gb) << 2;
258  frame->gain_index[10] |= get_bits(gb, 2);
259  frame->gain_index[11] = get_bits(gb, 3);
260  frame->gain_index[12] |= get_bits(gb, 4);
261  frame->gain_index[13] |= get_bits(gb, 3);
262  frame->gain_index[14] = get_bits(gb, 3);
263  }
264 
265  return get_bits1(gb);
266 }
267 
268 static void index_conv(int16_t *index)
269 {
270  int k;
271 
272  for (k = 4; k < 6; k++) {
273  if (index[k] >= 44 && index[k] < 108) {
274  index[k] += 64;
275  } else if (index[k] >= 108 && index[k] < 128) {
276  index[k] += 128;
277  }
278  }
279 }
280 
281 static void lsf_dequantization(int16_t *lsfdeq, int16_t *index, int16_t lpc_n)
282 {
283  int i, j, pos = 0, cb_pos = 0;
284 
285  for (i = 0; i < LSF_NSPLIT; i++) {
286  for (j = 0; j < lsf_dim_codebook[i]; j++) {
287  lsfdeq[pos + j] = lsf_codebook[cb_pos + index[i] * lsf_dim_codebook[i] + j];
288  }
289 
290  pos += lsf_dim_codebook[i];
291  cb_pos += lsf_size_codebook[i] * lsf_dim_codebook[i];
292  }
293 
294  if (lpc_n > 1) {
295  pos = 0;
296  cb_pos = 0;
297  for (i = 0; i < LSF_NSPLIT; i++) {
298  for (j = 0; j < lsf_dim_codebook[i]; j++) {
299  lsfdeq[LPC_FILTERORDER + pos + j] = lsf_codebook[cb_pos +
300  index[LSF_NSPLIT + i] * lsf_dim_codebook[i] + j];
301  }
302 
303  pos += lsf_dim_codebook[i];
304  cb_pos += lsf_size_codebook[i] * lsf_dim_codebook[i];
305  }
306  }
307 }
308 
309 static void lsf_check_stability(int16_t *lsf, int dim, int nb_vectors)
310 {
311  for (int n = 0; n < 2; n++) {
312  for (int m = 0; m < nb_vectors; m++) {
313  for (int k = 0; k < dim - 1; k++) {
314  int i = m * dim + k;
315 
316  if ((lsf[i + 1] - lsf[i]) < 319) {
317  if (lsf[i + 1] < lsf[i]) {
318  lsf[i + 1] = lsf[i] + 160;
319  lsf[i] = lsf[i + 1] - 160;
320  } else {
321  lsf[i] -= 160;
322  lsf[i + 1] += 160;
323  }
324  }
325 
326  lsf[i] = av_clip(lsf[i], 82, 25723);
327  }
328  }
329  }
330 }
331 
332 static void lsf_interpolate(int16_t *out, int16_t *in1,
333  int16_t *in2, int16_t coef,
334  int size)
335 {
336  int invcoef = 16384 - coef, i;
337 
338  for (i = 0; i < size; i++)
339  out[i] = (coef * in1[i] + invcoef * in2[i] + 8192) >> 14;
340 }
341 
342 static void lsf2lsp(int16_t *lsf, int16_t *lsp, int order)
343 {
344  int16_t diff, freq;
345  int32_t tmp;
346  int i, k;
347 
348  for (i = 0; i < order; i++) {
349  freq = (lsf[i] * 20861) >> 15;
350  /* 20861: 1.0/(2.0*PI) in Q17 */
351  /*
352  Upper 8 bits give the index k and
353  Lower 8 bits give the difference, which needs
354  to be approximated linearly
355  */
356  k = FFMIN(freq >> 8, 63);
357  diff = freq & 0xFF;
358 
359  /* Calculate linear approximation */
360  tmp = cos_derivative_tbl[k] * diff;
361  lsp[i] = cos_tbl[k] + (tmp >> 12);
362  }
363 }
364 
365 static void get_lsp_poly(int16_t *lsp, int32_t *f)
366 {
367  int16_t high, low;
368  int i, j, k, l;
369  int32_t tmp;
370 
371  f[0] = 16777216;
372  f[1] = lsp[0] * -1024;
373 
374  for (i = 2, k = 2, l = 2; i <= 5; i++, k += 2) {
375  f[l] = f[l - 2];
376 
377  for (j = i; j > 1; j--, l--) {
378  high = f[l - 1] >> 16;
379  low = (f[l - 1] - (high * (1 << 16))) >> 1;
380 
381  tmp = ((high * lsp[k]) * 4) + (((low * lsp[k]) >> 15) * 4);
382 
383  f[l] += f[l - 2];
384  f[l] -= (unsigned)tmp;
385  }
386 
387  f[l] -= lsp[k] * (1 << 10);
388  l += i;
389  }
390 }
391 
392 static void lsf2poly(int16_t *a, int16_t *lsf)
393 {
394  int32_t f[2][6];
395  int16_t lsp[10];
396  int32_t tmp;
397  int i;
398 
399  lsf2lsp(lsf, lsp, LPC_FILTERORDER);
400 
401  get_lsp_poly(&lsp[0], f[0]);
402  get_lsp_poly(&lsp[1], f[1]);
403 
404  for (i = 5; i > 0; i--) {
405  f[0][i] += (unsigned)f[0][i - 1];
406  f[1][i] -= (unsigned)f[1][i - 1];
407  }
408 
409  a[0] = 4096;
410  for (i = 5; i > 0; i--) {
411  tmp = f[0][6 - i] + (unsigned)f[1][6 - i] + 4096;
412  a[6 - i] = tmp >> 13;
413 
414  tmp = f[0][6 - i] - (unsigned)f[1][6 - i] + 4096;
415  a[5 + i] = tmp >> 13;
416  }
417 }
418 
419 static void lsp_interpolate2polydec(int16_t *a, int16_t *lsf1,
420  int16_t *lsf2, int coef, int length)
421 {
422  int16_t lsftmp[LPC_FILTERORDER];
423 
424  lsf_interpolate(lsftmp, lsf1, lsf2, coef, length);
425  lsf2poly(a, lsftmp);
426 }
427 
428 static void bw_expand(int16_t *out, const int16_t *in, const int16_t *coef, int length)
429 {
430  int i;
431 
432  out[0] = in[0];
433  for (i = 1; i < length; i++)
434  out[i] = (coef[i] * in[i] + 16384) >> 15;
435 }
436 
437 static void lsp_interpolate(int16_t *syntdenum, int16_t *weightdenum,
438  int16_t *lsfdeq, int16_t length,
439  ILBCContext *s)
440 {
441  int16_t lp[LPC_FILTERORDER + 1], *lsfdeq2;
442  int i, pos, lp_length;
443 
444  lsfdeq2 = lsfdeq + length;
445  lp_length = length + 1;
446 
447  if (s->mode == 30) {
448  lsp_interpolate2polydec(lp, (*s).lsfdeqold, lsfdeq, lsf_weight_30ms[0], length);
449  memcpy(syntdenum, lp, lp_length * 2);
450  bw_expand(weightdenum, lp, kLpcChirpSyntDenum, lp_length);
451 
452  pos = lp_length;
453  for (i = 1; i < 6; i++) {
454  lsp_interpolate2polydec(lp, lsfdeq, lsfdeq2,
455  lsf_weight_30ms[i],
456  length);
457  memcpy(syntdenum + pos, lp, lp_length * 2);
458  bw_expand(weightdenum + pos, lp, kLpcChirpSyntDenum, lp_length);
459  pos += lp_length;
460  }
461  } else {
462  pos = 0;
463  for (i = 0; i < s->nsub; i++) {
464  lsp_interpolate2polydec(lp, s->lsfdeqold, lsfdeq,
465  lsf_weight_20ms[i], length);
466  memcpy(syntdenum + pos, lp, lp_length * 2);
467  bw_expand(weightdenum + pos, lp, kLpcChirpSyntDenum, lp_length);
468  pos += lp_length;
469  }
470  }
471 
472  if (s->mode == 30) {
473  memcpy(s->lsfdeqold, lsfdeq2, length * 2);
474  } else {
475  memcpy(s->lsfdeqold, lsfdeq, length * 2);
476  }
477 }
478 
479 static void filter_mafq12(int16_t *in_ptr, int16_t *out_ptr,
480  int16_t *B, int16_t B_length,
481  int16_t length)
482 {
483  int o, i, j;
484 
485  for (i = 0; i < length; i++) {
486  const int16_t *b_ptr = &B[0];
487  const int16_t *x_ptr = &in_ptr[i];
488 
489  o = 0;
490  for (j = 0; j < B_length; j++)
491  o += b_ptr[j] * *x_ptr--;
492 
493  o = av_clip(o, -134217728, 134215679);
494 
495  out_ptr[i] = ((o + 2048) >> 12);
496  }
497 }
498 
499 static void filter_arfq12(const int16_t *data_in,
500  int16_t *data_out,
501  const int16_t *coefficients,
502  int coefficients_length,
503  int data_length)
504 {
505  int i, j;
506 
507  for (i = 0; i < data_length; i++) {
508  int output = 0, sum = 0;
509 
510  for (j = coefficients_length - 1; j > 0; j--) {
511  sum += (unsigned)(coefficients[j] * data_out[i - j]);
512  }
513 
514  output = coefficients[0] * data_in[i] - (unsigned)sum;
515  output = av_clip(output, -134217728, 134215679);
516 
517  data_out[i] = (output + 2048) >> 12;
518  }
519 }
520 
521 static void state_construct(int16_t ifm, int16_t *idx,
522  int16_t *synt_denum, int16_t *Out_fix,
523  int16_t len)
524 {
525  int k;
526  int16_t maxVal;
527  int16_t *tmp1, *tmp2, *tmp3;
528  /* Stack based */
529  int16_t numerator[1 + LPC_FILTERORDER];
530  int16_t sampleValVec[2 * STATE_SHORT_LEN_30MS + LPC_FILTERORDER];
531  int16_t sampleMaVec[2 * STATE_SHORT_LEN_30MS + LPC_FILTERORDER];
532  int16_t *sampleVal = &sampleValVec[LPC_FILTERORDER];
533  int16_t *sampleMa = &sampleMaVec[LPC_FILTERORDER];
534  int16_t *sampleAr = &sampleValVec[LPC_FILTERORDER];
535 
536  /* initialization of coefficients */
537 
538  for (k = 0; k < LPC_FILTERORDER + 1; k++) {
539  numerator[k] = synt_denum[LPC_FILTERORDER - k];
540  }
541 
542  /* decoding of the maximum value */
543 
544  maxVal = frg_quant_mod[ifm];
545 
546  /* decoding of the sample values */
547  tmp1 = sampleVal;
548  tmp2 = &idx[len - 1];
549 
550  if (ifm < 37) {
551  for (k = 0; k < len; k++) {
552  /*the shifting is due to the Q13 in sq4_fixQ13[i], also the adding of 2097152 (= 0.5 << 22)
553  maxVal is in Q8 and result is in Q(-1) */
554  (*tmp1) = (int16_t) ((SPL_MUL_16_16(maxVal, ilbc_state[(*tmp2)]) + 2097152) >> 22);
555  tmp1++;
556  tmp2--;
557  }
558  } else if (ifm < 59) {
559  for (k = 0; k < len; k++) {
560  /*the shifting is due to the Q13 in sq4_fixQ13[i], also the adding of 262144 (= 0.5 << 19)
561  maxVal is in Q5 and result is in Q(-1) */
562  (*tmp1) = (int16_t) ((SPL_MUL_16_16(maxVal, ilbc_state[(*tmp2)]) + 262144) >> 19);
563  tmp1++;
564  tmp2--;
565  }
566  } else {
567  for (k = 0; k < len; k++) {
568  /*the shifting is due to the Q13 in sq4_fixQ13[i], also the adding of 65536 (= 0.5 << 17)
569  maxVal is in Q3 and result is in Q(-1) */
570  (*tmp1) = (int16_t) ((SPL_MUL_16_16(maxVal, ilbc_state[(*tmp2)]) + 65536) >> 17);
571  tmp1++;
572  tmp2--;
573  }
574  }
575 
576  /* Set the rest of the data to zero */
577  memset(&sampleVal[len], 0, len * 2);
578 
579  /* circular convolution with all-pass filter */
580 
581  /* Set the state to zero */
582  memset(sampleValVec, 0, LPC_FILTERORDER * 2);
583 
584  /* Run MA filter + AR filter */
585  filter_mafq12(sampleVal, sampleMa, numerator, LPC_FILTERORDER + 1, len + LPC_FILTERORDER);
586  memset(&sampleMa[len + LPC_FILTERORDER], 0, (len - LPC_FILTERORDER) * 2);
587  filter_arfq12(sampleMa, sampleAr, synt_denum, LPC_FILTERORDER + 1, 2 * len);
588 
589  tmp1 = &sampleAr[len - 1];
590  tmp2 = &sampleAr[2 * len - 1];
591  tmp3 = Out_fix;
592  for (k = 0; k < len; k++) {
593  (*tmp3) = (*tmp1) + (*tmp2);
594  tmp1--;
595  tmp2--;
596  tmp3++;
597  }
598 }
599 
600 static int16_t gain_dequantization(int index, int max_in, int stage)
601 {
602  int16_t scale = FFMAX(1638, FFABS(max_in));
603 
604  return ((scale * ilbc_gain[stage][index]) + 8192) >> 14;
605 }
606 
607 static void vector_rmultiplication(int16_t *out, const int16_t *in,
608  const int16_t *win,
609  int length, int shift)
610 {
611  for (int i = 0; i < length; i++)
612  out[i] = (in[i] * win[-i]) >> shift;
613 }
614 
615 static void vector_multiplication(int16_t *out, const int16_t *in,
616  const int16_t *win, int length,
617  int shift)
618 {
619  for (int i = 0; i < length; i++)
620  out[i] = (in[i] * win[i]) >> shift;
621 }
622 
623 static void add_vector_and_shift(int16_t *out, const int16_t *in1,
624  const int16_t *in2, int length,
625  int shift)
626 {
627  for (int i = 0; i < length; i++)
628  out[i] = (in1[i] + in2[i]) >> shift;
629 }
630 
631 static void create_augmented_vector(int index, int16_t *buffer, int16_t *cbVec)
632 {
633  int16_t cbVecTmp[4];
634  int interpolation_length = FFMIN(4, index);
635  int16_t ilow = index - interpolation_length;
636 
637  memcpy(cbVec, buffer - index, index * 2);
638 
639  vector_multiplication(&cbVec[ilow], buffer - index - interpolation_length, alpha, interpolation_length, 15);
640  vector_rmultiplication(cbVecTmp, buffer - interpolation_length, &alpha[interpolation_length - 1], interpolation_length, 15);
641  add_vector_and_shift(&cbVec[ilow], &cbVec[ilow], cbVecTmp, interpolation_length, 0);
642 
643  memcpy(cbVec + index, buffer - index, FFMIN(SUBL - index, index) * sizeof(*cbVec));
644 }
645 
646 static void get_codebook(int16_t * cbvec, /* (o) Constructed codebook vector */
647  int16_t * mem, /* (i) Codebook buffer */
648  int16_t index, /* (i) Codebook index */
649  int16_t lMem, /* (i) Length of codebook buffer */
650  int16_t cbveclen /* (i) Codebook vector length */
651 )
652 {
653  int16_t k, base_size;
654  int16_t lag;
655  /* Stack based */
656  int16_t tempbuff2[SUBL + 5];
657 
658  /* Determine size of codebook sections */
659  base_size = lMem - cbveclen + 1;
660 
661  if (cbveclen == SUBL) {
662  base_size += cbveclen / 2;
663  }
664 
665  /* No filter -> First codebook section */
666  if (index < lMem - cbveclen + 1) {
667  /* first non-interpolated vectors */
668 
669  k = index + cbveclen;
670  /* get vector */
671  memcpy(cbvec, mem + lMem - k, cbveclen * 2);
672  } else if (index < base_size) {
673 
674  /* Calculate lag */
675 
676  k = (int16_t) SPL_MUL_16_16(2, (index - (lMem - cbveclen + 1))) + cbveclen;
677 
678  lag = k / 2;
679 
680  create_augmented_vector(lag, mem + lMem, cbvec);
681  } else {
682  int16_t memIndTest;
683 
684  /* first non-interpolated vectors */
685 
686  if (index - base_size < lMem - cbveclen + 1) {
687 
688  /* Set up filter memory, stuff zeros outside memory buffer */
689 
690  memIndTest = lMem - (index - base_size + cbveclen);
691 
692  memset(mem - CB_HALFFILTERLEN, 0, CB_HALFFILTERLEN * 2);
693  memset(mem + lMem, 0, CB_HALFFILTERLEN * 2);
694 
695  /* do filtering to get the codebook vector */
696 
697  filter_mafq12(&mem[memIndTest + 4], cbvec, (int16_t *) kCbFiltersRev, CB_FILTERLEN, cbveclen);
698  } else {
699  /* interpolated vectors */
700  /* Stuff zeros outside memory buffer */
701  memIndTest = lMem - cbveclen - CB_FILTERLEN;
702  memset(mem + lMem, 0, CB_HALFFILTERLEN * 2);
703 
704  /* do filtering */
705  filter_mafq12(&mem[memIndTest + 7], tempbuff2, (int16_t *) kCbFiltersRev, CB_FILTERLEN, (int16_t) (cbveclen + 5));
706 
707  /* Calculate lag index */
708  lag = (cbveclen << 1) - 20 + index - base_size - lMem - 1;
709 
710  create_augmented_vector(lag, tempbuff2 + SUBL + 5, cbvec);
711  }
712  }
713 }
714 
715 static void construct_vector (
716  int16_t *decvector, /* (o) Decoded vector */
717  int16_t *index, /* (i) Codebook indices */
718  int16_t *gain_index, /* (i) Gain quantization indices */
719  int16_t *mem, /* (i) Buffer for codevector construction */
720  int16_t lMem, /* (i) Length of buffer */
721  int16_t veclen)
722 {
723  int16_t gain[CB_NSTAGES];
724  int16_t cbvec0[SUBL];
725  int16_t cbvec1[SUBL];
726  int16_t cbvec2[SUBL];
727  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 += (unsigned)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 += (unsigned)step * ((*rp_end * *rp_end - *rp_beg * *rp_beg) >> shifts);
1307 
1308  rp_beg += step;
1309  rp_end += step;
1310  }
1311 
1312  return maxlag + offset;
1313 }
1314 
1315 static void hp_output(int16_t *signal, const int16_t *ba, int16_t *y,
1316  int16_t *x, int16_t len)
1317 {
1318  int32_t tmp;
1319 
1320  for (int i = 0; i < len; i++) {
1321  tmp = SPL_MUL_16_16(y[1], ba[3]); /* (-a[1])*y[i-1] (low part) */
1322  tmp += SPL_MUL_16_16(y[3], ba[4]); /* (-a[2])*y[i-2] (low part) */
1323  tmp = (tmp >> 15);
1324  tmp += SPL_MUL_16_16(y[0], ba[3]); /* (-a[1])*y[i-1] (high part) */
1325  tmp += SPL_MUL_16_16(y[2], ba[4]); /* (-a[2])*y[i-2] (high part) */
1326  tmp = (tmp * 2);
1327 
1328  tmp += SPL_MUL_16_16(signal[i], ba[0]); /* b[0]*x[0] */
1329  tmp += SPL_MUL_16_16(x[0], ba[1]); /* b[1]*x[i-1] */
1330  tmp += SPL_MUL_16_16(x[1], ba[2]); /* b[2]*x[i-2] */
1331 
1332  /* Update state (input part) */
1333  x[1] = x[0];
1334  x[0] = signal[i];
1335 
1336  /* Convert back to Q0 and multiply with 2 */
1337  signal[i] = av_clip_intp2(tmp + 1024, 26) >> 11;
1338 
1339  /* Update state (filtered part) */
1340  y[2] = y[0];
1341  y[3] = y[1];
1342 
1343  /* upshift tmp by 3 with saturation */
1344  if (tmp > 268435455) {
1345  tmp = INT32_MAX;
1346  } else if (tmp < -268435456) {
1347  tmp = INT32_MIN;
1348  } else {
1349  tmp = tmp * 8;
1350  }
1351 
1352  y[0] = tmp >> 16;
1353  y[1] = (tmp - (y[0] * (1 << 16))) >> 1;
1354  }
1355 }
1356 
1357 static int ilbc_decode_frame(AVCodecContext *avctx, void *data,
1358  int *got_frame_ptr, AVPacket *avpkt)
1359 {
1360  const uint8_t *buf = avpkt->data;
1361  AVFrame *frame = data;
1362  ILBCContext *s = avctx->priv_data;
1363  int mode = s->mode, ret;
1364  int16_t *plc_data = &s->plc_residual[LPC_FILTERORDER];
1365 
1366  if ((ret = init_get_bits8(&s->gb, buf, avpkt->size)) < 0)
1367  return ret;
1368  memset(&s->frame, 0, sizeof(ILBCFrame));
1369 
1370  frame->nb_samples = s->block_samples;
1371  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1372  return ret;
1373 
1374  if (unpack_frame(s))
1375  mode = 0;
1376  if (s->frame.start < 1 || s->frame.start > 5)
1377  mode = 0;
1378 
1379  if (mode) {
1381 
1382  lsf_dequantization(s->lsfdeq, s->frame.lsf, s->lpc_n);
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 {
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 
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;
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;
1469  } else {
1470  s->block_samples = 160;
1471  s->nsub = NSUB_20MS;
1472  s->nasub = NASUB_20MS;
1473  s->lpc_n = LPC_N_20MS;
1475  }
1476 
1477  return 0;
1478 }
1479 
1481  .name = "ilbc",
1482  .long_name = NULL_IF_CONFIG_SMALL("iLBC (Internet Low Bitrate Codec)"),
1483  .type = AVMEDIA_TYPE_AUDIO,
1484  .id = AV_CODEC_ID_ILBC,
1485  .init = ilbc_decode_init,
1486  .decode = ilbc_decode_frame,
1487  .capabilities = AV_CODEC_CAP_DR1,
1488  .priv_data_size = sizeof(ILBCContext),
1489 };
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:268
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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:379
int block_samples
Definition: ilbcdec.c:102
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1615
#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:1478
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
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:3477
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2258
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:2229
int mem
Definition: avisynth_c.h:916
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
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define f(width, name)
Definition: cbs_vp9.c:255
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
uint8_t * data
Definition: avcodec.h:1477
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
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a source
ptrdiff_t size
Definition: opengl_enc.c:100
#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:1480
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
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:114
const char * name
Name of the codec implementation.
Definition: avcodec.h:3484
uint8_t bits
Definition: vp3data.h:202
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:2272
#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
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#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:760
#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:2221
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:677
int16_t prevScale
Definition: ilbcdec.c:119
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:1565
#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:1964
int16_t no_of_bytes
Definition: ilbcdec.c:104
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:766
#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:498
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;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);return NULL;}return ac;}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;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->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);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
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:282
#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:1445
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:1592
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:2222
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:1315
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
#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:1454
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&#39;ed).
Definition: ebur128.h:83
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:334
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
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:1357
#define LPC_FILTERORDER
Definition: ilbcdec.c:43
GLuint buffer
Definition: opengl_enc.c:101
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
int16_t no_of_words
Definition: ilbcdec.c:103
static uint8_t tmp[11]
Definition: aes_ctr.c:26