37 tok/s from Qwen3-Next-80B (48 GB) on a 32 GB laptop, 24 without drafts vs 2.8 for llama.cpp; reading 62 vs 16 tok/s. Faster than llama.cpp on all 13 models compared in Q4_K_M. LLMs bigger than your RAM, pure C, CPU or GPU.
C avx2ccpu-inferenceggufinference-enginelinuxllmlocal-llmmixture-of-expertsmoenvmequantizationqwen3simdspeculative-decodingvulkan
/* SPDX-License-Identifier: GPL-3.0-or-later
Copyright (C) 2026 Maurizio Cammalleri */
/*
* audio_opus_celt.c - the CELT layer of Opus (RFC 6716 section 4.3;
* audio_opus.h), as the reference decoder computes it in floating point:
* silence, the post-filter's parameters, transients, the coarse energy
* (Laplace-coded, predicted in time and frequency), the time-frequency
* resolution changes, the spreading, the dynamic allocation boosts and the
* allocation trim, the bit allocation (interpolated between the allocation
* vectors, bands skipped from the top, intensity and dual stereo, fine
* energy bits), the fine energy, the shapes of the bands (pyramid vector
* quantization: theta splits, mid/side stereo, folding from lower bands,
* the pulses' combinatorial index, spreading rotations, Haar and Hadamard
* reshuffles), the final energy bits, anti-collapse, the bands scaled by
* their energies, the inverse MDCT with its short overlap (a DCT-IV on
* audio_fft.c, mirrored for the overlap), the pitch post-filter and the
* de-emphasis.
*/
#include "audio_opus.h"
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "audio_fft.h"
#include "audio_opus_tab.h"
#define NB 21 /* bands */
#define OV 120 /* overlap */
#define DBS 2048 /* the decoder's memory a channel */
#define BITRES 3
#define MAX_FINE_BITS 8
#define FINE_OFFSET 21
#define QTHETA_OFFSET 4
#define QTHETA_OFFSET_TWOPHASE 16
#define SPREAD_NONE 0
#define SPREAD_NORMAL 2
#define SPREAD_AGGRESSIVE 3
#define PVQ_N 180
#define PVQ_K 132
struct celt_dec {
int start, end, cc;
float mem[2][DBS + OV];
float old_e[2 * NB], old_loge[2 * NB], old_loge2[2 * NB], bg_loge[2 * NB];
float preemph[2];
int pf_period, pf_period_old, pf_tapset, pf_tapset_old;
float pf_gain, pf_gain_old;
uint32_t rng;
struct aimdct *mdct[4]; /* 240, 480, 960, 1920 points */
uint32_t *pvq; /* U(a, b), a <= b: pvq[a * PVQ_N + b] */
float x[2 * 960], freq[960], freq2[960], u[960];
/* concealment: frames concealed since the last decoded one (in 2.5 ms
units), whether the pitch-based kind is not to be used yet, its last
pitch, the overlap still to be folded with the next frame, the LPC
of the concealed signal */
int loss_duration, skip_plc, last_pitch, prefilter_and_fold;
float lpc[2][24];
float norm[2 * 8 * 100]; /* the bands as folded from */
};
/* ---- small helpers ---- */
static inline int imin(int a, int b)
{
return a < b ? a : b;
}
static inline int imax(int a, int b)
{
return a > b ? a : b;
}
static int frac_mul16(int a, int b)
{
return (16384 + (int32_t)(int16_t)a * (int16_t)b) >> 15;
}
static int bitexact_cos(int x)
{
int32_t tmp = (4096 + (int32_t)x * x) >> 13;
int x2 = tmp;
x2 =
(32767 - x2) +
frac_mul16(x2, (-7651 + frac_mul16(x2, (8277 + frac_mul16(-626, x2)))));
return 1 + x2;
}
static int bitexact_log2tan(int isin, int icos)
{
int lc = rc_ilog((uint32_t)icos), ls = rc_ilog((uint32_t)isin);
icos <<= 15 - lc;
isin <<= 15 - ls;
return (ls - lc) * (1 << 11) +
frac_mul16(isin, frac_mul16(isin, -2597) + 7932) -
frac_mul16(icos, frac_mul16(icos, -2597) + 7932);
}
static uint32_t lcg(uint32_t s)
{
return 1664525 * s + 1013904223;
}
static unsigned isqrt32(uint32_t v)
{
unsigned r = (unsigned)sqrt((double)v);
while ((uint64_t)r * r > v)
r--;
while ((uint64_t)(r + 1) * (r + 1) <= v)
r++;
return r;
}
static uint32_t pvq_u(const struct celt_dec *d, int a, int b)
{
if (a > b) {
int t = a;
a = b;
b = t;
}
return d->pvq[a * PVQ_N + b];
}
/* ---- the decoder ---- */
struct celt_dec *jcelt_new(int channels)
{
struct celt_dec *d = calloc(1, sizeof *d);
if (!d)
return NULL;
d->cc = channels;
d->end = NB;
for (int i = 0; i < 4; i++)
if (!(d->mdct[i] = aimdct_new(240 << i))) {
jcelt_free(d);
return NULL;
}
d->pvq = calloc((size_t)PVQ_K * PVQ_N, sizeof *d->pvq);
if (!d->pvq) {
jcelt_free(d);
return NULL;
}
/* U(n, k) = U(n - 1, k) + U(n, k - 1) + U(n - 1, k - 1), U(0, 0) = 1 */
uint64_t row[2][PVQ_N + 2];
uint64_t *prev = row[0], *cur = row[1];
for (int k = 0; k < PVQ_N; k++)
prev[k] = k == 0;
for (int a = 0; a < PVQ_K; a++) {
for (int b = a; b < PVQ_N; b++)
d->pvq[a * PVQ_N + b] =
prev[b] > 0xFFFFFFFFu ? 0xFFFFFFFFu : (uint32_t)prev[b];
/* the next row from this one */
cur[0] = 0;
for (int k = 1; k < PVQ_N; k++) {
uint64_t v = prev[k] + cur[k - 1] + prev[k - 1];
cur[k] = v > (1ull << 40) ? (1ull << 40) : v;
}
uint64_t *t = prev;
prev = cur;
cur = t;
}
jcelt_reset(d);
return d;
}
void jcelt_free(struct celt_dec *d)
{
if (!d)
return;
for (int i = 0; i < 4; i++)
aimdct_free(d->mdct[i]);
free(d->pvq);
free(d);
}
void jcelt_reset(struct celt_dec *d)
{
memset(d->mem, 0, sizeof d->mem);
memset(d->old_e, 0, sizeof d->old_e);
memset(d->bg_loge, 0, sizeof d->bg_loge);
for (int i = 0; i < 2 * NB; i++)
d->old_loge[i] = d->old_loge2[i] = -28.f;
d->preemph[0] = d->preemph[1] = 0;
d->pf_period = d->pf_period_old = d->pf_tapset = d->pf_tapset_old = 0;
d->pf_gain = d->pf_gain_old = 0;
d->rng = 0;
d->loss_duration = 0;
d->skip_plc = 1;
d->last_pitch = 0;
d->prefilter_and_fold = 0;
memset(d->lpc, 0, sizeof d->lpc);
}
void jcelt_bands(struct celt_dec *d, int start, int end)
{
d->start = start;
d->end = end;
}
uint32_t jcelt_rng(const struct celt_dec *d)
{
return d->rng;
}
/* ---- energies ---- */
static int laplace(struct rc *r, unsigned fs, int decay)
{
int val = 0;
unsigned fl = 0, fm = rc_decode_bin(r, 15);
if (fm >= fs) {
val++;
fl = fs;
fs = ((32768 - 2 * 16 - fs) * (unsigned)(16384 - decay) >> 15) + 1;
while (fs > 1 && fm >= fl + 2 * fs) {
fs *= 2;
fl += fs;
fs = ((fs - 2) * (unsigned)decay >> 15) + 1;
val++;
}
if (fs <= 1) {
int di = (int)((fm - fl) >> 1);
val += di;
fl += 2 * (unsigned)di;
}
if (fm < fl + fs)
val = -val;
else
fl += fs;
}
rc_update(r, fl, fl + fs < 32768 ? fl + fs : 32768, 32768);
return val;
}
static void coarse_energy(struct celt_dec *d, struct rc *r, int intra, int C,
int LM)
{
static const float PRED[4] = {29440 / 32768.f, 26112 / 32768.f,
21248 / 32768.f, 16384 / 32768.f};
static const float BETA[4] = {30147 / 32768.f, 22282 / 32768.f,
12124 / 32768.f, 6554 / 32768.f};
static const uint8_t SMALL[3] = {2, 1, 0};
const uint8_t *prob = CELT_EPROB + (LM * 2 + intra) * 42;
float prev[2] = {0, 0};
float coef = intra ? 0 : PRED[LM], beta = intra ? 4915 / 32768.f : BETA[LM];
int budget = (int)r->storage * 8;
for (int i = d->start; i < d->end; i++)
for (int c = 0; c < C; c++) {
int tell = rc_tell(r), qi;
if (budget - tell >= 15) {
int pi = 2 * imin(i, 20);
qi = laplace(r, (unsigned)prob[pi] << 7, prob[pi + 1] << 6);
} else if (budget - tell >= 2) {
qi = rc_icdf(r, SMALL, 2);
qi = (qi >> 1) ^ -(qi & 1);
} else if (budget - tell >= 1) {
qi = -rc_bit_logp(r, 1);
} else {
qi = -1;
}
float q = (float)qi, *e = &d->old_e[i + c * NB];
*e = *e > -9.f ? *e : -9.f;
*e = coef * *e + prev[c] + q;
prev[c] = prev[c] + q - beta * q;
}
}
static void tf_decode(struct rc *r, int start, int end, int transient, int *tf,
int LM)
{
uint32_t budget = r->storage * 8, tell = (uint32_t)rc_tell(r);
int logp = transient ? 2 : 4, changed = 0, curr = 0;
int rsv = LM > 0 && tell + (uint32_t)logp + 1 <= budget;
budget -= (uint32_t)rsv;
for (int i = start; i < end; i++) {
if (tell + (uint32_t)logp <= budget) {
curr ^= rc_bit_logp(r, (unsigned)logp);
tell = (uint32_t)rc_tell(r);
changed |= curr;
}
tf[i] = curr;
logp = transient ? 4 : 5;
}
int sel = 0;
const int8_t *t = CELT_TF_SELECT + 8 * LM;
if (rsv && t[4 * transient + changed] != t[4 * transient + 2 + changed])
sel = rc_bit_logp(r, 1);
for (int i = start; i < end; i++)
tf[i] = t[4 * transient + 2 * sel + tf[i]];
}
/* ---- the allocation ---- */
static const uint8_t LOG2_FRAC[24] = {0, 8, 13, 16, 19, 21, 23, 24,
26, 27, 28, 29, 30, 31, 32, 32,
33, 34, 34, 35, 36, 36, 37, 37};
static const uint8_t *cache_of(int LM, int band)
{
return CELT_CACHE_BITS + CELT_CACHE_INDEX[(LM + 1) * NB + band];
}
static int bits2pulses(int band, int LM, int bits)
{
const uint8_t *cache = cache_of(LM, band);
int lo = 0, hi = cache[0];
bits--;
for (int i = 0; i < 6; i++) {
int mid = (lo + hi + 1) >> 1;
if ((int)cache[mid] >= bits)
hi = mid;
else
lo = mid;
}
if (bits - (lo == 0 ? -1 : (int)cache[lo]) <= (int)cache[hi] - bits)
return lo;
return hi;
}
static int pulses2bits(int band, int LM, int pulses)
{
return pulses == 0 ? 0 : cache_of(LM, band)[pulses] + 1;
}
static int get_pulses(int i)
{
return i < 8 ? i : (8 + (i & 7)) << ((i >> 3) - 1);
}
static int band_w(int j)
{
return CELT_EBANDS[j + 1] - CELT_EBANDS[j];
}
static int interp_bits2pulses(struct rc *r, int start, int end, int skip_start,
const int *bits1, const int *bits2,
const int *thresh, const int *cap, int32_t total,
int32_t *balance_out, int skip_rsv,
int *intensity, int intensity_rsv,
int *dual_stereo, int dual_stereo_rsv, int *bits,
int *ebits, int *fine_priority, int C, int LM)
{
int alloc_floor = C << BITRES, stereo = C > 1, logM = LM << BITRES;
int lo = 0, hi = 1 << 6, coded;
int32_t psum;
for (int i = 0; i < 6; i++) {
int mid = (lo + hi) >> 1, done = 0;
psum = 0;
for (int j = end; j-- > start;) {
int tmp = bits1[j] + (mid * bits2[j] >> 6);
if (tmp >= thresh[j] || done) {
done = 1;
psum += imin(tmp, cap[j]);
} else if (tmp >= alloc_floor) {
psum += alloc_floor;
}
}
if (psum > total)
hi = mid;
else
lo = mid;
}
psum = 0;
int done = 0;
for (int j = end; j-- > start;) {
int tmp = bits1[j] + (lo * bits2[j] >> 6);
if (tmp < thresh[j] && !done)
tmp = tmp >= alloc_floor ? alloc_floor : 0;
else
done = 1;
tmp = imin(tmp, cap[j]);
bits[j] = tmp;
psum += tmp;
}
for (coded = end;; coded--) {
int j = coded - 1;
if (j <= skip_start) {
total += skip_rsv;
break;
}
int32_t left = total - psum;
int span = CELT_EBANDS[coded] - CELT_EBANDS[start];
int32_t percoeff = left / span;
left -= span * percoeff;
int rem = imax((int)left - (CELT_EBANDS[j] - CELT_EBANDS[start]), 0);
int bw = CELT_EBANDS[coded] - CELT_EBANDS[j];
int band_bits = (int)(bits[j] + percoeff * bw + rem);
if (band_bits >= imax(thresh[j], alloc_floor + (1 << BITRES))) {
if (rc_bit_logp(r, 1))
break;
psum += 1 << BITRES;
band_bits -= 1 << BITRES;
}
psum -= bits[j] + intensity_rsv;
if (intensity_rsv > 0)
intensity_rsv = LOG2_FRAC[j - start];
psum += intensity_rsv;
if (band_bits >= alloc_floor) {
psum += alloc_floor;
bits[j] = alloc_floor;
} else {
bits[j] = 0;
}
}
if (intensity_rsv > 0)
*intensity = start + (int)rc_uint(r, (uint32_t)(coded + 1 - start));
else
*intensity = 0;
if (*intensity <= start) {
total += dual_stereo_rsv;
dual_stereo_rsv = 0;
}
*dual_stereo = dual_stereo_rsv > 0 ? rc_bit_logp(r, 1) : 0;
int32_t left = total - psum;
int span = CELT_EBANDS[coded] - CELT_EBANDS[start];
int32_t percoeff = left / span;
left -= span * percoeff;
for (int j = start; j < coded; j++)
bits[j] += (int)percoeff * band_w(j);
for (int j = start; j < coded; j++) {
int tmp = (int)(left < band_w(j) ? left : band_w(j));
bits[j] += tmp;
left -= tmp;
}
int32_t balance = 0;
int j;
for (j = start; j < coded; j++) {
int N0 = band_w(j), N = N0 << LM;
int32_t bit = bits[j] + balance, excess;
if (N > 1) {
excess = bit - cap[j] > 0 ? bit - cap[j] : 0;
bits[j] = (int)(bit - excess);
int den =
C * N + (C == 2 && N > 2 && !*dual_stereo && j < *intensity);
int nclogn = den * (CELT_LOGN[j] + logM);
int offset = (nclogn >> 1) - den * FINE_OFFSET;
if (N == 2)
offset += den << BITRES >> 2;
if (bits[j] + offset < den * 2 << BITRES)
offset += nclogn >> 2;
else if (bits[j] + offset < den * 3 << BITRES)
offset += nclogn >> 3;
ebits[j] = imax(0, bits[j] + offset + (den << (BITRES - 1)));
ebits[j] = (ebits[j] / den) >> BITRES;
if (C * ebits[j] > (bits[j] >> BITRES))
ebits[j] = bits[j] >> stereo >> BITRES;
ebits[j] = imin(ebits[j], MAX_FINE_BITS);
fine_priority[j] = ebits[j] * (den << BITRES) >= bits[j] + offset;
bits[j] -= C * ebits[j] << BITRES;
} else {
excess = bit - (C << BITRES) > 0 ? bit - (C << BITRES) : 0;
bits[j] = (int)(bit - excess);
ebits[j] = 0;
fine_priority[j] = 1;
}
if (excess > 0) {
int extra_fine = imin((int)(excess >> (stereo + BITRES)),
MAX_FINE_BITS - ebits[j]);
ebits[j] += extra_fine;
int extra_bits = extra_fine * C << BITRES;
fine_priority[j] = extra_bits >= excess - balance;
excess -= extra_bits;
}
balance = excess;
}
*balance_out = balance;
for (; j < end; j++) {
ebits[j] = bits[j] >> stereo >> BITRES;
bits[j] = 0;
fine_priority[j] = ebits[j] < 1;
}
return coded;
}
static int allocation(struct rc *r, int start, int end, const int *offsets,
const int *cap, int trim, int *intensity, int *dual,
int32_t total, int32_t *balance, int *pulses, int *ebits,
int *fine_priority, int C, int LM)
{
int bits1[NB], bits2[NB], thresh[NB], trim_off[NB];
total = total > 0 ? total : 0;
int skip_start = start;
int skip_rsv = total >= 1 << BITRES ? 1 << BITRES : 0;
total -= skip_rsv;
int intensity_rsv = 0, dual_rsv = 0;
if (C == 2) {
intensity_rsv = LOG2_FRAC[end - start];
if (intensity_rsv > total) {
intensity_rsv = 0;
} else {
total -= intensity_rsv;
dual_rsv = total >= 1 << BITRES ? 1 << BITRES : 0;
total -= dual_rsv;
}
}
for (int j = start; j < end; j++) {
thresh[j] = imax(C << BITRES, (3 * band_w(j) << LM << BITRES) >> 4);
trim_off[j] = C * band_w(j) * (trim - 5 - LM) * (end - j - 1) *
(1 << (LM + BITRES)) >>
6;
if (band_w(j) << LM == 1)
trim_off[j] -= C << BITRES;
}
int lo = 1, hi = 11 - 1;
do {
int done = 0, psum = 0, mid = (lo + hi) >> 1;
for (int j = end; j-- > start;) {
int b = C * band_w(j) * CELT_ALLOC[mid * NB + j] << LM >> 2;
if (b > 0)
b = imax(0, b + trim_off[j]);
b += offsets[j];
if (b >= thresh[j] || done) {
done = 1;
psum += imin(b, cap[j]);
} else if (b >= C << BITRES) {
psum += C << BITRES;
}
}
if (psum > total)
hi = mid - 1;
else
lo = mid + 1;
} while (lo <= hi);
hi = lo--;
for (int j = start; j < end; j++) {
int b1 = C * band_w(j) * CELT_ALLOC[lo * NB + j] << LM >> 2;
int b2 = hi >= 11 ? cap[j]
: C * band_w(j) * CELT_ALLOC[hi * NB + j] << LM >> 2;
if (b1 > 0)
b1 = imax(0, b1 + trim_off[j]);
if (b2 > 0)
b2 = imax(0, b2 + trim_off[j]);
if (lo > 0)
b1 += offsets[j];
b2 += offsets[j];
if (offsets[j] > 0)
skip_start = j;
b2 = imax(0, b2 - b1);
bits1[j] = b1;
bits2[j] = b2;
}
return interp_bits2pulses(r, start, end, skip_start, bits1, bits2, thresh,
cap, total, balance, skip_rsv, intensity,
intensity_rsv, dual, dual_rsv, pulses, ebits,
fine_priority, C, LM);
}
/* ---- the shapes ---- */
static void exp_rotation1(float *X, int len, int stride, float c, float s)
{
float ms = -s, *x = X;
for (int i = 0; i < len - stride; i++) {
float x1 = x[0], x2 = x[stride];
x[stride] = c * x2 + s * x1;
*x++ = c * x1 + ms * x2;
}
x = &X[len - 2 * stride - 1];
for (int i = len - 2 * stride - 1; i >= 0; i--) {
float x1 = x[0], x2 = x[stride];
x[stride] = c * x2 + s * x1;
*x-- = c * x1 + ms * x2;
}
}
static void exp_rotation(float *X, int len, int stride, int K, int spread)
{
static const int FACTOR[3] = {15, 10, 5};
if (2 * K >= len || spread == SPREAD_NONE)
return;
int factor = FACTOR[spread - 1], stride2 = 0;
float gain = (float)len / (float)(len + factor * K);
float theta = .5f * gain * gain;
float c = cosf(.5f * (float)M_PI * theta);
float s = cosf(.5f * (float)M_PI * (1.f - theta));
if (len >= 8 * stride) {
stride2 = 1;
while ((stride2 * stride2 + stride2) * stride + (stride >> 2) < len)
stride2++;
}
len /= stride;
for (int i = 0; i < stride; i++) {
if (stride2)
exp_rotation1(X + i * len, len, stride2, s, c);
exp_rotation1(X + i * len, len, 1, c, s);
}
}
static void renormalise(float *X, int N, float gain)
{
float E = 1e-15f;
for (int i = 0; i < N; i++)
E += X[i] * X[i];
float g = gain * (1.f / sqrtf(E));
for (int i = 0; i < N; i++)
X[i] *= g;
}
/* the vector of pulses with index i among those of n dimensions and k
pulses (the reference's cwrsi), into y: their squared norm */
static float cwrsi(const struct celt_dec *d, int n, int k, uint32_t i, int *y)
{
float yy = 0;
while (n > 2) {
uint32_t p, q;
int s, k0, val;
if (k >= n) {
p = pvq_u(d, n, k + 1);
s = -(i >= p);
i -= p & (uint32_t)s;
k0 = k;
q = pvq_u(d, n, n);
if (q > i) {
k = n;
do
p = pvq_u(d, --k, n);
while (p > i);
} else {
for (p = pvq_u(d, n, k); p > i; p = pvq_u(d, n, k))
k--;
}
i -= p;
val = (k0 - k + s) ^ s;
} else {
p = pvq_u(d, k, n);
q = pvq_u(d, k + 1, n);
if (p <= i && i < q) {
i -= p;
val = 0;
} else {
s = -(i >= q);
i -= q & (uint32_t)s;
k0 = k;
do
p = pvq_u(d, --k, n);
while (p > i);
i -= p;
val = (k0 - k + s) ^ s;
}
}
*y++ = val;
yy += (float)val * val;
n--;
}
uint32_t p = 2 * (uint32_t)k + 1;
int s = -(i >= p);
i -= p & (uint32_t)s;
int k0 = k;
k = (int)((i + 1) >> 1);
if (k)
i -= 2 * (uint32_t)k - 1;
int val = (k0 - k + s) ^ s;
*y++ = val;
yy += (float)val * val;
s = -(int)i;
val = (k + s) ^ s;
*y = val;
yy += (float)val * val;
return yy;
}
static unsigned alg_unquant(const struct celt_dec *d, float *X, int N, int K,
int spread, int B, struct rc *r, float gain)
{
int iy[176];
uint32_t idx = rc_uint(r, pvq_u(d, N, K) + pvq_u(d, N, K + 1));
float ryy = cwrsi(d, N, K, idx, iy);
float g = gain * (1.f / sqrtf(ryy));
for (int i = 0; i < N; i++)
X[i] = g * (float)iy[i];
exp_rotation(X, N, B, K, spread);
if (B <= 1)
return 1;
int N0 = N / B;
unsigned mask = 0;
for (int i = 0; i < B; i++) {
int t = 0;
for (int j = 0; j < N0; j++)
t |= iy[i * N0 + j];
mask |= (unsigned)(t != 0) << i;
}
return mask;
}
static void haar1(float *X, int N0, int stride)
{
N0 >>= 1;
for (int i = 0; i < stride; i++)
for (int j = 0; j < N0; j++) {
float a = .70710678f * X[stride * 2 * j + i];
float b = .70710678f * X[stride * (2 * j + 1) + i];
X[stride * 2 * j + i] = a + b;
X[stride * (2 * j + 1) + i] = a - b;
}
}
static void deinterleave(float *X, int N0, int stride, int hadamard)
{
float tmp[960];
int N = N0 * stride;
for (int i = 0; i < stride; i++)
for (int j = 0; j < N0; j++) {
int to = hadamard ? CELT_ORDERY[stride - 2 + i] : i;
tmp[to * N0 + j] = X[j * stride + i];
}
memcpy(X, tmp, sizeof(float) * (size_t)N);
}
static void interleave(float *X, int N0, int stride, int hadamard)
{
float tmp[960];
int N = N0 * stride;
for (int i = 0; i < stride; i++)
for (int j = 0; j < N0; j++) {
int from = hadamard ? CELT_ORDERY[stride - 2 + i] : i;
tmp[j * stride + i] = X[from * N0 + j];
}
memcpy(X, tmp, sizeof(float) * (size_t)N);
}
static int compute_qn(int N, int b, int offset, int pulse_cap, int stereo)
{
static const int16_t EXP2[8] = {16384, 17866, 19483, 21247,
23170, 25267, 27554, 30048};
int N2 = 2 * N - 1;
if (stereo && N == 2)
N2--;
int qb = (b + N2 * offset) / N2;
qb = imin(b - pulse_cap - (4 << BITRES), qb);
qb = imin(8 << BITRES, qb);
if (qb < (1 << BITRES >> 1))
return 1;
int qn = EXP2[qb & 7] >> (14 - (qb >> BITRES));
return (qn + 1) >> 1 << 1;
}
struct bctx {
struct celt_dec *d;
struct rc *r;
int i, intensity, spread, tf_change, avoid_split_noise;
int32_t remaining;
uint32_t seed;
};
struct split {
int inv, imid, iside, delta, itheta, qalloc;
};
static void compute_theta(struct bctx *c, struct split *s, int N, int *b, int B,
int B0, int LM, int stereo, int *fill)
{
struct rc *r = c->r;
int i = c->i, itheta = 0, inv = 0;
int pulse_cap = CELT_LOGN[i] + LM * (1 << BITRES);
int offset = (pulse_cap >> 1) -
(stereo && N == 2 ? QTHETA_OFFSET_TWOPHASE : QTHETA_OFFSET);
int qn = compute_qn(N, *b, offset, pulse_cap, stereo);
if (stereo && i >= c->intensity)
qn = 1;
uint32_t tell = rc_tell_frac(r);
if (qn != 1) {
if (stereo && N > 2) {
int p0 = 3, x0 = qn / 2, ft = p0 * (x0 + 1) + x0, x;
int fs = (int)rc_decode(r, (unsigned)ft);
if (fs < (x0 + 1) * p0)
x = fs / p0;
else
x = x0 + 1 + (fs - (x0 + 1) * p0);
rc_update(
r, (unsigned)(x <= x0 ? p0 * x : (x - 1 - x0) + (x0 + 1) * p0),
(unsigned)(x <= x0 ? p0 * (x + 1) : (x - x0) + (x0 + 1) * p0),
(unsigned)ft);
itheta = x;
} else if (B0 > 1 || stereo) {
itheta = (int)rc_uint(r, (uint32_t)qn + 1);
} else {
int ft = ((qn >> 1) + 1) * ((qn >> 1) + 1), fs, fl;
int fm = (int)rc_decode(r, (unsigned)ft);
if (fm < ((qn >> 1) * ((qn >> 1) + 1) >> 1)) {
itheta = (int)(isqrt32(8 * (uint32_t)fm + 1) - 1) >> 1;
fs = itheta + 1;
fl = itheta * (itheta + 1) >> 1;
} else {
itheta = (int)(2 * (qn + 1) -
(int)isqrt32(8 * (uint32_t)(ft - fm - 1) + 1)) >>
1;
fs = qn + 1 - itheta;
fl = ft - ((qn + 1 - itheta) * (qn + 2 - itheta) >> 1);
}
rc_update(r, (unsigned)fl, (unsigned)(fl + fs), (unsigned)ft);
}
itheta = itheta * 16384 / qn;
} else if (stereo) {
inv = *b > 2 << BITRES && c->remaining > 2 << BITRES ? rc_bit_logp(r, 2)
: 0;
itheta = 0;
}
int qalloc = (int)(rc_tell_frac(r) - tell);
*b -= qalloc;
int imid, iside, delta;
if (itheta == 0) {
imid = 32767;
iside = 0;
*fill &= (1 << B) - 1;
delta = -16384;
} else if (itheta == 16384) {
imid = 0;
iside = 32767;
*fill &= ((1 << B) - 1) << B;
delta = 16384;
} else {
imid = bitexact_cos(itheta);
iside = bitexact_cos(16384 - itheta);
delta = frac_mul16((N - 1) << 7, bitexact_log2tan(iside, imid));
}
s->inv = inv;
s->imid = imid;
s->iside = iside;
s->delta = delta;
s->itheta = itheta;
s->qalloc = qalloc;
}
static unsigned band_n1(struct bctx *c, float *X, float *Y, float *lowband_out)
{
float *x = X;
for (int k = 0; k < 1 + (Y != NULL); k++) {
int sign = 0;
if (c->remaining >= 1 << BITRES) {
sign = (int)rc_bits(c->r, 1);
c->remaining -= 1 << BITRES;
}
x[0] = sign ? -1.f : 1.f;
x = Y;
}
if (lowband_out)
lowband_out[0] = X[0];
return 1;
}
static unsigned partition(struct bctx *c, float *X, int N, int b, int B,
float *lowband, int LM, float gain, int fill)
{
int i = c->i, B0 = B;
unsigned cm = 0;
const uint8_t *cache = cache_of(LM, i);
if (LM != -1 && b > cache[cache[0]] + 12 && N > 2) {
struct split s;
float *Y, *next_lowband2 = NULL;
N >>= 1;
Y = X + N;
LM -= 1;
if (B == 1)
fill = (fill & 1) | (fill << 1);
B = (B + 1) >> 1;
compute_theta(c, &s, N, &b, B, B0, LM, 0, &fill);
float mid = (1.f / 32768) * s.imid, side = (1.f / 32768) * s.iside;
int delta = s.delta;
if (B0 > 1 && (s.itheta & 0x3fff)) {
if (s.itheta > 8192)
delta -= delta >> (4 - LM);
else
delta = imin(0, delta + (N << BITRES >> (5 - LM)));
}
int mbits = imax(0, imin(b, (b - delta) / 2)), sbits = b - mbits;
c->remaining -= s.qalloc;
if (lowband)
next_lowband2 = lowband + N;
int32_t rebalance = c->remaining;
if (mbits >= sbits) {
cm = partition(c, X, N, mbits, B, lowband, LM, gain * mid, fill);
rebalance = mbits - (rebalance - c->remaining);
if (rebalance > 3 << BITRES && s.itheta != 0)
sbits += (int)rebalance - (3 << BITRES);
cm |= partition(c, Y, N, sbits, B, next_lowband2, LM, gain * side,
fill >> B)
<< (B0 >> 1);
} else {
cm = partition(c, Y, N, sbits, B, next_lowband2, LM, gain * side,
fill >> B)
<< (B0 >> 1);
rebalance = sbits - (rebalance - c->remaining);
if (rebalance > 3 << BITRES && s.itheta != 16384)
mbits += (int)rebalance - (3 << BITRES);
cm |= partition(c, X, N, mbits, B, lowband, LM, gain * mid, fill);
}
return cm;
}
int q = bits2pulses(i, LM, b), curr = pulses2bits(i, LM, q);
c->remaining -= curr;
while (c->remaining < 0 && q > 0) {
c->remaining += curr;
q--;
curr = pulses2bits(i, LM, q);
c->remaining -= curr;
}
if (q != 0)
return alg_unquant(c->d, X, N, get_pulses(q), c->spread, B, c->r, gain);
unsigned mask = (unsigned)(1UL << B) - 1;
fill &= (int)mask;
if (!fill) {
memset(X, 0, sizeof(float) * (size_t)N);
return 0;
}
if (!lowband) {
for (int j = 0; j < N; j++) {
c->seed = lcg(c->seed);
X[j] = (float)((int32_t)c->seed >> 20);
}
cm = mask;
} else {
for (int j = 0; j < N; j++) {
c->seed = lcg(c->seed);
X[j] = lowband[j] + (c->seed & 0x8000 ? 1.f / 256 : -1.f / 256);
}
cm = (unsigned)fill;
}
renormalise(X, N, gain);
return cm;
}
static unsigned quant_band(struct bctx *c, float *X, int N, int b, int B,
float *lowband, int LM, float *lowband_out,
float gain, float *scratch, int fill)
{
int N0 = N, N_B = N, B0 = B, time_divide = 0, recombine = 0;
int long_blocks = B0 == 1, tf_change = c->tf_change;
N_B /= B;
if (N == 1)
return band_n1(c, X, NULL, lowband_out);
if (tf_change > 0)
recombine = tf_change;
if (scratch && lowband &&
(recombine || ((N_B & 1) == 0 && tf_change < 0) || B0 > 1)) {
memcpy(scratch, lowband, sizeof(float) * (size_t)N);
lowband = scratch;
}
for (int k = 0; k < recombine; k++) {
static const uint8_t T[16] = {0, 1, 1, 1, 2, 3, 3, 3,
2, 3, 3, 3, 2, 3, 3, 3};
if (lowband)
haar1(lowband, N >> k, 1 << k);
fill = T[fill & 0xF] | T[fill >> 4] << 2;
}
B >>= recombine;
N_B <<= recombine;
while ((N_B & 1) == 0 && tf_change < 0) {
if (lowband)
haar1(lowband, N_B, B);
fill |= fill << B;
B <<= 1;
N_B >>= 1;
time_divide++;
tf_change++;
}
B0 = B;
int N_B0 = N_B;
if (B0 > 1 && lowband)
deinterleave(lowband, N_B >> recombine, B0 << recombine, long_blocks);
unsigned cm = partition(c, X, N, b, B, lowband, LM, gain, fill);
if (B0 > 1)
interleave(X, N_B >> recombine, B0 << recombine, long_blocks);
N_B = N_B0;
B = B0;
for (int k = 0; k < time_divide; k++) {
B >>= 1;
N_B <<= 1;
cm |= cm >> B;
haar1(X, N_B, B);
}
for (int k = 0; k < recombine; k++) {
static const uint8_t T[16] = {0x00, 0x03, 0x0C, 0x0F, 0x30, 0x33,
0x3C, 0x3F, 0xC0, 0xC3, 0xCC, 0xCF,
0xF0, 0xF3, 0xFC, 0xFF};
cm = T[cm];
haar1(X, N0 >> k, 1 << k);
}
B <<= recombine;
if (lowband_out) {
float n = sqrtf((float)N0);
for (int j = 0; j < N0; j++)
lowband_out[j] = n * X[j];
}
return cm & ((1u << B) - 1);
}
static void stereo_merge(float *X, float *Y, float mid, int N)
{
float xp = 0, side = 0;
for (int j = 0; j < N; j++) {
xp += Y[j] * X[j];
side += Y[j] * Y[j];
}
xp *= mid;
float El = mid * mid + side - 2 * xp, Er = mid * mid + side + 2 * xp;
if (Er < 6e-4f || El < 6e-4f) {
memcpy(Y, X, sizeof(float) * (size_t)N);
return;
}
float lgain = 1.f / sqrtf(El), rgain = 1.f / sqrtf(Er);
for (int j = 0; j < N; j++) {
float l = mid * X[j], r = Y[j];
X[j] = lgain * (l - r);
Y[j] = rgain * (l + r);
}
}
static unsigned band_stereo(struct bctx *c, float *X, float *Y, int N, int b,
int B, float *lowband, int LM, float *lowband_out,
float *scratch, int fill)
{
if (N == 1)
return band_n1(c, X, Y, lowband_out);
int orig_fill = fill;
struct split s;
unsigned cm;
compute_theta(c, &s, N, &b, B, B, LM, 1, &fill);
float mid = (1.f / 32768) * s.imid, side = (1.f / 32768) * s.iside;
if (N == 2) {
int mbits = b, sbits = 0, sign = 0;
if (s.itheta != 0 && s.itheta != 16384)
sbits = 1 << BITRES;
mbits -= sbits;
int ch = s.itheta > 8192;
c->remaining -= s.qalloc + sbits;
float *x2 = ch ? Y : X, *y2 = ch ? X : Y;
if (sbits)
sign = (int)rc_bits(c->r, 1);
sign = 1 - 2 * sign;
cm = quant_band(c, x2, N, mbits, B, lowband, LM, lowband_out, 1.f,
scratch, orig_fill);
y2[0] = (float)-sign * x2[1];
y2[1] = (float)sign * x2[0];
X[0] *= mid;
X[1] *= mid;
Y[0] *= side;
Y[1] *= side;
float t = X[0];
X[0] = t - Y[0];
Y[0] = t + Y[0];
t = X[1];
X[1] = t - Y[1];
Y[1] = t + Y[1];
} else {
int mbits = imax(0, imin(b, (b - s.delta) / 2)), sbits = b - mbits;
c->remaining -= s.qalloc;
int32_t rebalance = c->remaining;
if (mbits >= sbits) {
cm = quant_band(c, X, N, mbits, B, lowband, LM, lowband_out, 1.f,
scratch, fill);
rebalance = mbits - (rebalance - c->remaining);
if (rebalance > 3 << BITRES && s.itheta != 0)
sbits += (int)rebalance - (3 << BITRES);
cm |= quant_band(c, Y, N, sbits, B, NULL, LM, NULL, side, NULL,
fill >> B);
} else {
cm = quant_band(c, Y, N, sbits, B, NULL, LM, NULL, side, NULL,
fill >> B);
rebalance = sbits - (rebalance - c->remaining);
if (rebalance > 3 << BITRES && s.itheta != 16384)
mbits += (int)rebalance - (3 << BITRES);
cm |= quant_band(c, X, N, mbits, B, lowband, LM, lowband_out, 1.f,
scratch, fill);
}
}
if (N != 2)
stereo_merge(X, Y, mid, N);
if (s.inv)
for (int j = 0; j < N; j++)
Y[j] = -Y[j];
return cm;
}
static void all_bands(struct celt_dec *d, struct rc *r, int start, int end,
float *X_, float *Y_, uint8_t *collapse, int *pulses,
int short_blocks, int spread, int dual_stereo,
int intensity, int *tf_res, int32_t total_bits,
int32_t balance, int LM, int coded_bands)
{
int M = 1 << LM, B = short_blocks ? M : 1, C = Y_ ? 2 : 1;
int norm_off = M * CELT_EBANDS[start], update_lowband = 1;
int lowband_offset = 0;
float *norm = d->norm, *norm2 = norm + M * CELT_EBANDS[NB - 1] - norm_off;
float *scratch = X_ + M * CELT_EBANDS[NB - 1];
struct bctx c = {.d = d,
.r = r,
.intensity = intensity,
.spread = spread,
.seed = d->rng,
.avoid_split_noise = B > 1};
for (int i = start; i < end; i++) {
int last = i == end - 1, effective_lowband = -1, b;
float *X = X_ + M * CELT_EBANDS[i],
*Y = Y_ ? Y_ + M * CELT_EBANDS[i] : NULL;
int N = M * CELT_EBANDS[i + 1] - M * CELT_EBANDS[i];
unsigned x_cm, y_cm;
c.i = i;
int32_t tell = (int32_t)rc_tell_frac(r);
if (i != start)
balance -= tell;
int32_t remaining = total_bits - tell - 1;
c.remaining = remaining;
if (i <= coded_bands - 1) {
int32_t curr_balance = balance / imin(3, coded_bands - i);
b = imax(0, imin(16383, (int)imin((int)(remaining + 1),
pulses[i] + (int)curr_balance)));
} else {
b = 0;
}
if ((M * CELT_EBANDS[i] - N >= M * CELT_EBANDS[start] ||
i == start + 1) &&
(update_lowband || lowband_offset == 0))
lowband_offset = i;
if (i == start + 1) { /* the folding of the second band, in hybrid */
int n1 = M * band_w(start), n2 = M * band_w(start + 1);
if (n2 > n1) {
memmove(&norm[n1], &norm[2 * n1 - n2],
sizeof(float) * (size_t)(n2 - n1));
if (dual_stereo)
memmove(&norm2[n1], &norm2[2 * n1 - n2],
sizeof(float) * (size_t)(n2 - n1));
}
}
c.tf_change = tf_res[i];
float *sc = scratch;
if (last)
sc = NULL;
if (lowband_offset != 0 &&
(spread != SPREAD_AGGRESSIVE || B > 1 || c.tf_change < 0)) {
effective_lowband =
imax(0, M * CELT_EBANDS[lowband_offset] - norm_off - N);
int fold_start = lowband_offset;
while (M * CELT_EBANDS[--fold_start] > effective_lowband + norm_off)
;
int fold_end = lowband_offset - 1;
while (++fold_end < i &&
M * CELT_EBANDS[fold_end] < effective_lowband + norm_off + N)
;
x_cm = y_cm = 0;
int f = fold_start;
do {
x_cm |= collapse[f * C + 0];
y_cm |= collapse[f * C + C - 1];
} while (++f < fold_end);
} else {
x_cm = y_cm = (1u << B) - 1;
}
if (dual_stereo && i == intensity) {
dual_stereo = 0;
for (int j = 0; j < M * CELT_EBANDS[i] - norm_off; j++)
norm[j] = .5f * (norm[j] + norm2[j]);
}
float *lo1 = effective_lowband != -1 ? norm + effective_lowband : NULL;
float *out1 = last ? NULL : norm + M * CELT_EBANDS[i] - norm_off;
if (dual_stereo) {
float *lo2 =
effective_lowband != -1 ? norm2 + effective_lowband : NULL;
float *out2 = last ? NULL : norm2 + M * CELT_EBANDS[i] - norm_off;
x_cm = quant_band(&c, X, N, b / 2, B, lo1, LM, out1, 1.f, sc,
(int)x_cm);
y_cm = quant_band(&c, Y, N, b / 2, B, lo2, LM, out2, 1.f, sc,
(int)y_cm);
} else {
if (Y)
x_cm = band_stereo(&c, X, Y, N, b, B, lo1, LM, out1, sc,
(int)(x_cm | y_cm));
else
x_cm = quant_band(&c, X, N, b, B, lo1, LM, out1, 1.f, sc,
(int)(x_cm | y_cm));
y_cm = x_cm;
}
collapse[i * C + 0] = (uint8_t)x_cm;
collapse[i * C + C - 1] = (uint8_t)y_cm;
balance += pulses[i] + tell;
update_lowband = b > (N << BITRES);
c.avoid_split_noise = 0;
}
d->rng = c.seed;
}
static void anti_collapse(struct celt_dec *d, float *X_, const uint8_t *masks,
int LM, int C, int size, int start, int end,
const int *pulses)
{
uint32_t seed = d->rng;
for (int i = start; i < end; i++) {
int N0 = band_w(i);
int depth = (1 + pulses[i]) / N0 >> LM;
float thresh = .5f * exp2f(-.125f * (float)depth);
float sqrt_1 = 1.f / sqrtf((float)(N0 << LM));
for (int c = 0; c < C; c++) {
float prev1 = d->old_loge[c * NB + i],
prev2 = d->old_loge2[c * NB + i];
if (C == 1) {
prev1 =
prev1 > d->old_loge[NB + i] ? prev1 : d->old_loge[NB + i];
prev2 =
prev2 > d->old_loge2[NB + i] ? prev2 : d->old_loge2[NB + i];
}
float ediff =
d->old_e[c * NB + i] - (prev1 < prev2 ? prev1 : prev2);
ediff = ediff > 0 ? ediff : 0;
float rr = 2.f * exp2f(-ediff);
if (LM == 3)
rr *= 1.41421356f;
rr = rr < thresh ? rr : thresh;
rr *= sqrt_1;
float *X = X_ + c * size + (CELT_EBANDS[i] << LM);
int renorm = 0;
for (int k = 0; k < 1 << LM; k++)
if (!(masks[i * C + c] & 1 << k)) {
for (int j = 0; j < N0; j++) {
seed = lcg(seed);
X[(j << LM) + k] = seed & 0x8000 ? rr : -rr;
}
renorm = 1;
}
if (renorm)
renormalise(X, N0 << LM, 1.f);
}
}
}
/* ---- synthesis ---- */
static void denormalise(const float *X, float *freq, const float *loge,
int start, int end, int M, int N, int silence)
{
int bound = M * CELT_EBANDS[end];
if (silence) {
bound = 0;
start = end = 0;
}
memset(freq, 0, sizeof(float) * (size_t)N);
for (int i = start; i < end; i++) {
float lg = loge[i] + CELT_EMEANS[i];
float g = exp2f(lg < 32.f ? lg : 32.f);
for (int j = M * CELT_EBANDS[i]; j < M * CELT_EBANDS[i + 1]; j++)
freq[j] = X[j] * g;
}
(void)bound;
}
/* the inverse MDCT of a block of n / 2 coefficients (every stride-th of
in) into out[OV / 2 ...], then its overlap mirrored with what out[0 ..
OV) held */
static void imdct_block(struct celt_dec *d, int which, const float *in,
int stride, float *out)
{
struct aimdct *m = d->mdct[which];
int N2 = 120 << which;
aimdct_dct4(m, in, stride, d->u);
for (int k = 0; k < N2; k++)
out[OV / 2 + k] = -d->u[N2 - 1 - k];
const float *w = CELT_WINDOW;
for (int i = 0; i < OV / 2; i++) {
float x1 = out[OV - 1 - i], x2 = out[i];
out[i] = w[OV - 1 - i] * x2 - w[i] * x1;
out[OV - 1 - i] = w[i] * x2 + w[OV - 1 - i] * x1;
}
}
static void synthesis(struct celt_dec *d, float *X, float **out_syn, int start,
int end, int C, int CC, int transient, int LM,
int silence)
{
int M = 1 << LM, N = 120 << LM, B, NB_, which;
if (transient) {
B = M;
NB_ = 120;
which = 0;
} else {
B = 1;
NB_ = N;
which = LM;
}
float *freq = d->freq;
if (CC == 2 && C == 1) {
denormalise(X, freq, d->old_e, start, end, M, N, silence);
for (int c = 0; c < 2; c++)
for (int b = 0; b < B; b++)
imdct_block(d, which, freq + b, B, out_syn[c] + NB_ * b);
} else if (CC == 1 && C == 2) {
float *f2 = d->freq2;
denormalise(X, freq, d->old_e, start, end, M, N, silence);
denormalise(X + N, f2, d->old_e + NB, start, end, M, N, silence);
for (int i = 0; i < N; i++)
freq[i] = .5f * freq[i] + .5f * f2[i];
for (int b = 0; b < B; b++)
imdct_block(d, which, freq + b, B, out_syn[0] + NB_ * b);
} else {
for (int c = 0; c < CC; c++) {
denormalise(X + c * N, freq, d->old_e + c * NB, start, end, M, N,
silence);
for (int b = 0; b < B; b++)
imdct_block(d, which, freq + b, B, out_syn[c] + NB_ * b);
}
}
}
/* the pitch post-filter (pre-filter with negative gains): y from x, which
may be the same buffer, its history before it */
static void comb_filter(float *y, const float *x, int T0, int T1, int N,
float g0, float g1, int tap0, int tap1, int overlap)
{
static const float G[3][3] = {{0.3066406250f, 0.2170410156f, 0.1296386719f},
{0.4638671875f, 0.2680664062f, 0.f},
{0.7998046875f, 0.1000976562f, 0.f}};
if (g0 == 0 && g1 == 0) {
if (x != y)
memmove(y, x, sizeof(float) * (size_t)N);
return;
}
T0 = imax(T0, 15);
T1 = imax(T1, 15);
float g00 = g0 * G[tap0][0], g01 = g0 * G[tap0][1], g02 = g0 * G[tap0][2];
float g10 = g1 * G[tap1][0], g11 = g1 * G[tap1][1], g12 = g1 * G[tap1][2];
float x1 = x[-T1 + 1], x2 = x[-T1], x3 = x[-T1 - 1], x4 = x[-T1 - 2];
if (g0 == g1 && T0 == T1 && tap0 == tap1)
overlap = 0;
int i;
for (i = 0; i < overlap; i++) {
float x0 = x[i - T1 + 2];
float f = CELT_WINDOW[i] * CELT_WINDOW[i];
y[i] = x[i] + (1.f - f) * g00 * x[i - T0] +
(1.f - f) * g01 * (x[i - T0 + 1] + x[i - T0 - 1]) +
(1.f - f) * g02 * (x[i - T0 + 2] + x[i - T0 - 2]) +
f * g10 * x2 + f * g11 * (x1 + x3) + f * g12 * (x0 + x4);
x4 = x3;
x3 = x2;
x2 = x1;
x1 = x0;
}
if (g1 == 0) {
if (x != y)
memmove(y + overlap, x + overlap,
sizeof(float) * (size_t)(N - overlap));
return;
}
x4 = x[i - T1 - 2];
x3 = x[i - T1 - 1];
x2 = x[i - T1];
x1 = x[i - T1 + 1];
for (; i < N; i++) {
float x0 = x[i - T1 + 2];
y[i] = x[i] + g10 * x2 + g11 * (x1 + x3) + g12 * (x0 + x4);
x4 = x3;
x3 = x2;
x2 = x1;
x1 = x0;
}
}
/* the concealed overlap pre-filtered and folded as an MDCT would leave
it, so the next decoded frame blends with it */
static void prefilter_and_fold(struct celt_dec *d, int N)
{
float etmp[OV];
for (int c = 0; c < d->cc; c++) {
comb_filter(etmp, d->mem[c] + DBS - N, d->pf_period_old, d->pf_period,
OV, -d->pf_gain_old, -d->pf_gain, d->pf_tapset_old,
d->pf_tapset, 0);
for (int i = 0; i < OV / 2; i++)
d->mem[c][DBS - N + i] = CELT_WINDOW[i] * etmp[OV - 1 - i] +
CELT_WINDOW[OV - i - 1] * etmp[i];
}
}
int jcelt_frame(struct celt_dec *d, struct rc *r, int len, int n, int stream_ch,
float **out)
{
static const uint8_t SPREAD_ICDF[4] = {25, 23, 2, 0};
static const uint8_t TRIM_ICDF[11] = {126, 124, 119, 109, 87, 41,
19, 9, 4, 2, 0};
static const uint8_t TAPSET_ICDF[3] = {2, 1, 0};
int LM, C = stream_ch, CC = d->cc, start = d->start, end = d->end;
for (LM = 0; LM <= 3 && 120 << LM != n; LM++)
;
if (LM > 3 || len < 0 || len > 1275)
return -1;
int M = 1 << LM, N = n;
float *out_syn[2];
for (int c = 0; c < CC; c++)
out_syn[c] = d->mem[c] + DBS - N;
int eff_end = end > NB ? NB : end;
if (C == 1)
for (int i = 0; i < NB; i++)
d->old_e[i] =
d->old_e[i] > d->old_e[NB + i] ? d->old_e[i] : d->old_e[NB + i];
if (d->loss_duration == 0)
d->skip_plc = 0;
int32_t total_bits = len * 8;
int tell = rc_tell(r), silence;
if (tell >= total_bits)
silence = 1;
else if (tell == 1)
silence = rc_bit_logp(r, 15);
else
silence = 0;
if (silence) {
tell = len * 8;
r->nbits_total += tell - rc_tell(r);
}
float pf_gain = 0;
int pf_pitch = 0, pf_tapset = 0;
if (start == 0 && tell + 16 <= total_bits) {
if (rc_bit_logp(r, 1)) {
int octave = (int)rc_uint(r, 6);
pf_pitch =
(16 << octave) + (int)rc_bits(r, 4 + (unsigned)octave) - 1;
int qg = (int)rc_bits(r, 3);
if (rc_tell(r) + 2 <= total_bits)
pf_tapset = rc_icdf(r, TAPSET_ICDF, 2);
pf_gain = .09375f * (float)(qg + 1);
}
tell = rc_tell(r);
}
int transient = 0;
if (LM > 0 && tell + 3 <= total_bits) {
transient = rc_bit_logp(r, 3);
tell = rc_tell(r);
}
int short_blocks = transient ? M : 0;
int intra = tell + 3 <= total_bits ? rc_bit_logp(r, 3) : 0;
if (!intra && d->loss_duration != 0) {
/* after concealment, a safe start for the energy's prediction */
int missing = imin(10, d->loss_duration >> LM);
float safety = LM == 0 ? 1.5f : LM == 1 ? .5f : 0;
for (int c = 0; c < 2; c++)
for (int i = start; i < end; i++) {
float *e = &d->old_e[c * NB + i];
float e1 = d->old_loge[c * NB + i],
e2 = d->old_loge2[c * NB + i];
if (*e < (e1 > e2 ? e1 : e2)) {
float slope =
e1 - *e > .5f * (e2 - *e) ? e1 - *e : .5f * (e2 - *e);
float t = (1 + missing) * slope;
float v = *e - (t > 0 ? t : 0);
*e = v > -20.f ? v : -20.f;
} else {
float m = *e < e1 ? *e : e1;
*e = m < e2 ? m : e2;
}
*e -= safety;
}
}
coarse_energy(d, r, intra, C, LM);
int tf_res[NB];
tf_decode(r, start, end, transient, tf_res, LM);
tell = rc_tell(r);
int spread = SPREAD_NORMAL;
if (tell + 4 <= total_bits)
spread = rc_icdf(r, SPREAD_ICDF, 5);
int cap[NB], offsets[NB];
for (int i = 0; i < NB; i++) {
int w = band_w(i) << LM;
cap[i] = (CELT_CACHE_CAPS[NB * (2 * LM + C - 1) + i] + 64) * C * w >> 2;
}
int dynalloc_logp = 6;
total_bits <<= BITRES;
uint32_t tf = rc_tell_frac(r);
for (int i = start; i < end; i++) {
int width = C * band_w(i) << LM;
int quanta = imin(width << BITRES, imax(6 << BITRES, width));
int loop_logp = dynalloc_logp, boost = 0;
while ((int32_t)tf + (loop_logp << BITRES) < total_bits &&
boost < cap[i]) {
int flag = rc_bit_logp(r, (unsigned)loop_logp);
tf = rc_tell_frac(r);
if (!flag)
break;
boost += quanta;
total_bits -= quanta;
loop_logp = 1;
}
offsets[i] = boost;
if (boost > 0)
dynalloc_logp = imax(2, dynalloc_logp - 1);
}
for (int i = 0; i < start; i++)
offsets[i] = 0;
int trim = (int32_t)tf + (6 << BITRES) <= total_bits
? rc_icdf(r, TRIM_ICDF, 7)
: 5;
int32_t bits =
(((int32_t)len * 8) << BITRES) - (int32_t)rc_tell_frac(r) - 1;
int anti_rsv =
transient && LM >= 2 && bits >= ((LM + 2) << BITRES) ? 1 << BITRES : 0;
bits -= anti_rsv;
int pulses[NB], fine_quant[NB], fine_prio[NB], intensity = 0, dual = 0;
int32_t balance = 0;
int coded =
allocation(r, start, end, offsets, cap, trim, &intensity, &dual, bits,
&balance, pulses, fine_quant, fine_prio, C, LM);
for (int i = start; i < end; i++) {
if (fine_quant[i] <= 0)
continue;
for (int c = 0; c < C; c++) {
int q2 = (int)rc_bits(r, (unsigned)fine_quant[i]);
d->old_e[i + c * NB] += ((float)q2 + .5f) *
(float)(1 << (14 - fine_quant[i])) *
(1.f / 16384) -
.5f;
}
}
for (int c = 0; c < CC; c++)
memmove(d->mem[c], d->mem[c] + N,
sizeof(float) * (size_t)(DBS - N + OV));
uint8_t collapse[2 * NB];
float *X = d->x;
memset(X, 0, sizeof(float) * (size_t)(C * N));
all_bands(d, r, start, end, X, C == 2 ? X + N : NULL, collapse, pulses,
short_blocks, spread, dual, intensity, tf_res,
len * (8 << BITRES) - anti_rsv, balance, LM, coded);
int anti_on = anti_rsv > 0 ? (int)rc_bits(r, 1) : 0;
int bits_left = len * 8 - rc_tell(r);
for (int prio = 0; prio < 2; prio++)
for (int i = start; i < end && bits_left >= C; i++) {
if (fine_quant[i] >= MAX_FINE_BITS || fine_prio[i] != prio)
continue;
for (int c = 0; c < C; c++) {
int q2 = (int)rc_bits(r, 1);
d->old_e[i + c * NB] += ((float)q2 - .5f) *
(float)(1 << (14 - fine_quant[i] - 1)) *
(1.f / 16384);
bits_left--;
}
}
if (anti_on)
anti_collapse(d, X, collapse, LM, C, N, start, end, pulses);
if (silence)
for (int i = 0; i < C * NB; i++)
d->old_e[i] = -28.f;
if (d->prefilter_and_fold)
prefilter_and_fold(d, N);
synthesis(d, X, out_syn, start, eff_end, C, CC, transient, LM, silence);
for (int c = 0; c < CC; c++) {
d->pf_period = imax(d->pf_period, 15);
d->pf_period_old = imax(d->pf_period_old, 15);
comb_filter(out_syn[c], out_syn[c], d->pf_period_old, d->pf_period, 120,
d->pf_gain_old, d->pf_gain, d->pf_tapset_old, d->pf_tapset,
OV);
if (LM != 0)
comb_filter(out_syn[c] + 120, out_syn[c] + 120, d->pf_period,
pf_pitch, N - 120, d->pf_gain, pf_gain, d->pf_tapset,
pf_tapset, OV);
}
d->pf_period_old = d->pf_period;
d->pf_gain_old = d->pf_gain;
d->pf_tapset_old = d->pf_tapset;
d->pf_period = pf_pitch;
d->pf_gain = pf_gain;
d->pf_tapset = pf_tapset;
if (LM != 0) {
d->pf_period_old = d->pf_period;
d->pf_gain_old = d->pf_gain;
d->pf_tapset_old = d->pf_tapset;
}
if (C == 1)
memcpy(&d->old_e[NB], d->old_e, sizeof(float) * NB);
if (!transient) {
memcpy(d->old_loge2, d->old_loge, sizeof d->old_loge);
memcpy(d->old_loge, d->old_e, sizeof d->old_e);
} else {
for (int i = 0; i < 2 * NB; i++)
d->old_loge[i] =
d->old_loge[i] < d->old_e[i] ? d->old_loge[i] : d->old_e[i];
}
float max_bg = (float)imin(160, d->loss_duration + M) * 0.001f;
for (int i = 0; i < 2 * NB; i++)
d->bg_loge[i] = d->bg_loge[i] + max_bg < d->old_e[i]
? d->bg_loge[i] + max_bg
: d->old_e[i];
for (int c = 0; c < 2; c++) {
for (int i = 0; i < start; i++) {
d->old_e[c * NB + i] = 0;
d->old_loge[c * NB + i] = d->old_loge2[c * NB + i] = -28.f;
}
for (int i = end; i < NB; i++) {
d->old_e[c * NB + i] = 0;
d->old_loge[c * NB + i] = d->old_loge2[c * NB + i] = -28.f;
}
}
d->rng = r->rng;
d->loss_duration = 0;
d->prefilter_and_fold = 0;
for (int c = 0; c < CC; c++) {
float m = d->preemph[c];
for (int j = 0; j < N; j++) {
float tmp = out_syn[c][j] + 1e-30f + m;
m = 0.85000610f * tmp;
out[c][j] = tmp * (1.f / 32768);
}
d->preemph[c] = m;
}
return rc_tell(r) > 8 * len ? -1 : 0;
}
/* ---- concealment ---- */
static void autocorr(const float *x, float *ac, const float *window,
int overlap, int lag, int n)
{
float xx[1024];
const float *xp = x;
if (overlap) {
memcpy(xx, x, sizeof(float) * (size_t)n);
for (int i = 0; i < overlap; i++) {
xx[i] = x[i] * window[i];
xx[n - i - 1] = x[n - i - 1] * window[i];
}
xp = xx;
}
for (int k = 0; k <= lag; k++) {
float s = 0;
for (int i = k; i < n; i++)
s += xp[i] * xp[i - k];
ac[k] = s;
}
}
static void celt_lpc(float *lpc, const float *ac, int p)
{
float err = ac[0];
memset(lpc, 0, sizeof(float) * (size_t)p);
if (ac[0] <= 1e-10f)
return;
for (int i = 0; i < p; i++) {
float rr = 0;
for (int j = 0; j < i; j++)
rr += lpc[j] * ac[i - j];
rr += ac[i + 1];
float r = -rr / err;
lpc[i] = r;
for (int j = 0; j < (i + 1) >> 1; j++) {
float t1 = lpc[j], t2 = lpc[i - 1 - j];
lpc[j] = t1 + r * t2;
lpc[i - 1 - j] = t2 + r * t1;
}
err = err - r * r * err;
if (err <= .001f * ac[0])
break;
}
}
static void find_best_pitch(const float *xcorr, const float *y, int len,
int max_pitch, int *best)
{
float Syy = 1, bnum[2] = {-1, -1}, bden[2] = {0, 0};
best[0] = 0;
best[1] = 1;
for (int j = 0; j < len; j++)
Syy += y[j] * y[j];
for (int i = 0; i < max_pitch; i++) {
if (xcorr[i] > 0) {
float x16 = xcorr[i] * 1e-12f, num = x16 * x16;
if (num * bden[1] > bnum[1] * Syy) {
if (num * bden[0] > bnum[0] * Syy) {
bnum[1] = bnum[0];
bden[1] = bden[0];
best[1] = best[0];
bnum[0] = num;
bden[0] = Syy;
best[0] = i;
} else {
bnum[1] = num;
bden[1] = Syy;
best[1] = i;
}
}
}
Syy += y[i + len] * y[i + len] - y[i] * y[i];
Syy = Syy > 1 ? Syy : 1;
}
}
static int plc_pitch(struct celt_dec *d)
{
float lp[DBS >> 1];
float ac[5], lpc[4], lpc2[5], tmp = 1.f;
int len = DBS, C = d->cc;
for (int i = 1; i < len >> 1; i++) {
lp[i] = .25f * d->mem[0][2 * i - 1] + .25f * d->mem[0][2 * i + 1] +
.5f * d->mem[0][2 * i];
if (C == 2)
lp[i] += .25f * d->mem[1][2 * i - 1] + .25f * d->mem[1][2 * i + 1] +
.5f * d->mem[1][2 * i];
}
lp[0] = .25f * d->mem[0][1] + .5f * d->mem[0][0];
if (C == 2)
lp[0] += .25f * d->mem[1][1] + .5f * d->mem[1][0];
autocorr(lp, ac, NULL, 0, 4, len >> 1);
ac[0] *= 1.0001f;
for (int i = 1; i <= 4; i++)
ac[i] -= ac[i] * (.008f * i) * (.008f * i);
celt_lpc(lpc, ac, 4);
for (int i = 0; i < 4; i++) {
tmp *= .9f;
lpc[i] *= tmp;
}
lpc2[0] = lpc[0] + .8f;
lpc2[1] = lpc[1] + .8f * lpc[0];
lpc2[2] = lpc[2] + .8f * lpc[1];
lpc2[3] = lpc[3] + .8f * lpc[2];
lpc2[4] = .8f * lpc[3];
float m[5] = {0, 0, 0, 0, 0};
for (int i = 0; i < len >> 1; i++) {
float s = lp[i] + lpc2[0] * m[0] + lpc2[1] * m[1] + lpc2[2] * m[2] +
lpc2[3] * m[3] + lpc2[4] * m[4];
m[4] = m[3];
m[3] = m[2];
m[2] = m[1];
m[1] = m[0];
m[0] = lp[i];
lp[i] = s;
}
/* the search: x the last part, y all of it */
const float *x = lp + (720 >> 1), *y = lp;
int slen = DBS - 720, max_pitch = 720 - 100, lag = slen + max_pitch;
float x4[(DBS - 720) >> 2], y4[(DBS + 620) >> 2], xcorr[(720 - 100) >> 1];
int best[2] = {0, 0};
for (int j = 0; j < slen >> 2; j++)
x4[j] = x[2 * j];
for (int j = 0; j < lag >> 2; j++)
y4[j] = y[2 * j];
for (int i = 0; i < max_pitch >> 2; i++) {
float s = 0;
for (int j = 0; j < slen >> 2; j++)
s += x4[j] * y4[i + j];
xcorr[i] = s;
}
find_best_pitch(xcorr, y4, slen >> 2, max_pitch >> 2, best);
for (int i = 0; i < max_pitch >> 1; i++) {
xcorr[i] = 0;
if (abs(i - 2 * best[0]) > 2 && abs(i - 2 * best[1]) > 2)
continue;
float s = 0;
for (int j = 0; j < slen >> 1; j++)
s += x[j] * y[i + j];
xcorr[i] = s > -1 ? s : -1;
}
find_best_pitch(xcorr, y, slen >> 1, max_pitch >> 1, best);
int offset = 0;
if (best[0] > 0 && best[0] < (max_pitch >> 1) - 1) {
float a = xcorr[best[0] - 1], b = xcorr[best[0]],
c = xcorr[best[0] + 1];
if ((c - a) > .7f * (b - a))
offset = 1;
else if ((a - c) > .7f * (b - c))
offset = -1;
}
return 720 - (2 * best[0] - offset);
}
void jcelt_plc(struct celt_dec *d, int n, float **out)
{
int LM, N = n, C = d->cc, start = d->start;
for (LM = 0; LM < 3 && 120 << LM != n; LM++)
;
if (120 << LM != n) { /* not a CELT frame's size: silence */
for (int c = 0; c < C; c++)
if (out[c] && n > 0)
memset(out[c], 0, sizeof(float) * (size_t)n);
return;
}
float *out_syn[2];
for (int c = 0; c < C; c++)
out_syn[c] = d->mem[c] + DBS - N;
int noise = d->loss_duration >= 40 || start != 0 || d->skip_plc;
if (noise) {
int end = d->end, eff_end = imax(start, imin(end, NB));
for (int c = 0; c < C; c++)
memmove(d->mem[c], d->mem[c] + N,
sizeof(float) * (size_t)(DBS - N + OV));
if (d->prefilter_and_fold)
prefilter_and_fold(d, N);
float decay = d->loss_duration == 0 ? 1.5f : .5f;
for (int c = 0; c < C; c++)
for (int i = start; i < end; i++) {
float *e = &d->old_e[c * NB + i], v = *e - decay;
*e = d->bg_loge[c * NB + i] > v ? d->bg_loge[c * NB + i] : v;
}
uint32_t seed = d->rng;
float *X = d->x;
for (int c = 0; c < C; c++)
for (int i = start; i < eff_end; i++) {
int off = N * c + (CELT_EBANDS[i] << LM);
int blen = band_w(i) << LM;
for (int j = 0; j < blen; j++) {
seed = lcg(seed);
X[off + j] = (float)((int32_t)seed >> 20);
}
renormalise(X + off, blen, 1.f);
}
d->rng = seed;
synthesis(d, X, out_syn, start, eff_end, C, C, 0, LM, 0);
d->prefilter_and_fold = 0;
d->skip_plc = 1;
} else {
float fade = 1.f;
int pitch;
if (d->loss_duration == 0) {
d->last_pitch = pitch = plc_pitch(d);
} else {
pitch = d->last_pitch;
fade = .8f;
}
int exc_len = imin(2 * pitch, 1024);
float exc_buf[1024 + 24], fir_tmp[1024], *exc = exc_buf + 24;
for (int c = 0; c < C; c++) {
float *buf = d->mem[c], S1 = 0;
for (int i = 0; i < 1024 + 24; i++)
exc[i - 24] = buf[DBS - 1024 - 24 + i];
if (d->loss_duration == 0) {
float ac[25];
autocorr(exc, ac, CELT_WINDOW, OV, 24, 1024);
ac[0] *= 1.0001f;
for (int i = 1; i <= 24; i++)
ac[i] -= ac[i] * (0.008f * 0.008f) * i * i;
celt_lpc(d->lpc[c], ac, 24);
}
for (int i = 0; i < exc_len; i++) {
float s = exc[1024 - exc_len + i];
for (int k = 0; k < 24; k++)
s += d->lpc[c][k] * exc[1024 - exc_len + i - k - 1];
fir_tmp[i] = s;
}
memcpy(exc + 1024 - exc_len, fir_tmp,
sizeof(float) * (size_t)exc_len);
float E1 = 1, E2 = 1;
int dl = exc_len >> 1;
for (int i = 0; i < dl; i++) {
float e = exc[1024 - dl + i];
E1 += e * e;
e = exc[1024 - 2 * dl + i];
E2 += e * e;
}
E1 = E1 < E2 ? E1 : E2;
float decay = sqrtf((E1 * .5f) / E2);
memmove(buf, buf + N, sizeof(float) * (size_t)(DBS - N));
int ex_off = 1024 - pitch, ex_len = N + OV;
float att = fade * decay;
for (int i = 0, j = 0; i < ex_len; i++, j++) {
if (j >= pitch) {
j -= pitch;
att *= decay;
}
buf[DBS - N + i] = att * exc[ex_off + j];
float t = buf[DBS - 1024 - N + ex_off + j];
S1 += t * t;
}
float mem[24];
for (int i = 0; i < 24; i++)
mem[i] = buf[DBS - N - 1 - i];
for (int i = 0; i < ex_len; i++) {
float s = buf[DBS - N + i];
for (int k = 0; k < 24; k++)
s -= d->lpc[c][k] * mem[k];
memmove(mem + 1, mem, 23 * sizeof(float));
mem[0] = s;
buf[DBS - N + i] = s;
}
float S2 = 0;
for (int i = 0; i < ex_len; i++)
S2 += buf[DBS - N + i] * buf[DBS - N + i];
if (!(S1 > 0.2f * S2)) {
for (int i = 0; i < ex_len; i++)
buf[DBS - N + i] = 0;
} else if (S1 < S2) {
float ratio = sqrtf((S1 * .5f + 1) / (S2 + 1));
for (int i = 0; i < OV; i++)
buf[DBS - N + i] *= 1.f - CELT_WINDOW[i] * (1.f - ratio);
for (int i = OV; i < ex_len; i++)
buf[DBS - N + i] *= ratio;
}
}
d->prefilter_and_fold = 1;
}
d->loss_duration = imin(10000, d->loss_duration + (1 << LM));
for (int c = 0; c < C; c++) {
float m = d->preemph[c];
for (int j = 0; j < N; j++) {
float tmp = out_syn[c][j] + 1e-30f + m;
m = 0.85000610f * tmp;
out[c][j] = tmp * (1.f / 32768);
}
d->preemph[c] = m;
}
}