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/PLC.java
+240
View File
@@ -0,0 +1,240 @@
/*
* Decompiled with CFR 0.152.
*/
package de.maxhenkel.voicechat.concentus;
import de.maxhenkel.voicechat.concentus.Arrays;
import de.maxhenkel.voicechat.concentus.BWExpander;
import de.maxhenkel.voicechat.concentus.BoxedValueInt;
import de.maxhenkel.voicechat.concentus.Filters;
import de.maxhenkel.voicechat.concentus.Inlines;
import de.maxhenkel.voicechat.concentus.LPCInversePredGain;
import de.maxhenkel.voicechat.concentus.PLCStruct;
import de.maxhenkel.voicechat.concentus.SilkChannelDecoder;
import de.maxhenkel.voicechat.concentus.SilkDecoderControl;
import de.maxhenkel.voicechat.concentus.SumSqrShift;
class PLC {
private static final int NB_ATT = 2;
private static final short[] HARM_ATT_Q15 = new short[]{32440, 31130};
private static final short[] PLC_RAND_ATTENUATE_V_Q15 = new short[]{31130, 26214};
private static final short[] PLC_RAND_ATTENUATE_UV_Q15 = new short[]{32440, 29491};
PLC() {
}
static void silk_PLC_Reset(SilkChannelDecoder psDec) {
psDec.sPLC.pitchL_Q8 = Inlines.silk_LSHIFT(psDec.frame_length, 7);
psDec.sPLC.prevGain_Q16[0] = 65536;
psDec.sPLC.prevGain_Q16[1] = 65536;
psDec.sPLC.subfr_length = 20;
psDec.sPLC.nb_subfr = 2;
}
static void silk_PLC(SilkChannelDecoder psDec, SilkDecoderControl psDecCtrl, short[] frame, int frame_ptr, int lost) {
if (psDec.fs_kHz != psDec.sPLC.fs_kHz) {
PLC.silk_PLC_Reset(psDec);
psDec.sPLC.fs_kHz = psDec.fs_kHz;
}
if (lost != 0) {
PLC.silk_PLC_conceal(psDec, psDecCtrl, frame, frame_ptr);
++psDec.lossCnt;
} else {
PLC.silk_PLC_update(psDec, psDecCtrl);
}
}
static void silk_PLC_update(SilkChannelDecoder psDec, SilkDecoderControl psDecCtrl) {
PLCStruct psPLC = psDec.sPLC;
psDec.prevSignalType = psDec.indices.signalType;
int LTP_Gain_Q14 = 0;
if (psDec.indices.signalType == 2) {
int i;
for (int j = 0; j * psDec.subfr_length < psDecCtrl.pitchL[psDec.nb_subfr - 1] && j != psDec.nb_subfr; ++j) {
int temp_LTP_Gain_Q14 = 0;
for (i = 0; i < 5; ++i) {
temp_LTP_Gain_Q14 += psDecCtrl.LTPCoef_Q14[(psDec.nb_subfr - 1 - j) * 5 + i];
}
if (temp_LTP_Gain_Q14 <= LTP_Gain_Q14) continue;
LTP_Gain_Q14 = temp_LTP_Gain_Q14;
System.arraycopy(psDecCtrl.LTPCoef_Q14, Inlines.silk_SMULBB(psDec.nb_subfr - 1 - j, 5), psPLC.LTPCoef_Q14, 0, 5);
psPLC.pitchL_Q8 = Inlines.silk_LSHIFT(psDecCtrl.pitchL[psDec.nb_subfr - 1 - j], 8);
}
Arrays.MemSet(psPLC.LTPCoef_Q14, (short)0, 5);
psPLC.LTPCoef_Q14[2] = (short)LTP_Gain_Q14;
if (LTP_Gain_Q14 < 11469) {
int tmp = Inlines.silk_LSHIFT(11469, 10);
int scale_Q10 = Inlines.silk_DIV32(tmp, Inlines.silk_max(LTP_Gain_Q14, 1));
for (i = 0; i < 5; ++i) {
psPLC.LTPCoef_Q14[i] = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(psPLC.LTPCoef_Q14[i], scale_Q10), 10);
}
} else if (LTP_Gain_Q14 > 15565) {
int tmp = Inlines.silk_LSHIFT(15565, 14);
int scale_Q14 = Inlines.silk_DIV32(tmp, Inlines.silk_max(LTP_Gain_Q14, 1));
for (i = 0; i < 5; ++i) {
psPLC.LTPCoef_Q14[i] = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(psPLC.LTPCoef_Q14[i], scale_Q14), 14);
}
}
} else {
psPLC.pitchL_Q8 = Inlines.silk_LSHIFT(Inlines.silk_SMULBB(psDec.fs_kHz, 18), 8);
Arrays.MemSet(psPLC.LTPCoef_Q14, (short)0, 5);
}
System.arraycopy(psDecCtrl.PredCoef_Q12[1], 0, psPLC.prevLPC_Q12, 0, psDec.LPC_order);
psPLC.prevLTP_scale_Q14 = (short)psDecCtrl.LTP_scale_Q14;
System.arraycopy(psDecCtrl.Gains_Q16, psDec.nb_subfr - 2, psPLC.prevGain_Q16, 0, 2);
psPLC.subfr_length = psDec.subfr_length;
psPLC.nb_subfr = psDec.nb_subfr;
}
static void silk_PLC_energy(BoxedValueInt energy1, BoxedValueInt shift1, BoxedValueInt energy2, BoxedValueInt shift2, int[] exc_Q14, int[] prevGain_Q10, int subfr_length, int nb_subfr) {
int exc_buf_ptr = 0;
short[] exc_buf = new short[2 * subfr_length];
for (int k = 0; k < 2; ++k) {
for (int i = 0; i < subfr_length; ++i) {
exc_buf[exc_buf_ptr + i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT(Inlines.silk_SMULWW(exc_Q14[i + (k + nb_subfr - 2) * subfr_length], prevGain_Q10[k]), 8));
}
exc_buf_ptr += subfr_length;
}
SumSqrShift.silk_sum_sqr_shift(energy1, shift1, exc_buf, subfr_length);
SumSqrShift.silk_sum_sqr_shift(energy2, shift2, exc_buf, subfr_length, subfr_length);
}
static void silk_PLC_conceal(SilkChannelDecoder psDec, SilkDecoderControl psDecCtrl, short[] frame, int frame_ptr) {
int j;
int i;
BoxedValueInt energy1 = new BoxedValueInt(0);
BoxedValueInt energy2 = new BoxedValueInt(0);
BoxedValueInt shift1 = new BoxedValueInt(0);
BoxedValueInt shift2 = new BoxedValueInt(0);
short[] sLTP = new short[psDec.ltp_mem_length];
int[] sLTP_Q14 = new int[psDec.ltp_mem_length + psDec.frame_length];
PLCStruct psPLC = psDec.sPLC;
int[] prevGain_Q10 = new int[]{Inlines.silk_RSHIFT(psPLC.prevGain_Q16[0], 6), Inlines.silk_RSHIFT(psPLC.prevGain_Q16[1], 6)};
if (psDec.first_frame_after_reset != 0) {
Arrays.MemSet(psPLC.prevLPC_Q12, (short)0, 16);
}
PLC.silk_PLC_energy(energy1, shift1, energy2, shift2, psDec.exc_Q14, prevGain_Q10, psDec.subfr_length, psDec.nb_subfr);
int rand_ptr = Inlines.silk_RSHIFT(energy1.Val, shift2.Val) < Inlines.silk_RSHIFT(energy2.Val, shift1.Val) ? Inlines.silk_max_int(0, (psPLC.nb_subfr - 1) * psPLC.subfr_length - 128) : Inlines.silk_max_int(0, psPLC.nb_subfr * psPLC.subfr_length - 128);
short[] B_Q14 = psPLC.LTPCoef_Q14;
short rand_scale_Q14 = psPLC.randScale_Q14;
short harm_Gain_Q15 = HARM_ATT_Q15[Inlines.silk_min_int(1, psDec.lossCnt)];
int rand_Gain_Q15 = psDec.prevSignalType == 2 ? PLC_RAND_ATTENUATE_V_Q15[Inlines.silk_min_int(1, psDec.lossCnt)] : PLC_RAND_ATTENUATE_UV_Q15[Inlines.silk_min_int(1, psDec.lossCnt)];
BWExpander.silk_bwexpander(psPLC.prevLPC_Q12, psDec.LPC_order, 64881);
if (psDec.lossCnt == 0) {
rand_scale_Q14 = 16384;
if (psDec.prevSignalType == 2) {
for (i = 0; i < 5; ++i) {
rand_scale_Q14 = (short)(rand_scale_Q14 - B_Q14[i]);
}
rand_scale_Q14 = Inlines.silk_max_16((short)3277, rand_scale_Q14);
rand_scale_Q14 = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(rand_scale_Q14, psPLC.prevLTP_scale_Q14), 14);
} else {
int invGain_Q30 = LPCInversePredGain.silk_LPC_inverse_pred_gain(psPLC.prevLPC_Q12, psDec.LPC_order);
int down_scale_Q30 = Inlines.silk_min_32(Inlines.silk_RSHIFT(0x40000000, 3), invGain_Q30);
down_scale_Q30 = Inlines.silk_max_32(Inlines.silk_RSHIFT(0x40000000, 8), down_scale_Q30);
down_scale_Q30 = Inlines.silk_LSHIFT(down_scale_Q30, 3);
rand_Gain_Q15 = Inlines.silk_RSHIFT(Inlines.silk_SMULWB(down_scale_Q30, rand_Gain_Q15), 14);
}
}
int rand_seed = psPLC.rand_seed;
int lag = Inlines.silk_RSHIFT_ROUND(psPLC.pitchL_Q8, 8);
int sLTP_buf_idx = psDec.ltp_mem_length;
int idx = psDec.ltp_mem_length - lag - psDec.LPC_order - 2;
Inlines.OpusAssert(idx > 0);
Filters.silk_LPC_analysis_filter(sLTP, idx, psDec.outBuf, idx, psPLC.prevLPC_Q12, 0, psDec.ltp_mem_length - idx, psDec.LPC_order);
int inv_gain_Q30 = Inlines.silk_INVERSE32_varQ(psPLC.prevGain_Q16[1], 46);
inv_gain_Q30 = Inlines.silk_min(inv_gain_Q30, 0x3FFFFFFF);
for (i = idx + psDec.LPC_order; i < psDec.ltp_mem_length; ++i) {
sLTP_Q14[i] = Inlines.silk_SMULWB(inv_gain_Q30, sLTP[i]);
}
for (int k = 0; k < psDec.nb_subfr; ++k) {
int pred_lag_ptr = sLTP_buf_idx - lag + 2;
for (i = 0; i < psDec.subfr_length; ++i) {
int LTP_pred_Q12 = 2;
LTP_pred_Q12 = Inlines.silk_SMLAWB(LTP_pred_Q12, sLTP_Q14[pred_lag_ptr], B_Q14[0]);
LTP_pred_Q12 = Inlines.silk_SMLAWB(LTP_pred_Q12, sLTP_Q14[pred_lag_ptr - 1], B_Q14[1]);
LTP_pred_Q12 = Inlines.silk_SMLAWB(LTP_pred_Q12, sLTP_Q14[pred_lag_ptr - 2], B_Q14[2]);
LTP_pred_Q12 = Inlines.silk_SMLAWB(LTP_pred_Q12, sLTP_Q14[pred_lag_ptr - 3], B_Q14[3]);
LTP_pred_Q12 = Inlines.silk_SMLAWB(LTP_pred_Q12, sLTP_Q14[pred_lag_ptr - 4], B_Q14[4]);
++pred_lag_ptr;
rand_seed = Inlines.silk_RAND(rand_seed);
idx = Inlines.silk_RSHIFT(rand_seed, 25) & 0x7F;
sLTP_Q14[sLTP_buf_idx] = Inlines.silk_LSHIFT32(Inlines.silk_SMLAWB(LTP_pred_Q12, psDec.exc_Q14[rand_ptr + idx], rand_scale_Q14), 2);
++sLTP_buf_idx;
}
for (j = 0; j < 5; ++j) {
B_Q14[j] = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(harm_Gain_Q15, B_Q14[j]), 15);
}
rand_scale_Q14 = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(rand_scale_Q14, rand_Gain_Q15), 15);
psPLC.pitchL_Q8 = Inlines.silk_SMLAWB(psPLC.pitchL_Q8, psPLC.pitchL_Q8, 655);
psPLC.pitchL_Q8 = Inlines.silk_min_32(psPLC.pitchL_Q8, Inlines.silk_LSHIFT(Inlines.silk_SMULBB(18, psDec.fs_kHz), 8));
lag = Inlines.silk_RSHIFT_ROUND(psPLC.pitchL_Q8, 8);
}
int sLPC_Q14_ptr = psDec.ltp_mem_length - 16;
System.arraycopy(psDec.sLPC_Q14_buf, 0, sLTP_Q14, sLPC_Q14_ptr, 16);
Inlines.OpusAssert(psDec.LPC_order >= 10);
for (i = 0; i < psDec.frame_length; ++i) {
int sLPCmaxi = sLPC_Q14_ptr + 16 + i;
int LPC_pred_Q10 = Inlines.silk_RSHIFT(psDec.LPC_order, 1);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 1], psPLC.prevLPC_Q12[0]);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 2], psPLC.prevLPC_Q12[1]);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 3], psPLC.prevLPC_Q12[2]);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 4], psPLC.prevLPC_Q12[3]);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 5], psPLC.prevLPC_Q12[4]);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 6], psPLC.prevLPC_Q12[5]);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 7], psPLC.prevLPC_Q12[6]);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 8], psPLC.prevLPC_Q12[7]);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 9], psPLC.prevLPC_Q12[8]);
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - 10], psPLC.prevLPC_Q12[9]);
for (j = 10; j < psDec.LPC_order; ++j) {
LPC_pred_Q10 = Inlines.silk_SMLAWB(LPC_pred_Q10, sLTP_Q14[sLPCmaxi - j - 1], psPLC.prevLPC_Q12[j]);
}
sLTP_Q14[sLPCmaxi] = Inlines.silk_ADD_LSHIFT32(sLTP_Q14[sLPCmaxi], LPC_pred_Q10, 4);
frame[frame_ptr + i] = (short)Inlines.silk_SAT16(Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWW(sLTP_Q14[sLPCmaxi], prevGain_Q10[1]), 8)));
}
System.arraycopy(sLTP_Q14, sLPC_Q14_ptr + psDec.frame_length, psDec.sLPC_Q14_buf, 0, 16);
psPLC.rand_seed = rand_seed;
psPLC.randScale_Q14 = rand_scale_Q14;
for (i = 0; i < 4; ++i) {
psDecCtrl.pitchL[i] = lag;
}
}
static void silk_PLC_glue_frames(SilkChannelDecoder psDec, short[] frame, int frame_ptr, int length) {
BoxedValueInt energy_shift = new BoxedValueInt(0);
BoxedValueInt energy = new BoxedValueInt(0);
PLCStruct psPLC = psDec.sPLC;
if (psDec.lossCnt != 0) {
BoxedValueInt boxed_conc_e = new BoxedValueInt(0);
BoxedValueInt boxed_conc_shift = new BoxedValueInt(0);
SumSqrShift.silk_sum_sqr_shift(boxed_conc_e, boxed_conc_shift, frame, frame_ptr, length);
psPLC.conc_energy = boxed_conc_e.Val;
psPLC.conc_energy_shift = boxed_conc_shift.Val;
psPLC.last_frame_lost = 1;
} else {
if (psDec.sPLC.last_frame_lost != 0) {
SumSqrShift.silk_sum_sqr_shift(energy, energy_shift, frame, frame_ptr, length);
if (energy_shift.Val > psPLC.conc_energy_shift) {
psPLC.conc_energy = Inlines.silk_RSHIFT(psPLC.conc_energy, energy_shift.Val - psPLC.conc_energy_shift);
} else if (energy_shift.Val < psPLC.conc_energy_shift) {
energy.Val = Inlines.silk_RSHIFT(energy.Val, psPLC.conc_energy_shift - energy_shift.Val);
}
if (energy.Val > psPLC.conc_energy) {
int LZ = Inlines.silk_CLZ32(psPLC.conc_energy);
psPLC.conc_energy = Inlines.silk_LSHIFT(psPLC.conc_energy, --LZ);
energy.Val = Inlines.silk_RSHIFT(energy.Val, Inlines.silk_max_32(24 - LZ, 0));
int frac_Q24 = Inlines.silk_DIV32(psPLC.conc_energy, Inlines.silk_max(energy.Val, 1));
int gain_Q16 = Inlines.silk_LSHIFT(Inlines.silk_SQRT_APPROX(frac_Q24), 4);
int slope_Q16 = Inlines.silk_DIV32_16(65536 - gain_Q16, length);
slope_Q16 = Inlines.silk_LSHIFT(slope_Q16, 2);
for (int i = frame_ptr; i < frame_ptr + length; ++i) {
frame[i] = (short)Inlines.silk_SMULWB(gain_Q16, frame[i]);
if ((gain_Q16 += slope_Q16) > 65536) break;
}
}
}
psPLC.last_frame_lost = 0;
}
}
}