GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/opusdec.c Lines: 283 392 72.2 %
Date: 2021-01-21 21:11:50 Branches: 155 234 66.2 %

Line Branch Exec Source
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 "get_bits.h"
47
#include "internal.h"
48
#include "mathops.h"
49
#include "opus.h"
50
#include "opustab.h"
51
#include "opus_celt.h"
52
53
static const uint16_t silk_frame_duration_ms[16] = {
54
    10, 20, 40, 60,
55
    10, 20, 40, 60,
56
    10, 20, 40, 60,
57
    10, 20,
58
    10, 20,
59
};
60
61
/* number of samples of silence to feed to the resampler
62
 * at the beginning */
63
static const int silk_resample_delay[] = {
64
    4, 8, 11, 11, 11
65
};
66
67
26219
static int get_silk_samplerate(int config)
68
{
69
26219
    if (config < 4)
70
1551
        return 8000;
71
24668
    else if (config < 8)
72
1222
        return 12000;
73
23446
    return 16000;
74
}
75
76
68
static void opus_fade(float *out,
77
                      const float *in1, const float *in2,
78
                      const float *window, int len)
79
{
80
    int i;
81
7268
    for (i = 0; i < len; i++)
82
7200
        out[i] = in2[i] * window[i] + in1[i] * (1.0 - window[i]);
83
68
}
84
85
17
static int opus_flush_resample(OpusStreamContext *s, int nb_samples)
86
{
87
17
    int celt_size = av_audio_fifo_size(s->celt_delay);
88
    int ret, i;
89
17
    ret = swr_convert(s->swr,
90
17
                      (uint8_t**)s->cur_out, nb_samples,
91
                      NULL, 0);
92
17
    if (ret < 0)
93
        return ret;
94
17
    else if (ret != nb_samples) {
95
        av_log(s->avctx, AV_LOG_ERROR, "Wrong number of flushed samples: %d\n",
96
               ret);
97
        return AVERROR_BUG;
98
    }
99
100
17
    if (celt_size) {
101
        if (celt_size != nb_samples) {
102
            av_log(s->avctx, AV_LOG_ERROR, "Wrong number of CELT delay samples.\n");
103
            return AVERROR_BUG;
104
        }
105
        av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, nb_samples);
106
        for (i = 0; i < s->output_channels; i++) {
107
            s->fdsp->vector_fmac_scalar(s->cur_out[i],
108
                                        s->celt_output[i], 1.0,
109
                                        nb_samples);
110
        }
111
    }
112
113
17
    if (s->redundancy_idx) {
114
12
        for (i = 0; i < s->output_channels; i++)
115
8
            opus_fade(s->cur_out[i], s->cur_out[i],
116
8
                      s->redundancy_output[i] + 120 + s->redundancy_idx,
117
8
                      ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);
118
4
        s->redundancy_idx = 0;
119
    }
120
121
17
    s->cur_out[0]         += nb_samples;
122
17
    s->cur_out[1]         += nb_samples;
123
17
    s->remaining_out_size -= nb_samples * sizeof(float);
124
125
17
    return 0;
