FFmpeg: libavcodec/opusdec.c Source File

FFmpeg

[フレーム]

libavcodec

opusdec.c

Go to the documentation of this file.

1 /*

2 * Opus decoder

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 */

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 */

36 #include <stdint.h>

38 #include "libavutil/attributes.h"

39 #include "libavutil/audio_fifo.h"

40 #include "libavutil/channel_layout.h"

41 #include "libavutil/ffmath.h"

42 #include "libavutil/float_dsp.h"

43 #include "libavutil/frame.h"

44 #include "libavutil/mem_internal.h"

45 #include "libavutil/opt.h"

47 #include "libswresample/swresample.h"

49 #include "avcodec.h"

50 #include "codec_internal.h"

51 #include "decode.h"

52 #include "opus.h"

53 #include "opustab.h"

54 #include "opus_celt.h"

55 #include "opus_parse.h"

56 #include "opus_rc.h"

57 #include "opus_silk.h"

59 static const uint16_t silk_frame_duration_ms[16] = {

60 10, 20, 40, 60,

61 10, 20, 40, 60,

62 10, 20, 40, 60,

63 10, 20,

64 10, 20,

65 };

67 /* number of samples of silence to feed to the resampler

68 * at the beginning */

69 static const int silk_resample_delay[] = {

70 4, 8, 11, 11, 11

71 };

73 typedef struct OpusStreamContext {

74 AVCodecContext *avctx;

75 int output_channels;

77 /* number of decoded samples for this stream */

78 int decoded_samples;

79 /* current output buffers for this stream */

80 float *out[2];

81 int out_size;

82 /* Buffer with samples from this stream for synchronizing

83 * the streams when they have different resampling delays */

84 AVAudioFifo *sync_buffer;

86 OpusRangeCoder rc;

87 OpusRangeCoder redundancy_rc;

88 SilkContext *silk;

89 CeltFrame *celt;

90 AVFloatDSPContext *fdsp;

92 float silk_buf[2][960];

93 float *silk_output[2];

94 DECLARE_ALIGNED(32, float, celt_buf)[2][960];

95 float *celt_output[2];

97 DECLARE_ALIGNED(32, float, redundancy_buf)[2][960];

98 float *redundancy_output[2];

100 /* buffers for the next samples to be decoded */

101 float *cur_out[2];

102 int remaining_out_size;

103

104 float *out_dummy;

105 int out_dummy_allocated_size;

106

107 SwrContext *swr;

108 AVAudioFifo *celt_delay;

109 int silk_samplerate;

110 /* number of samples we still want to get from the resampler */

111 int delayed_samples;

112

113 OpusPacket packet;

114

115 int redundancy_idx;

116 } OpusStreamContext;

117

118 typedef struct OpusContext {

119 AVClass *av_class;

120

121 struct OpusStreamContext *streams;

122 int apply_phase_inv;

123

124 AVFloatDSPContext *fdsp;

125 float gain;

126

127 OpusParseContext p;

128 } OpusContext;

129

130 static int get_silk_samplerate(int config)

131 {

132 if (config < 4)

133 return 8000;

134 else if (config < 8)

135 return 12000;

136 return 16000;

137 }

138

139 static void opus_fade(float *out,

140 const float *in1, const float *in2,

141 const float *window, int len)

142 {

143 int i;

144 for (i = 0; i < len; i++)

145 out[i] = in2[i] * window[i] + in1[i] * (1.0 - window[i]);

146 }

147

148 static int opus_flush_resample(OpusStreamContext *s, int nb_samples)

149 {

150 int celt_size = av_audio_fifo_size(s->celt_delay);

151 int ret, i;

152 ret = swr_convert(s->swr,

153 (uint8_t**)s->cur_out, nb_samples,

154 NULL, 0);

155 if (ret < 0)

156 return ret;

157 else if (ret != nb_samples) {

158 av_log(s->avctx, AV_LOG_ERROR, "Wrong number of flushed samples: %d\n",

159 ret);

160 return AVERROR_BUG;

161 }

162

163 if (celt_size) {

164 if (celt_size != nb_samples) {

165 av_log(s->avctx, AV_LOG_ERROR, "Wrong number of CELT delay samples.\n");

166 return AVERROR_BUG;

167 }

168 av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, nb_samples);

169 for (i = 0; i < s->output_channels; i++) {

170 s->fdsp->vector_fmac_scalar(s->cur_out[i],

171 s->celt_output[i], 1.0,

172 nb_samples);

173 }

174 }

175

176 if (s->redundancy_idx) {

177 for (i = 0; i < s->output_channels; i++)

178 opus_fade(s->cur_out[i], s->cur_out[i],

179 s->redundancy_output[i] + 120 + s->redundancy_idx,

180 ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);

181 s->redundancy_idx = 0;

182 }

