GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/opusenc.c Lines: 0 385 0.0 %
Date: 2019-11-18 18:00:01 Branches: 0 212 0.0 %

Line Branch Exec Source
1
/*
2
 * Opus encoder
3
 * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
#include "opusenc.h"
23
#include "opus_pvq.h"
24
#include "opusenc_psy.h"
25
#include "opustab.h"
26
27
#include "libavutil/float_dsp.h"
28
#include "libavutil/opt.h"
29
#include "internal.h"
30
#include "bytestream.h"
31
#include "audio_frame_queue.h"
32
33
typedef struct OpusEncContext {
34
    AVClass *av_class;
35
    OpusEncOptions options;
36
    OpusPsyContext psyctx;
37
    AVCodecContext *avctx;
38
    AudioFrameQueue afq;
39
    AVFloatDSPContext *dsp;
40
    MDCT15Context *mdct[CELT_BLOCK_NB];
41
    CeltPVQ *pvq;
42
    struct FFBufQueue bufqueue;
43
44
    uint8_t enc_id[64];
45
    int enc_id_bits;
46
47
    OpusPacketInfo packet;
48
49
    int channels;
50
51
    CeltFrame *frame;
52
    OpusRangeCoder *rc;
53
54
    /* Actual energy the decoder will have */
55
    float last_quantized_energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS];
56
57
    DECLARE_ALIGNED(32, float, scratch)[2048];