126
}
127
128
32
static int opus_init_resample(OpusStreamContext *s)
129
{
130
    static const float delay[16] = { 0.0 };
131
32
    const uint8_t *delayptr[2] = { (uint8_t*)delay, (uint8_t*)delay };
132
    int ret;
133
134
32
    av_opt_set_int(s->swr, "in_sample_rate", s->silk_samplerate, 0);
135
32
    ret = swr_init(s->swr);
136
32
    if (ret < 0) {
137
        av_log(s->avctx, AV_LOG_ERROR, "Error opening the resampler.\n");
138
        return ret;
139
    }
140
141
32
    ret = swr_convert(s->swr,
142
                      NULL, 0,
143
32
                      delayptr, silk_resample_delay[s->packet.bandwidth]);
144
32
    if (ret < 0) {
145
        av_log(s->avctx, AV_LOG_ERROR,
146
               "Error feeding initial silence to the resampler.\n");
147
        return ret;
148
    }
149
150
32
    return 0;
151
}
152
153
30
static int opus_decode_redundancy(OpusStreamContext *s, const uint8_t *data, int size)
154
{
155
30
    int ret = ff_opus_rc_dec_init(&s->redundancy_rc, data, size);
156
30
    if (ret < 0)
157
        goto fail;
158
30
    ff_opus_rc_dec_raw_init(&s->redundancy_rc, data + size, size);
159
160
30
    ret = ff_celt_decode_frame(s->celt, &s->redundancy_rc,
161
30
                               s->redundancy_output,
162
30
                               s->packet.stereo + 1, 240,
163
30
                               0, ff_celt_band_end[s->packet.bandwidth]);
164
30
    if (ret < 0)
165
        goto fail;
166
167
30
    return 0;
168
fail:
169
    av_log(s->avctx, AV_LOG_ERROR, "Error decoding the redundancy frame.\n");
170
    return ret;
171
}
172
173
34393
static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size)
174
{
175
34393
    int samples    = s->packet.frame_duration;
176
34393
    int redundancy = 0;
177
    int redundancy_size, redundancy_pos;
178
    int ret, i, consumed;
179
34393
    int delayed_samples = s->delayed_samples;
180
181
34393
    ret = ff_opus_rc_dec_init(&s->rc, data, size);
182
34393
    if (ret < 0)
183
        return ret;
184
185
    /* decode the silk frame */
186

34393
    if (s->packet.mode == OPUS_MODE_SILK || s->packet.mode == OPUS_MODE_HYBRID) {
187
9471
        if (!swr_is_initialized(s->swr)) {
188
32
            ret = opus_init_resample(s);
189
32
            if (ret < 0)
190
                return ret;
191
        }
192
193
9471
        samples = ff_silk_decode_superframe(s->silk, &s->rc, s->silk_output,
194
9471
                                            FFMIN(s->packet.bandwidth, OPUS_BANDWIDTH_WIDEBAND),
195
9471
                                            s->packet.stereo + 1,
196
9471
                                            silk_frame_duration_ms[s->packet.config]);
197
9471
        if (samples < 0) {
198
            av_log(s->avctx, AV_LOG_ERROR, "Error decoding a SILK frame.\n");
199
            return samples;
200
        }
201
9471
        samples = swr_convert(s->swr,
202
9471
                              (uint8_t**)s->cur_out, s->packet.frame_duration,
203
9471
                              (const uint8_t**)s->silk_output, samples);
204
9471
        if (samples < 0) {
205
            av_log(s->avctx, AV_LOG_ERROR, "Error resampling SILK data.\n");
206
            return samples;
207
        }
208
        av_assert2((samples & 7) == 0);
209
9471
        s->delayed_samples += s->packet.frame_duration - samples;
210
    } else
211
24922
        ff_silk_flush(s->silk);
212
213
    // decode redundancy information
214
34393
    consumed = opus_rc_tell(&s->rc);
215

34393
    if (s->packet.mode == OPUS_MODE_HYBRID && consumed + 37 <= size * 8)
216
4904
        redundancy = ff_opus_rc_dec_log(&s->rc, 12);
217

29489
    else if (s->packet.mode == OPUS_MODE_SILK && consumed + 17 <= size * 8)
218
14
        redundancy = 1;
219
220
34393
    if (redundancy) {
221
30
        redundancy_pos = ff_opus_rc_dec_log(&s->rc, 1);
222
223
30
        if (s->packet.mode == OPUS_MODE_HYBRID)
224
16
            redundancy_size = ff_opus_rc_dec_uint(&s->rc, 256) + 2;
225
        else
226
14
            redundancy_size = size - (consumed + 7) / 8;
227
30
        size -= redundancy_size;
228
30
        if (size < 0) {
229
            av_log(s->avctx, AV_LOG_ERROR, "Invalid redundancy frame size.\n");
230
            return AVERROR_INVALIDDATA;
231
        }
232
233
30
        if (redundancy_pos) {
234
14
            ret = opus_decode_redundancy(s, data + size, redundancy_size);
235
14
            if (ret < 0)
236
                return ret;
237
14
            ff_celt_flush(s->celt);
238
        }
239
    }
240
241
    /* decode the CELT frame */
242

64253
    if (s->packet.mode == OPUS_MODE_CELT || s->packet.mode == OPUS_MODE_HYBRID) {
243
29860
        float *out_tmp[2] = { s->cur_out[0], s->cur_out[1] };
244
59720
        float **dst = (s->packet.mode == OPUS_MODE_CELT) ?
245
29860
                      out_tmp : s->celt_output;
246
29860
        int celt_output_samples = samples;
247
29860
        int delay_samples = av_audio_fifo_size(s->celt_delay);
248
249
29860
        if (delay_samples) {
250
            if (s->packet.mode == OPUS_MODE_HYBRID) {
251
                av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, delay_samples);
252
253
                for (i = 0; i < s->output_channels; i++) {
254
                    s->fdsp->vector_fmac_scalar(out_tmp[i], s->celt_output[i], 1.0,
255
                                                delay_samples);
256
                    out_tmp[i] += delay_samples;
257
                }
258
                celt_output_samples -= delay_samples;
259
            } else {
260
                av_log(s->avctx, AV_LOG_WARNING,
261
                       "Spurious CELT delay samples present.\n");
262
                av_audio_fifo_drain(s->celt_delay, delay_samples);
263
                if (s->avctx->err_recognition & AV_EF_EXPLODE)
264
                    return AVERROR_BUG;
265
            }
266
        }
267
268
29860
        ff_opus_rc_dec_raw_init(&s->rc, data + size, size);
269
270
29860
        ret = ff_celt_decode_frame(s->celt, &s->rc, dst,
271
29860
                                   s->packet.stereo + 1,
272
                                   s->packet.frame_duration,
273
29860
                                   (s->packet.mode == OPUS_MODE_HYBRID) ? 17 : 0,
274
29860
                                   ff_celt_band_end[s->packet.bandwidth]);
275
29860
        if (ret < 0)
276
            return ret;
277
278
29860
        if (s->packet.mode == OPUS_MODE_HYBRID) {
279
4938
            int celt_delay = s->packet.frame_duration - celt_output_samples;
280
4938
            void *delaybuf[2] = { s->celt_output[0] + celt_output_samples,
281
4938
                                  s->celt_output[1] + celt_output_samples };
282
283
14814
            for (i = 0; i < s->output_channels; i++) {
284
9876
                s->fdsp->vector_fmac_scalar(out_tmp[i],
285
9876
                                            s->celt_output[i], 1.0,
286
                                            celt_output_samples);
287
            }
288
289
4938
            ret = av_audio_fifo_write(s->celt_delay, delaybuf, celt_delay);
290
4938
            if (ret < 0)
291
                return ret;
292
        }
293
    } else