183

184 s->cur_out[0] += nb_samples;

185 s->cur_out[1] += nb_samples;

186 s->remaining_out_size -= nb_samples * sizeof(float);

187

188 return 0;

189 }

190

191 static int opus_init_resample(OpusStreamContext *s)

192 {

193 static const float delay[16] = { 0.0 };

194 const uint8_t *delayptr[2] = { (uint8_t*)delay, (uint8_t*)delay };

195 int ret;

196

197 av_opt_set_int(s->swr, "in_sample_rate", s->silk_samplerate, 0);

198 ret = swr_init(s->swr);

199 if (ret < 0) {

200 av_log(s->avctx, AV_LOG_ERROR, "Error opening the resampler.\n");

201 return ret;

202 }

203

204 ret = swr_convert(s->swr,

205 NULL, 0,

206 delayptr, silk_resample_delay[s->packet.bandwidth]);

207 if (ret < 0) {

208 av_log(s->avctx, AV_LOG_ERROR,

209 "Error feeding initial silence to the resampler.\n");

210 return ret;

211 }

212

213 return 0;

214 }

215

216 static int opus_decode_redundancy(OpusStreamContext *s, const uint8_t *data, int size)

217 {

218 int ret = ff_opus_rc_dec_init(&s->redundancy_rc, data, size);

219 if (ret < 0)

220 goto fail;

221 ff_opus_rc_dec_raw_init(&s->redundancy_rc, data + size, size);

222

223 ret = ff_celt_decode_frame(s->celt, &s->redundancy_rc,

224 s->redundancy_output,

225 s->packet.stereo + 1, 240,

226 0, ff_celt_band_end[s->packet.bandwidth]);

227 if (ret < 0)

228 goto fail;

229

230 return 0;

231 fail:

232 av_log(s->avctx, AV_LOG_ERROR, "Error decoding the redundancy frame.\n");

233 return ret;

234 }

235

236 static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size)

237 {

238 int samples = s->packet.frame_duration;

239 int redundancy = 0;

240 int redundancy_size, redundancy_pos;

241 int ret, i, consumed;

242 int delayed_samples = s->delayed_samples;

243

244 ret = ff_opus_rc_dec_init(&s->rc, data, size);

245 if (ret < 0)

246 return ret;

247

248 /* decode the silk frame */

249 if (s->packet.mode == OPUS_MODE_SILK || s->packet.mode == OPUS_MODE_HYBRID) {

250 if (!swr_is_initialized(s->swr)) {

251 ret = opus_init_resample(s);

252 if (ret < 0)

253 return ret;

254 }

255

256 samples = ff_silk_decode_superframe(s->silk, &s->rc, s->silk_output,

257 FFMIN(s->packet.bandwidth, OPUS_BANDWIDTH_WIDEBAND),

258 s->packet.stereo + 1,

259 silk_frame_duration_ms[s->packet.config]);

260 if (samples < 0) {

261 av_log(s->avctx, AV_LOG_ERROR, "Error decoding a SILK frame.\n");

262 return samples;

263 }

264 samples = swr_convert(s->swr,

265 (uint8_t**)s->cur_out, s->packet.frame_duration,

266 (const uint8_t**)s->silk_output, samples);

267 if (samples < 0) {

268 av_log(s->avctx, AV_LOG_ERROR, "Error resampling SILK data.\n");

269 return samples;

270 }

271 av_assert2((samples & 7) == 0);

272 s->delayed_samples += s->packet.frame_duration - samples;

273 } else

274 ff_silk_flush(s->silk);

275

276 // decode redundancy information

277 consumed = opus_rc_tell(&s->rc);

278 if (s->packet.mode == OPUS_MODE_HYBRID && consumed + 37 <= size * 8)

279 redundancy = ff_opus_rc_dec_log(&s->rc, 12);

280 else if (s->packet.mode == OPUS_MODE_SILK && consumed + 17 <= size * 8)

281 redundancy = 1;

282

283 if (redundancy) {

284 redundancy_pos = ff_opus_rc_dec_log(&s->rc, 1);

285

286 if (s->packet.mode == OPUS_MODE_HYBRID)

287 redundancy_size = ff_opus_rc_dec_uint(&s->rc, 256) + 2;

288 else

289 redundancy_size = size - (consumed + 7) / 8;

290 size -= redundancy_size;

291 if (size < 0) {

292 av_log(s->avctx, AV_LOG_ERROR, "Invalid redundancy frame size.\n");

293 return AVERROR_INVALIDDATA;

294 }

295

296 if (redundancy_pos) {

297 ret = opus_decode_redundancy(s, data + size, redundancy_size);

298 if (ret < 0)

299 return ret;

300 ff_celt_flush(s->celt);

301 }

302 }

303

304 /* decode the CELT frame */

305 if (s->packet.mode == OPUS_MODE_CELT || s->packet.mode == OPUS_MODE_HYBRID) {

306 float *out_tmp[2] = { s->cur_out[0], s->cur_out[1] };

307 float **dst = (s->packet.mode == OPUS_MODE_CELT) ?

308 out_tmp : s->celt_output;

309 int celt_output_samples = samples;

310 int delay_samples = av_audio_fifo_size(s->celt_delay);

311

312 if (delay_samples) {

313 if (s->packet.mode == OPUS_MODE_HYBRID) {

314 av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, delay_samples);

315

316 for (i = 0; i < s->output_channels; i++) {

317 s->fdsp->vector_fmac_scalar(out_tmp[i], s->celt_output[i], 1.0,

318 delay_samples);

319 out_tmp[i] += delay_samples;

320 }

321 celt_output_samples -= delay_samples;

322 } else {

323 av_log(s->avctx, AV_LOG_WARNING,

324 "Spurious CELT delay samples present.\n");

325 av_audio_fifo_drain(s->celt_delay, delay_samples);

326 if (s->avctx->err_recognition & AV_EF_EXPLODE)

327 return AVERROR_BUG;

328 }

329 }

330

331 ff_opus_rc_dec_raw_init(&s->rc, data + size, size);

332

333 ret = ff_celt_decode_frame(s->celt, &s->rc, dst,

334 s->packet.stereo + 1,

335 s->packet.frame_duration,

336 (s->packet.mode == OPUS_MODE_HYBRID) ? 17 : 0,

337 ff_celt_band_end[s->packet.bandwidth]);

338 if (ret < 0)

339 return ret;

340

341 if (s->packet.mode == OPUS_MODE_HYBRID) {

342 int celt_delay = s->packet.frame_duration - celt_output_samples;

343 void *delaybuf[2] = { s->celt_output[0] + celt_output_samples,

344 s->celt_output[1] + celt_output_samples };

345

346 for (i = 0; i < s->output_channels; i++) {

347 s->fdsp->vector_fmac_scalar(out_tmp[i],

348 s->celt_output[i], 1.0,

349 celt_output_samples);

350 }

351

352 ret = av_audio_fifo_write(s->celt_delay, delaybuf, celt_delay);

353 if (ret < 0)

354 return ret;

355 }

356 } else

