FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
opus_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 "opus_celt.h"
29 #include "opustab.h"
30 #include "opus_pvq.h"
31 
32 /* Use the 2D z-transform to apply prediction in both the time domain (alpha)
33  * and the frequency domain (beta) */
35 {
36  int i, j;
37  float prev[2] = { 0 };
38  float alpha = ff_celt_alpha_coef[f->size];
39  float beta = ff_celt_beta_coef[f->size];
40  const uint8_t *model = ff_celt_coarse_energy_dist[f->size][0];
41 
42  /* intra frame */
43  if (opus_rc_tell(rc) + 3 <= f->framebits && ff_opus_rc_dec_log(rc, 3)) {
44  alpha = 0.0f;
45  beta = 1.0f - (4915.0f/32768.0f);
46  model = ff_celt_coarse_energy_dist[f->size][1];
47  }
48 
49  for (i = 0; i < CELT_MAX_BANDS; i++) {
50  for (j = 0; j < f->channels; j++) {
51  CeltBlock *block = &f->block[j];
52  float value;
53  int available;
54 
55  if (i < f->start_band || i >= f->end_band) {
56  block->energy[i] = 0.0;
57  continue;
58  }
59 
60  available = f->framebits - opus_rc_tell(rc);
61  if (available >= 15) {
62  /* decode using a Laplace distribution */
63  int k = FFMIN(i, 20) << 1;
64  value = ff_opus_rc_dec_laplace(rc, model[k] << 7, model[k+1] << 6);
65  } else if (available >= 2) {
67  value = (x>>1) ^ -(x&1);
68  } else if (available >= 1) {
69  value = -(float)ff_opus_rc_dec_log(rc, 1);
70  } else value = -1;
71 
72  block->energy[i] = FFMAX(-9.0f, block->energy[i]) * alpha + prev[j] + value;
73  prev[j] += beta * value;
74  }
75  }
76 }
77 
79 {
80  int i;
81  for (i = f->start_band; i < f->end_band; i++) {
82  int j;
83  if (!f->fine_bits[i])
84  continue;
85 
86  for (j = 0; j < f->channels; j++) {
87  CeltBlock *block = &f->block[j];
88  int q2;
89  float offset;
90  q2 = ff_opus_rc_get_raw(rc, f->fine_bits[i]);
91  offset = (q2 + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f - 0.5f;
92  block->energy[i] += offset;
93  }
94  }
95 }
96 
98 {
99  int priority, i, j;
100  int bits_left = f->framebits - opus_rc_tell(rc);
101 
102  for (priority = 0; priority < 2; priority++) {
103  for (i = f->start_band; i < f->end_band && bits_left >= f->channels; i++) {
104  if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
105  continue;
106 
107  for (j = 0; j < f->channels; j++) {
108  int q2;
109  float offset;
110  q2 = ff_opus_rc_get_raw(rc, 1);
111  offset = (q2 - 0.5f) * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
112  f->block[j].energy[i] += offset;
113  bits_left--;
114  }
115  }
116  }
117 }
118 
120 {
121  int i, diff = 0, tf_select = 0, tf_changed = 0, tf_select_bit;
122  int consumed, bits = f->transient ? 2 : 4;
123 
124  consumed = opus_rc_tell(rc);
125  tf_select_bit = (f->size != 0 && consumed+bits+1 <= f->framebits);
126 
127  for (i = f->start_band; i < f->end_band; i++) {
128  if (consumed+bits+tf_select_bit <= f->framebits) {
129  diff ^= ff_opus_rc_dec_log(rc, bits);
130  consumed = opus_rc_tell(rc);
131  tf_changed |= diff;
132  }
133  f->tf_change[i] = diff;
134  bits = f->transient ? 4 : 5;
135  }
136 
137  if (tf_select_bit && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
138  ff_celt_tf_select[f->size][f->transient][1][tf_changed])
139  tf_select = ff_opus_rc_dec_log(rc, 1);
140 
141  for (i = f->start_band; i < f->end_band; i++) {
142  f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
143  }
144 }
145 
146 static void celt_denormalize(CeltFrame *f, CeltBlock *block, float *data)
147 {
148  int i, j;
149 
150  for (i = f->start_band; i < f->end_band; i++) {
151  float *dst = data + (ff_celt_freq_bands[i] << f->size);
152  float log_norm = block->energy[i] + ff_celt_mean_energy[i];
153  float norm = exp2f(FFMIN(log_norm, 32.0f));
154 
155  for (j = 0; j < ff_celt_freq_range[i] << f->size; j++)
156  dst[j] *= norm;
157  }
158 }
159 
161 {
162  const int T0 = block->pf_period_old;
163  const int T1 = block->pf_period;
164 
165  float g00, g01, g02;
166  float g10, g11, g12;
167 
168  float x0, x1, x2, x3, x4;
169 
170  int i;
171 
172  if (block->pf_gains[0] == 0.0 &&
173  block->pf_gains_old[0] == 0.0)
174  return;
175 
176  g00 = block->pf_gains_old[0];
177  g01 = block->pf_gains_old[1];
178  g02 = block->pf_gains_old[2];
179  g10 = block->pf_gains[0];
180  g11 = block->pf_gains[1];
181  g12 = block->pf_gains[2];
182 
183  x1 = data[-T1 + 1];
184  x2 = data[-T1];
185  x3 = data[-T1 - 1];
186  x4 = data[-T1 - 2];
187 
188  for (i = 0; i < CELT_OVERLAP; i++) {
189  float w = ff_celt_window2[i];
190  x0 = data[i - T1 + 2];
191 
192  data[i] += (1.0 - w) * g00 * data[i - T0] +
193  (1.0 - w) * g01 * (data[i - T0 - 1] + data[i - T0 + 1]) +
194  (1.0 - w) * g02 * (data[i - T0 - 2] + data[i - T0 + 2]) +
195  w * g10 * x2 +
196  w * g11 * (x1 + x3) +
197  w * g12 * (x0 + x4);
198  x4 = x3;
199  x3 = x2;
200  x2 = x1;
201  x1 = x0;
202  }
203 }
204 
205 static void celt_postfilter_apply(CeltBlock *block, float *data, int len)
206 {
207  const int T = block->pf_period;
208  float g0, g1, g2;
209  float x0, x1, x2, x3, x4;
210  int i;
211 
212  if (block->pf_gains[0] == 0.0 || len <= 0)
213  return;
214 
215  g0 = block->pf_gains[0];
216  g1 = block->pf_gains[1];
217  g2 = block->pf_gains[2];
218 
219  x4 = data[-T - 2];
220  x3 = data[-T - 1];
221  x2 = data[-T];
222  x1 = data[-T + 1];
223 
224  for (i = 0; i < len; i++) {
225  x0 = data[i - T + 2];
226  data[i] += g0 * x2 +
227  g1 * (x1 + x3) +
228  g2 * (x0 + x4);
229  x4 = x3;
230  x3 = x2;
231  x2 = x1;
232  x1 = x0;
233  }
234 }
235 
237 {
238  int len = f->blocksize * f->blocks;
239 
240  celt_postfilter_apply_transition(block, block->buf + 1024);
241 
242  block->pf_period_old = block->pf_period;
243  memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains));
244 
245  block->pf_period = block->pf_period_new;
246  memcpy(block->pf_gains, block->pf_gains_new, sizeof(block->pf_gains));
247 
248  if (len > CELT_OVERLAP) {
249  celt_postfilter_apply_transition(block, block->buf + 1024 + CELT_OVERLAP);
250  celt_postfilter_apply(block, block->buf + 1024 + 2 * CELT_OVERLAP,
251  len - 2 * CELT_OVERLAP);
252 
253  block->pf_period_old = block->pf_period;
254  memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains));
255  }
256 
257  memmove(block->buf, block->buf + len, (1024 + CELT_OVERLAP / 2) * sizeof(float));
258 }
259 
260 static int parse_postfilter(CeltFrame *f, OpusRangeCoder *rc, int consumed)
261 {
262  int i;
263 
264  memset(f->block[0].pf_gains_new, 0, sizeof(f->block[0].pf_gains_new));
265  memset(f->block[1].pf_gains_new, 0, sizeof(f->block[1].pf_gains_new));
266 
267  if (f->start_band == 0 && consumed + 16 <= f->framebits) {
268  int has_postfilter = ff_opus_rc_dec_log(rc, 1);
269  if (has_postfilter) {
270  float gain;
271  int tapset, octave, period;
272 
273  octave = ff_opus_rc_dec_uint(rc, 6);
274  period = (16 << octave) + ff_opus_rc_get_raw(rc, 4 + octave) - 1;
275  gain = 0.09375f * (ff_opus_rc_get_raw(rc, 3) + 1);
276  tapset = (opus_rc_tell(rc) + 2 <= f->framebits) ?
278 
279  for (i = 0; i < 2; i++) {
280  CeltBlock *block = &f->block[i];
281 
283  block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
284  block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
285  block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
286  }
287  }
288 
289  consumed = opus_rc_tell(rc);
290  }
291 
292  return consumed;
293 }
294 
295 static void process_anticollapse(CeltFrame *f, CeltBlock *block, float *X)
296 {
297  int i, j, k;
298 
299  for (i = f->start_band; i < f->end_band; i++) {
300  int renormalize = 0;
301  float *xptr;
302  float prev[2];
303  float Ediff, r;
304  float thresh, sqrt_1;
305  int depth;
306 
307  /* depth in 1/8 bits */
308  depth = (1 + f->pulses[i]) / (ff_celt_freq_range[i] << f->size);
309  thresh = exp2f(-1.0 - 0.125f * depth);
310  sqrt_1 = 1.0f / sqrtf(ff_celt_freq_range[i] << f->size);
311 
312  xptr = X + (ff_celt_freq_bands[i] << f->size);
313 
314  prev[0] = block->prev_energy[0][i];
315  prev[1] = block->prev_energy[1][i];
316  if (f->channels == 1) {
317  CeltBlock *block1 = &f->block[1];
318 
319  prev[0] = FFMAX(prev[0], block1->prev_energy[0][i]);
320  prev[1] = FFMAX(prev[1], block1->prev_energy[1][i]);
321  }
322  Ediff = block->energy[i] - FFMIN(prev[0], prev[1]);
323  Ediff = FFMAX(0, Ediff);
324 
325  /* r needs to be multiplied by 2 or 2*sqrt(2) depending on LM because
326  short blocks don't have the same energy as long */
327  r = exp2f(1 - Ediff);
328  if (f->size == 3)
329  r *= M_SQRT2;
330  r = FFMIN(thresh, r) * sqrt_1;
331  for (k = 0; k < 1 << f->size; k++) {
332  /* Detect collapse */
333  if (!(block->collapse_masks[i] & 1 << k)) {
334  /* Fill with noise */
335  for (j = 0; j < ff_celt_freq_range[i]; j++)
336  xptr[(j << f->size) + k] = (celt_rng(f) & 0x8000) ? r : -r;
337  renormalize = 1;
338  }
339  }
340 
341  /* We just added some energy, so we need to renormalize */
342  if (renormalize)
343  celt_renormalize_vector(xptr, ff_celt_freq_range[i] << f->size, 1.0f);
344  }
345 }
346 
348  float **output, int channels, int frame_size,
349  int start_band, int end_band)
350 {
351  int i, j, downmix = 0;
352  int consumed; // bits of entropy consumed thus far for this frame
353  MDCT15Context *imdct;
354 
355  if (channels != 1 && channels != 2) {
356  av_log(f->avctx, AV_LOG_ERROR, "Invalid number of coded channels: %d\n",
357  channels);
358  return AVERROR_INVALIDDATA;
359  }
360  if (start_band < 0 || start_band > end_band || end_band > CELT_MAX_BANDS) {
361  av_log(f->avctx, AV_LOG_ERROR, "Invalid start/end band: %d %d\n",
362  start_band, end_band);
363  return AVERROR_INVALIDDATA;
364  }
365 
366  f->silence = 0;
367  f->transient = 0;
368  f->anticollapse = 0;
369  f->flushed = 0;
370  f->channels = channels;
371  f->start_band = start_band;
372  f->end_band = end_band;
373  f->framebits = rc->rb.bytes * 8;
374 
375  f->size = av_log2(frame_size / CELT_SHORT_BLOCKSIZE);
376  if (f->size > CELT_MAX_LOG_BLOCKS ||
377  frame_size != CELT_SHORT_BLOCKSIZE * (1 << f->size)) {
378  av_log(f->avctx, AV_LOG_ERROR, "Invalid CELT frame size: %d\n",
379  frame_size);
380  return AVERROR_INVALIDDATA;
381  }
382 
383  if (!f->output_channels)
385 
386  for (i = 0; i < f->channels; i++) {
387  memset(f->block[i].coeffs, 0, sizeof(f->block[i].coeffs));
388  memset(f->block[i].collapse_masks, 0, sizeof(f->block[i].collapse_masks));
389  }
390 
391  consumed = opus_rc_tell(rc);
392 
393  /* obtain silence flag */
394  if (consumed >= f->framebits)
395  f->silence = 1;
396  else if (consumed == 1)
397  f->silence = ff_opus_rc_dec_log(rc, 15);
398 
399 
400  if (f->silence) {
401  consumed = f->framebits;
402  rc->total_bits += f->framebits - opus_rc_tell(rc);
403  }
404 
405  /* obtain post-filter options */
406  consumed = parse_postfilter(f, rc, consumed);
407 
408  /* obtain transient flag */
409  if (f->size != 0 && consumed+3 <= f->framebits)
410  f->transient = ff_opus_rc_dec_log(rc, 3);
411 
412  f->blocks = f->transient ? 1 << f->size : 1;
413  f->blocksize = frame_size / f->blocks;
414 
415  imdct = f->imdct[f->transient ? 0 : f->size];
416 
417  if (channels == 1) {
418  for (i = 0; i < CELT_MAX_BANDS; i++)
419  f->block[0].energy[i] = FFMAX(f->block[0].energy[i], f->block[1].energy[i]);
420  }
421 
423  celt_decode_tf_changes (f, rc);
424  ff_celt_bitalloc (f, rc, 0);
425  celt_decode_fine_energy (f, rc);
426  ff_celt_quant_bands (f, rc);
427 
428  if (f->anticollapse_needed)
429  f->anticollapse = ff_opus_rc_get_raw(rc, 1);
430 
432 
433  /* apply anti-collapse processing and denormalization to
434  * each coded channel */
435  for (i = 0; i < f->channels; i++) {
436  CeltBlock *block = &f->block[i];
437 
438  if (f->anticollapse)
439  process_anticollapse(f, block, f->block[i].coeffs);
440 
441  celt_denormalize(f, block, f->block[i].coeffs);
442  }
443 
444  /* stereo -> mono downmix */
445  if (f->output_channels < f->channels) {
446  f->dsp->vector_fmac_scalar(f->block[0].coeffs, f->block[1].coeffs, 1.0, FFALIGN(frame_size, 16));
447  downmix = 1;
448  } else if (f->output_channels > f->channels)
449  memcpy(f->block[1].coeffs, f->block[0].coeffs, frame_size * sizeof(float));
450 
451  if (f->silence) {
452  for (i = 0; i < 2; i++) {
453  CeltBlock *block = &f->block[i];
454 
455  for (j = 0; j < FF_ARRAY_ELEMS(block->energy); j++)
456  block->energy[j] = CELT_ENERGY_SILENCE;
457  }
458  memset(f->block[0].coeffs, 0, sizeof(f->block[0].coeffs));
459  memset(f->block[1].coeffs, 0, sizeof(f->block[1].coeffs));
460  }
461 
462  /* transform and output for each output channel */
463  for (i = 0; i < f->output_channels; i++) {
464  CeltBlock *block = &f->block[i];
465  float m = block->emph_coeff;
466 
467  /* iMDCT and overlap-add */
468  for (j = 0; j < f->blocks; j++) {
469  float *dst = block->buf + 1024 + j * f->blocksize;
470 
471  imdct->imdct_half(imdct, dst + CELT_OVERLAP / 2, f->block[i].coeffs + j,
472  f->blocks);
473  f->dsp->vector_fmul_window(dst, dst, dst + CELT_OVERLAP / 2,
475  }
476 
477  if (downmix)
478  f->dsp->vector_fmul_scalar(&block->buf[1024], &block->buf[1024], 0.5f, frame_size);
479 
480  /* postfilter */
481  celt_postfilter(f, block);
482 
483  /* deemphasis and output scaling */
484  for (j = 0; j < frame_size; j++) {
485  const float tmp = block->buf[1024 - frame_size + j] + m;
486  m = tmp * CELT_EMPH_COEFF;
487  output[i][j] = tmp;
488  }
489 
490  block->emph_coeff = m;
491  }
492 
493  if (channels == 1)
494  memcpy(f->block[1].energy, f->block[0].energy, sizeof(f->block[0].energy));
495 
496  for (i = 0; i < 2; i++ ) {
497  CeltBlock *block = &f->block[i];
498 
499  if (!f->transient) {
500  memcpy(block->prev_energy[1], block->prev_energy[0], sizeof(block->prev_energy[0]));
501  memcpy(block->prev_energy[0], block->energy, sizeof(block->prev_energy[0]));
502  } else {
503  for (j = 0; j < CELT_MAX_BANDS; j++)
504  block->prev_energy[0][j] = FFMIN(block->prev_energy[0][j], block->energy[j]);
505  }
506 
507  for (j = 0; j < f->start_band; j++) {
508  block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
509  block->energy[j] = 0.0;
510  }
511  for (j = f->end_band; j < CELT_MAX_BANDS; j++) {
512  block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
513  block->energy[j] = 0.0;
514  }
515  }
516 
517  f->seed = rc->range;
518 
519  return 0;
520 }
521 
523 {
524  int i, j;
525 
526  if (f->flushed)
527  return;
528 
529  for (i = 0; i < 2; i++) {
530  CeltBlock *block = &f->block[i];
531 
532  for (j = 0; j < CELT_MAX_BANDS; j++)
533  block->prev_energy[0][j] = block->prev_energy[1][j] = CELT_ENERGY_SILENCE;
534 
535  memset(block->energy, 0, sizeof(block->energy));
536  memset(block->buf, 0, sizeof(block->buf));
537 
538  memset(block->pf_gains, 0, sizeof(block->pf_gains));
539  memset(block->pf_gains_old, 0, sizeof(block->pf_gains_old));
540  memset(block->pf_gains_new, 0, sizeof(block->pf_gains_new));
541 
542  block->emph_coeff = 0.0;
543  }
544  f->seed = 0;
545 
546  f->flushed = 1;
547 }
548 
550 {
551  CeltFrame *frm = *f;
552  int i;
553 
554  if (!frm)
555  return;
556 
557  for (i = 0; i < FF_ARRAY_ELEMS(frm->imdct); i++)
558  ff_mdct15_uninit(&frm->imdct[i]);
559 
560  ff_celt_pvq_uninit(&frm->pvq);
561 
562  av_freep(&frm->dsp);
563  av_freep(f);
564 }
565 
566 int ff_celt_init(AVCodecContext *avctx, CeltFrame **f, int output_channels,
567  int apply_phase_inv)
568 {
569  CeltFrame *frm;
570  int i, ret;
571 
572  if (output_channels != 1 && output_channels != 2) {
573  av_log(avctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",
574  output_channels);
575  return AVERROR(EINVAL);
576  }
577 
578  frm = av_mallocz(sizeof(*frm));
579  if (!frm)
580  return AVERROR(ENOMEM);
581 
582  frm->avctx = avctx;
583  frm->output_channels = output_channels;
584  frm->apply_phase_inv = apply_phase_inv;
585 
586  for (i = 0; i < FF_ARRAY_ELEMS(frm->imdct); i++)
587  if ((ret = ff_mdct15_init(&frm->imdct[i], 1, i + 3, -1.0f/32768)) < 0)
588  goto fail;
589 
590  if ((ret = ff_celt_pvq_init(&frm->pvq, 0)) < 0)
591  goto fail;
592 
594  if (!frm->dsp) {
595  ret = AVERROR(ENOMEM);
596  goto fail;
597  }
598 
599  ff_celt_flush(frm);
600 
601  *f = frm;
602 
603  return 0;
604 fail:
605  ff_celt_free(&frm);
606  return ret;
607 }
int channels
Definition: opus_celt.h:99
int anticollapse
Definition: opus_celt.h:117
int ff_celt_decode_frame(CeltFrame *f, OpusRangeCoder *rc, float **output, int channels, int frame_size, int start_band, int end_band)
Definition: opus_celt.c:347
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static float alpha(float a)
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
int framebits
Definition: opus_celt.h:131
static void celt_postfilter(CeltFrame *f, CeltBlock *block)
Definition: opus_celt.c:236
const uint8_t ff_celt_coarse_energy_dist[4][2][42]
Definition: opustab.c:803
float coeffs[CELT_MAX_FRAME_SIZE]
Definition: opus_celt.h:75
int output_channels
Definition: opus_celt.h:100
channels
Definition: aptx.c:30
const uint8_t ff_celt_freq_bands[]
Definition: opustab.c:763
int av_log2(unsigned v)
Definition: intmath.c:26
float pf_gains_new[3]
Definition: opus_celt.h:83
RawBitsContext rb
Definition: opus_rc.h:42
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:236
int av_cold ff_celt_pvq_init(CeltPVQ **pvq, int encode)
Definition: opus_pvq.c:897
const float ff_celt_postfilter_taps[3][3]
Definition: opustab.c:1093
static void celt_postfilter_apply(CeltBlock *block, float *data, int len)
Definition: opus_celt.c:205
int pf_period_new
Definition: opus_celt.h:82
void(* vector_fmac_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float and add to destination vector.
Definition: float_dsp.h:54
static void celt_denormalize(CeltFrame *f, CeltBlock *block, float *data)
Definition: opus_celt.c:146
static int16_t block[64]
Definition: dct.c:115
int fine_priority[CELT_MAX_BANDS]
Definition: opus_celt.h:136
CeltBlock block[2]
Definition: opus_celt.h:97
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:119
uint32_t total_bits
Definition: opus_rc.h:45
int flushed
Definition: opus_celt.h:120
uint8_t
#define CELT_OVERLAP
Definition: opus.h:42
const float * ff_celt_window
Definition: opustab.c:1130
int silence
Definition: opus_celt.h:115
static void process_anticollapse(CeltFrame *f, CeltBlock *block, float *X)
Definition: opus_celt.c:295
av_cold int ff_mdct15_init(MDCT15Context **ps, int inverse, int N, double scale)
Definition: mdct15.c:247
#define CELT_POSTFILTER_MINPERIOD
Definition: opus_celt.h:44
#define CELT_MAX_LOG_BLOCKS
Definition: opus.h:43
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
int end_band
Definition: opus_celt.h:105
uint32_t range
Definition: opus_rc.h:43
float pf_gains[3]
Definition: opus_celt.h:85
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void(* imdct_half)(struct MDCT15Context *s, float *dst, const float *src, ptrdiff_t stride)
Definition: mdct15.h:52
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:127
#define AVERROR(e)
Definition: error.h:43
int start_band
Definition: opus_celt.h:104
#define CELT_EMPH_COEFF
Definition: opus_celt.h:43
const char * r
Definition: vf_curves.c:111
void ff_celt_flush(CeltFrame *f)
Definition: opus_celt.c:522
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1583
static void celt_decode_tf_changes(CeltFrame *f, OpusRangeCoder *rc)
Definition: opus_celt.c:119
int tf_change[CELT_MAX_BANDS]
Definition: opus_celt.h:138
float emph_coeff
Definition: opus_celt.h:89
int pulses[CELT_MAX_BANDS]
Definition: opus_celt.h:137
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
int apply_phase_inv
Definition: opus_celt.h:101
#define FFMAX(a, b)
Definition: common.h:94
int anticollapse_needed
Definition: opus_celt.h:116
#define fail()
Definition: checkasm.h:114
int fine_bits[CELT_MAX_BANDS]
Definition: opus_celt.h:135
uint32_t ff_opus_rc_dec_cdf(OpusRangeCoder *rc, const uint16_t *cdf)
Definition: opus_rc.c:90
AVCodecContext * avctx
Definition: opus_celt.h:94
uint32_t seed
Definition: opus_celt.h:121
const int8_t ff_celt_tf_select[4][2][2][2]
Definition: opustab.c:777
#define T(x)
Definition: vp56_arith.h:29
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:884
#define FFMIN(a, b)
Definition: common.h:96
#define CELT_SHORT_BLOCKSIZE
Definition: opus.h:41
uint32_t bytes
Definition: opus_rc.h:35
uint8_t w
Definition: llviddspenc.c:38
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
void ff_celt_free(CeltFrame **f)
Definition: opus_celt.c:549
int blocks
Definition: opus_celt.h:113
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
Definition: float_dsp.h:85
int transient
Definition: opus_celt.h:107
int ff_opus_rc_dec_laplace(OpusRangeCoder *rc, uint32_t symbol, int decay)
Definition: opus_rc.c:275
const uint8_t ff_celt_freq_range[]
Definition: opustab.c:767
static void celt_decode_coarse_energy(CeltFrame *f, OpusRangeCoder *rc)
Definition: opus_celt.c:34
static void celt_postfilter_apply_transition(CeltBlock *block, float *data)
Definition: opus_celt.c:160
#define FF_ARRAY_ELEMS(a)
#define exp2f(x)
Definition: libm.h:293
int frame_size
Definition: mxfenc.c:1947
static void celt_decode_fine_energy(CeltFrame *f, OpusRangeCoder *rc)
Definition: opus_celt.c:78
#define CELT_MAX_BANDS
Definition: opus.h:45
main external API structure.
Definition: avcodec.h:1503
const float ff_celt_window2[120]
Definition: opustab.c:1133
int pf_period_old
Definition: opus_celt.h:86
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:61
#define CELT_MAX_FINE_BITS
Definition: opus_celt.h:39
AVFloatDSPContext * dsp
Definition: opus_celt.h:96
#define CELT_ENERGY_SILENCE
Definition: opus_celt.h:45
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
void ff_celt_bitalloc(CeltFrame *f, OpusRangeCoder *rc, int encode)
Definition: opus.c:552
CeltPVQ * pvq
Definition: opus_celt.h:98
static av_always_inline void celt_renormalize_vector(float *X, int N, float gain)
Definition: opus_celt.h:148
float pf_gains_old[3]
Definition: opus_celt.h:87
const uint16_t ff_celt_model_energy_small[]
Definition: opustab.c:761
#define M_SQRT2
Definition: mathematics.h:61
float energy[CELT_MAX_BANDS]
Definition: opus_celt.h:66
const float ff_celt_beta_coef[]
Definition: opustab.c:799
static av_always_inline uint32_t celt_rng(CeltFrame *f)
Definition: opus_celt.h:142
av_cold void ff_mdct15_uninit(MDCT15Context **ps)
Definition: mdct15.c:43
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int blocksize
Definition: opus_celt.h:114
int len
static void celt_decode_final_energy(CeltFrame *f, OpusRangeCoder *rc)
Definition: opus_celt.c:97
const float ff_celt_alpha_coef[]
Definition: opustab.c:795
static int16_t block1[64]
Definition: dct.c:116
uint32_t ff_opus_rc_dec_uint(OpusRangeCoder *rc, uint32_t size)
CELT: read a uniform distribution.
Definition: opus_rc.c:182
const float ff_celt_mean_energy[]
Definition: opustab.c:787
#define av_freep(p)
static int parse_postfilter(CeltFrame *f, OpusRangeCoder *rc, int consumed)
Definition: opus_celt.c:260
enum CeltBlockSize size
Definition: opus_celt.h:103
MDCT15Context * imdct[4]
Definition: opus_celt.h:95
int pf_period
Definition: opus_celt.h:84
float prev_energy[2][CELT_MAX_BANDS]
Definition: opus_celt.h:69
uint8_t collapse_masks[CELT_MAX_BANDS]
Definition: opus_celt.h:71
const uint16_t ff_celt_model_tapset[]
Definition: opustab.c:753
int ff_celt_init(AVCodecContext *avctx, CeltFrame **f, int output_channels, int apply_phase_inv)
Definition: opus_celt.c:566
void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)
Definition: opus_pvq.c:914
void ff_celt_quant_bands(CeltFrame *f, OpusRangeCoder *rc)
Definition: opus.c:443
float buf[2048]
Definition: opus_celt.h:74
static uint8_t tmp[11]
Definition: aes_ctr.c:26