294
4533
        ff_celt_flush(s->celt);
295
296
34393
    if (s->redundancy_idx) {
297
        for (i = 0; i < s->output_channels; i++)
298
            opus_fade(s->cur_out[i], s->cur_out[i],
299
                      s->redundancy_output[i] + 120 + s->redundancy_idx,
300
                      ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);
301
        s->redundancy_idx = 0;
302
    }
303
34393
    if (redundancy) {
304
30
        if (!redundancy_pos) {
305
16
            ff_celt_flush(s->celt);
306
16
            ret = opus_decode_redundancy(s, data + size, redundancy_size);
307
16
            if (ret < 0)
308
                return ret;
309
310
48
            for (i = 0; i < s->output_channels; i++) {
311
32
                opus_fade(s->cur_out[i] + samples - 120 + delayed_samples,
312
32
                          s->cur_out[i] + samples - 120 + delayed_samples,
313
32
                          s->redundancy_output[i] + 120,
314
                          ff_celt_window2, 120 - delayed_samples);
315
32
                if (delayed_samples)
316
8
                    s->redundancy_idx = 120 - delayed_samples;
317
            }
318
        } else {
319
42
            for (i = 0; i < s->output_channels; i++) {
320
28
                memcpy(s->cur_out[i] + delayed_samples, s->redundancy_output[i], 120 * sizeof(float));
321
28
                opus_fade(s->cur_out[i] + 120 + delayed_samples,
322
28
                          s->redundancy_output[i] + 120,
323
28
                          s->cur_out[i] + 120 + delayed_samples,
324
                          ff_celt_window2, 120);
325
            }
326
        }
327
    }
328
329
34393
    return samples;
330
}
331
332
26220
static int opus_decode_subpacket(OpusStreamContext *s,
333
                                 const uint8_t *buf, int buf_size,
334
                                 int nb_samples)