357 ff_celt_flush(s->celt);

358

359 if (s->redundancy_idx) {

360 for (i = 0; i < s->output_channels; i++)

361 opus_fade(s->cur_out[i], s->cur_out[i],

362 s->redundancy_output[i] + 120 + s->redundancy_idx,

363 ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);

364 s->redundancy_idx = 0;

365 }

366 if (redundancy) {

367 if (!redundancy_pos) {

368 ff_celt_flush(s->celt);

369 ret = opus_decode_redundancy(s, data + size, redundancy_size);

370 if (ret < 0)

371 return ret;

372

373 for (i = 0; i < s->output_channels; i++) {

374 opus_fade(s->cur_out[i] + samples - 120 + delayed_samples,

375 s->cur_out[i] + samples - 120 + delayed_samples,

376 s->redundancy_output[i] + 120,

377 ff_celt_window2, 120 - delayed_samples);

378 if (delayed_samples)

379 s->redundancy_idx = 120 - delayed_samples;

380 }

381 } else {

382 for (i = 0; i < s->output_channels; i++) {

383 memcpy(s->cur_out[i] + delayed_samples, s->redundancy_output[i], 120 * sizeof(float));

384 opus_fade(s->cur_out[i] + 120 + delayed_samples,

385 s->redundancy_output[i] + 120,

386 s->cur_out[i] + 120 + delayed_samples,

387 ff_celt_window2, 120);

388 }

389 }

390 }

391

392 return samples;

393 }

394

395 static int opus_decode_subpacket(OpusStreamContext *s,

396 const uint8_t *buf, int buf_size,

397 int nb_samples)

