FFmpeg
opus_silk.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Andrew D'Addesio
3  * Copyright (c) 2013-2014 Mozilla Corporation
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Opus SILK decoder
25  */
26 
27 #include <stdint.h>
28 
29 #include "libavutil/mem.h"
30 #include "mathops.h"
31 #include "opus.h"
32 #include "opus_rc.h"
33 #include "opus_silk.h"
34 #include "opustab.h"
35 
36 #define ROUND_MULL(a,b,s) (((MUL64(a, b) >> ((s) - 1)) + 1) >> 1)
37 
38 typedef struct SilkFrame {
39  int coded;
40  int log_gain;
41  int16_t nlsf[16];
42  float lpc[16];
43 
44  float output [2 * SILK_HISTORY];
47 
49 } SilkFrame;
50 
51 struct SilkContext {
52  void *logctx;
54 
55  int midonly;
56  int subframes;
57  int sflength;
58  int flength;
60 
62  int wb;
63 
66  float stereo_weights[2];
67 
69 };
70 
71 static inline void silk_stabilize_lsf(int16_t nlsf[16], int order, const uint16_t min_delta[17])
72 {
73  int pass, i;
74  for (pass = 0; pass < 20; pass++) {
75  int k, min_diff = 0;
76  for (i = 0; i < order+1; i++) {
77  int low = i != 0 ? nlsf[i-1] : 0;
78  int high = i != order ? nlsf[i] : 32768;
79  int diff = (high - low) - (min_delta[i]);
80 
81  if (diff < min_diff) {
82  min_diff = diff;
83  k = i;
84 
85  if (pass == 20)
86  break;
87  }
88  }
89  if (min_diff == 0) /* no issues; stabilized */
90  return;
91 
92  /* wiggle one or two LSFs */
93  if (k == 0) {
94  /* repel away from lower bound */
95  nlsf[0] = min_delta[0];
96  } else if (k == order) {
97  /* repel away from higher bound */
98  nlsf[order-1] = 32768 - min_delta[order];
99  } else {
100  /* repel away from current position */
101  int min_center = 0, max_center = 32768, center_val;
102 
103  /* lower extent */
104  for (i = 0; i < k; i++)
105  min_center += min_delta[i];
106  min_center += min_delta[k] >> 1;
107 
108  /* upper extent */
109  for (i = order; i > k; i--)
110  max_center -= min_delta[i];
111  max_center -= min_delta[k] >> 1;
112 
113  /* move apart */
114  center_val = nlsf[k - 1] + nlsf[k];
115  center_val = (center_val >> 1) + (center_val & 1); // rounded divide by 2
116  center_val = FFMIN(max_center, FFMAX(min_center, center_val));
117 
118  nlsf[k - 1] = center_val - (min_delta[k] >> 1);
119  nlsf[k] = nlsf[k - 1] + min_delta[k];
120  }
121  }
122 
123  /* resort to the fall-back method, the standard method for LSF stabilization */
124 
125  /* sort; as the LSFs should be nearly sorted, use insertion sort */
126  for (i = 1; i < order; i++) {
127  int j, value = nlsf[i];
128  for (j = i - 1; j >= 0 && nlsf[j] > value; j--)
129  nlsf[j + 1] = nlsf[j];
130  nlsf[j + 1] = value;
131  }
132 
133  /* push forwards to increase distance */
134  if (nlsf[0] < min_delta[0])
135  nlsf[0] = min_delta[0];
136  for (i = 1; i < order; i++)
137  nlsf[i] = FFMAX(nlsf[i], FFMIN(nlsf[i - 1] + min_delta[i], 32767));
138 
139  /* push backwards to increase distance */
140  if (nlsf[order-1] > 32768 - min_delta[order])
141  nlsf[order-1] = 32768 - min_delta[order];
142  for (i = order-2; i >= 0; i--)
143  if (nlsf[i] > nlsf[i + 1] - min_delta[i+1])
144  nlsf[i] = nlsf[i + 1] - min_delta[i+1];
145 
146  return;
147 }
148 
149 static inline int silk_is_lpc_stable(const int16_t lpc[16], int order)
150 {
151  int k, j, DC_resp = 0;
152  int32_t lpc32[2][16]; // Q24
153  int totalinvgain = 1 << 30; // 1.0 in Q30
154  int32_t *row = lpc32[0], *prevrow;
155 
156  /* initialize the first row for the Levinson recursion */
157  for (k = 0; k < order; k++) {
158  DC_resp += lpc[k];
159  row[k] = lpc[k] * 4096;
160  }
161 
162  if (DC_resp >= 4096)
163  return 0;
164 
165  /* check if prediction gain pushes any coefficients too far */
166  for (k = order - 1; 1; k--) {
167  int rc; // Q31; reflection coefficient
168  int gaindiv; // Q30; inverse of the gain (the divisor)
169  int gain; // gain for this reflection coefficient
170  int fbits; // fractional bits used for the gain
171  int error; // Q29; estimate of the error of our partial estimate of 1/gaindiv
172 
173  if (FFABS(row[k]) > 16773022)
174  return 0;
175 
176  rc = -(row[k] * 128);
177  gaindiv = (1 << 30) - MULH(rc, rc);
178 
179  totalinvgain = MULH(totalinvgain, gaindiv) << 2;
180  if (k == 0)
181  return (totalinvgain >= 107374);
182 
183  /* approximate 1.0/gaindiv */
184  fbits = opus_ilog(gaindiv);
185  gain = ((1 << 29) - 1) / (gaindiv >> (fbits + 1 - 16)); // Q<fbits-16>
186  error = (1 << 29) - MULL(gaindiv << (15 + 16 - fbits), gain, 16);
187  gain = ((gain << 16) + (error * gain >> 13));
188 
189  /* switch to the next row of the LPC coefficients */
190  prevrow = row;
191  row = lpc32[k & 1];
192 
193  for (j = 0; j < k; j++) {
194  int x = av_sat_sub32(prevrow[j], ROUND_MULL(prevrow[k - j - 1], rc, 31));
195  int64_t tmp = ROUND_MULL(x, gain, fbits);
196 
197  /* per RFC 8251 section 6, if this calculation overflows, the filter
198  is considered unstable. */
199  if (tmp < INT32_MIN || tmp > INT32_MAX)
200  return 0;
201 
202  row[j] = (int32_t)tmp;
203  }
204  }
205 }
206 
207 static void silk_lsp2poly(const int32_t lsp[/* 2 * half_order - 1 */],
208  int32_t pol[/* half_order + 1 */], int half_order)
209 {
210  int i, j;
211 
212  pol[0] = 65536; // 1.0 in Q16
213  pol[1] = -lsp[0];
214 
215  for (i = 1; i < half_order; i++) {
216  pol[i + 1] = pol[i - 1] * 2 - ROUND_MULL(lsp[2 * i], pol[i], 16);
217  for (j = i; j > 1; j--)
218  pol[j] += pol[j - 2] - ROUND_MULL(lsp[2 * i], pol[j - 1], 16);
219 
220  pol[1] -= lsp[2 * i];
221  }
222 }
223 
224 static void silk_lsf2lpc(const int16_t nlsf[16], float lpcf[16], int order)
225 {
226  int i, k;
227  int32_t lsp[16]; // Q17; 2*cos(LSF)
228  int32_t p[9], q[9]; // Q16
229  int32_t lpc32[16]; // Q17
230  int16_t lpc[16]; // Q12
231 
232  /* convert the LSFs to LSPs, i.e. 2*cos(LSF) */
233  for (k = 0; k < order; k++) {
234  int index = nlsf[k] >> 8;
235  int offset = nlsf[k] & 255;
236  int k2 = (order == 10) ? ff_silk_lsf_ordering_nbmb[k] : ff_silk_lsf_ordering_wb[k];
237 
238  /* interpolate and round */
239  lsp[k2] = ff_silk_cosine[index] * 256;
240  lsp[k2] += (ff_silk_cosine[index + 1] - ff_silk_cosine[index]) * offset;
241  lsp[k2] = (lsp[k2] + 4) >> 3;
242  }
243 
244  silk_lsp2poly(lsp , p, order >> 1);
245  silk_lsp2poly(lsp + 1, q, order >> 1);
246 
247  /* reconstruct A(z) */
248  for (k = 0; k < order>>1; k++) {
249  int32_t p_tmp = p[k + 1] + p[k];
250  int32_t q_tmp = q[k + 1] - q[k];
251  lpc32[k] = -q_tmp - p_tmp;
252  lpc32[order-k-1] = q_tmp - p_tmp;
253  }
254 
255  /* limit the range of the LPC coefficients to each fit within an int16_t */
256  for (i = 0; i < 10; i++) {
257  int j;
258  unsigned int maxabs = 0;
259  for (j = 0, k = 0; j < order; j++) {
260  unsigned int x = FFABS(lpc32[k]);
261  if (x > maxabs) {
262  maxabs = x; // Q17
263  k = j;
264  }
265  }
266 
267  maxabs = (maxabs + 16) >> 5; // convert to Q12
268 
269  if (maxabs > 32767) {
270  /* perform bandwidth expansion */
271  unsigned int chirp, chirp_base; // Q16
272  maxabs = FFMIN(maxabs, 163838); // anything above this overflows chirp's numerator
273  chirp_base = chirp = 65470 - ((maxabs - 32767) << 14) / ((maxabs * (k+1)) >> 2);
274 
275  for (k = 0; k < order; k++) {
276  lpc32[k] = ROUND_MULL(lpc32[k], chirp, 16);
277  chirp = (chirp_base * chirp + 32768) >> 16;
278  }
279  } else break;
280  }
281 
282  if (i == 10) {
283  /* time's up: just clamp */
284  for (k = 0; k < order; k++) {
285  int x = (lpc32[k] + 16) >> 5;
286  lpc[k] = av_clip_int16(x);
287  lpc32[k] = lpc[k] << 5; // shortcut mandated by the spec; drops lower 5 bits
288  }
289  } else {
290  for (k = 0; k < order; k++)
291  lpc[k] = (lpc32[k] + 16) >> 5;
292  }
293 
294  /* if the prediction gain causes the LPC filter to become unstable,
295  apply further bandwidth expansion on the Q17 coefficients */
296  for (i = 1; i <= 16 && !silk_is_lpc_stable(lpc, order); i++) {
297  unsigned int chirp, chirp_base;
298  chirp_base = chirp = 65536 - (1 << i);
299 
300  for (k = 0; k < order; k++) {
301  lpc32[k] = ROUND_MULL(lpc32[k], chirp, 16);
302  lpc[k] = (lpc32[k] + 16) >> 5;
303  chirp = (chirp_base * chirp + 32768) >> 16;
304  }
305  }
306 
307  for (i = 0; i < order; i++)
308  lpcf[i] = lpc[i] / 4096.0f;
309 }
310 
312  OpusRangeCoder *rc,
313  float lpc_leadin[16], float lpc[16],
314  int *lpc_order, int *has_lpc_leadin, int voiced)
315 {
316  int i;
317  int order; // order of the LP polynomial; 10 for NB/MB and 16 for WB
318  int8_t lsf_i1, lsf_i2[16]; // stage-1 and stage-2 codebook indices
319  int16_t lsf_res[16]; // residual as a Q10 value
320  int16_t nlsf[16]; // Q15
321 
322  *lpc_order = order = s->wb ? 16 : 10;
323 
324  /* obtain LSF stage-1 and stage-2 indices */
325  lsf_i1 = ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s1[s->wb][voiced]);
326  for (i = 0; i < order; i++) {
327  int index = s->wb ? ff_silk_lsf_s2_model_sel_wb [lsf_i1][i] :
329  lsf_i2[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s2[index]) - 4;
330  if (lsf_i2[i] == -4)
332  else if (lsf_i2[i] == 4)
334  }
335 
336  /* reverse the backwards-prediction step */
337  for (i = order - 1; i >= 0; i--) {
338  int qstep = s->wb ? 9830 : 11796;
339 
340  lsf_res[i] = lsf_i2[i] * 1024;
341  if (lsf_i2[i] < 0) lsf_res[i] += 102;
342  else if (lsf_i2[i] > 0) lsf_res[i] -= 102;
343  lsf_res[i] = (lsf_res[i] * qstep) >> 16;
344 
345  if (i + 1 < order) {
348  lsf_res[i] += (lsf_res[i+1] * weight) >> 8;
349  }
350  }
351 
352  /* reconstruct the NLSF coefficients from the supplied indices */
353  for (i = 0; i < order; i++) {
354  const uint8_t * codebook = s->wb ? ff_silk_lsf_codebook_wb [lsf_i1] :
356  int cur, prev, next, weight_sq, weight, ipart, fpart, y, value;
357 
358  /* find the weight of the residual */
359  /* TODO: precompute */
360  cur = codebook[i];
361  prev = i ? codebook[i - 1] : 0;
362  next = i + 1 < order ? codebook[i + 1] : 256;
363  weight_sq = (1024 / (cur - prev) + 1024 / (next - cur)) << 16;
364 
365  /* approximate square-root with mandated fixed-point arithmetic */
366  ipart = opus_ilog(weight_sq);
367  fpart = (weight_sq >> (ipart-8)) & 127;
368  y = ((ipart & 1) ? 32768 : 46214) >> ((32 - ipart)>>1);
369  weight = y + ((213 * fpart * y) >> 16);
370 
371  value = cur * 128 + (lsf_res[i] * 16384) / weight;
372  nlsf[i] = av_clip_uintp2(value, 15);
373  }
374 
375  /* stabilize the NLSF coefficients */
376  silk_stabilize_lsf(nlsf, order, s->wb ? ff_silk_lsf_min_spacing_wb :
378 
379  /* produce an interpolation for the first 2 subframes, */
380  /* and then convert both sets of NLSFs to LPC coefficients */
381  *has_lpc_leadin = 0;
382  if (s->subframes == 4) {
384  if (offset != 4 && frame->coded) {
385  *has_lpc_leadin = 1;
386  if (offset != 0) {
387  int16_t nlsf_leadin[16];
388  for (i = 0; i < order; i++)
389  nlsf_leadin[i] = frame->nlsf[i] +
390  ((nlsf[i] - frame->nlsf[i]) * offset >> 2);
391  silk_lsf2lpc(nlsf_leadin, lpc_leadin, order);
392  } else /* avoid re-computation for a (roughly) 1-in-4 occurrence */
393  memcpy(lpc_leadin, frame->lpc, 16 * sizeof(float));
394  } else
395  offset = 4;
396  s->nlsf_interp_factor = offset;
397 
398  silk_lsf2lpc(nlsf, lpc, order);
399  } else {
400  s->nlsf_interp_factor = 4;
401  silk_lsf2lpc(nlsf, lpc, order);
402  }
403 
404  memcpy(frame->nlsf, nlsf, order * sizeof(nlsf[0]));
405  memcpy(frame->lpc, lpc, order * sizeof(lpc[0]));
406 }
407 
408 static inline void silk_count_children(OpusRangeCoder *rc, int model, int32_t total,
409  int32_t child[2])
410 {
411  if (total != 0) {
412  child[0] = ff_opus_rc_dec_cdf(rc,
413  ff_silk_model_pulse_location[model] + (((total - 1 + 5) * (total - 1)) >> 1));
414  child[1] = total - child[0];
415  } else {
416  child[0] = 0;
417  child[1] = 0;
418  }
419 }
420 
422  float* excitationf,
423  int qoffset_high, int active, int voiced)
424 {
425  int i;
426  uint32_t seed;
427  int shellblocks;
428  int ratelevel;
429  uint8_t pulsecount[20]; // total pulses in each shell block
430  uint8_t lsbcount[20] = {0}; // raw lsbits defined for each pulse in each shell block
431  int32_t excitation[320]; // Q23
432 
433  /* excitation parameters */
435  shellblocks = ff_silk_shell_blocks[s->bandwidth][s->subframes >> 2];
436  ratelevel = ff_opus_rc_dec_cdf(rc, ff_silk_model_exc_rate[voiced]);
437 
438  for (i = 0; i < shellblocks; i++) {
439  pulsecount[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_pulse_count[ratelevel]);
440  if (pulsecount[i] == 17) {
441  while (pulsecount[i] == 17 && ++lsbcount[i] != 10)
442  pulsecount[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_pulse_count[9]);
443  if (lsbcount[i] == 10)
444  pulsecount[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_pulse_count[10]);
445  }
446  }
447 
448  /* decode pulse locations using PVQ */
449  for (i = 0; i < shellblocks; i++) {
450  if (pulsecount[i] != 0) {
451  int a, b, c, d;
452  int32_t * location = excitation + 16*i;
453  int32_t branch[4][2];
454  branch[0][0] = pulsecount[i];
455 
456  /* unrolled tail recursion */
457  for (a = 0; a < 1; a++) {
458  silk_count_children(rc, 0, branch[0][a], branch[1]);
459  for (b = 0; b < 2; b++) {
460  silk_count_children(rc, 1, branch[1][b], branch[2]);
461  for (c = 0; c < 2; c++) {
462  silk_count_children(rc, 2, branch[2][c], branch[3]);
463  for (d = 0; d < 2; d++) {
464  silk_count_children(rc, 3, branch[3][d], location);
465  location += 2;
466  }
467  }
468  }
469  }
470  } else
471  memset(excitation + 16*i, 0, 16*sizeof(int32_t));
472  }
473 
474  /* decode least significant bits */
475  for (i = 0; i < shellblocks << 4; i++) {
476  int bit;
477  for (bit = 0; bit < lsbcount[i >> 4]; bit++)
478  excitation[i] = (excitation[i] << 1) |
480  }
481 
482  /* decode signs */
483  for (i = 0; i < shellblocks << 4; i++) {
484  if (excitation[i] != 0) {
485  int sign = ff_opus_rc_dec_cdf(rc, ff_silk_model_excitation_sign[active +
486  voiced][qoffset_high][FFMIN(pulsecount[i >> 4], 6)]);
487  if (sign == 0)
488  excitation[i] *= -1;
489  }
490  }
491 
492  /* assemble the excitation */
493  for (i = 0; i < shellblocks << 4; i++) {
494  int value = excitation[i];
495  excitation[i] = value * 256 | ff_silk_quant_offset[voiced][qoffset_high];
496  if (value < 0) excitation[i] += 20;
497  else if (value > 0) excitation[i] -= 20;
498 
499  /* invert samples pseudorandomly */
500  seed = 196314165 * seed + 907633515;
501  if (seed & 0x80000000)
502  excitation[i] *= -1;
503  seed += value;
504 
505  excitationf[i] = excitation[i] / 8388608.0f;
506  }
507 }
508 
509 /** Maximum residual history according to 4.2.7.6.1 */
510 #define SILK_MAX_LAG (288 + LTP_ORDER / 2)
511 
512 /** Order of the LTP filter */
513 #define LTP_ORDER 5
514 
516  int frame_num, int channel, int coded_channels,
517  int active, int active1, int redundant)
518 {
519  /* per frame */
520  int voiced; // combines with active to indicate inactive, active, or active+voiced
521  int qoffset_high;
522  int order; // order of the LPC coefficients
523  float lpc_leadin[16], lpc_body[16], residual[SILK_MAX_LAG + SILK_HISTORY];
524  int has_lpc_leadin;
525  float ltpscale;
526 
527  /* per subframe */
528  struct {
529  float gain;
530  int pitchlag;
531  float ltptaps[5];
532  } sf[4];
533 
534  SilkFrame * const frame = s->frame + channel;
535 
536  int i;
537 
538  /* obtain stereo weights */
539  if (coded_channels == 2 && channel == 0) {
540  int n, wi[2], ws[2], w[2];
542  wi[0] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s2) + 3 * (n / 5);
544  wi[1] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s2) + 3 * (n % 5);
546 
547  for (i = 0; i < 2; i++)
548  w[i] = ff_silk_stereo_weights[wi[i]] +
549  (((ff_silk_stereo_weights[wi[i] + 1] - ff_silk_stereo_weights[wi[i]]) * 6554) >> 16)
550  * (ws[i]*2 + 1);
551 
552  s->stereo_weights[0] = (w[0] - w[1]) / 8192.0;
553  s->stereo_weights[1] = w[1] / 8192.0;
554 
555  /* and read the mid-only flag */
556  s->midonly = active1 ? 0 : ff_opus_rc_dec_cdf(rc, ff_silk_model_mid_only);
557  }
558 
559  /* obtain frame type */
560  if (!active) {
562  voiced = 0;
563  } else {
565  qoffset_high = type & 1;
566  voiced = type >> 1;
567  }
568 
569  /* obtain subframe quantization gains */
570  for (i = 0; i < s->subframes; i++) {
571  int log_gain; //Q7
572  int ipart, fpart, lingain;
573 
574  if (i == 0 && (frame_num == 0 || !frame->coded)) {
575  /* gain is coded absolute */
576  int x = ff_opus_rc_dec_cdf(rc, ff_silk_model_gain_highbits[active + voiced]);
577  log_gain = (x<<3) | ff_opus_rc_dec_cdf(rc, ff_silk_model_gain_lowbits);
578 
579  if (frame->coded)
580  log_gain = FFMAX(log_gain, frame->log_gain - 16);
581  } else {
582  /* gain is coded relative */
583  int delta_gain = ff_opus_rc_dec_cdf(rc, ff_silk_model_gain_delta);
584  log_gain = av_clip_uintp2(FFMAX((delta_gain<<1) - 16,
585  frame->log_gain + delta_gain - 4), 6);
586  }
587 
588  frame->log_gain = log_gain;
589 
590  /* approximate 2**(x/128) with a Q7 (i.e. non-integer) input */
591  log_gain = (log_gain * 0x1D1C71 >> 16) + 2090;
592  ipart = log_gain >> 7;
593  fpart = log_gain & 127;
594  lingain = (1 << ipart) + ((-174 * fpart * (128-fpart) >>16) + fpart) * ((1<<ipart) >> 7);
595  sf[i].gain = lingain / 65536.0f;
596  }
597 
598  /* obtain LPC filter coefficients */
599  silk_decode_lpc(s, frame, rc, lpc_leadin, lpc_body, &order, &has_lpc_leadin, voiced);
600 
601  /* obtain pitch lags, if this is a voiced frame */
602  if (voiced) {
603  int lag_absolute = (!frame_num || !frame->prev_voiced);
604  int primarylag; // primary pitch lag for the entire SILK frame
605  int ltpfilter;
606  const int8_t * offsets;
607 
608  if (!lag_absolute) {
610  if (delta)
611  primarylag = frame->primarylag + delta - 9;
612  else
613  lag_absolute = 1;
614  }
615 
616  if (lag_absolute) {
617  /* primary lag is coded absolute */
618  int highbits, lowbits;
619  static const uint16_t * const model[] = {
622  };
624  lowbits = ff_opus_rc_dec_cdf(rc, model[s->bandwidth]);
625 
626  primarylag = ff_silk_pitch_min_lag[s->bandwidth] +
627  highbits*ff_silk_pitch_scale[s->bandwidth] + lowbits;
628  }
629  frame->primarylag = primarylag;
630 
631  if (s->subframes == 2)
632  offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
637  else
638  offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
643 
644  for (i = 0; i < s->subframes; i++)
645  sf[i].pitchlag = av_clip(primarylag + offsets[i],
646  ff_silk_pitch_min_lag[s->bandwidth],
647  ff_silk_pitch_max_lag[s->bandwidth]);
648 
649  /* obtain LTP filter coefficients */
651  for (i = 0; i < s->subframes; i++) {
652  int index, j;
653  static const uint16_t * const filter_sel[] = {
656  };
657  static const int8_t (* const filter_taps[])[5] = {
659  };
660  index = ff_opus_rc_dec_cdf(rc, filter_sel[ltpfilter]);
661  for (j = 0; j < 5; j++)
662  sf[i].ltptaps[j] = filter_taps[ltpfilter][index][j] / 128.0f;
663  }
664  }
665 
666  /* obtain LTP scale factor */
667  if (voiced && frame_num == 0)
669  ff_silk_model_ltp_scale_index)] / 16384.0f;
670  else ltpscale = 15565.0f/16384.0f;
671 
672  /* generate the excitation signal for the entire frame */
673  silk_decode_excitation(s, rc, residual + SILK_MAX_LAG, qoffset_high,
674  active, voiced);
675 
676  /* skip synthesising the output if we do not need it */
677  // TODO: implement error recovery
678  if (s->output_channels == channel || redundant)
679  return;
680 
681  /* generate the output signal */
682  for (i = 0; i < s->subframes; i++) {
683  const float * lpc_coeff = (i < 2 && has_lpc_leadin) ? lpc_leadin : lpc_body;
684  float *dst = frame->output + SILK_HISTORY + i * s->sflength;
685  float *resptr = residual + SILK_MAX_LAG + i * s->sflength;
686  float *lpc = frame->lpc_history + SILK_HISTORY + i * s->sflength;
687  float sum;
688  int j, k;
689 
690  if (voiced) {
691  int out_end;
692  float scale;
693 
694  if (i < 2 || s->nlsf_interp_factor == 4) {
695  out_end = -i * s->sflength;
696  scale = ltpscale;
697  } else {
698  out_end = -(i - 2) * s->sflength;
699  scale = 1.0f;
700  }
701 
702  /* when the LPC coefficients change, a re-whitening filter is used */
703  /* to produce a residual that accounts for the change */
704  for (j = - sf[i].pitchlag - LTP_ORDER/2; j < out_end; j++) {
705  sum = dst[j];
706  for (k = 0; k < order; k++)
707  sum -= lpc_coeff[k] * dst[j - k - 1];
708  resptr[j] = av_clipf(sum, -1.0f, 1.0f) * scale / sf[i].gain;
709  }
710 
711  if (out_end) {
712  float rescale = sf[i-1].gain / sf[i].gain;
713  for (j = out_end; j < 0; j++)
714  resptr[j] *= rescale;
715  }
716 
717  /* LTP synthesis */
718  for (j = 0; j < s->sflength; j++) {
719  sum = resptr[j];
720  for (k = 0; k < LTP_ORDER; k++)
721  sum += sf[i].ltptaps[k] * resptr[j - sf[i].pitchlag + LTP_ORDER/2 - k];
722  resptr[j] = sum;
723  }
724  }
725 
726  /* LPC synthesis */
727  for (j = 0; j < s->sflength; j++) {
728  sum = resptr[j] * sf[i].gain;
729  for (k = 1; k <= order; k++)
730  sum += lpc_coeff[k - 1] * lpc[j - k];
731 
732  lpc[j] = sum;
733  dst[j] = av_clipf(sum, -1.0f, 1.0f);
734  }
735  }
736 
737  frame->prev_voiced = voiced;
738  memmove(frame->lpc_history, frame->lpc_history + s->flength, SILK_HISTORY * sizeof(float));
739  memmove(frame->output, frame->output + s->flength, SILK_HISTORY * sizeof(float));
740 
741  frame->coded = 1;
742 }
743 
744 static void silk_unmix_ms(SilkContext *s, float *l, float *r)
745 {
746  float *mid = s->frame[0].output + SILK_HISTORY - s->flength;
747  float *side = s->frame[1].output + SILK_HISTORY - s->flength;
748  float w0_prev = s->prev_stereo_weights[0];
749  float w1_prev = s->prev_stereo_weights[1];
750  float w0 = s->stereo_weights[0];
751  float w1 = s->stereo_weights[1];
752  int n1 = ff_silk_stereo_interp_len[s->bandwidth];
753  int i;
754 
755  for (i = 0; i < n1; i++) {
756  float interp0 = w0_prev + i * (w0 - w0_prev) / n1;
757  float interp1 = w1_prev + i * (w1 - w1_prev) / n1;
758  float p0 = 0.25 * (mid[i - 2] + 2 * mid[i - 1] + mid[i]);
759 
760  l[i] = av_clipf((1 + interp1) * mid[i - 1] + side[i - 1] + interp0 * p0, -1.0, 1.0);
761  r[i] = av_clipf((1 - interp1) * mid[i - 1] - side[i - 1] - interp0 * p0, -1.0, 1.0);
762  }
763 
764  for (; i < s->flength; i++) {
765  float p0 = 0.25 * (mid[i - 2] + 2 * mid[i - 1] + mid[i]);
766 
767  l[i] = av_clipf((1 + w1) * mid[i - 1] + side[i - 1] + w0 * p0, -1.0, 1.0);
768  r[i] = av_clipf((1 - w1) * mid[i - 1] - side[i - 1] - w0 * p0, -1.0, 1.0);
769  }
770 
771  memcpy(s->prev_stereo_weights, s->stereo_weights, sizeof(s->stereo_weights));
772 }
773 
775 {
776  if (!frame->coded)
777  return;
778 
779  memset(frame->output, 0, sizeof(frame->output));
780  memset(frame->lpc_history, 0, sizeof(frame->lpc_history));
781 
782  memset(frame->lpc, 0, sizeof(frame->lpc));
783  memset(frame->nlsf, 0, sizeof(frame->nlsf));
784 
785  frame->log_gain = 0;
786 
787  frame->primarylag = 0;
788  frame->prev_voiced = 0;
789  frame->coded = 0;
790 }
791 
793  float *output[2],
794  enum OpusBandwidth bandwidth,
795  int coded_channels,
796  int duration_ms)
797 {
798  int active[2][6], redundancy[2];
799  int nb_frames, i, j;
800 
801  if (bandwidth > OPUS_BANDWIDTH_WIDEBAND ||
802  coded_channels > 2 || duration_ms > 60) {
803  av_log(s->logctx, AV_LOG_ERROR, "Invalid parameters passed "
804  "to the SILK decoder.\n");
805  return AVERROR(EINVAL);
806  }
807 
808  nb_frames = 1 + (duration_ms > 20) + (duration_ms > 40);
809  s->subframes = duration_ms / nb_frames / 5; // 5ms subframes
810  s->sflength = 20 * (bandwidth + 2);
811  s->flength = s->sflength * s->subframes;
812  s->bandwidth = bandwidth;
813  s->wb = bandwidth == OPUS_BANDWIDTH_WIDEBAND;
814 
815  /* make sure to flush the side channel when switching from mono to stereo */
816  if (coded_channels > s->prev_coded_channels)
817  silk_flush_frame(&s->frame[1]);
818  s->prev_coded_channels = coded_channels;
819 
820  /* read the LP-layer header bits */
821  for (i = 0; i < coded_channels; i++) {
822  for (j = 0; j < nb_frames; j++)
823  active[i][j] = ff_opus_rc_dec_log(rc, 1);
824 
825  redundancy[i] = ff_opus_rc_dec_log(rc, 1);
826  }
827 
828  /* read the per-frame LBRR flags */
829  for (i = 0; i < coded_channels; i++)
830  if (redundancy[i] && duration_ms > 20) {
831  redundancy[i] = ff_opus_rc_dec_cdf(rc, duration_ms == 40 ?
833  }
834 
835  /* decode the LBRR frames */
836  for (i = 0; i < nb_frames; i++) {
837  for (j = 0; j < coded_channels; j++)
838  if (redundancy[j] & (1 << i)) {
839  int active1 = (j == 0 && !(redundancy[1] & (1 << i))) ? 0 : 1;
840  silk_decode_frame(s, rc, i, j, coded_channels, 1, active1, 1);
841  }
842 
843  s->midonly = 0;
844  }
845 
846  for (i = 0; i < nb_frames; i++) {
847  for (j = 0; j < coded_channels && !s->midonly; j++)
848  silk_decode_frame(s, rc, i, j, coded_channels, active[j][i], active[1][i], 0);
849 
850  /* reset the side channel if it is not coded */
851  if (s->midonly && s->frame[1].coded)
852  silk_flush_frame(&s->frame[1]);
853 
854  if (coded_channels == 1 || s->output_channels == 1) {
855  for (j = 0; j < s->output_channels; j++) {
856  memcpy(output[j] + i * s->flength,
857  s->frame[0].output + SILK_HISTORY - s->flength - 2,
858  s->flength * sizeof(float));
859  }
860  } else {
861  silk_unmix_ms(s, output[0] + i * s->flength, output[1] + i * s->flength);
862  }
863 
864  s->midonly = 0;
865  }
866 
867  return nb_frames * s->flength;
868 }
869 
871 {
872  av_freep(ps);
873 }
874 
876 {
877  silk_flush_frame(&s->frame[0]);
878  silk_flush_frame(&s->frame[1]);
879 
880  memset(s->prev_stereo_weights, 0, sizeof(s->prev_stereo_weights));
881 }
882 
883 int ff_silk_init(void *logctx, SilkContext **ps, int output_channels)
884 {
885  SilkContext *s;
886 
887  if (output_channels != 1 && output_channels != 2) {
888  av_log(logctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",
889  output_channels);
890  return AVERROR(EINVAL);
891  }
892 
893  s = av_mallocz(sizeof(*s));
894  if (!s)
895  return AVERROR(ENOMEM);
896 
897  s->logctx = logctx;
898  s->output_channels = output_channels;
899 
900  ff_silk_flush(s);
901 
902  *ps = s;
903 
904  return 0;
905 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
ff_silk_model_ltp_filter1_sel
const uint16_t ff_silk_model_ltp_filter1_sel[]
Definition: opustab.c:146
ff_silk_model_lbrr_flags_40
const uint16_t ff_silk_model_lbrr_flags_40[]
Definition: opustab.c:31
ff_silk_model_mid_only
const uint16_t ff_silk_model_mid_only[]
Definition: opustab.c:43
silk_flush_frame
static void silk_flush_frame(SilkFrame *frame)
Definition: opus_silk.c:774
ff_silk_model_exc_rate
const uint16_t ff_silk_model_exc_rate[2][10]
Definition: opustab.c:159
ff_silk_model_lsf_interpolation_offset
const uint16_t ff_silk_model_lsf_interpolation_offset[]
Definition: opustab.c:106
av_clip
#define av_clip
Definition: common.h:99
SilkFrame::lpc_history
float lpc_history[2 *SILK_HISTORY]
Definition: opus_silk.c:45
r
const char * r
Definition: vf_curves.c:127
LTP_ORDER
#define LTP_ORDER
Order of the LTP filter.
Definition: opus_silk.c:513
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_silk_model_lsf_s2
const uint16_t ff_silk_model_lsf_s2[32][10]
Definition: opustab.c:82
OPUS_BANDWIDTH_NARROWBAND
@ OPUS_BANDWIDTH_NARROWBAND
Definition: opus.h:50
opus_ilog
#define opus_ilog(i)
Definition: opus_rc.h:30
SilkContext::prev_stereo_weights
float prev_stereo_weights[2]
Definition: opus_silk.c:65
ff_silk_model_pitch_contour_mbwb10ms
const uint16_t ff_silk_model_pitch_contour_mbwb10ms[]
Definition: opustab.c:130
ff_silk_lsf_ordering_nbmb
const uint8_t ff_silk_lsf_ordering_nbmb[]
Definition: opustab.c:554
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:123
SilkContext::output_channels
int output_channels
Definition: opus_silk.c:53
output
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
Definition: filter_design.txt:225
ff_silk_pitch_max_lag
const uint16_t ff_silk_pitch_max_lag[]
Definition: opustab.c:602
SilkContext::flength
int flength
Definition: opus_silk.c:58
SilkContext::logctx
void * logctx
Definition: opus_silk.c:52
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
w
uint8_t w
Definition: llviddspenc.c:38
SilkFrame::log_gain
int log_gain
Definition: opus_silk.c:40
SilkFrame::output
float output[2 *SILK_HISTORY]
Definition: opus_silk.c:44
b
#define b
Definition: input.c:41
ff_silk_model_frame_type_active
const uint16_t ff_silk_model_frame_type_active[]
Definition: opustab.c:47
opus.h
ff_silk_pitch_offset_nb20ms
const int8_t ff_silk_pitch_offset_nb20ms[11][4]
Definition: opustab.c:610
SilkContext::frame
SilkFrame frame[2]
Definition: opus_silk.c:64
ff_silk_model_gain_delta
const uint16_t ff_silk_model_gain_delta[]
Definition: opustab.c:57
silk_stabilize_lsf
static void silk_stabilize_lsf(int16_t nlsf[16], int order, const uint16_t min_delta[17])
Definition: opus_silk.c:71
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_silk_model_lsf_s1
const uint16_t ff_silk_model_lsf_s1[2][2][33]
Definition: opustab.c:62
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:56
ff_silk_shell_blocks
const uint8_t ff_silk_shell_blocks[3][2]
Definition: opustab.c:743
ff_silk_flush
void ff_silk_flush(SilkContext *s)
Definition: opus_silk.c:875
ff_silk_stereo_weights
const int16_t ff_silk_stereo_weights[]
Definition: opustab.c:321
ff_silk_model_ltp_scale_index
const uint16_t ff_silk_model_ltp_scale_index[]
Definition: opustab.c:155
SilkContext::bandwidth
enum OpusBandwidth bandwidth
Definition: opus_silk.c:61
ff_silk_lsf_codebook_wb
const uint8_t ff_silk_lsf_codebook_wb[32][16]
Definition: opustab.c:511
SilkFrame
Definition: opus_silk.c:38
ff_silk_model_pitch_contour_nb10ms
const uint16_t ff_silk_model_pitch_contour_nb10ms[]
Definition: opustab.c:124
ff_silk_model_pulse_location
const uint16_t ff_silk_model_pulse_location[4][168]
Definition: opustab.c:189
MULH
#define MULH
Definition: mathops.h:42
ff_silk_pitch_offset_mbwb20ms
const int8_t ff_silk_pitch_offset_mbwb20ms[34][4]
Definition: opustab.c:639
type
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 type
Definition: writing_filters.txt:86
silk_lsp2poly
static void silk_lsp2poly(const int32_t lsp[], int32_t pol[], int half_order)
Definition: opus_silk.c:207
ff_silk_model_excitation_lsb
const uint16_t ff_silk_model_excitation_lsb[]
Definition: opustab.c:261
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_silk_lsf_s2_model_sel_wb
const uint8_t ff_silk_lsf_s2_model_sel_wb[32][16]
Definition: opustab.c:361
SilkFrame::lpc
float lpc[16]
Definition: opus_silk.c:42
s
#define s(width, name)
Definition: cbs_vp9.c:198
offsets
static const int offsets[]
Definition: hevc_pel.c:34
SILK_HISTORY
#define SILK_HISTORY
Definition: opus_silk.h:29
ff_silk_pitch_offset_mbwb10ms
const int8_t ff_silk_pitch_offset_mbwb10ms[12][2]
Definition: opustab.c:624
av_sat_sub32
#define av_sat_sub32
Definition: common.h:135
ff_silk_lsf_s2_model_sel_nbmb
const uint8_t ff_silk_lsf_s2_model_sel_nbmb[32][10]
Definition: opustab.c:326
SilkContext
Definition: opus_silk.c:51
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
OPUS_BANDWIDTH_WIDEBAND
@ OPUS_BANDWIDTH_WIDEBAND
Definition: opus.h:52
silk_decode_lpc
static void silk_decode_lpc(SilkContext *s, SilkFrame *frame, OpusRangeCoder *rc, float lpc_leadin[16], float lpc[16], int *lpc_order, int *has_lpc_leadin, int voiced)
Definition: opus_silk.c:311
SILK_MAX_LAG
#define SILK_MAX_LAG
Maximum residual history according to 4.2.7.6.1.
Definition: opus_silk.c:510
ff_silk_model_gain_lowbits
const uint16_t ff_silk_model_gain_lowbits[]
Definition: opustab.c:55
av_clip_int16
#define av_clip_int16
Definition: common.h:114
SilkFrame::nlsf
int16_t nlsf[16]
Definition: opus_silk.c:41
ff_silk_model_stereo_s3
const uint16_t ff_silk_model_stereo_s3[]
Definition: opustab.c:41
mathops.h
ff_silk_quant_offset
const uint8_t ff_silk_quant_offset[2][2]
Definition: opustab.c:749
av_clipf
av_clipf
Definition: af_crystalizer.c:121
ff_silk_pitch_offset_nb10ms
const int8_t ff_silk_pitch_offset_nb10ms[3][2]
Definition: opustab.c:604
seed
static unsigned int seed
Definition: videogen.c:78
ff_silk_model_ltp_filter2_sel
const uint16_t ff_silk_model_ltp_filter2_sel[]
Definition: opustab.c:150
ff_silk_model_excitation_sign
const uint16_t ff_silk_model_excitation_sign[3][2][7][3]
Definition: opustab.c:263
ff_silk_init
int ff_silk_init(void *logctx, SilkContext **ps, int output_channels)
Definition: opus_silk.c:883
ff_silk_lsf_min_spacing_nbmb
const uint16_t ff_silk_lsf_min_spacing_nbmb[]
Definition: opustab.c:546
SilkContext::subframes
int subframes
Definition: opus_silk.c:56
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
weight
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1563
ff_silk_pitch_min_lag
const uint16_t ff_silk_pitch_min_lag[]
Definition: opustab.c:600
silk_unmix_ms
static void silk_unmix_ms(SilkContext *s, float *l, float *r)
Definition: opus_silk.c:744
ff_silk_lsf_codebook_nbmb
const uint8_t ff_silk_lsf_codebook_nbmb[32][10]
Definition: opustab.c:476
ff_silk_model_pitch_lowbits_nb
const uint16_t ff_silk_model_pitch_lowbits_nb[]
Definition: opustab.c:113
ff_silk_model_pitch_delta
const uint16_t ff_silk_model_pitch_delta[]
Definition: opustab.c:119
ff_silk_model_ltp_filter0_sel
const uint16_t ff_silk_model_ltp_filter0_sel[]
Definition: opustab.c:142
opustab.h
f
f
Definition: af_crystalizer.c:121
ff_silk_lsf_weight_sel_wb
const uint8_t ff_silk_lsf_weight_sel_wb[32][15]
Definition: opustab.c:441
ff_silk_model_pitch_contour_mbwb20ms
const uint16_t ff_silk_model_pitch_contour_mbwb20ms[]
Definition: opustab.c:134
rescale
static void rescale(GDVContext *gdv, uint8_t *dst, int w, int h, int scale_v, int scale_h)
Definition: gdv.c:132
ff_silk_lsf_ordering_wb
const uint8_t ff_silk_lsf_ordering_wb[]
Definition: opustab.c:558
ff_silk_lsf_pred_weights_wb
const uint8_t ff_silk_lsf_pred_weights_wb[2][15]
Definition: opustab.c:401
OpusRangeCoder
Definition: opus_rc.h:39
silk_lsf2lpc
static void silk_lsf2lpc(const int16_t nlsf[16], float lpcf[16], int order)
Definition: opus_silk.c:224
silk_decode_frame
static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc, int frame_num, int channel, int coded_channels, int active, int active1, int redundant)
Definition: opus_silk.c:515
ff_silk_model_pitch_highbits
const uint16_t ff_silk_model_pitch_highbits[]
Definition: opustab.c:108
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
ff_silk_ltp_filter2_taps
const int8_t ff_silk_ltp_filter2_taps[32][5]
Definition: opustab.c:706
a
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:41
silk_count_children
static void silk_count_children(OpusRangeCoder *rc, int model, int32_t total, int32_t child[2])
Definition: opus_silk.c:408
offset
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
Definition: writing_filters.txt:86
silk_is_lpc_stable
static int silk_is_lpc_stable(const int16_t lpc[16], int order)
Definition: opus_silk.c:149
ff_opus_rc_dec_cdf
uint32_t ff_opus_rc_dec_cdf(OpusRangeCoder *rc, const uint16_t *cdf)
Definition: opus_rc.c:90
ff_silk_cosine
const int16_t ff_silk_cosine[]
Definition: opustab.c:562
ff_silk_model_stereo_s1
const uint16_t ff_silk_model_stereo_s1[]
Definition: opustab.c:34
ff_silk_model_pitch_contour_nb20ms
const uint16_t ff_silk_model_pitch_contour_nb20ms[]
Definition: opustab.c:126
ff_silk_ltp_filter0_taps
const int8_t ff_silk_ltp_filter0_taps[8][5]
Definition: opustab.c:676
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ff_silk_stereo_interp_len
const int ff_silk_stereo_interp_len[3]
Definition: opustab.c:754
ff_silk_model_pulse_count
const uint16_t ff_silk_model_pulse_count[11][19]
Definition: opustab.c:164
ff_silk_free
void ff_silk_free(SilkContext **ps)
Definition: opus_silk.c:870
SilkContext::nlsf_interp_factor
int nlsf_interp_factor
Definition: opus_silk.c:59
SilkFrame::coded
int coded
Definition: opus_silk.c:39
delta
float delta
Definition: vorbis_enc_data.h:430
value
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 default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
SilkContext::prev_coded_channels
int prev_coded_channels
Definition: opus_silk.c:68
ff_silk_model_pitch_lowbits_mb
const uint16_t ff_silk_model_pitch_lowbits_mb[]
Definition: opustab.c:115
frame
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
Definition: filter_design.txt:264
ff_silk_lsf_weight_sel_nbmb
const uint8_t ff_silk_lsf_weight_sel_nbmb[32][9]
Definition: opustab.c:406
silk_decode_excitation
static void silk_decode_excitation(SilkContext *s, OpusRangeCoder *rc, float *excitationf, int qoffset_high, int active, int voiced)
Definition: opus_silk.c:421
ff_silk_model_frame_type_inactive
const uint16_t ff_silk_model_frame_type_inactive[]
Definition: opustab.c:45
ff_silk_model_lsf_s2_ext
const uint16_t ff_silk_model_lsf_s2_ext[]
Definition: opustab.c:104
SilkFrame::primarylag
int primarylag
Definition: opus_silk.c:46
ff_silk_model_gain_highbits
const uint16_t ff_silk_model_gain_highbits[3][9]
Definition: opustab.c:49
SilkContext::stereo_weights
float stereo_weights[2]
Definition: opus_silk.c:66
SilkContext::sflength
int sflength
Definition: opus_silk.c:57
ff_silk_lsf_min_spacing_wb
const uint16_t ff_silk_lsf_min_spacing_wb[]
Definition: opustab.c:550
ROUND_MULL
#define ROUND_MULL(a, b, s)
Definition: opus_silk.c:36
SilkContext::midonly
int midonly
Definition: opus_silk.c:55
mem.h
ff_silk_pitch_scale
const uint16_t ff_silk_pitch_scale[]
Definition: opustab.c:598
ff_silk_ltp_scale_factor
const uint16_t ff_silk_ltp_scale_factor[]
Definition: opustab.c:741
ff_silk_ltp_filter1_taps
const int8_t ff_silk_ltp_filter1_taps[16][5]
Definition: opustab.c:687
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
SilkContext::wb
int wb
Definition: opus_silk.c:62
ff_silk_lsf_pred_weights_nbmb
const uint8_t ff_silk_lsf_pred_weights_nbmb[2][9]
Definition: opustab.c:396
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
ff_silk_model_ltp_filter
const uint16_t ff_silk_model_ltp_filter[]
Definition: opustab.c:140
d
d
Definition: ffmpeg_filter.c:424
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_silk_model_stereo_s2
const uint16_t ff_silk_model_stereo_s2[]
Definition: opustab.c:39
ff_opus_rc_dec_log
uint32_t ff_opus_rc_dec_log(OpusRangeCoder *rc, uint32_t bits)
Definition: opus_rc.c:114
ff_silk_decode_superframe
int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc, float *output[2], enum OpusBandwidth bandwidth, int coded_channels, int duration_ms)
Decode the LP layer of one Opus frame (which may correspond to several SILK frames).
Definition: opus_silk.c:792
MULL
#define MULL(a, b, s)
Definition: mathops.h:59
opus_rc.h
ff_silk_model_lcg_seed
const uint16_t ff_silk_model_lcg_seed[]
Definition: opustab.c:157
SilkFrame::prev_voiced
int prev_voiced
Definition: opus_silk.c:48
ff_silk_model_lbrr_flags_60
const uint16_t ff_silk_model_lbrr_flags_60[]
Definition: opustab.c:32
opus_silk.h
OpusBandwidth
OpusBandwidth
Definition: opus.h:49
channel
channel
Definition: ebur128.h:39
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:41
ff_silk_model_pitch_lowbits_wb
const uint16_t ff_silk_model_pitch_lowbits_wb[]
Definition: opustab.c:117