335
{
336
26220
    int output_samples = 0;
337
26220
    int flush_needed   = 0;
338
    int i, j, ret;
339
340
26220
    s->cur_out[0]         = s->out[0];
341
26220
    s->cur_out[1]         = s->out[1];
342
26220
    s->remaining_out_size = s->out_size;
343
344
    /* check if we need to flush the resampler */
345
26220
    if (swr_is_initialized(s->swr)) {
346
9012
        if (buf) {
347
            int64_t cur_samplerate;
348
9011
            av_opt_get_int(s->swr, "in_sample_rate", 0, &cur_samplerate);
349

9011
            flush_needed = (s->packet.mode == OPUS_MODE_CELT) || (cur_samplerate != s->silk_samplerate);
350
        } else {
351
1
            flush_needed = !!s->delayed_samples;
352
        }
353
    }
354
355

26220
    if (!buf && !flush_needed)
356
        return 0;
357
358
    /* use dummy output buffers if the channel is not mapped to anything */
359
26220
    if (!s->cur_out[0] ||
360

26220
        (s->output_channels == 2 && !s->cur_out[1])) {
361
        av_fast_malloc(&s->out_dummy, &s->out_dummy_allocated_size,
362
                       s->remaining_out_size);
363
        if (!s->out_dummy)
364
            return AVERROR(ENOMEM);
365
        if (!s->cur_out[0])
366
            s->cur_out[0] = s->out_dummy;
367
        if (!s->cur_out[1])
368
            s->cur_out[1] = s->out_dummy;
369
    }
370
371
    /* flush the resampler if necessary */
372
26220
    if (flush_needed) {
373
17
        ret = opus_flush_resample(s, s->delayed_samples);
374
17
        if (ret < 0) {
375
            av_log(s->avctx, AV_LOG_ERROR, "Error flushing the resampler.\n");
376
            return ret;
377
        }
378
17
        swr_close(s->swr);
379
17
        output_samples += s->delayed_samples;
380
17
        s->delayed_samples = 0;
381
382
17
        if (!buf)
383
1
            goto finish;
384
    }
385
386
    /* decode all the frames in the packet */
387
60612
    for (i = 0; i < s->packet.frame_count; i++) {
388
34393
        int size = s->packet.frame_size[i];
389
34393
        int samples = opus_decode_frame(s, buf + s->packet.frame_offset[i], size);
390
391
34393
        if (samples < 0) {
392
            av_log(s->avctx, AV_LOG_ERROR, "Error decoding an Opus frame.\n");
393
            if (s->avctx->err_recognition & AV_EF_EXPLODE)
394
                return samples;
395
396
            for (j = 0; j < s->output_channels; j++)
397
                memset(s->cur_out[j], 0, s->packet.frame_duration * sizeof(float));
398
            samples = s->packet.frame_duration;
399
        }
400
34393
        output_samples += samples;
401
402
100113
        for (j = 0; j < s->output_channels; j++)
403
65720
            s->cur_out[j] += samples;
404
34393
        s->remaining_out_size -= samples * sizeof(float);
405
    }
406
407
26219
finish:
408
26220
    s->cur_out[0] = s->cur_out[1] = NULL;
409
26220
    s->remaining_out_size = 0;
410
411
26220
    return output_samples;
412
}
413
414
21636
static int opus_decode_packet(AVCodecContext *avctx, void *data,
415
                              int *got_frame_ptr, AVPacket *avpkt)