398 {

399 int output_samples = 0;

400 int flush_needed = 0;

401 int i, j, ret;

402

403 s->cur_out[0] = s->out[0];

404 s->cur_out[1] = s->out[1];

405 s->remaining_out_size = s->out_size;

406

407 /* check if we need to flush the resampler */

408 if (swr_is_initialized(s->swr)) {

409 if (buf) {

410 int64_t cur_samplerate;

411 av_opt_get_int(s->swr, "in_sample_rate", 0, &cur_samplerate);

412 flush_needed = (s->packet.mode == OPUS_MODE_CELT) || (cur_samplerate != s->silk_samplerate);

413 } else {

414 flush_needed = !!s->delayed_samples;

415 }

416 }

417

418 if (!buf && !flush_needed)

419 return 0;

420

421 /* use dummy output buffers if the channel is not mapped to anything */

422 if (!s->cur_out[0] ||

423 (s->output_channels == 2 && !s->cur_out[1])) {

424 av_fast_malloc(&s->out_dummy, &s->out_dummy_allocated_size,

425 s->remaining_out_size);

426 if (!s->out_dummy)

427 return AVERROR(ENOMEM);

428 if (!s->cur_out[0])

429 s->cur_out[0] = s->out_dummy;

430 if (!s->cur_out[1])

431 s->cur_out[1] = s->out_dummy;

432 }

433

434 /* flush the resampler if necessary */

435 if (flush_needed) {

436 ret = opus_flush_resample(s, s->delayed_samples);

437 if (ret < 0) {

438 av_log(s->avctx, AV_LOG_ERROR, "Error flushing the resampler.\n");

439 return ret;

440 }

441 swr_close(s->swr);

442 output_samples += s->delayed_samples;

443 s->delayed_samples = 0;

444

445 if (!buf)

446 goto finish;

447 }

448

449 /* decode all the frames in the packet */

450 for (i = 0; i < s->packet.frame_count; i++) {

451 int size = s->packet.frame_size[i];

452 int samples = opus_decode_frame(s, buf + s->packet.frame_offset[i], size);

453

454 if (samples < 0) {

455 av_log(s->avctx, AV_LOG_ERROR, "Error decoding an Opus frame.\n");

456 if (s->avctx->err_recognition & AV_EF_EXPLODE)

457 return samples;

458

459 for (j = 0; j < s->output_channels; j++)

460 memset(s->cur_out[j], 0, s->packet.frame_duration * sizeof(float));

461 samples = s->packet.frame_duration;

462 }

463 output_samples += samples;

464

465 for (j = 0; j < s->output_channels; j++)

466 s->cur_out[j] += samples;

467 s->remaining_out_size -= samples * sizeof(float);

468 }

469

470 finish:

471 s->cur_out[0] = s->cur_out[1] = NULL;

472 s->remaining_out_size = 0;

473

474 return output_samples;

475 }

476

477 static int opus_decode_packet(AVCodecContext *avctx, AVFrame *frame,

478 int *got_frame_ptr, AVPacket *avpkt)

