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