29 #define CELT_PVQ_U(n, k) (ff_celt_pvq_u_row[FFMIN(n, k)][FFMAX(n, k)])
30 #define CELT_PVQ_V(n, k) (CELT_PVQ_U(n, k) + CELT_PVQ_U(n, (k) + 1))
34 x = (
MUL16(x, x) + 4096) >> 13;
46 return (ls << 11) - (lc << 11) +
59 for (
i = 0;
i < 6;
i++) {
60 int center = (low + high + 1) >> 1;
61 if (cache[center] >=
bits)
67 return (
bits - (low == 0 ? -1 : cache[low]) <= cache[high] -
bits) ? low : high;
80 for (
i = 0;
i <
N;
i++)
95 *Xptr++ =
c * x1 -
s * x2;
103 *Xptr-- =
c * x1 -
s * x2;
108 uint32_t
stride, uint32_t K,
111 uint32_t stride2 = 0;
119 gain = (float)
len / (
len + (20 - 5*spread) * K);
120 theta =
M_PI * gain * gain / 4;
149 int i, j,
N0 =
N /
B;
150 uint32_t collapse_mask = 0;
155 for (
i = 0;
i <
B;
i++)
156 for (j = 0; j <
N0; j++)
157 collapse_mask |= (!!iy[
i*
N0+j]) <<
i;
158 return collapse_mask;
164 float xp = 0, side = 0;
170 for (
i = 0;
i <
N;
i++) {
178 E[0] = mid2 * mid2 + side - 2 * xp;
179 E[1] = mid2 * mid2 + side + 2 * xp;
180 if (
E[0] < 6e-4f ||
E[1] < 6e-4f) {
181 for (
i = 0;
i <
N;
i++)
186 gain[0] = 1.0f / sqrtf(
E[0]);
187 gain[1] = 1.0f / sqrtf(
E[1]);
189 for (
i = 0;
i <
N;
i++) {
206 for (j = 0; j <
N0; j++)
209 memcpy(
X,
tmp,
N*
sizeof(
float));
219 for (j = 0; j <
N0; j++)
222 memcpy(
X,
tmp,
N*
sizeof(
float));
230 for (j = 0; j <
N0; j++) {
231 float x0 =
X[
stride * (2 * j + 0) +
i];
232 float x1 =
X[
stride * (2 * j + 1) +
i];
244 if (stereo &&
N == 2)
251 qn = (qb < (1 << 3 >> 1)) ? 1 : ((
ff_celt_qn_exp2[qb & 0x7] >> (14 - (qb >> 3))) + 1) >> 1 << 1;
256 static inline uint32_t
celt_icwrsi(uint32_t
N, uint32_t K,
const int *y)
258 int i, idx = 0, sum = 0;
259 for (
i =
N - 1;
i >= 0;
i--) {
268 static inline uint64_t
celt_cwrsi(uint32_t
N, uint32_t K, uint32_t
i,
int *y)
294 for (p = row[K]; p >
i; p = row[K])
298 val = (k0 - K +
s) ^
s;
306 if (p <=
i &&
i < q) {
320 val = (k0 - K +
s) ^
s;
338 val = (k0 - K +
s) ^
s;
369 float res = 0.0f, xy_norm = 0.0f;
371 for (
i = 0;
i <
N;
i++)
374 res = K/(res + FLT_EPSILON);
376 for (
i = 0;
i <
N;
i++) {
379 xy_norm += y[
i]*
X[
i];
384 int max_idx = 0, phase =
FFSIGN(K);
385 float max_num = 0.0f;
386 float max_den = 1.0f;
389 for (
i = 0;
i <
N;
i++) {
393 const int ca = 1 ^ ((y[
i] == 0) & (phase < 0));
394 const int y_new = y_norm + 2*phase*
FFABS(y[
i]);
395 float xy_new = xy_norm + 1*phase*
FFABS(
X[
i]);
396 xy_new = xy_new * xy_new;
397 if (ca && (max_den*xy_new) > (y_new*max_num)) {
407 xy_norm += 1*phase*
X[max_idx];
408 y_norm += 2*phase*y[max_idx];
412 return (
float)y_norm;
416 enum CeltSpread spread, uint32_t blocks,
float gain,
432 enum CeltSpread spread, uint32_t blocks,
float gain,
446 float e[2] = { 0.0f, 0.0f };
448 for (
i = 0;
i <
N;
i++) {
449 e[0] += (
X[
i] +
Y[
i])*(
X[
i] +
Y[
i]);
450 e[1] += (
X[
i] -
Y[
i])*(
X[
i] -
Y[
i]);
453 for (
i = 0;
i <
N;
i++) {
464 const float energy_n = 1.0f/(sqrtf(e_l*e_l + e_r*e_r) + FLT_EPSILON);
467 for (
i = 0;
i <
N;
i++)
468 X[
i] = e_l*
X[
i] + e_r*
Y[
i];
474 for (
i = 0;
i <
N;
i++) {
475 const float Xret =
X[
i];
483 const int band,
float *
X,
484 float *
Y,
int N,
int b,
485 uint32_t blocks,
float *lowband,
487 int level,
float gain,
488 float *lowband_scratch,
493 int stereo = !!
Y,
split = stereo;
494 int imid = 0, iside = 0;
496 int N_B =
N / blocks;
502 float mid = 0, side = 0;
503 int longblocks = (
B0 == 1);
508 for (
i = 0;
i <= stereo;
i++) {
510 if (
f->remaining2 >= 1 << 3) {
517 f->remaining2 -= 1 << 3;
519 x[0] = 1.0f - 2.0f*sign;
523 lowband_out[0] =
X[0];
527 if (!stereo &&
level == 0) {
528 int tf_change =
f->tf_change[band];
531 recombine = tf_change;
535 (recombine || ((N_B & 1) == 0 && tf_change < 0) ||
B0 > 1)) {
536 for (
i = 0;
i <
N;
i++)
537 lowband_scratch[
i] = lowband[
i];
538 lowband = lowband_scratch;
541 for (k = 0; k < recombine; k++) {
542 if (
quant || lowband)
546 blocks >>= recombine;
550 while ((N_B & 1) == 0 && tf_change < 0) {
551 if (
quant || lowband)
553 fill |= fill << blocks;
563 if (
B0 > 1 && (
quant || lowband))
565 N_B >> recombine,
B0 << recombine,
572 if (!stereo &&
duration >= 0 &&
b > cache[cache[0]] + 12 &&
N > 2) {
578 fill = (fill & 1) | (fill << 1);
579 blocks = (blocks + 1) >> 1;
585 int mbits, sbits,
delta;
596 qn = (stereo && band >=
f->intensity_stereo) ? 1 :
601 itheta = (itheta*qn + 8192) >> 14;
607 else if (stereo ||
B0 > 1)
611 itheta = itheta * 16384 / qn;
615 f->block[1].lin_energy[band],
N);
622 else if (stereo ||
B0 > 1)
626 itheta = itheta * 16384 / qn;
630 inv =
f->apply_phase_inv ? itheta > 8192 : 0;
632 for (
i = 0;
i <
N;
i++)
636 f->block[1].lin_energy[band],
N);
638 if (
b > 2 << 3 &&
f->remaining2 > 2 << 3) {
645 inv =
f->apply_phase_inv ? inv : 0;
658 }
else if (itheta == 16384) {
661 fill &= ((1 << blocks) - 1) << blocks;
671 mid = imid / 32768.0f;
672 side = iside / 32768.0f;
677 if (
N == 2 && stereo) {
684 sbits = (itheta != 0 && itheta != 16384) ? 1 << 3 : 0;
687 f->remaining2 -= qalloc+sbits;
693 sign = x2[0]*y2[1] - x2[1]*y2[0] < 0;
702 cm = pvq->
quant_band(pvq,
f, rc, band, x2,
NULL,
N, mbits, blocks, lowband,
duration,
703 lowband_out,
level, gain, lowband_scratch, orig_fill);
706 y2[0] = -sign * x2[1];
707 y2[1] = sign * x2[0];
720 float *next_lowband2 =
NULL;
721 float *next_lowband_out1 =
NULL;
728 if (
B0 > 1 && !stereo && (itheta & 0x3fff)) {
739 f->remaining2 -= qalloc;
741 if (lowband && !stereo)
742 next_lowband2 = lowband +
N;
747 next_lowband_out1 = lowband_out;
749 next_level =
level + 1;
751 rebalance =
f->remaining2;
752 if (mbits >= sbits) {
756 lowband,
duration, next_lowband_out1, next_level,
757 stereo ? 1.0f : (gain * mid), lowband_scratch, fill);
758 rebalance = mbits - (rebalance -
f->remaining2);
759 if (rebalance > 3 << 3 && itheta != 0)
760 sbits += rebalance - (3 << 3);
766 gain * side,
NULL, fill >> blocks);
767 cm |= cmt << ((
B0 >> 1) & (stereo - 1));
773 gain * side,
NULL, fill >> blocks);
774 cm <<= ((
B0 >> 1) & (stereo - 1));
775 rebalance = sbits - (rebalance -
f->remaining2);
776 if (rebalance > 3 << 3 && itheta != 16384)
777 mbits += rebalance - (3 << 3);
782 lowband,
duration, next_lowband_out1, next_level,
783 stereo ? 1.0f : (gain * mid), lowband_scratch, fill);
790 f->remaining2 -= curr_bits;
793 while (
f->remaining2 < 0 && q > 0) {
794 f->remaining2 += curr_bits;
796 f->remaining2 -= curr_bits;
803 f->spread, blocks, gain, pvq);
806 f->spread, blocks, gain, pvq);
810 uint32_t cm_mask = (1 << blocks) - 1;
815 for (
i = 0;
i <
N;
i++)
820 for (
i = 0;
i <
N;
i++) {
822 X[
i] = lowband[
i] + (((
celt_rng(
f)) & 0x8000) ? 1.0f / 256 : -1.0f / 256);
828 memset(
X, 0,
N*
sizeof(
float));
838 for (
i = 0;
i <
N;
i++)
841 }
else if (
level == 0) {
847 B0 << recombine, longblocks);
852 for (k = 0; k < time_divide; k++) {
859 for (k = 0; k < recombine; k++) {
863 blocks <<= recombine;
868 for (
i = 0;
i <
N0;
i++)
869 lowband_out[
i] = n *
X[
i];
879 #if CONFIG_OPUS_DECODER
880 return quant_band_template(pvq,
f, rc, band,
X,
Y,
N,
b, blocks, lowband,
duration,
881 lowband_out,
level, gain, lowband_scratch, fill, 0);
889 #if CONFIG_OPUS_ENCODER
890 return quant_band_template(pvq,
f, rc, band,
X,
Y,
N,
b, blocks, lowband,
duration,
891 lowband_out,
level, gain, lowband_scratch, fill, 1);
904 s->quant_band =
encode ? pvq_encode_band : pvq_decode_band;
static double val(void *priv, double ch)
static char * split(char *message, char delim)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define CONFIG_OPUS_ENCODER
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
#define ROUND_MUL16(a, b)
static av_always_inline uint32_t celt_rng(CeltFrame *f)
static av_always_inline void celt_renormalize_vector(float *X, int N, float gain)
#define CELT_QTHETA_OFFSET_TWOPHASE
#define CELT_QTHETA_OFFSET
static uint32_t celt_alg_quant(OpusRangeCoder *rc, float *X, uint32_t N, uint32_t K, enum CeltSpread spread, uint32_t blocks, float gain, CeltPVQ *pvq)
static uint32_t celt_icwrsi(uint32_t N, uint32_t K, const int *y)
static float ppp_pvq_search_c(float *X, int *y, int K, int N)
static uint64_t celt_cwrsi(uint32_t N, uint32_t K, uint32_t i, int *y)
static void celt_stereo_ms_decouple(float *X, float *Y, int N)
static void celt_deinterleave_hadamard(float *tmp, float *X, int N0, int stride, int hadamard)
static void celt_exp_rotation(float *X, uint32_t len, uint32_t stride, uint32_t K, enum CeltSpread spread, const int encode)
static void celt_encode_pulses(OpusRangeCoder *rc, int *y, uint32_t N, uint32_t K)
static float celt_decode_pulses(OpusRangeCoder *rc, int *y, uint32_t N, uint32_t K)
static void celt_stereo_merge(float *X, float *Y, float mid, int N)
static QUANT_FN(pvq_decode_band)
static void celt_interleave_hadamard(float *tmp, float *X, int N0, int stride, int hadamard)
int av_cold ff_celt_pvq_init(CeltPVQ **pvq, int encode)
void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)
static void celt_stereo_is_decouple(float *X, float *Y, float e_l, float e_r, int N)
static int celt_pulses2bits(const uint8_t *cache, int pulses)
static av_always_inline uint32_t quant_band_template(CeltPVQ *pvq, 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, int quant)
static uint32_t celt_extract_collapse_mask(const int *iy, uint32_t N, uint32_t B)
static void celt_exp_rotation_impl(float *X, uint32_t len, uint32_t stride, float c, float s)
static int celt_log2tan(int isin, int icos)
static int celt_bits2pulses(const uint8_t *cache, int bits)
static void celt_haar1(float *X, int N0, int stride)
static int16_t celt_cos(int16_t x)
static int celt_compute_qn(int N, int b, int offset, int pulse_cap, int stereo)
static int celt_calc_theta(const float *X, const float *Y, int coupling, int N)
static uint32_t celt_alg_unquant(OpusRangeCoder *rc, float *X, uint32_t N, uint32_t K, enum CeltSpread spread, uint32_t blocks, float gain, CeltPVQ *pvq)
Decode pulse vector and combine the result with the pitch vector to produce the final normalised sign...
static void celt_normalize_residual(const int *av_restrict iy, float *av_restrict X, int N, float g)
void ff_celt_pvq_init_x86(struct CeltPVQ *s)
uint32_t ff_opus_rc_dec_uint(OpusRangeCoder *rc, uint32_t size)
CELT: read a uniform distribution.
void ff_opus_rc_enc_uint(OpusRangeCoder *rc, uint32_t val, uint32_t size)
CELT: write a uniformly distributed integer.
uint32_t ff_opus_rc_dec_uint_step(OpusRangeCoder *rc, int k0)
void ff_opus_rc_enc_uint_step(OpusRangeCoder *rc, uint32_t val, int k0)
void ff_opus_rc_enc_uint_tri(OpusRangeCoder *rc, uint32_t k, int qn)
void ff_opus_rc_put_raw(OpusRangeCoder *rc, uint32_t val, uint32_t count)
CELT: write 0 - 31 bits to the rawbits buffer.
uint32_t ff_opus_rc_dec_log(OpusRangeCoder *rc, uint32_t bits)
uint32_t ff_opus_rc_dec_uint_tri(OpusRangeCoder *rc, int qn)
uint32_t ff_opus_rc_get_raw(OpusRangeCoder *rc, uint32_t count)
CELT: read 1-25 raw bits at the end of the frame, backwards byte-wise.
void ff_opus_rc_enc_log(OpusRangeCoder *rc, int val, uint32_t bits)
static av_always_inline uint32_t opus_rc_tell_frac(const OpusRangeCoder *rc)
const uint8_t ff_celt_log_freq_range[]
const uint8_t ff_celt_bit_interleave[]
const uint32_t *const ff_celt_pvq_u_row[15]
const uint8_t ff_celt_hadamard_order[]
const uint8_t ff_celt_cache_bits[392]
const uint16_t ff_celt_qn_exp2[]
const int16_t ff_celt_cache_index[105]
const uint8_t ff_celt_bit_deinterleave[]
float(* pvq_search)(float *X, int *y, int K, int N)
static const uint8_t offset[127][2]