479 {

480 OpusContext *c = avctx->priv_data;

481 const uint8_t *buf = avpkt->data;

482 int buf_size = avpkt->size;

483 int coded_samples = 0;

484 int decoded_samples = INT_MAX;

485 int delayed_samples = 0;

486 int i, ret;

487

488 /* calculate the number of delayed samples */

489 for (int i = 0; i < c->p.nb_streams; i++) {

490 OpusStreamContext *s = &c->streams[i];

491 s->out[0] =

492 s->out[1] = NULL;

493 delayed_samples = FFMAX(delayed_samples,

494 s->delayed_samples + av_audio_fifo_size(s->sync_buffer));

495 }

496

497 /* decode the header of the first sub-packet to find out the sample count */

498 if (buf) {

499 OpusPacket *pkt = &c->streams[0].packet;

500 ret = ff_opus_parse_packet(pkt, buf, buf_size, c->p.nb_streams > 1);

501 if (ret < 0) {

502 av_log(avctx, AV_LOG_ERROR, "Error parsing the packet header.\n");

503 return ret;

504 }

505 coded_samples += pkt->frame_count * pkt->frame_duration;

506 c->streams[0].silk_samplerate = get_silk_samplerate(pkt->config);

507 }

508

509 frame->nb_samples = coded_samples + delayed_samples;

510

511 /* no input or buffered data => nothing to do */

512 if (!frame->nb_samples) {

513 *got_frame_ptr = 0;

514 return 0;

515 }

516

517 /* setup the data buffers */

518 ret = ff_get_buffer(avctx, frame, 0);

519 if (ret < 0)

520 return ret;

521 frame->nb_samples = 0;

522

523 for (i = 0; i < avctx->ch_layout.nb_channels; i++) {

524 ChannelMap *map = &c->p.channel_maps[i];

525 if (!map->copy)

526 c->streams[map->stream_idx].out[map->channel_idx] = (float*)frame->extended_data[i];

527 }

528

529 /* read the data from the sync buffers */

530 for (int i = 0; i < c->p.nb_streams; i++) {

531 OpusStreamContext *s = &c->streams[i];

532 float **out = s->out;

533 int sync_size = av_audio_fifo_size(s->sync_buffer);

534

535 float sync_dummy[32];

536 int out_dummy = (!out[0]) | ((!out[1]) << 1);

537

538 if (!out[0])

539 out[0] = sync_dummy;

540 if (!out[1])

541 out[1] = sync_dummy;

542 if (out_dummy && sync_size > FF_ARRAY_ELEMS(sync_dummy))

543 return AVERROR_BUG;

544

545 ret = av_audio_fifo_read(s->sync_buffer, (void**)out, sync_size);

546 if (ret < 0)

547 return ret;

548

549 if (out_dummy & 1)

550 out[0] = NULL;

551 else

552 out[0] += ret;

553 if (out_dummy & 2)

554 out[1] = NULL;

555 else

556 out[1] += ret;

557

558 s->out_size = frame->linesize[0] - ret * sizeof(float);

559 }

560

561 /* decode each sub-packet */

562 for (int i = 0; i < c->p.nb_streams; i++) {

563 OpusStreamContext *s = &c->streams[i];

564

565 if (i && buf) {

566 ret = ff_opus_parse_packet(&s->packet, buf, buf_size, i != c->p.nb_streams - 1);

567 if (ret < 0) {

568 av_log(avctx, AV_LOG_ERROR, "Error parsing the packet header.\n");

569 return ret;

570 }

571 if (coded_samples != s->packet.frame_count * s->packet.frame_duration) {

572 av_log(avctx, AV_LOG_ERROR,

573 "Mismatching coded sample count in substream %d.\n", i);

574 return AVERROR_INVALIDDATA;

575 }

576

577 s->silk_samplerate = get_silk_samplerate(s->packet.config);

578 }

579

580 ret = opus_decode_subpacket(&c->streams[i], buf, s->packet.data_size,

581 coded_samples);

582 if (ret < 0)

583 return ret;

584 s->decoded_samples = ret;

585 decoded_samples = FFMIN(decoded_samples, ret);

586

587 buf += s->packet.packet_size;

588 buf_size -= s->packet.packet_size;

589 }

590

591 /* buffer the extra samples */

592 for (int i = 0; i < c->p.nb_streams; i++) {

593 OpusStreamContext *s = &c->streams[i];

594 int buffer_samples = s->decoded_samples - decoded_samples;

595 if (buffer_samples) {

596 float *buf[2] = { s->out[0] ? s->out[0] : (float*)frame->extended_data[0],

597 s->out[1] ? s->out[1] : (float*)frame->extended_data[0] };

598 buf[0] += decoded_samples;

599 buf[1] += decoded_samples;

600 ret = av_audio_fifo_write(s->sync_buffer, (void**)buf, buffer_samples);

601 if (ret < 0)

602 return ret;

603 }

604 }

605

606 for (i = 0; i < avctx->ch_layout.nb_channels; i++) {

607 ChannelMap *map = &c->p.channel_maps[i];

608

609 /* handle copied channels */

610 if (map->copy) {

611 memcpy(frame->extended_data[i],

612 frame->extended_data[map->copy_idx],

613 frame->linesize[0]);

614 } else if (map->silence) {

615 memset(frame->extended_data[i], 0, frame->linesize[0]);

616 }

617

618 if (c->p.gain_i && decoded_samples > 0) {

619 c->fdsp->vector_fmul_scalar((float*)frame->extended_data[i],

620 (float*)frame->extended_data[i],

621 c->gain, FFALIGN(decoded_samples, 8));

622 }

623 }

624

625 frame->nb_samples = decoded_samples;

626 *got_frame_ptr = !!decoded_samples;

627

628 return avpkt->size;

629 }

630

631 static av_cold void opus_decode_flush(AVCodecContext *ctx)

632 {

633 OpusContext *c = ctx->priv_data;

634

635 for (int i = 0; i < c->p.nb_streams; i++) {

636 OpusStreamContext *s = &c->streams[i];

637

638 memset(&s->packet, 0, sizeof(s->packet));

639 s->delayed_samples = 0;

640

641 av_audio_fifo_drain(s->celt_delay, av_audio_fifo_size(s->celt_delay));

642 swr_close(s->swr);

643

644 av_audio_fifo_drain(s->sync_buffer, av_audio_fifo_size(s->sync_buffer));

645

646 ff_silk_flush(s->silk);

647 ff_celt_flush(s->celt);

648 }

649 }

650

651 static av_cold int opus_decode_close(AVCodecContext *avctx)

652 {

653 OpusContext *c = avctx->priv_data;

654

655 for (int i = 0; i < c->p.nb_streams; i++) {

656 OpusStreamContext *s = &c->streams[i];

657

658 ff_silk_free(&s->silk);

659 ff_celt_free(&s->celt);

660

661 av_freep(&s->out_dummy);

662 s->out_dummy_allocated_size = 0;

663

664 av_audio_fifo_free(s->sync_buffer);

665 av_audio_fifo_free(s->celt_delay);

666 swr_free(&s->swr);

667 }

668

669 av_freep(&c->streams);

670

671 c->p.nb_streams = 0;

672

673 av_freep(&c->p.channel_maps);

674 av_freep(&c->fdsp);

675

676 return 0;

677 }

