LCOV - code coverage report
Current view: top level - libavcodec - opusenc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 589 0.0 %
Date: 2017-12-15 11:05:35 Functions: 0 19 0.0 %

          Line data    Source code
       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           0 : static void opus_write_extradata(AVCodecContext *avctx)
      61             : {
      62           0 :     uint8_t *bs = avctx->extradata;
      63             : 
      64           0 :     bytestream_put_buffer(&bs, "OpusHead", 8);
      65           0 :     bytestream_put_byte  (&bs, 0x1);
      66           0 :     bytestream_put_byte  (&bs, avctx->channels);
      67           0 :     bytestream_put_le16  (&bs, avctx->initial_padding);
      68           0 :     bytestream_put_le32  (&bs, avctx->sample_rate);
      69           0 :     bytestream_put_le16  (&bs, 0x0);
      70           0 :     bytestream_put_byte  (&bs, 0x0); /* Default layout */
      71           0 : }
      72             : 
      73           0 : static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)
      74             : {
      75           0 :     int i, 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           0 :     int cfg = toc_cfg[s->packet.framesize][s->packet.mode][s->packet.bandwidth];
      87           0 :     *fsize_needed = 0;
      88           0 :     if (!cfg)
      89           0 :         return 1;
      90           0 :     if (s->packet.frames == 2) {                                       /* 2 packets */
      91           0 :         if (s->frame[0].framebits == s->frame[1].framebits) {          /* same size */
      92           0 :             tmp = 0x1;
      93             :         } else {                                                  /* different size */
      94           0 :             tmp = 0x2;
      95           0 :             *fsize_needed = 1;                     /* put frame sizes in the packet */
      96             :         }
      97           0 :     } else if (s->packet.frames > 2) {
      98           0 :         tmp = 0x3;
      99           0 :         extended_toc = 1;
     100             :     }
     101           0 :     tmp |= (s->channels > 1) << 2;                                /* Stereo or mono */
     102           0 :     tmp |= (cfg - 1)         << 3;                           /* codec configuration */
     103           0 :     *toc++ = tmp;
     104           0 :     if (extended_toc) {
     105           0 :         for (i = 0; i < (s->packet.frames - 1); i++)
     106           0 :             *fsize_needed |= (s->frame[i].framebits != s->frame[i + 1].framebits);
     107           0 :         tmp = (*fsize_needed) << 7;                                /* vbr flag */
     108           0 :         tmp |= (0) << 6;                                       /* padding flag */
     109           0 :         tmp |= s->packet.frames;
     110           0 :         *toc++ = tmp;
     111             :     }
     112           0 :     *size = 1 + extended_toc;
     113           0 :     return 0;
     114             : }
     115             : 
     116           0 : static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f)
     117             : {
     118             :     int sf, ch;
     119           0 :     AVFrame *cur = NULL;
     120           0 :     const int subframesize = s->avctx->frame_size;
     121           0 :     int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
     122             : 
     123           0 :     cur = ff_bufqueue_get(&s->bufqueue);
     124             : 
     125           0 :     for (ch = 0; ch < f->channels; ch++) {
     126           0 :         CeltBlock *b = &f->block[ch];
     127           0 :         const void *input = cur->extended_data[ch];
     128           0 :         size_t bps = av_get_bytes_per_sample(cur->format);
     129           0 :         memcpy(b->overlap, input, bps*cur->nb_samples);
     130             :     }
     131             : 
     132           0 :     av_frame_free(&cur);
     133             : 
     134           0 :     for (sf = 0; sf < subframes; sf++) {
     135           0 :         if (sf != (subframes - 1))
     136           0 :             cur = ff_bufqueue_get(&s->bufqueue);
     137             :         else
     138           0 :             cur = ff_bufqueue_peek(&s->bufqueue, 0);
     139             : 
     140           0 :         for (ch = 0; ch < f->channels; ch++) {
     141           0 :             CeltBlock *b = &f->block[ch];
     142           0 :             const void *input = cur->extended_data[ch];
     143           0 :             const size_t bps  = av_get_bytes_per_sample(cur->format);
     144           0 :             const size_t left = (subframesize - cur->nb_samples)*bps;
     145           0 :             const size_t len  = FFMIN(subframesize, cur->nb_samples)*bps;
     146           0 :             memcpy(&b->samples[sf*subframesize], input, len);
     147           0 :             memset(&b->samples[cur->nb_samples], 0, left);
     148             :         }
     149             : 
     150             :         /* Last frame isn't popped off and freed yet - we need it for overlap */
     151           0 :         if (sf != (subframes - 1))
     152           0 :             av_frame_free(&cur);
     153             :     }
     154           0 : }
     155             : 
     156             : /* Apply the pre emphasis filter */
     157           0 : static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)
     158             : {
     159             :     int i, sf, ch;
     160           0 :     const int subframesize = s->avctx->frame_size;
     161           0 :     const int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
     162             : 
     163             :     /* Filter overlap */
     164           0 :     for (ch = 0; ch < f->channels; ch++) {
     165           0 :         CeltBlock *b = &f->block[ch];
     166           0 :         float m = b->emph_coeff;
     167           0 :         for (i = 0; i < CELT_OVERLAP; i++) {
     168           0 :             float sample = b->overlap[i];
     169           0 :             b->overlap[i] = sample - m;
     170           0 :             m = sample * CELT_EMPH_COEFF;
     171             :         }
     172           0 :         b->emph_coeff = m;
     173             :     }
     174             : 
     175             :     /* Filter the samples but do not update the last subframe's coeff - overlap ^^^ */
     176           0 :     for (sf = 0; sf < subframes; sf++) {
     177           0 :         for (ch = 0; ch < f->channels; ch++) {
     178           0 :             CeltBlock *b = &f->block[ch];
     179           0 :             float m = b->emph_coeff;
     180           0 :             for (i = 0; i < subframesize; i++) {
     181           0 :                 float sample = b->samples[sf*subframesize + i];
     182           0 :                 b->samples[sf*subframesize + i] = sample - m;
     183           0 :                 m = sample * CELT_EMPH_COEFF;
     184             :             }
     185           0 :             if (sf != (subframes - 1))
     186           0 :                 b->emph_coeff = m;
     187             :         }
     188             :     }
     189           0 : }
     190             : 
     191             : /* Create the window and do the mdct */
     192           0 : static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)
     193             : {
     194             :     int i, j, t, ch;
     195           0 :     float *win = s->scratch, *temp = s->scratch + 1920;
     196             : 
     197           0 :     if (f->transient) {
     198           0 :         for (ch = 0; ch < f->channels; ch++) {
     199           0 :             CeltBlock *b = &f->block[ch];
     200           0 :             float *src1 = b->overlap;
     201           0 :             for (t = 0; t < f->blocks; t++) {
     202           0 :                 float *src2 = &b->samples[CELT_OVERLAP*t];
     203           0 :                 s->dsp->vector_fmul(win, src1, ff_celt_window, 128);
     204           0 :                 s->dsp->vector_fmul_reverse(&win[CELT_OVERLAP], src2,
     205             :                                             ff_celt_window - 8, 128);
     206           0 :                 src1 = src2;
     207           0 :                 s->mdct[0]->mdct(s->mdct[0], b->coeffs + t, win, f->blocks);
     208             :             }
     209             :         }
     210             :     } else {
     211           0 :         int blk_len = OPUS_BLOCK_SIZE(f->size), wlen = OPUS_BLOCK_SIZE(f->size + 1);
     212           0 :         int rwin = blk_len - CELT_OVERLAP, lap_dst = (wlen - blk_len - CELT_OVERLAP) >> 1;
     213           0 :         memset(win, 0, wlen*sizeof(float));
     214           0 :         for (ch = 0; ch < f->channels; ch++) {
     215           0 :             CeltBlock *b = &f->block[ch];
     216             : 
     217             :             /* Overlap */
     218           0 :             s->dsp->vector_fmul(temp, b->overlap, ff_celt_window, 128);
     219           0 :             memcpy(win + lap_dst, temp, CELT_OVERLAP*sizeof(float));
     220             : 
     221             :             /* Samples, flat top window */
     222           0 :             memcpy(&win[lap_dst + CELT_OVERLAP], b->samples, rwin*sizeof(float));
     223             : 
     224             :             /* Samples, windowed */
     225           0 :             s->dsp->vector_fmul_reverse(temp, b->samples + rwin,
     226             :                                         ff_celt_window - 8, 128);
     227           0 :             memcpy(win + lap_dst + blk_len, temp, CELT_OVERLAP*sizeof(float));
     228             : 
     229           0 :             s->mdct[f->size]->mdct(s->mdct[f->size], b->coeffs, win, 1);
     230             :         }
     231             :     }
     232             : 
     233           0 :     for (ch = 0; ch < f->channels; ch++) {
     234           0 :         CeltBlock *block = &f->block[ch];
     235           0 :         for (i = 0; i < CELT_MAX_BANDS; i++) {
     236           0 :             float ener = 0.0f;
     237           0 :             int band_offset = ff_celt_freq_bands[i] << f->size;
     238           0 :             int band_size   = ff_celt_freq_range[i] << f->size;
     239           0 :             float *coeffs   = &block->coeffs[band_offset];
     240             : 
     241           0 :             for (j = 0; j < band_size; j++)
     242           0 :                 ener += coeffs[j]*coeffs[j];
     243             : 
     244           0 :             block->lin_energy[i] = sqrtf(ener) + FLT_EPSILON;
     245           0 :             ener = 1.0f/block->lin_energy[i];
     246             : 
     247           0 :             for (j = 0; j < band_size; j++)
     248           0 :                 coeffs[j] *= ener;
     249             : 
     250           0 :             block->energy[i] = log2f(block->lin_energy[i]) - ff_celt_mean_energy[i];
     251             : 
     252             :             /* CELT_ENERGY_SILENCE is what the decoder uses and its not -infinity */
     253           0 :             block->energy[i] = FFMAX(block->energy[i], CELT_ENERGY_SILENCE);
     254             :         }
     255             :     }
     256           0 : }
     257             : 
     258           0 : static void celt_enc_tf(CeltFrame *f, OpusRangeCoder *rc)
     259             : {
     260           0 :     int i, tf_select = 0, diff = 0, tf_changed = 0, tf_select_needed;
     261           0 :     int bits = f->transient ? 2 : 4;
     262             : 
     263           0 :     tf_select_needed = ((f->size && (opus_rc_tell(rc) + bits + 1) <= f->framebits));
     264             : 
     265           0 :     for (i = f->start_band; i < f->end_band; i++) {
     266           0 :         if ((opus_rc_tell(rc) + bits + tf_select_needed) <= f->framebits) {
     267           0 :             const int tbit = (diff ^ 1) == f->tf_change[i];
     268           0 :             ff_opus_rc_enc_log(rc, tbit, bits);
     269           0 :             diff ^= tbit;
     270           0 :             tf_changed |= diff;
     271             :         }
     272           0 :         bits = f->transient ? 4 : 5;
     273             :     }
     274             : 
     275           0 :     if (tf_select_needed && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
     276           0 :                             ff_celt_tf_select[f->size][f->transient][1][tf_changed]) {
     277           0 :         ff_opus_rc_enc_log(rc, f->tf_select, 1);
     278           0 :         tf_select = f->tf_select;
     279             :     }
     280             : 
     281           0 :     for (i = f->start_band; i < f->end_band; i++)
     282           0 :         f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
     283           0 : }
     284             : 
     285           0 : void ff_celt_enc_bitalloc(CeltFrame *f, OpusRangeCoder *rc)
     286             : {
     287             :     int i, j, low, high, total, done, bandbits, remaining, tbits_8ths;
     288           0 :     int skip_startband      = f->start_band;
     289           0 :     int skip_bit            = 0;
     290           0 :     int intensitystereo_bit = 0;
     291           0 :     int dualstereo_bit      = 0;
     292           0 :     int dynalloc            = 6;
     293           0 :     int extrabits           = 0;
     294             : 
     295           0 :     int *cap = f->caps;
     296             :     int boost[CELT_MAX_BANDS];
     297             :     int trim_offset[CELT_MAX_BANDS];
     298             :     int threshold[CELT_MAX_BANDS];
     299             :     int bits1[CELT_MAX_BANDS];
     300             :     int bits2[CELT_MAX_BANDS];
     301             : 
     302             :     /* Tell the spread to the decoder */
     303           0 :     if (opus_rc_tell(rc) + 4 <= f->framebits)
     304           0 :         ff_opus_rc_enc_cdf(rc, f->spread, ff_celt_model_spread);
     305             :     else
     306           0 :         f->spread = CELT_SPREAD_NORMAL;
     307             : 
     308             :     /* Generate static allocation caps */
     309           0 :     for (i = 0; i < CELT_MAX_BANDS; i++) {
     310           0 :         cap[i] = (ff_celt_static_caps[f->size][f->channels - 1][i] + 64)
     311           0 :                  * ff_celt_freq_range[i] << (f->channels - 1) << f->size >> 2;
     312             :     }
     313             : 
     314             :     /* Band boosts */
     315           0 :     tbits_8ths = f->framebits << 3;
     316           0 :     for (i = f->start_band; i < f->end_band; i++) {
     317           0 :         int quanta, b_dynalloc, boost_amount = f->alloc_boost[i];
     318             : 
     319           0 :         boost[i] = 0;
     320             : 
     321           0 :         quanta = ff_celt_freq_range[i] << (f->channels - 1) << f->size;
     322           0 :         quanta = FFMIN(quanta << 3, FFMAX(6 << 3, quanta));
     323           0 :         b_dynalloc = dynalloc;
     324             : 
     325           0 :         while (opus_rc_tell_frac(rc) + (b_dynalloc << 3) < tbits_8ths && boost[i] < cap[i]) {
     326           0 :             int is_boost = boost_amount--;
     327             : 
     328           0 :             ff_opus_rc_enc_log(rc, is_boost, b_dynalloc);
     329           0 :             if (!is_boost)
     330           0 :                 break;
     331             : 
     332           0 :             boost[i]   += quanta;
     333           0 :             tbits_8ths -= quanta;
     334             : 
     335           0 :             b_dynalloc = 1;
     336             :         }
     337             : 
     338           0 :         if (boost[i])
     339           0 :             dynalloc = FFMAX(2, dynalloc - 1);
     340             :     }
     341             : 
     342             :     /* Put allocation trim */
     343           0 :     if (opus_rc_tell_frac(rc) + (6 << 3) <= tbits_8ths)
     344           0 :         ff_opus_rc_enc_cdf(rc, f->alloc_trim, ff_celt_model_alloc_trim);
     345             : 
     346             :     /* Anti-collapse bit reservation */
     347           0 :     tbits_8ths = (f->framebits << 3) - opus_rc_tell_frac(rc) - 1;
     348           0 :     f->anticollapse_needed = 0;
     349           0 :     if (f->transient && f->size >= 2 && tbits_8ths >= ((f->size + 2) << 3))
     350           0 :         f->anticollapse_needed = 1 << 3;
     351           0 :     tbits_8ths -= f->anticollapse_needed;
     352             : 
     353             :     /* Band skip bit reservation */
     354           0 :     if (tbits_8ths >= 1 << 3)
     355           0 :         skip_bit = 1 << 3;
     356           0 :     tbits_8ths -= skip_bit;
     357             : 
     358             :     /* Intensity/dual stereo bit reservation */
     359           0 :     if (f->channels == 2) {
     360           0 :         intensitystereo_bit = ff_celt_log2_frac[f->end_band - f->start_band];
     361           0 :         if (intensitystereo_bit <= tbits_8ths) {
     362           0 :             tbits_8ths -= intensitystereo_bit;
     363           0 :             if (tbits_8ths >= 1 << 3) {
     364           0 :                 dualstereo_bit = 1 << 3;
     365           0 :                 tbits_8ths -= 1 << 3;
     366             :             }
     367             :         } else {
     368           0 :             intensitystereo_bit = 0;
     369             :         }
     370             :     }
     371             : 
     372             :     /* Trim offsets */
     373           0 :     for (i = f->start_band; i < f->end_band; i++) {
     374           0 :         int trim     = f->alloc_trim - 5 - f->size;
     375           0 :         int band     = ff_celt_freq_range[i] * (f->end_band - i - 1);
     376           0 :         int duration = f->size + 3;
     377           0 :         int scale    = duration + f->channels - 1;
     378             : 
     379             :         /* PVQ minimum allocation threshold, below this value the band is
     380             :          * skipped */
     381           0 :         threshold[i] = FFMAX(3 * ff_celt_freq_range[i] << duration >> 4,
     382             :                              f->channels << 3);
     383             : 
     384           0 :         trim_offset[i] = trim * (band << scale) >> 6;
     385             : 
     386           0 :         if (ff_celt_freq_range[i] << f->size == 1)
     387           0 :             trim_offset[i] -= f->channels << 3;
     388             :     }
     389             : 
     390             :     /* Bisection */
     391           0 :     low  = 1;
     392           0 :     high = CELT_VECTORS - 1;
     393           0 :     while (low <= high) {
     394           0 :         int center = (low + high) >> 1;
     395           0 :         done = total = 0;
     396             : 
     397           0 :         for (i = f->end_band - 1; i >= f->start_band; i--) {
     398           0 :             bandbits = ff_celt_freq_range[i] * ff_celt_static_alloc[center][i]
     399           0 :                        << (f->channels - 1) << f->size >> 2;
     400             : 
     401           0 :             if (bandbits)
     402           0 :                 bandbits = FFMAX(0, bandbits + trim_offset[i]);
     403           0 :             bandbits += boost[i];
     404             : 
     405           0 :             if (bandbits >= threshold[i] || done) {
     406           0 :                 done = 1;
     407           0 :                 total += FFMIN(bandbits, cap[i]);
     408           0 :             } else if (bandbits >= f->channels << 3)
     409           0 :                 total += f->channels << 3;
     410             :         }
     411             : 
     412           0 :         if (total > tbits_8ths)
     413           0 :             high = center - 1;
     414             :         else
     415           0 :             low = center + 1;
     416             :     }
     417           0 :     high = low--;
     418             : 
     419             :     /* Bisection */
     420           0 :     for (i = f->start_band; i < f->end_band; i++) {
     421           0 :         bits1[i] = ff_celt_freq_range[i] * ff_celt_static_alloc[low][i]
     422           0 :                    << (f->channels - 1) << f->size >> 2;
     423           0 :         bits2[i] = high >= CELT_VECTORS ? cap[i] :
     424           0 :                    ff_celt_freq_range[i] * ff_celt_static_alloc[high][i]
     425           0 :                    << (f->channels - 1) << f->size >> 2;
     426             : 
     427           0 :         if (bits1[i])
     428           0 :             bits1[i] = FFMAX(0, bits1[i] + trim_offset[i]);
     429           0 :         if (bits2[i])
     430           0 :             bits2[i] = FFMAX(0, bits2[i] + trim_offset[i]);
     431           0 :         if (low)
     432           0 :             bits1[i] += boost[i];
     433           0 :         bits2[i] += boost[i];
     434             : 
     435           0 :         if (boost[i])
     436           0 :             skip_startband = i;
     437           0 :         bits2[i] = FFMAX(0, bits2[i] - bits1[i]);
     438             :     }
     439             : 
     440             :     /* Bisection */
     441           0 :     low  = 0;
     442           0 :     high = 1 << CELT_ALLOC_STEPS;
     443           0 :     for (i = 0; i < CELT_ALLOC_STEPS; i++) {
     444           0 :         int center = (low + high) >> 1;
     445           0 :         done = total = 0;
     446             : 
     447           0 :         for (j = f->end_band - 1; j >= f->start_band; j--) {
     448           0 :             bandbits = bits1[j] + (center * bits2[j] >> CELT_ALLOC_STEPS);
     449             : 
     450           0 :             if (bandbits >= threshold[j] || done) {
     451           0 :                 done = 1;
     452           0 :                 total += FFMIN(bandbits, cap[j]);
     453           0 :             } else if (bandbits >= f->channels << 3)
     454           0 :                 total += f->channels << 3;
     455             :         }
     456           0 :         if (total > tbits_8ths)
     457           0 :             high = center;
     458             :         else
     459           0 :             low = center;
     460             :     }
     461             : 
     462             :     /* Bisection */
     463           0 :     done = total = 0;
     464           0 :     for (i = f->end_band - 1; i >= f->start_band; i--) {
     465           0 :         bandbits = bits1[i] + (low * bits2[i] >> CELT_ALLOC_STEPS);
     466             : 
     467           0 :         if (bandbits >= threshold[i] || done)
     468           0 :             done = 1;
     469             :         else
     470           0 :             bandbits = (bandbits >= f->channels << 3) ?
     471           0 :                        f->channels << 3 : 0;
     472             : 
     473           0 :         bandbits     = FFMIN(bandbits, cap[i]);
     474           0 :         f->pulses[i] = bandbits;
     475           0 :         total      += bandbits;
     476             :     }
     477             : 
     478             :     /* Band skipping */
     479           0 :     for (f->coded_bands = f->end_band; ; f->coded_bands--) {
     480             :         int allocation;
     481           0 :         j = f->coded_bands - 1;
     482             : 
     483           0 :         if (j == skip_startband) {
     484             :             /* all remaining bands are not skipped */
     485           0 :             tbits_8ths += skip_bit;
     486           0 :             break;
     487             :         }
     488             : 
     489             :         /* determine the number of bits available for coding "do not skip" markers */
     490           0 :         remaining   = tbits_8ths - total;
     491           0 :         bandbits    = remaining / (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
     492           0 :         remaining  -= bandbits  * (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
     493           0 :         allocation  = f->pulses[j] + bandbits * ff_celt_freq_range[j]
     494           0 :                       + FFMAX(0, remaining - (ff_celt_freq_bands[j] - ff_celt_freq_bands[f->start_band]));
     495             : 
     496             :         /* a "do not skip" marker is only coded if the allocation is
     497             :            above the chosen threshold */
     498           0 :         if (allocation >= FFMAX(threshold[j], (f->channels + 1) << 3)) {
     499           0 :             const int do_not_skip = f->coded_bands <= f->skip_band_floor;
     500           0 :             ff_opus_rc_enc_log(rc, do_not_skip, 1);
     501           0 :             if (do_not_skip)
     502           0 :                 break;
     503             : 
     504           0 :             total      += 1 << 3;
     505           0 :             allocation -= 1 << 3;
     506             :         }
     507             : 
     508             :         /* the band is skipped, so reclaim its bits */
     509           0 :         total -= f->pulses[j];
     510           0 :         if (intensitystereo_bit) {
     511           0 :             total -= intensitystereo_bit;
     512           0 :             intensitystereo_bit = ff_celt_log2_frac[j - f->start_band];
     513           0 :             total += intensitystereo_bit;
     514             :         }
     515             : 
     516           0 :         total += f->pulses[j] = (allocation >= f->channels << 3) ? f->channels << 3 : 0;
     517             :     }
     518             : 
     519             :     /* Encode stereo flags */
     520           0 :     if (intensitystereo_bit) {
     521           0 :         f->intensity_stereo = FFMIN(f->intensity_stereo, f->coded_bands);
     522           0 :         ff_opus_rc_enc_uint(rc, f->intensity_stereo, f->coded_bands + 1 - f->start_band);
     523             :     }
     524           0 :     if (f->intensity_stereo <= f->start_band)
     525           0 :         tbits_8ths += dualstereo_bit; /* no intensity stereo means no dual stereo */
     526           0 :     else if (dualstereo_bit)
     527           0 :         ff_opus_rc_enc_log(rc, f->dual_stereo, 1);
     528             : 
     529             :     /* Supply the remaining bits in this frame to lower bands */
     530           0 :     remaining = tbits_8ths - total;
     531           0 :     bandbits  = remaining / (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
     532           0 :     remaining -= bandbits * (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
     533           0 :     for (i = f->start_band; i < f->coded_bands; i++) {
     534           0 :         int bits = FFMIN(remaining, ff_celt_freq_range[i]);
     535             : 
     536           0 :         f->pulses[i] += bits + bandbits * ff_celt_freq_range[i];
     537           0 :         remaining    -= bits;
     538             :     }
     539             : 
     540             :     /* Finally determine the allocation */
     541           0 :     for (i = f->start_band; i < f->coded_bands; i++) {
     542           0 :         int N = ff_celt_freq_range[i] << f->size;
     543           0 :         int prev_extra = extrabits;
     544           0 :         f->pulses[i] += extrabits;
     545             : 
     546           0 :         if (N > 1) {
     547             :             int dof;        // degrees of freedom
     548             :             int temp;       // dof * channels * log(dof)
     549             :             int offset;     // fine energy quantization offset, i.e.
     550             :                             // extra bits assigned over the standard
     551             :                             // totalbits/dof
     552             :             int fine_bits, max_bits;
     553             : 
     554           0 :             extrabits = FFMAX(0, f->pulses[i] - cap[i]);
     555           0 :             f->pulses[i] -= extrabits;
     556             : 
     557             :             /* intensity stereo makes use of an extra degree of freedom */
     558           0 :             dof = N * f->channels + (f->channels == 2 && N > 2 && !f->dual_stereo && i < f->intensity_stereo);
     559           0 :             temp = dof * (ff_celt_log_freq_range[i] + (f->size << 3));
     560           0 :             offset = (temp >> 1) - dof * CELT_FINE_OFFSET;
     561           0 :             if (N == 2) /* dof=2 is the only case that doesn't fit the model */
     562           0 :                 offset += dof << 1;
     563             : 
     564             :             /* grant an additional bias for the first and second pulses */
     565           0 :             if (f->pulses[i] + offset < 2 * (dof << 3))
     566           0 :                 offset += temp >> 2;
     567           0 :             else if (f->pulses[i] + offset < 3 * (dof << 3))
     568           0 :                 offset += temp >> 3;
     569             : 
     570           0 :             fine_bits = (f->pulses[i] + offset + (dof << 2)) / (dof << 3);
     571           0 :             max_bits  = FFMIN((f->pulses[i] >> 3) >> (f->channels - 1), CELT_MAX_FINE_BITS);
     572             : 
     573           0 :             max_bits  = FFMAX(max_bits, 0);
     574             : 
     575           0 :             f->fine_bits[i] = av_clip(fine_bits, 0, max_bits);
     576             : 
     577             :             /* if fine_bits was rounded down or capped,
     578             :                give priority for the final fine energy pass */
     579           0 :             f->fine_priority[i] = (f->fine_bits[i] * (dof << 3) >= f->pulses[i] + offset);
     580             : 
     581             :             /* the remaining bits are assigned to PVQ */
     582           0 :             f->pulses[i] -= f->fine_bits[i] << (f->channels - 1) << 3;
     583             :         } else {
     584             :             /* all bits go to fine energy except for the sign bit */
     585           0 :             extrabits = FFMAX(0, f->pulses[i] - (f->channels << 3));
     586           0 :             f->pulses[i] -= extrabits;
     587           0 :             f->fine_bits[i] = 0;
     588           0 :             f->fine_priority[i] = 1;
     589             :         }
     590             : 
     591             :         /* hand back a limited number of extra fine energy bits to this band */
     592           0 :         if (extrabits > 0) {
     593           0 :             int fineextra = FFMIN(extrabits >> (f->channels + 2),
     594             :                                   CELT_MAX_FINE_BITS - f->fine_bits[i]);
     595           0 :             f->fine_bits[i] += fineextra;
     596             : 
     597           0 :             fineextra <<= f->channels + 2;
     598           0 :             f->fine_priority[i] = (fineextra >= extrabits - prev_extra);
     599           0 :             extrabits -= fineextra;
     600             :         }
     601             :     }
     602           0 :     f->remaining = extrabits;
     603             : 
     604             :     /* skipped bands dedicate all of their bits for fine energy */
     605           0 :     for (; i < f->end_band; i++) {
     606           0 :         f->fine_bits[i]     = f->pulses[i] >> (f->channels - 1) >> 3;
     607           0 :         f->pulses[i]        = 0;
     608           0 :         f->fine_priority[i] = f->fine_bits[i] < 1;
     609             :     }
     610           0 : }
     611             : 
     612           0 : static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)
     613             : {
     614           0 :     float gain = f->pf_gain;
     615           0 :     int i, txval, octave = f->pf_octave, period = f->pf_period, tapset = f->pf_tapset;
     616             : 
     617           0 :     ff_opus_rc_enc_log(rc, f->pfilter, 1);
     618           0 :     if (!f->pfilter)
     619           0 :         return;
     620             : 
     621             :     /* Octave */
     622           0 :     txval = FFMIN(octave, 6);
     623           0 :     ff_opus_rc_enc_uint(rc, txval, 6);
     624           0 :     octave = txval;
     625             :     /* Period */
     626           0 :     txval = av_clip(period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
     627           0 :     ff_opus_rc_put_raw(rc, period, 4 + octave);
     628           0 :     period = txval + (16 << octave) - 1;
     629             :     /* Gain */
     630           0 :     txval = FFMIN(((int)(gain / 0.09375f)) - 1, 7);
     631           0 :     ff_opus_rc_put_raw(rc, txval, 3);
     632           0 :     gain   = 0.09375f * (txval + 1);
     633             :     /* Tapset */
     634           0 :     if ((opus_rc_tell(rc) + 2) <= f->framebits)
     635           0 :         ff_opus_rc_enc_cdf(rc, tapset, ff_celt_model_tapset);
     636             :     else
     637           0 :         tapset = 0;
     638             :     /* Finally create the coeffs */
     639           0 :     for (i = 0; i < 2; i++) {
     640           0 :         CeltBlock *block = &f->block[i];
     641             : 
     642           0 :         block->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);
     643           0 :         block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
     644           0 :         block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
     645           0 :         block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
     646             :     }
     647             : }
     648             : 
     649           0 : static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f,
     650             :                              float last_energy[][CELT_MAX_BANDS], int intra)
     651             : {
     652             :     int i, ch;
     653           0 :     float alpha, beta, prev[2] = { 0, 0 };
     654           0 :     const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][intra];
     655             : 
     656             :     /* Inter is really just differential coding */
     657           0 :     if (opus_rc_tell(rc) + 3 <= f->framebits)
     658           0 :         ff_opus_rc_enc_log(rc, intra, 3);
     659             :     else
     660           0 :         intra = 0;
     661             : 
     662           0 :     if (intra) {
     663           0 :         alpha = 0.0f;
     664           0 :         beta  = 1.0f - (4915.0f/32768.0f);
     665             :     } else {
     666           0 :         alpha = ff_celt_alpha_coef[f->size];
     667           0 :         beta  = ff_celt_beta_coef[f->size];
     668             :     }
     669             : 
     670           0 :     for (i = f->start_band; i < f->end_band; i++) {
     671           0 :         for (ch = 0; ch < f->channels; ch++) {
     672           0 :             CeltBlock *block = &f->block[ch];
     673           0 :             const int left = f->framebits - opus_rc_tell(rc);
     674           0 :             const float last = FFMAX(-9.0f, last_energy[ch][i]);
     675           0 :             float diff = block->energy[i] - prev[ch] - last*alpha;
     676           0 :             int q_en = lrintf(diff);
     677           0 :             if (left >= 15) {
     678           0 :                 ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6);
     679           0 :             } else if (left >= 2) {
     680           0 :                 q_en = av_clip(q_en, -1, 1);
     681           0 :                 ff_opus_rc_enc_cdf(rc, 2*q_en + 3*(q_en < 0), ff_celt_model_energy_small);
     682           0 :             } else if (left >= 1) {
     683           0 :                 q_en = av_clip(q_en, -1, 0);
     684           0 :                 ff_opus_rc_enc_log(rc, (q_en & 1), 1);
     685           0 :             } else q_en = -1;
     686             : 
     687           0 :             block->error_energy[i] = q_en - diff;
     688           0 :             prev[ch] += beta * q_en;
     689             :         }
     690             :     }
     691           0 : }
     692             : 
     693           0 : static void celt_quant_coarse(CeltFrame *f, OpusRangeCoder *rc,
     694             :                               float last_energy[][CELT_MAX_BANDS])
     695             : {
     696             :     uint32_t inter, intra;
     697           0 :     OPUS_RC_CHECKPOINT_SPAWN(rc);
     698             : 
     699           0 :     exp_quant_coarse(rc, f, last_energy, 1);
     700           0 :     intra = OPUS_RC_CHECKPOINT_BITS(rc);
     701             : 
     702           0 :     OPUS_RC_CHECKPOINT_ROLLBACK(rc);
     703             : 
     704           0 :     exp_quant_coarse(rc, f, last_energy, 0);
     705           0 :     inter = OPUS_RC_CHECKPOINT_BITS(rc);
     706             : 
     707           0 :     if (inter > intra) { /* Unlikely */
     708           0 :         OPUS_RC_CHECKPOINT_ROLLBACK(rc);
     709           0 :         exp_quant_coarse(rc, f, last_energy, 1);
     710             :     }
     711           0 : }
     712             : 
     713           0 : static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)
     714             : {
     715             :     int i, ch;
     716           0 :     for (i = f->start_band; i < f->end_band; i++) {
     717           0 :         if (!f->fine_bits[i])
     718           0 :             continue;
     719           0 :         for (ch = 0; ch < f->channels; ch++) {
     720           0 :             CeltBlock *block = &f->block[ch];
     721           0 :             int quant, lim = (1 << f->fine_bits[i]);
     722           0 :             float offset, diff = 0.5f - block->error_energy[i];
     723           0 :             quant = av_clip(floor(diff*lim), 0, lim - 1);
     724           0 :             ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]);
     725           0 :             offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f);
     726           0 :             block->error_energy[i] -= offset;
     727             :         }
     728             :     }
     729           0 : }
     730             : 
     731           0 : static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
     732             : {
     733             :     int i, ch, priority;
     734           0 :     for (priority = 0; priority < 2; priority++) {
     735           0 :         for (i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) {
     736           0 :             if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
     737           0 :                 continue;
     738           0 :             for (ch = 0; ch < f->channels; ch++) {
     739           0 :                 CeltBlock *block = &f->block[ch];
     740           0 :                 const float err = block->error_energy[i];
     741           0 :                 const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
     742           0 :                 const int sign = FFABS(err + offset) < FFABS(err - offset);
     743           0 :                 ff_opus_rc_put_raw(rc, sign, 1);
     744           0 :                 block->error_energy[i] -= offset*(1 - 2*sign);
     745             :             }
     746             :         }
     747             :     }
     748           0 : }
     749             : 
     750           0 : static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc,
     751             :                               CeltFrame *f, int index)
     752             : {
     753             :     int i, ch;
     754             : 
     755           0 :     ff_opus_rc_enc_init(rc);
     756             : 
     757           0 :     ff_opus_psy_celt_frame_init(&s->psyctx, f, index);
     758             : 
     759           0 :     celt_frame_setup_input(s, f);
     760             : 
     761           0 :     if (f->silence) {
     762           0 :         if (f->framebits >= 16)
     763           0 :             ff_opus_rc_enc_log(rc, 1, 15); /* Silence (if using explicit singalling) */
     764           0 :         for (ch = 0; ch < s->channels; ch++)
     765           0 :             memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
     766           0 :         return;
     767             :     }
     768             : 
     769             :     /* Filters */
     770           0 :     celt_apply_preemph_filter(s, f);
     771           0 :     if (f->pfilter) {
     772           0 :         ff_opus_rc_enc_log(rc, 0, 15);
     773           0 :         celt_enc_quant_pfilter(rc, f);
     774             :     }
     775             : 
     776             :     /* Transform */
     777           0 :     celt_frame_mdct(s, f);
     778             : 
     779             :     /* Need to handle transient/non-transient switches at any point during analysis */
     780           0 :     while (ff_opus_psy_celt_frame_process(&s->psyctx, f, index))
     781           0 :         celt_frame_mdct(s, f);
     782             : 
     783           0 :     ff_opus_rc_enc_init(rc);
     784             : 
     785             :     /* Silence */
     786           0 :     ff_opus_rc_enc_log(rc, 0, 15);
     787             : 
     788             :     /* Pitch filter */
     789           0 :     if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits)
     790           0 :         celt_enc_quant_pfilter(rc, f);
     791             : 
     792             :     /* Transient flag */
     793           0 :     if (f->size && opus_rc_tell(rc) + 3 <= f->framebits)
     794           0 :         ff_opus_rc_enc_log(rc, f->transient, 3);
     795             : 
     796             :     /* Main encoding */
     797           0 :     celt_quant_coarse   (f, rc, s->last_quantized_energy);
     798           0 :     celt_enc_tf         (f, rc);
     799           0 :     ff_celt_enc_bitalloc(f, rc);
     800           0 :     celt_quant_fine     (f, rc);
     801           0 :     ff_celt_quant_bands (f, rc);
     802             : 
     803             :     /* Anticollapse bit */
     804           0 :     if (f->anticollapse_needed)
     805           0 :         ff_opus_rc_put_raw(rc, f->anticollapse, 1);
     806             : 
     807             :     /* Final per-band energy adjustments from leftover bits */
     808           0 :     celt_quant_final(s, rc, f);
     809             : 
     810           0 :     for (ch = 0; ch < f->channels; ch++) {
     811           0 :         CeltBlock *block = &f->block[ch];
     812           0 :         for (i = 0; i < CELT_MAX_BANDS; i++)
     813           0 :             s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i];
     814             :     }
     815             : }
     816             : 
     817           0 : static inline int write_opuslacing(uint8_t *dst, int v)
     818             : {
     819           0 :     dst[0] = FFMIN(v - FFALIGN(v - 255, 4), v);
     820           0 :     dst[1] = v - dst[0] >> 2;
     821           0 :     return 1 + (v >= 252);
     822             : }
     823             : 
     824           0 : static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
     825             : {
     826             :     int i, offset, fsize_needed;
     827             : 
     828             :     /* Write toc */
     829           0 :     opus_gen_toc(s, avpkt->data, &offset, &fsize_needed);
     830             : 
     831             :     /* Frame sizes if needed */
     832           0 :     if (fsize_needed) {
     833           0 :         for (i = 0; i < s->packet.frames - 1; i++) {
     834           0 :             offset += write_opuslacing(avpkt->data + offset,
     835           0 :                                        s->frame[i].framebits >> 3);
     836             :         }
     837             :     }
     838             : 
     839             :     /* Packets */
     840           0 :     for (i = 0; i < s->packet.frames; i++) {
     841           0 :         ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset,
     842           0 :                            s->frame[i].framebits >> 3);
     843           0 :         offset += s->frame[i].framebits >> 3;
     844             :     }
     845             : 
     846           0 :     avpkt->size = offset;
     847           0 : }
     848             : 
     849             : /* Used as overlap for the first frame and padding for the last encoded packet */
     850           0 : static AVFrame *spawn_empty_frame(OpusEncContext *s)
     851             : {
     852             :     int i;
     853           0 :     AVFrame *f = av_frame_alloc();
     854           0 :     if (!f)
     855           0 :         return NULL;
     856           0 :     f->format         = s->avctx->sample_fmt;
     857           0 :     f->nb_samples     = s->avctx->frame_size;
     858           0 :     f->channel_layout = s->avctx->channel_layout;
     859           0 :     if (av_frame_get_buffer(f, 4)) {
     860           0 :         av_frame_free(&f);
     861           0 :         return NULL;
     862             :     }
     863           0 :     for (i = 0; i < s->channels; i++) {
     864           0 :         size_t bps = av_get_bytes_per_sample(f->format);
     865           0 :         memset(f->extended_data[i], 0, bps*f->nb_samples);
     866             :     }
     867           0 :     return f;
     868             : }
     869             : 
     870           0 : static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     871             :                              const AVFrame *frame, int *got_packet_ptr)
     872             : {
     873           0 :     OpusEncContext *s = avctx->priv_data;
     874           0 :     int i, ret, frame_size, alloc_size = 0;
     875             : 
     876           0 :     if (frame) { /* Add new frame to queue */
     877           0 :         if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
     878           0 :             return ret;
     879           0 :         ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame));
     880             :     } else {
     881           0 :         ff_opus_psy_signal_eof(&s->psyctx);
     882           0 :         if (!s->afq.remaining_samples)
     883           0 :             return 0; /* We've been flushed and there's nothing left to encode */
     884             :     }
     885             : 
     886             :     /* Run the psychoacoustic system */
     887           0 :     if (ff_opus_psy_process(&s->psyctx, &s->packet))
     888           0 :         return 0;
     889             : 
     890           0 :     frame_size = OPUS_BLOCK_SIZE(s->packet.framesize);
     891             : 
     892           0 :     if (!frame) {
     893             :         /* This can go negative, that's not a problem, we only pad if positive */
     894           0 :         int pad_empty = s->packet.frames*(frame_size/s->avctx->frame_size) - s->bufqueue.available + 1;
     895             :         /* Pad with empty 2.5 ms frames to whatever framesize was decided,
     896             :          * this should only happen at the very last flush frame. The frames
     897             :          * allocated here will be freed (because they have no other references)
     898             :          * after they get used by celt_frame_setup_input() */
     899           0 :         for (i = 0; i < pad_empty; i++) {
     900           0 :             AVFrame *empty = spawn_empty_frame(s);
     901           0 :             if (!empty)
     902           0 :                 return AVERROR(ENOMEM);
     903           0 :             ff_bufqueue_add(avctx, &s->bufqueue, empty);
     904             :         }
     905             :     }
     906             : 
     907           0 :     for (i = 0; i < s->packet.frames; i++) {
     908           0 :         celt_encode_frame(s, &s->rc[i], &s->frame[i], i);
     909           0 :         alloc_size += s->frame[i].framebits >> 3;
     910             :     }
     911             : 
     912             :     /* Worst case toc + the frame lengths if needed */
     913           0 :     alloc_size += 2 + s->packet.frames*2;
     914             : 
     915           0 :     if ((ret = ff_alloc_packet2(avctx, avpkt, alloc_size, 0)) < 0)
     916           0 :         return ret;
     917             : 
     918             :     /* Assemble packet */
     919           0 :     opus_packet_assembler(s, avpkt);
     920             : 
     921             :     /* Update the psychoacoustic system */
     922           0 :     ff_opus_psy_postencode_update(&s->psyctx, s->frame, s->rc);
     923             : 
     924             :     /* Remove samples from queue and skip if needed */
     925           0 :     ff_af_queue_remove(&s->afq, s->packet.frames*frame_size, &avpkt->pts, &avpkt->duration);
     926           0 :     if (s->packet.frames*frame_size > avpkt->duration) {
     927           0 :         uint8_t *side = av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
     928           0 :         if (!side)
     929           0 :             return AVERROR(ENOMEM);
     930           0 :         AV_WL32(&side[4], s->packet.frames*frame_size - avpkt->duration + 120);
     931             :     }
     932             : 
     933           0 :     *got_packet_ptr = 1;
     934             : 
     935           0 :     return 0;
     936             : }
     937             : 
     938           0 : static av_cold int opus_encode_end(AVCodecContext *avctx)
     939             : {
     940             :     int i;
     941           0 :     OpusEncContext *s = avctx->priv_data;
     942             : 
     943           0 :     for (i = 0; i < CELT_BLOCK_NB; i++)
     944           0 :         ff_mdct15_uninit(&s->mdct[i]);
     945             : 
     946           0 :     ff_celt_pvq_uninit(&s->pvq);
     947           0 :     av_freep(&s->dsp);
     948           0 :     av_freep(&s->frame);
     949           0 :     av_freep(&s->rc);
     950           0 :     ff_af_queue_close(&s->afq);
     951           0 :     ff_opus_psy_end(&s->psyctx);
     952           0 :     ff_bufqueue_discard_all(&s->bufqueue);
     953           0 :     av_freep(&avctx->extradata);
     954             : 
     955           0 :     return 0;
     956             : }
     957             : 
     958           0 : static av_cold int opus_encode_init(AVCodecContext *avctx)
     959             : {
     960             :     int i, ch, ret, max_frames;
     961           0 :     OpusEncContext *s = avctx->priv_data;
     962             : 
     963           0 :     s->avctx = avctx;
     964           0 :     s->channels = avctx->channels;
     965             : 
     966             :     /* Opus allows us to change the framesize on each packet (and each packet may
     967             :      * have multiple frames in it) but we can't change the codec's frame size on
     968             :      * runtime, so fix it to the lowest possible number of samples and use a queue
     969             :      * to accumulate AVFrames until we have enough to encode whatever the encoder
     970             :      * decides is the best */
     971           0 :     avctx->frame_size = 120;
     972             :     /* Initial padding will change if SILK is ever supported */
     973           0 :     avctx->initial_padding = 120;
     974             : 
     975           0 :     if (!avctx->bit_rate) {
     976           0 :         int coupled = ff_opus_default_coupled_streams[s->channels - 1];
     977           0 :         avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000);
     978           0 :     } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) {
     979           0 :         int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels);
     980           0 :         av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %"PRId64" kbps, clipping to %"PRId64" kbps\n",
     981           0 :                avctx->bit_rate/1000, clipped_rate/1000);
     982           0 :         avctx->bit_rate = clipped_rate;
     983             :     }
     984             : 
     985             :     /* Extradata */
     986           0 :     avctx->extradata_size = 19;
     987           0 :     avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
     988           0 :     if (!avctx->extradata)
     989           0 :         return AVERROR(ENOMEM);
     990           0 :     opus_write_extradata(avctx);
     991             : 
     992           0 :     ff_af_queue_init(avctx, &s->afq);
     993             : 
     994           0 :     if ((ret = ff_celt_pvq_init(&s->pvq, 1)) < 0)
     995           0 :         return ret;
     996             : 
     997           0 :     if (!(s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT)))
     998           0 :         return AVERROR(ENOMEM);
     999             : 
    1000             :     /* I have no idea why a base scaling factor of 68 works, could be the twiddles */
    1001           0 :     for (i = 0; i < CELT_BLOCK_NB; i++)
    1002           0 :         if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
    1003           0 :             return AVERROR(ENOMEM);
    1004             : 
    1005             :     /* Zero out previous energy (matters for inter first frame) */
    1006           0 :     for (ch = 0; ch < s->channels; ch++)
    1007           0 :         memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
    1008             : 
    1009             :     /* Allocate an empty frame to use as overlap for the first frame of audio */
    1010           0 :     ff_bufqueue_add(avctx, &s->bufqueue, spawn_empty_frame(s));
    1011           0 :     if (!ff_bufqueue_peek(&s->bufqueue, 0))
    1012           0 :         return AVERROR(ENOMEM);
    1013             : 
    1014           0 :     if ((ret = ff_opus_psy_init(&s->psyctx, s->avctx, &s->bufqueue, &s->options)))
    1015           0 :         return ret;
    1016             : 
    1017             :     /* Frame structs and range coder buffers */
    1018           0 :     max_frames = ceilf(FFMIN(s->options.max_delay_ms, 120.0f)/2.5f);
    1019           0 :     s->frame = av_malloc(max_frames*sizeof(CeltFrame));
    1020           0 :     if (!s->frame)
    1021           0 :         return AVERROR(ENOMEM);
    1022           0 :     s->rc = av_malloc(max_frames*sizeof(OpusRangeCoder));
    1023           0 :     if (!s->rc)
    1024           0 :         return AVERROR(ENOMEM);
    1025             : 
    1026           0 :     for (i = 0; i < max_frames; i++) {
    1027           0 :         s->frame[i].dsp = s->dsp;
    1028           0 :         s->frame[i].avctx = s->avctx;
    1029           0 :         s->frame[i].seed = 0;
    1030           0 :         s->frame[i].pvq = s->pvq;
    1031           0 :         s->frame[i].apply_phase_inv = 1;
    1032           0 :         s->frame[i].block[0].emph_coeff = s->frame[i].block[1].emph_coeff = 0.0f;
    1033             :     }
    1034             : 
    1035           0 :     return 0;
    1036             : }
    1037             : 
    1038             : #define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
    1039             : static const AVOption opusenc_options[] = {
    1040             :     { "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" },
    1041             :     { NULL },
    1042             : };
    1043             : 
    1044             : static const AVClass opusenc_class = {
    1045             :     .class_name = "Opus encoder",
    1046             :     .item_name  = av_default_item_name,
    1047             :     .option     = opusenc_options,
    1048             :     .version    = LIBAVUTIL_VERSION_INT,
    1049             : };
    1050             : 
    1051             : static const AVCodecDefault opusenc_defaults[] = {
    1052             :     { "b", "0" },
    1053             :     { "compression_level", "10" },
    1054             :     { NULL },
    1055             : };
    1056             : 
    1057             : AVCodec ff_opus_encoder = {
    1058             :     .name           = "opus",
    1059             :     .long_name      = NULL_IF_CONFIG_SMALL("Opus"),
    1060             :     .type           = AVMEDIA_TYPE_AUDIO,
    1061             :     .id             = AV_CODEC_ID_OPUS,
    1062             :     .defaults       = opusenc_defaults,
    1063             :     .priv_class     = &opusenc_class,
    1064             :     .priv_data_size = sizeof(OpusEncContext),
    1065             :     .init           = opus_encode_init,
    1066             :     .encode2        = opus_encode_frame,
    1067             :     .close          = opus_encode_end,
    1068             :     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
    1069             :     .capabilities   = AV_CODEC_CAP_EXPERIMENTAL | AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY,
    1070             :     .supported_samplerates = (const int []){ 48000, 0 },
    1071             :     .channel_layouts = (const uint64_t []){ AV_CH_LAYOUT_MONO,
    1072             :                                             AV_CH_LAYOUT_STEREO, 0 },
    1073             :     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
    1074             :                                                      AV_SAMPLE_FMT_NONE },
    1075             : };

Generated by: LCOV version 1.13