58
} OpusEncContext;
59
60
static void opus_write_extradata(AVCodecContext *avctx)
61
{
62
    uint8_t *bs = avctx->extradata;
63
64
    bytestream_put_buffer(&bs, "OpusHead", 8);
65
    bytestream_put_byte  (&bs, 0x1);
66
    bytestream_put_byte  (&bs, avctx->channels);
67
    bytestream_put_le16  (&bs, avctx->initial_padding);
68
    bytestream_put_le32  (&bs, avctx->sample_rate);
69
    bytestream_put_le16  (&bs, 0x0);
70
    bytestream_put_byte  (&bs, 0x0); /* Default layout */
71
}
72
73
static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)
74
{
75
    int tmp = 0x0, extended_toc = 0;
76
    static const int toc_cfg[][OPUS_MODE_NB][OPUS_BANDWITH_NB] = {
77
        /*  Silk                    Hybrid                  Celt                    Layer     */
78
        /*  NB  MB  WB SWB  FB      NB  MB  WB SWB  FB      NB  MB  WB SWB  FB      Bandwidth */
79
        { {  0,  0,  0,  0,  0 }, {  0,  0,  0,  0,  0 }, { 17,  0, 21, 25, 29 } }, /* 2.5 ms */
80
        { {  0,  0,  0,  0,  0 }, {  0,  0,  0,  0,  0 }, { 18,  0, 22, 26, 30 } }, /*   5 ms */
81
        { {  1,  5,  9,  0,  0 }, {  0,  0,  0, 13, 15 }, { 19,  0, 23, 27, 31 } }, /*  10 ms */
82
        { {  2,  6, 10,  0,  0 }, {  0,  0,  0, 14, 16 }, { 20,  0, 24, 28, 32 } }, /*  20 ms */
83
        { {  3,  7, 11,  0,  0 }, {  0,  0,  0,  0,  0 }, {  0,  0,  0,  0,  0 } }, /*  40 ms */
84
        { {  4,  8, 12,  0,  0 }, {  0,  0,  0,  0,  0 }, {  0,  0,  0,  0,  0 } }, /*  60 ms */
85
    };
86
    int cfg = toc_cfg[s->packet.framesize][s->packet.mode][s->packet.bandwidth];
87
    *fsize_needed = 0;
88
    if (!cfg)
89
        return 1;
90
    if (s->packet.frames == 2) {                                       /* 2 packets */
91
        if (s->frame[0].framebits == s->frame[1].framebits) {          /* same size */
92
            tmp = 0x1;
93
        } else {                                                  /* different size */
94
            tmp = 0x2;
95
            *fsize_needed = 1;                     /* put frame sizes in the packet */
96
        }
97
    } else if (s->packet.frames > 2) {
98
        tmp = 0x3;
99
        extended_toc = 1;
100
    }
101
    tmp |= (s->channels > 1) << 2;                                /* Stereo or mono */
102
    tmp |= (cfg - 1)         << 3;                           /* codec configuration */
103
    *toc++ = tmp;
104
    if (extended_toc) {
105
        for (int i = 0; i < (s->packet.frames - 1); i++)
106
            *fsize_needed |= (s->frame[i].framebits != s->frame[i + 1].framebits);
107
        tmp = (*fsize_needed) << 7;                                /* vbr flag */
108
        tmp |= (0) << 6;                                       /* padding flag */
109
        tmp |= s->packet.frames;
110
        *toc++ = tmp;
111
    }
112
    *size = 1 + extended_toc;
113
    return 0;
114
}
115
116
static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f)
117
{
118
    AVFrame *cur = NULL;
119
    const int subframesize = s->avctx->frame_size;
120
    int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
121
122
    cur = ff_bufqueue_get(&s->bufqueue);
123
124
    for (int ch = 0; ch < f->channels; ch++) {
125
        CeltBlock *b = &f->block[ch];
126
        const void *input = cur->extended_data[ch];
127
        size_t bps = av_get_bytes_per_sample(cur->format);
128
        memcpy(b->overlap, input, bps*cur->nb_samples);
129
    }
130
131
    av_frame_free(&cur);
132
133
    for (int sf = 0; sf < subframes; sf++) {
134
        if (sf != (subframes - 1))
135
            cur = ff_bufqueue_get(&s->bufqueue);
136
        else
137
            cur = ff_bufqueue_peek(&s->bufqueue, 0);
138
139
        for (int ch = 0; ch < f->channels; ch++) {
140
            CeltBlock *b = &f->block[ch];
141
            const void *input = cur->extended_data[ch];
142
            const size_t bps  = av_get_bytes_per_sample(cur->format);
143
            const size_t left = (subframesize - cur->nb_samples)*bps;
144
            const size_t len  = FFMIN(subframesize, cur->nb_samples)*bps;
145
            memcpy(&b->samples[sf*subframesize], input, len);
146
            memset(&b->samples[cur->nb_samples], 0, left);
147
        }
148
149
        /* Last frame isn't popped off and freed yet - we need it for overlap */
150
        if (sf != (subframes - 1))
151
            av_frame_free(&cur);
152
    }
153
}
154
155
/* Apply the pre emphasis filter */
156
static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)
157
{
158
    const int subframesize = s->avctx->frame_size;
159
    const int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
160
161
    /* Filter overlap */
162
    for (int ch = 0; ch < f->channels; ch++) {
163
        CeltBlock *b = &f->block[ch];
164
        float m = b->emph_coeff;
165
        for (int i = 0; i < CELT_OVERLAP; i++) {
166
            float sample = b->overlap[i];
167
            b->overlap[i] = sample - m;
168
            m = sample * CELT_EMPH_COEFF;
169
        }
170
        b->emph_coeff = m;
171
    }
172
173
    /* Filter the samples but do not update the last subframe's coeff - overlap ^^^ */
174
    for (int sf = 0; sf < subframes; sf++) {
175
        for (int ch = 0; ch < f->channels; ch++) {
176
            CeltBlock *b = &f->block[ch];
177
            float m = b->emph_coeff;
178
            for (int i = 0; i < subframesize; i++) {
179
                float sample = b->samples[sf*subframesize + i];
180
                b->samples[sf*subframesize + i] = sample - m;
181
                m = sample * CELT_EMPH_COEFF;
182
            }
183
            if (sf != (subframes - 1))
184
                b->emph_coeff = m;
185
        }
186
    }
187
}
188
189
/* Create the window and do the mdct */
190
static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)
191
{
192
    float *win = s->scratch, *temp = s->scratch + 1920;
193
194
    if (f->transient) {
195
        for (int ch = 0; ch < f->channels; ch++) {
196
            CeltBlock *b = &f->block[ch];
197
            float *src1 = b->overlap;
198
            for (int t = 0; t < f->blocks; t++) {
199
                float *src2 = &b->samples[CELT_OVERLAP*t];
200
                s->dsp->vector_fmul(win, src1, ff_celt_window, 128);
201
                s->dsp->vector_fmul_reverse(&win[CELT_OVERLAP], src2,
202
                                            ff_celt_window - 8, 128);
203
                src1 = src2;
204
                s->mdct[0]->mdct(s->mdct[0], b->coeffs + t, win, f->blocks);
205
            }
206
        }
207
    } else {
208
        int blk_len = OPUS_BLOCK_SIZE(f->size), wlen = OPUS_BLOCK_SIZE(f->size + 1);
209
        int rwin = blk_len - CELT_OVERLAP, lap_dst = (wlen - blk_len - CELT_OVERLAP) >> 1;
210
        memset(win, 0, wlen*sizeof(float));
211
        for (int ch = 0; ch < f->channels; ch++) {
212
            CeltBlock *b = &f->block[ch];
213
214
            /* Overlap */
215
            s->dsp->vector_fmul(temp, b->overlap, ff_celt_window, 128);
216
            memcpy(win + lap_dst, temp, CELT_OVERLAP*sizeof(float));
217
218
            /* Samples, flat top window */
219
            memcpy(&win[lap_dst + CELT_OVERLAP], b->samples, rwin*sizeof(float));
220
221
            /* Samples, windowed */
222
            s->dsp->vector_fmul_reverse(temp, b->samples + rwin,
223
                                        ff_celt_window - 8, 128);
224
            memcpy(win + lap_dst + blk_len, temp, CELT_OVERLAP*sizeof(float));
225
226
            s->mdct[f->size]->mdct(s->mdct[f->size], b->coeffs, win, 1);
227
        }
228
    }
229
230
    for (int ch = 0; ch < f->channels; ch++) {
231
        CeltBlock *block = &f->block[ch];
232
        for (int i = 0; i < CELT_MAX_BANDS; i++) {
233
            float ener = 0.0f;
234
            int band_offset = ff_celt_freq_bands[i] << f->size;
235
            int band_size   = ff_celt_freq_range[i] << f->size;
236
            float *coeffs   = &block->coeffs[band_offset];
237
238
            for (int j = 0; j < band_size; j++)
239
                ener += coeffs[j]*coeffs[j];
240
241
            block->lin_energy[i] = sqrtf(ener) + FLT_EPSILON;
242
            ener = 1.0f/block->lin_energy[i];
243
244
            for (int j = 0; j < band_size; j++)
245
                coeffs[j] *= ener;
246
247
            block->energy[i] = log2f(block->lin_energy[i]) - ff_celt_mean_energy[i];
248
249
            /* CELT_ENERGY_SILENCE is what the decoder uses and its not -infinity */
250
            block->energy[i] = FFMAX(block->energy[i], CELT_ENERGY_SILENCE);
251
        }
252
    }
253
}
254
255
static void celt_enc_tf(CeltFrame *f, OpusRangeCoder *rc)
256
{
257
    int tf_select = 0, diff = 0, tf_changed = 0, tf_select_needed;
258
    int bits = f->transient ? 2 : 4;
259
260
    tf_select_needed = ((f->size && (opus_rc_tell(rc) + bits + 1) <= f->framebits));
261
262
    for (int i = f->start_band; i < f->end_band; i++) {
263
        if ((opus_rc_tell(rc) + bits + tf_select_needed) <= f->framebits) {
264
            const int tbit = (diff ^ 1) == f->tf_change[i];
265
            ff_opus_rc_enc_log(rc, tbit, bits);
266
            diff ^= tbit;
267
            tf_changed |= diff;
268
        }
269
        bits = f->transient ? 4 : 5;
270
    }
271
272
    if (tf_select_needed && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
273
                            ff_celt_tf_select[f->size][f->transient][1][tf_changed]) {
274
        ff_opus_rc_enc_log(rc, f->tf_select, 1);
275
        tf_select = f->tf_select;
276
    }
277
278
    for (int i = f->start_band; i < f->end_band; i++)
279
        f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
280
}
281
282
static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)
283
{
284
    float gain = f->pf_gain;
285
    int txval, octave = f->pf_octave, period = f->pf_period, tapset = f->pf_tapset;
286
287
    ff_opus_rc_enc_log(rc, f->pfilter, 1);
288
    if (!f->pfilter)
289
        return;
290
291
    /* Octave */
292
    txval = FFMIN(octave, 6);
293
    ff_opus_rc_enc_uint(rc, txval, 6);
294
    octave = txval;
295
    /* Period */
296
    txval = av_clip(period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
297
    ff_opus_rc_put_raw(rc, period, 4 + octave);
298
    period = txval + (16 << octave) - 1;
299
    /* Gain */
300
    txval = FFMIN(((int)(gain / 0.09375f)) - 1, 7);
301
    ff_opus_rc_put_raw(rc, txval, 3);
302
    gain   = 0.09375f * (txval + 1);
303
    /* Tapset */
304
    if ((opus_rc_tell(rc) + 2) <= f->framebits)
305
        ff_opus_rc_enc_cdf(rc, tapset, ff_celt_model_tapset);
306
    else
307
        tapset = 0;
308
    /* Finally create the coeffs */
309
    for (int i = 0; i < 2; i++) {
310
        CeltBlock *block = &f->block[i];
311
312
        block->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);
313
        block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
314
        block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
315
        block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
316
    }
317
}
318
319
static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f,
320
                             float last_energy[][CELT_MAX_BANDS], int intra)