678

679 static av_cold int opus_decode_init(AVCodecContext *avctx)

680 {

681 OpusContext *c = avctx->priv_data;

682 int ret;

683

684 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

685 avctx->sample_rate = 48000;

686

687 c->fdsp = avpriv_float_dsp_alloc(0);

688 if (!c->fdsp)

689 return AVERROR(ENOMEM);

690

691 /* find out the channel configuration */

692 ret = ff_opus_parse_extradata(avctx, &c->p);

693 if (ret < 0)

694 return ret;

695 if (c->p.gain_i)

696 c->gain = ff_exp10(c->p.gain_i / (20.0 * 256));

697

698 /* allocate and init each independent decoder */

699 c->streams = av_calloc(c->p.nb_streams, sizeof(*c->streams));

700 if (!c->streams) {

701 c->p.nb_streams = 0;

702 return AVERROR(ENOMEM);

703 }

704

705 for (int i = 0; i < c->p.nb_streams; i++) {

706 OpusStreamContext *s = &c->streams[i];

707 AVChannelLayout layout;

708

709 s->output_channels = (i < c->p.nb_stereo_streams) ? 2 : 1;

710

711 s->avctx = avctx;

712

713 for (int j = 0; j < s->output_channels; j++) {

714 s->silk_output[j] = s->silk_buf[j];

715 s->celt_output[j] = s->celt_buf[j];

716 s->redundancy_output[j] = s->redundancy_buf[j];

717 }

718

719 s->fdsp = c->fdsp;

720

721 s->swr =swr_alloc();

722 if (!s->swr)

723 return AVERROR(ENOMEM);

724

725 layout = (s->output_channels == 1) ? (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO :

726 (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;

727 av_opt_set_int(s->swr, "in_sample_fmt", avctx->sample_fmt, 0);

728 av_opt_set_int(s->swr, "out_sample_fmt", avctx->sample_fmt, 0);

729 av_opt_set_chlayout(s->swr, "in_chlayout", &layout, 0);

730 av_opt_set_chlayout(s->swr, "out_chlayout", &layout, 0);

731 av_opt_set_int(s->swr, "out_sample_rate", avctx->sample_rate, 0);

732 av_opt_set_int(s->swr, "filter_size", 16, 0);

733

734 ret = ff_silk_init(avctx, &s->silk, s->output_channels);

735 if (ret < 0)

736 return ret;

737

738 ret = ff_celt_init(avctx, &s->celt, s->output_channels, c->apply_phase_inv);

739 if (ret < 0)

740 return ret;

741

742 s->celt_delay = av_audio_fifo_alloc(avctx->sample_fmt,

743 s->output_channels, 1024);

744 if (!s->celt_delay)

745 return AVERROR(ENOMEM);

746

747 s->sync_buffer = av_audio_fifo_alloc(avctx->sample_fmt,

748 s->output_channels, 32);

749 if (!s->sync_buffer)

750 return AVERROR(ENOMEM);

751 }

752

753 return 0;

754 }

755

756 #define OFFSET(x) offsetof(OpusContext, x)

757 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM

758 static const AVOption opus_options[] = {

759 { "apply_phase_inv", "Apply intensity stereo phase inversion", OFFSET(apply_phase_inv), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, AD },

760 { NULL },

761 };

762

763 static const AVClass opus_class = {

764 .class_name = "Opus Decoder",

765 .item_name = av_default_item_name,

766 .option = opus_options,

767 .version = LIBAVUTIL_VERSION_INT,

768 };

769

770 const FFCodec ff_opus_decoder = {

771 .p.name = "opus",

772 CODEC_LONG_NAME("Opus"),

773 .p.priv_class = &opus_class,

774 .p.type = AVMEDIA_TYPE_AUDIO,

775 .p.id = AV_CODEC_ID_OPUS,

776 .priv_data_size = sizeof(OpusContext),

777 .init = opus_decode_init,

778 .close = opus_decode_close,

779 FF_CODEC_DECODE_CB(opus_decode_packet),

780 .flush = opus_decode_flush,

781 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_CHANNEL_CONF,

782 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

783 };

OpusStreamContext::decoded_samples

int decoded_samples

Definition: opusdec.c:78

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_exp10

static av_always_inline double ff_exp10(double x)

Compute 10^x for floating point values.

Definition: ffmath.h:42

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: defs.h:51

OpusStreamContext::avctx

AVCodecContext * avctx

Definition: opusdec.c:74

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:42

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

mem_internal.h

out

FILE * out

Definition: movenc.c:54

OpusStreamContext::delayed_samples

int delayed_samples

Definition: opusdec.c:111

AV_CHANNEL_LAYOUT_STEREO

#define AV_CHANNEL_LAYOUT_STEREO

Definition: channel_layout.h:369

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1034

ff_opus_decoder

const FFCodec ff_opus_decoder

Definition: opusdec.c:770

opus_decode_packet

static int opus_decode_packet(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)

Definition: opusdec.c:477

opus_decode_frame

static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size)

Definition: opusdec.c:236

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:330

AVPacket::data

uint8_t * data

Definition: packet.h:374

AVOption

AVOption.

Definition: opt.h:251

data

const char data[16]

Definition: mxf.c:146

opus_decode_close

static av_cold int opus_decode_close(AVCodecContext *avctx)

Definition: opusdec.c:651

opus.h

FFCodec

Definition: codec_internal.h:127

OFFSET

#define OFFSET(x)

Definition: opusdec.c:756

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

OpusStreamContext::rc

OpusRangeCoder rc

Definition: opusdec.c:86

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:311

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:60

ff_celt_flush

void ff_celt_flush(CeltFrame *f)

Definition: opusdec_celt.c:494

OpusStreamContext::celt_delay

AVAudioFifo * celt_delay

Definition: opusdec.c:108

silk_frame_duration_ms

static const uint16_t silk_frame_duration_ms[16]

Definition: opusdec.c:59

opus_parse.h

ff_celt_decode_frame

int ff_celt_decode_frame(CeltFrame *f, OpusRangeCoder *rc, float **output, int coded_channels, int frame_size, int startband, int endband)

Definition: opusdec_celt.c:322

OpusContext::p

OpusParseContext p

Definition: opusdec.c:127

opus_options

static const AVOption opus_options[]

Definition: opusdec.c:758

OpusStreamContext::swr

SwrContext * swr

Definition: opusdec.c:107

window

static SDL_Window * window

Definition: ffplay.c:365

ff_silk_flush

void ff_silk_flush(SilkContext *s)

Definition: opus_silk.c:874

AVAudioFifo

Context for an Audio FIFO Buffer.

Definition: audio_fifo.c:37

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

finish

static void finish(void)

Definition: movenc.c:342

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:2054

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:134

OpusStreamContext::out_size

int out_size

Definition: opusdec.c:81

OpusContext::gain

float gain

Definition: opusdec.c:125

swr_is_initialized

int swr_is_initialized(struct SwrContext *s)

Check whether an swr context has been initialized or not.

Definition: swresample.c:826

OpusStreamContext::celt

CeltFrame * celt

Definition: opusdec.c:89

OpusStreamContext::redundancy_buf

float redundancy_buf[2][960]

Definition: opusdec.c:97

opus_fade

static void opus_fade(float *out, const float *in1, const float *in2, const float *window, int len)

Definition: opusdec.c:139

OpusStreamContext::celt_output

float * celt_output[2]

Definition: opusdec.c:95

opus_decode_redundancy

static int opus_decode_redundancy(OpusStreamContext *s, const uint8_t *data, int size)

Definition: opusdec.c:216

OpusStreamContext::out

float * out[2]

Definition: opusdec.c:80

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

OpusStreamContext::silk_output

float * silk_output[2]

Definition: opusdec.c:93

swr_init

av_cold int swr_init(struct SwrContext *s)

Initialize context after user parameters have been set.

Definition: swresample.c:193

float

Definition: af_crystalizer.c:122

OpusStreamContext

Definition: opusdec.c:73

ff_celt_band_end

const uint8_t ff_celt_band_end[]

Definition: opustab.c:29

OpusContext::apply_phase_inv

int apply_phase_inv

Definition: opusdec.c:122

OpusStreamContext::remaining_out_size

int remaining_out_size

Definition: opusdec.c:102

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:306

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

#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

OpusStreamContext::fdsp

AVFloatDSPContext * fdsp

Definition: opusdec.c:90

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

swr_alloc

av_cold struct SwrContext * swr_alloc(void)

Allocate SwrContext.

Definition: options.c:169

OpusStreamContext::redundancy_idx

int redundancy_idx

Definition: opusdec.c:115

OpusContext::av_class

AVClass * av_class

Definition: opusdec.c:119

opus_flush_resample

static int opus_flush_resample(OpusStreamContext *s, int nb_samples)

Definition: opusdec.c:148

ctx

AVFormatContext * ctx

Definition: movenc.c:48

decode.h

OpusStreamContext::sync_buffer

AVAudioFifo * sync_buffer

Definition: opusdec.c:84

SwrContext

The libswresample context.

Definition: swresample_internal.h:95

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

SilkContext

Definition: opus_silk.c:50

OPUS_BANDWIDTH_WIDEBAND

@ OPUS_BANDWIDTH_WIDEBAND

Definition: opus.h:52

OPUS_MODE_CELT

@ OPUS_MODE_CELT

Definition: opus.h:44

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

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

OpusStreamContext::silk_samplerate

int silk_samplerate

Definition: opusdec.c:109

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

OpusStreamContext::packet

OpusPacket packet

Definition: opusdec.c:113

OpusParseContext

Definition: opus_parse.h:63

OpusStreamContext::out_dummy_allocated_size

int out_dummy_allocated_size

Definition: opusdec.c:105

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

OpusStreamContext::redundancy_rc

OpusRangeCoder redundancy_rc

Definition: opusdec.c:87

OpusContext::fdsp

AVFloatDSPContext * fdsp

Definition: opusdec.c:124

swresample.h

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:763

float_dsp.h

opus_decode_init

static av_cold int opus_decode_init(AVCodecContext *avctx)

Definition: opusdec.c:679

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:103

opustab.h

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1473

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

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:301

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:87

av_opt_set_chlayout

int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *channel_layout, int search_flags)

