LCOV - code coverage report
Current view: top level - libavcodec - opusenc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 395 0.0 %
Date: 2018-05-20 11:54:08 Functions: 0 18 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 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 (int 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           0 :     AVFrame *cur = NULL;
     119           0 :     const int subframesize = s->avctx->frame_size;
     120           0 :     int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
     121             : 
     122           0 :     cur = ff_bufqueue_get(&s->bufqueue);
     123             : 
     124           0 :     for (int ch = 0; ch < f->channels; ch++) {
     125           0 :         CeltBlock *b = &f->block[ch];
     126           0 :         const void *input = cur->extended_data[ch];
     127           0 :         size_t bps = av_get_bytes_per_sample(cur->format);
     128           0 :         memcpy(b->overlap, input, bps*cur->nb_samples);
     129             :     }
     130             : 
     131           0 :     av_frame_free(&cur);
     132             : 
     133           0 :     for (int sf = 0; sf < subframes; sf++) {
     134           0 :         if (sf != (subframes - 1))
     135           0 :             cur = ff_bufqueue_get(&s->bufqueue);
     136             :         else
     137           0 :             cur = ff_bufqueue_peek(&s->bufqueue, 0);
     138             : 
     139           0 :         for (int ch = 0; ch < f->channels; ch++) {
     140           0 :             CeltBlock *b = &f->block[ch];
     141           0 :             const void *input = cur->extended_data[ch];
     142           0 :             const size_t bps  = av_get_bytes_per_sample(cur->format);
     143           0 :             const size_t left = (subframesize - cur->nb_samples)*bps;
     144           0 :             const size_t len  = FFMIN(subframesize, cur->nb_samples)*bps;
     145           0 :             memcpy(&b->samples[sf*subframesize], input, len);
     146           0 :             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           0 :         if (sf != (subframes - 1))
     151           0 :             av_frame_free(&cur);
     152             :     }
     153           0 : }
     154             : 
     155             : /* Apply the pre emphasis filter */
     156           0 : static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)
     157             : {
     158           0 :     const int subframesize = s->avctx->frame_size;
     159           0 :     const int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
     160             : 
     161             :     /* Filter overlap */
     162           0 :     for (int ch = 0; ch < f->channels; ch++) {
     163           0 :         CeltBlock *b = &f->block[ch];
     164           0 :         float m = b->emph_coeff;
     165           0 :         for (int i = 0; i < CELT_OVERLAP; i++) {
     166           0 :             float sample = b->overlap[i];
     167           0 :             b->overlap[i] = sample - m;
     168           0 :             m = sample * CELT_EMPH_COEFF;
     169             :         }
     170           0 :         b->emph_coeff = m;
     171             :     }
     172             : 
     173             :     /* Filter the samples but do not update the last subframe's coeff - overlap ^^^ */
     174           0 :     for (int sf = 0; sf < subframes; sf++) {
     175           0 :         for (int ch = 0; ch < f->channels; ch++) {
     176           0 :             CeltBlock *b = &f->block[ch];
     177           0 :             float m = b->emph_coeff;
     178           0 :             for (int i = 0; i < subframesize; i++) {
     179           0 :                 float sample = b->samples[sf*subframesize + i];
     180           0 :                 b->samples[sf*subframesize + i] = sample - m;
     181           0 :                 m = sample * CELT_EMPH_COEFF;
     182             :             }
     183           0 :             if (sf != (subframes - 1))
     184           0 :                 b->emph_coeff = m;
     185             :         }
     186             :     }
     187           0 : }
     188             : 
     189             : /* Create the window and do the mdct */
     190           0 : static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)
     191             : {
     192           0 :     float *win = s->scratch, *temp = s->scratch + 1920;
     193             : 
     194           0 :     if (f->transient) {
     195           0 :         for (int ch = 0; ch < f->channels; ch++) {
     196           0 :             CeltBlock *b = &f->block[ch];
     197           0 :             float *src1 = b->overlap;
     198           0 :             for (int t = 0; t < f->blocks; t++) {
     199           0 :                 float *src2 = &b->samples[CELT_OVERLAP*t];
     200           0 :                 s->dsp->vector_fmul(win, src1, ff_celt_window, 128);
     201           0 :                 s->dsp->vector_fmul_reverse(&win[CELT_OVERLAP], src2,
     202             :                                             ff_celt_window - 8, 128);
     203           0 :                 src1 = src2;
     204           0 :                 s->mdct[0]->mdct(s->mdct[0], b->coeffs + t, win, f->blocks);
     205             :             }
     206             :         }
     207             :     } else {
     208           0 :         int blk_len = OPUS_BLOCK_SIZE(f->size), wlen = OPUS_BLOCK_SIZE(f->size + 1);
     209           0 :         int rwin = blk_len - CELT_OVERLAP, lap_dst = (wlen - blk_len - CELT_OVERLAP) >> 1;
     210           0 :         memset(win, 0, wlen*sizeof(float));
     211           0 :         for (int ch = 0; ch < f->channels; ch++) {
     212           0 :             CeltBlock *b = &f->block[ch];
     213             : 
     214             :             /* Overlap */
     215           0 :             s->dsp->vector_fmul(temp, b->overlap, ff_celt_window, 128);
     216           0 :             memcpy(win + lap_dst, temp, CELT_OVERLAP*sizeof(float));
     217             : 
     218             :             /* Samples, flat top window */
     219           0 :             memcpy(&win[lap_dst + CELT_OVERLAP], b->samples, rwin*sizeof(float));
     220             : 
     221             :             /* Samples, windowed */
     222           0 :             s->dsp->vector_fmul_reverse(temp, b->samples + rwin,
     223             :                                         ff_celt_window - 8, 128);
     224           0 :             memcpy(win + lap_dst + blk_len, temp, CELT_OVERLAP*sizeof(float));
     225             : 
     226           0 :             s->mdct[f->size]->mdct(s->mdct[f->size], b->coeffs, win, 1);
     227             :         }
     228             :     }
     229             : 
     230           0 :     for (int ch = 0; ch < f->channels; ch++) {
     231           0 :         CeltBlock *block = &f->block[ch];
     232           0 :         for (int i = 0; i < CELT_MAX_BANDS; i++) {
     233           0 :             float ener = 0.0f;
     234           0 :             int band_offset = ff_celt_freq_bands[i] << f->size;
     235           0 :             int band_size   = ff_celt_freq_range[i] << f->size;
     236           0 :             float *coeffs   = &block->coeffs[band_offset];
     237             : 
     238           0 :             for (int j = 0; j < band_size; j++)
     239           0 :                 ener += coeffs[j]*coeffs[j];
     240             : 
     241           0 :             block->lin_energy[i] = sqrtf(ener) + FLT_EPSILON;
     242           0 :             ener = 1.0f/block->lin_energy[i];
     243             : 
     244           0 :             for (int j = 0; j < band_size; j++)
     245           0 :                 coeffs[j] *= ener;
     246             : 
     247           0 :             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           0 :             block->energy[i] = FFMAX(block->energy[i], CELT_ENERGY_SILENCE);
     251             :         }
     252             :     }
     253           0 : }
     254             : 
     255           0 : static void celt_enc_tf(CeltFrame *f, OpusRangeCoder *rc)
     256             : {
     257           0 :     int tf_select = 0, diff = 0, tf_changed = 0, tf_select_needed;
     258           0 :     int bits = f->transient ? 2 : 4;
     259             : 
     260           0 :     tf_select_needed = ((f->size && (opus_rc_tell(rc) + bits + 1) <= f->framebits));
     261             : 
     262           0 :     for (int i = f->start_band; i < f->end_band; i++) {
     263           0 :         if ((opus_rc_tell(rc) + bits + tf_select_needed) <= f->framebits) {
     264           0 :             const int tbit = (diff ^ 1) == f->tf_change[i];
     265           0 :             ff_opus_rc_enc_log(rc, tbit, bits);
     266           0 :             diff ^= tbit;
     267           0 :             tf_changed |= diff;
     268             :         }
     269           0 :         bits = f->transient ? 4 : 5;
     270             :     }
     271             : 
     272           0 :     if (tf_select_needed && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
     273           0 :                             ff_celt_tf_select[f->size][f->transient][1][tf_changed]) {
     274           0 :         ff_opus_rc_enc_log(rc, f->tf_select, 1);
     275           0 :         tf_select = f->tf_select;
     276             :     }
     277             : 
     278           0 :     for (int i = f->start_band; i < f->end_band; i++)
     279           0 :         f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
     280           0 : }
     281             : 
     282           0 : static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)
     283             : {
     284           0 :     float gain = f->pf_gain;
     285           0 :     int txval, octave = f->pf_octave, period = f->pf_period, tapset = f->pf_tapset;
     286             : 
     287           0 :     ff_opus_rc_enc_log(rc, f->pfilter, 1);
     288           0 :     if (!f->pfilter)
     289           0 :         return;
     290             : 
     291             :     /* Octave */
     292           0 :     txval = FFMIN(octave, 6);
     293           0 :     ff_opus_rc_enc_uint(rc, txval, 6);
     294           0 :     octave = txval;
     295             :     /* Period */
     296           0 :     txval = av_clip(period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
     297           0 :     ff_opus_rc_put_raw(rc, period, 4 + octave);
     298           0 :     period = txval + (16 << octave) - 1;
     299             :     /* Gain */
     300           0 :     txval = FFMIN(((int)(gain / 0.09375f)) - 1, 7);
     301           0 :     ff_opus_rc_put_raw(rc, txval, 3);
     302           0 :     gain   = 0.09375f * (txval + 1);
     303             :     /* Tapset */
     304           0 :     if ((opus_rc_tell(rc) + 2) <= f->framebits)
     305           0 :         ff_opus_rc_enc_cdf(rc, tapset, ff_celt_model_tapset);
     306             :     else
     307           0 :         tapset = 0;
     308             :     /* Finally create the coeffs */
     309           0 :     for (int i = 0; i < 2; i++) {
     310           0 :         CeltBlock *block = &f->block[i];
     311             : 
     312           0 :         block->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);
     313           0 :         block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
     314           0 :         block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
     315           0 :         block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
     316             :     }
     317             : }
     318             : 
     319           0 : static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f,
     320             :                              float last_energy[][CELT_MAX_BANDS], int intra)
     321             : {
     322           0 :     float alpha, beta, prev[2] = { 0, 0 };
     323           0 :     const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][intra];
     324             : 
     325             :     /* Inter is really just differential coding */
     326           0 :     if (opus_rc_tell(rc) + 3 <= f->framebits)
     327           0 :         ff_opus_rc_enc_log(rc, intra, 3);
     328             :     else
     329           0 :         intra = 0;
     330             : 
     331           0 :     if (intra) {
     332           0 :         alpha = 0.0f;
     333           0 :         beta  = 1.0f - (4915.0f/32768.0f);
     334             :     } else {
     335           0 :         alpha = ff_celt_alpha_coef[f->size];
     336           0 :         beta  = ff_celt_beta_coef[f->size];
     337             :     }
     338             : 
     339           0 :     for (int i = f->start_band; i < f->end_band; i++) {
     340           0 :         for (int ch = 0; ch < f->channels; ch++) {
     341           0 :             CeltBlock *block = &f->block[ch];
     342           0 :             const int left = f->framebits - opus_rc_tell(rc);
     343           0 :             const float last = FFMAX(-9.0f, last_energy[ch][i]);
     344           0 :             float diff = block->energy[i] - prev[ch] - last*alpha;
     345           0 :             int q_en = lrintf(diff);
     346           0 :             if (left >= 15) {
     347           0 :                 ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6);
     348           0 :             } else if (left >= 2) {
     349           0 :                 q_en = av_clip(q_en, -1, 1);
     350           0 :                 ff_opus_rc_enc_cdf(rc, 2*q_en + 3*(q_en < 0), ff_celt_model_energy_small);
     351           0 :             } else if (left >= 1) {
     352           0 :                 q_en = av_clip(q_en, -1, 0);
     353           0 :                 ff_opus_rc_enc_log(rc, (q_en & 1), 1);
     354           0 :             } else q_en = -1;
     355             : 
     356           0 :             block->error_energy[i] = q_en - diff;
     357           0 :             prev[ch] += beta * q_en;
     358             :         }
     359             :     }
     360           0 : }
     361             : 
     362           0 : static void celt_quant_coarse(CeltFrame *f, OpusRangeCoder *rc,
     363             :                               float last_energy[][CELT_MAX_BANDS])
     364             : {
     365             :     uint32_t inter, intra;
     366           0 :     OPUS_RC_CHECKPOINT_SPAWN(rc);
     367             : 
     368           0 :     exp_quant_coarse(rc, f, last_energy, 1);
     369           0 :     intra = OPUS_RC_CHECKPOINT_BITS(rc);
     370             : 
     371           0 :     OPUS_RC_CHECKPOINT_ROLLBACK(rc);
     372             : 
     373           0 :     exp_quant_coarse(rc, f, last_energy, 0);
     374           0 :     inter = OPUS_RC_CHECKPOINT_BITS(rc);
     375             : 
     376           0 :     if (inter > intra) { /* Unlikely */
     377           0 :         OPUS_RC_CHECKPOINT_ROLLBACK(rc);
     378           0 :         exp_quant_coarse(rc, f, last_energy, 1);
     379             :     }
     380           0 : }
     381             : 
     382           0 : static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)
     383             : {
     384           0 :     for (int i = f->start_band; i < f->end_band; i++) {
     385           0 :         if (!f->fine_bits[i])
     386           0 :             continue;
     387           0 :         for (int ch = 0; ch < f->channels; ch++) {
     388           0 :             CeltBlock *block = &f->block[ch];
     389           0 :             int quant, lim = (1 << f->fine_bits[i]);
     390           0 :             float offset, diff = 0.5f - block->error_energy[i];
     391           0 :             quant = av_clip(floor(diff*lim), 0, lim - 1);
     392           0 :             ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]);
     393           0 :             offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f);
     394           0 :             block->error_energy[i] -= offset;
     395             :         }
     396             :     }
     397           0 : }
     398             : 
     399           0 : static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
     400             : {
     401           0 :     for (int priority = 0; priority < 2; priority++) {
     402           0 :         for (int i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) {
     403           0 :             if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
     404           0 :                 continue;
     405           0 :             for (int ch = 0; ch < f->channels; ch++) {
     406           0 :                 CeltBlock *block = &f->block[ch];
     407           0 :                 const float err = block->error_energy[i];
     408           0 :                 const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
     409           0 :                 const int sign = FFABS(err + offset) < FFABS(err - offset);
     410           0 :                 ff_opus_rc_put_raw(rc, sign, 1);
     411           0 :                 block->error_energy[i] -= offset*(1 - 2*sign);
     412             :             }
     413             :         }
     414             :     }
     415           0 : }
     416             : 
     417           0 : static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc,
     418             :                               CeltFrame *f, int index)
     419             : {
     420           0 :     ff_opus_rc_enc_init(rc);
     421             : 
     422           0 :     ff_opus_psy_celt_frame_init(&s->psyctx, f, index);
     423             : 
     424           0 :     celt_frame_setup_input(s, f);
     425             : 
     426           0 :     if (f->silence) {
     427           0 :         if (f->framebits >= 16)
     428           0 :             ff_opus_rc_enc_log(rc, 1, 15); /* Silence (if using explicit singalling) */
     429           0 :         for (int ch = 0; ch < s->channels; ch++)
     430           0 :             memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
     431           0 :         return;
     432             :     }
     433             : 
     434             :     /* Filters */
     435           0 :     celt_apply_preemph_filter(s, f);
     436           0 :     if (f->pfilter) {
     437           0 :         ff_opus_rc_enc_log(rc, 0, 15);
     438           0 :         celt_enc_quant_pfilter(rc, f);
     439             :     }
     440             : 
     441             :     /* Transform */
     442           0 :     celt_frame_mdct(s, f);
     443             : 
     444             :     /* Need to handle transient/non-transient switches at any point during analysis */
     445           0 :     while (ff_opus_psy_celt_frame_process(&s->psyctx, f, index))
     446           0 :         celt_frame_mdct(s, f);
     447             : 
     448           0 :     ff_opus_rc_enc_init(rc);
     449             : 
     450             :     /* Silence */
     451           0 :     ff_opus_rc_enc_log(rc, 0, 15);
     452             : 
     453             :     /* Pitch filter */
     454           0 :     if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits)
     455           0 :         celt_enc_quant_pfilter(rc, f);
     456             : 
     457             :     /* Transient flag */
     458           0 :     if (f->size && opus_rc_tell(rc) + 3 <= f->framebits)
     459           0 :         ff_opus_rc_enc_log(rc, f->transient, 3);
     460             : 
     461             :     /* Main encoding */
     462           0 :     celt_quant_coarse  (f, rc, s->last_quantized_energy);
     463           0 :     celt_enc_tf        (f, rc);
     464           0 :     ff_celt_bitalloc   (f, rc, 1);
     465           0 :     celt_quant_fine    (f, rc);
     466           0 :     ff_celt_quant_bands(f, rc);
     467             : 
     468             :     /* Anticollapse bit */
     469           0 :     if (f->anticollapse_needed)
     470           0 :         ff_opus_rc_put_raw(rc, f->anticollapse, 1);
     471             : 
     472             :     /* Final per-band energy adjustments from leftover bits */
     473           0 :     celt_quant_final(s, rc, f);
     474             : 
     475           0 :     for (int ch = 0; ch < f->channels; ch++) {
     476           0 :         CeltBlock *block = &f->block[ch];
     477           0 :         for (int i = 0; i < CELT_MAX_BANDS; i++)
     478           0 :             s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i];
     479             :     }
     480             : }
     481             : 
     482           0 : static inline int write_opuslacing(uint8_t *dst, int v)
     483             : {
     484           0 :     dst[0] = FFMIN(v - FFALIGN(v - 255, 4), v);
     485           0 :     dst[1] = v - dst[0] >> 2;
     486           0 :     return 1 + (v >= 252);
     487             : }
     488             : 
     489           0 : static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
     490             : {
     491             :     int offset, fsize_needed;
     492             : 
     493             :     /* Write toc */
     494           0 :     opus_gen_toc(s, avpkt->data, &offset, &fsize_needed);
     495             : 
     496             :     /* Frame sizes if needed */
     497           0 :     if (fsize_needed) {
     498           0 :         for (int i = 0; i < s->packet.frames - 1; i++) {
     499           0 :             offset += write_opuslacing(avpkt->data + offset,
     500           0 :                                        s->frame[i].framebits >> 3);
     501             :         }
     502             :     }
     503             : 
     504             :     /* Packets */
     505           0 :     for (int i = 0; i < s->packet.frames; i++) {
     506           0 :         ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset,
     507           0 :                            s->frame[i].framebits >> 3);
     508           0 :         offset += s->frame[i].framebits >> 3;
     509             :     }
     510             : 
     511           0 :     avpkt->size = offset;
     512           0 : }
     513             : 
     514             : /* Used as overlap for the first frame and padding for the last encoded packet */
     515           0 : static AVFrame *spawn_empty_frame(OpusEncContext *s)
     516             : {
     517           0 :     AVFrame *f = av_frame_alloc();
     518           0 :     if (!f)
     519           0 :         return NULL;
     520           0 :     f->format         = s->avctx->sample_fmt;
     521           0 :     f->nb_samples     = s->avctx->frame_size;
     522           0 :     f->channel_layout = s->avctx->channel_layout;
     523           0 :     if (av_frame_get_buffer(f, 4)) {
     524           0 :         av_frame_free(&f);
     525           0 :         return NULL;
     526             :     }
     527           0 :     for (int i = 0; i < s->channels; i++) {
     528           0 :         size_t bps = av_get_bytes_per_sample(f->format);
     529           0 :         memset(f->extended_data[i], 0, bps*f->nb_samples);
     530             :     }
     531           0 :     return f;
     532             : }
     533             : 
     534           0 : static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     535             :                              const AVFrame *frame, int *got_packet_ptr)
     536             : {
     537           0 :     OpusEncContext *s = avctx->priv_data;
     538           0 :     int ret, frame_size, alloc_size = 0;
     539             : 
     540           0 :     if (frame) { /* Add new frame to queue */
     541           0 :         if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
     542           0 :             return ret;
     543           0 :         ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame));
     544             :     } else {
     545           0 :         ff_opus_psy_signal_eof(&s->psyctx);
     546           0 :         if (!s->afq.remaining_samples)
     547           0 :             return 0; /* We've been flushed and there's nothing left to encode */
     548             :     }
     549             : 
     550             :     /* Run the psychoacoustic system */
     551           0 :     if (ff_opus_psy_process(&s->psyctx, &s->packet))
     552           0 :         return 0;
     553             : 
     554           0 :     frame_size = OPUS_BLOCK_SIZE(s->packet.framesize);
     555             : 
     556           0 :     if (!frame) {
     557             :         /* This can go negative, that's not a problem, we only pad if positive */
     558           0 :         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           0 :         for (int i = 0; i < pad_empty; i++) {
     564           0 :             AVFrame *empty = spawn_empty_frame(s);
     565           0 :             if (!empty)
     566           0 :                 return AVERROR(ENOMEM);
     567           0 :             ff_bufqueue_add(avctx, &s->bufqueue, empty);
     568             :         }
     569             :     }
     570             : 
     571           0 :     for (int i = 0; i < s->packet.frames; i++) {
     572           0 :         celt_encode_frame(s, &s->rc[i], &s->frame[i], i);
     573           0 :         alloc_size += s->frame[i].framebits >> 3;
     574             :     }
     575             : 
     576             :     /* Worst case toc + the frame lengths if needed */
     577           0 :     alloc_size += 2 + s->packet.frames*2;
     578             : 
     579           0 :     if ((ret = ff_alloc_packet2(avctx, avpkt, alloc_size, 0)) < 0)
     580           0 :         return ret;
     581             : 
     582             :     /* Assemble packet */
     583           0 :     opus_packet_assembler(s, avpkt);
     584             : 
     585             :     /* Update the psychoacoustic system */
     586           0 :     ff_opus_psy_postencode_update(&s->psyctx, s->frame, s->rc);
     587             : 
     588             :     /* Remove samples from queue and skip if needed */
     589           0 :     ff_af_queue_remove(&s->afq, s->packet.frames*frame_size, &avpkt->pts, &avpkt->duration);
     590           0 :     if (s->packet.frames*frame_size > avpkt->duration) {
     591           0 :         uint8_t *side = av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
     592           0 :         if (!side)
     593           0 :             return AVERROR(ENOMEM);
     594           0 :         AV_WL32(&side[4], s->packet.frames*frame_size - avpkt->duration + 120);
     595             :     }
     596             : 
     597           0 :     *got_packet_ptr = 1;
     598             : 
     599           0 :     return 0;
     600             : }
     601             : 
     602           0 : static av_cold int opus_encode_end(AVCodecContext *avctx)
     603             : {
     604           0 :     OpusEncContext *s = avctx->priv_data;
     605             : 
     606           0 :     for (int i = 0; i < CELT_BLOCK_NB; i++)
     607           0 :         ff_mdct15_uninit(&s->mdct[i]);
     608             : 
     609           0 :     ff_celt_pvq_uninit(&s->pvq);
     610           0 :     av_freep(&s->dsp);
     611           0 :     av_freep(&s->frame);
     612           0 :     av_freep(&s->rc);
     613           0 :     ff_af_queue_close(&s->afq);
     614           0 :     ff_opus_psy_end(&s->psyctx);
     615           0 :     ff_bufqueue_discard_all(&s->bufqueue);
     616           0 :     av_freep(&avctx->extradata);
     617             : 
     618           0 :     return 0;
     619             : }
     620             : 
     621           0 : static av_cold int opus_encode_init(AVCodecContext *avctx)
     622             : {
     623             :     int ret, max_frames;
     624           0 :     OpusEncContext *s = avctx->priv_data;
     625             : 
     626           0 :     s->avctx = avctx;
     627           0 :     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           0 :     avctx->frame_size = 120;
     635             :     /* Initial padding will change if SILK is ever supported */
     636           0 :     avctx->initial_padding = 120;
     637             : 
     638           0 :     if (!avctx->bit_rate) {
     639           0 :         int coupled = ff_opus_default_coupled_streams[s->channels - 1];
     640           0 :         avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000);
     641           0 :     } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) {
     642           0 :         int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels);
     643           0 :         av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %"PRId64" kbps, clipping to %"PRId64" kbps\n",
     644           0 :                avctx->bit_rate/1000, clipped_rate/1000);
     645           0 :         avctx->bit_rate = clipped_rate;
     646             :     }
     647             : 
     648             :     /* Extradata */
     649           0 :     avctx->extradata_size = 19;
     650           0 :     avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
     651           0 :     if (!avctx->extradata)
     652           0 :         return AVERROR(ENOMEM);
     653           0 :     opus_write_extradata(avctx);
     654             : 
     655           0 :     ff_af_queue_init(avctx, &s->afq);
     656             : 
     657           0 :     if ((ret = ff_celt_pvq_init(&s->pvq, 1)) < 0)
     658           0 :         return ret;
     659             : 
     660           0 :     if (!(s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT)))
     661           0 :         return AVERROR(ENOMEM);
     662             : 
     663             :     /* I have no idea why a base scaling factor of 68 works, could be the twiddles */
     664           0 :     for (int i = 0; i < CELT_BLOCK_NB; i++)
     665           0 :         if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
     666           0 :             return AVERROR(ENOMEM);
     667             : 
     668             :     /* Zero out previous energy (matters for inter first frame) */
     669           0 :     for (int ch = 0; ch < s->channels; ch++)
     670           0 :         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           0 :     ff_bufqueue_add(avctx, &s->bufqueue, spawn_empty_frame(s));
     674           0 :     if (!ff_bufqueue_peek(&s->bufqueue, 0))
     675           0 :         return AVERROR(ENOMEM);
     676             : 
     677           0 :     if ((ret = ff_opus_psy_init(&s->psyctx, s->avctx, &s->bufqueue, &s->options)))
     678           0 :         return ret;
     679             : 
     680             :     /* Frame structs and range coder buffers */
     681           0 :     max_frames = ceilf(FFMIN(s->options.max_delay_ms, 120.0f)/2.5f);
     682           0 :     s->frame = av_malloc(max_frames*sizeof(CeltFrame));
     683           0 :     if (!s->frame)
     684           0 :         return AVERROR(ENOMEM);
     685           0 :     s->rc = av_malloc(max_frames*sizeof(OpusRangeCoder));
     686           0 :     if (!s->rc)
     687           0 :         return AVERROR(ENOMEM);
     688             : 
     689           0 :     for (int i = 0; i < max_frames; i++) {
     690           0 :         s->frame[i].dsp = s->dsp;
     691           0 :         s->frame[i].avctx = s->avctx;
     692           0 :         s->frame[i].seed = 0;
     693           0 :         s->frame[i].pvq = s->pvq;
     694           0 :         s->frame[i].apply_phase_inv = 1;
     695           0 :         s->frame[i].block[0].emph_coeff = s->frame[i].block[1].emph_coeff = 0.0f;
     696             :     }
     697             : 
     698           0 :     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             : };

Generated by: LCOV version 1.13