321
{
322
    float alpha, beta, prev[2] = { 0, 0 };
323
    const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][intra];
324
325
    /* Inter is really just differential coding */
326
    if (opus_rc_tell(rc) + 3 <= f->framebits)
327
        ff_opus_rc_enc_log(rc, intra, 3);
328
    else
329
        intra = 0;
330
331
    if (intra) {
332
        alpha = 0.0f;
333
        beta  = 1.0f - (4915.0f/32768.0f);
334
    } else {
335
        alpha = ff_celt_alpha_coef[f->size];
336
        beta  = ff_celt_beta_coef[f->size];
337
    }
338
339
    for (int i = f->start_band; i < f->end_band; i++) {
340
        for (int ch = 0; ch < f->channels; ch++) {
341
            CeltBlock *block = &f->block[ch];
342
            const int left = f->framebits - opus_rc_tell(rc);
343
            const float last = FFMAX(-9.0f, last_energy[ch][i]);
344
            float diff = block->energy[i] - prev[ch] - last*alpha;
345
            int q_en = lrintf(diff);
346
            if (left >= 15) {
347
                ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6);
348
            } else if (left >= 2) {
349
                q_en = av_clip(q_en, -1, 1);
350
                ff_opus_rc_enc_cdf(rc, 2*q_en + 3*(q_en < 0), ff_celt_model_energy_small);
351
            } else if (left >= 1) {
352
                q_en = av_clip(q_en, -1, 0);
353
                ff_opus_rc_enc_log(rc, (q_en & 1), 1);
354
            } else q_en = -1;
355
356
            block->error_energy[i] = q_en - diff;
357
            prev[ch] += beta * q_en;
358
        }