Definition: opt.c:786

get_silk_samplerate

static int get_silk_samplerate(int config)

Definition: opusdec.c:130

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1050

size

int size

Definition: twinvq_data.h:10344

OpusRangeCoder

Definition: opus_rc.h:39

OpusStreamContext::silk

SilkContext * silk

Definition: opusdec.c:88

swr_free

av_cold void swr_free(SwrContext **ss)

Free the given SwrContext and set the pointer to NULL.

Definition: swresample.c:174

AV_CODEC_ID_OPUS

@ AV_CODEC_ID_OPUS

Definition: codec_id.h:498

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:830

AVFloatDSPContext

Definition: float_dsp.h:24

ff_celt_window2

const float ff_celt_window2[120]

Definition: opustab.c:1136

ff_opus_rc_dec_init

int ff_opus_rc_dec_init(OpusRangeCoder *rc, const uint8_t *data, int size)

Definition: opus_rc.c:338

frame.h

OpusContext::streams

struct OpusStreamContext * streams

Definition: opusdec.c:121

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

Definition: filter_design.txt:18

ff_silk_init

int ff_silk_init(AVCodecContext *avctx, SilkContext **ps, int output_channels)

Definition: opus_silk.c:882

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

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

ff_silk_free

void ff_silk_free(SilkContext **ps)

