first commit
Build AsminVoicechat / prepare-release (push) Successful in 14s
Build AsminVoicechat / build-and-test (17) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (18) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (19) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (20) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (21) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (22) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (23) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (24) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (25) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (26) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (27-ea) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (16) (push) Canceled after 38s
Build AsminVoicechat / prepare-release (push) Successful in 14s
Build AsminVoicechat / build-and-test (17) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (18) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (19) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (20) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (21) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (22) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (23) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (24) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (25) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (26) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (27-ea) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (16) (push) Canceled after 38s
This commit is contained in:
asminme committed
commit
bbccd4a815
454 files changed
+45050
No files matched your search
@@ -0,0 +1,986 @@
|
||||
/*
|
||||
* Decompiled with CFR 0.152.
|
||||
*/
|
||||
package de.maxhenkel.voicechat.concentus;
|
||||
|
||||
import de.maxhenkel.voicechat.concentus.Arrays;
|
||||
import de.maxhenkel.voicechat.concentus.BoxedValueInt;
|
||||
import de.maxhenkel.voicechat.concentus.CeltMode;
|
||||
import de.maxhenkel.voicechat.concentus.CeltTables;
|
||||
import de.maxhenkel.voicechat.concentus.EntropyCoder;
|
||||
import de.maxhenkel.voicechat.concentus.Inlines;
|
||||
import de.maxhenkel.voicechat.concentus.Kernels;
|
||||
import de.maxhenkel.voicechat.concentus.Rate;
|
||||
import de.maxhenkel.voicechat.concentus.VQ;
|
||||
|
||||
class Bands {
|
||||
private static final byte[] bit_interleave_table = new byte[]{0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3};
|
||||
private static final short[] bit_deinterleave_table = new short[]{0, 3, 12, 15, 48, 51, 60, 63, 192, 195, 204, 207, 240, 243, 252, 255};
|
||||
|
||||
Bands() {
|
||||
}
|
||||
|
||||
static int hysteresis_decision(int val, int[] thresholds, int[] hysteresis, int N, int prev) {
|
||||
int i;
|
||||
for (i = 0; i < N && val >= thresholds[i]; ++i) {
|
||||
}
|
||||
if (i > prev && val < thresholds[prev] + hysteresis[prev]) {
|
||||
i = prev;
|
||||
}
|
||||
if (i < prev && val > thresholds[prev - 1] - hysteresis[prev - 1]) {
|
||||
i = prev;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
static int celt_lcg_rand(int seed) {
|
||||
return 1664525 * seed + 1013904223;
|
||||
}
|
||||
|
||||
static int bitexact_cos(int x) {
|
||||
int tmp = 4096 + x * x >> 13;
|
||||
Inlines.OpusAssert(tmp <= Short.MAX_VALUE);
|
||||
int x2 = tmp;
|
||||
x2 = Short.MAX_VALUE - x2 + Inlines.FRAC_MUL16(x2, -7651 + Inlines.FRAC_MUL16(x2, 8277 + Inlines.FRAC_MUL16(-626, x2)));
|
||||
Inlines.OpusAssert(x2 <= 32766);
|
||||
return 1 + x2;
|
||||
}
|
||||
|
||||
static int bitexact_log2tan(int isin, int icos) {
|
||||
int lc = Inlines.EC_ILOG(icos);
|
||||
int ls = Inlines.EC_ILOG(isin);
|
||||
return (ls - lc) * 2048 + Inlines.FRAC_MUL16(isin <<= 15 - ls, Inlines.FRAC_MUL16(isin, -2597) + 7932) - Inlines.FRAC_MUL16(icos <<= 15 - lc, Inlines.FRAC_MUL16(icos, -2597) + 7932);
|
||||
}
|
||||
|
||||
static void compute_band_energies(CeltMode m, int[][] X, int[][] bandE, int end, int C, int LM) {
|
||||
short[] eBands = m.eBands;
|
||||
int N = m.shortMdctSize << LM;
|
||||
int c = 0;
|
||||
do {
|
||||
for (int i = 0; i < end; ++i) {
|
||||
int maxval = 0;
|
||||
int sum = 0;
|
||||
maxval = Inlines.celt_maxabs32(X[c], eBands[i] << LM, eBands[i + 1] - eBands[i] << LM);
|
||||
if (maxval > 0) {
|
||||
int shift = Inlines.celt_ilog2(maxval) - 14 + ((m.logN[i] >> 3) + LM + 1 >> 1);
|
||||
int j = eBands[i] << LM;
|
||||
if (shift > 0) {
|
||||
do {
|
||||
sum = Inlines.MAC16_16(sum, Inlines.EXTRACT16(Inlines.SHR32(X[c][j], shift)), Inlines.EXTRACT16(Inlines.SHR32(X[c][j], shift)));
|
||||
} while (++j < eBands[i + 1] << LM);
|
||||
} else {
|
||||
do {
|
||||
sum = Inlines.MAC16_16(sum, Inlines.EXTRACT16(Inlines.SHL32(X[c][j], -shift)), Inlines.EXTRACT16(Inlines.SHL32(X[c][j], -shift)));
|
||||
} while (++j < eBands[i + 1] << LM);
|
||||
}
|
||||
bandE[c][i] = 1 + Inlines.VSHR32(Inlines.celt_sqrt(sum), -shift);
|
||||
continue;
|
||||
}
|
||||
bandE[c][i] = 1;
|
||||
}
|
||||
} while (++c < C);
|
||||
}
|
||||
|
||||
static void normalise_bands(CeltMode m, int[][] freq, int[][] X, int[][] bandE, int end, int C, int M) {
|
||||
short[] eBands = m.eBands;
|
||||
int c = 0;
|
||||
do {
|
||||
int i = 0;
|
||||
do {
|
||||
int shift = Inlines.celt_zlog2(bandE[c][i]) - 13;
|
||||
int E = Inlines.VSHR32(bandE[c][i], shift);
|
||||
short g = Inlines.EXTRACT16(Inlines.celt_rcp(Inlines.SHL32(E, 3)));
|
||||
int j = M * eBands[i];
|
||||
do {
|
||||
X[c][j] = Inlines.MULT16_16_Q15(Inlines.VSHR32(freq[c][j], shift - 1), (int)g);
|
||||
} while (++j < M * eBands[i + 1]);
|
||||
} while (++i < end);
|
||||
} while (++c < C);
|
||||
}
|
||||
|
||||
static void denormalise_bands(CeltMode m, int[] X, int[] freq, int freq_ptr, int[] bandLogE, int bandLogE_ptr, int start, int end, int M, int downsample, int silence) {
|
||||
int i;
|
||||
short[] eBands = m.eBands;
|
||||
int N = M * m.shortMdctSize;
|
||||
int bound = M * eBands[end];
|
||||
if (downsample != 1) {
|
||||
bound = Inlines.IMIN(bound, N / downsample);
|
||||
}
|
||||
if (silence != 0) {
|
||||
bound = 0;
|
||||
end = 0;
|
||||
start = 0;
|
||||
}
|
||||
int f = freq_ptr;
|
||||
int x = M * eBands[start];
|
||||
for (i = 0; i < M * eBands[start]; ++i) {
|
||||
freq[f++] = 0;
|
||||
}
|
||||
for (i = start; i < end; ++i) {
|
||||
int g;
|
||||
int j = M * eBands[i];
|
||||
int band_end = M * eBands[i + 1];
|
||||
int lg = Inlines.ADD16(bandLogE[bandLogE_ptr + i], (int)Inlines.SHL16(CeltTables.eMeans[i], 6));
|
||||
int shift = 16 - (lg >> 10);
|
||||
if (shift > 31) {
|
||||
shift = 0;
|
||||
g = 0;
|
||||
} else {
|
||||
g = Inlines.celt_exp2_frac(lg & 0x3FF);
|
||||
}
|
||||
if (shift < 0) {
|
||||
if (shift < -2) {
|
||||
g = Short.MAX_VALUE;
|
||||
shift = -2;
|
||||
}
|
||||
do {
|
||||
freq[f] = Inlines.SHR32(Inlines.MULT16_16(X[x], g), -shift);
|
||||
} while (++j < band_end);
|
||||
continue;
|
||||
}
|
||||
do {
|
||||
freq[f++] = Inlines.SHR32(Inlines.MULT16_16(X[x++], g), shift);
|
||||
} while (++j < band_end);
|
||||
}
|
||||
Inlines.OpusAssert(start <= end);
|
||||
Arrays.MemSetWithOffset(freq, 0, freq_ptr + bound, N - bound);
|
||||
}
|
||||
|
||||
static void anti_collapse(CeltMode m, int[][] X_, short[] collapse_masks, int LM, int C, int size, int start, int end, int[] logE, int[] prev1logE, int[] prev2logE, int[] pulses, int seed) {
|
||||
for (int i = start; i < end; ++i) {
|
||||
int N0 = m.eBands[i + 1] - m.eBands[i];
|
||||
Inlines.OpusAssert(pulses[i] >= 0);
|
||||
int depth = Inlines.celt_udiv(1 + pulses[i], m.eBands[i + 1] - m.eBands[i]) >> LM;
|
||||
int thresh32 = Inlines.SHR32(Inlines.celt_exp2(0 - Inlines.SHL16(depth, 7)), 1);
|
||||
int thresh = Inlines.MULT16_32_Q15((short)16384, Inlines.MIN32(Short.MAX_VALUE, thresh32));
|
||||
int t = N0 << LM;
|
||||
int shift = Inlines.celt_ilog2(t) >> 1;
|
||||
t = Inlines.SHL32(t, 7 - shift << 1);
|
||||
int sqrt_1 = Inlines.celt_rsqrt_norm(t);
|
||||
int c = 0;
|
||||
do {
|
||||
int r;
|
||||
boolean renormalize = false;
|
||||
int prev1 = prev1logE[c * m.nbEBands + i];
|
||||
int prev2 = prev2logE[c * m.nbEBands + i];
|
||||
if (C == 1) {
|
||||
prev1 = Inlines.MAX16(prev1, prev1logE[m.nbEBands + i]);
|
||||
prev2 = Inlines.MAX16(prev2, prev2logE[m.nbEBands + i]);
|
||||
}
|
||||
int Ediff = Inlines.EXTEND32(logE[c * m.nbEBands + i]) - Inlines.EXTEND32(Inlines.MIN16(prev1, prev2));
|
||||
if ((Ediff = Inlines.MAX32(0, Ediff)) < 16384) {
|
||||
int r32 = Inlines.SHR32(Inlines.celt_exp2((short)(0 - Inlines.EXTRACT16(Ediff))), 1);
|
||||
r = 2 * Inlines.MIN16(16383, r32);
|
||||
} else {
|
||||
r = 0;
|
||||
}
|
||||
if (LM == 3) {
|
||||
r = Inlines.MULT16_16_Q14(23170, Inlines.MIN32(23169, r));
|
||||
}
|
||||
r = Inlines.SHR16(Inlines.MIN16(thresh, r), 1);
|
||||
r = Inlines.SHR32(Inlines.MULT16_16_Q15(sqrt_1, r), shift);
|
||||
int X = m.eBands[i] << LM;
|
||||
for (int k = 0; k < 1 << LM; ++k) {
|
||||
if ((collapse_masks[i * C + c] & 1 << k) != 0) continue;
|
||||
int Xk = X + k;
|
||||
for (int j = 0; j < N0; ++j) {
|
||||
seed = Bands.celt_lcg_rand(seed);
|
||||
X_[c][Xk + (j << LM)] = (seed & 0x8000) != 0 ? r : 0 - r;
|
||||
}
|
||||
renormalize = true;
|
||||
}
|
||||
if (!renormalize) continue;
|
||||
VQ.renormalise_vector(X_[c], X, N0 << LM, Short.MAX_VALUE);
|
||||
} while (++c < C);
|
||||
}
|
||||
}
|
||||
|
||||
static void intensity_stereo(CeltMode m, int[] X, int X_ptr, int[] Y, int Y_ptr, int[][] bandE, int bandID, int N) {
|
||||
int i = bandID;
|
||||
int shift = Inlines.celt_zlog2(Inlines.MAX32(bandE[0][i], bandE[1][i])) - 13;
|
||||
int left = Inlines.VSHR32(bandE[0][i], shift);
|
||||
int right = Inlines.VSHR32(bandE[1][i], shift);
|
||||
int norm = 1 + Inlines.celt_sqrt(1 + Inlines.MULT16_16(left, left) + Inlines.MULT16_16(right, right));
|
||||
int a1 = Inlines.DIV32_16(Inlines.SHL32(left, 14), norm);
|
||||
int a2 = Inlines.DIV32_16(Inlines.SHL32(right, 14), norm);
|
||||
for (int j = 0; j < N; ++j) {
|
||||
int l = X[X_ptr + j];
|
||||
int r = Y[Y_ptr + j];
|
||||
X[X_ptr + j] = Inlines.EXTRACT16(Inlines.SHR32(Inlines.MAC16_16(Inlines.MULT16_16(a1, l), a2, r), 14));
|
||||
}
|
||||
}
|
||||
|
||||
static void stereo_split(int[] X, int X_ptr, int[] Y, int Y_ptr, int N) {
|
||||
for (int j = 0; j < N; ++j) {
|
||||
int l = Inlines.MULT16_16(23170, X[X_ptr + j]);
|
||||
int r = Inlines.MULT16_16(23170, Y[Y_ptr + j]);
|
||||
X[X_ptr + j] = Inlines.EXTRACT16(Inlines.SHR32(Inlines.ADD32(l, r), 15));
|
||||
Y[Y_ptr + j] = Inlines.EXTRACT16(Inlines.SHR32(Inlines.SUB32(r, l), 15));
|
||||
}
|
||||
}
|
||||
|
||||
static void stereo_merge(int[] X, int X_ptr, int[] Y, int Y_ptr, int mid, int N) {
|
||||
BoxedValueInt xp = new BoxedValueInt(0);
|
||||
BoxedValueInt side = new BoxedValueInt(0);
|
||||
Kernels.dual_inner_prod(Y, Y_ptr, X, X_ptr, Y, Y_ptr, N, xp, side);
|
||||
xp.Val = Inlines.MULT16_32_Q15(mid, xp.Val);
|
||||
int mid2 = Inlines.SHR16(mid, 1);
|
||||
int El = Inlines.MULT16_16(mid2, mid2) + side.Val - 2 * xp.Val;
|
||||
int Er = Inlines.MULT16_16(mid2, mid2) + side.Val + 2 * xp.Val;
|
||||
if (Er < 161061 || El < 161061) {
|
||||
System.arraycopy(X, X_ptr, Y, Y_ptr, N);
|
||||
return;
|
||||
}
|
||||
int kl = Inlines.celt_ilog2(El) >> 1;
|
||||
int kr = Inlines.celt_ilog2(Er) >> 1;
|
||||
int t = Inlines.VSHR32(El, kl - 7 << 1);
|
||||
int lgain = Inlines.celt_rsqrt_norm(t);
|
||||
t = Inlines.VSHR32(Er, kr - 7 << 1);
|
||||
int rgain = Inlines.celt_rsqrt_norm(t);
|
||||
if (kl < 7) {
|
||||
kl = 7;
|
||||
}
|
||||
if (kr < 7) {
|
||||
kr = 7;
|
||||
}
|
||||
for (int j = 0; j < N; ++j) {
|
||||
int l = Inlines.MULT16_16_P15(mid, X[X_ptr + j]);
|
||||
int r = Y[Y_ptr + j];
|
||||
X[X_ptr + j] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MULT16_16(lgain, Inlines.SUB16(l, r)), kl + 1));
|
||||
Y[Y_ptr + j] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MULT16_16(rgain, Inlines.ADD16(l, r)), kr + 1));
|
||||
}
|
||||
}
|
||||
|
||||
static int spreading_decision(CeltMode m, int[][] X, BoxedValueInt average, int last_decision, BoxedValueInt hf_average, BoxedValueInt tapset_decision, int update_hf, int end, int C, int M) {
|
||||
int sum = 0;
|
||||
int nbBands = 0;
|
||||
short[] eBands = m.eBands;
|
||||
int hf_sum = 0;
|
||||
Inlines.OpusAssert(end > 0);
|
||||
if (M * (eBands[end] - eBands[end - 1]) <= 8) {
|
||||
return 0;
|
||||
}
|
||||
int c = 0;
|
||||
do {
|
||||
for (int i = 0; i < end; ++i) {
|
||||
int tmp = 0;
|
||||
int[] tcount = new int[]{0, 0, 0};
|
||||
int[] x = X[c];
|
||||
int x_ptr = M * eBands[i];
|
||||
int N = M * (eBands[i + 1] - eBands[i]);
|
||||
if (N <= 8) continue;
|
||||
for (int j = x_ptr; j < N + x_ptr; ++j) {
|
||||
int x2N = Inlines.MULT16_16(Inlines.MULT16_16_Q15(x[j], x[j]), N);
|
||||
if (x2N < 2048) {
|
||||
tcount[0] = tcount[0] + 1;
|
||||
}
|
||||
if (x2N < 512) {
|
||||
tcount[1] = tcount[1] + 1;
|
||||
}
|
||||
if (x2N >= 128) continue;
|
||||
tcount[2] = tcount[2] + 1;
|
||||
}
|
||||
if (i > m.nbEBands - 4) {
|
||||
hf_sum += Inlines.celt_udiv(32 * (tcount[1] + tcount[0]), N);
|
||||
}
|
||||
tmp = (2 * tcount[2] >= N ? 1 : 0) + (2 * tcount[1] >= N ? 1 : 0) + (2 * tcount[0] >= N ? 1 : 0);
|
||||
sum += tmp * 256;
|
||||
++nbBands;
|
||||
}
|
||||
} while (++c < C);
|
||||
if (update_hf != 0) {
|
||||
if (hf_sum != 0) {
|
||||
hf_sum = Inlines.celt_udiv(hf_sum, C * (4 - m.nbEBands + end));
|
||||
}
|
||||
hf_sum = hf_average.Val = hf_average.Val + hf_sum >> 1;
|
||||
if (tapset_decision.Val == 2) {
|
||||
hf_sum += 4;
|
||||
} else if (tapset_decision.Val == 0) {
|
||||
hf_sum -= 4;
|
||||
}
|
||||
tapset_decision.Val = hf_sum > 22 ? 2 : (hf_sum > 18 ? 1 : 0);
|
||||
}
|
||||
Inlines.OpusAssert(nbBands > 0);
|
||||
Inlines.OpusAssert(sum >= 0);
|
||||
sum = Inlines.celt_udiv(sum, nbBands);
|
||||
average.Val = sum = sum + average.Val >> 1;
|
||||
sum = 3 * sum + ((3 - last_decision << 7) + 64) + 2 >> 2;
|
||||
int decision = sum < 80 ? 3 : (sum < 256 ? 2 : (sum < 384 ? 1 : 0));
|
||||
return decision;
|
||||
}
|
||||
|
||||
static void deinterleave_hadamard(int[] X, int X_ptr, int N0, int stride, int hadamard) {
|
||||
int N = N0 * stride;
|
||||
int[] tmp = new int[N];
|
||||
Inlines.OpusAssert(stride > 0);
|
||||
if (hadamard != 0) {
|
||||
int ordery = stride - 2;
|
||||
for (int i = 0; i < stride; ++i) {
|
||||
for (int j = 0; j < N0; ++j) {
|
||||
tmp[CeltTables.ordery_table[ordery + i] * N0 + j] = X[j * stride + i + X_ptr];
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < stride; ++i) {
|
||||
for (int j = 0; j < N0; ++j) {
|
||||
tmp[i * N0 + j] = X[j * stride + i + X_ptr];
|
||||
}
|
||||
}
|
||||
}
|
||||
System.arraycopy(tmp, 0, X, X_ptr, N);
|
||||
}
|
||||
|
||||
static void interleave_hadamard(int[] X, int X_ptr, int N0, int stride, int hadamard) {
|
||||
int N = N0 * stride;
|
||||
int[] tmp = new int[N];
|
||||
if (hadamard != 0) {
|
||||
int ordery = stride - 2;
|
||||
for (int i = 0; i < stride; ++i) {
|
||||
for (int j = 0; j < N0; ++j) {
|
||||
tmp[j * stride + i] = X[CeltTables.ordery_table[ordery + i] * N0 + j + X_ptr];
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < stride; ++i) {
|
||||
for (int j = 0; j < N0; ++j) {
|
||||
tmp[j * stride + i] = X[i * N0 + j + X_ptr];
|
||||
}
|
||||
}
|
||||
}
|
||||
System.arraycopy(tmp, 0, X, X_ptr, N);
|
||||
}
|
||||
|
||||
static void haar1(int[] X, int X_ptr, int N0, int stride) {
|
||||
N0 >>= 1;
|
||||
for (int i = 0; i < stride; ++i) {
|
||||
for (int j = 0; j < N0; ++j) {
|
||||
int tmpidx = X_ptr + i + stride * 2 * j;
|
||||
int tmp1 = Inlines.MULT16_16(23170, X[tmpidx]);
|
||||
int tmp2 = Inlines.MULT16_16(23170, X[tmpidx + stride]);
|
||||
X[tmpidx] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.ADD32(tmp1, tmp2), 15));
|
||||
X[tmpidx + stride] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.SUB32(tmp1, tmp2), 15));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void haar1ZeroOffset(int[] X, int N0, int stride) {
|
||||
N0 >>= 1;
|
||||
for (int i = 0; i < stride; ++i) {
|
||||
for (int j = 0; j < N0; ++j) {
|
||||
int tmpidx = i + stride * 2 * j;
|
||||
int tmp1 = Inlines.MULT16_16(23170, X[tmpidx]);
|
||||
int tmp2 = Inlines.MULT16_16(23170, X[tmpidx + stride]);
|
||||
X[tmpidx] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.ADD32(tmp1, tmp2), 15));
|
||||
X[tmpidx + stride] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.SUB32(tmp1, tmp2), 15));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int compute_qn(int N, int b, int offset, int pulse_cap, int stereo) {
|
||||
int qn;
|
||||
short[] exp2_table8 = new short[]{16384, 17866, 19483, 21247, 23170, 25267, 27554, 30048};
|
||||
int N2 = 2 * N - 1;
|
||||
if (stereo != 0 && N == 2) {
|
||||
--N2;
|
||||
}
|
||||
int qb = Inlines.celt_sudiv(b + N2 * offset, N2);
|
||||
qb = Inlines.IMIN(b - pulse_cap - 32, qb);
|
||||
if ((qb = Inlines.IMIN(64, qb)) < 4) {
|
||||
qn = 1;
|
||||
} else {
|
||||
qn = exp2_table8[qb & 7] >> 14 - (qb >> 3);
|
||||
qn = qn + 1 >> 1 << 1;
|
||||
}
|
||||
Inlines.OpusAssert(qn <= 256);
|
||||
return qn;
|
||||
}
|
||||
|
||||
static void compute_theta(band_ctx ctx, split_ctx sctx, int[] X, int X_ptr, int[] Y, int Y_ptr, int N, BoxedValueInt b, int B, int B0, int LM, int stereo, BoxedValueInt fill) {
|
||||
int delta;
|
||||
int iside;
|
||||
int imid;
|
||||
int itheta = 0;
|
||||
int inv = 0;
|
||||
int encode = ctx.encode;
|
||||
CeltMode m = ctx.m;
|
||||
int i = ctx.i;
|
||||
int intensity = ctx.intensity;
|
||||
EntropyCoder ec = ctx.ec;
|
||||
int[][] bandE = ctx.bandE;
|
||||
int pulse_cap = m.logN[i] + LM * 8;
|
||||
int offset = (pulse_cap >> 1) - (stereo != 0 && N == 2 ? 16 : 4);
|
||||
int qn = Bands.compute_qn(N, b.Val, offset, pulse_cap, stereo);
|
||||
if (stereo != 0 && i >= intensity) {
|
||||
qn = 1;
|
||||
}
|
||||
if (encode != 0) {
|
||||
itheta = VQ.stereo_itheta(X, X_ptr, Y, Y_ptr, stereo, N);
|
||||
}
|
||||
int tell = ec.tell_frac();
|
||||
if (qn != 1) {
|
||||
if (encode != 0) {
|
||||
itheta = itheta * qn + 8192 >> 14;
|
||||
}
|
||||
if (stereo != 0 && N > 2) {
|
||||
int p0 = 3;
|
||||
int x = itheta;
|
||||
int x0 = qn / 2;
|
||||
long ft = Inlines.CapToUInt32(p0 * (x0 + 1) + x0);
|
||||
if (encode != 0) {
|
||||
ec.encode(x <= x0 ? p0 * x : x - 1 - x0 + (x0 + 1) * p0, x <= x0 ? p0 * (x + 1) : x - x0 + (x0 + 1) * p0, ft);
|
||||
} else {
|
||||
int fs = (int)ec.decode(ft);
|
||||
x = fs < (x0 + 1) * p0 ? fs / p0 : x0 + 1 + (fs - (x0 + 1) * p0);
|
||||
ec.dec_update(x <= x0 ? p0 * x : x - 1 - x0 + (x0 + 1) * p0, x <= x0 ? p0 * (x + 1) : x - x0 + (x0 + 1) * p0, ft);
|
||||
itheta = x;
|
||||
}
|
||||
} else if (B0 > 1 || stereo != 0) {
|
||||
if (encode != 0) {
|
||||
ec.enc_uint(itheta, qn + 1);
|
||||
} else {
|
||||
itheta = (int)ec.dec_uint(qn + 1);
|
||||
}
|
||||
} else {
|
||||
int fs = 1;
|
||||
int ft = ((qn >> 1) + 1) * ((qn >> 1) + 1);
|
||||
if (encode != 0) {
|
||||
fs = itheta <= qn >> 1 ? itheta + 1 : qn + 1 - itheta;
|
||||
int fl = itheta <= qn >> 1 ? itheta * (itheta + 1) >> 1 : ft - ((qn + 1 - itheta) * (qn + 2 - itheta) >> 1);
|
||||
ec.encode(fl, fl + fs, ft);
|
||||
} else {
|
||||
int fl = 0;
|
||||
int fm = (int)ec.decode(ft);
|
||||
if (fm < (qn >> 1) * ((qn >> 1) + 1) >> 1) {
|
||||
itheta = Inlines.isqrt32(8 * fm + 1) - 1 >> 1;
|
||||
fs = itheta + 1;
|
||||
fl = itheta * (itheta + 1) >> 1;
|
||||
} else {
|
||||
itheta = 2 * (qn + 1) - Inlines.isqrt32(8 * (ft - fm - 1) + 1) >> 1;
|
||||
fs = qn + 1 - itheta;
|
||||
fl = ft - ((qn + 1 - itheta) * (qn + 2 - itheta) >> 1);
|
||||
}
|
||||
ec.dec_update(fl, fl + fs, ft);
|
||||
}
|
||||
}
|
||||
Inlines.OpusAssert(itheta >= 0);
|
||||
itheta = Inlines.celt_udiv(itheta * 16384, qn);
|
||||
if (encode != 0 && stereo != 0) {
|
||||
if (itheta == 0) {
|
||||
Bands.intensity_stereo(m, X, X_ptr, Y, Y_ptr, bandE, i, N);
|
||||
} else {
|
||||
Bands.stereo_split(X, X_ptr, Y, Y_ptr, N);
|
||||
}
|
||||
}
|
||||
} else if (stereo != 0) {
|
||||
if (encode != 0) {
|
||||
int n = inv = itheta > 8192 ? 1 : 0;
|
||||
if (inv != 0) {
|
||||
for (int j = 0; j < N; ++j) {
|
||||
Y[Y_ptr + j] = 0 - Y[Y_ptr + j];
|
||||
}
|
||||
}
|
||||
Bands.intensity_stereo(m, X, X_ptr, Y, Y_ptr, bandE, i, N);
|
||||
}
|
||||
if (b.Val > 16 && ctx.remaining_bits > 16) {
|
||||
if (encode != 0) {
|
||||
ec.enc_bit_logp(inv, 2);
|
||||
} else {
|
||||
inv = ec.dec_bit_logp(2L);
|
||||
}
|
||||
} else {
|
||||
inv = 0;
|
||||
}
|
||||
itheta = 0;
|
||||
}
|
||||
int qalloc = ec.tell_frac() - tell;
|
||||
b.Val -= qalloc;
|
||||
if (itheta == 0) {
|
||||
imid = Short.MAX_VALUE;
|
||||
iside = 0;
|
||||
fill.Val &= (1 << B) - 1;
|
||||
delta = -16384;
|
||||
} else if (itheta == 16384) {
|
||||
imid = 0;
|
||||
iside = Short.MAX_VALUE;
|
||||
fill.Val &= (1 << B) - 1 << B;
|
||||
delta = 16384;
|
||||
} else {
|
||||
imid = Bands.bitexact_cos((short)itheta);
|
||||
iside = Bands.bitexact_cos((short)(16384 - itheta));
|
||||
delta = Inlines.FRAC_MUL16(N - 1 << 7, Bands.bitexact_log2tan(iside, imid));
|
||||
}
|
||||
sctx.inv = inv;
|
||||
sctx.imid = imid;
|
||||
sctx.iside = iside;
|
||||
sctx.delta = delta;
|
||||
sctx.itheta = itheta;
|
||||
sctx.qalloc = qalloc;
|
||||
}
|
||||
|
||||
static int quant_band_n1(band_ctx ctx, int[] X, int X_ptr, int[] Y, int Y_ptr, int b, int[] lowband_out, int lowband_out_ptr) {
|
||||
boolean resynth = ctx.encode == 0;
|
||||
int[] x = X;
|
||||
int x_ptr = X_ptr;
|
||||
int encode = ctx.encode;
|
||||
EntropyCoder ec = ctx.ec;
|
||||
int stereo = Y != null ? 1 : 0;
|
||||
int c = 0;
|
||||
do {
|
||||
int sign = 0;
|
||||
if (ctx.remaining_bits >= 8) {
|
||||
if (encode != 0) {
|
||||
sign = x[x_ptr] < 0 ? 1 : 0;
|
||||
ec.enc_bits(sign, 1);
|
||||
} else {
|
||||
sign = ec.dec_bits(1);
|
||||
}
|
||||
ctx.remaining_bits -= 8;
|
||||
b -= 8;
|
||||
}
|
||||
if (resynth) {
|
||||
x[x_ptr] = sign != 0 ? -16384 : 16384;
|
||||
}
|
||||
x = Y;
|
||||
x_ptr = Y_ptr;
|
||||
} while (++c < 1 + stereo);
|
||||
if (lowband_out != null) {
|
||||
lowband_out[lowband_out_ptr] = Inlines.SHR16(X[X_ptr], 4);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int quant_partition(band_ctx ctx, int[] X, int X_ptr, int N, int b, int B, int[] lowband, int lowband_ptr, int LM, int gain, int fill) {
|
||||
int imid = 0;
|
||||
int iside = 0;
|
||||
int B0 = B;
|
||||
int mid = 0;
|
||||
int side = 0;
|
||||
int cm = 0;
|
||||
boolean resynth = ctx.encode == 0;
|
||||
int Y = 0;
|
||||
int encode = ctx.encode;
|
||||
CeltMode m = ctx.m;
|
||||
int i = ctx.i;
|
||||
int spread = ctx.spread;
|
||||
EntropyCoder ec = ctx.ec;
|
||||
short[] cache = m.cache.bits;
|
||||
short cache_ptr = m.cache.index[(LM + 1) * m.nbEBands + i];
|
||||
if (LM != -1 && b > cache[cache_ptr + cache[cache_ptr]] + 12 && N > 2) {
|
||||
split_ctx sctx = new split_ctx();
|
||||
int next_lowband2 = 0;
|
||||
Y = X_ptr + (N >>= 1);
|
||||
--LM;
|
||||
if (B == 1) {
|
||||
fill = fill & 1 | fill << 1;
|
||||
}
|
||||
B = B + 1 >> 1;
|
||||
BoxedValueInt boxed_b = new BoxedValueInt(b);
|
||||
BoxedValueInt boxed_fill = new BoxedValueInt(fill);
|
||||
Bands.compute_theta(ctx, sctx, X, X_ptr, X, Y, N, boxed_b, B, B0, LM, 0, boxed_fill);
|
||||
b = boxed_b.Val;
|
||||
fill = boxed_fill.Val;
|
||||
imid = sctx.imid;
|
||||
iside = sctx.iside;
|
||||
int delta = sctx.delta;
|
||||
int itheta = sctx.itheta;
|
||||
int qalloc = sctx.qalloc;
|
||||
mid = imid;
|
||||
side = iside;
|
||||
if (B0 > 1 && (itheta & 0x3FFF) != 0) {
|
||||
delta = itheta > 8192 ? (delta -= delta >> 4 - LM) : Inlines.IMIN(0, delta + (N << 3 >> 5 - LM));
|
||||
}
|
||||
int mbits = Inlines.IMAX(0, Inlines.IMIN(b, (b - delta) / 2));
|
||||
int sbits = b - mbits;
|
||||
ctx.remaining_bits -= qalloc;
|
||||
if (lowband != null) {
|
||||
next_lowband2 = lowband_ptr + N;
|
||||
}
|
||||
int rebalance = ctx.remaining_bits;
|
||||
if (mbits >= sbits) {
|
||||
cm = Bands.quant_partition(ctx, X, X_ptr, N, mbits, B, lowband, lowband_ptr, LM, Inlines.MULT16_16_P15(gain, mid), fill);
|
||||
if ((rebalance = mbits - (rebalance - ctx.remaining_bits)) > 24 && itheta != 0) {
|
||||
sbits += rebalance - 24;
|
||||
}
|
||||
cm |= Bands.quant_partition(ctx, X, Y, N, sbits, B, lowband, next_lowband2, LM, Inlines.MULT16_16_P15(gain, side), fill >> B) << (B0 >> 1);
|
||||
} else {
|
||||
cm = Bands.quant_partition(ctx, X, Y, N, sbits, B, lowband, next_lowband2, LM, Inlines.MULT16_16_P15(gain, side), fill >> B) << (B0 >> 1);
|
||||
if ((rebalance = sbits - (rebalance - ctx.remaining_bits)) > 24 && itheta != 16384) {
|
||||
mbits += rebalance - 24;
|
||||
}
|
||||
cm |= Bands.quant_partition(ctx, X, X_ptr, N, mbits, B, lowband, lowband_ptr, LM, Inlines.MULT16_16_P15(gain, mid), fill);
|
||||
}
|
||||
} else {
|
||||
int q = Rate.bits2pulses(m, i, LM, b);
|
||||
int curr_bits = Rate.pulses2bits(m, i, LM, q);
|
||||
ctx.remaining_bits -= curr_bits;
|
||||
while (ctx.remaining_bits < 0 && q > 0) {
|
||||
ctx.remaining_bits += curr_bits;
|
||||
curr_bits = Rate.pulses2bits(m, i, LM, --q);
|
||||
ctx.remaining_bits -= curr_bits;
|
||||
}
|
||||
if (q != 0) {
|
||||
int K = Rate.get_pulses(q);
|
||||
cm = encode != 0 ? VQ.alg_quant(X, X_ptr, N, K, spread, B, ec) : VQ.alg_unquant(X, X_ptr, N, K, spread, B, ec, gain);
|
||||
} else if (resynth) {
|
||||
int cm_mask = (1 << B) - 1;
|
||||
if ((fill &= cm_mask) == 0) {
|
||||
Arrays.MemSetWithOffset(X, 0, X_ptr, N);
|
||||
} else {
|
||||
if (lowband == null) {
|
||||
for (int j = 0; j < N; ++j) {
|
||||
ctx.seed = Bands.celt_lcg_rand(ctx.seed);
|
||||
X[X_ptr + j] = ctx.seed >> 20;
|
||||
}
|
||||
cm = cm_mask;
|
||||
} else {
|
||||
for (int j = 0; j < N; ++j) {
|
||||
ctx.seed = Bands.celt_lcg_rand(ctx.seed);
|
||||
int tmp = 4;
|
||||
tmp = (ctx.seed & 0x8000) != 0 ? tmp : 0 - tmp;
|
||||
X[X_ptr + j] = lowband[lowband_ptr + j] + tmp;
|
||||
}
|
||||
cm = fill;
|
||||
}
|
||||
VQ.renormalise_vector(X, X_ptr, N, gain);
|
||||
}
|
||||
}
|
||||
}
|
||||
return cm;
|
||||
}
|
||||
|
||||
static int quant_band(band_ctx ctx, int[] X, int X_ptr, int N, int b, int B, int[] lowband, int lowband_ptr, int LM, int[] lowband_out, int lowband_out_ptr, int gain, int[] lowband_scratch, int lowband_scratch_ptr, int fill) {
|
||||
int k;
|
||||
int N0 = N;
|
||||
int N_B = N;
|
||||
int B0 = B;
|
||||
int time_divide = 0;
|
||||
int recombine = 0;
|
||||
int cm = 0;
|
||||
boolean resynth = ctx.encode == 0;
|
||||
int encode = ctx.encode;
|
||||
int tf_change = ctx.tf_change;
|
||||
int longBlocks = B0 == 1 ? 1 : 0;
|
||||
N_B = Inlines.celt_udiv(N_B, B);
|
||||
if (N == 1) {
|
||||
return Bands.quant_band_n1(ctx, X, X_ptr, null, 0, b, lowband_out, lowband_out_ptr);
|
||||
}
|
||||
if (tf_change > 0) {
|
||||
recombine = tf_change;
|
||||
}
|
||||
if (lowband_scratch != null && lowband != null && (recombine != 0 || (N_B & 1) == 0 && tf_change < 0 || B0 > 1)) {
|
||||
System.arraycopy(lowband, lowband_ptr, lowband_scratch, lowband_scratch_ptr, N);
|
||||
lowband = lowband_scratch;
|
||||
lowband_ptr = lowband_scratch_ptr;
|
||||
}
|
||||
for (k = 0; k < recombine; ++k) {
|
||||
if (encode != 0) {
|
||||
Bands.haar1(X, X_ptr, N >> k, 1 << k);
|
||||
}
|
||||
if (lowband != null) {
|
||||
Bands.haar1(lowband, lowband_ptr, N >> k, 1 << k);
|
||||
}
|
||||
int idx1 = fill & 0xF;
|
||||
int idx2 = fill >> 4;
|
||||
if (idx1 < 0) {
|
||||
System.out.println("e");
|
||||
}
|
||||
if (idx2 < 0) {
|
||||
System.out.println("e");
|
||||
}
|
||||
fill = bit_interleave_table[fill & 0xF] | bit_interleave_table[fill >> 4] << 2;
|
||||
}
|
||||
B >>= recombine;
|
||||
N_B <<= recombine;
|
||||
while ((N_B & 1) == 0 && tf_change < 0) {
|
||||
if (encode != 0) {
|
||||
Bands.haar1(X, X_ptr, N_B, B);
|
||||
}
|
||||
if (lowband != null) {
|
||||
Bands.haar1(lowband, lowband_ptr, 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) {
|
||||
if (encode != 0) {
|
||||
Bands.deinterleave_hadamard(X, X_ptr, N_B >> recombine, B0 << recombine, longBlocks);
|
||||
}
|
||||
if (lowband != null) {
|
||||
Bands.deinterleave_hadamard(lowband, lowband_ptr, N_B >> recombine, B0 << recombine, longBlocks);
|
||||
}
|
||||
}
|
||||
cm = Bands.quant_partition(ctx, X, X_ptr, N, b, B, lowband, lowband_ptr, LM, gain, fill);
|
||||
if (resynth) {
|
||||
if (B0 > 1) {
|
||||
Bands.interleave_hadamard(X, X_ptr, N_B >> recombine, B0 << recombine, longBlocks);
|
||||
}
|
||||
N_B = N_B0;
|
||||
B = B0;
|
||||
for (k = 0; k < time_divide; ++k) {
|
||||
cm |= cm >> (B >>= 1);
|
||||
Bands.haar1(X, X_ptr, N_B <<= 1, B);
|
||||
}
|
||||
for (k = 0; k < recombine; ++k) {
|
||||
cm = bit_deinterleave_table[cm];
|
||||
Bands.haar1(X, X_ptr, N0 >> k, 1 << k);
|
||||
}
|
||||
B <<= recombine;
|
||||
if (lowband_out != null) {
|
||||
int n = Inlines.celt_sqrt(Inlines.SHL32(N0, 22));
|
||||
for (int j = 0; j < N0; ++j) {
|
||||
lowband_out[lowband_out_ptr + j] = Inlines.MULT16_16_Q15(n, X[X_ptr + j]);
|
||||
}
|
||||
}
|
||||
cm &= (1 << B) - 1;
|
||||
}
|
||||
return cm;
|
||||
}
|
||||
|
||||
static int quant_band_stereo(band_ctx ctx, int[] X, int X_ptr, int[] Y, int Y_ptr, int N, int b, int B, int[] lowband, int lowband_ptr, int LM, int[] lowband_out, int lowband_out_ptr, int[] lowband_scratch, int lowband_scratch_ptr, int fill) {
|
||||
int sbits;
|
||||
int mbits;
|
||||
int imid = 0;
|
||||
int iside = 0;
|
||||
int inv = 0;
|
||||
int mid = 0;
|
||||
int side = 0;
|
||||
int cm = 0;
|
||||
boolean resynth = ctx.encode == 0;
|
||||
split_ctx sctx = new split_ctx();
|
||||
int encode = ctx.encode;
|
||||
EntropyCoder ec = ctx.ec;
|
||||
if (N == 1) {
|
||||
return Bands.quant_band_n1(ctx, X, X_ptr, Y, Y_ptr, b, lowband_out, lowband_out_ptr);
|
||||
}
|
||||
int orig_fill = fill;
|
||||
BoxedValueInt boxed_b = new BoxedValueInt(b);
|
||||
BoxedValueInt boxed_fill = new BoxedValueInt(fill);
|
||||
Bands.compute_theta(ctx, sctx, X, X_ptr, Y, Y_ptr, N, boxed_b, B, B, LM, 1, boxed_fill);
|
||||
b = boxed_b.Val;
|
||||
fill = boxed_fill.Val;
|
||||
inv = sctx.inv;
|
||||
imid = sctx.imid;
|
||||
iside = sctx.iside;
|
||||
int delta = sctx.delta;
|
||||
int itheta = sctx.itheta;
|
||||
int qalloc = sctx.qalloc;
|
||||
mid = imid;
|
||||
side = iside;
|
||||
if (N == 2) {
|
||||
int y2_ptr;
|
||||
int[] y2;
|
||||
int x2_ptr;
|
||||
int[] x2;
|
||||
int sign = 0;
|
||||
mbits = b;
|
||||
sbits = 0;
|
||||
if (itheta != 0 && itheta != 16384) {
|
||||
sbits = 8;
|
||||
}
|
||||
mbits -= sbits;
|
||||
boolean c = itheta > 8192;
|
||||
ctx.remaining_bits -= qalloc + sbits;
|
||||
if (c) {
|
||||
x2 = Y;
|
||||
x2_ptr = Y_ptr;
|
||||
y2 = X;
|
||||
y2_ptr = X_ptr;
|
||||
} else {
|
||||
x2 = X;
|
||||
x2_ptr = X_ptr;
|
||||
y2 = Y;
|
||||
y2_ptr = Y_ptr;
|
||||
}
|
||||
if (sbits != 0) {
|
||||
if (encode != 0) {
|
||||
sign = x2[x2_ptr] * y2[Y_ptr + 1] - x2[x2_ptr + 1] * y2[Y_ptr] < 0 ? 1 : 0;
|
||||
ec.enc_bits(sign, 1);
|
||||
} else {
|
||||
sign = ec.dec_bits(1);
|
||||
}
|
||||
}
|
||||
sign = 1 - 2 * sign;
|
||||
cm = Bands.quant_band(ctx, x2, x2_ptr, N, mbits, B, lowband, lowband_ptr, LM, lowband_out, lowband_out_ptr, Short.MAX_VALUE, lowband_scratch, lowband_scratch_ptr, orig_fill);
|
||||
y2[Y_ptr] = (0 - sign) * x2[x2_ptr + 1];
|
||||
y2[Y_ptr + 1] = sign * x2[x2_ptr];
|
||||
if (resynth) {
|
||||
X[X_ptr] = Inlines.MULT16_16_Q15(mid, X[X_ptr]);
|
||||
X[X_ptr + 1] = Inlines.MULT16_16_Q15(mid, X[X_ptr + 1]);
|
||||
Y[Y_ptr] = Inlines.MULT16_16_Q15(side, Y[Y_ptr]);
|
||||
Y[Y_ptr + 1] = Inlines.MULT16_16_Q15(side, Y[Y_ptr + 1]);
|
||||
int tmp = X[X_ptr];
|
||||
X[X_ptr] = Inlines.SUB16(tmp, Y[Y_ptr]);
|
||||
Y[Y_ptr] = Inlines.ADD16(tmp, Y[Y_ptr]);
|
||||
tmp = X[X_ptr + 1];
|
||||
X[X_ptr + 1] = Inlines.SUB16(tmp, Y[Y_ptr + 1]);
|
||||
Y[Y_ptr + 1] = Inlines.ADD16(tmp, Y[Y_ptr + 1]);
|
||||
}
|
||||
} else {
|
||||
mbits = Inlines.IMAX(0, Inlines.IMIN(b, (b - delta) / 2));
|
||||
sbits = b - mbits;
|
||||
ctx.remaining_bits -= qalloc;
|
||||
int rebalance = ctx.remaining_bits;
|
||||
if (mbits >= sbits) {
|
||||
cm = Bands.quant_band(ctx, X, X_ptr, N, mbits, B, lowband, lowband_ptr, LM, lowband_out, lowband_out_ptr, Short.MAX_VALUE, lowband_scratch, lowband_scratch_ptr, fill);
|
||||
if ((rebalance = mbits - (rebalance - ctx.remaining_bits)) > 24 && itheta != 0) {
|
||||
sbits += rebalance - 24;
|
||||
}
|
||||
cm |= Bands.quant_band(ctx, Y, Y_ptr, N, sbits, B, null, 0, LM, null, 0, side, null, 0, fill >> B);
|
||||
} else {
|
||||
cm = Bands.quant_band(ctx, Y, Y_ptr, N, sbits, B, null, 0, LM, null, 0, side, null, 0, fill >> B);
|
||||
if ((rebalance = sbits - (rebalance - ctx.remaining_bits)) > 24 && itheta != 16384) {
|
||||
mbits += rebalance - 24;
|
||||
}
|
||||
cm |= Bands.quant_band(ctx, X, X_ptr, N, mbits, B, lowband, lowband_ptr, LM, lowband_out, lowband_out_ptr, Short.MAX_VALUE, lowband_scratch, lowband_scratch_ptr, fill);
|
||||
}
|
||||
}
|
||||
if (resynth) {
|
||||
if (N != 2) {
|
||||
Bands.stereo_merge(X, X_ptr, Y, Y_ptr, mid, N);
|
||||
}
|
||||
if (inv != 0) {
|
||||
for (int j = Y_ptr; j < N + Y_ptr; ++j) {
|
||||
Y[j] = (short)(0 - Y[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return cm;
|
||||
}
|
||||
|
||||
static void quant_all_bands(int encode, CeltMode m, int start, int end, int[] X_, int[] Y_, short[] collapse_masks, int[][] bandE, int[] pulses, int shortBlocks, int spread, int dual_stereo, int intensity, int[] tf_res, int total_bits, int balance, EntropyCoder ec, int LM, int codedBands, BoxedValueInt seed) {
|
||||
short[] eBands = m.eBands;
|
||||
boolean update_lowband = true;
|
||||
int C = Y_ != null ? 2 : 1;
|
||||
boolean resynth = encode == 0;
|
||||
band_ctx ctx = new band_ctx();
|
||||
int M = 1 << LM;
|
||||
int B = shortBlocks != 0 ? M : 1;
|
||||
int norm_offset = M * eBands[start];
|
||||
int[] norm = new int[C * (M * eBands[m.nbEBands - 1] - norm_offset)];
|
||||
int norm2 = M * eBands[m.nbEBands - 1] - norm_offset;
|
||||
int[] lowband_scratch = X_;
|
||||
int lowband_scratch_ptr = M * eBands[m.nbEBands - 1];
|
||||
int lowband_offset = 0;
|
||||
ctx.bandE = bandE;
|
||||
ctx.ec = ec;
|
||||
ctx.encode = encode;
|
||||
ctx.intensity = intensity;
|
||||
ctx.m = m;
|
||||
ctx.seed = seed.Val;
|
||||
ctx.spread = spread;
|
||||
for (int i = start; i < end; ++i) {
|
||||
long x_cm;
|
||||
long y_cm;
|
||||
int b;
|
||||
int remaining_bits;
|
||||
int[] Y;
|
||||
int effective_lowband = -1;
|
||||
int Y_ptr = 0;
|
||||
int tf_change = 0;
|
||||
ctx.i = i;
|
||||
boolean last = i == end - 1;
|
||||
int[] X = X_;
|
||||
int X_ptr = M * eBands[i];
|
||||
if (Y_ != null) {
|
||||
Y = Y_;
|
||||
Y_ptr = M * eBands[i];
|
||||
} else {
|
||||
Y = null;
|
||||
}
|
||||
int N = M * eBands[i + 1] - M * eBands[i];
|
||||
int tell = ec.tell_frac();
|
||||
if (i != start) {
|
||||
balance -= tell;
|
||||
}
|
||||
ctx.remaining_bits = remaining_bits = total_bits - tell - 1;
|
||||
if (i <= codedBands - 1) {
|
||||
int curr_balance = Inlines.celt_sudiv(balance, Inlines.IMIN(3, codedBands - i));
|
||||
b = Inlines.IMAX(0, Inlines.IMIN(16383, Inlines.IMIN(remaining_bits + 1, pulses[i] + curr_balance)));
|
||||
} else {
|
||||
b = 0;
|
||||
}
|
||||
if (resynth && M * eBands[i] - N >= M * eBands[start] && (update_lowband || lowband_offset == 0)) {
|
||||
lowband_offset = i;
|
||||
}
|
||||
ctx.tf_change = tf_change = tf_res[i];
|
||||
if (i >= m.effEBands) {
|
||||
X = norm;
|
||||
X_ptr = 0;
|
||||
if (Y_ != null) {
|
||||
Y = norm;
|
||||
Y_ptr = 0;
|
||||
}
|
||||
lowband_scratch = null;
|
||||
}
|
||||
if (i == end - 1) {
|
||||
lowband_scratch = null;
|
||||
}
|
||||
if (lowband_offset != 0 && (spread != 3 || B > 1 || tf_change < 0)) {
|
||||
effective_lowband = Inlines.IMAX(0, M * eBands[lowband_offset] - norm_offset - N);
|
||||
int fold_start = lowband_offset;
|
||||
while (M * eBands[--fold_start] > effective_lowband + norm_offset) {
|
||||
}
|
||||
int fold_end = lowband_offset - 1;
|
||||
while (M * eBands[++fold_end] < effective_lowband + norm_offset + N) {
|
||||
}
|
||||
y_cm = 0L;
|
||||
x_cm = 0L;
|
||||
int fold_i = fold_start;
|
||||
do {
|
||||
x_cm |= (long)collapse_masks[fold_i * C + 0];
|
||||
y_cm |= (long)collapse_masks[fold_i * C + C - 1];
|
||||
} while (++fold_i < fold_end);
|
||||
} else {
|
||||
x_cm = y_cm = (long)((1 << B) - 1);
|
||||
}
|
||||
if (dual_stereo != 0 && i == intensity) {
|
||||
dual_stereo = 0;
|
||||
if (resynth) {
|
||||
for (int j = 0; j < M * eBands[i] - norm_offset; ++j) {
|
||||
norm[j] = Inlines.HALF32(norm[j] + norm[norm2 + j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (dual_stereo != 0) {
|
||||
x_cm = Bands.quant_band(ctx, X, X_ptr, N, b / 2, B, (int[])(effective_lowband != -1 ? norm : null), effective_lowband, LM, last ? null : norm, M * eBands[i] - norm_offset, Short.MAX_VALUE, lowband_scratch, lowband_scratch_ptr, (int)x_cm);
|
||||
y_cm = Bands.quant_band(ctx, Y, Y_ptr, N, b / 2, B, (int[])(effective_lowband != -1 ? norm : null), norm2 + effective_lowband, LM, last ? null : norm, norm2 + (M * eBands[i] - norm_offset), Short.MAX_VALUE, lowband_scratch, lowband_scratch_ptr, (int)y_cm);
|
||||
} else {
|
||||
x_cm = Y != null ? (long)Bands.quant_band_stereo(ctx, X, X_ptr, Y, Y_ptr, N, b, B, (int[])(effective_lowband != -1 ? norm : null), effective_lowband, LM, last ? null : norm, M * eBands[i] - norm_offset, lowband_scratch, lowband_scratch_ptr, (int)(x_cm | y_cm)) : (long)Bands.quant_band(ctx, X, X_ptr, N, b, B, (int[])(effective_lowband != -1 ? norm : null), effective_lowband, LM, last ? null : norm, M * eBands[i] - norm_offset, Short.MAX_VALUE, lowband_scratch, lowband_scratch_ptr, (int)(x_cm | y_cm));
|
||||
y_cm = x_cm;
|
||||
}
|
||||
collapse_masks[i * C + 0] = (short)(x_cm & 0xFFL);
|
||||
collapse_masks[i * C + C - 1] = (short)(y_cm & 0xFFL);
|
||||
balance += pulses[i] + tell;
|
||||
update_lowband = b > N << 3;
|
||||
}
|
||||
seed.Val = ctx.seed;
|
||||
}
|
||||
|
||||
public static class band_ctx {
|
||||
public int encode;
|
||||
public CeltMode m;
|
||||
public int i;
|
||||
public int intensity;
|
||||
public int spread;
|
||||
public int tf_change;
|
||||
public EntropyCoder ec;
|
||||
public int remaining_bits;
|
||||
public int[][] bandE;
|
||||
public int seed;
|
||||
}
|
||||
|
||||
public static class split_ctx {
|
||||
public int inv;
|
||||
public int imid;
|
||||
public int iside;
|
||||
public int delta;
|
||||
public int itheta;
|
||||
public int qalloc;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user