359
    }
360
}
361
362
static void celt_quant_coarse(CeltFrame *f, OpusRangeCoder *rc,
363
                              float last_energy[][CELT_MAX_BANDS])
364
{
365
    uint32_t inter, intra;
366
    OPUS_RC_CHECKPOINT_SPAWN(rc);
367
368
    exp_quant_coarse(rc, f, last_energy, 1);
369
    intra = OPUS_RC_CHECKPOINT_BITS(rc);
370
371
    OPUS_RC_CHECKPOINT_ROLLBACK(rc);
372
373
    exp_quant_coarse(rc, f, last_energy, 0);
374
    inter = OPUS_RC_CHECKPOINT_BITS(rc);
375
376
    if (inter > intra) { /* Unlikely */
377
        OPUS_RC_CHECKPOINT_ROLLBACK(rc);
378
        exp_quant_coarse(rc, f, last_energy, 1);
379
    }
380
}
381
382
static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)
383
{
384
    for (int i = f->start_band; i < f->end_band; i++) {
385
        if (!f->fine_bits[i])
386
            continue;
387
        for (int ch = 0; ch < f->channels; ch++) {
388
            CeltBlock *block = &f->block[ch];
389
            int quant, lim = (1 << f->fine_bits[i]);
390
            float offset, diff = 0.5f - block->error_energy[i];
391
            quant = av_clip(floor(diff*lim), 0, lim - 1);
392
            ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]);
393
            offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f);
394
            block->error_energy[i] -= offset;
395
        }
396
    }
397
}
398
399
static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
400
{
401
    for (int priority = 0; priority < 2; priority++) {
402
        for (int i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) {
403
            if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
404
                continue;
405
            for (int ch = 0; ch < f->channels; ch++) {
406
                CeltBlock *block = &f->block[ch];
407
                const float err = block->error_energy[i];
408
                const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
409
                const int sign = FFABS(err + offset) < FFABS(err - offset);
410
                ff_opus_rc_put_raw(rc, sign, 1);
411
                block->error_energy[i] -= offset*(1 - 2*sign);
412
            }
413
        }
414
    }
415
}
416
417
static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc,
418
                              CeltFrame *f, int index)