Definition: opus_silk.c:869

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:43

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

opus_decode_flush

static av_cold void opus_decode_flush(AVCodecContext *ctx)

Definition: opusdec.c:631

audio_fifo.h

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:191

len

int len

Definition: vorbis_enc_data.h:426

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:262

avcodec.h

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

opus_decode_subpacket

static int opus_decode_subpacket(OpusStreamContext *s, const uint8_t *buf, int buf_size, int nb_samples)

Definition: opusdec.c:395

AVCodecContext

main external API structure.

Definition: avcodec.h:426

#define AD

Definition: opusdec.c:757

channel_layout.h

OpusStreamContext::silk_buf

float silk_buf[2][960]

Definition: opusdec.c:92

OPUS_MODE_SILK

@ OPUS_MODE_SILK

Definition: opus.h:42

OpusPacket

Definition: opus_parse.h:31

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:76

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:191

ffmath.h

ChannelMap

Definition: opus_parse.h:48

silk_resample_delay

static const int silk_resample_delay[]

Definition: opusdec.c:69

OpusStreamContext::out_dummy

float * out_dummy

Definition: opusdec.c:104

map

const VDPAUPixFmtMap * map

Definition: hwcontext_vdpau.c:71

AV_CHANNEL_LAYOUT_MONO

#define AV_CHANNEL_LAYOUT_MONO

Definition: channel_layout.h:368

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:453

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:555

avpriv_float_dsp_alloc

av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)

Allocate a float DSP context.

Definition: float_dsp.c:135

ff_opus_parse_extradata

av_cold int ff_opus_parse_extradata(AVCodecContext *avctx, OpusParseContext *s)

Definition: opus_parse.c:296

ff_celt_free

void ff_celt_free(CeltFrame **f)

Definition: opusdec_celt.c:525

swr_close

av_cold void swr_close(SwrContext *s)

Closes the context so that swr_is_initialized() returns 0.

Definition: swresample.c:189

OpusStreamContext::celt_buf

float celt_buf[2][960]

Definition: opusdec.c:94

AVERROR_BUG

#define AVERROR_BUG

Internal bug, also see AVERROR_BUG2.

Definition: error.h:52

OpusStreamContext::cur_out

float * cur_out[2]

Definition: opusdec.c:101

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_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:791

opus_rc.h

OpusStreamContext::output_channels

int output_channels

Definition: opusdec.c:75

OpusStreamContext::redundancy_output

float * redundancy_output[2]

Definition: opusdec.c:98

AVFormatContext::priv_data

void * priv_data

Format private data.