416
{
417
21636
    OpusContext *c      = avctx->priv_data;
418
21636
    AVFrame *frame      = data;
419
21636
    const uint8_t *buf  = avpkt->data;
420
21636
    int buf_size        = avpkt->size;
421
21636
    int coded_samples   = 0;
422
21636
    int decoded_samples = INT_MAX;
423
21636
    int delayed_samples = 0;
424
    int i, ret;
425
426
    /* calculate the number of delayed samples */
427
47872
    for (i = 0; i < c->nb_streams; i++) {
428
26236
        OpusStreamContext *s = &c->streams[i];
429
26236
        s->out[0] =
430
26236
        s->out[1] = NULL;
431
26236
        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
21636
    if (buf) {
437
21622
        OpusPacket *pkt = &c->streams[0].packet;
438
21622
        ret = ff_opus_parse_packet(pkt, buf, buf_size, c->nb_streams > 1);
439
21622
        if (ret < 0) {
440
            av_log(avctx, AV_LOG_ERROR, "Error parsing the packet header.\n");
441
            return ret;
442
        }
443
21622
        coded_samples += pkt->frame_count * pkt->frame_duration;
444
21622
        c->streams[0].silk_samplerate = get_silk_samplerate(pkt->config);
445
    }
446
447
21636
    frame->nb_samples = coded_samples + delayed_samples;
448
449
    /* no input or buffered data => nothing to do */
450
21636
    if (!frame->nb_samples) {
451
13
        *got_frame_ptr = 0;
452
13
        return 0;
453
    }
454
455
    /* setup the data buffers */
456
21623
    ret = ff_get_buffer(avctx, frame, 0);
457
21623
    if (ret < 0)
458
        return ret;
459
21623
    frame->nb_samples = 0;
460
461
70997
    for (i = 0; i < avctx->channels; i++) {
462
49374
        ChannelMap *map = &c->channel_maps[i];
463
49374
        if (!map->copy)
464
49374
            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
47843
    for (i = 0; i < c->nb_streams; i++) {
469
26220
        OpusStreamContext *s = &c->streams[i];
470
26220
        float          **out = s->out;
471
26220
        int sync_size = av_audio_fifo_size(s->sync_buffer);
472
473
        float sync_dummy[32];
474
26220
        int out_dummy = (!out[0]) | ((!out[1]) << 1);
475
476
26220
        if (!out[0])
477
            out[0] = sync_dummy;
478
26220
        if (!out[1])
479
3066
            out[1] = sync_dummy;
480

26220
        if (out_dummy && sync_size > FF_ARRAY_ELEMS(sync_dummy))
481
            return AVERROR_BUG;
482
483
26220
        ret = av_audio_fifo_read(s->sync_buffer, (void**)out, sync_size);
484
26220
        if (ret < 0)
485
            return ret;
486
487
26220
        if (out_dummy & 1)
488
            out[0] = NULL;
489
        else
490
26220
            out[0] += ret;
491
26220
        if (out_dummy & 2)
492
3066
            out[1] = NULL;
493
        else
494
23154
            out[1] += ret;
495
496
26220
        s->out_size = frame->linesize[0] - ret * sizeof(float);
497
    }
498
499
    /* decode each sub-packet */
500
47843
    for (i = 0; i < c->nb_streams; i++) {
501
26220
        OpusStreamContext *s = &c->streams[i];
502
503

26220
        if (i && buf) {
504
4597
            ret = ff_opus_parse_packet(&s->packet, buf, buf_size, i != c->nb_streams - 1);
505
4597
            if (ret < 0) {
506
                av_log(avctx, AV_LOG_ERROR, "Error parsing the packet header.\n");
507
                return ret;
508
            }
509
4597
            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
4597
            s->silk_samplerate = get_silk_samplerate(s->packet.config);
516
        }
517
518
26220
        ret = opus_decode_subpacket(&c->streams[i], buf, s->packet.data_size,
519
                                    coded_samples);
520
26220
        if (ret < 0)
521
            return ret;
522
26220
        s->decoded_samples = ret;
523
26220
        decoded_samples       = FFMIN(decoded_samples, ret);
524
525
26220
        buf      += s->packet.packet_size;
526
26220
        buf_size -= s->packet.packet_size;
527
    }
528
529
    /* buffer the extra samples */
530
47843
    for (i = 0; i < c->nb_streams; i++) {
531
26220
        OpusStreamContext *s = &c->streams[i];
532
26220
        int   buffer_samples = s->decoded_samples - decoded_samples;
533
26220
        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
70997
    for (i = 0; i < avctx->channels; i++) {
545
49374
        ChannelMap *map = &c->channel_maps[i];
546
547
        /* handle copied channels */
548
49374
        if (map->copy) {
549
            memcpy(frame->extended_data[i],
550
                   frame->extended_data[map->copy_idx],
551
                   frame->linesize[0]);
552
49374
        } else if (map->silence) {
553
            memset(frame->extended_data[i], 0, frame->linesize[0]);
554
        }
555
556

49374
        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
21623
    frame->nb_samples = decoded_samples;
564
21623
    *got_frame_ptr    = !!decoded_samples;
565
566
21623
    return avpkt->size;
567
}
568
569
static 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
590
31
static av_cold int opus_decode_close(AVCodecContext *avctx)
591
{
592
31
    OpusContext *c = avctx->priv_data;
593
    int i;
594
595
72
    for (i = 0; i < c->nb_streams; i++) {
596
41
        OpusStreamContext *s = &c->streams[i];
597
598
41
        ff_silk_free(&s->silk);
599
41
        ff_celt_free(&s->celt);
600
601
41
        av_freep(&s->out_dummy);
602
41
        s->out_dummy_allocated_size = 0;
603
604
41
        av_audio_fifo_free(s->sync_buffer);
605
41
        av_audio_fifo_free(s->celt_delay);
606
41
        swr_free(&s->swr);
607
    }
608
609
31
    av_freep(&c->streams);
610
611
31
    c->nb_streams = 0;
612
613
31
    av_freep(&c->channel_maps);
614
31
    av_freep(&c->fdsp);
615
616
31
    return 0;
617
}
618
619
31
static av_cold int opus_decode_init(AVCodecContext *avctx)
620
{
621
31
    OpusContext *c = avctx->priv_data;
622
    int ret, i, j;
623
624
31
    avctx->sample_fmt  = AV_SAMPLE_FMT_FLTP;
625
31
    avctx->sample_rate = 48000;
626
627
31
    c->fdsp = avpriv_float_dsp_alloc(0);
628
31
    if (!c->fdsp)
629
        return AVERROR(ENOMEM);
630
631
    /* find out the channel configuration */
632
31
    ret = ff_opus_parse_extradata(avctx, c);
633
31
    if (ret < 0)
634
        return ret;
635
636
    /* allocate and init each independent decoder */
637
31
    c->streams = av_mallocz_array(c->nb_streams, sizeof(*c->streams));
638
31
    if (!c->streams) {
639
        c->nb_streams = 0;
640
        return AVERROR(ENOMEM);
641
    }
642
643
72
    for (i = 0; i < c->nb_streams; i++) {
644
41
        OpusStreamContext *s = &c->streams[i];
645
        uint64_t layout;
646
647
41
        s->output_channels = (i < c->nb_stereo_streams) ? 2 : 1;
648
649
41
        s->avctx = avctx;
650
651
115
        for (j = 0; j < s->output_channels; j++) {
652
74
            s->silk_output[j]       = s->silk_buf[j];
653
74
            s->celt_output[j]       = s->celt_buf[j];
654
74
            s->redundancy_output[j] = s->redundancy_buf[j];
655
        }
656
657
41
        s->fdsp = c->fdsp;
658
659
41
        s->swr =swr_alloc();
660
41
        if (!s->swr)
661
            return AVERROR(ENOMEM);
662
663
41
        layout = (s->output_channels == 1) ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
664
41
        av_opt_set_int(s->swr, "in_sample_fmt",      avctx->sample_fmt,  0);
665
41
        av_opt_set_int(s->swr, "out_sample_fmt",     avctx->sample_fmt,  0);
666
41
        av_opt_set_int(s->swr, "in_channel_layout",  layout,             0);
667
41
        av_opt_set_int(s->swr, "out_channel_layout", layout,             0);
668
41
        av_opt_set_int(s->swr, "out_sample_rate",    avctx->sample_rate, 0);
669
41
        av_opt_set_int(s->swr, "filter_size",        16,                 0);
670
671
41
        ret = ff_silk_init(avctx, &s->silk, s->output_channels);
672
41
        if (ret < 0)
673
            return ret;
674
675
41
        ret = ff_celt_init(avctx, &s->celt, s->output_channels, c->apply_phase_inv);
676
41
        if (ret < 0)
677
            return ret;
678
679
41
        s->celt_delay = av_audio_fifo_alloc(avctx->sample_fmt,
680
                                            s->output_channels, 1024);
681
41
        if (!s->celt_delay)
682
            return AVERROR(ENOMEM);
683
684
41
        s->sync_buffer = av_audio_fifo_alloc(avctx->sample_fmt,
685
                                             s->output_channels, 32);
686
41
        if (!s->sync_buffer)
687
            return AVERROR(ENOMEM);
688
    }
689
690
31
    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
707
AVCodec ff_opus_decoder = {
708
    .name            = "opus",
709
    .long_name       = NULL_IF_CONFIG_SMALL("Opus"),
710
    .priv_class      = &opus_class,
711
    .type            = AVMEDIA_TYPE_AUDIO,
712
    .id              = AV_CODEC_ID_OPUS,
713
    .priv_data_size  = sizeof(OpusContext),
714
    .init            = opus_decode_init,
715
    .close           = opus_decode_close,
716
    .decode          = opus_decode_packet,
717
    .flush           = opus_decode_flush,
718
    .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
};