419
{
420
    ff_opus_rc_enc_init(rc);
421
422
    ff_opus_psy_celt_frame_init(&s->psyctx, f, index);
423
424
    celt_frame_setup_input(s, f);
425
426
    if (f->silence) {
427
        if (f->framebits >= 16)
428
            ff_opus_rc_enc_log(rc, 1, 15); /* Silence (if using explicit singalling) */
429
        for (int ch = 0; ch < s->channels; ch++)
430
            memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
431
        return;
432
    }
433
434
    /* Filters */
435
    celt_apply_preemph_filter(s, f);
436
    if (f->pfilter) {
437
        ff_opus_rc_enc_log(rc, 0, 15);
438
        celt_enc_quant_pfilter(rc, f);
439
    }
440
441
    /* Transform */
442
    celt_frame_mdct(s, f);
443
444
    /* Need to handle transient/non-transient switches at any point during analysis */
445
    while (ff_opus_psy_celt_frame_process(&s->psyctx, f, index))
446
        celt_frame_mdct(s, f);
447
448
    ff_opus_rc_enc_init(rc);
449
450
    /* Silence */
451
    ff_opus_rc_enc_log(rc, 0, 15);
452
453
    /* Pitch filter */
454
    if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits)
455
        celt_enc_quant_pfilter(rc, f);
456
457
    /* Transient flag */
458
    if (f->size && opus_rc_tell(rc) + 3 <= f->framebits)
459
        ff_opus_rc_enc_log(rc, f->transient, 3);
460
461
    /* Main encoding */
462
    celt_quant_coarse  (f, rc, s->last_quantized_energy);
463
    celt_enc_tf        (f, rc);
464
    ff_celt_bitalloc   (f, rc, 1);
465
    celt_quant_fine    (f, rc);
466
    ff_celt_quant_bands(f, rc);
467
468
    /* Anticollapse bit */
469
    if (f->anticollapse_needed)
470
        ff_opus_rc_put_raw(rc, f->anticollapse, 1);
471
472
    /* Final per-band energy adjustments from leftover bits */
473
    celt_quant_final(s, rc, f);
474
475
    for (int ch = 0; ch < f->channels; ch++) {
476
        CeltBlock *block = &f->block[ch];
477
        for (int i = 0; i < CELT_MAX_BANDS; i++)
478
            s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i];
479
    }
480
}
481
482
static inline int write_opuslacing(uint8_t *dst, int v)
483
{
484
    dst[0] = FFMIN(v - FFALIGN(v - 255, 4), v);
485
    dst[1] = v - dst[0] >> 2;
486
    return 1 + (v >= 252);
487
}
488
489
static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
490
{
491
    int offset, fsize_needed;
492
493
    /* Write toc */
494
    opus_gen_toc(s, avpkt->data, &offset, &fsize_needed);
495
496
    /* Frame sizes if needed */
497
    if (fsize_needed) {
498
        for (int i = 0; i < s->packet.frames - 1; i++) {
499
            offset += write_opuslacing(avpkt->data + offset,
500
                                       s->frame[i].framebits >> 3);
501
        }
502
    }
503
504
    /* Packets */
505
    for (int i = 0; i < s->packet.frames; i++) {
506
        ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset,
507
                           s->frame[i].framebits >> 3);
508
        offset += s->frame[i].framebits >> 3;
509
    }
510
511
    avpkt->size = offset;
512
}
513
514
/* Used as overlap for the first frame and padding for the last encoded packet */
515
static AVFrame *spawn_empty_frame(OpusEncContext *s)
516
{
517
    AVFrame *f = av_frame_alloc();
518
    if (!f)
519
        return NULL;
520
    f->format         = s->avctx->sample_fmt;
521
    f->nb_samples     = s->avctx->frame_size;
522
    f->channel_layout = s->avctx->channel_layout;
523
    if (av_frame_get_buffer(f, 4)) {
524
        av_frame_free(&f);
525
        return NULL;
526
    }
527
    for (int i = 0; i < s->channels; i++) {
528
        size_t bps = av_get_bytes_per_sample(f->format);
529
        memset(f->extended_data[i], 0, bps*f->nb_samples);
530
    }
531
    return f;
532
}
533
534
static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
535
                             const AVFrame *frame, int *got_packet_ptr)
