asminme/AsminVoicechat
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

first commit
Build AsminVoicechat / prepare-release (push) Successful in 14s
Details
Build AsminVoicechat / build-and-test (17) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (18) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (19) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (20) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (21) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (22) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (23) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (24) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (25) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (26) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (27-ea) (push) Canceled after 0s
Details
Build AsminVoicechat / build-and-test (16) (push) Canceled after 38s
Details

Browse Source
This commit is contained in:
asminme committed 2026-10-24 15:18:03 +02:00
commit bbccd4a815
454 files changed
+45050
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

source/decompiled/de/maxhenkel/voicechat/concentus/VoiceActivityDetection.java
+152
View File
@@ -0,0 +1,152 @@
/*
* Decompiled with CFR 0.152.
*/
package de.maxhenkel.voicechat.concentus;
import de.maxhenkel.voicechat.concentus.Filters;
import de.maxhenkel.voicechat.concentus.Inlines;
import de.maxhenkel.voicechat.concentus.Sigmoid;
import de.maxhenkel.voicechat.concentus.SilkChannelEncoder;
import de.maxhenkel.voicechat.concentus.SilkVADState;
class VoiceActivityDetection {
private static final int[] tiltWeights = new int[]{30000, 6000, -12000, -12000};
VoiceActivityDetection() {
}
static int silk_VAD_Init(SilkVADState psSilk_VAD) {
int b;
int ret = 0;
psSilk_VAD.Reset();
for (b = 0; b < 4; ++b) {
psSilk_VAD.NoiseLevelBias[b] = Inlines.silk_max_32(Inlines.silk_DIV32_16(50, (short)(b + 1)), 1);
}
for (b = 0; b < 4; ++b) {
psSilk_VAD.NL[b] = Inlines.silk_MUL(100, psSilk_VAD.NoiseLevelBias[b]);
psSilk_VAD.inv_NL[b] = Inlines.silk_DIV32(Integer.MAX_VALUE, psSilk_VAD.NL[b]);
}
psSilk_VAD.counter = 15;
for (b = 0; b < 4; ++b) {
psSilk_VAD.NrgRatioSmth_Q8[b] = 25600;
}
return ret;
}
static int silk_VAD_GetSA_Q8(SilkChannelEncoder psEncC, short[] pIn, int pIn_ptr) {
int SNR_Q7;
int speech_nrg;
int b;
int i;
int sumSquared = 0;
int[] Xnrg = new int[4];
int[] NrgToNoiseRatio_Q8 = new int[4];
int[] X_offset = new int[4];
int ret = 0;
SilkVADState psSilk_VAD = psEncC.sVAD;
Inlines.OpusAssert(true);
Inlines.OpusAssert(320 >= psEncC.frame_length);
Inlines.OpusAssert(psEncC.frame_length <= 512);
Inlines.OpusAssert(psEncC.frame_length == 8 * Inlines.silk_RSHIFT(psEncC.frame_length, 3));
int decimated_framelength1 = Inlines.silk_RSHIFT(psEncC.frame_length, 1);
int decimated_framelength2 = Inlines.silk_RSHIFT(psEncC.frame_length, 2);
int decimated_framelength = Inlines.silk_RSHIFT(psEncC.frame_length, 3);
X_offset[0] = 0;
X_offset[1] = decimated_framelength + decimated_framelength2;
X_offset[2] = X_offset[1] + decimated_framelength;
X_offset[3] = X_offset[2] + decimated_framelength2;
short[] X = new short[X_offset[3] + decimated_framelength1];
Filters.silk_ana_filt_bank_1(pIn, pIn_ptr, psSilk_VAD.AnaState, X, X, X_offset[3], psEncC.frame_length);
Filters.silk_ana_filt_bank_1(X, 0, psSilk_VAD.AnaState1, X, X, X_offset[2], decimated_framelength1);
Filters.silk_ana_filt_bank_1(X, 0, psSilk_VAD.AnaState2, X, X, X_offset[1], decimated_framelength2);
X[decimated_framelength - 1] = (short)Inlines.silk_RSHIFT(X[decimated_framelength - 1], 1);
short HPstateTmp = X[decimated_framelength - 1];
for (i = decimated_framelength - 1; i > 0; --i) {
X[i - 1] = (short)Inlines.silk_RSHIFT(X[i - 1], 1);
int n = i;
X[n] = (short)(X[n] - X[i - 1]);
}
X[0] = (short)(X[0] - psSilk_VAD.HPstate);
psSilk_VAD.HPstate = HPstateTmp;
for (b = 0; b < 4; ++b) {
decimated_framelength = Inlines.silk_RSHIFT(psEncC.frame_length, Inlines.silk_min_int(4 - b, 3));
int dec_subframe_length = Inlines.silk_RSHIFT(decimated_framelength, 2);
int dec_subframe_offset = 0;
Xnrg[b] = psSilk_VAD.XnrgSubfr[b];
for (int s = 0; s < 4; ++s) {
sumSquared = 0;
for (i = 0; i < dec_subframe_length; ++i) {
int x_tmp = Inlines.silk_RSHIFT(X[X_offset[b] + i + dec_subframe_offset], 3);
Inlines.OpusAssert((sumSquared = Inlines.silk_SMLABB(sumSquared, x_tmp, x_tmp)) >= 0);
}
Xnrg[b] = s < 3 ? Inlines.silk_ADD_POS_SAT32(Xnrg[b], sumSquared) : Inlines.silk_ADD_POS_SAT32(Xnrg[b], Inlines.silk_RSHIFT(sumSquared, 1));
dec_subframe_offset += dec_subframe_length;
}
psSilk_VAD.XnrgSubfr[b] = sumSquared;
}
VoiceActivityDetection.silk_VAD_GetNoiseLevels(Xnrg, psSilk_VAD);
sumSquared = 0;
int input_tilt = 0;
for (b = 0; b < 4; ++b) {
speech_nrg = Xnrg[b] - psSilk_VAD.NL[b];
if (speech_nrg > 0) {
NrgToNoiseRatio_Q8[b] = (Xnrg[b] & 0xFF800000) == 0 ? Inlines.silk_DIV32(Inlines.silk_LSHIFT(Xnrg[b], 8), psSilk_VAD.NL[b] + 1) : Inlines.silk_DIV32(Xnrg[b], Inlines.silk_RSHIFT(psSilk_VAD.NL[b], 8) + 1);
SNR_Q7 = Inlines.silk_lin2log(NrgToNoiseRatio_Q8[b]) - 1024;
sumSquared = Inlines.silk_SMLABB(sumSquared, SNR_Q7, SNR_Q7);
if (speech_nrg < 0x100000) {
SNR_Q7 = Inlines.silk_SMULWB(Inlines.silk_LSHIFT(Inlines.silk_SQRT_APPROX(speech_nrg), 6), SNR_Q7);
}
input_tilt = Inlines.silk_SMLAWB(input_tilt, tiltWeights[b], SNR_Q7);
continue;
}
NrgToNoiseRatio_Q8[b] = 256;
}
sumSquared = Inlines.silk_DIV32_16(sumSquared, 4);
short pSNR_dB_Q7 = (short)(3 * Inlines.silk_SQRT_APPROX(sumSquared));
int SA_Q15 = Sigmoid.silk_sigm_Q15(Inlines.silk_SMULWB(45000, pSNR_dB_Q7) - 128);
psEncC.input_tilt_Q15 = Inlines.silk_LSHIFT(Sigmoid.silk_sigm_Q15(input_tilt) - 16384, 1);
speech_nrg = 0;
for (b = 0; b < 4; ++b) {
speech_nrg += (b + 1) * Inlines.silk_RSHIFT(Xnrg[b] - psSilk_VAD.NL[b], 4);
}
if (speech_nrg <= 0) {
SA_Q15 = Inlines.silk_RSHIFT(SA_Q15, 1);
} else if (speech_nrg < 32768) {
speech_nrg = psEncC.frame_length == 10 * psEncC.fs_kHz ? Inlines.silk_LSHIFT_SAT32(speech_nrg, 16) : Inlines.silk_LSHIFT_SAT32(speech_nrg, 15);
speech_nrg = Inlines.silk_SQRT_APPROX(speech_nrg);
SA_Q15 = Inlines.silk_SMULWB(32768 + speech_nrg, SA_Q15);
}
psEncC.speech_activity_Q8 = Inlines.silk_min_int(Inlines.silk_RSHIFT(SA_Q15, 7), 255);
int smooth_coef_Q16 = Inlines.silk_SMULWB(4096, Inlines.silk_SMULWB(SA_Q15, SA_Q15));
if (psEncC.frame_length == 10 * psEncC.fs_kHz) {
smooth_coef_Q16 >>= 1;
}
for (b = 0; b < 4; ++b) {
psSilk_VAD.NrgRatioSmth_Q8[b] = Inlines.silk_SMLAWB(psSilk_VAD.NrgRatioSmth_Q8[b], NrgToNoiseRatio_Q8[b] - psSilk_VAD.NrgRatioSmth_Q8[b], smooth_coef_Q16);
SNR_Q7 = 3 * (Inlines.silk_lin2log(psSilk_VAD.NrgRatioSmth_Q8[b]) - 1024);
psEncC.input_quality_bands_Q15[b] = Sigmoid.silk_sigm_Q15(Inlines.silk_RSHIFT(SNR_Q7 - 2048, 4));
}
return ret;
}
static void silk_VAD_GetNoiseLevels(int[] pX, SilkVADState psSilk_VAD) {
int min_coef = psSilk_VAD.counter < 1000 ? Inlines.silk_DIV32_16(Short.MAX_VALUE, (short)(Inlines.silk_RSHIFT(psSilk_VAD.counter, 4) + 1)) : 0;
for (int k = 0; k < 4; ++k) {
int nl = psSilk_VAD.NL[k];
Inlines.OpusAssert(nl >= 0);
int nrg = Inlines.silk_ADD_POS_SAT32(pX[k], psSilk_VAD.NoiseLevelBias[k]);
Inlines.OpusAssert(nrg > 0);
int inv_nrg = Inlines.silk_DIV32(Integer.MAX_VALUE, nrg);
Inlines.OpusAssert(inv_nrg >= 0);
int coef = nrg > Inlines.silk_LSHIFT(nl, 3) ? 128 : (nrg < nl ? 1024 : Inlines.silk_SMULWB(Inlines.silk_SMULWW(inv_nrg, nl), 2048));
coef = Inlines.silk_max_int(coef, min_coef);
psSilk_VAD.inv_NL[k] = Inlines.silk_SMLAWB(psSilk_VAD.inv_NL[k], inv_nrg - psSilk_VAD.inv_NL[k], coef);
Inlines.OpusAssert(psSilk_VAD.inv_NL[k] >= 0);
nl = Inlines.silk_DIV32(Integer.MAX_VALUE, psSilk_VAD.inv_NL[k]);
Inlines.OpusAssert(nl >= 0);
psSilk_VAD.NL[k] = nl = Inlines.silk_min(nl, 0xFFFFFF);
}
++psSilk_VAD.counter;
}
}