diff --git a/configure b/configure index a7cd3a2244..2f761c39c2 100755 --- a/configure +++ b/configure @@ -2492,6 +2492,7 @@ nuv_decoder_select="idctdsp lzo" on2avc_decoder_select="mdct" opus_decoder_deps="swresample" opus_decoder_select="mdct15" +opus_encoder_select="audio_frame_queue audiodsp mdct15" png_decoder_select="zlib" png_encoder_select="llvidencdsp zlib" prores_decoder_select="blockdsp idctdsp" diff --git a/libavcodec/Makefile b/libavcodec/Makefile index e1f83a0404..a1ce264f25 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -444,6 +444,7 @@ OBJS-$(CONFIG_NUV_DECODER) += nuv.o rtjpeg.o OBJS-$(CONFIG_ON2AVC_DECODER) += on2avc.o on2avcdata.o OBJS-$(CONFIG_OPUS_DECODER) += opusdec.o opus.o opus_celt.o opus_rc.o \ opus_pvq.o opus_silk.o opustab.o vorbis_data.o +OBJS-$(CONFIG_OPUS_ENCODER) += opusenc.o opus_rc.o opustab.o opus_pvq.o OBJS-$(CONFIG_PAF_AUDIO_DECODER) += pafaudio.o OBJS-$(CONFIG_PAF_VIDEO_DECODER) += pafvideo.o OBJS-$(CONFIG_PAM_DECODER) += pnmdec.o pnm.o diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c index 368012992b..f12a54df50 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -449,7 +449,7 @@ void avcodec_register_all(void) REGISTER_DECODER(MPC8, mpc8); REGISTER_ENCDEC (NELLYMOSER, nellymoser); REGISTER_DECODER(ON2AVC, on2avc); - REGISTER_DECODER(OPUS, opus); + REGISTER_ENCDEC (OPUS, opus); REGISTER_DECODER(PAF_AUDIO, paf_audio); REGISTER_DECODER(QCELP, qcelp); REGISTER_DECODER(QDM2, qdm2); diff --git a/libavcodec/opus_celt.h b/libavcodec/opus_celt.h index 7b46a5116b..23c20891cd 100644 --- a/libavcodec/opus_celt.h +++ b/libavcodec/opus_celt.h @@ -61,14 +61,23 @@ enum CeltBlockSize { typedef struct CeltBlock { float energy[CELT_MAX_BANDS]; + float lin_energy[CELT_MAX_BANDS]; + float error_energy[CELT_MAX_BANDS]; float prev_energy[2][CELT_MAX_BANDS]; uint8_t collapse_masks[CELT_MAX_BANDS]; + int band_bins[CELT_MAX_BANDS]; /* MDCT bins per band */ + float *band_coeffs[CELT_MAX_BANDS]; + /* buffer for mdct output + postfilter */ DECLARE_ALIGNED(32, float, buf)[2048]; DECLARE_ALIGNED(32, float, coeffs)[CELT_MAX_FRAME_SIZE]; + /* Used by the encoder */ + DECLARE_ALIGNED(32, float, overlap)[120]; + DECLARE_ALIGNED(32, float, samples)[CELT_MAX_FRAME_SIZE]; + /* postfilter parameters */ int pf_period_new; float pf_gains_new[3]; @@ -94,6 +103,12 @@ struct CeltFrame { int end_band; int coded_bands; int transient; + int intra; + int pfilter; + int skip_band_floor; + int tf_select; + int alloc_trim; + int alloc_boost[CELT_MAX_BANDS]; int blocks; /* number of iMDCT blocks in the frame, depends on transient */ int blocksize; /* size of each block */ int silence; /* Frame is filled with silence */ @@ -109,6 +124,7 @@ struct CeltFrame { int framebits; int remaining; int remaining2; + int caps [CELT_MAX_BANDS]; int fine_bits [CELT_MAX_BANDS]; int fine_priority[CELT_MAX_BANDS]; int pulses [CELT_MAX_BANDS]; diff --git a/libavcodec/opus_pvq.c b/libavcodec/opus_pvq.c index ddc5fc2895..a2f5088aa9 100644 --- a/libavcodec/opus_pvq.c +++ b/libavcodec/opus_pvq.c @@ -1,7 +1,7 @@ /* * Copyright (c) 2012 Andrew D'Addesio * Copyright (c) 2013-2014 Mozilla Corporation - * Copyright (c) 2016 Rostislav Pehlivanov + * Copyright (c) 2017 Rostislav Pehlivanov * * This file is part of FFmpeg. * @@ -78,8 +78,8 @@ static inline void celt_normalize_residual(const int * av_restrict iy, float * a X[i] = g * iy[i]; } -static void celt_exp_rotation1(float *X, uint32_t len, uint32_t stride, - float c, float s) +static void celt_exp_rotation_impl(float *X, uint32_t len, uint32_t stride, + float c, float s) { float *Xptr; int i; @@ -105,7 +105,7 @@ static void celt_exp_rotation1(float *X, uint32_t len, uint32_t stride, static inline void celt_exp_rotation(float *X, uint32_t len, uint32_t stride, uint32_t K, - enum CeltSpread spread) + enum CeltSpread spread, const int encode) { uint32_t stride2 = 0; float c, s; @@ -133,9 +133,15 @@ static inline void celt_exp_rotation(float *X, uint32_t len, extract_collapse_mask().*/ len /= stride; for (i = 0; i < stride; i++) { - if (stride2) - celt_exp_rotation1(X + i * len, len, stride2, s, c); - celt_exp_rotation1(X + i * len, len, 1, c, s); + if (encode) { + celt_exp_rotation_impl(X + i * len, len, 1, c, -s); + if (stride2) + celt_exp_rotation_impl(X + i * len, len, stride2, s, -c); + } else { + if (stride2) + celt_exp_rotation_impl(X + i * len, len, stride2, s, c); + celt_exp_rotation_impl(X + i * len, len, 1, c, s); + } } } @@ -270,6 +276,18 @@ static inline int celt_compute_qn(int N, int b, int offset, int pulse_cap, return qn; } +/* Convert the quantized vector to an index */ +static inline uint32_t celt_icwrsi(uint32_t N, const int *y) +{ + int i, idx = 0, sum = 0; + for (i = N - 1; i >= 0; i--) { + const uint32_t i_s = CELT_PVQ_U(N - i, sum + FFABS(y[i]) + 1); + idx += CELT_PVQ_U(N - i, sum) + (y[i] < 0)*i_s; + sum += FFABS(y[i]); + } + return idx; +} + // this code was adapted from libopus static inline uint64_t celt_cwrsi(uint32_t N, uint32_t K, uint32_t i, int *y) { @@ -356,12 +374,74 @@ static inline uint64_t celt_cwrsi(uint32_t N, uint32_t K, uint32_t i, int *y) return norm; } +static inline void celt_encode_pulses(OpusRangeCoder *rc, int *y, uint32_t N, uint32_t K) +{ + ff_opus_rc_enc_uint(rc, celt_icwrsi(N, y), CELT_PVQ_V(N, K)); +} + static inline float celt_decode_pulses(OpusRangeCoder *rc, int *y, uint32_t N, uint32_t K) { const uint32_t idx = ff_opus_rc_dec_uint(rc, CELT_PVQ_V(N, K)); return celt_cwrsi(N, K, idx, y); } +/* + * Faster than libopus's search, operates entirely in the signed domain. + * Slightly worse/better depending on N, K and the input vector. + */ +static void celt_pvq_search(float *X, int *y, int K, int N) +{ + int i; + float res = 0.0f, y_norm = 0.0f, xy_norm = 0.0f; + + for (i = 0; i < N; i++) + res += FFABS(X[i]); + + res = K/res; + + for (i = 0; i < N; i++) { + y[i] = lrintf(res*X[i]); + y_norm += y[i]*y[i]; + xy_norm += y[i]*X[i]; + K -= FFABS(y[i]); + } + + while (K) { + int max_idx = 0, phase = FFSIGN(K); + float max_den = 1.0f, max_num = 0.0f; + y_norm += 1.0f; + + for (i = 0; i < N; i++) { + float xy_new = xy_norm + 1*phase*FFABS(X[i]); + float y_new = y_norm + 2*phase*FFABS(y[i]); + xy_new = xy_new * xy_new; + if ((max_den*xy_new) > (y_new*max_num)) { + max_den = y_new; + max_num = xy_new; + max_idx = i; + } + } + + K -= phase; + + phase *= FFSIGN(X[max_idx]); + xy_norm += 1*phase*X[max_idx]; + y_norm += 2*phase*y[max_idx]; + y[max_idx] += phase; + } +} + +static uint32_t celt_alg_quant(OpusRangeCoder *rc, float *X, uint32_t N, uint32_t K, + enum CeltSpread spread, uint32_t blocks, float gain) +{ + int y[176]; + + celt_exp_rotation(X, N, blocks, K, spread, 1); + celt_pvq_search(X, y, K, N); + celt_encode_pulses(rc, y, N, K); + return celt_extract_collapse_mask(y, N, blocks); +} + /** Decode pulse vector and combine the result with the pitch vector to produce the final normalised signal in the current band. */ static uint32_t celt_alg_unquant(OpusRangeCoder *rc, float *X, uint32_t N, uint32_t K, @@ -371,7 +451,7 @@ static uint32_t celt_alg_unquant(OpusRangeCoder *rc, float *X, uint32_t N, uint3 gain /= sqrtf(celt_decode_pulses(rc, y, N, K)); celt_normalize_residual(y, X, N, gain); - celt_exp_rotation(X, N, blocks, K, spread); + celt_exp_rotation(X, N, blocks, K, spread, 0); return celt_extract_collapse_mask(y, N, blocks); } @@ -725,5 +805,353 @@ uint32_t ff_celt_decode_band(CeltFrame *f, OpusRangeCoder *rc, const int band, } cm = av_mod_uintp2(cm, blocks); } + + return cm; +} + +/* This has to be, AND MUST BE done by the psychoacoustic system, this has a very + * big impact on the entire quantization and especially huge on transients */ +static int celt_calc_theta(const float *X, const float *Y, int coupling, int N) +{ + int j; + float e[2] = { 0.0f, 0.0f }; + for (j = 0; j < N; j++) { + if (coupling) { /* Coupling case */ + e[0] += (X[j] + Y[j])*(X[j] + Y[j]); + e[1] += (X[j] - Y[j])*(X[j] - Y[j]); + } else { + e[0] += X[j]*X[j]; + e[1] += Y[j]*Y[j]; + } + } + return lrintf(32768.0f*atan2f(sqrtf(e[1]), sqrtf(e[0]))/M_PI); +} + +static void celt_stereo_is_decouple(float *X, float *Y, float e_l, float e_r, int N) +{ + int i; + const float energy_n = 1.0f/(sqrtf(e_l*e_l + e_r*e_r) + FLT_EPSILON); + e_l *= energy_n; + e_r *= energy_n; + for (i = 0; i < N; i++) + X[i] = e_l*X[i] + e_r*Y[i]; +} + +static void celt_stereo_ms_decouple(float *X, float *Y, int N) +{ + int i; + const float decouple_norm = 1.0f/sqrtf(2.0f); + for (i = 0; i < N; i++) { + const float Xret = X[i]; + X[i] = (X[i] + Y[i])*decouple_norm; + Y[i] = (Y[i] - Xret)*decouple_norm; + } +} + +uint32_t ff_celt_encode_band(CeltFrame *f, OpusRangeCoder *rc, const int band, + float *X, float *Y, int N, int b, uint32_t blocks, + float *lowband, int duration, float *lowband_out, int level, + float gain, float *lowband_scratch, int fill) +{ + const uint8_t *cache; + int dualstereo, split; + int imid = 0, iside = 0; + //uint32_t N0 = N; + int N_B; + //int N_B0; + int B0 = blocks; + int time_divide = 0; + int recombine = 0; + int inv = 0; + float mid = 0, side = 0; + int longblocks = (B0 == 1); + uint32_t cm = 0; + + //N_B0 = N_B = N / blocks; + split = dualstereo = (Y != NULL); + + if (N == 1) { + /* special case for one sample - the decoder's output will be +- 1.0f!!! */ + int i; + float *x = X; + for (i = 0; i <= dualstereo; i++) { + if (f->remaining2 >= 1<<3) { + ff_opus_rc_put_raw(rc, x[0] < 0, 1); + f->remaining2 -= 1 << 3; + b -= 1 << 3; + } + x = Y; + } + if (lowband_out) + lowband_out[0] = X[0]; + return 1; + } + + if (!dualstereo && level == 0) { + int tf_change = f->tf_change[band]; + int k; + if (tf_change > 0) + recombine = tf_change; + /* Band recombining to increase frequency resolution */ + + if (lowband && + (recombine || ((N_B & 1) == 0 && tf_change < 0) || B0 > 1)) { + int j; + for (j = 0; j < N; j++) + lowband_scratch[j] = lowband[j]; + lowband = lowband_scratch; + } + + for (k = 0; k < recombine; k++) { + celt_haar1(X, N >> k, 1 << k); + fill = ff_celt_bit_interleave[fill & 0xF] | ff_celt_bit_interleave[fill >> 4] << 2; + } + blocks >>= recombine; + N_B <<= recombine; + + /* Increasing the time resolution */ + while ((N_B & 1) == 0 && tf_change < 0) { + celt_haar1(X, N_B, blocks); + fill |= fill << blocks; + blocks <<= 1; + N_B >>= 1; + time_divide++; + tf_change++; + } + B0 = blocks; + //N_B0 = N_B; + + /* Reorganize the samples in time order instead of frequency order */ + if (B0 > 1) + celt_deinterleave_hadamard(f->scratch, X, N_B >> recombine, + B0 << recombine, longblocks); + } + + /* If we need 1.5 more bit than we can produce, split the band in two. */ + cache = ff_celt_cache_bits + + ff_celt_cache_index[(duration + 1) * CELT_MAX_BANDS + band]; + if (!dualstereo && duration >= 0 && b > cache[cache[0]] + 12 && N > 2) { + N >>= 1; + Y = X + N; + split = 1; + duration -= 1; + if (blocks == 1) + fill = (fill & 1) | (fill << 1); + blocks = (blocks + 1) >> 1; + } + + if (split) { + int qn; + int itheta = celt_calc_theta(X, Y, dualstereo, N); + int mbits, sbits, delta; + int qalloc; + int pulse_cap; + int offset; + int orig_fill; + int tell; + + /* Decide on the resolution to give to the split parameter theta */ + pulse_cap = ff_celt_log_freq_range[band] + duration * 8; + offset = (pulse_cap >> 1) - (dualstereo && N == 2 ? CELT_QTHETA_OFFSET_TWOPHASE : + CELT_QTHETA_OFFSET); + qn = (dualstereo && band >= f->intensity_stereo) ? 1 : + celt_compute_qn(N, b, offset, pulse_cap, dualstereo); + tell = opus_rc_tell_frac(rc); + + if (qn != 1) { + + itheta = (itheta*qn + 8192) >> 14; + + /* Entropy coding of the angle. We use a uniform pdf for the + * time split, a step for stereo, and a triangular one for the rest. */ + if (dualstereo && N > 2) + ff_opus_rc_enc_uint_step(rc, itheta, qn / 2); + else if (dualstereo || B0 > 1) + ff_opus_rc_enc_uint(rc, itheta, qn + 1); + else + ff_opus_rc_enc_uint_tri(rc, itheta, qn); + itheta = itheta * 16384 / qn; + + if (dualstereo) { + if (itheta == 0) + celt_stereo_is_decouple(X, Y, f->block[0].lin_energy[band], f->block[1].lin_energy[band], N); + else + celt_stereo_ms_decouple(X, Y, N); + } + } else if (dualstereo) { + inv = itheta > 8192; + if (inv) + { + int j; + for (j=0;jblock[0].lin_energy[band], f->block[1].lin_energy[band], N); + + if (b > 2 << 3 && f->remaining2 > 2 << 3) { + ff_opus_rc_enc_log(rc, inv, 2); + } else { + inv = 0; + } + + itheta = 0; + } + qalloc = opus_rc_tell_frac(rc) - tell; + b -= qalloc; + + orig_fill = fill; + if (itheta == 0) { + imid = 32767; + iside = 0; + fill = av_mod_uintp2(fill, blocks); + delta = -16384; + } else if (itheta == 16384) { + imid = 0; + iside = 32767; + fill &= ((1 << blocks) - 1) << blocks; + delta = 16384; + } else { + imid = celt_cos(itheta); + iside = celt_cos(16384-itheta); + /* This is the mid vs side allocation that minimizes squared error + in that band. */ + delta = ROUND_MUL16((N - 1) << 7, celt_log2tan(iside, imid)); + } + + mid = imid / 32768.0f; + side = iside / 32768.0f; + + /* This is a special case for N=2 that only works for stereo and takes + advantage of the fact that mid and side are orthogonal to encode + the side with just one bit. */ + if (N == 2 && dualstereo) { + int c; + int sign = 0; + float tmp; + float *x2, *y2; + mbits = b; + /* Only need one bit for the side */ + sbits = (itheta != 0 && itheta != 16384) ? 1 << 3 : 0; + mbits -= sbits; + c = (itheta > 8192); + f->remaining2 -= qalloc+sbits; + + x2 = c ? Y : X; + y2 = c ? X : Y; + if (sbits) { + sign = x2[0]*y2[1] - x2[1]*y2[0] < 0; + ff_opus_rc_put_raw(rc, sign, 1); + } + sign = 1 - 2 * sign; + /* We use orig_fill here because we want to fold the side, but if + itheta==16384, we'll have cleared the low bits of fill. */ + cm = ff_celt_encode_band(f, rc, band, x2, NULL, N, mbits, blocks, + lowband, duration, lowband_out, level, gain, + lowband_scratch, orig_fill); + /* We don't split N=2 bands, so cm is either 1 or 0 (for a fold-collapse), + and there's no need to worry about mixing with the other channel. */ + y2[0] = -sign * x2[1]; + y2[1] = sign * x2[0]; + X[0] *= mid; + X[1] *= mid; + Y[0] *= side; + Y[1] *= side; + tmp = X[0]; + X[0] = tmp - Y[0]; + Y[0] = tmp + Y[0]; + tmp = X[1]; + X[1] = tmp - Y[1]; + Y[1] = tmp + Y[1]; + } else { + /* "Normal" split code */ + float *next_lowband2 = NULL; + float *next_lowband_out1 = NULL; + int next_level = 0; + int rebalance; + + /* Give more bits to low-energy MDCTs than they would + * otherwise deserve */ + if (B0 > 1 && !dualstereo && (itheta & 0x3fff)) { + if (itheta > 8192) + /* Rough approximation for pre-echo masking */ + delta -= delta >> (4 - duration); + else + /* Corresponds to a forward-masking slope of + * 1.5 dB per 10 ms */ + delta = FFMIN(0, delta + (N << 3 >> (5 - duration))); + } + mbits = av_clip((b - delta) / 2, 0, b); + sbits = b - mbits; + f->remaining2 -= qalloc; + + if (lowband && !dualstereo) + next_lowband2 = lowband + N; /* >32-bit split case */ + + /* Only stereo needs to pass on lowband_out. + * Otherwise, it's handled at the end */ + if (dualstereo) + next_lowband_out1 = lowband_out; + else + next_level = level + 1; + + rebalance = f->remaining2; + if (mbits >= sbits) { + /* In stereo mode, we do not apply a scaling to the mid + * because we need the normalized mid for folding later */ + cm = ff_celt_encode_band(f, rc, band, X, NULL, N, mbits, blocks, + lowband, duration, next_lowband_out1, + next_level, dualstereo ? 1.0f : (gain * mid), + lowband_scratch, fill); + + rebalance = mbits - (rebalance - f->remaining2); + if (rebalance > 3 << 3 && itheta != 0) + sbits += rebalance - (3 << 3); + + /* For a stereo split, the high bits of fill are always zero, + * so no folding will be done to the side. */ + cm |= ff_celt_encode_band(f, rc, band, Y, NULL, N, sbits, blocks, + next_lowband2, duration, NULL, + next_level, gain * side, NULL, + fill >> blocks) << ((B0 >> 1) & (dualstereo - 1)); + } else { + /* For a stereo split, the high bits of fill are always zero, + * so no folding will be done to the side. */ + cm = ff_celt_encode_band(f, rc, band, Y, NULL, N, sbits, blocks, + next_lowband2, duration, NULL, + next_level, gain * side, NULL, + fill >> blocks) << ((B0 >> 1) & (dualstereo - 1)); + + rebalance = sbits - (rebalance - f->remaining2); + if (rebalance > 3 << 3 && itheta != 16384) + mbits += rebalance - (3 << 3); + + /* In stereo mode, we do not apply a scaling to the mid because + * we need the normalized mid for folding later */ + cm |= ff_celt_encode_band(f, rc, band, X, NULL, N, mbits, blocks, + lowband, duration, next_lowband_out1, + next_level, dualstereo ? 1.0f : (gain * mid), + lowband_scratch, fill); + } + } + } else { + /* This is the basic no-split case */ + uint32_t q = celt_bits2pulses(cache, b); + uint32_t curr_bits = celt_pulses2bits(cache, q); + f->remaining2 -= curr_bits; + + /* Ensures we can never bust the budget */ + while (f->remaining2 < 0 && q > 0) { + f->remaining2 += curr_bits; + curr_bits = celt_pulses2bits(cache, --q); + f->remaining2 -= curr_bits; + } + + if (q != 0) { + /* Finally do the actual quantization */ + cm = celt_alg_quant(rc, X, N, (q < 8) ? q : (8 + (q & 7)) << ((q >> 3) - 1), + f->spread, blocks, gain); + } + } + return cm; } diff --git a/libavcodec/opus_pvq.h b/libavcodec/opus_pvq.h index 0354a3c960..d414b47a42 100644 --- a/libavcodec/opus_pvq.h +++ b/libavcodec/opus_pvq.h @@ -32,4 +32,10 @@ uint32_t ff_celt_decode_band(CeltFrame *f, OpusRangeCoder *rc, const int band, float *lowband, int duration, float *lowband_out, int level, float gain, float *lowband_scratch, int fill); +/* Encodes a band using PVQ */ +uint32_t ff_celt_encode_band(CeltFrame *f, OpusRangeCoder *rc, const int band, + float *X, float *Y, int N, int b, uint32_t blocks, + float *lowband, int duration, float *lowband_out, int level, + float gain, float *lowband_scratch, int fill); + #endif /* AVCODEC_OPUS_PVQ_H */ diff --git a/libavcodec/opusenc.c b/libavcodec/opusenc.c new file mode 100644 index 0000000000..985b41ccc0 --- /dev/null +++ b/libavcodec/opusenc.c @@ -0,0 +1,1130 @@ +/* + * Opus encoder + * Copyright (c) 2017 Rostislav Pehlivanov + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "opus_celt.h" +#include "opus_pvq.h" +#include "opustab.h" + +#include "libavutil/float_dsp.h" +#include "libavutil/opt.h" +#include "internal.h" +#include "bytestream.h" +#include "audio_frame_queue.h" + +/* Determines the maximum delay the psychoacoustic system will use for lookahead */ +#define FF_BUFQUEUE_SIZE 145 +#include "libavfilter/bufferqueue.h" + +#define OPUS_MAX_LOOKAHEAD ((FF_BUFQUEUE_SIZE - 1)*2.5f) + +#define OPUS_MAX_CHANNELS 2 + +/* 120 ms / 2.5 ms = 48 frames (extremely improbable, but the encoder'll work) */ +#define OPUS_MAX_FRAMES_PER_PACKET 48 + +#define OPUS_BLOCK_SIZE(x) (2 * 15 * (1 << (x + 2))) + +#define OPUS_SAMPLES_TO_BLOCK_SIZE(x) (ff_log2(x / (2 * 15)) - 2) + +typedef struct OpusEncOptions { + float max_delay_ms; +} OpusEncOptions; + +typedef struct OpusEncContext { + AVClass *av_class; + OpusEncOptions options; + AVCodecContext *avctx; + AudioFrameQueue afq; + AVFloatDSPContext *dsp; + MDCT15Context *mdct[CELT_BLOCK_NB]; + struct FFBufQueue bufqueue; + + enum OpusMode mode; + enum OpusBandwidth bandwidth; + int pkt_framesize; + int pkt_frames; + + int channels; + + CeltFrame *frame; + OpusRangeCoder *rc; + + /* Actual energy the decoder will have */ + float last_quantized_energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]; + + DECLARE_ALIGNED(32, float, scratch)[2048]; +} OpusEncContext; + +static void opus_write_extradata(AVCodecContext *avctx) +{ + uint8_t *bs = avctx->extradata; + + bytestream_put_buffer(&bs, "OpusHead", 8); + bytestream_put_byte (&bs, 0x1); + bytestream_put_byte (&bs, avctx->channels); + bytestream_put_le16 (&bs, avctx->initial_padding); + bytestream_put_le32 (&bs, avctx->sample_rate); + bytestream_put_le16 (&bs, 0x0); + bytestream_put_byte (&bs, 0x0); /* Default layout */ +} + +static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed) +{ + int i, tmp = 0x0, extended_toc = 0; + static const int toc_cfg[][OPUS_MODE_NB][OPUS_BANDWITH_NB] = { + /* Silk Hybrid Celt Layer */ + /* NB MB WB SWB FB NB MB WB SWB FB NB MB WB SWB FB Bandwidth */ + { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 17, 0, 21, 25, 29 } }, /* 2.5 ms */ + { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 18, 0, 22, 26, 30 } }, /* 5 ms */ + { { 1, 5, 9, 0, 0 }, { 0, 0, 0, 13, 15 }, { 19, 0, 23, 27, 31 } }, /* 10 ms */ + { { 2, 6, 10, 0, 0 }, { 0, 0, 0, 14, 16 }, { 20, 0, 24, 28, 32 } }, /* 20 ms */ + { { 3, 7, 11, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }, /* 40 ms */ + { { 4, 8, 12, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }, /* 60 ms */ + }; + int cfg = toc_cfg[s->pkt_framesize][s->mode][s->bandwidth]; + *fsize_needed = 0; + if (!cfg) + return 1; + if (s->pkt_frames == 2) { /* 2 packets */ + if (s->frame[0].framebits == s->frame[1].framebits) { /* same size */ + tmp = 0x1; + } else { /* different size */ + tmp = 0x2; + *fsize_needed = 1; /* put frame sizes in the packet */ + } + } else if (s->pkt_frames > 2) { + tmp = 0x3; + extended_toc = 1; + } + tmp |= (s->channels > 1) << 2; /* Stereo or mono */ + tmp |= (cfg - 1) << 3; /* codec configuration */ + *toc++ = tmp; + if (extended_toc) { + for (i = 0; i < (s->pkt_frames - 1); i++) + *fsize_needed |= (s->frame[i].framebits != s->frame[i + 1].framebits); + tmp = (*fsize_needed) << 7; /* vbr flag */ + tmp |= s->pkt_frames; /* frame number - can be 0 as well */ + *toc++ = tmp; + } + *size = 1 + extended_toc; + return 0; +} + +static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f) +{ + int sf, ch; + AVFrame *cur = NULL; + const int subframesize = s->avctx->frame_size; + int subframes = OPUS_BLOCK_SIZE(s->pkt_framesize) / subframesize; + + cur = ff_bufqueue_get(&s->bufqueue); + + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *b = &f->block[ch]; + const void *input = cur->extended_data[ch]; + size_t bps = av_get_bytes_per_sample(cur->format); + memcpy(b->overlap, input, bps*cur->nb_samples); + } + + av_frame_free(&cur); + + for (sf = 0; sf < subframes; sf++) { + if (sf != (subframes - 1)) + cur = ff_bufqueue_get(&s->bufqueue); + else + cur = ff_bufqueue_peek(&s->bufqueue, 0); + + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *b = &f->block[ch]; + const void *input = cur->extended_data[ch]; + const size_t bps = av_get_bytes_per_sample(cur->format); + const size_t left = (subframesize - cur->nb_samples)*bps; + const size_t len = FFMIN(subframesize, cur->nb_samples)*bps; + memcpy(&b->samples[sf*subframesize], input, len); + memset(&b->samples[cur->nb_samples], 0, left); + } + + /* Last frame isn't popped off and freed yet - we need it for overlap */ + if (sf != (subframes - 1)) + av_frame_free(&cur); + } +} + +/* Apply the pre emphasis filter */ +static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f) +{ + int i, sf, ch; + const int subframesize = s->avctx->frame_size; + const int subframes = OPUS_BLOCK_SIZE(s->pkt_framesize) / subframesize; + + /* Filter overlap */ + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *b = &f->block[ch]; + float m = b->emph_coeff; + for (i = 0; i < CELT_OVERLAP; i++) { + float sample = b->overlap[i]; + b->overlap[i] = sample - m; + m = sample * CELT_EMPH_COEFF; + } + b->emph_coeff = m; + } + + /* Filter the samples but do not update the last subframe's coeff - overlap ^^^ */ + for (sf = 0; sf < subframes; sf++) { + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *b = &f->block[ch]; + float m = b->emph_coeff; + for (i = 0; i < subframesize; i++) { + float sample = b->samples[sf*subframesize + i]; + b->samples[sf*subframesize + i] = sample - m; + m = sample * CELT_EMPH_COEFF; + } + if (sf != (subframes - 1)) + b->emph_coeff = m; + } + } +} + +/* Create the window and do the mdct */ +static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f) +{ + int i, t, ch; + float *win = s->scratch; + + /* I think I can use s->dsp->vector_fmul_window for transients at least */ + if (f->transient) { + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *b = &f->block[ch]; + float *src1 = b->overlap; + for (t = 0; t < f->blocks; t++) { + float *src2 = &b->samples[CELT_OVERLAP*t]; + for (i = 0; i < CELT_OVERLAP; i++) { + win[ i] = src1[i]*ff_celt_window[i]; + win[CELT_OVERLAP + i] = src2[i]*ff_celt_window[CELT_OVERLAP - i - 1]; + } + src1 = src2; + s->mdct[0]->mdct(s->mdct[0], b->coeffs + t, win, f->blocks); + } + } + } else { + int blk_len = OPUS_BLOCK_SIZE(f->size), wlen = OPUS_BLOCK_SIZE(f->size + 1); + int rwin = blk_len - CELT_OVERLAP, lap_dst = (wlen - blk_len - CELT_OVERLAP) >> 1; + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *b = &f->block[ch]; + + memset(win, 0, wlen*sizeof(float)); + + memcpy(&win[lap_dst + CELT_OVERLAP], b->samples, rwin*sizeof(float)); + + /* Alignment fucks me over */ + //s->dsp->vector_fmul(&dst[lap_dst], b->overlap, ff_celt_window, CELT_OVERLAP); + //s->dsp->vector_fmul_reverse(&dst[lap_dst + blk_len - CELT_OVERLAP], b->samples, ff_celt_window, CELT_OVERLAP); + + for (i = 0; i < CELT_OVERLAP; i++) { + win[lap_dst + i] = b->overlap[i] *ff_celt_window[i]; + win[lap_dst + blk_len + i] = b->samples[rwin + i]*ff_celt_window[CELT_OVERLAP - i - 1]; + } + + s->mdct[f->size]->mdct(s->mdct[f->size], b->coeffs, win, 1); + } + } +} + +/* Fills the bands and normalizes them */ +static int celt_frame_map_norm_bands(OpusEncContext *s, CeltFrame *f) +{ + int i, j, ch, noise = 0; + + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *block = &f->block[ch]; + float *start = block->coeffs; + for (i = 0; i < CELT_MAX_BANDS; i++) { + float ener = 0.0f; + + /* Calculate band bins */ + block->band_bins[i] = ff_celt_freq_range[i] << f->size; + block->band_coeffs[i] = start; + start += block->band_bins[i]; + + /* Normalize band energy */ + for (j = 0; j < block->band_bins[i]; j++) + ener += block->band_coeffs[i][j]*block->band_coeffs[i][j]; + + block->lin_energy[i] = sqrtf(ener) + FLT_EPSILON; + ener = 1.0f/block->lin_energy[i]; + + for (j = 0; j < block->band_bins[i]; j++) + block->band_coeffs[i][j] *= ener; + + block->energy[i] = log2f(block->lin_energy[i]) - ff_celt_mean_energy[i]; + + /* CELT_ENERGY_SILENCE is what the decoder uses and its not -infinity */ + block->energy[i] = FFMAX(block->energy[i], CELT_ENERGY_SILENCE); + noise |= block->energy[i] > CELT_ENERGY_SILENCE; + } + } + return !noise; +} + +static void celt_enc_tf(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f) +{ + int i, tf_select = 0, diff = 0, tf_changed = 0, tf_select_needed; + int bits = f->transient ? 2 : 4; + + tf_select_needed = ((f->size && (opus_rc_tell(rc) + bits + 1) <= f->framebits)); + + for (i = f->start_band; i < f->end_band; i++) { + if ((opus_rc_tell(rc) + bits + tf_select_needed) <= f->framebits) { + const int tbit = (diff ^ 1) == f->tf_change[i]; + ff_opus_rc_enc_log(rc, tbit, bits); + diff ^= tbit; + tf_changed |= diff; + } + bits = f->transient ? 4 : 5; + } + + if (tf_select_needed && ff_celt_tf_select[f->size][f->transient][0][tf_changed] != + ff_celt_tf_select[f->size][f->transient][1][tf_changed]) { + ff_opus_rc_enc_log(rc, f->tf_select, 1); + tf_select = f->tf_select; + } + + for (i = f->start_band; i < f->end_band; i++) + f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]]; +} + +static void celt_bitalloc(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f) +{ + int i, j, low, high, total, done, bandbits, remaining, tbits_8ths; + int skip_startband = f->start_band; + int skip_bit = 0; + int intensitystereo_bit = 0; + int dualstereo_bit = 0; + int dynalloc = 6; + int extrabits = 0; + + int *cap = f->caps; + int boost[CELT_MAX_BANDS]; + int trim_offset[CELT_MAX_BANDS]; + int threshold[CELT_MAX_BANDS]; + int bits1[CELT_MAX_BANDS]; + int bits2[CELT_MAX_BANDS]; + + /* Tell the spread to the decoder */ + if (opus_rc_tell(rc) + 4 <= f->framebits) + ff_opus_rc_enc_cdf(rc, f->spread, ff_celt_model_spread); + + /* Generate static allocation caps */ + for (i = 0; i < CELT_MAX_BANDS; i++) { + cap[i] = (ff_celt_static_caps[f->size][f->channels - 1][i] + 64) + * ff_celt_freq_range[i] << (f->channels - 1) << f->size >> 2; + } + + /* Band boosts */ + tbits_8ths = f->framebits << 3; + for (i = f->start_band; i < f->end_band; i++) { + int quanta, b_dynalloc, boost_amount = f->alloc_boost[i]; + + boost[i] = 0; + + quanta = ff_celt_freq_range[i] << (f->channels - 1) << f->size; + quanta = FFMIN(quanta << 3, FFMAX(6 << 3, quanta)); + b_dynalloc = dynalloc; + + while (opus_rc_tell_frac(rc) + (b_dynalloc << 3) < tbits_8ths && boost[i] < cap[i]) { + int is_boost = boost_amount--; + + ff_opus_rc_enc_log(rc, is_boost, b_dynalloc); + if (!is_boost) + break; + + boost[i] += quanta; + tbits_8ths -= quanta; + + b_dynalloc = 1; + } + + if (boost[i]) + dynalloc = FFMAX(2, dynalloc - 1); + } + + /* Put allocation trim */ + if (opus_rc_tell_frac(rc) + (6 << 3) <= tbits_8ths) + ff_opus_rc_enc_cdf(rc, f->alloc_trim, ff_celt_model_alloc_trim); + + /* Anti-collapse bit reservation */ + tbits_8ths = (f->framebits << 3) - opus_rc_tell_frac(rc) - 1; + f->anticollapse_needed = 0; + if (f->transient && f->size >= 2 && tbits_8ths >= ((f->size + 2) << 3)) + f->anticollapse_needed = 1 << 3; + tbits_8ths -= f->anticollapse_needed; + + /* Band skip bit reservation */ + if (tbits_8ths >= 1 << 3) + skip_bit = 1 << 3; + tbits_8ths -= skip_bit; + + /* Intensity/dual stereo bit reservation */ + if (f->channels == 2) { + intensitystereo_bit = ff_celt_log2_frac[f->end_band - f->start_band]; + if (intensitystereo_bit <= tbits_8ths) { + tbits_8ths -= intensitystereo_bit; + if (tbits_8ths >= 1 << 3) { + dualstereo_bit = 1 << 3; + tbits_8ths -= 1 << 3; + } + } else { + intensitystereo_bit = 0; + } + } + + /* Trim offsets */ + for (i = f->start_band; i < f->end_band; i++) { + int trim = f->alloc_trim - 5 - f->size; + int band = ff_celt_freq_range[i] * (f->end_band - i - 1); + int duration = f->size + 3; + int scale = duration + f->channels - 1; + + /* PVQ minimum allocation threshold, below this value the band is + * skipped */ + threshold[i] = FFMAX(3 * ff_celt_freq_range[i] << duration >> 4, + f->channels << 3); + + trim_offset[i] = trim * (band << scale) >> 6; + + if (ff_celt_freq_range[i] << f->size == 1) + trim_offset[i] -= f->channels << 3; + } + + /* Bisection */ + low = 1; + high = CELT_VECTORS - 1; + while (low <= high) { + int center = (low + high) >> 1; + done = total = 0; + + for (i = f->end_band - 1; i >= f->start_band; i--) { + bandbits = ff_celt_freq_range[i] * ff_celt_static_alloc[center][i] + << (f->channels - 1) << f->size >> 2; + + if (bandbits) + bandbits = FFMAX(0, bandbits + trim_offset[i]); + bandbits += boost[i]; + + if (bandbits >= threshold[i] || done) { + done = 1; + total += FFMIN(bandbits, cap[i]); + } else if (bandbits >= f->channels << 3) + total += f->channels << 3; + } + + if (total > tbits_8ths) + high = center - 1; + else + low = center + 1; + } + high = low--; + + /* Bisection */ + for (i = f->start_band; i < f->end_band; i++) { + bits1[i] = ff_celt_freq_range[i] * ff_celt_static_alloc[low][i] + << (f->channels - 1) << f->size >> 2; + bits2[i] = high >= CELT_VECTORS ? cap[i] : + ff_celt_freq_range[i] * ff_celt_static_alloc[high][i] + << (f->channels - 1) << f->size >> 2; + + if (bits1[i]) + bits1[i] = FFMAX(0, bits1[i] + trim_offset[i]); + if (bits2[i]) + bits2[i] = FFMAX(0, bits2[i] + trim_offset[i]); + if (low) + bits1[i] += boost[i]; + bits2[i] += boost[i]; + + if (boost[i]) + skip_startband = i; + bits2[i] = FFMAX(0, bits2[i] - bits1[i]); + } + + /* Bisection */ + low = 0; + high = 1 << CELT_ALLOC_STEPS; + for (i = 0; i < CELT_ALLOC_STEPS; i++) { + int center = (low + high) >> 1; + done = total = 0; + + for (j = f->end_band - 1; j >= f->start_band; j--) { + bandbits = bits1[j] + (center * bits2[j] >> CELT_ALLOC_STEPS); + + if (bandbits >= threshold[j] || done) { + done = 1; + total += FFMIN(bandbits, cap[j]); + } else if (bandbits >= f->channels << 3) + total += f->channels << 3; + } + if (total > tbits_8ths) + high = center; + else + low = center; + } + + /* Bisection */ + done = total = 0; + for (i = f->end_band - 1; i >= f->start_band; i--) { + bandbits = bits1[i] + (low * bits2[i] >> CELT_ALLOC_STEPS); + + if (bandbits >= threshold[i] || done) + done = 1; + else + bandbits = (bandbits >= f->channels << 3) ? + f->channels << 3 : 0; + + bandbits = FFMIN(bandbits, cap[i]); + f->pulses[i] = bandbits; + total += bandbits; + } + + /* Band skipping */ + for (f->coded_bands = f->end_band; ; f->coded_bands--) { + int allocation; + j = f->coded_bands - 1; + + if (j == skip_startband) { + /* all remaining bands are not skipped */ + tbits_8ths += skip_bit; + break; + } + + /* determine the number of bits available for coding "do not skip" markers */ + remaining = tbits_8ths - total; + bandbits = remaining / (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]); + remaining -= bandbits * (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]); + allocation = f->pulses[j] + bandbits * ff_celt_freq_range[j] + + FFMAX(0, remaining - (ff_celt_freq_bands[j] - ff_celt_freq_bands[f->start_band])); + + /* a "do not skip" marker is only coded if the allocation is + above the chosen threshold */ + if (allocation >= FFMAX(threshold[j], (f->channels + 1) << 3)) { + const int do_not_skip = f->coded_bands <= f->skip_band_floor; + ff_opus_rc_enc_log(rc, do_not_skip, 1); + if (do_not_skip) + break; + + total += 1 << 3; + allocation -= 1 << 3; + } + + /* the band is skipped, so reclaim its bits */ + total -= f->pulses[j]; + if (intensitystereo_bit) { + total -= intensitystereo_bit; + intensitystereo_bit = ff_celt_log2_frac[j - f->start_band]; + total += intensitystereo_bit; + } + + total += f->pulses[j] = (allocation >= f->channels << 3) ? f->channels << 3 : 0; + } + + /* Encode stereo flags */ + if (intensitystereo_bit) { + f->intensity_stereo = FFMIN(f->intensity_stereo, f->coded_bands); + ff_opus_rc_enc_uint(rc, f->intensity_stereo, f->coded_bands + 1 - f->start_band); + } + if (f->intensity_stereo <= f->start_band) + tbits_8ths += dualstereo_bit; /* no intensity stereo means no dual stereo */ + else if (dualstereo_bit) + ff_opus_rc_enc_log(rc, f->dual_stereo, 1); + + /* Supply the remaining bits in this frame to lower bands */ + remaining = tbits_8ths - total; + bandbits = remaining / (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]); + remaining -= bandbits * (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]); + for (i = f->start_band; i < f->coded_bands; i++) { + int bits = FFMIN(remaining, ff_celt_freq_range[i]); + + f->pulses[i] += bits + bandbits * ff_celt_freq_range[i]; + remaining -= bits; + } + + /* Finally determine the allocation */ + for (i = f->start_band; i < f->coded_bands; i++) { + int N = ff_celt_freq_range[i] << f->size; + int prev_extra = extrabits; + f->pulses[i] += extrabits; + + if (N > 1) { + int dof; // degrees of freedom + int temp; // dof * channels * log(dof) + int offset; // fine energy quantization offset, i.e. + // extra bits assigned over the standard + // totalbits/dof + int fine_bits, max_bits; + + extrabits = FFMAX(0, f->pulses[i] - cap[i]); + f->pulses[i] -= extrabits; + + /* intensity stereo makes use of an extra degree of freedom */ + dof = N * f->channels + (f->channels == 2 && N > 2 && !f->dual_stereo && i < f->intensity_stereo); + temp = dof * (ff_celt_log_freq_range[i] + (f->size << 3)); + offset = (temp >> 1) - dof * CELT_FINE_OFFSET; + if (N == 2) /* dof=2 is the only case that doesn't fit the model */ + offset += dof << 1; + + /* grant an additional bias for the first and second pulses */ + if (f->pulses[i] + offset < 2 * (dof << 3)) + offset += temp >> 2; + else if (f->pulses[i] + offset < 3 * (dof << 3)) + offset += temp >> 3; + + fine_bits = (f->pulses[i] + offset + (dof << 2)) / (dof << 3); + max_bits = FFMIN((f->pulses[i] >> 3) >> (f->channels - 1), CELT_MAX_FINE_BITS); + + max_bits = FFMAX(max_bits, 0); + + f->fine_bits[i] = av_clip(fine_bits, 0, max_bits); + + /* if fine_bits was rounded down or capped, + give priority for the final fine energy pass */ + f->fine_priority[i] = (f->fine_bits[i] * (dof << 3) >= f->pulses[i] + offset); + + /* the remaining bits are assigned to PVQ */ + f->pulses[i] -= f->fine_bits[i] << (f->channels - 1) << 3; + } else { + /* all bits go to fine energy except for the sign bit */ + extrabits = FFMAX(0, f->pulses[i] - (f->channels << 3)); + f->pulses[i] -= extrabits; + f->fine_bits[i] = 0; + f->fine_priority[i] = 1; + } + + /* hand back a limited number of extra fine energy bits to this band */ + if (extrabits > 0) { + int fineextra = FFMIN(extrabits >> (f->channels + 2), + CELT_MAX_FINE_BITS - f->fine_bits[i]); + f->fine_bits[i] += fineextra; + + fineextra <<= f->channels + 2; + f->fine_priority[i] = (fineextra >= extrabits - prev_extra); + extrabits -= fineextra; + } + } + f->remaining = extrabits; + + /* skipped bands dedicate all of their bits for fine energy */ + for (; i < f->end_band; i++) { + f->fine_bits[i] = f->pulses[i] >> (f->channels - 1) >> 3; + f->pulses[i] = 0; + f->fine_priority[i] = f->fine_bits[i] < 1; + } +} + +static void celt_quant_coarse(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f) +{ + int i, ch; + float alpha, beta, prev[2] = { 0, 0 }; + const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][f->intra]; + + /* Inter is really just differential coding */ + if (opus_rc_tell(rc) + 3 <= f->framebits) + ff_opus_rc_enc_log(rc, f->intra, 3); + else + f->intra = 0; + + if (f->intra) { + alpha = 0.0f; + beta = 1.0f - 4915.0f/32768.0f; + } else { + alpha = ff_celt_alpha_coef[f->size]; + beta = 1.0f - ff_celt_beta_coef[f->size]; + } + + for (i = f->start_band; i < f->end_band; i++) { + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *block = &f->block[ch]; + const int left = f->framebits - opus_rc_tell(rc); + const float last = FFMAX(-9.0f, s->last_quantized_energy[ch][i]); + float diff = block->energy[i] - prev[ch] - last*alpha; + int q_en = lrintf(diff); + if (left >= 15) { + ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6); + } else if (left >= 2) { + q_en = av_clip(q_en, -1, 1); + ff_opus_rc_enc_cdf(rc, ((q_en & 1) << 1) | (q_en < 0), ff_celt_model_energy_small); + } else if (left >= 1) { + q_en = av_clip(q_en, -1, 0); + ff_opus_rc_enc_log(rc, (q_en & 1), 1); + } else q_en = -1; + + block->error_energy[i] = q_en - diff; + prev[ch] += beta * q_en; + } + } +} + +static void celt_quant_fine(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f) +{ + int i, ch; + for (i = f->start_band; i < f->end_band; i++) { + if (!f->fine_bits[i]) + continue; + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *block = &f->block[ch]; + int quant, lim = (1 << f->fine_bits[i]); + float offset, diff = 0.5f - block->error_energy[i]; + quant = av_clip(floor(diff*lim), 0, lim - 1); + ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]); + offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f); + block->error_energy[i] -= offset; + } + } +} + +static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f) +{ + int i, ch, priority; + for (priority = 0; priority < 2; priority++) { + for (i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) { + if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS) + continue; + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *block = &f->block[ch]; + const float err = block->error_energy[i]; + const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f; + const int sign = FFABS(err + offset) < FFABS(err - offset); + ff_opus_rc_put_raw(rc, sign, 1); + block->error_energy[i] -= offset*(1 - 2*sign); + } + } + } +} + +static void celt_quant_bands(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f) +{ + float lowband_scratch[8 * 22]; + float norm[2 * 8 * 100]; + + int totalbits = (f->framebits << 3) - f->anticollapse_needed; + + int update_lowband = 1; + int lowband_offset = 0; + + int i, j; + + for (i = f->start_band; i < f->end_band; i++) { + int band_offset = ff_celt_freq_bands[i] << f->size; + int band_size = ff_celt_freq_range[i] << f->size; + float *X = f->block[0].coeffs + band_offset; + float *Y = (f->channels == 2) ? f->block[1].coeffs + band_offset : NULL; + + int consumed = opus_rc_tell_frac(rc); + float *norm2 = norm + 8 * 100; + int effective_lowband = -1; + unsigned int cm[2]; + int b; + + /* Compute how many bits we want to allocate to this band */ + if (i != f->start_band) + f->remaining -= consumed; + f->remaining2 = totalbits - consumed - 1; + if (i <= f->coded_bands - 1) { + int curr_balance = f->remaining / FFMIN(3, f->coded_bands-i); + b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[i] + curr_balance), 14); + } else + b = 0; + + if (ff_celt_freq_bands[i] - ff_celt_freq_range[i] >= ff_celt_freq_bands[f->start_band] && + (update_lowband || lowband_offset == 0)) + lowband_offset = i; + + /* Get a conservative estimate of the collapse_mask's for the bands we're + going to be folding from. */ + if (lowband_offset != 0 && (f->spread != CELT_SPREAD_AGGRESSIVE || + f->blocks > 1 || f->tf_change[i] < 0)) { + int foldstart, foldend; + + /* This ensures we never repeat spectral content within one band */ + effective_lowband = FFMAX(ff_celt_freq_bands[f->start_band], + ff_celt_freq_bands[lowband_offset] - ff_celt_freq_range[i]); + foldstart = lowband_offset; + while (ff_celt_freq_bands[--foldstart] > effective_lowband); + foldend = lowband_offset - 1; + while (ff_celt_freq_bands[++foldend] < effective_lowband + ff_celt_freq_range[i]); + + cm[0] = cm[1] = 0; + for (j = foldstart; j < foldend; j++) { + cm[0] |= f->block[0].collapse_masks[j]; + cm[1] |= f->block[f->channels - 1].collapse_masks[j]; + } + } else + /* Otherwise, we'll be using the LCG to fold, so all blocks will (almost + always) be non-zero.*/ + cm[0] = cm[1] = (1 << f->blocks) - 1; + + if (f->dual_stereo && i == f->intensity_stereo) { + /* Switch off dual stereo to do intensity */ + f->dual_stereo = 0; + for (j = ff_celt_freq_bands[f->start_band] << f->size; j < band_offset; j++) + norm[j] = (norm[j] + norm2[j]) / 2; + } + + if (f->dual_stereo) { + cm[0] = ff_celt_encode_band(f, rc, i, X, NULL, band_size, b / 2, f->blocks, + effective_lowband != -1 ? norm + (effective_lowband << f->size) : NULL, f->size, + norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]); + + cm[1] = ff_celt_encode_band(f, rc, i, Y, NULL, band_size, b/2, f->blocks, + effective_lowband != -1 ? norm2 + (effective_lowband << f->size) : NULL, f->size, + norm2 + band_offset, 0, 1.0f, lowband_scratch, cm[1]); + } else { + cm[0] = ff_celt_encode_band(f, rc, i, X, Y, band_size, b, f->blocks, + effective_lowband != -1 ? norm + (effective_lowband << f->size) : NULL, f->size, + norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]|cm[1]); + cm[1] = cm[0]; + } + + f->block[0].collapse_masks[i] = (uint8_t)cm[0]; + f->block[f->channels - 1].collapse_masks[i] = (uint8_t)cm[1]; + f->remaining += f->pulses[i] + consumed; + + /* Update the folding position only as long as we have 1 bit/sample depth */ + update_lowband = (b > band_size << 3); + } +} + +static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f) +{ + int i, ch; + + celt_frame_setup_input(s, f); + celt_apply_preemph_filter(s, f); + if (f->pfilter) { + /* Not implemented */ + } + celt_frame_mdct(s, f); + f->silence = celt_frame_map_norm_bands(s, f); + if (f->silence) { + f->framebits = 1; + return; + } + + ff_opus_rc_enc_log(rc, f->silence, 15); + + if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits) + ff_opus_rc_enc_log(rc, f->pfilter, 1); + + if (f->pfilter) { + /* Not implemented */ + } + + if (f->size && opus_rc_tell(rc) + 3 <= f->framebits) + ff_opus_rc_enc_log(rc, f->transient, 3); + + celt_quant_coarse (s, rc, f); + celt_enc_tf (s, rc, f); + celt_bitalloc (s, rc, f); + celt_quant_fine (s, rc, f); + celt_quant_bands (s, rc, f); + + if (f->anticollapse_needed) + ff_opus_rc_put_raw(rc, f->anticollapse, 1); + + celt_quant_final(s, rc, f); + + for (ch = 0; ch < f->channels; ch++) { + CeltBlock *block = &f->block[ch]; + for (i = 0; i < CELT_MAX_BANDS; i++) + s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i]; + } +} + +static void ff_opus_psy_process(OpusEncContext *s, int end, int *need_more) +{ + int max_delay_samples = (s->options.max_delay_ms*s->avctx->sample_rate)/1000; + int max_bsize = FFMIN(OPUS_SAMPLES_TO_BLOCK_SIZE(max_delay_samples), CELT_BLOCK_960); + + s->pkt_frames = 1; + s->pkt_framesize = max_bsize; + s->mode = OPUS_MODE_CELT; + s->bandwidth = OPUS_BANDWIDTH_FULLBAND; + + *need_more = s->bufqueue.available*s->avctx->frame_size < (max_delay_samples + CELT_OVERLAP); + /* Don't request more if we start being flushed with NULL frames */ + *need_more = !end && *need_more; +} + +static void ff_opus_psy_celt_frame_setup(OpusEncContext *s, CeltFrame *f, int index) +{ + int frame_size = OPUS_BLOCK_SIZE(s->pkt_framesize); + + f->avctx = s->avctx; + f->dsp = s->dsp; + f->start_band = (s->mode == OPUS_MODE_HYBRID) ? 17 : 0; + f->end_band = ff_celt_band_end[s->bandwidth]; + f->channels = s->channels; + f->size = s->pkt_framesize; + + /* Decisions */ + f->silence = 0; + f->pfilter = 0; + f->transient = 0; + f->intra = 1; + f->tf_select = 0; + f->anticollapse = 0; + f->alloc_trim = 5; + f->skip_band_floor = f->end_band; + f->intensity_stereo = f->end_band; + f->dual_stereo = 0; + f->spread = CELT_SPREAD_NORMAL; + memset(f->tf_change, 0, sizeof(int)*CELT_MAX_BANDS); + memset(f->alloc_boost, 0, sizeof(int)*CELT_MAX_BANDS); + + f->blocks = f->transient ? frame_size/CELT_OVERLAP : 1; + f->framebits = FFALIGN(lrintf((double)s->avctx->bit_rate/(s->avctx->sample_rate/frame_size)), 8); +} + +static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt) +{ + int i, offset, fsize_needed; + + /* Write toc */ + opus_gen_toc(s, avpkt->data, &offset, &fsize_needed); + + for (i = 0; i < s->pkt_frames; i++) { + ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset, s->frame[i].framebits >> 3); + offset += s->frame[i].framebits >> 3; + } + + avpkt->size = offset; +} + +/* Used as overlap for the first frame and padding for the last encoded packet */ +static AVFrame *spawn_empty_frame(OpusEncContext *s) +{ + int i; + AVFrame *f = av_frame_alloc(); + if (!f) + return NULL; + f->format = s->avctx->sample_fmt; + f->nb_samples = s->avctx->frame_size; + f->channel_layout = s->avctx->channel_layout; + if (av_frame_get_buffer(f, 4)) { + av_frame_free(&f); + return NULL; + } + for (i = 0; i < s->channels; i++) { + size_t bps = av_get_bytes_per_sample(f->format); + memset(f->extended_data[i], 0, bps*f->nb_samples); + } + return f; +} + +static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, + const AVFrame *frame, int *got_packet_ptr) +{ + OpusEncContext *s = avctx->priv_data; + int i, ret, frame_size, need_more, alloc_size = 0; + + if (frame) { /* Add new frame to queue */ + if ((ret = ff_af_queue_add(&s->afq, frame)) < 0) + return ret; + ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame)); + } else { + if (!s->afq.remaining_samples) + return 0; /* We've been flushed and there's nothing left to encode */ + } + + /* Run the psychoacoustic system */ + ff_opus_psy_process(s, !frame, &need_more); + + /* Get more samples for lookahead/encoding */ + if (need_more) + return 0; + + frame_size = OPUS_BLOCK_SIZE(s->pkt_framesize); + + if (!frame) { + /* This can go negative, that's not a problem, we only pad if positive */ + int pad_empty = s->pkt_frames*(frame_size/s->avctx->frame_size) - s->bufqueue.available + 1; + /* Pad with empty 2.5 ms frames to whatever framesize was decided, + * this should only happen at the very last flush frame. The frames + * allocated here will be freed (because they have no other references) + * after they get used by celt_frame_setup_input() */ + for (i = 0; i < pad_empty; i++) { + AVFrame *empty = spawn_empty_frame(s); + if (!empty) + return AVERROR(ENOMEM); + ff_bufqueue_add(avctx, &s->bufqueue, empty); + } + } + + for (i = 0; i < s->pkt_frames; i++) { + ff_opus_rc_enc_init(&s->rc[i]); + ff_opus_psy_celt_frame_setup(s, &s->frame[i], i); + celt_encode_frame(s, &s->rc[i], &s->frame[i]); + alloc_size += s->frame[i].framebits >> 3; + } + + /* Worst case toc + the frame lengths if needed */ + alloc_size += 2 + s->pkt_frames*2; + + if ((ret = ff_alloc_packet2(avctx, avpkt, alloc_size, 0)) < 0) + return ret; + + /* Assemble packet */ + opus_packet_assembler(s, avpkt); + + /* Remove samples from queue and skip if needed */ + ff_af_queue_remove(&s->afq, s->pkt_frames*frame_size, &avpkt->pts, &avpkt->duration); + if (s->pkt_frames*frame_size > avpkt->duration) { + uint8_t *side = av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10); + if (!side) + return AVERROR(ENOMEM); + AV_WL32(&side[4], s->pkt_frames*frame_size - avpkt->duration + 120); + } + + *got_packet_ptr = 1; + + return 0; +} + +static av_cold int opus_encode_end(AVCodecContext *avctx) +{ + int i; + OpusEncContext *s = avctx->priv_data; + + for (i = 0; i < CELT_BLOCK_NB; i++) + ff_mdct15_uninit(&s->mdct[i]); + + av_freep(&s->dsp); + av_freep(&s->frame); + av_freep(&s->rc); + ff_af_queue_close(&s->afq); + ff_bufqueue_discard_all(&s->bufqueue); + av_freep(&avctx->extradata); + + return 0; +} + +static av_cold int opus_encode_init(AVCodecContext *avctx) +{ + int i, ch, ret; + OpusEncContext *s = avctx->priv_data; + + s->avctx = avctx; + s->channels = avctx->channels; + + /* Opus allows us to change the framesize on each packet (and each packet may + * have multiple frames in it) but we can't change the codec's frame size on + * runtime, so fix it to the lowest possible number of samples and use a queue + * to accumulate AVFrames until we have enough to encode whatever the encoder + * decides is the best */ + avctx->frame_size = 120; + /* Initial padding will change if SILK is ever supported */ + avctx->initial_padding = 120; + + avctx->cutoff = !avctx->cutoff ? 20000 : avctx->cutoff; + + if (!avctx->bit_rate) { + int coupled = ff_opus_default_coupled_streams[s->channels - 1]; + avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000); + } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) { + int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels); + av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %li kbps, clipping to %li kbps\n", + avctx->bit_rate/1000, clipped_rate/1000); + avctx->bit_rate = clipped_rate; + } + + /* Frame structs and range coder buffers */ + s->frame = av_malloc(OPUS_MAX_FRAMES_PER_PACKET*sizeof(CeltFrame)); + if (!s->frame) + return AVERROR(ENOMEM); + s->rc = av_malloc(OPUS_MAX_FRAMES_PER_PACKET*sizeof(OpusRangeCoder)); + if (!s->rc) + return AVERROR(ENOMEM); + + /* Extradata */ + avctx->extradata_size = 19; + avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE); + if (!avctx->extradata) + return AVERROR(ENOMEM); + opus_write_extradata(avctx); + + ff_af_queue_init(avctx, &s->afq); + + if (!(s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT))) + return AVERROR(ENOMEM); + + /* I have no idea why a base scaling factor of 68 works, could be the twiddles */ + for (i = 0; i < CELT_BLOCK_NB; i++) + if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i)))) + return AVERROR(ENOMEM); + + /* Zero out previous energy (matters for inter first frame) */ + for (ch = 0; ch < s->channels; ch++) + for (i = 0; i < CELT_MAX_BANDS; i++) + s->last_quantized_energy[ch][i] = 0.0f; + + /* Allocate an empty frame to use as overlap for the first frame of audio */ + ff_bufqueue_add(avctx, &s->bufqueue, spawn_empty_frame(s)); + if (!ff_bufqueue_peek(&s->bufqueue, 0)) + return AVERROR(ENOMEM); + + return 0; +} + +#define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM +static const AVOption opusenc_options[] = { + { "opus_delay", "Maximum delay (and lookahead) in milliseconds", offsetof(OpusEncContext, options.max_delay_ms), AV_OPT_TYPE_FLOAT, { .dbl = OPUS_MAX_LOOKAHEAD }, 2.5f, OPUS_MAX_LOOKAHEAD, OPUSENC_FLAGS }, + { NULL }, +}; + +static const AVClass opusenc_class = { + .class_name = "Opus encoder", + .item_name = av_default_item_name, + .option = opusenc_options, + .version = LIBAVUTIL_VERSION_INT, +}; + +static const AVCodecDefault opusenc_defaults[] = { + { "b", "0" }, + { "compression_level", "10" }, + { NULL }, +}; + +AVCodec ff_opus_encoder = { + .name = "opus", + .long_name = NULL_IF_CONFIG_SMALL("Opus"), + .type = AVMEDIA_TYPE_AUDIO, + .id = AV_CODEC_ID_OPUS, + .defaults = opusenc_defaults, + .priv_class = &opusenc_class, + .priv_data_size = sizeof(OpusEncContext), + .init = opus_encode_init, + .encode2 = opus_encode_frame, + .close = opus_encode_end, + .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, + .capabilities = AV_CODEC_CAP_EXPERIMENTAL | AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY, + .supported_samplerates = (const int []){ 48000, 0 }, + .channel_layouts = (const uint64_t []){ AV_CH_LAYOUT_MONO, + AV_CH_LAYOUT_STEREO, 0 }, + .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP, + AV_SAMPLE_FMT_NONE }, +};