536
{
537
    OpusEncContext *s = avctx->priv_data;
538
    int ret, frame_size, alloc_size = 0;
539
540
    if (frame) { /* Add new frame to queue */
541
        if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
542
            return ret;
543
        ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame));
544
    } else {
545
        ff_opus_psy_signal_eof(&s->psyctx);
546
        if (!s->afq.remaining_samples || !avctx->frame_number)
547
            return 0; /* We've been flushed and there's nothing left to encode */
548
    }
549
550
    /* Run the psychoacoustic system */
551
    if (ff_opus_psy_process(&s->psyctx, &s->packet))
552
        return 0;
553
554
    frame_size = OPUS_BLOCK_SIZE(s->packet.framesize);
555
556
    if (!frame) {
557
        /* This can go negative, that's not a problem, we only pad if positive */
558
        int pad_empty = s->packet.frames*(frame_size/s->avctx->frame_size) - s->bufqueue.available + 1;
559
        /* Pad with empty 2.5 ms frames to whatever framesize was decided,
560
         * this should only happen at the very last flush frame. The frames
561
         * allocated here will be freed (because they have no other references)
562
         * after they get used by celt_frame_setup_input() */
563
        for (int i = 0; i < pad_empty; i++) {
564
            AVFrame *empty = spawn_empty_frame(s);
565
            if (!empty)
566
                return AVERROR(ENOMEM);
567
            ff_bufqueue_add(avctx, &s->bufqueue, empty);
568
        }
569
    }
570
571
    for (int i = 0; i < s->packet.frames; i++) {
572
        celt_encode_frame(s, &s->rc[i], &s->frame[i], i);
573
        alloc_size += s->frame[i].framebits >> 3;
574
    }
575
576
    /* Worst case toc + the frame lengths if needed */
577
    alloc_size += 2 + s->packet.frames*2;
578
579
    if ((ret = ff_alloc_packet2(avctx, avpkt, alloc_size, 0)) < 0)
580
        return ret;
581
582
    /* Assemble packet */
583
    opus_packet_assembler(s, avpkt);
584
585
    /* Update the psychoacoustic system */
586
    ff_opus_psy_postencode_update(&s->psyctx, s->frame, s->rc);
587
588
    /* Remove samples from queue and skip if needed */
589
    ff_af_queue_remove(&s->afq, s->packet.frames*frame_size, &avpkt->pts, &avpkt->duration);
590
    if (s->packet.frames*frame_size > avpkt->duration) {
591
        uint8_t *side = av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
592
        if (!side)
593
            return AVERROR(ENOMEM);
594
        AV_WL32(&side[4], s->packet.frames*frame_size - avpkt->duration + 120);
595
    }
596
597
    *got_packet_ptr = 1;
598
599
    return 0;
600
}
601
602
static av_cold int opus_encode_end(AVCodecContext *avctx)
603
{
604
    OpusEncContext *s = avctx->priv_data;
605
606
    for (int i = 0; i < CELT_BLOCK_NB; i++)
607
        ff_mdct15_uninit(&s->mdct[i]);
608
609
    ff_celt_pvq_uninit(&s->pvq);
610
    av_freep(&s->dsp);
611
    av_freep(&s->frame);
612
    av_freep(&s->rc);
613
    ff_af_queue_close(&s->afq);
614
    ff_opus_psy_end(&s->psyctx);
615
    ff_bufqueue_discard_all(&s->bufqueue);
616
    av_freep(&avctx->extradata);
617
618
    return 0;
619
}
620
621
static av_cold int opus_encode_init(AVCodecContext *avctx)
622
{
623
    int ret, max_frames;
624
    OpusEncContext *s = avctx->priv_data;
625
626
    s->avctx = avctx;
627
    s->channels = avctx->channels;
628
629
    /* Opus allows us to change the framesize on each packet (and each packet may
630
     * have multiple frames in it) but we can't change the codec's frame size on
631
     * runtime, so fix it to the lowest possible number of samples and use a queue
632
     * to accumulate AVFrames until we have enough to encode whatever the encoder
633
     * decides is the best */
634
    avctx->frame_size = 120;
635
    /* Initial padding will change if SILK is ever supported */
636
    avctx->initial_padding = 120;
637
638
    if (!avctx->bit_rate) {
639
        int coupled = ff_opus_default_coupled_streams[s->channels - 1];
640
        avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000);
641
    } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) {
642
        int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels);
