FFmpeg
opusdec_celt.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Andrew D'Addesio
3  * Copyright (c) 2013-2014 Mozilla Corporation
4  * Copyright (c) 2016 Rostislav Pehlivanov <atomnuker@gmail.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Opus CELT decoder
26  */
27 
28 #include <float.h>
29 
30 #include "opus_celt.h"
31 #include "opustab.h"
32 #include "opus_pvq.h"
33 
34 /* Use the 2D z-transform to apply prediction in both the time domain (alpha)
35  * and the frequency domain (beta) */
37 {
38  int i, j;
39  float prev[2] = { 0 };
40  float alpha = ff_celt_alpha_coef[f->size];
41  float beta = ff_celt_beta_coef[f->size];
42  const uint8_t *model = ff_celt_coarse_energy_dist[f->size][0];
43 
44  /* intra frame */
45  if (opus_rc_tell(rc) + 3 <= f->framebits && ff_opus_rc_dec_log(rc, 3)) {
46  alpha = 0.0f;
47  beta = 1.0f - (4915.0f/32768.0f);
48  model = ff_celt_coarse_energy_dist[f->size][1];
49  }
50 
51  for (i = 0; i < CELT_MAX_BANDS; i++) {
52  for (j = 0; j < f->channels; j++) {
53  CeltBlock *block = &f->block[j];
54  float value;
55  int available;
56 
57  if (i < f->start_band || i >= f->end_band) {
58  block->energy[i] = 0.0;
59  continue;
60  }
61 
62  available = f->framebits - opus_rc_tell(rc);
63  if (available >= 15) {
64  /* decode using a Laplace distribution */
65  int k = FFMIN(i, 20) << 1;
66  value = ff_opus_rc_dec_laplace(rc, model[k] << 7, model[k+1] << 6);
67  } else if (available >= 2) {
69  value = (x>>1) ^ -(x&1);
70  } else if (available >= 1) {
72  } else value = -1;
73 
74  block->energy[i] = FFMAX(-9.0f, block->energy[i]) * alpha + prev[j] + value;
75  prev[j] += beta * value;
76  }
77  }
78 }
79 
81 {
82  int i;
83  for (i = f->start_band; i < f->end_band; i++) {
84  int j;
85  if (!f->fine_bits[i])
86  continue;
87 
88  for (j = 0; j < f->channels; j++) {
89  CeltBlock *block = &f->block[j];
90  int q2;
91  float offset;
92  q2 = ff_opus_rc_get_raw(rc, f->fine_bits[i]);
93  offset = (q2 + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f - 0.5f;
94  block->energy[i] += offset;
95  }
96  }
97 }
98 
100 {
101  int priority, i, j;
102  int bits_left = f->framebits - opus_rc_tell(rc);
103 
104  for (priority = 0; priority < 2; priority++) {
105  for (i = f->start_band; i < f->end_band && bits_left >= f->channels; i++) {
106  if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
107  continue;
108 
109  for (j = 0; j < f->channels; j++) {
110  int q2;
111  float offset;
112  q2 = ff_opus_rc_get_raw(rc, 1);
113  offset = (q2 - 0.5f) * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
114  f->block[j].energy[i] += offset;
115  bits_left--;
116  }
117  }
118  }
119 }
120 
122 {
123  int i, diff = 0, tf_select = 0, tf_changed = 0, tf_select_bit;
124  int consumed, bits = f->transient ? 2 : 4;
125 
126  consumed = opus_rc_tell(rc);
127  tf_select_bit = (f->size != 0 && consumed+bits+1 <= f->framebits);
128 
129  for (i = f->start_band; i < f->end_band; i++) {
130  if (consumed+bits+tf_select_bit <= f->framebits) {
132  consumed = opus_rc_tell(rc);
133  tf_changed |= diff;
134  }
135  f->tf_change[i] = diff;
136  bits = f->transient ? 4 : 5;
137  }
138 
139  if (tf_select_bit && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
140  ff_celt_tf_select[f->size][f->transient][1][tf_changed])
141  tf_select = ff_opus_rc_dec_log(rc, 1);
142 
143  for (i = f->start_band; i < f->end_band; i++) {
144  f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
145  }
146 }
147 
149 {
150  int i, j;
151 
152  for (i = f->start_band; i < f->end_band; i++) {
153  float *dst = data + (ff_celt_freq_bands[i] << f->size);
154  float log_norm = block->energy[i] + ff_celt_mean_energy[i];
155  float norm = exp2f(FFMIN(log_norm, 32.0f));
156 
157  for (j = 0; j < ff_celt_freq_range[i] << f->size; j++)
158  dst[j] *= norm;
159  }
160 }
161 
163 {
164  const int T0 = block->pf_period_old;
165  const int T1 = block->pf_period;
166 
167  float g00, g01, g02;
168  float g10, g11, g12;
169 
170  float x0, x1, x2, x3, x4;
171 
172  int i;
173 
174  if (block->pf_gains[0] == 0.0 &&
175  block->pf_gains_old[0] == 0.0)
176  return;
177 
178  g00 = block->pf_gains_old[0];
179  g01 = block->pf_gains_old[1];
180  g02 = block->pf_gains_old[2];
181  g10 = block->pf_gains[0];
182  g11 = block->pf_gains[1];
183  g12 = block->pf_gains[2];
184 
185  x1 = data[-T1 + 1];
186  x2 = data[-T1];
187  x3 = data[-T1 - 1];
188  x4 = data[-T1 - 2];
189 
190  for (i = 0; i < CELT_OVERLAP; i++) {
191  float w = ff_celt_window2[i];
192  x0 = data[i - T1 + 2];
193 
194  data[i] += (1.0 - w) * g00 * data[i - T0] +
195  (1.0 - w) * g01 * (data[i - T0 - 1] + data[i - T0 + 1]) +
196  (1.0 - w) * g02 * (data[i - T0 - 2] + data[i - T0 + 2]) +
197  w * g10 * x2 +
198  w * g11 * (x1 + x3) +
199  w * g12 * (x0 + x4);
200  x4 = x3;
201  x3 = x2;
202  x2 = x1;
203  x1 = x0;
204  }
205 }
206 
208 {
209  int len = f->blocksize * f->blocks;
210  const int filter_len = len - 2 * CELT_OVERLAP;
211 
213 
214  block->pf_period_old = block->pf_period;
215  memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains));
216 
217  block->pf_period = block->pf_period_new;
218  memcpy(block->pf_gains, block->pf_gains_new, sizeof(block->pf_gains));
219 
220  if (len > CELT_OVERLAP) {
222 
223  if (block->pf_gains[0] > FLT_EPSILON && filter_len > 0)
224  f->opusdsp.postfilter(block->buf + 1024 + 2 * CELT_OVERLAP,
225  block->pf_period, block->pf_gains,
226  filter_len);
227 
228  block->pf_period_old = block->pf_period;
229  memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains));
230  }
231 
232  memmove(block->buf, block->buf + len, (1024 + CELT_OVERLAP / 2) * sizeof(float));
233 }
234 
235 static int parse_postfilter(CeltFrame *f, OpusRangeCoder *rc, int consumed)
236 {
237  int i;
238 
239  memset(f->block[0].pf_gains_new, 0, sizeof(f->block[0].pf_gains_new));
240  memset(f->block[1].pf_gains_new, 0, sizeof(f->block[1].pf_gains_new));
241 
242  if (f->start_band == 0 && consumed + 16 <= f->framebits) {
243  int has_postfilter = ff_opus_rc_dec_log(rc, 1);
244  if (has_postfilter) {
245  float gain;
246  int tapset, octave, period;
247 
248  octave = ff_opus_rc_dec_uint(rc, 6);
249  period = (16 << octave) + ff_opus_rc_get_raw(rc, 4 + octave) - 1;
250  gain = 0.09375f * (ff_opus_rc_get_raw(rc, 3) + 1);
251  tapset = (opus_rc_tell(rc) + 2 <= f->framebits) ?
253 
254  for (i = 0; i < 2; i++) {
255  CeltBlock *block = &f->block[i];
256 
257  block->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);
258  block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
259  block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
260  block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
261  }
262  }
263 
264  consumed = opus_rc_tell(rc);
265  }
266 
267  return consumed;
268 }
269 
271 {
272  int i, j, k;
273 
274  for (i = f->start_band; i < f->end_band; i++) {
275  int renormalize = 0;
276  float *xptr;
277  float prev[2];
278  float Ediff, r;
279  float thresh, sqrt_1;
280  int depth;
281 
282  /* depth in 1/8 bits */
283  depth = (1 + f->pulses[i]) / (ff_celt_freq_range[i] << f->size);
284  thresh = exp2f(-1.0 - 0.125f * depth);
285  sqrt_1 = 1.0f / sqrtf(ff_celt_freq_range[i] << f->size);
286 
287  xptr = X + (ff_celt_freq_bands[i] << f->size);
288 
289  prev[0] = block->prev_energy[0][i];
290  prev[1] = block->prev_energy[1][i];
291  if (f->channels == 1) {
292  CeltBlock *block1 = &f->block[1];
293 
294  prev[0] = FFMAX(prev[0], block1->prev_energy[0][i]);
295  prev[1] = FFMAX(prev[1], block1->prev_energy[1][i]);
296  }
297  Ediff = block->energy[i] - FFMIN(prev[0], prev[1]);
298  Ediff = FFMAX(0, Ediff);
299 
300  /* r needs to be multiplied by 2 or 2*sqrt(2) depending on LM because
301  short blocks don't have the same energy as long */
302  r = exp2f(1 - Ediff);
303  if (f->size == 3)
304  r *= M_SQRT2;
305  r = FFMIN(thresh, r) * sqrt_1;
306  for (k = 0; k < 1 << f->size; k++) {
307  /* Detect collapse */
308  if (!(block->collapse_masks[i] & 1 << k)) {
309  /* Fill with noise */
310  for (j = 0; j < ff_celt_freq_range[i]; j++)
311  xptr[(j << f->size) + k] = (celt_rng(f) & 0x8000) ? r : -r;
312  renormalize = 1;
313  }
314  }
315 
316  /* We just added some energy, so we need to renormalize */
317  if (renormalize)
318  celt_renormalize_vector(xptr, ff_celt_freq_range[i] << f->size, 1.0f);
319  }
320 }
321 
323  float **output, int channels, int frame_size,
324  int start_band, int end_band)
325 {
326  int i, j, downmix = 0;
327  int consumed; // bits of entropy consumed thus far for this frame
328  AVTXContext *imdct;
329  av_tx_fn imdct_fn;
330 
331  if (channels != 1 && channels != 2) {
332  av_log(f->avctx, AV_LOG_ERROR, "Invalid number of coded channels: %d\n",
333  channels);
334  return AVERROR_INVALIDDATA;
335  }
336  if (start_band < 0 || start_band > end_band || end_band > CELT_MAX_BANDS) {
337  av_log(f->avctx, AV_LOG_ERROR, "Invalid start/end band: %d %d\n",
338  start_band, end_band);
339  return AVERROR_INVALIDDATA;
340  }
341 
342  f->silence = 0;
343  f->transient = 0;
344  f->anticollapse = 0;
345  f->flushed = 0;
346  f->channels = channels;
347  f->start_band = start_band;
348  f->end_band = end_band;
349  f->framebits = rc->rb.bytes * 8;
350 
352  if (f->size > CELT_MAX_LOG_BLOCKS ||
353  frame_size != CELT_SHORT_BLOCKSIZE * (1 << f->size)) {
354  av_log(f->avctx, AV_LOG_ERROR, "Invalid CELT frame size: %d\n",
355  frame_size);
356  return AVERROR_INVALIDDATA;
357  }
358 
359  if (!f->output_channels)
360  f->output_channels = channels;
361 
362  for (i = 0; i < f->channels; i++) {
363  memset(f->block[i].coeffs, 0, sizeof(f->block[i].coeffs));
364  memset(f->block[i].collapse_masks, 0, sizeof(f->block[i].collapse_masks));
365  }
366 
367  consumed = opus_rc_tell(rc);
368 
369  /* obtain silence flag */
370  if (consumed >= f->framebits)
371  f->silence = 1;
372  else if (consumed == 1)
373  f->silence = ff_opus_rc_dec_log(rc, 15);
374 
375 
376  if (f->silence) {
377  consumed = f->framebits;
378  rc->total_bits += f->framebits - opus_rc_tell(rc);
379  }
380 
381  /* obtain post-filter options */
382  consumed = parse_postfilter(f, rc, consumed);
383 
384  /* obtain transient flag */
385  if (f->size != 0 && consumed+3 <= f->framebits)
386  f->transient = ff_opus_rc_dec_log(rc, 3);
387 
388  f->blocks = f->transient ? 1 << f->size : 1;
389  f->blocksize = frame_size / f->blocks;
390 
391  imdct = f->tx[f->transient ? 0 : f->size];
392  imdct_fn = f->tx_fn[f->transient ? 0 : f->size];
393 
394  if (channels == 1) {
395  for (i = 0; i < CELT_MAX_BANDS; i++)
396  f->block[0].energy[i] = FFMAX(f->block[0].energy[i], f->block[1].energy[i]);
397  }
398 
401  ff_celt_bitalloc (f, rc, 0);
404 
405  if (f->anticollapse_needed)
406  f->anticollapse = ff_opus_rc_get_raw(rc, 1);
407 
409 
410  /* apply anti-collapse processing and denormalization to
411  * each coded channel */
412  for (i = 0; i < f->channels; i++) {
413  CeltBlock *block = &f->block[i];
414 
415  if (f->anticollapse)
416  process_anticollapse(f, block, f->block[i].coeffs);
417 
418  celt_denormalize(f, block, f->block[i].coeffs);
419  }
420 
421  /* stereo -> mono downmix */
422  if (f->output_channels < f->channels) {
423  f->dsp->vector_fmac_scalar(f->block[0].coeffs, f->block[1].coeffs, 1.0, FFALIGN(frame_size, 16));
424  downmix = 1;
425  } else if (f->output_channels > f->channels)
426  memcpy(f->block[1].coeffs, f->block[0].coeffs, frame_size * sizeof(float));
427 
428  if (f->silence) {
429  for (i = 0; i < 2; i++) {
430  CeltBlock *block = &f->block[i];
431 
432  for (j = 0; j < FF_ARRAY_ELEMS(block->energy); j++)
433  block->energy[j] = CELT_ENERGY_SILENCE;
434  }
435  memset(f->block[0].coeffs, 0, sizeof(f->block[0].coeffs));
436  memset(f->block[1].coeffs, 0, sizeof(f->block[1].coeffs));
437  }
438 
439  /* transform and output for each output channel */
440  for (i = 0; i < f->output_channels; i++) {
441  CeltBlock *block = &f->block[i];
442 
443  /* iMDCT and overlap-add */
444  for (j = 0; j < f->blocks; j++) {
445  float *dst = block->buf + 1024 + j * f->blocksize;
446 
447  imdct_fn(imdct, dst + CELT_OVERLAP / 2, f->block[i].coeffs + j,
448  sizeof(float)*f->blocks);
449  f->dsp->vector_fmul_window(dst, dst, dst + CELT_OVERLAP / 2,
451  }
452 
453  if (downmix)
454  f->dsp->vector_fmul_scalar(&block->buf[1024], &block->buf[1024], 0.5f, frame_size);
455 
456  /* postfilter */
458 
459  /* deemphasis */
460  block->emph_coeff = f->opusdsp.deemphasis(output[i],
461  &block->buf[1024 - frame_size],
462  block->emph_coeff, frame_size);
463  }
464 
465  if (channels == 1)
466  memcpy(f->block[1].energy, f->block[0].energy, sizeof(f->block[0].energy));
467 
468  for (i = 0; i < 2; i++ ) {
469  CeltBlock *block = &f->block[i];
470 
471  if (!f->transient) {
472  memcpy(block->prev_energy[1], block->prev_energy[0], sizeof(block->prev_energy[0]));
473  memcpy(block->prev_energy[0], block->energy, sizeof(block->prev_energy[0]));
474  } else {
475  for (j = 0; j < CELT_MAX_BANDS; j++)
476  block->prev_energy[0][j] = FFMIN(block->prev_energy[0][j], block->energy[j]);
477  }
478 
479  for (j = 0; j < f->start_band; j++) {
480  block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
481  block->energy[j] = 0.0;
482  }
483  for (j = f->end_band; j < CELT_MAX_BANDS; j++) {
484  block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
485  block->energy[j] = 0.0;
486  }
487  }
488 
489  f->seed = rc->range;
490 
491  return 0;
492 }
493 
495 {
496  int i, j;
497 
498  if (f->flushed)
499  return;
500 
501  for (i = 0; i < 2; i++) {
502  CeltBlock *block = &f->block[i];
503 
504  for (j = 0; j < CELT_MAX_BANDS; j++)
505  block->prev_energy[0][j] = block->prev_energy[1][j] = CELT_ENERGY_SILENCE;
506 
507  memset(block->energy, 0, sizeof(block->energy));
508  memset(block->buf, 0, sizeof(block->buf));
509 
510  memset(block->pf_gains, 0, sizeof(block->pf_gains));
511  memset(block->pf_gains_old, 0, sizeof(block->pf_gains_old));
512  memset(block->pf_gains_new, 0, sizeof(block->pf_gains_new));
513 
514  /* libopus uses CELT_EMPH_COEFF on init, but 0 is better since there's
515  * a lesser discontinuity when seeking.
516  * The deemphasis functions differ from libopus in that they require
517  * an initial state divided by the coefficient. */
518  block->emph_coeff = 0.0f / CELT_EMPH_COEFF;
519  }
520  f->seed = 0;
521 
522  f->flushed = 1;
523 }
524 
526 {
527  CeltFrame *frm = *f;
528  int i;
529 
530  if (!frm)
531  return;
532 
533  for (i = 0; i < FF_ARRAY_ELEMS(frm->tx); i++)
534  av_tx_uninit(&frm->tx[i]);
535 
536  ff_celt_pvq_uninit(&frm->pvq);
537 
538  av_freep(&frm->dsp);
539  av_freep(f);
540 }
541 
543  int apply_phase_inv)
544 {
545  CeltFrame *frm;
546  int i, ret;
547 
548  if (output_channels != 1 && output_channels != 2) {
549  av_log(avctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",
551  return AVERROR(EINVAL);
552  }
553 
554  frm = av_mallocz(sizeof(*frm));
555  if (!frm)
556  return AVERROR(ENOMEM);
557 
558  frm->avctx = avctx;
560  frm->apply_phase_inv = apply_phase_inv;
561 
562  for (i = 0; i < FF_ARRAY_ELEMS(frm->tx); i++) {
563  const float scale = -1.0f/32768;
564  if ((ret = av_tx_init(&frm->tx[i], &frm->tx_fn[i], AV_TX_FLOAT_MDCT, 1, 15 << (i + 3), &scale, 0)) < 0)
565  goto fail;
566  }
567 
568  if ((ret = ff_celt_pvq_init(&frm->pvq, 0)) < 0)
569  goto fail;
570 
572  if (!frm->dsp) {
573  ret = AVERROR(ENOMEM);
574  goto fail;
575  }
576 
577  ff_opus_dsp_init(&frm->opusdsp);
578  ff_celt_flush(frm);
579 
580  *f = frm;
581 
582  return 0;
583 fail:
584  ff_celt_free(&frm);
585  return ret;
586 }
ff_celt_postfilter_taps
const float ff_celt_postfilter_taps[3][3]
Definition: opustab.c:1098
OpusStreamContext::avctx
AVCodecContext * avctx
Definition: opusdec.c:74
CeltFrame::dsp
AVFloatDSPContext * dsp
Definition: opus_celt.h:102
r
const char * r
Definition: vf_curves.c:126
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_celt_freq_bands
const uint8_t ff_celt_freq_bands[]
Definition: opustab.c:768
CeltFrame::tx_fn
av_tx_fn tx_fn[4]
Definition: opus_celt.h:101
ff_opus_rc_get_raw
uint32_t ff_opus_rc_get_raw(OpusRangeCoder *rc, uint32_t count)
CELT: read 1-25 raw bits at the end of the frame, backwards byte-wise.
Definition: opus_rc.c:140
AVTXContext
Definition: tx_priv.h:228
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
celt_postfilter
static void celt_postfilter(CeltFrame *f, CeltBlock *block)
Definition: opusdec_celt.c:207
ff_celt_model_tapset
const uint16_t ff_celt_model_tapset[]
Definition: opustab.c:758
w
uint8_t w
Definition: llviddspenc.c:38
ff_celt_free
void ff_celt_free(CeltFrame **f)
Definition: opusdec_celt.c:525
CeltFrame::avctx
AVCodecContext * avctx
Definition: opus_celt.h:99
data
const char data[16]
Definition: mxf.c:146
float.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
OpusStreamContext::rc
OpusRangeCoder rc
Definition: opusdec.c:86
ff_celt_pvq_init
int av_cold ff_celt_pvq_init(CeltPVQ **pvq, int encode)
Definition: opus_pvq.c:906
ff_celt_init
int ff_celt_init(AVCodecContext *avctx, CeltFrame **f, int output_channels, int apply_phase_inv)
Definition: opusdec_celt.c:542
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:883
opus_rc_tell
static av_always_inline uint32_t opus_rc_tell(const OpusRangeCoder *rc)
CELT: estimate bits of entropy that have thus far been consumed for the current CELT frame,...
Definition: opus_rc.h:60
ff_celt_coarse_energy_dist
const uint8_t ff_celt_coarse_energy_dist[4][2][42]
Definition: opustab.c:808
CeltBlock
Definition: opus_celt.h:70
X
@ X
Definition: vf_addroi.c:26
CeltFrame::output_channels
int output_channels
Definition: opus_celt.h:107
fail
#define fail()
Definition: checkasm.h:134
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:511
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
celt_decode_fine_energy
static void celt_decode_fine_energy(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusdec_celt.c:80
celt_renormalize_vector
static av_always_inline void celt_renormalize_vector(float *X, int N, float gain)
Definition: opus_celt.h:155
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
CeltFrame::apply_phase_inv
int apply_phase_inv
Definition: opus_celt.h:108
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:127
float
float
Definition: af_crystalizer.c:122
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
ff_opus_rc_dec_uint
uint32_t ff_opus_rc_dec_uint(OpusRangeCoder *rc, uint32_t size)
CELT: read a uniform distribution.
Definition: opus_rc.c:182
frame_size
int frame_size
Definition: mxfenc.c:2202
CELT_MAX_FINE_BITS
#define CELT_MAX_FINE_BITS
Definition: opus_celt.h:47
bits
uint8_t bits
Definition: vp3data.h:128
exp2f
#define exp2f(x)
Definition: libm.h:293
channels
channels
Definition: aptx.h:31
OpusRangeCoder::range
uint32_t range
Definition: opus_rc.h:42
bits_left
#define bits_left
Definition: bitstream.h:113
ff_celt_decode_frame
int ff_celt_decode_frame(CeltFrame *f, OpusRangeCoder *rc, float **output, int channels, int frame_size, int start_band, int end_band)
Definition: opusdec_celt.c:322
ff_celt_pvq_uninit
void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)
Definition: opus_pvq.c:926
period
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 minimum maximum flags name is the option keep it simple and lowercase description are in without period
Definition: writing_filters.txt:89
CELT_SHORT_BLOCKSIZE
#define CELT_SHORT_BLOCKSIZE
Definition: opus_celt.h:38
celt_decode_coarse_energy
static void celt_decode_coarse_energy(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusdec_celt.c:36
RawBitsContext::bytes
uint32_t bytes
Definition: opus_rc.h:34
ff_celt_window
static const float *const ff_celt_window
Definition: opustab.h:162
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
ff_celt_freq_range
const uint8_t ff_celt_freq_range[]
Definition: opustab.c:772
CeltFrame::tx
AVTXContext * tx[4]
Definition: opus_celt.h:100
CELT_ENERGY_SILENCE
#define CELT_ENERGY_SILENCE
Definition: opus_celt.h:52
CELT_OVERLAP
#define CELT_OVERLAP
Definition: opus_celt.h:39
opustab.h
CELT_MAX_BANDS
#define CELT_MAX_BANDS
Definition: opus_celt.h:42
f
f
Definition: af_crystalizer.c:122
opus_pvq.h
OpusRangeCoder
Definition: opus_rc.h:39
ff_celt_window2
const float ff_celt_window2[120]
Definition: opustab.c:1136
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:162
celt_rng
static av_always_inline uint32_t celt_rng(CeltFrame *f)
Definition: opus_celt.h:149
ff_celt_tf_select
const int8_t ff_celt_tf_select[4][2][2][2]
Definition: opustab.c:782
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
ff_celt_beta_coef
const float ff_celt_beta_coef[]
Definition: opustab.c:804
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:294
ff_opus_rc_dec_cdf
uint32_t ff_opus_rc_dec_cdf(OpusRangeCoder *rc, const uint16_t *cdf)
Definition: opus_rc.c:90
ff_celt_flush
void ff_celt_flush(CeltFrame *f)
Definition: opusdec_celt.c:494
ff_opus_rc_dec_laplace
int ff_opus_rc_dec_laplace(OpusRangeCoder *rc, uint32_t symbol, int decay)
Definition: opus_rc.c:275
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
CeltFrame::pvq
struct CeltPVQ * pvq
Definition: opus_celt.h:104
available
if no frame is available
Definition: filter_design.txt:166
opus_celt.h
celt_postfilter_apply_transition
static void celt_postfilter_apply_transition(CeltBlock *block, float *data)
Definition: opusdec_celt.c:162
CELT_MAX_LOG_BLOCKS
#define CELT_MAX_LOG_BLOCKS
Definition: opus_celt.h:40
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:264
len
int len
Definition: vorbis_enc_data.h:426
CELT_POSTFILTER_MINPERIOD
#define CELT_POSTFILTER_MINPERIOD
Definition: opus_celt.h:51
celt_denormalize
static void celt_denormalize(CeltFrame *f, CeltBlock *block, float *data)
Definition: opusdec_celt.c:148
ff_celt_quant_bands
void ff_celt_quant_bands(CeltFrame *f, OpusRangeCoder *rc)
Definition: opus_celt.c:28
process_anticollapse
static void process_anticollapse(CeltFrame *f, CeltBlock *block, float *X)
Definition: opusdec_celt.c:270
ff_celt_bitalloc
void ff_celt_bitalloc(CeltFrame *f, OpusRangeCoder *rc, int encode)
Definition: opus_celt.c:137
celt_decode_final_energy
static void celt_decode_final_energy(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusdec_celt.c:99
ret
ret
Definition: filter_design.txt:187
CELT_EMPH_COEFF
#define CELT_EMPH_COEFF
Definition: opusdsp.h:22
AVCodecContext
main external API structure.
Definition: avcodec.h:431
ff_celt_model_energy_small
const uint16_t ff_celt_model_energy_small[]
Definition: opustab.c:766
CeltFrame::opusdsp
OpusDSP opusdsp
Definition: opus_celt.h:105
ff_opus_dsp_init
av_cold void ff_opus_dsp_init(OpusDSP *ctx)
Definition: opusdsp.c:54
celt_decode_tf_changes
static void celt_decode_tf_changes(CeltFrame *f, OpusRangeCoder *rc)
Definition: opusdec_celt.c:121
ff_celt_alpha_coef
const float ff_celt_alpha_coef[]
Definition: opustab.c:800
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:321
OpusRangeCoder::rb
RawBitsContext rb
Definition: opus_rc.h:41
M_SQRT2
#define M_SQRT2
Definition: mathematics.h:61
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_opus_rc_dec_log
uint32_t ff_opus_rc_dec_log(OpusRangeCoder *rc, uint32_t bits)
Definition: opus_rc.c:114
ff_celt_mean_energy
const float ff_celt_mean_energy[]
Definition: opustab.c:792
OpusStreamContext::output_channels
int output_channels
Definition: opusdec.c:75
parse_postfilter
static int parse_postfilter(CeltFrame *f, OpusRangeCoder *rc, int consumed)
Definition: opusdec_celt.c:235
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
block1
static int16_t block1[64]
Definition: dct.c:118
OpusRangeCoder::total_bits
uint32_t total_bits
Definition: opus_rc.h:44
CeltFrame
Definition: opus_celt.h:97