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;
73 return (pulses == 0) ? 0 : cache[
pulses] + 1;
80 for (i = 0; i <
N; i++)
91 for (i = 0; i < len -
stride; i++) {
94 Xptr[
stride] = c * x2 + s * x1;
95 *Xptr++ = c * x1 - s * x2;
98 Xptr = &X[len - 2 * stride - 1];
99 for (i = len - 2 * stride - 1; i >= 0; i--) {
102 Xptr[
stride] = c * x2 + s * x1;
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;
125 if (len >= stride << 3) {
129 while ((stride2 * stride2 + stride2) * stride + (stride >> 2) < len)
134 for (i = 0; i <
stride; i++) {
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-4
f || E[1] < 6e-4
f) {
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++) {
192 value[0] = mid * X[
i];
194 X[
i] = gain[0] * (value[0] - value[1]);
195 Y[
i] = gain[1] * (value[0] + value[1]);
205 for (i = 0; i <
stride; i++)
206 for (j = 0; j <
N0; j++)
207 tmp[j*stride+i] = X[order[i]*N0+j];
209 memcpy(X, tmp, N*
sizeof(
float));
218 for (i = 0; i <
stride; i++)
219 for (j = 0; j <
N0; j++)
220 tmp[order[i]*N0+j] = X[j*stride+i];
222 memcpy(X, tmp, N*
sizeof(
float));
229 for (i = 0; i <
stride; i++) {
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];
233 X[stride * (2 * j + 0) + i] = (x0 + x1) *
M_SQRT1_2;
234 X[stride * (2 * j + 1) + i] = (x0 - x1) *
M_SQRT1_2;
244 if (stereo && N == 2)
250 qb =
FFMIN3(b - pulse_cap - (4 << 3), (b + N2 * offset) / N2, 8 << 3);
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)) {
406 phase *=
FFSIGN(X[max_idx]);
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++) {
519 x[0] = 1.0f - 2.0f*sign;
523 lowband_out[0] = X[0];
527 if (!stereo && level == 0) {
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)
543 celt_haar1(quant ? X : lowband, N >> k, 1 << k);
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;
601 itheta = (itheta*qn + 8192) >> 14;
607 else if (stereo || B0 > 1)
611 itheta = itheta * 16384 / qn;
622 else if (stereo || B0 > 1)
626 itheta = itheta * 16384 / qn;
632 for (i = 0; i <
N; i++)
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;
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)) {
735 delta =
FFMIN(0, delta + (N << 3 >> (5 - duration)));
737 mbits =
av_clip((b - delta) / 2, 0, b);
741 if (lowband && !stereo)
742 next_lowband2 = lowband +
N;
747 next_lowband_out1 = lowband_out;
749 next_level = level + 1;
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);
764 cmt = pvq->
quant_band(pvq, f, rc, band, Y,
NULL, N, sbits, blocks,
765 next_lowband2, duration,
NULL, next_level,
766 gain * side,
NULL, fill >> blocks);
767 cm |= cmt << ((B0 >> 1) & (stereo - 1));
772 next_lowband2, duration,
NULL, next_level,
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);
781 cm |= pvq->
quant_band(pvq, f, rc, band, X,
NULL, N, mbits, blocks,
782 lowband, duration, next_lowband_out1, next_level,
783 stereo ? 1.0f : (gain * mid), lowband_scratch, fill);
802 cm =
celt_alg_quant(rc, X, N, (q < 8) ? q : (8 + (q & 7)) << ((q >> 3) - 1),
803 f->
spread, blocks, gain, pvq);
805 cm =
celt_alg_unquant(rc, X, N, (q < 8) ? q : (8 + (q & 7)) << ((q >> 3) - 1),
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;
906 if (CONFIG_OPUS_ENCODER && ARCH_X86)
static void celt_stereo_merge(float *X, float *Y, float mid, int N)
const uint8_t ff_celt_cache_bits[392]
const uint32_t *const ff_celt_pvq_u_row[15]
static int celt_compute_qn(int N, int b, int offset, int pulse_cap, int stereo)
const uint8_t ff_celt_log_freq_range[]
void ff_celt_pvq_init_x86(struct CeltPVQ *s)
static int celt_calc_theta(const float *X, const float *Y, int coupling, int N)
static float ppp_pvq_search_c(float *X, int *y, int K, int N)
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
void ff_opus_rc_enc_log(OpusRangeCoder *rc, int val, uint32_t bits)
uint32_t ff_opus_rc_dec_log(OpusRangeCoder *rc, uint32_t bits)
int av_cold ff_celt_pvq_init(CeltPVQ **pvq, int encode)
const uint8_t ff_celt_bit_deinterleave[]
static uint32_t celt_icwrsi(uint32_t N, uint32_t K, const int *y)
const uint16_t ff_celt_qn_exp2[]
void ff_opus_rc_enc_uint(OpusRangeCoder *rc, uint32_t val, uint32_t size)
CELT: write a uniformly distributed integer.
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_interleave_hadamard(float *tmp, float *X, int N0, int stride, int hadamard)
const uint8_t ff_celt_hadamard_order[]
uint32_t ff_opus_rc_dec_uint_tri(OpusRangeCoder *rc, int qn)
static void celt_stereo_ms_decouple(float *X, float *Y, int N)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
GLsizei GLboolean const GLfloat * value
static void celt_exp_rotation_impl(float *X, uint32_t len, uint32_t stride, float c, float s)
static void celt_deinterleave_hadamard(float *tmp, float *X, int N0, int stride, int hadamard)
static float celt_decode_pulses(OpusRangeCoder *rc, int *y, uint32_t N, uint32_t K)
static void celt_haar1(float *X, int N0, int stride)
float lin_energy[CELT_MAX_BANDS]
void ff_opus_rc_enc_uint_tri(OpusRangeCoder *rc, uint32_t k, int qn)
const int16_t ff_celt_cache_index[105]
static int celt_log2tan(int isin, int icos)
static void celt_encode_pulses(OpusRangeCoder *rc, int *y, uint32_t N, uint32_t K)
int tf_change[CELT_MAX_BANDS]
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 char * split(char *message, char delim)
static int16_t celt_cos(int16_t x)
static uint64_t celt_cwrsi(uint32_t N, uint32_t K, uint32_t i, int *y)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
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 void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
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.
uint32_t ff_opus_rc_dec_uint_step(OpusRangeCoder *rc, int k0)
static av_always_inline void celt_renormalize_vector(float *X, int N, float gain)
static uint32_t celt_extract_collapse_mask(const int *iy, uint32_t N, uint32_t B)
static int celt_pulses2bits(const uint8_t *cache, int pulses)
#define CELT_QTHETA_OFFSET
static void celt_stereo_is_decouple(float *X, float *Y, float e_l, float e_r, int N)
GLint GLenum GLboolean GLsizei stride
#define ROUND_MUL16(a, b)
void ff_opus_rc_put_raw(OpusRangeCoder *rc, uint32_t val, uint32_t count)
CELT: write 0 - 31 bits to the rawbits buffer.
static int celt_bits2pulses(const uint8_t *cache, int bits)
static av_always_inline uint32_t celt_rng(CeltFrame *f)
const uint8_t ff_celt_bit_interleave[]
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_normalize_residual(const int *av_restrict iy, float *av_restrict X, int N, float g)
uint32_t ff_opus_rc_dec_uint(OpusRangeCoder *rc, uint32_t size)
CELT: read a uniform distribution.
void ff_opus_rc_enc_uint_step(OpusRangeCoder *rc, uint32_t val, int k0)
static QUANT_FN(pvq_decode_band)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static double val(void *priv, double ch)
void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)
#define CELT_QTHETA_OFFSET_TWOPHASE
float(* pvq_search)(float *X, int *y, int K, int N)
static av_always_inline uint32_t opus_rc_tell_frac(const OpusRangeCoder *rc)