643
        av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %"PRId64" kbps, clipping to %"PRId64" kbps\n",
644
               avctx->bit_rate/1000, clipped_rate/1000);
645
        avctx->bit_rate = clipped_rate;
646
    }
647
648
    /* Extradata */
649
    avctx->extradata_size = 19;
650
    avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
651
    if (!avctx->extradata)
652
        return AVERROR(ENOMEM);
653
    opus_write_extradata(avctx);
654
655
    ff_af_queue_init(avctx, &s->afq);
656
657
    if ((ret = ff_celt_pvq_init(&s->pvq, 1)) < 0)
658
        return ret;
659
660
    if (!(s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT)))
661
        return AVERROR(ENOMEM);
662
663
    /* I have no idea why a base scaling factor of 68 works, could be the twiddles */
664
    for (int i = 0; i < CELT_BLOCK_NB; i++)
665
        if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
666
            return AVERROR(ENOMEM);
667
668
    /* Zero out previous energy (matters for inter first frame) */
669
    for (int ch = 0; ch < s->channels; ch++)
670
        memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
671
672
    /* Allocate an empty frame to use as overlap for the first frame of audio */
673
    ff_bufqueue_add(avctx, &s->bufqueue, spawn_empty_frame(s));
674
    if (!ff_bufqueue_peek(&s->bufqueue, 0))
675
        return AVERROR(ENOMEM);
676
677
    if ((ret = ff_opus_psy_init(&s->psyctx, s->avctx, &s->bufqueue, &s->options)))
678
        return ret;
679
680
    /* Frame structs and range coder buffers */
681
    max_frames = ceilf(FFMIN(s->options.max_delay_ms, 120.0f)/2.5f);
682
    s->frame = av_malloc(max_frames*sizeof(CeltFrame));
683
    if (!s->frame)
684
        return AVERROR(ENOMEM);
685
    s->rc = av_malloc(max_frames*sizeof(OpusRangeCoder));
686
    if (!s->rc)
687
        return AVERROR(ENOMEM);
688
689
    for (int i = 0; i < max_frames; i++) {
690
        s->frame[i].dsp = s->dsp;
691
        s->frame[i].avctx = s->avctx;
692
        s->frame[i].seed = 0;
693
        s->frame[i].pvq = s->pvq;
694
        s->frame[i].apply_phase_inv = 1;
695
        s->frame[i].block[0].emph_coeff = s->frame[i].block[1].emph_coeff = 0.0f;
696
    }
697
698
    return 0;
699
}
700
701
#define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
702
static const AVOption opusenc_options[] = {
703
    { "opus_delay", "Maximum delay in milliseconds", offsetof(OpusEncContext, options.max_delay_ms), AV_OPT_TYPE_FLOAT, { .dbl = OPUS_MAX_LOOKAHEAD }, 2.5f, OPUS_MAX_LOOKAHEAD, OPUSENC_FLAGS, "max_delay_ms" },
704
    { NULL },
705
};
706
707
static const AVClass opusenc_class = {
708
    .class_name = "Opus encoder",
709
    .item_name  = av_default_item_name,
710
    .option     = opusenc_options,
711
    .version    = LIBAVUTIL_VERSION_INT,
712
};
713
714
static const AVCodecDefault opusenc_defaults[] = {
715
    { "b", "0" },
716
    { "compression_level", "10" },
717
    { NULL },
718
};
719
720
AVCodec ff_opus_encoder = {
721
    .name           = "opus",
722
    .long_name      = NULL_IF_CONFIG_SMALL("Opus"),
723
    .type           = AVMEDIA_TYPE_AUDIO,
724
    .id             = AV_CODEC_ID_OPUS,
725
    .defaults       = opusenc_defaults,
726
    .priv_class     = &opusenc_class,
727
    .priv_data_size = sizeof(OpusEncContext),
728
    .init           = opus_encode_init,
729
    .encode2        = opus_encode_frame,
730
    .close          = opus_encode_end,
731
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
732
    .capabilities   = AV_CODEC_CAP_EXPERIMENTAL | AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY,
733
    .supported_samplerates = (const int []){ 48000, 0 },
734
    .channel_layouts = (const uint64_t []){ AV_CH_LAYOUT_MONO,
735
                                            AV_CH_LAYOUT_STEREO, 0 },
736
    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
737
                                                     AV_SAMPLE_FMT_NONE },
738
};