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" 40#include "libavutil/channel_layout.h" 41#include "libavutil/opt.h" 42 43#include "libswresample/swresample.h" 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 54static 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 */ 64static const int silk_resample_delay[] = { 65 4, 8, 11, 11, 11 66}; 67 68static 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 77static 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 86static 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 129static int opus_init_resample(OpusStreamContext *s) 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 154static 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; 169fail: 170 av_log(s->avctx, AV_LOG_ERROR, "Error decoding the redundancy frame.\n"); 171 return ret; 172} 173 174static 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)) { 189 ret = opus_init_resample(s); 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 269 ff_opus_rc_dec_raw_init(&s->rc, data + size, size); 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 333static int opus_decode_subpacket(OpusStreamContext *s, 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 408finish: 409 s->cur_out[0] = s->cur_out[1] = NULL; 410 s->remaining_out_size = 0; 411 412 return output_samples; 413} 414 415static int opus_decode_packet(AVCodecContext *avctx, AVFrame *frame, 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 569static av_cold void opus_decode_flush(AVCodecContext *ctx) 570{ 571 OpusContext *c = ctx->priv_data; 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 590static av_cold int opus_decode_close(AVCodecContext *avctx) 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 619static av_cold int opus_decode_init(AVCodecContext *avctx) 620{ 621 OpusContext *c = avctx->priv_data; 622 int ret, i, j; 623 624 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; 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 695static 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 700static 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 707const FFCodec ff_opus_decoder = { 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), 714 .init = opus_decode_init, 715 .close = opus_decode_close, 716 FF_CODEC_DECODE_CB(opus_decode_packet), 717 .flush = opus_decode_flush, 718 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_CHANNEL_CONF, 719 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, 720}; 721