FFmpeg
opusdec.c
Go to the documentation of this file.
1 /*
2  * Opus decoder
3  * Copyright (c) 2012 Andrew D'Addesio
4  * Copyright (c) 2013-2014 Mozilla Corporation
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 decoder
26  * @author Andrew D'Addesio, Anton Khirnov
27  *
28  * Codec homepage: http://opus-codec.org/
29  * Specification: http://tools.ietf.org/html/rfc6716
30  * Ogg Opus specification: https://tools.ietf.org/html/draft-ietf-codec-oggopus-03
31  *
32  * Ogg-contained .opus files can be produced with opus-tools:
33  * http://git.xiph.org/?p=opus-tools.git
34  */
35 
36 #include <stdint.h>
37 
38 #include "libavutil/attributes.h"
39 #include "libavutil/audio_fifo.h"
41 #include "libavutil/opt.h"
42 
44 
45 #include "avcodec.h"
46 #include "codec_internal.h"
47 #include "get_bits.h"
48 #include "internal.h"
49 #include "mathops.h"
50 #include "opus.h"
51 #include "opustab.h"
52 #include "opus_celt.h"
53 
54 static const uint16_t silk_frame_duration_ms[16] = {
55  10, 20, 40, 60,
56  10, 20, 40, 60,
57  10, 20, 40, 60,
58  10, 20,
59  10, 20,
60 };
61 
62 /* number of samples of silence to feed to the resampler
63  * at the beginning */
64 static const int silk_resample_delay[] = {
65  4, 8, 11, 11, 11
66 };
67 
68 static int get_silk_samplerate(int config)
69 {
70  if (config < 4)
71  return 8000;
72  else if (config < 8)
73  return 12000;
74  return 16000;
75 }
76 
77 static void opus_fade(float *out,
78  const float *in1, const float *in2,
79  const float *window, int len)
80 {
81  int i;
82  for (i = 0; i < len; i++)
83  out[i] = in2[i] * window[i] + in1[i] * (1.0 - window[i]);
84 }
85 
86 static int opus_flush_resample(OpusStreamContext *s, int nb_samples)
87 {
88  int celt_size = av_audio_fifo_size(s->celt_delay);
89  int ret, i;
90  ret = swr_convert(s->swr,
91  (uint8_t**)s->cur_out, nb_samples,
92  NULL, 0);
93  if (ret < 0)
94  return ret;
95  else if (ret != nb_samples) {
96  av_log(s->avctx, AV_LOG_ERROR, "Wrong number of flushed samples: %d\n",
97  ret);
98  return AVERROR_BUG;
99  }
100 
101  if (celt_size) {
102  if (celt_size != nb_samples) {
103  av_log(s->avctx, AV_LOG_ERROR, "Wrong number of CELT delay samples.\n");
104  return AVERROR_BUG;
105  }
106  av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, nb_samples);
107  for (i = 0; i < s->output_channels; i++) {
108  s->fdsp->vector_fmac_scalar(s->cur_out[i],
109  s->celt_output[i], 1.0,
110  nb_samples);
111  }
112  }
113 
114  if (s->redundancy_idx) {
115  for (i = 0; i < s->output_channels; i++)
116  opus_fade(s->cur_out[i], s->cur_out[i],
117  s->redundancy_output[i] + 120 + s->redundancy_idx,
118  ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);
119  s->redundancy_idx = 0;
120  }
121 
122  s->cur_out[0] += nb_samples;
123  s->cur_out[1] += nb_samples;
124  s->remaining_out_size -= nb_samples * sizeof(float);
125 
126  return 0;
127 }
128 
130 {
131  static const float delay[16] = { 0.0 };
132  const uint8_t *delayptr[2] = { (uint8_t*)delay, (uint8_t*)delay };
133  int ret;
134 
135  av_opt_set_int(s->swr, "in_sample_rate", s->silk_samplerate, 0);
136  ret = swr_init(s->swr);
137  if (ret < 0) {
138  av_log(s->avctx, AV_LOG_ERROR, "Error opening the resampler.\n");
139  return ret;
140  }
141 
142  ret = swr_convert(s->swr,
143  NULL, 0,
144  delayptr, silk_resample_delay[s->packet.bandwidth]);
145  if (ret < 0) {
146  av_log(s->avctx, AV_LOG_ERROR,
147  "Error feeding initial silence to the resampler.\n");
148  return ret;
149  }
150 
151  return 0;
152 }
153 
154 static int opus_decode_redundancy(OpusStreamContext *s, const uint8_t *data, int size)
155 {
156  int ret = ff_opus_rc_dec_init(&s->redundancy_rc, data, size);
157  if (ret < 0)
158  goto fail;
159  ff_opus_rc_dec_raw_init(&s->redundancy_rc, data + size, size);
160 
161  ret = ff_celt_decode_frame(s->celt, &s->redundancy_rc,
162  s->redundancy_output,
163  s->packet.stereo + 1, 240,
164  0, ff_celt_band_end[s->packet.bandwidth]);
165  if (ret < 0)
166  goto fail;
167 
168  return 0;
169 fail:
170  av_log(s->avctx, AV_LOG_ERROR, "Error decoding the redundancy frame.\n");
171  return ret;
172 }
173 
174 static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size)
175 {
176  int samples = s->packet.frame_duration;
177  int redundancy = 0;
178  int redundancy_size, redundancy_pos;
179  int ret, i, consumed;
180  int delayed_samples = s->delayed_samples;
181 
182  ret = ff_opus_rc_dec_init(&s->rc, data, size);
183  if (ret < 0)
184  return ret;
185 
186  /* decode the silk frame */
187  if (s->packet.mode == OPUS_MODE_SILK || s->packet.mode == OPUS_MODE_HYBRID) {
188  if (!swr_is_initialized(s->swr)) {
190  if (ret < 0)
191  return ret;
192  }
193 
194  samples = ff_silk_decode_superframe(s->silk, &s->rc, s->silk_output,
195  FFMIN(s->packet.bandwidth, OPUS_BANDWIDTH_WIDEBAND),
196  s->packet.stereo + 1,
197  silk_frame_duration_ms[s->packet.config]);
198  if (samples < 0) {
199  av_log(s->avctx, AV_LOG_ERROR, "Error decoding a SILK frame.\n");
200  return samples;
201  }
202  samples = swr_convert(s->swr,
203  (uint8_t**)s->cur_out, s->packet.frame_duration,
204  (const uint8_t**)s->silk_output, samples);
205  if (samples < 0) {
206  av_log(s->avctx, AV_LOG_ERROR, "Error resampling SILK data.\n");
207  return samples;
208  }
209  av_assert2((samples & 7) == 0);
210  s->delayed_samples += s->packet.frame_duration - samples;
211  } else
212  ff_silk_flush(s->silk);
213 
214  // decode redundancy information
215  consumed = opus_rc_tell(&s->rc);
216  if (s->packet.mode == OPUS_MODE_HYBRID && consumed + 37 <= size * 8)
217  redundancy = ff_opus_rc_dec_log(&s->rc, 12);
218  else if (s->packet.mode == OPUS_MODE_SILK && consumed + 17 <= size * 8)
219  redundancy = 1;
220 
221  if (redundancy) {
222  redundancy_pos = ff_opus_rc_dec_log(&s->rc, 1);
223 
224  if (s->packet.mode == OPUS_MODE_HYBRID)
225  redundancy_size = ff_opus_rc_dec_uint(&s->rc, 256) + 2;
226  else
227  redundancy_size = size - (consumed + 7) / 8;
228  size -= redundancy_size;
229  if (size < 0) {
230  av_log(s->avctx, AV_LOG_ERROR, "Invalid redundancy frame size.\n");
231  return AVERROR_INVALIDDATA;
232  }
233 
234  if (redundancy_pos) {
235  ret = opus_decode_redundancy(s, data + size, redundancy_size);
236  if (ret < 0)
237  return ret;
238  ff_celt_flush(s->celt);
239  }
240  }
241 
242  /* decode the CELT frame */
243  if (s->packet.mode == OPUS_MODE_CELT || s->packet.mode == OPUS_MODE_HYBRID) {
244  float *out_tmp[2] = { s->cur_out[0], s->cur_out[1] };
245  float **dst = (s->packet.mode == OPUS_MODE_CELT) ?
246  out_tmp : s->celt_output;
247  int celt_output_samples = samples;
248  int delay_samples = av_audio_fifo_size(s->celt_delay);
249 
250  if (delay_samples) {
251  if (s->packet.mode == OPUS_MODE_HYBRID) {
252  av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, delay_samples);
253 
254  for (i = 0; i < s->output_channels; i++) {
255  s->fdsp->vector_fmac_scalar(out_tmp[i], s->celt_output[i], 1.0,
256  delay_samples);
257  out_tmp[i] += delay_samples;
258  }
259  celt_output_samples -= delay_samples;
260  } else {
261  av_log(s->avctx, AV_LOG_WARNING,
262  "Spurious CELT delay samples present.\n");
263  av_audio_fifo_drain(s->celt_delay, delay_samples);
264  if (s->avctx->err_recognition & AV_EF_EXPLODE)
265  return AVERROR_BUG;
266  }
267  }
268 
270 
271  ret = ff_celt_decode_frame(s->celt, &s->rc, dst,
272  s->packet.stereo + 1,
273  s->packet.frame_duration,
274  (s->packet.mode == OPUS_MODE_HYBRID) ? 17 : 0,
275  ff_celt_band_end[s->packet.bandwidth]);
276  if (ret < 0)
277  return ret;
278 
279  if (s->packet.mode == OPUS_MODE_HYBRID) {
280  int celt_delay = s->packet.frame_duration - celt_output_samples;
281  void *delaybuf[2] = { s->celt_output[0] + celt_output_samples,
282  s->celt_output[1] + celt_output_samples };
283 
284  for (i = 0; i < s->output_channels; i++) {
285  s->fdsp->vector_fmac_scalar(out_tmp[i],
286  s->celt_output[i], 1.0,
287  celt_output_samples);
288  }
289 
290  ret = av_audio_fifo_write(s->celt_delay, delaybuf, celt_delay);
291  if (ret < 0)
292  return ret;
293  }
294  } else
295  ff_celt_flush(s->celt);
296 
297  if (s->redundancy_idx) {
298  for (i = 0; i < s->output_channels; i++)
299  opus_fade(s->cur_out[i], s->cur_out[i],
300  s->redundancy_output[i] + 120 + s->redundancy_idx,
301  ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);
302  s->redundancy_idx = 0;
303  }
304  if (redundancy) {
305  if (!redundancy_pos) {
306  ff_celt_flush(s->celt);
307  ret = opus_decode_redundancy(s, data + size, redundancy_size);
308  if (ret < 0)
309  return ret;
310 
311  for (i = 0; i < s->output_channels; i++) {
312  opus_fade(s->cur_out[i] + samples - 120 + delayed_samples,
313  s->cur_out[i] + samples - 120 + delayed_samples,
314  s->redundancy_output[i] + 120,
315  ff_celt_window2, 120 - delayed_samples);
316  if (delayed_samples)
317  s->redundancy_idx = 120 - delayed_samples;
318  }
319  } else {
320  for (i = 0; i < s->output_channels; i++) {
321  memcpy(s->cur_out[i] + delayed_samples, s->redundancy_output[i], 120 * sizeof(float));
322  opus_fade(s->cur_out[i] + 120 + delayed_samples,
323  s->redundancy_output[i] + 120,
324  s->cur_out[i] + 120 + delayed_samples,
325  ff_celt_window2, 120);
326  }
327  }
328  }
329 
330  return samples;
331 }
332 
334  const uint8_t *buf, int buf_size,
335  int nb_samples)
336 {
337  int output_samples = 0;
338  int flush_needed = 0;
339  int i, j, ret;
340 
341  s->cur_out[0] = s->out[0];
342  s->cur_out[1] = s->out[1];
343  s->remaining_out_size = s->out_size;
344 
345  /* check if we need to flush the resampler */
346  if (swr_is_initialized(s->swr)) {
347  if (buf) {
348  int64_t cur_samplerate;
349  av_opt_get_int(s->swr, "in_sample_rate", 0, &cur_samplerate);
350  flush_needed = (s->packet.mode == OPUS_MODE_CELT) || (cur_samplerate != s->silk_samplerate);
351  } else {
352  flush_needed = !!s->delayed_samples;
353  }
354  }
355 
356  if (!buf && !flush_needed)
357  return 0;
358 
359  /* use dummy output buffers if the channel is not mapped to anything */
360  if (!s->cur_out[0] ||
361  (s->output_channels == 2 && !s->cur_out[1])) {
362  av_fast_malloc(&s->out_dummy, &s->out_dummy_allocated_size,
363  s->remaining_out_size);
364  if (!s->out_dummy)
365  return AVERROR(ENOMEM);
366  if (!s->cur_out[0])
367  s->cur_out[0] = s->out_dummy;
368  if (!s->cur_out[1])
369  s->cur_out[1] = s->out_dummy;
370  }
371 
372  /* flush the resampler if necessary */
373  if (flush_needed) {
374  ret = opus_flush_resample(s, s->delayed_samples);
375  if (ret < 0) {
376  av_log(s->avctx, AV_LOG_ERROR, "Error flushing the resampler.\n");
377  return ret;
378  }
379  swr_close(s->swr);
380  output_samples += s->delayed_samples;
381  s->delayed_samples = 0;
382 
383  if (!buf)
384  goto finish;
385  }
386 
387  /* decode all the frames in the packet */
388  for (i = 0; i < s->packet.frame_count; i++) {
389  int size = s->packet.frame_size[i];
390  int samples = opus_decode_frame(s, buf + s->packet.frame_offset[i], size);
391 
392  if (samples < 0) {
393  av_log(s->avctx, AV_LOG_ERROR, "Error decoding an Opus frame.\n");
394  if (s->avctx->err_recognition & AV_EF_EXPLODE)
395  return samples;
396 
397  for (j = 0; j < s->output_channels; j++)
398  memset(s->cur_out[j], 0, s->packet.frame_duration * sizeof(float));
399  samples = s->packet.frame_duration;
400  }
401  output_samples += samples;
402 
403  for (j = 0; j < s->output_channels; j++)
404  s->cur_out[j] += samples;
405  s->remaining_out_size -= samples * sizeof(float);
406  }
407 
408 finish:
409  s->cur_out[0] = s->cur_out[1] = NULL;
410  s->remaining_out_size = 0;
411 
412  return output_samples;
413 }
414 
416  int *got_frame_ptr, AVPacket *avpkt)
417 {
418  OpusContext *c = avctx->priv_data;
419  const uint8_t *buf = avpkt->data;
420  int buf_size = avpkt->size;
421  int coded_samples = 0;
422  int decoded_samples = INT_MAX;
423  int delayed_samples = 0;
424  int i, ret;
425 
426  /* calculate the number of delayed samples */
427  for (i = 0; i < c->nb_streams; i++) {
428  OpusStreamContext *s = &c->streams[i];
429  s->out[0] =
430  s->out[1] = NULL;
431  delayed_samples = FFMAX(delayed_samples,
432  s->delayed_samples + av_audio_fifo_size(s->sync_buffer));
433  }
434 
435  /* decode the header of the first sub-packet to find out the sample count */
436  if (buf) {
437  OpusPacket *pkt = &c->streams[0].packet;
438  ret = ff_opus_parse_packet(pkt, buf, buf_size, c->nb_streams > 1);
439  if (ret < 0) {
440  av_log(avctx, AV_LOG_ERROR, "Error parsing the packet header.\n");
441  return ret;
442  }
443  coded_samples += pkt->frame_count * pkt->frame_duration;
444  c->streams[0].silk_samplerate = get_silk_samplerate(pkt->config);
445  }
446 
447  frame->nb_samples = coded_samples + delayed_samples;
448 
449  /* no input or buffered data => nothing to do */
450  if (!frame->nb_samples) {
451  *got_frame_ptr = 0;
452  return 0;
453  }
454 
455  /* setup the data buffers */
456  ret = ff_get_buffer(avctx, frame, 0);
457  if (ret < 0)
458  return ret;
459  frame->nb_samples = 0;
460 
461  for (i = 0; i < avctx->ch_layout.nb_channels; i++) {
462  ChannelMap *map = &c->channel_maps[i];
463  if (!map->copy)
464  c->streams[map->stream_idx].out[map->channel_idx] = (float*)frame->extended_data[i];
465  }
466 
467  /* read the data from the sync buffers */
468  for (i = 0; i < c->nb_streams; i++) {
469  OpusStreamContext *s = &c->streams[i];
470  float **out = s->out;
471  int sync_size = av_audio_fifo_size(s->sync_buffer);
472 
473  float sync_dummy[32];
474  int out_dummy = (!out[0]) | ((!out[1]) << 1);
475 
476  if (!out[0])
477  out[0] = sync_dummy;
478  if (!out[1])
479  out[1] = sync_dummy;
480  if (out_dummy && sync_size > FF_ARRAY_ELEMS(sync_dummy))
481  return AVERROR_BUG;
482 
483  ret = av_audio_fifo_read(s->sync_buffer, (void**)out, sync_size);
484  if (ret < 0)
485  return ret;
486 
487  if (out_dummy & 1)
488  out[0] = NULL;
489  else
490  out[0] += ret;
491  if (out_dummy & 2)
492  out[1] = NULL;
493  else
494  out[1] += ret;
495 
496  s->out_size = frame->linesize[0] - ret * sizeof(float);
497  }
498 
499  /* decode each sub-packet */
500  for (i = 0; i < c->nb_streams; i++) {
501  OpusStreamContext *s = &c->streams[i];
502 
503  if (i && buf) {
504  ret = ff_opus_parse_packet(&s->packet, buf, buf_size, i != c->nb_streams - 1);
505  if (ret < 0) {
506  av_log(avctx, AV_LOG_ERROR, "Error parsing the packet header.\n");
507  return ret;
508  }
509  if (coded_samples != s->packet.frame_count * s->packet.frame_duration) {
510  av_log(avctx, AV_LOG_ERROR,
511  "Mismatching coded sample count in substream %d.\n", i);
512  return AVERROR_INVALIDDATA;
513  }
514 
515  s->silk_samplerate = get_silk_samplerate(s->packet.config);
516  }
517 
518  ret = opus_decode_subpacket(&c->streams[i], buf, s->packet.data_size,
519  coded_samples);
520  if (ret < 0)
521  return ret;
522  s->decoded_samples = ret;
523  decoded_samples = FFMIN(decoded_samples, ret);
524 
525  buf += s->packet.packet_size;
526  buf_size -= s->packet.packet_size;
527  }
528 
529  /* buffer the extra samples */
530  for (i = 0; i < c->nb_streams; i++) {
531  OpusStreamContext *s = &c->streams[i];
532  int buffer_samples = s->decoded_samples - decoded_samples;
533  if (buffer_samples) {
534  float *buf[2] = { s->out[0] ? s->out[0] : (float*)frame->extended_data[0],
535  s->out[1] ? s->out[1] : (float*)frame->extended_data[0] };
536  buf[0] += decoded_samples;
537  buf[1] += decoded_samples;
538  ret = av_audio_fifo_write(s->sync_buffer, (void**)buf, buffer_samples);
539  if (ret < 0)
540  return ret;
541  }
542  }
543 
544  for (i = 0; i < avctx->ch_layout.nb_channels; i++) {
545  ChannelMap *map = &c->channel_maps[i];
546 
547  /* handle copied channels */
548  if (map->copy) {
549  memcpy(frame->extended_data[i],
550  frame->extended_data[map->copy_idx],
551  frame->linesize[0]);
552  } else if (map->silence) {
553  memset(frame->extended_data[i], 0, frame->linesize[0]);
554  }
555 
556  if (c->gain_i && decoded_samples > 0) {
557  c->fdsp->vector_fmul_scalar((float*)frame->extended_data[i],
558  (float*)frame->extended_data[i],
559  c->gain, FFALIGN(decoded_samples, 8));
560  }
561  }
562 
563  frame->nb_samples = decoded_samples;
564  *got_frame_ptr = !!decoded_samples;
565 
566  return avpkt->size;
567 }
568 
570 {
572  int i;
573 
574  for (i = 0; i < c->nb_streams; i++) {
575  OpusStreamContext *s = &c->streams[i];
576 
577  memset(&s->packet, 0, sizeof(s->packet));
578  s->delayed_samples = 0;
579 
580  av_audio_fifo_drain(s->celt_delay, av_audio_fifo_size(s->celt_delay));
581  swr_close(s->swr);
582 
583  av_audio_fifo_drain(s->sync_buffer, av_audio_fifo_size(s->sync_buffer));
584 
585  ff_silk_flush(s->silk);
586  ff_celt_flush(s->celt);
587  }
588 }
589 
591 {
592  OpusContext *c = avctx->priv_data;
593  int i;
594 
595  for (i = 0; i < c->nb_streams; i++) {
596  OpusStreamContext *s = &c->streams[i];
597 
598  ff_silk_free(&s->silk);
599  ff_celt_free(&s->celt);
600 
601  av_freep(&s->out_dummy);
602  s->out_dummy_allocated_size = 0;
603 
604  av_audio_fifo_free(s->sync_buffer);
605  av_audio_fifo_free(s->celt_delay);
606  swr_free(&s->swr);
607  }
608 
609  av_freep(&c->streams);
610 
611  c->nb_streams = 0;
612 
613  av_freep(&c->channel_maps);
614  av_freep(&c->fdsp);
615 
616  return 0;
617 }
618 
620 {
621  OpusContext *c = avctx->priv_data;
622  int ret, i, j;
623 
625  avctx->sample_rate = 48000;
626 
627  c->fdsp = avpriv_float_dsp_alloc(0);
628  if (!c->fdsp)
629  return AVERROR(ENOMEM);
630 
631  /* find out the channel configuration */
632  ret = ff_opus_parse_extradata(avctx, c);
633  if (ret < 0)
634  return ret;
635 
636  /* allocate and init each independent decoder */
637  c->streams = av_calloc(c->nb_streams, sizeof(*c->streams));
638  if (!c->streams) {
639  c->nb_streams = 0;
640  return AVERROR(ENOMEM);
641  }
642 
643  for (i = 0; i < c->nb_streams; i++) {
644  OpusStreamContext *s = &c->streams[i];
645  uint64_t layout;
646 
647  s->output_channels = (i < c->nb_stereo_streams) ? 2 : 1;
648 
649  s->avctx = avctx;
650 
651  for (j = 0; j < s->output_channels; j++) {
652  s->silk_output[j] = s->silk_buf[j];
653  s->celt_output[j] = s->celt_buf[j];
654  s->redundancy_output[j] = s->redundancy_buf[j];
655  }
656 
657  s->fdsp = c->fdsp;
658 
659  s->swr =swr_alloc();
660  if (!s->swr)
661  return AVERROR(ENOMEM);
662 
663  layout = (s->output_channels == 1) ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
664  av_opt_set_int(s->swr, "in_sample_fmt", avctx->sample_fmt, 0);
665  av_opt_set_int(s->swr, "out_sample_fmt", avctx->sample_fmt, 0);
666  av_opt_set_int(s->swr, "in_channel_layout", layout, 0);
667  av_opt_set_int(s->swr, "out_channel_layout", layout, 0);
668  av_opt_set_int(s->swr, "out_sample_rate", avctx->sample_rate, 0);
669  av_opt_set_int(s->swr, "filter_size", 16, 0);
670 
671  ret = ff_silk_init(avctx, &s->silk, s->output_channels);
672  if (ret < 0)
673  return ret;
674 
675  ret = ff_celt_init(avctx, &s->celt, s->output_channels, c->apply_phase_inv);
676  if (ret < 0)
677  return ret;
678 
679  s->celt_delay = av_audio_fifo_alloc(avctx->sample_fmt,
680  s->output_channels, 1024);
681  if (!s->celt_delay)
682  return AVERROR(ENOMEM);
683 
684  s->sync_buffer = av_audio_fifo_alloc(avctx->sample_fmt,
685  s->output_channels, 32);
686  if (!s->sync_buffer)
687  return AVERROR(ENOMEM);
688  }
689 
690  return 0;
691 }
692 
693 #define OFFSET(x) offsetof(OpusContext, x)
694 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
695 static const AVOption opus_options[] = {
696  { "apply_phase_inv", "Apply intensity stereo phase inversion", OFFSET(apply_phase_inv), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, AD },
697  { NULL },
698 };
699 
700 static const AVClass opus_class = {
701  .class_name = "Opus Decoder",
702  .item_name = av_default_item_name,
703  .option = opus_options,
704  .version = LIBAVUTIL_VERSION_INT,
705 };
706 
708  .p.name = "opus",
709  .p.long_name = NULL_IF_CONFIG_SMALL("Opus"),
710  .p.priv_class = &opus_class,
711  .p.type = AVMEDIA_TYPE_AUDIO,
712  .p.id = AV_CODEC_ID_OPUS,
713  .priv_data_size = sizeof(OpusContext),
715  .close = opus_decode_close,
717  .flush = opus_decode_flush,
720 };
av_audio_fifo_free
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
Definition: audio_fifo.c:48
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:39
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
opt.h
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:998
ff_opus_parse_extradata
av_cold int ff_opus_parse_extradata(AVCodecContext *avctx, OpusContext *s)
Definition: opus.c:293
ff_celt_flush
void ff_celt_flush(CeltFrame *f)
Definition: opus_celt.c:490
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:204
ff_opus_decoder
const FFCodec ff_opus_decoder
Definition: opusdec.c:707
opus_decode_packet
static int opus_decode_packet(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: opusdec.c:415
opus_decode_frame
static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size)
Definition: opusdec.c:174
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
data
const char data[16]
Definition: mxf.c:143
opus_decode_close
static av_cold int opus_decode_close(AVCodecContext *avctx)
Definition: opusdec.c:590
opus.h
FFCodec
Definition: codec_internal.h:112
ff_opus_parse_packet
int ff_opus_parse_packet(OpusPacket *pkt, const uint8_t *buf, int buf_size, int self_delimiting)
Parse Opus packet info from raw packet data.
Definition: opus.c:92
OFFSET
#define OFFSET(x)
Definition: opusdec.c:693
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
tf_sess_config.config
config
Definition: tf_sess_config.py:33
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:61
init
static int init
Definition: av_tx.c:47
silk_frame_duration_ms
static const uint16_t silk_frame_duration_ms[16]
Definition: opusdec.c:54
opus_options
static const AVOption opus_options[]
Definition: opusdec.c:695
window
static SDL_Window * window
Definition: ffplay.c:365
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
finish
static void finish(void)
Definition: movenc.c:342
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
av_audio_fifo_drain
int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
Drain data from an AVAudioFifo.
Definition: audio_fifo.c:194
fail
#define fail()
Definition: checkasm.h:130
swr_is_initialized
int swr_is_initialized(struct SwrContext *s)
Check whether an swr context has been initialized or not.
Definition: swresample.c:796
opus_fade
static void opus_fade(float *out, const float *in1, const float *in2, const float *window, int len)
Definition: opusdec.c:77
opus_decode_redundancy
static int opus_decode_redundancy(OpusStreamContext *s, const uint8_t *data, int size)
Definition: opusdec.c:154
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:205
ff_celt_init
int ff_celt_init(AVCodecContext *avctx, CeltFrame **f, int output_channels, int apply_phase_inv)
Definition: opus_celt.c:538
pkt
AVPacket * pkt
Definition: movenc.c:59
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
av_cold
#define av_cold
Definition: attributes.h:90
swr_init
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
Definition: swresample.c:191
float
float
Definition: af_crystalizer.c:122
OpusStreamContext
Definition: opus.h:101
ff_celt_band_end
const uint8_t ff_celt_band_end[]
Definition: opustab.c:29
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
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
s
#define s(width, name)
Definition: cbs_vp9.c:256
av_audio_fifo_write
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
Definition: audio_fifo.c:119
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
swr_alloc
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
Definition: options.c:167
ff_silk_init
int ff_silk_init(AVCodecContext *avctx, SilkContext **ps, int output_channels)
Definition: opus_silk.c:875
opus_flush_resample
static int opus_flush_resample(OpusStreamContext *s, int nb_samples)
Definition: opusdec.c:86
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
ff_silk_flush
void ff_silk_flush(SilkContext *s)
Definition: opus_silk.c:867
OPUS_BANDWIDTH_WIDEBAND
@ OPUS_BANDWIDTH_WIDEBAND
Definition: opus.h:74
OPUS_MODE_CELT
@ OPUS_MODE_CELT
Definition: opus.h:66
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_silk_decode_superframe
int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc, float *output[2], enum OpusBandwidth bandwidth, int coded_channels, int duration_ms)
Decode the LP layer of one Opus frame (which may correspond to several SILK frames).
Definition: opus_silk.c:786
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_audio_fifo_alloc
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
Definition: audio_fifo.c:62
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
mathops.h
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:978
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1355
swresample.h
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:624
opus_class
static const AVClass opus_class
Definition: opusdec.c:700
opus_decode_init
static av_cold int opus_decode_init(AVCodecContext *avctx)
Definition: opusdec.c:619
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
opustab.h
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
codec_internal.h
get_silk_samplerate
static int get_silk_samplerate(int config)
Definition: opusdec.c:68
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1014
size
int size
Definition: twinvq_data.h:10344
ff_celt_free
void ff_celt_free(CeltFrame **f)
Definition: opus_celt.c:521
swr_free
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:173
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:485
swr_convert
int attribute_align_arg swr_convert(struct SwrContext *s, uint8_t **out_arg, int out_count, const uint8_t **in_arg, int in_count)
Convert audio.
Definition: swresample.c:800
ff_celt_window2
const float ff_celt_window2[120]
Definition: opustab.c:1138
ff_opus_rc_dec_init
int ff_opus_rc_dec_init(OpusRangeCoder *rc, const uint8_t *data, int size)
Definition: opus_rc.c:338
attributes.h
av_audio_fifo_size
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
Definition: audio_fifo.c:221
layout
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 layout
Definition: filter_design.txt:18
av_audio_fifo_read
int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
Read data from an AVAudioFifo.
Definition: audio_fifo.c:174
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
opus_celt.h
ff_opus_rc_dec_raw_init
void ff_opus_rc_dec_raw_init(OpusRangeCoder *rc, const uint8_t *rightend, uint32_t bytes)
Definition: opus_rc.c:352
OPUS_MODE_HYBRID
@ OPUS_MODE_HYBRID
Definition: opus.h:65
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: codec_internal.h:31
opus_decode_flush
static av_cold void opus_decode_flush(AVCodecContext *ctx)
Definition: opusdec.c:569
audio_fifo.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
len
int len
Definition: vorbis_enc_data.h:426
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_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: opus_celt.c:320
opus_decode_subpacket
static int opus_decode_subpacket(OpusStreamContext *s, const uint8_t *buf, int buf_size, int nb_samples)
Definition: opusdec.c:333
AVCodecContext
main external API structure.
Definition: avcodec.h:389
AD
#define AD
Definition: opusdec.c:694
channel_layout.h
OPUS_MODE_SILK
@ OPUS_MODE_SILK
Definition: opus.h:64
OpusPacket
Definition: opus.h:85
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:82
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
opus_init_resample
static int opus_init_resample(OpusStreamContext *s)
Definition: opusdec.c:129
ChannelMap
Definition: opus.h:147
silk_resample_delay
static const int silk_resample_delay[]
Definition: opusdec.c:64
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:561
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
swr_close
av_cold void swr_close(SwrContext *s)
Closes the context so that swr_is_initialized() returns 0.
Definition: swresample.c:187
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
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_silk_free
void ff_silk_free(SilkContext **ps)
Definition: opus_silk.c:862
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1241
OpusContext
Definition: opus.h:162