From de5f7da236d8f0fad73edb7561c596936dedfc82 Mon Sep 17 00:00:00 2001 From: ericek111 Date: Thu, 24 Sep 2026 20:46:46 +0000 Subject: [PATCH] Port TS3's WebRTC capture processing to Java TS3 pre-processes the microphone with WebRTC's audio processing module. AudioProcessor ports the stages it enables, in APM's order, per 10 ms at 48 kHz: - The high-pass filter APM forces on with noise suppression, then the three-band split and WebRTC's noise suppressor at TS3's four levels. - The transient suppressor behind "Typing attenuation", which only acts while it is told about key presses. - AGC2 adaptive digital, WebRTC's successor to the AGC1 that TS3 runs. The tests compare against 16-bit outputs of upstream APM builds (webrtc-audio-processing 2.1, and 1.3 for the transient suppressor). Co-Authored-By: Claude Opus 5.5 --- .../main/java/com/ts3client/audio/Fft.java | 6 +- .../audio/processing/AudioProcessor.java | 150 ++++++++ .../audio/processing/HighPassFilter.java | 32 ++ .../audio/processing/ThreeBandFilterBank.java | 152 +++++++++ .../agc2/AdaptiveDigitalConfig.java | 11 + .../agc2/AdaptiveDigitalGainController.java | 97 ++++++ .../audio/processing/agc2/Agc2Common.java | 41 +++ .../audio/processing/agc2/GainApplier.java | 46 +++ .../processing/agc2/GainController2.java | 78 +++++ .../agc2/InterpolatedGainCurve.java | 76 +++++ .../audio/processing/agc2/Limiter.java | 91 +++++ .../processing/agc2/NoiseFloorEstimator.java | 90 +++++ .../processing/agc2/SaturationProtector.java | 122 +++++++ .../processing/agc2/SpeechLevelEstimator.java | 106 ++++++ .../audio/processing/ns/FastMath.java | 49 +++ .../audio/processing/ns/NoiseEstimator.java | 145 ++++++++ .../audio/processing/ns/NoiseSuppressor.java | 320 ++++++++++++++++++ .../audio/processing/ns/NsCommon.java | 29 ++ .../processing/ns/QuantileNoiseEstimator.java | 79 +++++ .../processing/ns/SignalModelEstimator.java | 255 ++++++++++++++ .../ns/SpeechProbabilityEstimator.java | 53 +++ .../audio/processing/ns/SuppressionLevel.java | 30 ++ .../audio/processing/ns/WienerFilter.java | 93 +++++ .../transients/TransientDetector.java | 125 +++++++ .../transients/TransientSuppressor.java | 186 ++++++++++ .../transients/WaveletPacketTree.java | 124 +++++++ .../audio/vad/RnnSpeechDetector.java | 5 + .../java/com/ts3client/audio/vad/RnnVad.java | 8 + .../audio/processing/AudioProcessorTest.java | 174 ++++++++++ .../ts3client/audio/processing/golden-ns0.s16 | Bin 0 -> 96000 bytes .../audio/processing/golden-ns1-typing.s16 | Bin 0 -> 96000 bytes .../ts3client/audio/processing/golden-ns1.s16 | Bin 0 -> 96000 bytes .../ts3client/audio/processing/golden-ns2.s16 | Bin 0 -> 96000 bytes .../ts3client/audio/processing/golden-ns3.s16 | Bin 0 -> 96000 bytes 34 files changed, 2770 insertions(+), 3 deletions(-) create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/AudioProcessor.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/HighPassFilter.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ThreeBandFilterBank.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/AdaptiveDigitalConfig.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/AdaptiveDigitalGainController.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/Agc2Common.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/GainApplier.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/GainController2.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/InterpolatedGainCurve.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/Limiter.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/NoiseFloorEstimator.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/SaturationProtector.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/SpeechLevelEstimator.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/FastMath.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NoiseEstimator.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NoiseSuppressor.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NsCommon.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/QuantileNoiseEstimator.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SignalModelEstimator.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SpeechProbabilityEstimator.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SuppressionLevel.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/WienerFilter.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/TransientDetector.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/TransientSuppressor.java create mode 100644 ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/WaveletPacketTree.java create mode 100644 ts3-client/core/src/test/java/com/ts3client/audio/processing/AudioProcessorTest.java create mode 100644 ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns0.s16 create mode 100644 ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns1-typing.s16 create mode 100644 ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns1.s16 create mode 100644 ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns2.s16 create mode 100644 ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns3.s16 diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/Fft.java b/ts3-client/core/src/main/java/com/ts3client/audio/Fft.java index dbc4a8e..7c4a1d3 100644 --- a/ts3-client/core/src/main/java/com/ts3client/audio/Fft.java +++ b/ts3-client/core/src/main/java/com/ts3client/audio/Fft.java @@ -4,18 +4,18 @@ package com.ts3client.audio; * In-place iterative radix-2 Cooley–Tukey FFT shared by the voice DSP stages. * All arrays must have a power-of-two length. Pure math, no platform dependencies. */ -final class Fft { +public final class Fft { private Fft() { } /** Forward transform (unnormalised). */ - static void forward(double[] re, double[] im) { + public static void forward(double[] re, double[] im) { transform(re, im, false); } /** Inverse transform, normalised by {@code 1/n} so it inverts {@link #forward}. */ - static void inverse(double[] re, double[] im) { + public static void inverse(double[] re, double[] im) { transform(re, im, true); int n = re.length; double scale = 1.0 / n; diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/AudioProcessor.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/AudioProcessor.java new file mode 100644 index 0000000..d63d3cb --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/AudioProcessor.java @@ -0,0 +1,150 @@ +package com.ts3client.audio.processing; + +import com.ts3client.audio.processing.agc2.AdaptiveDigitalConfig; +import com.ts3client.audio.processing.agc2.GainController2; +import com.ts3client.audio.processing.ns.NoiseSuppressor; +import com.ts3client.audio.processing.ns.SuppressionLevel; +import com.ts3client.audio.processing.transients.TransientSuppressor; + +import java.util.concurrent.atomic.AtomicBoolean; + +/** + * The microphone pre-processing chain, set up the way the TeamSpeak 3 client configures + * WebRTC's audio processing module. TS3's capture preprocessor applies, per 10 ms at + * 48 kHz: + *
    + *
  1. noise suppression ("Remove background noise") at {@code denoiser_level} 0–3, run + * on the three-band split. TS3 disables APM's high-pass filter, but APM forces it on + * whenever noise suppression runs, so a 100 Hz high-pass comes with it;
    2. + *
  2. transient suppression ("Typing attenuation"), told about key presses;
    3. + *
  3. automatic gain control. TS3 runs WebRTC's legacy AGC1 (adaptive digital, target + * -9 dBFS, 20 dB compression); this runs its successor, AGC2 adaptive digital.
    4. + *
+ * + *

One deliberate difference: APM only splits into bands for band-wise stages, so with noise + * suppression and AGC1 both off its transient detector reads stale band data and never + * fires. TS3 hides this behind AGC1, which forces a split; with AGC2 it would show, so the + * split is done whenever typing attenuation is on. + * + *

Pure DSP with no platform dependencies. Drive {@link #process} from the capture thread; + * the setters and {@link #keyPressed()} may be called from any thread and take effect at the + * next 10 ms frame. With every stage off, audio passes through untouched. + */ +public final class AudioProcessor { + + public static final int SAMPLE_RATE = 48_000; + public static final int FRAME_SIZE = ThreeBandFilterBank.FULL_BAND_SIZE; + + private volatile boolean noiseSuppression; + private volatile SuppressionLevel suppressionLevel = SuppressionLevel.DB_12; + private volatile boolean transientSuppression; + private volatile boolean gainControl; + private final AtomicBoolean keyPressed = new AtomicBoolean(); + + private final ThreeBandFilterBank filterBank = new ThreeBandFilterBank(); + private HighPassFilter highPassFilter; + private NoiseSuppressor noiseSuppressor; + private TransientSuppressor transientSuppressor; + private GainController2 gainController; + + private final float[] fullBand = new float[FRAME_SIZE]; + private final float[][] bands = new float[ThreeBandFilterBank.NUM_BANDS][ThreeBandFilterBank.SPLIT_BAND_SIZE]; + + public void setNoiseSuppression(boolean enabled) { + this.noiseSuppression = enabled; + } + + public void setSuppressionLevel(SuppressionLevel level) { + this.suppressionLevel = level; + } + + public void setTransientSuppression(boolean enabled) { + this.transientSuppression = enabled; + } + + public void setGainControl(boolean enabled) { + this.gainControl = enabled; + } + + /** Reports a key press anywhere on the system; the transient suppressor only acts while typing. */ + public void keyPressed() { + keyPressed.set(true); + } + + /** Drops all filter state; call when (re)starting capture. */ + public void reset() { + highPassFilter = null; + noiseSuppressor = null; + transientSuppressor = null; + gainController = null; + keyPressed.set(false); + } + + /** + * Processes mono samples in [-1, 1] in place. {@code len} must be a multiple of + * {@link #FRAME_SIZE}. + */ + public void process(float[] buf, int len) { + for (int offset = 0; offset + FRAME_SIZE <= len; offset += FRAME_SIZE) { + processFrame(buf, offset); + } + } + + private void processFrame(float[] buf, int offset) { + applyConfig(); + boolean key = keyPressed.getAndSet(false); + if (noiseSuppressor == null && transientSuppressor == null && gainController == null) return; + + // APM carries samples on the 16-bit scale. + for (int i = 0; i < FRAME_SIZE; i++) { + fullBand[i] = Math.max(-1.f, Math.min(1.f, buf[offset + i])) * 32768.f; + } + + if (highPassFilter != null) { + highPassFilter.process(fullBand, FRAME_SIZE); + } + if (noiseSuppressor != null || transientSuppressor != null) { + filterBank.analysis(fullBand, bands); + } + if (noiseSuppressor != null) { + noiseSuppressor.analyze(bands[0]); + noiseSuppressor.process(bands); + filterBank.synthesis(bands, fullBand); + } + if (transientSuppressor != null) { + transientSuppressor.suppress(fullBand, bands[0], key); + } + if (gainController != null) { + gainController.process(fullBand); + } + + for (int i = 0; i < FRAME_SIZE; i++) { + buf[offset + i] = Math.max(-32768.f, Math.min(32768.f, fullBand[i])) * (1.f / 32768.f); + } + } + + /** Creates or drops stages to match the settings, as APM's {@code ApplyConfig} does. */ + private void applyConfig() { + SuppressionLevel level = suppressionLevel; + if (!noiseSuppression) { + noiseSuppressor = null; + highPassFilter = null; + } else if (noiseSuppressor == null || noiseSuppressor.level() != level) { + // APM builds a fresh suppressor on a level change; the statistics restart too. + noiseSuppressor = new NoiseSuppressor(level, ThreeBandFilterBank.NUM_BANDS); + if (highPassFilter == null) highPassFilter = new HighPassFilter(); + } + + if (!transientSuppression) { + transientSuppressor = null; + } else if (transientSuppressor == null) { + transientSuppressor = new TransientSuppressor(SAMPLE_RATE / ThreeBandFilterBank.NUM_BANDS); + } + + if (!gainControl) { + gainController = null; + } else if (gainController == null) { + gainController = new GainController2(AdaptiveDigitalConfig.DEFAULT); + } + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/HighPassFilter.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/HighPassFilter.java new file mode 100644 index 0000000..48a38dd --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/HighPassFilter.java @@ -0,0 +1,32 @@ +package com.ts3client.audio.processing; + +/** + * APM's high-pass filter at 48 kHz ({@code high_pass_filter.cc}): one second-order + * Butterworth section at 100 Hz, {@code butter(2, 100/24000, 'high')}, in direct form I. + */ +final class HighPassFilter { + + private static final float B0 = 0.99079f; + private static final float B1 = -1.98157f; + private static final float B2 = 0.99079f; + private static final float A1 = -1.98149f; + private static final float A2 = 0.98166f; + + private float x0, x1, y0, y1; + + void process(float[] y, int len) { + float mx0 = x0, mx1 = x1, my0 = y0, my1 = y1; + for (int k = 0; k < len; k++) { + final float tmp = y[k]; + y[k] = B0 * tmp + B1 * mx0 + B2 * mx1 - A1 * my0 - A2 * my1; + mx1 = mx0; + mx0 = tmp; + my1 = my0; + my0 = y[k]; + } + x0 = mx0; + x1 = mx1; + y0 = my0; + y1 = my1; + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ThreeBandFilterBank.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ThreeBandFilterBank.java new file mode 100644 index 0000000..faf8bc6 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ThreeBandFilterBank.java @@ -0,0 +1,152 @@ +package com.ts3client.audio.processing; + +/** + * Splits 10 ms of 48 kHz audio into three 16 kHz bands (0–8, 8–16 and + * 16–24 kHz) and merges them back, ported from WebRTC's + * {@code three_band_filter_bank.cc}. It is how APM feeds the noise suppressor at 48 kHz. + * + *

A cosine-modulated polyphase filter bank: the half-bandwidth low-pass prototype (a + * 48-tap Kaiser-windowed FIR, stored as ten non-zero 4-tap phases) is shifted to the three + * band centres by a DCT. + */ +final class ThreeBandFilterBank { + + static final int NUM_BANDS = 3; + static final int FULL_BAND_SIZE = 480; + static final int SPLIT_BAND_SIZE = FULL_BAND_SIZE / NUM_BANDS; + + private static final int SPARSITY = 4; + private static final int STRIDE_LOG2 = 2; + private static final int STRIDE = 1 << STRIDE_LOG2; + private static final int NUM_ZERO_FILTERS = 2; + private static final int FILTER_SIZE = 4; + private static final int MEMORY_SIZE = FILTER_SIZE * STRIDE - 1; + private static final int NUM_NON_ZERO_FILTERS = SPARSITY * NUM_BANDS - NUM_ZERO_FILTERS; + private static final int SUB_SAMPLING = NUM_BANDS; + private static final int ZERO_FILTER_INDEX_1 = 3; + private static final int ZERO_FILTER_INDEX_2 = 9; + + private static final float[][] FILTER_COEFFS = { + {-0.00047749f, -0.00496888f, +0.16547118f, +0.00425496f}, + {-0.00173287f, -0.01585778f, +0.14989004f, +0.00994113f}, + {-0.00304815f, -0.02536082f, +0.12154542f, +0.01157993f}, + {-0.00346946f, -0.02587886f, +0.04760441f, +0.00607594f}, + {-0.00154717f, -0.01136076f, +0.01387458f, +0.00186353f}, + {+0.00186353f, +0.01387458f, -0.01136076f, -0.00154717f}, + {+0.00607594f, +0.04760441f, -0.02587886f, -0.00346946f}, + {+0.00983212f, +0.08543175f, -0.02982767f, -0.00383509f}, + {+0.00994113f, +0.14989004f, -0.01585778f, -0.00173287f}, + {+0.00425496f, +0.16547118f, -0.00496888f, -0.00047749f}}; + + private static final float[][] DCT_MODULATION = { + {2.f, 2.f, 2.f}, + {1.73205077f, 0.f, -1.73205077f}, + {1.f, -2.f, 1.f}, + {-1.f, 2.f, -1.f}, + {-1.73205077f, 0.f, 1.73205077f}, + {-2.f, -2.f, -2.f}, + {-1.73205077f, 0.f, 1.73205077f}, + {-1.f, 2.f, -1.f}, + {1.f, -2.f, 1.f}, + {1.73205077f, 0.f, -1.73205077f}}; + + private final float[][] stateAnalysis = new float[NUM_NON_ZERO_FILTERS][MEMORY_SIZE]; + private final float[][] stateSynthesis = new float[NUM_NON_ZERO_FILTERS][MEMORY_SIZE]; + + private final float[] inSubsampled = new float[SPLIT_BAND_SIZE]; + private final float[] outSubsampled = new float[SPLIT_BAND_SIZE]; + + /** Splits {@code in} (480 samples) into {@code out[band]} (160 samples each). */ + void analysis(float[] in, float[][] out) { + for (int band = 0; band < NUM_BANDS; band++) { + java.util.Arrays.fill(out[band], 0, SPLIT_BAND_SIZE, 0.f); + } + + for (int downsamplingIndex = 0; downsamplingIndex < SUB_SAMPLING; downsamplingIndex++) { + for (int k = 0; k < SPLIT_BAND_SIZE; k++) { + inSubsampled[k] = in[(SUB_SAMPLING - 1) - downsamplingIndex + SUB_SAMPLING * k]; + } + + for (int inShift = 0; inShift < STRIDE; inShift++) { + int filterIndex = filterIndex(downsamplingIndex + inShift * SUB_SAMPLING); + if (filterIndex < 0) continue; + + filterCore(FILTER_COEFFS[filterIndex], inSubsampled, inShift, outSubsampled, + stateAnalysis[filterIndex]); + + float[] dct = DCT_MODULATION[filterIndex]; + for (int band = 0; band < NUM_BANDS; band++) { + float[] outBand = out[band]; + for (int n = 0; n < SPLIT_BAND_SIZE; n++) { + outBand[n] += dct[band] * outSubsampled[n]; + } + } + } + } + } + + /** Merges {@code in[band]} (160 samples each) back into {@code out} (480 samples). */ + void synthesis(float[][] in, float[] out) { + java.util.Arrays.fill(out, 0, FULL_BAND_SIZE, 0.f); + for (int upsamplingIndex = 0; upsamplingIndex < SUB_SAMPLING; upsamplingIndex++) { + for (int inShift = 0; inShift < STRIDE; inShift++) { + int filterIndex = filterIndex(upsamplingIndex + inShift * SUB_SAMPLING); + if (filterIndex < 0) continue; + + float[] dct = DCT_MODULATION[filterIndex]; + java.util.Arrays.fill(inSubsampled, 0.f); + for (int band = 0; band < NUM_BANDS; band++) { + float[] inBand = in[band]; + for (int n = 0; n < SPLIT_BAND_SIZE; n++) { + inSubsampled[n] += dct[band] * inBand[n]; + } + } + + filterCore(FILTER_COEFFS[filterIndex], inSubsampled, inShift, outSubsampled, + stateSynthesis[filterIndex]); + + final float upsamplingScaling = SUB_SAMPLING; + for (int k = 0; k < SPLIT_BAND_SIZE; k++) { + out[upsamplingIndex + SUB_SAMPLING * k] += upsamplingScaling * outSubsampled[k]; + } + } + } + } + + /** Maps a polyphase index to its stored filter, or -1 for the two all-zero phases. */ + private static int filterIndex(int index) { + if (index == ZERO_FILTER_INDEX_1 || index == ZERO_FILTER_INDEX_2) return -1; + if (index < ZERO_FILTER_INDEX_1) return index; + return index < ZERO_FILTER_INDEX_2 ? index - 1 : index - 2; + } + + /** Filters {@code in} with the sparse (upsampled by {@code STRIDE}) filter, shifted by {@code inShift}. */ + private static void filterCore(float[] filter, float[] in, int inShift, float[] out, float[] state) { + java.util.Arrays.fill(out, 0.f); + for (int k = 0; k < inShift; k++) { + for (int i = 0, j = MEMORY_SIZE + k - inShift; i < FILTER_SIZE; i++, j -= STRIDE) { + out[k] += state[j] * filter[i]; + } + } + + for (int k = inShift, shift = 0; k < FILTER_SIZE * STRIDE; k++, shift++) { + final int loopLimit = Math.min(FILTER_SIZE, 1 + (shift >> STRIDE_LOG2)); + for (int i = 0, j = shift; i < loopLimit; i++, j -= STRIDE) { + out[k] += in[j] * filter[i]; + } + for (int i = loopLimit, j = MEMORY_SIZE + shift - loopLimit * STRIDE; i < FILTER_SIZE; + i++, j -= STRIDE) { + out[k] += state[j] * filter[i]; + } + } + + for (int k = FILTER_SIZE * STRIDE, shift = FILTER_SIZE * STRIDE - inShift; k < SPLIT_BAND_SIZE; + k++, shift++) { + for (int i = 0, j = shift; i < FILTER_SIZE; i++, j -= STRIDE) { + out[k] += in[j] * filter[i]; + } + } + + System.arraycopy(in, SPLIT_BAND_SIZE - MEMORY_SIZE, state, 0, MEMORY_SIZE); + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/AdaptiveDigitalConfig.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/AdaptiveDigitalConfig.java new file mode 100644 index 0000000..6824254 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/AdaptiveDigitalConfig.java @@ -0,0 +1,11 @@ +package com.ts3client.audio.processing.agc2; + +/** + * AGC2's adaptive digital settings, {@code GainController2::AdaptiveDigital} in + * {@code audio_processing.h}. {@link #DEFAULT} holds WebRTC's defaults. + */ +public record AdaptiveDigitalConfig(float headroomDb, float maxGainDb, float initialGainDb, + float maxGainChangeDbPerSecond, float maxOutputNoiseLevelDbfs) { + + public static final AdaptiveDigitalConfig DEFAULT = new AdaptiveDigitalConfig(5.0f, 50.0f, 15.0f, 6.0f, -50.0f); +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/AdaptiveDigitalGainController.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/AdaptiveDigitalGainController.java new file mode 100644 index 0000000..78174aa --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/AdaptiveDigitalGainController.java @@ -0,0 +1,97 @@ +package com.ts3client.audio.processing.agc2; + +import static com.ts3client.audio.processing.agc2.Agc2Common.FRAME_DURATION_MS; +import static com.ts3client.audio.processing.agc2.Agc2Common.LIMITER_THRESHOLD_FOR_AGC_GAIN_DBFS; +import static com.ts3client.audio.processing.agc2.Agc2Common.VAD_CONFIDENCE_THRESHOLD; + +/** + * Picks and applies the adaptive gain, from {@code agc2/adaptive_digital_gain_controller.cc}: + * enough to bring the speech level (plus headroom) up to just below full scale, limited so + * the noise floor stays under {@code maxOutputNoiseLevelDbfs}, and moved at most + * {@code maxGainChangeDbPerSecond}. It only raises the gain after a run of confident speech. + */ +final class AdaptiveDigitalGainController { + + /** What the controller knows about the current frame. */ + record FrameInfo(float speechProbability, float speechLevelDbfs, boolean speechLevelReliable, + float noiseRmsDbfs, float headroomDb, float limiterEnvelopeDbfs) { + } + + private final GainApplier gainApplier; + private final AdaptiveDigitalConfig config; + private final int adjacentSpeechFramesThreshold; + private final float maxGainChangeDbPer10ms; + private int framesToGainIncreaseAllowed; + private float lastGainDb; + + AdaptiveDigitalGainController(AdaptiveDigitalConfig config, int adjacentSpeechFramesThreshold) { + this.config = config; + this.adjacentSpeechFramesThreshold = adjacentSpeechFramesThreshold; + this.gainApplier = new GainApplier(Agc2Common.dbToRatio(config.initialGainDb())); + this.maxGainChangeDbPer10ms = config.maxGainChangeDbPerSecond() * FRAME_DURATION_MS / 1000.0f; + this.framesToGainIncreaseAllowed = adjacentSpeechFramesThreshold; + this.lastGainDb = config.initialGainDb(); + } + + void process(FrameInfo info, float[] frame, int samples) { + final float inputLevelDbfs = info.speechLevelDbfs() + info.headroomDb(); + final float targetGainDb = limitGainByLowConfidence( + limitGainByNoise(computeGainDb(inputLevelDbfs), info.noiseRmsDbfs()), + lastGainDb, info.limiterEnvelopeDbfs(), info.speechLevelReliable()); + + // Only allow the gain to rise after a run of confident speech frames. + boolean firstConfidentSpeechFrame = false; + if (info.speechProbability() < VAD_CONFIDENCE_THRESHOLD) { + framesToGainIncreaseAllowed = adjacentSpeechFramesThreshold; + } else if (framesToGainIncreaseAllowed > 0) { + framesToGainIncreaseAllowed--; + firstConfidentSpeechFrame = framesToGainIncreaseAllowed == 0; + } + final boolean gainIncreaseAllowed = framesToGainIncreaseAllowed == 0; + + float maxGainIncreaseDb = maxGainChangeDbPer10ms; + if (firstConfidentSpeechFrame) { + // Make up for the frames the increase was held back. + maxGainIncreaseDb *= adjacentSpeechFramesThreshold; + } + + float difference = targetGainDb - lastGainDb; + if (!gainIncreaseAllowed) { + difference = Math.min(difference, 0.0f); + } + final float gainChangeThisFrameDb = Math.max(-maxGainChangeDbPer10ms, Math.min(maxGainIncreaseDb, difference)); + + if (gainChangeThisFrameDb != 0.f) { + gainApplier.setGainFactor(Agc2Common.dbToRatio(lastGainDb + gainChangeThisFrameDb)); + } + gainApplier.applyGain(frame, samples); + lastGainDb = lastGainDb + gainChangeThisFrameDb; + } + + /** The gain that puts the input level at {@code -headroomDb}, capped at {@code maxGainDb}. */ + private float computeGainDb(float inputLevelDbfs) { + if (inputLevelDbfs < -(config.headroomDb() + config.maxGainDb())) { + return config.maxGainDb(); + } + if (inputLevelDbfs < -config.headroomDb()) { + return -config.headroomDb() - inputLevelDbfs; + } + return 0.0f; + } + + private float limitGainByNoise(float targetGainDb, float inputNoiseLevelDbfs) { + final float maxAllowedGainDb = config.maxOutputNoiseLevelDbfs() - inputNoiseLevelDbfs; + return Math.min(targetGainDb, Math.max(maxAllowedGainDb, 0.0f)); + } + + /** Until the speech level is trusted, don't push the limiter's envelope above -1 dBFS. */ + private static float limitGainByLowConfidence(float targetGainDb, float lastGainDb, + float limiterAudioLevelDbfs, boolean estimateIsConfident) { + if (estimateIsConfident || limiterAudioLevelDbfs <= LIMITER_THRESHOLD_FOR_AGC_GAIN_DBFS) { + return targetGainDb; + } + final float limiterLevelDbfsBeforeGain = limiterAudioLevelDbfs - lastGainDb; + final float newTargetGainDb = Math.max(LIMITER_THRESHOLD_FOR_AGC_GAIN_DBFS - limiterLevelDbfsBeforeGain, 0.0f); + return Math.min(newTargetGainDb, targetGainDb); + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/Agc2Common.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/Agc2Common.java new file mode 100644 index 0000000..19924f8 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/Agc2Common.java @@ -0,0 +1,41 @@ +package com.ts3client.audio.processing.agc2; + +/** Constants and level conversions shared by AGC2, from {@code agc2/agc2_common.h} and {@code audio_util.h}. */ +final class Agc2Common { + + static final float MIN_FLOAT_S16_VALUE = -32768.0f; + static final float MAX_FLOAT_S16_VALUE = 32767.0f; + static final float MIN_LEVEL_DBFS = -90.31f; + + static final int FRAME_DURATION_MS = 10; + static final int SUB_FRAMES_IN_FRAME = 20; + + /** Target peak for the limiter's envelope when the speech level isn't trusted yet. */ + static final float LIMITER_THRESHOLD_FOR_AGC_GAIN_DBFS = -1.0f; + + static final int VAD_RESET_PERIOD_MS = 1500; + static final float VAD_CONFIDENCE_THRESHOLD = 0.95f; + static final int ADJACENT_SPEECH_FRAMES_THRESHOLD = 12; + + static final float LEVEL_ESTIMATOR_TIME_TO_CONFIDENCE_MS = 400; + static final float LEVEL_ESTIMATOR_LEAK_FACTOR = 1.0f - 1.0f / LEVEL_ESTIMATOR_TIME_TO_CONFIDENCE_MS; + + static final float SATURATION_PROTECTOR_INITIAL_HEADROOM_DB = 20.0f; + static final int SATURATION_PROTECTOR_BUFFER_SIZE = 4; + + private Agc2Common() { + } + + static float dbToRatio(float db) { + return (float) Math.pow(10.0f, db / 20.0f); + } + + /** Level of a 16-bit-scale amplitude in dBFS, floored at the int16 noise floor. */ + static float floatS16ToDbfs(float v) { + final float minDbfs = -90.30899869919436f; + if (v <= 1.0f) { + return minDbfs; + } + return 20.0f * (float) Math.log10(v) + minDbfs; + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/GainApplier.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/GainApplier.java new file mode 100644 index 0000000..2bae21b --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/GainApplier.java @@ -0,0 +1,46 @@ +package com.ts3client.audio.processing.agc2; + +/** + * Applies a gain factor, ramping linearly across the frame from the previous factor, from + * {@code agc2/gain_applier.cc}. + */ +final class GainApplier { + + private float lastGainFactor; + private float currentGainFactor; + + GainApplier(float initialGainFactor) { + this.lastGainFactor = initialGainFactor; + this.currentGainFactor = initialGainFactor; + } + + void setGainFactor(float gainFactor) { + currentGainFactor = gainFactor; + } + + void applyGain(float[] frame, int samples) { + final float last = lastGainFactor; + final float target = currentGainFactor; + lastGainFactor = currentGainFactor; + if (last == target && gainCloseToOne(target)) { + return; + } + if (last == target) { + for (int i = 0; i < samples; i++) { + frame[i] *= target; + } + return; + } + final float increment = (target - last) * (1.f / samples); + float gain = last; + for (int i = 0; i < samples; i++) { + frame[i] *= gain; + gain += increment; + } + } + + private static boolean gainCloseToOne(float gainFactor) { + return 1.f - 1.f / Agc2Common.MAX_FLOAT_S16_VALUE <= gainFactor + && gainFactor <= 1.f + 1.f / Agc2Common.MAX_FLOAT_S16_VALUE; + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/GainController2.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/GainController2.java new file mode 100644 index 0000000..e3fac82 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/GainController2.java @@ -0,0 +1,78 @@ +package com.ts3client.audio.processing.agc2; + +import static com.ts3client.audio.processing.agc2.Agc2Common.ADJACENT_SPEECH_FRAMES_THRESHOLD; +import static com.ts3client.audio.processing.agc2.Agc2Common.FRAME_DURATION_MS; +import static com.ts3client.audio.processing.agc2.Agc2Common.SATURATION_PROTECTOR_INITIAL_HEADROOM_DB; +import static com.ts3client.audio.processing.agc2.Agc2Common.VAD_RESET_PERIOD_MS; + +import com.ts3client.audio.vad.RnnSpeechDetector; + +/** + * WebRTC's AGC2 with the adaptive digital controller, as APM runs it + * ({@code gain_controller2.cc}): its own RNN VAD, speech and noise level estimators, a + * saturation protector choosing the headroom, the adaptive gain, and the output limiter. + * + *

TS3 uses the older AGC1 in adaptive-digital mode instead. AGC2 is its replacement in + * WebRTC: it measures the speech level only on frames its RNN VAD calls speech, and caps + * the gain so the measured noise floor stays below -50 dBFS. + * + *

Takes 10 ms mono frames at 48 kHz on the 16-bit scale, in place. + */ +public final class GainController2 { + + private static final int FRAME_SIZE = 480; + + private final RnnSpeechDetector vad = new RnnSpeechDetector(48_000); + private final float[] vadFrame = new float[FRAME_SIZE]; + private final int vadResetPeriodFrames = VAD_RESET_PERIOD_MS / FRAME_DURATION_MS; + private int timeToVadReset = vadResetPeriodFrames; + + private final SpeechLevelEstimator speechLevelEstimator; + private final NoiseFloorEstimator noiseLevelEstimator = new NoiseFloorEstimator(); + private final SaturationProtector saturationProtector = + new SaturationProtector(SATURATION_PROTECTOR_INITIAL_HEADROOM_DB, ADJACENT_SPEECH_FRAMES_THRESHOLD); + private final AdaptiveDigitalGainController adaptiveDigitalController; + private final Limiter limiter = new Limiter(); + + public GainController2(AdaptiveDigitalConfig config) { + this.speechLevelEstimator = new SpeechLevelEstimator(config, ADJACENT_SPEECH_FRAMES_THRESHOLD); + this.adaptiveDigitalController = new AdaptiveDigitalGainController(config, ADJACENT_SPEECH_FRAMES_THRESHOLD); + } + + public void process(float[] frame) { + final float speechProbability = analyzeVad(frame); + + float peak = 0.0f; + float rms = 0.0f; + for (int i = 0; i < FRAME_SIZE; i++) { + peak = Math.max(Math.abs(frame[i]), peak); + rms += frame[i] * frame[i]; + } + final float peakDbfs = Agc2Common.floatS16ToDbfs(peak); + final float rmsDbfs = Agc2Common.floatS16ToDbfs((float) Math.sqrt(rms / FRAME_SIZE)); + + final float noiseRmsDbfs = noiseLevelEstimator.analyze(frame, FRAME_SIZE); + speechLevelEstimator.update(rmsDbfs, peakDbfs, speechProbability); + final float speechLevelDbfs = speechLevelEstimator.levelDbfs(); + + saturationProtector.analyze(speechProbability, peakDbfs, speechLevelDbfs); + final float limiterEnvelopeDbfs = Agc2Common.floatS16ToDbfs(limiter.lastAudioLevel()); + + adaptiveDigitalController.process(new AdaptiveDigitalGainController.FrameInfo( + speechProbability, speechLevelDbfs, speechLevelEstimator.isConfident(), + noiseRmsDbfs, saturationProtector.headroomDb(), limiterEnvelopeDbfs), frame, FRAME_SIZE); + limiter.process(frame, FRAME_SIZE); + } + + /** {@code vad_wrapper.cc}: the RNN's state is reset every 1.5 s so it can't latch. */ + private float analyzeVad(float[] frame) { + if (--timeToVadReset <= 0) { + vad.resetNetwork(); + timeToVadReset = vadResetPeriodFrames; + } + for (int i = 0; i < FRAME_SIZE; i++) { + vadFrame[i] = frame[i] * (1.f / 32768.f); + } + return (float) vad.process(vadFrame, FRAME_SIZE); + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/InterpolatedGainCurve.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/InterpolatedGainCurve.java new file mode 100644 index 0000000..ea086ae --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/InterpolatedGainCurve.java @@ -0,0 +1,76 @@ +package com.ts3client.audio.processing.agc2; + +/** + * The limiter's gain curve as a piecewise-linear table, from + * {@code agc2/interpolated_gain_curve.h}: identity below the knee (about -0.8 dBFS), + * then a soft knee into a hard limit at full scale. + */ +final class InterpolatedGainCurve { + + private static final float MAX_INPUT_LEVEL_LINEAR = 36766.300710566735f; + + private static final float[] X = { + 30057.296875f, 30148.986328125f, 30240.67578125f, 30424.052734375f, + 30607.4296875f, 30790.806640625f, 30974.18359375f, 31157.560546875f, + 31340.939453125f, 31524.31640625f, 31707.693359375f, 31891.0703125f, + 32074.447265625f, 32257.82421875f, 32441.201171875f, 32624.580078125f, + 32807.95703125f, 32991.33203125f, 33174.7109375f, 33358.08984375f, + 33541.46484375f, 33724.84375f, 33819.53515625f, 34009.5390625f, + 34200.05859375f, 34389.81640625f, 34674.48828125f, 35054.375f, + 35434.86328125f, 35814.81640625f, 36195.16796875f, 36575.03125f}; + + private static final float[] M = { + -3.515235675877192989e-07f, -1.050251626111275982e-06f, + -2.085213736791047268e-06f, -3.443004743530764244e-06f, + -4.773849468620028347e-06f, -6.077375928725814447e-06f, + -7.353257842623861507e-06f, -8.601219633419532329e-06f, + -9.821013009059242904e-06f, -1.101243378798244521e-05f, + -1.217532644659513608e-05f, -1.330956911260727793e-05f, + -1.441507538402220234e-05f, -1.549179251014720649e-05f, + -1.653970684856176376e-05f, -1.755882840370759368e-05f, + -1.854918446042574942e-05f, -1.951086778717581183e-05f, + -2.044398024736437947e-05f, -2.1348627342376858e-05f, + -2.222496914328075945e-05f, -2.265374678245279938e-05f, + -2.242570917587727308e-05f, -2.220122041762806475e-05f, + -2.19802095671184361e-05f, -2.176260204578284174e-05f, + -2.133731686626560986e-05f, -2.092481918225530535e-05f, + -2.052459603874012828e-05f, -2.013615448959171772e-05f, + -1.975903069251216948e-05f, -1.939277899509761482e-05f}; + + private static final float[] Q = { + 1.010565876960754395f, 1.031631827354431152f, 1.062929749488830566f, + 1.104239225387573242f, 1.144973039627075195f, 1.185109615325927734f, + 1.224629044532775879f, 1.263512492179870605f, 1.301741957664489746f, + 1.339300632476806641f, 1.376173257827758789f, 1.412345528602600098f, + 1.447803974151611328f, 1.482536554336547852f, 1.516532182693481445f, + 1.549780607223510742f, 1.582272171974182129f, 1.613999366760253906f, + 1.644955039024353027f, 1.675132393836975098f, 1.704526185989379883f, + 1.718986630439758301f, 1.711274504661560059f, 1.703639745712280273f, + 1.696081161499023438f, 1.688597679138183594f, 1.673851132392883301f, + 1.659391283988952637f, 1.645209431648254395f, 1.631297469139099121f, + 1.617647409439086914f, 1.604251742362976074f}; + + private InterpolatedGainCurve() { + } + + /** The gain to apply at {@code inputLevel}, a 16-bit-scale peak level. */ + static float lookUpGainToApply(float inputLevel) { + if (inputLevel <= X[0]) { + return 1.0f; + } + if (inputLevel >= MAX_INPUT_LEVEL_LINEAR) { + // Saturating: scale the peak straight down to full scale. + return 32768.f / inputLevel; + } + // Segment whose start is the last point below inputLevel (lower_bound - 1). + int lo = 0; + int hi = X.length; + while (lo < hi) { + int mid = (lo + hi) >>> 1; + if (X[mid] < inputLevel) lo = mid + 1; + else hi = mid; + } + final int index = lo - 1; + return M[index] * inputLevel + Q[index]; + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/Limiter.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/Limiter.java new file mode 100644 index 0000000..aec29d1 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/Limiter.java @@ -0,0 +1,91 @@ +package com.ts3client.audio.processing.agc2; + +import static com.ts3client.audio.processing.agc2.Agc2Common.MAX_FLOAT_S16_VALUE; +import static com.ts3client.audio.processing.agc2.Agc2Common.MIN_FLOAT_S16_VALUE; +import static com.ts3client.audio.processing.agc2.Agc2Common.SUB_FRAMES_IN_FRAME; + +/** + * AGC2's output limiter, from {@code agc2/limiter.cc} and {@code fixed_digital_level_estimator.cc}: + * a peak envelope per 1/20 of the frame (instant attack, slow decay) looked up on the + * limiter's gain curve, with the gain interpolated across the sub-frames. + */ +final class Limiter { + + private static final float ATTACK_FILTER_CONSTANT = 0.0f; + private static final float DECAY_FILTER_CONSTANT = 0.9971259f; + private static final float ATTACK_FIRST_SUBFRAME_INTERPOLATION_POWER = 8.0f; + + private final float[] envelope = new float[SUB_FRAMES_IN_FRAME]; + private final float[] scalingFactors = new float[SUB_FRAMES_IN_FRAME + 1]; + private final float[] perSampleScalingFactors = new float[480]; + private float filterStateLevel; + private float lastScalingFactor = 1.f; + + /** The envelope level of the last sub-frame, on the 16-bit scale. */ + float lastAudioLevel() { + return filterStateLevel; + } + + void process(float[] frame, int samples) { + computeLevel(frame, samples); + + scalingFactors[0] = lastScalingFactor; + for (int i = 0; i < SUB_FRAMES_IN_FRAME; i++) { + scalingFactors[i + 1] = InterpolatedGainCurve.lookUpGainToApply(envelope[i]); + } + + computePerSampleSubframeFactors(samples); + for (int j = 0; j < samples; j++) { + frame[j] = Math.max(MIN_FLOAT_S16_VALUE, Math.min(MAX_FLOAT_S16_VALUE, frame[j] * perSampleScalingFactors[j])); + } + lastScalingFactor = scalingFactors[SUB_FRAMES_IN_FRAME]; + } + + private void computeLevel(float[] frame, int samples) { + final int samplesInSubFrame = samples / SUB_FRAMES_IN_FRAME; + java.util.Arrays.fill(envelope, 0.f); + for (int subFrame = 0; subFrame < SUB_FRAMES_IN_FRAME; subFrame++) { + for (int i = 0; i < samplesInSubFrame; i++) { + envelope[subFrame] = Math.max(envelope[subFrame], Math.abs(frame[subFrame * samplesInSubFrame + i])); + } + } + // Look one sub-frame ahead, so the gain is already down when a peak arrives. + for (int subFrame = 0; subFrame < SUB_FRAMES_IN_FRAME - 1; subFrame++) { + if (envelope[subFrame] < envelope[subFrame + 1]) { + envelope[subFrame] = envelope[subFrame + 1]; + } + } + for (int subFrame = 0; subFrame < SUB_FRAMES_IN_FRAME; subFrame++) { + final float value = envelope[subFrame]; + if (value > filterStateLevel) { + envelope[subFrame] = value * (1 - ATTACK_FILTER_CONSTANT) + filterStateLevel * ATTACK_FILTER_CONSTANT; + } else { + envelope[subFrame] = value * (1 - DECAY_FILTER_CONSTANT) + filterStateLevel * DECAY_FILTER_CONSTANT; + } + filterStateLevel = envelope[subFrame]; + } + } + + private void computePerSampleSubframeFactors(int samples) { + final int subframeSize = samples / SUB_FRAMES_IN_FRAME; + final boolean isAttack = scalingFactors[0] > scalingFactors[1]; + if (isAttack) { + // Upstream intends a power-curve fade here, but its i / n is integer division + // and always 0, so the first sub-frame holds the previous factor. Kept as is. + final int n = subframeSize; + for (int i = 0; i < n; i++) { + perSampleScalingFactors[i] = (float) Math.pow(1.f - i / n, ATTACK_FIRST_SUBFRAME_INTERPOLATION_POWER) + * (scalingFactors[0] - scalingFactors[1]) + scalingFactors[1]; + } + } + for (int i = isAttack ? 1 : 0; i < SUB_FRAMES_IN_FRAME; i++) { + final int subframeStart = i * subframeSize; + final float scalingStart = scalingFactors[i]; + final float scalingEnd = scalingFactors[i + 1]; + final float scalingDiff = (scalingEnd - scalingStart) / subframeSize; + for (int j = 0; j < subframeSize; j++) { + perSampleScalingFactors[subframeStart + j] = scalingStart + scalingDiff * j; + } + } + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/NoiseFloorEstimator.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/NoiseFloorEstimator.java new file mode 100644 index 0000000..71c70d3 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/NoiseFloorEstimator.java @@ -0,0 +1,90 @@ +package com.ts3client.audio.processing.agc2; + +/** + * Estimates the background noise level, from {@code agc2/noise_level_estimator.cc}: the + * minimum frame energy over 5 s periods, rising only slowly between periods, so AGC2 + * can cap its gain before it amplifies the noise floor. + */ +final class NoiseFloorEstimator { + + private static final int FRAMES_PER_SECOND = 100; + private static final int UPDATE_PERIOD_NUM_FRAMES = 500; + + private int sampleRateHz; + private float minNoiseEnergy; + private boolean firstPeriod; + private boolean preliminaryNoiseEnergySet; + private float preliminaryNoiseEnergy; + private float noiseEnergy; + private int counter; + + NoiseFloorEstimator() { + initialize(48000); + } + + /** @return the noise RMS in dBFS */ + float analyze(float[] frame, int samples) { + final int rate = samples * FRAMES_PER_SECOND; + if (rate != sampleRateHz) { + initialize(rate); + } + float frameEnergy = 0.0f; + for (int i = 0; i < samples; i++) { + frameEnergy += frame[i] * frame[i]; + } + if (frameEnergy <= minNoiseEnergy) { + // Ignore frames at or below the int16 noise floor, e.g. digital silence. + return energyToDbfs(noiseEnergy, samples); + } + + if (preliminaryNoiseEnergySet) { + preliminaryNoiseEnergy = Math.min(preliminaryNoiseEnergy, frameEnergy); + } else { + preliminaryNoiseEnergy = frameEnergy; + preliminaryNoiseEnergySet = true; + } + + if (counter == 0) { + // Period over: move towards the new minimum, slowly if it rose. + firstPeriod = false; + noiseEnergy = smooth(noiseEnergy, preliminaryNoiseEnergy); + counter = UPDATE_PERIOD_NUM_FRAMES; + preliminaryNoiseEnergySet = false; + } else if (firstPeriod) { + noiseEnergy = preliminaryNoiseEnergy; + counter--; + } else { + noiseEnergy = Math.min(noiseEnergy, preliminaryNoiseEnergy); + counter--; + } + return energyToDbfs(noiseEnergy, samples); + } + + private void initialize(int rate) { + sampleRateHz = rate; + firstPeriod = true; + preliminaryNoiseEnergySet = false; + // Two LSBs of RMS: anything quieter is treated as silence. + minNoiseEnergy = rate * 2.0f * 2.0f / FRAMES_PER_SECOND; + preliminaryNoiseEnergy = minNoiseEnergy; + noiseEnergy = minNoiseEnergy; + counter = UPDATE_PERIOD_NUM_FRAMES; + } + + private static float smooth(float currentEstimate, float newEstimate) { + final float attack = 0.5f; + if (currentEstimate < newEstimate) { + return attack * newEstimate + (1.0f - attack) * currentEstimate; + } + return newEstimate; + } + + private static float energyToDbfs(float signalEnergy, int numSamples) { + final float rmsSquare = signalEnergy / numSamples; + final float minDbfs = -90.30899869919436f; + if (rmsSquare <= 1.0f) { + return minDbfs; + } + return 10.0f * (float) Math.log10(rmsSquare) + minDbfs; + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/SaturationProtector.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/SaturationProtector.java new file mode 100644 index 0000000..af7a760 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/SaturationProtector.java @@ -0,0 +1,122 @@ +package com.ts3client.audio.processing.agc2; + +import static com.ts3client.audio.processing.agc2.Agc2Common.FRAME_DURATION_MS; +import static com.ts3client.audio.processing.agc2.Agc2Common.MIN_LEVEL_DBFS; +import static com.ts3client.audio.processing.agc2.Agc2Common.SATURATION_PROTECTOR_BUFFER_SIZE; +import static com.ts3client.audio.processing.agc2.Agc2Common.VAD_CONFIDENCE_THRESHOLD; + +/** + * Chooses how much headroom to leave above the speech level, from + * {@code agc2/saturation_protector.cc}: it tracks how far the speech peaks, delayed by a + * few 400 ms super-frames, sit above the speech level, and keeps the margin within + * 12–25 dB. + */ +final class SaturationProtector { + + private static final int PEAK_ENVELOPER_SUPER_FRAME_LENGTH_MS = 400; + private static final float MIN_MARGIN_DB = 12.0f; + private static final float MAX_MARGIN_DB = 25.0f; + private static final float ATTACK = 0.9988493699365052f; + private static final float DECAY = 0.9997697679981565f; + + private static final class State { + float headroomDb; + /** Ring buffer of past super-frame peaks. */ + final float[] peakDelayBuffer = new float[SATURATION_PROTECTOR_BUFFER_SIZE]; + int next; + int size; + float maxPeaksDbfs; + int timeSincePushMs; + + void reset(float initialHeadroomDb) { + headroomDb = initialHeadroomDb; + next = 0; + size = 0; + maxPeaksDbfs = MIN_LEVEL_DBFS; + timeSincePushMs = 0; + } + + void copyFrom(State o) { + headroomDb = o.headroomDb; + System.arraycopy(o.peakDelayBuffer, 0, peakDelayBuffer, 0, peakDelayBuffer.length); + next = o.next; + size = o.size; + maxPeaksDbfs = o.maxPeaksDbfs; + timeSincePushMs = o.timeSincePushMs; + } + + void push(float v) { + peakDelayBuffer[next++] = v; + if (next == peakDelayBuffer.length) next = 0; + if (size < peakDelayBuffer.length) size++; + } + + /** The oldest buffered peak, or {@code fallback} while the buffer is empty. */ + float front(float fallback) { + if (size == 0) return fallback; + return peakDelayBuffer[size == peakDelayBuffer.length ? next : 0]; + } + + void update(float peakDbfs, float speechLevelDbfs) { + maxPeaksDbfs = Math.max(maxPeaksDbfs, peakDbfs); + timeSincePushMs += FRAME_DURATION_MS; + if (timeSincePushMs > PEAK_ENVELOPER_SUPER_FRAME_LENGTH_MS) { + push(maxPeaksDbfs); + maxPeaksDbfs = MIN_LEVEL_DBFS; + timeSincePushMs = 0; + } + + final float delayedPeakDbfs = front(maxPeaksDbfs); + final float differenceDb = delayedPeakDbfs - speechLevelDbfs; + if (differenceDb > headroomDb) { + headroomDb = headroomDb * ATTACK + differenceDb * (1.0f - ATTACK); + } else { + headroomDb = headroomDb * DECAY + differenceDb * (1.0f - DECAY); + } + headroomDb = Math.max(MIN_MARGIN_DB, Math.min(MAX_MARGIN_DB, headroomDb)); + } + } + + private final float initialHeadroomDb; + private final int adjacentSpeechFramesThreshold; + private final State preliminary = new State(); + private final State reliable = new State(); + private int numAdjacentSpeechFrames; + private float headroomDb; + + SaturationProtector(float initialHeadroomDb, int adjacentSpeechFramesThreshold) { + this.initialHeadroomDb = initialHeadroomDb; + this.adjacentSpeechFramesThreshold = adjacentSpeechFramesThreshold; + reset(); + } + + float headroomDb() { + return headroomDb; + } + + void analyze(float speechProbability, float peakDbfs, float speechLevelDbfs) { + if (speechProbability < VAD_CONFIDENCE_THRESHOLD) { + if (adjacentSpeechFramesThreshold > 1) { + if (numAdjacentSpeechFrames >= adjacentSpeechFramesThreshold) { + reliable.copyFrom(preliminary); + } else if (numAdjacentSpeechFrames > 0) { + preliminary.copyFrom(reliable); + } + } + numAdjacentSpeechFrames = 0; + } else { + numAdjacentSpeechFrames++; + preliminary.update(peakDbfs, speechLevelDbfs); + if (numAdjacentSpeechFrames >= adjacentSpeechFramesThreshold) { + headroomDb = preliminary.headroomDb; + } + } + } + + void reset() { + numAdjacentSpeechFrames = 0; + headroomDb = initialHeadroomDb; + preliminary.reset(initialHeadroomDb); + reliable.reset(initialHeadroomDb); + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/SpeechLevelEstimator.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/SpeechLevelEstimator.java new file mode 100644 index 0000000..ca51772 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/agc2/SpeechLevelEstimator.java @@ -0,0 +1,106 @@ +package com.ts3client.audio.processing.agc2; + +import static com.ts3client.audio.processing.agc2.Agc2Common.FRAME_DURATION_MS; +import static com.ts3client.audio.processing.agc2.Agc2Common.LEVEL_ESTIMATOR_LEAK_FACTOR; +import static com.ts3client.audio.processing.agc2.Agc2Common.LEVEL_ESTIMATOR_TIME_TO_CONFIDENCE_MS; +import static com.ts3client.audio.processing.agc2.Agc2Common.SATURATION_PROTECTOR_INITIAL_HEADROOM_DB; +import static com.ts3client.audio.processing.agc2.Agc2Common.VAD_CONFIDENCE_THRESHOLD; + +/** + * Estimates the speech RMS level, from {@code agc2/speech_level_estimator.cc}: a + * speech-probability-weighted average over confidently voiced frames, which only takes + * effect after a run of adjacent speech frames so short noises don't move it. + */ +final class SpeechLevelEstimator { + + /** A level estimate kept as a weighted ratio, and the time left until it is trusted. */ + private static final class State { + int timeToConfidenceMs; + float numerator; + float denominator; + + void copyFrom(State other) { + timeToConfidenceMs = other.timeToConfidenceMs; + numerator = other.numerator; + denominator = other.denominator; + } + } + + private final float initialSpeechLevelDbfs; + private final int adjacentSpeechFramesThreshold; + private final State preliminary = new State(); + private final State reliable = new State(); + private float levelDbfs; + private boolean confident; + private int numAdjacentSpeechFrames; + + SpeechLevelEstimator(AdaptiveDigitalConfig config, int adjacentSpeechFramesThreshold) { + this.initialSpeechLevelDbfs = clamp(-SATURATION_PROTECTOR_INITIAL_HEADROOM_DB + - config.initialGainDb() - config.headroomDb()); + this.adjacentSpeechFramesThreshold = adjacentSpeechFramesThreshold; + reset(); + } + + float levelDbfs() { + return levelDbfs; + } + + boolean isConfident() { + return confident; + } + + void update(float rmsDbfs, float peakDbfs, float speechProbability) { + if (speechProbability < VAD_CONFIDENCE_THRESHOLD) { + // Not a speech frame: commit or roll back the preliminary estimate. + if (adjacentSpeechFramesThreshold > 1) { + if (numAdjacentSpeechFrames >= adjacentSpeechFramesThreshold) { + reliable.copyFrom(preliminary); + } else if (numAdjacentSpeechFrames > 0) { + preliminary.copyFrom(reliable); + } + } + numAdjacentSpeechFrames = 0; + } else { + numAdjacentSpeechFrames++; + final boolean bufferIsFull = preliminary.timeToConfidenceMs == 0; + if (!bufferIsFull) { + preliminary.timeToConfidenceMs -= FRAME_DURATION_MS; + } + final float leakFactor = bufferIsFull ? LEVEL_ESTIMATOR_LEAK_FACTOR : 1.0f; + preliminary.numerator = preliminary.numerator * leakFactor + rmsDbfs * speechProbability; + preliminary.denominator = preliminary.denominator * leakFactor + speechProbability; + final float level = preliminary.numerator / preliminary.denominator; + if (numAdjacentSpeechFrames >= adjacentSpeechFramesThreshold) { + levelDbfs = clamp(level); + } + } + updateIsConfident(); + } + + private void updateIsConfident() { + if (adjacentSpeechFramesThreshold == 1) { + confident = preliminary.timeToConfidenceMs == 0; + return; + } + confident = reliable.timeToConfidenceMs == 0 + || (numAdjacentSpeechFrames >= adjacentSpeechFramesThreshold + && preliminary.timeToConfidenceMs == 0); + } + + void reset() { + resetState(preliminary); + resetState(reliable); + levelDbfs = initialSpeechLevelDbfs; + numAdjacentSpeechFrames = 0; + } + + private void resetState(State state) { + state.timeToConfidenceMs = (int) LEVEL_ESTIMATOR_TIME_TO_CONFIDENCE_MS; + state.numerator = initialSpeechLevelDbfs; + state.denominator = 1.0f; + } + + private static float clamp(float levelDbfs) { + return Math.max(-90.0f, Math.min(30.0f, levelDbfs)); + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/FastMath.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/FastMath.java new file mode 100644 index 0000000..ffdeb47 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/FastMath.java @@ -0,0 +1,49 @@ +package com.ts3client.audio.processing.ns; + +/** + * The noise suppressor's approximate log/exp, ported from {@code ns/fast_math.cc}. They are + * deliberately inexact (the log reads the float's exponent bits), and the suppressor's + * statistics were tuned with these errors in place, so they are kept as they are. + */ +final class FastMath { + + private static final float LOG_OF_2 = 0.69314718056f; + private static final float LOG10_OF_E = 0.4342944819f; + + private FastMath() { + } + + /** Reads the float's bits as an integer: the exponent lands in the top, scaled. */ + private static float fastLog2(float in) { + float out = Float.floatToRawIntBits(in); + out *= 1.1920929e-7f; // 1/2^23 + out -= 126.942695f; // exponent bias + return out; + } + + static float sqrt(float f) { + return (float) Math.sqrt(f); + } + + static float pow2(float p) { + return (float) Math.pow(2.0f, p); + } + + static float pow(float x, float p) { + return pow2(p * fastLog2(x)); + } + + static float log(float x) { + return fastLog2(x) * LOG_OF_2; + } + + static void log(float[] x, float[] y) { + for (int k = 0; k < x.length; k++) { + y[k] = log(x[k]); + } + } + + static float exp(float x) { + return pow(10.f, x * LOG10_OF_E); + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NoiseEstimator.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NoiseEstimator.java new file mode 100644 index 0000000..5a3eec2 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NoiseEstimator.java @@ -0,0 +1,145 @@ +package com.ts3client.audio.processing.ns; + +import static com.ts3client.audio.processing.ns.NsCommon.FFT_SIZE_BY_2_PLUS_1; +import static com.ts3client.audio.processing.ns.NsCommon.SHORT_STARTUP_PHASE_BLOCKS; + +/** + * The noise spectrum, from {@code ns/noise_estimator.cc}: a quantile estimate, blended during + * the first half second with a parametric white/pink model fitted to the input, then + * refined each block according to how likely each bin holds speech. + */ +final class NoiseEstimator { + + private static final int BINS = FFT_SIZE_BY_2_PLUS_1; + private static final int START_BAND = 5; + + /** Natural log of the bin index; the first five are unused. */ + private static final float[] LOG_TABLE = { + 0.f, 0.f, 0.f, 0.f, 0.f, 1.609438f, 1.791759f, + 1.945910f, 2.079442f, 2.197225f, 2.302585f, 2.397895f, 2.484907f, 2.564949f, + 2.639057f, 2.708050f, 2.772589f, 2.833213f, 2.890372f, 2.944439f, 2.995732f, + 3.044522f, 3.091043f, 3.135494f, 3.178054f, 3.218876f, 3.258097f, 3.295837f, + 3.332205f, 3.367296f, 3.401197f, 3.433987f, 3.465736f, 3.496507f, 3.526361f, + 3.555348f, 3.583519f, 3.610918f, 3.637586f, 3.663562f, 3.688879f, 3.713572f, + 3.737669f, 3.761200f, 3.784190f, 3.806663f, 3.828641f, 3.850147f, 3.871201f, + 3.891820f, 3.912023f, 3.931826f, 3.951244f, 3.970292f, 3.988984f, 4.007333f, + 4.025352f, 4.043051f, 4.060443f, 4.077538f, 4.094345f, 4.110874f, 4.127134f, + 4.143135f, 4.158883f, 4.174387f, 4.189655f, 4.204693f, 4.219508f, 4.234107f, + 4.248495f, 4.262680f, 4.276666f, 4.290460f, 4.304065f, 4.317488f, 4.330733f, + 4.343805f, 4.356709f, 4.369448f, 4.382027f, 4.394449f, 4.406719f, 4.418841f, + 4.430817f, 4.442651f, 4.454347f, 4.465908f, 4.477337f, 4.488636f, 4.499810f, + 4.510859f, 4.521789f, 4.532599f, 4.543295f, 4.553877f, 4.564348f, 4.574711f, + 4.584968f, 4.595119f, 4.605170f, 4.615121f, 4.624973f, 4.634729f, 4.644391f, + 4.653960f, 4.663439f, 4.672829f, 4.682131f, 4.691348f, 4.700480f, 4.709530f, + 4.718499f, 4.727388f, 4.736198f, 4.744932f, 4.753591f, 4.762174f, 4.770685f, + 4.779124f, 4.787492f, 4.795791f, 4.804021f, 4.812184f, 4.820282f, 4.828314f, + 4.836282f, 4.844187f, 4.852030f}; + + private final SuppressionLevel params; + private final QuantileNoiseEstimator quantileNoiseEstimator = new QuantileNoiseEstimator(); + + private float whiteNoiseLevel; + private float pinkNoiseNumerator; + private float pinkNoiseExp; + final float[] prevNoiseSpectrum = new float[BINS]; + final float[] conservativeNoiseSpectrum = new float[BINS]; + final float[] parametricNoiseSpectrum = new float[BINS]; + final float[] noiseSpectrum = new float[BINS]; + + NoiseEstimator(SuppressionLevel params) { + this.params = params; + } + + void prepareAnalysis() { + System.arraycopy(noiseSpectrum, 0, prevNoiseSpectrum, 0, BINS); + } + + /** First-stage estimate for this block, before the speech probability is known. */ + void preUpdate(int numAnalyzedFrames, float[] signalSpectrum, float signalSpectralSum) { + quantileNoiseEstimator.estimate(signalSpectrum, noiseSpectrum); + if (numAnalyzedFrames >= SHORT_STARTUP_PHASE_BLOCKS) return; + + // Fit white and pink noise models to the spectrum while the quantiles settle. + float sumLogILogMagn = 0.f; + float sumLogI = 0.f; + float sumLogISquare = 0.f; + float sumLogMagn = 0.f; + for (int i = START_BAND; i < BINS; i++) { + float logI = LOG_TABLE[i]; + sumLogI += logI; + sumLogISquare += logI * logI; + float logSignal = FastMath.log(signalSpectrum[i]); + sumLogMagn += logSignal; + sumLogILogMagn += logI * logSignal; + } + + final float oneByBins = 1.f / BINS; + whiteNoiseLevel += signalSpectralSum * oneByBins * params.overSubtractionFactor; + + float denom = sumLogISquare * (BINS - START_BAND) - sumLogI * sumLogI; + float num = sumLogISquare * sumLogMagn - sumLogI * sumLogILogMagn; + float pinkNoiseAdjustment = num / denom; + pinkNoiseAdjustment = Math.max(pinkNoiseAdjustment, 0.f); + pinkNoiseNumerator += pinkNoiseAdjustment; + num = sumLogI * sumLogMagn - (BINS - START_BAND) * sumLogILogMagn; + pinkNoiseAdjustment = num / denom; + pinkNoiseAdjustment = Math.max(Math.min(pinkNoiseAdjustment, 1.f), 0.f); + pinkNoiseExp += pinkNoiseAdjustment; + + final float oneByNumAnalyzedFramesPlus1 = 1.f / (numAnalyzedFrames + 1.f); + float parametricExp = 0.f; + float parametricNum = 0.f; + if (pinkNoiseExp > 0.f) { + parametricNum = FastMath.exp(pinkNoiseNumerator * oneByNumAnalyzedFramesPlus1); + parametricNum *= numAnalyzedFrames + 1.f; + parametricExp = pinkNoiseExp * oneByNumAnalyzedFramesPlus1; + } + + for (int i = 0; i < BINS; i++) { + if (pinkNoiseExp == 0.f) { + parametricNoiseSpectrum[i] = whiteNoiseLevel; + } else { + float useBand = i < START_BAND ? START_BAND : i; + parametricNoiseSpectrum[i] = parametricNum / FastMath.pow(useBand, parametricExp); + } + } + + final float oneByShortStartupPhaseBlocks = 1.f / SHORT_STARTUP_PHASE_BLOCKS; + for (int i = 0; i < BINS; i++) { + noiseSpectrum[i] *= numAnalyzedFrames; + float tmp = parametricNoiseSpectrum[i] * (SHORT_STARTUP_PHASE_BLOCKS - numAnalyzedFrames); + noiseSpectrum[i] += tmp * oneByNumAnalyzedFramesPlus1; + noiseSpectrum[i] *= oneByShortStartupPhaseBlocks; + } + } + + /** Refines the estimate, updating slowly where speech is likely. */ + void postUpdate(float[] speechProbability, float[] signalSpectrum) { + final float noiseUpdate = 0.9f; + final float probRange = .2f; + float gamma = noiseUpdate; + for (int i = 0; i < BINS; i++) { + final float probSpeech = speechProbability[i]; + final float probNonSpeech = 1.f - probSpeech; + + float noiseUpdateTmp = gamma * prevNoiseSpectrum[i] + + (1.f - gamma) * (probNonSpeech * signalSpectrum[i] + probSpeech * prevNoiseSpectrum[i]); + + float gammaOld = gamma; + gamma = probSpeech > probRange ? .99f : noiseUpdate; + + if (probSpeech < probRange) { + conservativeNoiseSpectrum[i] += 0.05f * (signalSpectrum[i] - conservativeNoiseSpectrum[i]); + } + + if (gamma == gammaOld) { + noiseSpectrum[i] = noiseUpdateTmp; + } else { + noiseSpectrum[i] = gamma * prevNoiseSpectrum[i] + + (1.f - gamma) * (probNonSpeech * signalSpectrum[i] + probSpeech * prevNoiseSpectrum[i]); + // A downward update is always safe. + noiseSpectrum[i] = Math.min(noiseSpectrum[i], noiseUpdateTmp); + } + } + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NoiseSuppressor.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NoiseSuppressor.java new file mode 100644 index 0000000..f782d26 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NoiseSuppressor.java @@ -0,0 +1,320 @@ +package com.ts3client.audio.processing.ns; + +import static com.ts3client.audio.processing.ns.NsCommon.FFT_SIZE; +import static com.ts3client.audio.processing.ns.NsCommon.FFT_SIZE_BY_2_PLUS_1; +import static com.ts3client.audio.processing.ns.NsCommon.NS_FRAME_SIZE; +import static com.ts3client.audio.processing.ns.NsCommon.OVERLAP_SIZE; + +import com.ts3client.audio.Fft; + +/** + * WebRTC's noise suppressor ({@code ns/noise_suppressor.cc}), the module behind TS3's + * "Remove background noise", for one channel. + * + *

It works on band-split audio in 10 ms frames, samples on the 16-bit scale: the + * lowest band (0–8 kHz at 16 kHz) is filtered per bin, and the upper bands, if + * any, are delayed to match and scaled by one gain derived from the top of the lowest band. + * As in APM, call {@link #analyze} and then {@link #process} on every frame. + */ +public final class NoiseSuppressor { + + private static final int BINS = FFT_SIZE_BY_2_PLUS_1; + + /** Rising half of the hybrid Hann/flat analysis and synthesis window. */ + private static final float[] BLOCKS_160W256_FIRST_HALF = { + 0.00000000f, 0.01636173f, 0.03271908f, 0.04906767f, 0.06540313f, + 0.08172107f, 0.09801714f, 0.11428696f, 0.13052619f, 0.14673047f, + 0.16289547f, 0.17901686f, 0.19509032f, 0.21111155f, 0.22707626f, + 0.24298018f, 0.25881905f, 0.27458862f, 0.29028468f, 0.30590302f, + 0.32143947f, 0.33688985f, 0.35225005f, 0.36751594f, 0.38268343f, + 0.39774847f, 0.41270703f, 0.42755509f, 0.44228869f, 0.45690388f, + 0.47139674f, 0.48576339f, 0.50000000f, 0.51410274f, 0.52806785f, + 0.54189158f, 0.55557023f, 0.56910015f, 0.58247770f, 0.59569930f, + 0.60876143f, 0.62166057f, 0.63439328f, 0.64695615f, 0.65934582f, + 0.67155895f, 0.68359230f, 0.69544264f, 0.70710678f, 0.71858162f, + 0.72986407f, 0.74095113f, 0.75183981f, 0.76252720f, 0.77301045f, + 0.78328675f, 0.79335334f, 0.80320753f, 0.81284668f, 0.82226822f, + 0.83146961f, 0.84044840f, 0.84920218f, 0.85772861f, 0.86602540f, + 0.87409034f, 0.88192126f, 0.88951608f, 0.89687274f, 0.90398929f, + 0.91086382f, 0.91749450f, 0.92387953f, 0.93001722f, 0.93590593f, + 0.94154407f, 0.94693013f, 0.95206268f, 0.95694034f, 0.96156180f, + 0.96592583f, 0.97003125f, 0.97387698f, 0.97746197f, 0.98078528f, + 0.98384601f, 0.98664333f, 0.98917651f, 0.99144486f, 0.99344778f, + 0.99518473f, 0.99665524f, 0.99785892f, 0.99879546f, 0.99946459f, + 0.99986614f}; + + private final int numBands; + private final SuppressionLevel params; + private int numAnalyzedFrames = -1; + + private final SpeechProbabilityEstimator speechProbabilityEstimator = new SpeechProbabilityEstimator(); + private final WienerFilter wienerFilter; + private final NoiseEstimator noiseEstimator; + private final float[] prevAnalysisSignalSpectrum = new float[BINS]; + private final float[] analyzeAnalysisMemory = new float[OVERLAP_SIZE]; + private final float[] processAnalysisMemory = new float[OVERLAP_SIZE]; + private final float[] processSynthesisMemory = new float[OVERLAP_SIZE]; + private final float[][] processDelayMemory; + + // Scratch. + private final float[] extendedFrame = new float[FFT_SIZE]; + private final float[] real = new float[FFT_SIZE]; + private final float[] imag = new float[FFT_SIZE]; + private final double[] fftRe = new double[FFT_SIZE]; + private final double[] fftIm = new double[FFT_SIZE]; + private final float[] signalSpectrum = new float[BINS]; + private final float[] priorSnr = new float[BINS]; + private final float[] postSnr = new float[BINS]; + private final float[] delayedFrame = new float[NS_FRAME_SIZE]; + + /** + * @param level how hard to cut + * @param numBands 1 for 16 kHz audio, 3 for 48 kHz split by the three-band filter bank + */ + public NoiseSuppressor(SuppressionLevel level, int numBands) { + this.params = level; + this.numBands = numBands; + this.wienerFilter = new WienerFilter(level); + this.noiseEstimator = new NoiseEstimator(level); + java.util.Arrays.fill(prevAnalysisSignalSpectrum, 1.f); + this.processDelayMemory = new float[Math.max(0, numBands - 1)][OVERLAP_SIZE]; + } + + public SuppressionLevel level() { + return params; + } + + /** Updates the noise and speech statistics from the lowest band of this frame. */ + public void analyze(float[] band0) { + noiseEstimator.prepareAnalysis(); + + // Leave the statistics alone on digital silence: learning from zeros would make any + // later signal look like speech and nothing would be suppressed for a long while. + if (energyOfExtendedFrame(band0, analyzeAnalysisMemory) <= 0.f) { + return; + } + + if (++numAnalyzedFrames < 0) { + numAnalyzedFrames = 0; + } + + formExtendedFrame(band0, analyzeAnalysisMemory, extendedFrame); + applyFilterBankWindow(extendedFrame); + fft(extendedFrame, real, imag); + computeMagnitudeSpectrum(real, imag, signalSpectrum); + + float signalEnergy = 0.f; + for (int i = 0; i < BINS; i++) { + signalEnergy += real[i] * real[i] + imag[i] * imag[i]; + } + signalEnergy /= BINS; + + float signalSpectralSum = 0.f; + for (int i = 0; i < BINS; i++) { + signalSpectralSum += signalSpectrum[i]; + } + + noiseEstimator.preUpdate(numAnalyzedFrames, signalSpectrum, signalSpectralSum); + computeSnr(wienerFilter.filter, prevAnalysisSignalSpectrum, signalSpectrum, + noiseEstimator.prevNoiseSpectrum, noiseEstimator.noiseSpectrum, priorSnr, postSnr); + speechProbabilityEstimator.update(numAnalyzedFrames, priorSnr, postSnr, + noiseEstimator.conservativeNoiseSpectrum, signalSpectrum, signalSpectralSum, signalEnergy); + noiseEstimator.postUpdate(speechProbabilityEstimator.speechProbability, signalSpectrum); + + System.arraycopy(signalSpectrum, 0, prevAnalysisSignalSpectrum, 0, BINS); + } + + /** + * Suppresses noise in place. {@code bands[0]} is the lowest band; any further bands are + * the upper ones. Each holds {@value NsCommon#NS_FRAME_SIZE} samples on the 16-bit scale. + */ + public void process(float[][] bands) { + float[] band0 = bands[0]; + formExtendedFrame(band0, processAnalysisMemory, extendedFrame); + applyFilterBankWindow(extendedFrame); + float energyBeforeFiltering = energyOfExtendedFrame(extendedFrame); + + fft(extendedFrame, real, imag); + computeMagnitudeSpectrum(real, imag, signalSpectrum); + + wienerFilter.update(numAnalyzedFrames, noiseEstimator.noiseSpectrum, noiseEstimator.prevNoiseSpectrum, + noiseEstimator.parametricNoiseSpectrum, signalSpectrum); + + float upperBandGain = 1.f; + if (numBands > 1) { + upperBandGain = computeUpperBandsGain(params.minimumAttenuatingGain, wienerFilter.filter, + speechProbabilityEstimator.speechProbability, prevAnalysisSignalSpectrum, signalSpectrum); + } + + float[] filter = wienerFilter.filter; + for (int i = 0; i < BINS; i++) { + real[i] *= filter[i]; + imag[i] *= filter[i]; + } + ifft(real, imag, extendedFrame); + + float energyAfterFiltering = energyOfExtendedFrame(extendedFrame); + applyFilterBankWindow(extendedFrame); + + float gainAdjustment = wienerFilter.computeOverallScalingFactor(numAnalyzedFrames, + speechProbabilityEstimator.priorSpeechProbability, energyBeforeFiltering, energyAfterFiltering); + for (int i = 0; i < FFT_SIZE; i++) { + extendedFrame[i] = gainAdjustment * extendedFrame[i]; + } + + overlapAndAdd(extendedFrame, processSynthesisMemory, band0); + + for (int b = 1; b < numBands; b++) { + // Delay the upper bands to line up with the lowest band's filter bank. + float[] band = bands[b]; + delaySignal(band, processDelayMemory[b - 1], delayedFrame); + for (int j = 0; j < NS_FRAME_SIZE; j++) { + band[j] = upperBandGain * delayedFrame[j]; + } + } + + for (int b = 0; b < numBands; b++) { + float[] band = bands[b]; + for (int j = 0; j < NS_FRAME_SIZE; j++) { + band[j] = Math.min(Math.max(band[j], -32768.f), 32767.f); + } + } + } + + private static void applyFilterBankWindow(float[] x) { + for (int i = 0; i < 96; i++) { + x[i] = BLOCKS_160W256_FIRST_HALF[i] * x[i]; + } + for (int i = 161, k = 95; i < FFT_SIZE; i++, k--) { + x[i] = BLOCKS_160W256_FIRST_HALF[k] * x[i]; + } + } + + /** Prepends the kept tail of the previous frames, and keeps this frame's tail. */ + private static void formExtendedFrame(float[] frame, float[] oldData, float[] extended) { + System.arraycopy(oldData, 0, extended, 0, OVERLAP_SIZE); + System.arraycopy(frame, 0, extended, OVERLAP_SIZE, NS_FRAME_SIZE); + System.arraycopy(extended, FFT_SIZE - OVERLAP_SIZE, oldData, 0, OVERLAP_SIZE); + } + + private static void overlapAndAdd(float[] extended, float[] overlapMemory, float[] output) { + for (int i = 0; i < OVERLAP_SIZE; i++) { + output[i] = overlapMemory[i] + extended[i]; + } + System.arraycopy(extended, OVERLAP_SIZE, output, OVERLAP_SIZE, NS_FRAME_SIZE - OVERLAP_SIZE); + System.arraycopy(extended, NS_FRAME_SIZE, overlapMemory, 0, OVERLAP_SIZE); + } + + private static void delaySignal(float[] frame, float[] delayBuffer, float[] delayed) { + final int samplesFromFrame = NS_FRAME_SIZE - OVERLAP_SIZE; + System.arraycopy(delayBuffer, 0, delayed, 0, OVERLAP_SIZE); + System.arraycopy(frame, 0, delayed, OVERLAP_SIZE, samplesFromFrame); + System.arraycopy(frame, samplesFromFrame, delayBuffer, 0, OVERLAP_SIZE); + } + + private static float energyOfExtendedFrame(float[] x) { + float energy = 0.f; + for (float v : x) { + energy += v * v; + } + return energy; + } + + private static float energyOfExtendedFrame(float[] frame, float[] oldData) { + float energy = 0.f; + for (float v : oldData) { + energy += v * v; + } + for (int i = 0; i < NS_FRAME_SIZE; i++) { + energy += frame[i] * frame[i]; + } + return energy; + } + + private static void computeMagnitudeSpectrum(float[] real, float[] imag, float[] spectrum) { + spectrum[0] = Math.abs(real[0]) + 1.f; + spectrum[BINS - 1] = Math.abs(real[BINS - 1]) + 1.f; + for (int i = 1; i < BINS - 1; i++) { + spectrum[i] = FastMath.sqrt(real[i] * real[i] + imag[i] * imag[i]) + 1.f; + } + } + + private static void computeSnr(float[] filter, float[] prevSignalSpectrum, float[] signalSpectrum, + float[] prevNoiseSpectrum, float[] noiseSpectrum, + float[] priorSnr, float[] postSnr) { + for (int i = 0; i < BINS; i++) { + float prevEstimate = prevSignalSpectrum[i] / (prevNoiseSpectrum[i] + 0.0001f) * filter[i]; + if (signalSpectrum[i] > noiseSpectrum[i]) { + postSnr[i] = signalSpectrum[i] / (noiseSpectrum[i] + 0.0001f) - 1.f; + } else { + postSnr[i] = 0.f; + } + // Decision-directed estimate of the prior SNR. + priorSnr[i] = 0.98f * prevEstimate + (1.f - 0.98f) * postSnr[i]; + } + } + + /** One gain for the upper bands, from speech probability and gain at the top of band 0. */ + private static float computeUpperBandsGain(float minimumAttenuatingGain, float[] filter, + float[] speechProbability, + float[] prevAnalysisSignalSpectrum, float[] signalSpectrum) { + final int numAvgBins = 32; + final float oneByNumAvgBins = 1.f / numAvgBins; + float avgProbSpeech = 0.f; + float avgFilterGain = 0.f; + for (int i = BINS - numAvgBins - 1; i < BINS - 1; i++) { + avgProbSpeech += speechProbability[i]; + avgFilterGain += filter[i]; + } + avgProbSpeech = avgProbSpeech * oneByNumAvgBins; + avgFilterGain = avgFilterGain * oneByNumAvgBins; + + // Speech removed between analysis and processing (by an AEC) should not count. + float sumAnalysisSpectrum = 0.f; + float sumProcessingSpectrum = 0.f; + for (int i = 0; i < BINS; i++) { + sumAnalysisSpectrum += prevAnalysisSignalSpectrum[i]; + sumProcessingSpectrum += signalSpectrum[i]; + } + avgProbSpeech *= sumProcessingSpectrum / sumAnalysisSpectrum; + + float gain = 0.5f * (1.f + (float) Math.tanh(2.f * avgProbSpeech - 1.f)); + if (avgProbSpeech >= 0.5f) { + gain = 0.25f * gain + 0.75f * avgFilterGain; + } else { + gain = 0.5f * gain + 0.5f * avgFilterGain; + } + return Math.min(Math.max(gain, minimumAttenuatingGain), 1.f); + } + + private void fft(float[] timeData, float[] re, float[] im) { + for (int i = 0; i < FFT_SIZE; i++) { + fftRe[i] = timeData[i]; + fftIm[i] = 0; + } + Fft.forward(fftRe, fftIm); + for (int i = 0; i < BINS; i++) { + re[i] = (float) fftRe[i]; + im[i] = (float) fftIm[i]; + } + im[0] = 0; + im[BINS - 1] = 0; + } + + private void ifft(float[] re, float[] im, float[] timeData) { + fftRe[0] = re[0]; + fftIm[0] = 0; + fftRe[BINS - 1] = re[BINS - 1]; + fftIm[BINS - 1] = 0; + for (int i = 1; i < BINS - 1; i++) { + fftRe[i] = re[i]; + fftIm[i] = im[i]; + fftRe[FFT_SIZE - i] = re[i]; + fftIm[FFT_SIZE - i] = -im[i]; + } + Fft.inverse(fftRe, fftIm); + for (int i = 0; i < FFT_SIZE; i++) { + timeData[i] = (float) fftRe[i]; + } + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NsCommon.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NsCommon.java new file mode 100644 index 0000000..596eefe --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/NsCommon.java @@ -0,0 +1,29 @@ +package com.ts3client.audio.processing.ns; + +/** + * Sizes and constants of WebRTC's noise suppressor, mirroring {@code ns/ns_common.h}. + * + *

The suppressor works on the lowest 0–8 kHz band at 16 kHz: 10 ms + * frames of 160 samples, analysed with a 256-point FFT over a 96-sample overlap. + */ +final class NsCommon { + + static final int FFT_SIZE = 256; + static final int FFT_SIZE_BY_2_PLUS_1 = FFT_SIZE / 2 + 1; + static final int NS_FRAME_SIZE = 160; + static final int OVERLAP_SIZE = FFT_SIZE - NS_FRAME_SIZE; + + static final int SHORT_STARTUP_PHASE_BLOCKS = 50; + static final int LONG_STARTUP_PHASE_BLOCKS = 200; + static final int FEATURE_UPDATE_WINDOW_SIZE = 500; + + static final float LTR_FEATURE_THR = 0.5f; + static final float BIN_SIZE_LRT = 0.1f; + static final float BIN_SIZE_SPEC_FLAT = 0.05f; + static final float BIN_SIZE_SPEC_DIFF = 0.1f; + + static final int HISTOGRAM_SIZE = 1000; + + private NsCommon() { + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/QuantileNoiseEstimator.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/QuantileNoiseEstimator.java new file mode 100644 index 0000000..ade8ca3 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/QuantileNoiseEstimator.java @@ -0,0 +1,79 @@ +package com.ts3client.audio.processing.ns; + +import static com.ts3client.audio.processing.ns.NsCommon.FFT_SIZE_BY_2_PLUS_1; +import static com.ts3client.audio.processing.ns.NsCommon.LONG_STARTUP_PHASE_BLOCKS; + +import java.util.Arrays; + +/** + * Tracks a low quantile of each bin's log spectrum as the noise floor, from + * {@code ns/quantile_noise_estimator.cc}. Three estimates run staggered so that one of + * them completes a 200-block window every 67 blocks. + */ +final class QuantileNoiseEstimator { + + private static final int SIMULT = 3; + private static final int BINS = FFT_SIZE_BY_2_PLUS_1; + + private final float[] density = new float[SIMULT * BINS]; + private final float[] logQuantile = new float[SIMULT * BINS]; + private final float[] quantile = new float[BINS]; + private final int[] counter = new int[SIMULT]; + private int numUpdates = 1; + + private final float[] logSpectrum = new float[BINS]; + + QuantileNoiseEstimator() { + Arrays.fill(density, 0.3f); + Arrays.fill(logQuantile, 8.f); + final float oneBySimult = 1.f / SIMULT; + for (int i = 0; i < SIMULT; i++) { + counter[i] = (int) Math.floor(LONG_STARTUP_PHASE_BLOCKS * (i + 1.f) * oneBySimult); + } + } + + void estimate(float[] signalSpectrum, float[] noiseSpectrum) { + FastMath.log(signalSpectrum, logSpectrum); + + int quantileIndexToReturn = -1; + for (int s = 0, k = 0; s < SIMULT; s++, k += BINS) { + final float oneByCounterPlus1 = 1.f / (counter[s] + 1.f); + for (int i = 0, j = k; i < BINS; i++, j++) { + final float delta = density[j] > 1.f ? 40.f / density[j] : 40.f; + final float multiplier = delta * oneByCounterPlus1; + if (logSpectrum[i] > logQuantile[j]) { + logQuantile[j] += 0.25f * multiplier; + } else { + logQuantile[j] -= 0.75f * multiplier; + } + + final float width = 0.01f; + final float oneByWidthPlus2 = 1.f / (2.f * width); + if (Math.abs(logSpectrum[i] - logQuantile[j]) < width) { + density[j] = (counter[s] * density[j] + oneByWidthPlus2) * oneByCounterPlus1; + } + } + + if (counter[s] >= LONG_STARTUP_PHASE_BLOCKS) { + counter[s] = 0; + if (numUpdates >= LONG_STARTUP_PHASE_BLOCKS) { + quantileIndexToReturn = k; + } + } + counter[s]++; + } + + // During startup, follow the last estimate so the noise is non-zero from the start. + if (numUpdates < LONG_STARTUP_PHASE_BLOCKS) { + quantileIndexToReturn = BINS * (SIMULT - 1); + numUpdates++; + } + + if (quantileIndexToReturn >= 0) { + for (int i = 0; i < BINS; i++) { + quantile[i] = FastMath.exp(logQuantile[quantileIndexToReturn + i]); + } + } + System.arraycopy(quantile, 0, noiseSpectrum, 0, BINS); + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SignalModelEstimator.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SignalModelEstimator.java new file mode 100644 index 0000000..e5fdfa2 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SignalModelEstimator.java @@ -0,0 +1,255 @@ +package com.ts3client.audio.processing.ns; + +import static com.ts3client.audio.processing.ns.NsCommon.BIN_SIZE_LRT; +import static com.ts3client.audio.processing.ns.NsCommon.BIN_SIZE_SPEC_DIFF; +import static com.ts3client.audio.processing.ns.NsCommon.BIN_SIZE_SPEC_FLAT; +import static com.ts3client.audio.processing.ns.NsCommon.FEATURE_UPDATE_WINDOW_SIZE; +import static com.ts3client.audio.processing.ns.NsCommon.FFT_SIZE_BY_2_PLUS_1; +import static com.ts3client.audio.processing.ns.NsCommon.HISTOGRAM_SIZE; +import static com.ts3client.audio.processing.ns.NsCommon.LTR_FEATURE_THR; + +import java.util.Arrays; + +/** + * The three speech features the suppressor weighs (likelihood ratio, spectral flatness and + * difference from the noise template) and the prior model that decides how to weigh them, + * re-fitted from feature histograms every 500 blocks. Ports {@code signal_model_estimator.cc}, + * {@code prior_signal_model_estimator.cc}, {@code histograms.cc} and the two model structs. + */ +final class SignalModelEstimator { + + private static final int BINS = FFT_SIZE_BY_2_PLUS_1; + private static final float ONE_BY_BINS = 1.f / BINS; + + // SignalModel. + float lrt = LTR_FEATURE_THR; + float spectralFlatness = 0.5f; + float spectralDiff = 0.5f; + final float[] avgLogLrt = new float[BINS]; + + // PriorSignalModel. + float priorLrt = LTR_FEATURE_THR; + float flatnessThreshold = .5f; + float templateDiffThreshold = .5f; + float lrtWeighting = 1.f; + float flatnessWeighting = 0.f; + float differenceWeighting = 0.f; + + private final int[] lrtHistogram = new int[HISTOGRAM_SIZE]; + private final int[] flatnessHistogram = new int[HISTOGRAM_SIZE]; + private final int[] diffHistogram = new int[HISTOGRAM_SIZE]; + + private float diffNormalization; + private float signalEnergySum; + private int histogramAnalysisCounter = 500; + + SignalModelEstimator() { + Arrays.fill(avgLogLrt, LTR_FEATURE_THR); + } + + void adjustNormalization(int numAnalyzedFrames, float signalEnergy) { + diffNormalization *= numAnalyzedFrames; + diffNormalization += signalEnergy; + diffNormalization /= (numAnalyzedFrames + 1); + } + + void update(float[] priorSnr, float[] postSnr, float[] conservativeNoiseSpectrum, + float[] signalSpectrum, float signalSpectralSum, float signalEnergy) { + updateSpectralFlatness(signalSpectrum, signalSpectralSum); + + float diff = computeSpectralDiff(conservativeNoiseSpectrum, signalSpectrum, signalSpectralSum); + spectralDiff += 0.3f * (diff - spectralDiff); + + signalEnergySum += signalEnergy; + + if (--histogramAnalysisCounter > 0) { + updateHistograms(); + } else { + updatePriorModel(); + Arrays.fill(lrtHistogram, 0); + Arrays.fill(flatnessHistogram, 0); + Arrays.fill(diffHistogram, 0); + histogramAnalysisCounter = FEATURE_UPDATE_WINDOW_SIZE; + + signalEnergySum = signalEnergySum / FEATURE_UPDATE_WINDOW_SIZE; + diffNormalization = 0.5f * (signalEnergySum + diffNormalization); + signalEnergySum = 0.f; + } + + updateSpectralLrt(priorSnr, postSnr); + } + + private float computeSpectralDiff(float[] conservativeNoiseSpectrum, float[] signalSpectrum, + float signalSpectralSum) { + float noiseAverage = 0.f; + for (int i = 0; i < BINS; i++) { + noiseAverage += conservativeNoiseSpectrum[i]; + } + noiseAverage = noiseAverage * ONE_BY_BINS; + float signalAverage = signalSpectralSum * ONE_BY_BINS; + + float covariance = 0.f; + float noiseVariance = 0.f; + float signalVariance = 0.f; + for (int i = 0; i < BINS; i++) { + float signalDiff = signalSpectrum[i] - signalAverage; + float noiseDiff = conservativeNoiseSpectrum[i] - noiseAverage; + covariance += signalDiff * noiseDiff; + noiseVariance += noiseDiff * noiseDiff; + signalVariance += signalDiff * signalDiff; + } + covariance *= ONE_BY_BINS; + noiseVariance *= ONE_BY_BINS; + signalVariance *= ONE_BY_BINS; + + float diff = signalVariance - (covariance * covariance) / (noiseVariance + 0.0001f); + return diff / (diffNormalization + 0.0001f); + } + + private void updateSpectralFlatness(float[] signalSpectrum, float signalSpectralSum) { + final float averaging = 0.3f; + for (int i = 1; i < BINS; i++) { + if (signalSpectrum[i] == 0.f) { + spectralFlatness -= averaging * spectralFlatness; + return; + } + } + float num = 0.f; + for (int i = 1; i < BINS; i++) { + num += FastMath.log(signalSpectrum[i]); + } + float denom = signalSpectralSum - signalSpectrum[0]; + denom = denom * ONE_BY_BINS; + num = num * ONE_BY_BINS; + float tmp = FastMath.exp(num) / denom; + spectralFlatness += averaging * (tmp - spectralFlatness); + } + + private void updateSpectralLrt(float[] priorSnr, float[] postSnr) { + for (int i = 0; i < BINS; i++) { + float tmp1 = 1.f + 2.f * priorSnr[i]; + float tmp2 = 2.f * priorSnr[i] / (tmp1 + 0.0001f); + float besselTmp = (postSnr[i] + 1.f) * tmp2; + avgLogLrt[i] += .5f * (besselTmp - FastMath.log(tmp1) - avgLogLrt[i]); + } + float sum = 0.f; + for (int i = 0; i < BINS; i++) { + sum += avgLogLrt[i]; + } + lrt = sum * ONE_BY_BINS; + } + + private void updateHistograms() { + final float oneByBinSizeLrt = 1.f / BIN_SIZE_LRT; + if (lrt < HISTOGRAM_SIZE * BIN_SIZE_LRT && lrt >= 0.f) { + lrtHistogram[(int) (oneByBinSizeLrt * lrt)]++; + } + final float oneByBinSizeSpecFlat = 1.f / BIN_SIZE_SPEC_FLAT; + if (spectralFlatness < HISTOGRAM_SIZE * BIN_SIZE_SPEC_FLAT && spectralFlatness >= 0.f) { + flatnessHistogram[(int) (spectralFlatness * oneByBinSizeSpecFlat)]++; + } + final float oneByBinSizeSpecDiff = 1.f / BIN_SIZE_SPEC_DIFF; + if (spectralDiff < HISTOGRAM_SIZE * BIN_SIZE_SPEC_DIFF && spectralDiff >= 0.f) { + diffHistogram[(int) (spectralDiff * oneByBinSizeSpecDiff)]++; + } + } + + private void updatePriorModel() { + boolean lowLrtFluctuations = updatePriorLrt(); + + float[] flat = firstOfTwoLargestPeaks(BIN_SIZE_SPEC_FLAT, flatnessHistogram); + float flatPeakPosition = flat[0]; + int flatPeakWeight = (int) flat[1]; + float[] diff = firstOfTwoLargestPeaks(BIN_SIZE_SPEC_DIFF, diffHistogram); + float diffPeakPosition = diff[0]; + int diffPeakWeight = (int) diff[1]; + + // Only use the features whose histograms show a clear peak. + final int useSpecFlat = flatPeakWeight < 0.3f * 500 || flatPeakPosition < 0.6f ? 0 : 1; + final int useSpecDiff = diffPeakWeight < 0.3f * 500 || lowLrtFluctuations ? 0 : 1; + + templateDiffThreshold = 1.2f * diffPeakPosition; + templateDiffThreshold = Math.min(1.f, Math.max(0.16f, templateDiffThreshold)); + + float oneByFeatureSum = 1.f / (1.f + useSpecFlat + useSpecDiff); + lrtWeighting = oneByFeatureSum; + + if (useSpecFlat == 1) { + flatnessThreshold = 0.9f * flatPeakPosition; + flatnessThreshold = Math.min(.95f, Math.max(0.1f, flatnessThreshold)); + flatnessWeighting = oneByFeatureSum; + } else { + flatnessWeighting = 0.f; + } + + differenceWeighting = useSpecDiff == 1 ? oneByFeatureSum : 0.f; + } + + /** Re-fits the prior LRT; returns whether the LRT barely fluctuates. */ + private boolean updatePriorLrt() { + float average = 0.f; + float averageCompl = 0.f; + float averageSquared = 0.f; + int count = 0; + for (int i = 0; i < 10; i++) { + float binMid = (i + 0.5f) * BIN_SIZE_LRT; + average += lrtHistogram[i] * binMid; + count += lrtHistogram[i]; + } + if (count > 0) { + average = average / count; + } + for (int i = 0; i < HISTOGRAM_SIZE; i++) { + float binMid = (i + 0.5f) * BIN_SIZE_LRT; + averageSquared += lrtHistogram[i] * binMid * binMid; + averageCompl += lrtHistogram[i] * binMid; + } + final float oneByWindow = 1.f / FEATURE_UPDATE_WINDOW_SIZE; + averageSquared = averageSquared * oneByWindow; + averageCompl = averageCompl * oneByWindow; + + boolean lowLrtFluctuations = averageSquared - average * averageCompl < 0.05f; + final float maxLrt = 1.f; + final float minLrt = .2f; + if (lowLrtFluctuations) { + priorLrt = maxLrt; + } else { + priorLrt = Math.min(maxLrt, Math.max(minLrt, 1.2f * average)); + } + return lowLrtFluctuations; + } + + /** Returns {position, weight} of the larger peak, merged with the runner-up when adjacent. */ + private static float[] firstOfTwoLargestPeaks(float binSize, int[] histogram) { + int peakValue = 0; + int secondaryPeakValue = 0; + float peakPosition = 0.f; + float secondaryPeakPosition = 0.f; + int peakWeight = 0; + int secondaryPeakWeight = 0; + + for (int i = 0; i < HISTOGRAM_SIZE; i++) { + final float binMid = (i + 0.5f) * binSize; + if (histogram[i] > peakValue) { + secondaryPeakValue = peakValue; + secondaryPeakWeight = peakWeight; + secondaryPeakPosition = peakPosition; + + peakValue = histogram[i]; + peakWeight = histogram[i]; + peakPosition = binMid; + } else if (histogram[i] > secondaryPeakValue) { + secondaryPeakValue = histogram[i]; + secondaryPeakWeight = histogram[i]; + secondaryPeakPosition = binMid; + } + } + + if (Math.abs(secondaryPeakPosition - peakPosition) < 2 * binSize + && secondaryPeakWeight > 0.5f * peakWeight) { + peakWeight += secondaryPeakWeight; + peakPosition = 0.5f * (peakPosition + secondaryPeakPosition); + } + return new float[]{peakPosition, peakWeight}; + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SpeechProbabilityEstimator.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SpeechProbabilityEstimator.java new file mode 100644 index 0000000..79d24a1 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SpeechProbabilityEstimator.java @@ -0,0 +1,53 @@ +package com.ts3client.audio.processing.ns; + +import static com.ts3client.audio.processing.ns.NsCommon.FFT_SIZE_BY_2_PLUS_1; +import static com.ts3client.audio.processing.ns.NsCommon.LONG_STARTUP_PHASE_BLOCKS; + +/** + * Per-bin speech presence probability, from {@code ns/speech_probability_estimator.cc}: the + * features are mapped through sigmoids around the prior model's thresholds into a prior + * speech probability, which is then combined with each bin's likelihood ratio. + */ +final class SpeechProbabilityEstimator { + + private static final int BINS = FFT_SIZE_BY_2_PLUS_1; + private static final float WIDTH_PRIOR_0 = 4.f; + private static final float WIDTH_PRIOR_1 = 2.f * WIDTH_PRIOR_0; + + private final SignalModelEstimator model = new SignalModelEstimator(); + float priorSpeechProbability = .5f; + final float[] speechProbability = new float[BINS]; + + void update(int numAnalyzedFrames, float[] priorSnr, float[] postSnr, float[] conservativeNoiseSpectrum, + float[] signalSpectrum, float signalSpectralSum, float signalEnergy) { + if (numAnalyzedFrames < LONG_STARTUP_PHASE_BLOCKS) { + model.adjustNormalization(numAnalyzedFrames, signalEnergy); + } + model.update(priorSnr, postSnr, conservativeNoiseSpectrum, signalSpectrum, signalSpectralSum, + signalEnergy); + + float widthPrior = model.lrt < model.priorLrt ? WIDTH_PRIOR_1 : WIDTH_PRIOR_0; + float indicator0 = 0.5f * ((float) Math.tanh(widthPrior * (model.lrt - model.priorLrt)) + 1.f); + + widthPrior = model.spectralFlatness > model.flatnessThreshold ? WIDTH_PRIOR_1 : WIDTH_PRIOR_0; + float indicator1 = 0.5f * ((float) Math.tanh( + 1.f * widthPrior * (model.flatnessThreshold - model.spectralFlatness)) + 1.f); + + widthPrior = model.spectralDiff < model.templateDiffThreshold ? WIDTH_PRIOR_1 : WIDTH_PRIOR_0; + float indicator2 = 0.5f * ((float) Math.tanh( + widthPrior * (model.spectralDiff - model.templateDiffThreshold)) + 1.f); + + float indPrior = model.lrtWeighting * indicator0 + + model.flatnessWeighting * indicator1 + + model.differenceWeighting * indicator2; + + priorSpeechProbability += 0.1f * (indPrior - priorSpeechProbability); + priorSpeechProbability = Math.max(Math.min(priorSpeechProbability, 1.f), 0.01f); + + float gainPrior = (1.f - priorSpeechProbability) / (priorSpeechProbability + 0.0001f); + for (int i = 0; i < BINS; i++) { + float invLrt = FastMath.exp(-model.avgLogLrt[i]); + speechProbability[i] = 1.f / (1.f + gainPrior * invLrt); + } + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SuppressionLevel.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SuppressionLevel.java new file mode 100644 index 0000000..d0865f6 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/SuppressionLevel.java @@ -0,0 +1,30 @@ +package com.ts3client.audio.processing.ns; + +/** + * How hard the noise suppressor cuts, from {@code ns/suppression_params.cc}. TS3's + * {@code denoiser_level} slider (0–3) picks one of these directly, in this order. + */ +public enum SuppressionLevel { + + DB_6(1.f, 0.5f, false), + DB_12(1.f, 0.25f, true), + DB_18(1.1f, 0.125f, true), + DB_21(1.25f, 0.09f, true); + + final float overSubtractionFactor; + final float minimumAttenuatingGain; + final boolean useAttenuationAdjustment; + + SuppressionLevel(float overSubtractionFactor, float minimumAttenuatingGain, + boolean useAttenuationAdjustment) { + this.overSubtractionFactor = overSubtractionFactor; + this.minimumAttenuatingGain = minimumAttenuatingGain; + this.useAttenuationAdjustment = useAttenuationAdjustment; + } + + /** TS3's {@code denoiser_level}: 0 is 6 dB, 3 is 21 dB; out of range is clamped. */ + public static SuppressionLevel fromDenoiserLevel(int level) { + SuppressionLevel[] all = values(); + return all[Math.max(0, Math.min(all.length - 1, level))]; + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/WienerFilter.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/WienerFilter.java new file mode 100644 index 0000000..ef14b1e --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/ns/WienerFilter.java @@ -0,0 +1,93 @@ +package com.ts3client.audio.processing.ns; + +import static com.ts3client.audio.processing.ns.NsCommon.FFT_SIZE_BY_2_PLUS_1; +import static com.ts3client.audio.processing.ns.NsCommon.LONG_STARTUP_PHASE_BLOCKS; +import static com.ts3client.audio.processing.ns.NsCommon.SHORT_STARTUP_PHASE_BLOCKS; + +import java.util.Arrays; + +/** + * The per-bin suppression gain, from {@code ns/wiener_filter.cc}: a Wiener filter on the + * decision-directed prior SNR, floored at the level's minimum gain, plus the overall + * adjustment that eases the cut when it removed a lot of a likely-speech frame. + */ +final class WienerFilter { + + private static final int BINS = FFT_SIZE_BY_2_PLUS_1; + + private final SuppressionLevel params; + private final float[] spectrumPrevProcess = new float[BINS]; + private final float[] initialSpectralEstimate = new float[BINS]; + final float[] filter = new float[BINS]; + + WienerFilter(SuppressionLevel params) { + this.params = params; + Arrays.fill(filter, 1.f); + } + + void update(int numAnalyzedFrames, float[] noiseSpectrum, float[] prevNoiseSpectrum, + float[] parametricNoiseSpectrum, float[] signalSpectrum) { + for (int i = 0; i < BINS; i++) { + // Previous estimate based on the previous frame with the gain filter. + float prevTsa = spectrumPrevProcess[i] / (prevNoiseSpectrum[i] + 0.0001f) * filter[i]; + + float currentTsa; + if (signalSpectrum[i] > noiseSpectrum[i]) { + currentTsa = signalSpectrum[i] / (noiseSpectrum[i] + 0.0001f) - 1.f; + } else { + currentTsa = 0.f; + } + + float snrPrior = 0.98f * prevTsa + (1.f - 0.98f) * currentTsa; + filter[i] = snrPrior / (params.overSubtractionFactor + snrPrior); + filter[i] = Math.max(Math.min(filter[i], 1.f), params.minimumAttenuatingGain); + } + + if (numAnalyzedFrames < SHORT_STARTUP_PHASE_BLOCKS) { + // Blend in the parametric noise model while the estimates settle. + final float oneByShortStartupPhaseBlocks = 1.f / SHORT_STARTUP_PHASE_BLOCKS; + for (int i = 0; i < BINS; i++) { + initialSpectralEstimate[i] += signalSpectrum[i]; + float filterInitial = initialSpectralEstimate[i] + - params.overSubtractionFactor * parametricNoiseSpectrum[i]; + filterInitial /= initialSpectralEstimate[i] + 0.0001f; + filterInitial = Math.max(Math.min(filterInitial, 1.f), params.minimumAttenuatingGain); + + filterInitial *= SHORT_STARTUP_PHASE_BLOCKS - numAnalyzedFrames; + filter[i] *= numAnalyzedFrames; + filter[i] += filterInitial; + filter[i] *= oneByShortStartupPhaseBlocks; + } + } + + System.arraycopy(signalSpectrum, 0, spectrumPrevProcess, 0, BINS); + } + + float computeOverallScalingFactor(int numAnalyzedFrames, float priorSpeechProbability, + float energyBeforeFiltering, float energyAfterFiltering) { + if (!params.useAttenuationAdjustment || numAnalyzedFrames <= LONG_STARTUP_PHASE_BLOCKS) { + return 1.f; + } + + float gain = FastMath.sqrt(energyAfterFiltering / (energyBeforeFiltering + 1.f)); + + final float bLim = 0.5f; + float scaleFactor1 = 1.f; + if (gain > bLim) { + scaleFactor1 = 1.f + 1.3f * (gain - bLim); + if (gain * scaleFactor1 > 1.f) { + scaleFactor1 = 1.f / gain; + } + } + + float scaleFactor2 = 1.f; + if (gain < bLim) { + // Do not reduce the scale too much for pause regions: attenuation is already + // controlled by the gain floor. + gain = Math.max(gain, params.minimumAttenuatingGain); + scaleFactor2 = 1.f - 0.3f * (bLim - gain); + } + + return priorSpeechProbability * scaleFactor1 + (1.f - priorSpeechProbability) * scaleFactor2; + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/TransientDetector.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/TransientDetector.java new file mode 100644 index 0000000..2ace2c5 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/TransientDetector.java @@ -0,0 +1,125 @@ +package com.ts3client.audio.processing.transients; + +import java.util.ArrayDeque; + +/** + * Scores how likely a 10 ms chunk holds a transient such as a key click, from + * {@code transient/transient_detector.cc}. Each wavelet sub-band sample is compared against + * the moving mean and variance of the preceding 30 ms; the summed normalised deviation + * maps through a raised cosine to [0, 1], and the result is the maximum over the last three + * chunks so a click's tail stays covered. + */ +final class TransientDetector { + + private static final int CHUNK_MS = 10; + private static final int TRANSIENT_LENGTH_MS = 30; + private static final int CHUNKS_AT_STARTUP_LEFT_TO_DELETE = TRANSIENT_LENGTH_MS / CHUNK_MS; + private static final float DETECT_THRESHOLD = 16.f; + private static final float PI = 3.14159265358979323846f; + + private final int samplesPerChunk; + private final int leafLength; + private final WaveletPacketTree tree; + private final MovingMoments[] movingMoments = new MovingMoments[WaveletPacketTree.LEAVES]; + private final float[] firstMoments; + private final float[] secondMoments; + private final float[] lastFirstMoment = new float[WaveletPacketTree.LEAVES]; + private final float[] lastSecondMoment = new float[WaveletPacketTree.LEAVES]; + private final ArrayDeque previousResults = new ArrayDeque<>(); + private int chunksAtStartupLeftToDelete = CHUNKS_AT_STARTUP_LEFT_TO_DELETE; + + TransientDetector(int sampleRateHz) { + int perChunk = sampleRateHz * CHUNK_MS / 1000; + int perTransient = sampleRateHz * TRANSIENT_LENGTH_MS / 1000; + perChunk -= perChunk % WaveletPacketTree.LEAVES; + perTransient -= perTransient % WaveletPacketTree.LEAVES; + this.samplesPerChunk = perChunk; + this.tree = new WaveletPacketTree(perChunk); + this.leafLength = tree.leafLength(); + for (int i = 0; i < WaveletPacketTree.LEAVES; i++) { + movingMoments[i] = new MovingMoments(perTransient / WaveletPacketTree.LEAVES); + } + this.firstMoments = new float[leafLength]; + this.secondMoments = new float[leafLength]; + for (int i = 0; i < CHUNKS_AT_STARTUP_LEFT_TO_DELETE; i++) { + previousResults.add(0.f); + } + } + + int samplesPerChunk() { + return samplesPerChunk; + } + + /** Returns a detection score in [0, 1] for the chunk at {@code data[offset..]}. */ + float detect(float[] data, int offset) { + tree.update(data, offset); + + float result = 0.f; + for (int i = 0; i < WaveletPacketTree.LEAVES; i++) { + float[] leaf = tree.leaf(i); + movingMoments[i].calculateMoments(leaf, leafLength, firstMoments, secondMoments); + + // Each sample is judged against the moments of the samples before it. + float unbiased = leaf[0] - lastFirstMoment[i]; + result += unbiased * unbiased / (lastSecondMoment[i] + Float.MIN_NORMAL); + for (int j = 1; j < leafLength; j++) { + unbiased = leaf[j] - firstMoments[j - 1]; + result += unbiased * unbiased / (secondMoments[j - 1] + Float.MIN_NORMAL); + } + + lastFirstMoment[i] = firstMoments[leafLength - 1]; + lastSecondMoment[i] = secondMoments[leafLength - 1]; + } + result /= leafLength; + + // The moments need a full transient length of history before they mean anything. + if (chunksAtStartupLeftToDelete > 0) { + chunksAtStartupLeftToDelete--; + result = 0.f; + } + + if (result >= DETECT_THRESHOLD) { + result = 1.f; + } else { + // Raised cosine from 0 to 1 over [0, threshold), squared. + final float horizontalScaling = PI / DETECT_THRESHOLD; + result = ((float) Math.cos(result * horizontalScaling + PI) + 1.f) * 0.5f; + result *= result; + } + + previousResults.pollFirst(); + previousResults.addLast(result); + float max = 0.f; + for (float r : previousResults) { + max = Math.max(max, r); + } + return max; + } + + /** Running mean and mean square over a fixed window, from {@code moving_moments.cc}. */ + private static final class MovingMoments { + private final int length; + private final float[] queue; + private int head; + private float sum; + private float sumOfSquares; + + MovingMoments(int length) { + this.length = length; + this.queue = new float[length]; + } + + void calculateMoments(float[] in, int n, float[] first, float[] second) { + for (int i = 0; i < n; i++) { + final float oldValue = queue[head]; + queue[head] = in[i]; + head = (head + 1) % length; + + sum += in[i] - oldValue; + sumOfSquares += in[i] * in[i] - oldValue * oldValue; + first[i] = sum / length; + second[i] = Math.max(0.f, sumOfSquares / length); + } + } + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/TransientSuppressor.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/TransientSuppressor.java new file mode 100644 index 0000000..3260391 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/TransientSuppressor.java @@ -0,0 +1,186 @@ +package com.ts3client.audio.processing.transients; + +import com.ts3client.audio.Fft; + +/** + * WebRTC's transient suppressor ({@code transient/transient_suppressor_impl.cc}), the module + * behind TS3's "Typing attenuation", for one 48 kHz channel. + * + *

It only acts while the user is typing: every key press is reported through + * {@code keyPressed}, the detector switches on with the first press and the suppression + * with the second within about a second; four seconds without a press switch both off. + * While suppressing, spectral peaks that jump above the running spectral mean during a + * detected transient are pulled back towards it. + * + *

TS3 runs it with no analog AGC, so APM hands it a voice probability of 1: the + * suppressor always uses its "soft", voiced restoration, and the unvoiced "hard" path with + * its random phases is never taken. That path is left out here. + * + *

The output is delayed by 544 samples (11.3 ms) whether or not it is suppressing, + * exactly as upstream, so switching on and off doesn't shift the signal. + */ +public final class TransientSuppressor { + + private static final int CHUNK_MS = 10; + private static final float MEAN_IIR_COEFFICIENT = 0.5f; + private static final int MIN_VOICE_BIN = 3; + private static final int MAX_VOICE_BIN = 60; + + private static final int KEYPRESS_PENALTY = 1000 / CHUNK_MS; + private static final int IS_TYPING_THRESHOLD = 1000 / CHUNK_MS; + private static final int CHUNKS_UNTIL_NOT_TYPING = 4000 / CHUNK_MS; + + private static final int DATA_LENGTH = 480; + private static final int ANALYSIS_LENGTH = 1024; + private static final int BUFFER_DELAY = ANALYSIS_LENGTH - DATA_LENGTH; + private static final int COMPLEX_LENGTH = ANALYSIS_LENGTH / 2 + 1; + + /** + * {@code kBlocks480w1024}: a half-sine over [32, 992], zero outside. Upstream stores it + * as a table; this formula reproduces it to within float rounding. + */ + private static final float[] WINDOW = new float[ANALYSIS_LENGTH]; + + static { + for (int i = 32; i < 992; i++) { + WINDOW[i] = (float) Math.sin(Math.PI * (i - 32) / 960.0); + } + } + + private final TransientDetector detector; + private final float[] inBuffer = new float[ANALYSIS_LENGTH]; + private final float[] outBuffer = new float[ANALYSIS_LENGTH]; + private final float[] spectralMean = new float[COMPLEX_LENGTH]; + private final float[] magnitudes = new float[COMPLEX_LENGTH]; + private final float[] meanFactor = new float[COMPLEX_LENGTH]; + private final double[] fftRe = new double[ANALYSIS_LENGTH]; + private final double[] fftIm = new double[ANALYSIS_LENGTH]; + + private float detectorSmoothed; + private int keypressCounter; + private int chunksSinceKeypress; + private boolean detectionEnabled; + private boolean suppressionEnabled; + + /** @param detectionRateHz rate of the detection data passed to {@link #suppress} */ + public TransientSuppressor(int detectionRateHz) { + this.detector = new TransientDetector(detectionRateHz); + // A double sigmoid with its minimum over the voice range (300 Hz - 3 kHz at 16 kHz bins). + final float factorHeight = 10.f; + final float lowSlope = 1.f; + final float highSlope = 0.3f; + for (int i = 0; i < COMPLEX_LENGTH; i++) { + meanFactor[i] = factorHeight / (1.f + (float) Math.exp(lowSlope * (i - MIN_VOICE_BIN))) + + factorHeight / (1.f + (float) Math.exp(highSlope * (MAX_VOICE_BIN - i))); + } + } + + /** + * Processes 10 ms in place. + * + * @param data 480 samples at 48 kHz + * @param detectionData one chunk at the detection rate: APM passes the 0–8 kHz band + * @param keyPressed whether a key went down since the previous call + */ + public void suppress(float[] data, float[] detectionData, boolean keyPressed) { + updateKeypress(keyPressed); + updateBuffers(data); + + if (detectionEnabled) { + float detectorResult = detector.detect(detectionData, 0); + // Rise with the detector, but decay slowly so the ringing of a click is covered. + final float smoothFactor = 0.1f; + detectorSmoothed = detectorResult >= detectorSmoothed + ? detectorResult + : smoothFactor * detectorSmoothed + (1 - smoothFactor) * detectorResult; + suppressChunk(); + } + + // When not suppressing, the input buffer supplies the same delay. + System.arraycopy(suppressionEnabled ? outBuffer : inBuffer, 0, data, 0, DATA_LENGTH); + } + + private void suppressChunk() { + for (int i = 0; i < ANALYSIS_LENGTH; i++) { + fftRe[i] = inBuffer[i] * WINDOW[i]; + fftIm[i] = 0; + } + Fft.forward(fftRe, fftIm); + + for (int i = 0; i < COMPLEX_LENGTH; i++) { + magnitudes[i] = Math.abs((float) fftRe[i]) + Math.abs((float) fftIm[i]); + } + + if (suppressionEnabled) { + softRestoration(); + } + + for (int i = 0; i < COMPLEX_LENGTH; i++) { + spectralMean[i] = (1 - MEAN_IIR_COEFFICIENT) * spectralMean[i] + MEAN_IIR_COEFFICIENT * magnitudes[i]; + } + + // Back to the time domain; the restoration touched the lower half, mirror it. + for (int i = 1; i < COMPLEX_LENGTH - 1; i++) { + fftRe[ANALYSIS_LENGTH - i] = fftRe[i]; + fftIm[ANALYSIS_LENGTH - i] = -fftIm[i]; + } + fftIm[0] = 0; + fftIm[COMPLEX_LENGTH - 1] = 0; + Fft.inverse(fftRe, fftIm); + for (int i = 0; i < ANALYSIS_LENGTH; i++) { + outBuffer[i] += (float) fftRe[i] * WINDOW[i]; + } + } + + /** + * Pulls peaks above the spectral mean back towards it by the detector's confidence, + * skipping those far above the block's voice-band mean: those are more likely voice. + */ + private void softRestoration() { + float blockFrequencyMean = 0; + for (int i = MIN_VOICE_BIN; i < MAX_VOICE_BIN; i++) { + blockFrequencyMean += magnitudes[i]; + } + blockFrequencyMean /= (MAX_VOICE_BIN - MIN_VOICE_BIN); + + for (int i = 0; i < COMPLEX_LENGTH; i++) { + if (magnitudes[i] > spectralMean[i] && magnitudes[i] > 0 + && magnitudes[i] < blockFrequencyMean * meanFactor[i]) { + final float newMagnitude = magnitudes[i] - detectorSmoothed * (magnitudes[i] - spectralMean[i]); + final float ratio = newMagnitude / magnitudes[i]; + fftRe[i] *= ratio; + fftIm[i] *= ratio; + magnitudes[i] = newMagnitude; + } + } + } + + private void updateKeypress(boolean keyPressed) { + if (keyPressed) { + keypressCounter += KEYPRESS_PENALTY; + chunksSinceKeypress = 0; + detectionEnabled = true; + } + keypressCounter = Math.max(0, keypressCounter - 1); + + if (keypressCounter > IS_TYPING_THRESHOLD) { + suppressionEnabled = true; + keypressCounter = 0; + } + + if (detectionEnabled && ++chunksSinceKeypress > CHUNKS_UNTIL_NOT_TYPING) { + detectionEnabled = false; + suppressionEnabled = false; + keypressCounter = 0; + } + } + + private void updateBuffers(float[] data) { + System.arraycopy(inBuffer, DATA_LENGTH, inBuffer, 0, BUFFER_DELAY); + System.arraycopy(data, 0, inBuffer, BUFFER_DELAY, DATA_LENGTH); + if (detectionEnabled) { + System.arraycopy(outBuffer, DATA_LENGTH, outBuffer, 0, BUFFER_DELAY); + java.util.Arrays.fill(outBuffer, BUFFER_DELAY, ANALYSIS_LENGTH, 0.f); + } + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/WaveletPacketTree.java b/ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/WaveletPacketTree.java new file mode 100644 index 0000000..9ea7529 --- /dev/null +++ b/ts3-client/core/src/main/java/com/ts3client/audio/processing/transients/WaveletPacketTree.java @@ -0,0 +1,124 @@ +package com.ts3client.audio.processing.transients; + +/** + * A three-level wavelet packet decomposition with Daubechies-8 filters, ported from + * {@code transient/wpd_tree.cc} and {@code wpd_node.cc}. Each node low- or high-pass + * filters its parent, keeps the odd samples and rectifies them; the eight leaves hand the + * transient detector the signal's envelope in eight sub-bands. + */ +final class WaveletPacketTree { + + static final int LEVELS = 3; + static final int LEAVES = 1 << LEVELS; + + private static final float[] HIGH_PASS = { + -5.44158422430816093862e-02f, 3.12871590914465924627e-01f, + -6.75630736298012846142e-01f, 5.85354683654869090148e-01f, + 1.58291052560238926228e-02f, -2.84015542962428091389e-01f, + -4.72484573997972536787e-04f, 1.28747426620186011803e-01f, + 1.73693010020221083600e-02f, -4.40882539310647192377e-02f, + -1.39810279170155156436e-02f, 8.74609404701565465445e-03f, + 4.87035299301066034600e-03f, -3.91740372995977108837e-04f, + -6.75449405998556772109e-04f, -1.17476784002281916305e-04f}; + + private static final float[] LOW_PASS = { + -1.17476784002281916305e-04f, 6.75449405998556772109e-04f, + -3.91740372995977108837e-04f, -4.87035299301066034600e-03f, + 8.74609404701565465445e-03f, 1.39810279170155156436e-02f, + -4.40882539310647192377e-02f, -1.73693010020221083600e-02f, + 1.28747426620186011803e-01f, 4.72484573997972536787e-04f, + -2.84015542962428091389e-01f, -1.58291052560238926228e-02f, + 5.85354683654869090148e-01f, 6.75630736298012846142e-01f, + 3.12871590914465924627e-01f, 5.44158422430816093862e-02f}; + + /** Heap-ordered: node 1 is the root, node {@code n}'s children are {@code 2n} and {@code 2n+1}. */ + private final Node[] nodes = new Node[(1 << (LEVELS + 1))]; + + WaveletPacketTree(int dataLength) { + nodes[1] = new Node(dataLength, null); + for (int level = 0; level < LEVELS; level++) { + for (int i = 0; i < (1 << level); i++) { + int index = (1 << level) + i; + nodes[2 * index] = new Node(nodes[index].length / 2, LOW_PASS); + nodes[2 * index + 1] = new Node(nodes[index].length / 2, HIGH_PASS); + } + } + } + + void update(float[] data, int offset) { + System.arraycopy(data, offset, nodes[1].data, 0, nodes[1].length); + for (int level = 0; level < LEVELS; level++) { + for (int i = 0; i < (1 << level); i++) { + int index = (1 << level) + i; + nodes[2 * index].update(nodes[index]); + nodes[2 * index + 1].update(nodes[index]); + } + } + } + + /** The data of leaf {@code index}; its first {@link #leafLength()} samples are valid. */ + float[] leaf(int index) { + return nodes[LEAVES + index].data; + } + + int leafLength() { + return nodes[LEAVES].length; + } + + private static final class Node { + final int length; + /** Sized for the parent's length: the filter output lands here before decimation. */ + final float[] data; + private final float[] coefficients; // reversed, as FIRFilterC stores them + private final float[] state; + + Node(int length, float[] coefficients) { + this.length = length; + this.data = new float[2 * length + 1]; + if (coefficients == null) { + this.coefficients = null; + this.state = null; + } else { + int n = coefficients.length; + this.coefficients = new float[n]; + for (int i = 0; i < n; i++) { + this.coefficients[i] = coefficients[n - i - 1]; + } + this.state = new float[n - 1]; + } + } + + void update(Node parent) { + filter(parent.data, parent.length, data); + // Keep the odd samples, then rectify. + for (int i = 0; i < length; i++) { + data[i] = data[2 * i + 1]; + } + for (int i = 0; i < length; i++) { + data[i] = Math.abs(data[i]); + } + } + + /** FIR convolution carrying the last {@code taps - 1} inputs over, as in {@code fir_filter_c.cc}. */ + private void filter(float[] in, int n, float[] out) { + int stateLength = state.length; + for (int i = 0; i < n; i++) { + float acc = 0.f; + int j = 0; + for (; stateLength > i && j < stateLength - i; j++) { + acc += state[i + j] * coefficients[j]; + } + for (; j < coefficients.length; j++) { + acc += in[j + i - stateLength] * coefficients[j]; + } + out[i] = acc; + } + if (n >= stateLength) { + System.arraycopy(in, n - stateLength, state, 0, stateLength); + } else { + System.arraycopy(state, n, state, 0, stateLength - n); + System.arraycopy(in, 0, state, stateLength - n, n); + } + } + } +} diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/vad/RnnSpeechDetector.java b/ts3-client/core/src/main/java/com/ts3client/audio/vad/RnnSpeechDetector.java index 4e94c62..2e21a31 100644 --- a/ts3-client/core/src/main/java/com/ts3client/audio/vad/RnnSpeechDetector.java +++ b/ts3-client/core/src/main/java/com/ts3client/audio/vad/RnnSpeechDetector.java @@ -71,6 +71,11 @@ public final class RnnSpeechDetector implements SpeechProbabilityDetector { } } + /** See {@link RnnVad#resetNetwork()}. */ + public void resetNetwork() { + vad.resetNetwork(); + } + /** Appends samples (taking every {@code step}-th) and runs the detector per full frame. */ private void feed(float[] src, int offset, int length, int step) { for (int i = offset; i < offset + length; i += step) { diff --git a/ts3-client/core/src/main/java/com/ts3client/audio/vad/RnnVad.java b/ts3-client/core/src/main/java/com/ts3client/audio/vad/RnnVad.java index 69b54b3..5d649d9 100644 --- a/ts3-client/core/src/main/java/com/ts3client/audio/vad/RnnVad.java +++ b/ts3-client/core/src/main/java/com/ts3client/audio/vad/RnnVad.java @@ -59,6 +59,14 @@ public final class RnnVad { probability = 0.0f; } + /** + * Clears only the network's recurrent state, keeping the feature history. AGC2 does this + * every 1.5 s so its detector cannot latch. + */ + public void resetNetwork() { + network.reset(); + } + /** Speech probability in [0, 1] from the most recent {@link #process} call. */ public float probability() { return probability; diff --git a/ts3-client/core/src/test/java/com/ts3client/audio/processing/AudioProcessorTest.java b/ts3-client/core/src/test/java/com/ts3client/audio/processing/AudioProcessorTest.java new file mode 100644 index 0000000..eb45b17 --- /dev/null +++ b/ts3-client/core/src/test/java/com/ts3client/audio/processing/AudioProcessorTest.java @@ -0,0 +1,174 @@ +package com.ts3client.audio.processing; + +import com.ts3client.audio.processing.ns.SuppressionLevel; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.Random; +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Checks the chain against WebRTC itself. The {@code golden-*.s16} resources are + * {@link #testSignal()} run through upstream APM (webrtc-audio-processing 2.1 for noise + * suppression, 1.3 for the transient suppressor, which 2.x no longer ships), configured as + * TS3 configures it, and stored as 16-bit PCM. + */ +class AudioProcessorTest { + + private static final int RATE = AudioProcessor.SAMPLE_RATE; + private static final int FRAME = AudioProcessor.FRAME_SIZE; + + /** 10 ms frames in which the test signal has a key click, reported as key presses. */ + static final int[] KEY_FRAMES = {66, 72, 79, 85, 90, 97}; + private static final Set KEYS = Set.of(66, 72, 79, 85, 90, 97); + + /** + * One second of microphone-like input: quiet pink noise throughout, a voiced harmonic + * burst from 0.3 to 0.6 s, and key clicks after it. + */ + static float[] testSignal() { + Random random = new Random(11); + float[] x = new float[RATE]; + double b0 = 0, b1 = 0, b2 = 0; + for (int i = 0; i < x.length; i++) { + double w = random.nextGaussian(); + b0 = 0.99765 * b0 + w * 0.0990460; + b1 = 0.96300 * b1 + w * 0.2965164; + b2 = 0.57000 * b2 + w * 1.0526913; + double noise = (b0 + b1 + b2 + w * 0.1848) * 0.0012; + + double t = (double) i / RATE; + double voice = 0; + if (t >= 0.3 && t < 0.6) { + double envelope = Math.sin(Math.PI * (t - 0.3) / 0.3); + for (int h = 1; h <= 20; h++) { + voice += Math.sin(2 * Math.PI * 140 * h * t + h) / h; + } + voice *= 0.08 * envelope; + } + x[i] = (float) (noise + voice); + } + for (int frame : KEY_FRAMES) { + int start = frame * FRAME + 100; + for (int k = 0; k < 480; k++) { + x[start + k] += (float) (random.nextGaussian() * 0.1 * Math.exp(-k / 96.0)); + } + } + return x; + } + + private static float[] run(AudioProcessor processor, float[] input, Set keyFrames) { + float[] x = input.clone(); + float[] frame = new float[FRAME]; + for (int f = 0; f * FRAME + FRAME <= x.length; f++) { + if (keyFrames.contains(f)) processor.keyPressed(); + System.arraycopy(x, f * FRAME, frame, 0, FRAME); + processor.process(frame, FRAME); + System.arraycopy(frame, 0, x, f * FRAME, FRAME); + } + return x; + } + + private static void assertMatchesGolden(String name, float[] actual) throws IOException { + short[] golden = loadGolden(name); + assertEquals(golden.length, actual.length); + double maxDiff = 0; + double sumSquares = 0; + for (int i = 0; i < actual.length; i++) { + double d = actual[i] * 32768.0 - golden[i]; + maxDiff = Math.max(maxDiff, Math.abs(d)); + sumSquares += d * d; + } + double rms = Math.sqrt(sumSquares / actual.length); + // The reference is quantised to 16 bits, and float rounding differs slightly from + // upstream's: anything within a few LSB is the same signal. + assertTrue(maxDiff <= 4, name + ": max deviation " + maxDiff + " LSB"); + assertTrue(rms <= 0.6, name + ": RMS deviation " + rms + " LSB"); + } + + private static short[] loadGolden(String name) throws IOException { + try (InputStream in = AudioProcessorTest.class.getResourceAsStream(name)) { + assertNotNull(in, name); + ByteBuffer bytes = ByteBuffer.wrap(in.readAllBytes()).order(ByteOrder.LITTLE_ENDIAN); + short[] out = new short[bytes.remaining() / 2]; + bytes.asShortBuffer().get(out); + return out; + } + } + + @Test + void everythingOffPassesAudioThroughUntouched() { + float[] x = testSignal(); + assertArrayEquals(x, run(new AudioProcessor(), x, KEYS)); + } + + @Test + void noiseSuppressionMatchesWebRtcAtEveryLevel() throws IOException { + for (int level = 0; level <= 3; level++) { + AudioProcessor p = new AudioProcessor(); + p.setNoiseSuppression(true); + p.setSuppressionLevel(SuppressionLevel.fromDenoiserLevel(level)); + assertMatchesGolden("golden-ns" + level + ".s16", run(p, testSignal(), Set.of())); + } + } + + @Test + void typingAttenuationMatchesWebRtc() throws IOException { + AudioProcessor p = new AudioProcessor(); + p.setNoiseSuppression(true); + p.setSuppressionLevel(SuppressionLevel.DB_12); + p.setTransientSuppression(true); + assertMatchesGolden("golden-ns1-typing.s16", run(p, testSignal(), KEYS)); + } + + @Test + void typingAttenuationOnlyDelaysWithoutKeyPresses() { + float[] x = testSignal(); + AudioProcessor p = new AudioProcessor(); + p.setTransientSuppression(true); + float[] y = run(p, x, Set.of()); + int delay = 1024 - FRAME; + for (int i = delay; i < x.length; i++) { + assertEquals(x[i - delay], y[i], 0.0f); + } + } + + @Test + void gainControlRaisesQuietSpeechAndLeavesSilenceAlone() { + AudioProcessor p = new AudioProcessor(); + p.setGainControl(true); + float[] silence = run(p, new float[RATE], Set.of()); + for (float s : silence) assertEquals(0.0f, s, 0.0f); + + // 3 s of quiet voiced "words" at about -40 dBFS over a -70 dBFS noise floor. The + // pauses matter: without them AGC2 would take the voice for the noise floor. + Random random = new Random(5); + float[] quiet = new float[RATE * 3]; + for (int i = 0; i < quiet.length; i++) { + double t = (double) i / RATE; + double v = 0; + if (t % 0.5 < 0.3) { + for (int h = 1; h <= 20; h++) v += Math.sin(2 * Math.PI * 130 * h * t + h) / h; + v *= 0.004 * Math.sin(Math.PI * (t % 0.5) / 0.3); + } + quiet[i] = (float) (v + random.nextGaussian() * 0.0003); + } + float[] out = run(p, quiet, Set.of()); + assertTrue(rms(out, RATE * 2, RATE * 3) > 4 * rms(quiet, RATE * 2, RATE * 3), + "quiet speech should be raised by more than 12 dB"); + } + + private static double rms(float[] x, int from, int to) { + double sum = 0; + for (int i = from; i < to; i++) sum += x[i] * x[i]; + return Math.sqrt(sum / (to - from)); + } +} diff --git a/ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns0.s16 b/ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns0.s16 new file mode 100644 index 0000000000000000000000000000000000000000..edf3a4dcd7b56b77b5917e1cb3eca415abdb6c1f GIT binary patch literal 96000 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

=1s>+a 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

Pg+KRYIFDMJK0iARS ziMyU__d^xOd2WthvrCI9ChddI)J;JrpeScmaZq*n%z+}6k*wY&e}fa|!Y9gM?S+<< zj%opgUtr`AaHh@;fzVYIe5X43a8`L88)F@C-3Mjqj2m^pQzZ5{w4o7n0+IUgsC&ja zpnc45&s=~SBZ1&CX1oo)PdDkqRC00| zvESWb`z*iLune_tP;WCEJ)|m0^>VR+cNAFFnHV?sfyJ!z7jX0|e@_5kd01r4$pfO@ zkus%Q`{jBWnj#UorYaO^r4+E)&M(>eF&o*!s>-be)?I+2s@fhy+l_*A?ndiqU#GLs z1f`?EPByzLI!BvhUc5c`Y8Si(J@+-(la^G3^?%Grr_!rVS$*czmsNQNiV>-T@)D~_ z1UfnJxPymPm{N4E9Wr?jR38qWZgxge1nFi)qq2eiVinp2s>V5vjK6nz{%<@@+2WnR zh)!0DVkdQi`EN(AOGl~~R!1mMXNnGG-bvt4{oy44hC}NudDolqbxOOg}QQ{h2xYfzY`u%zDh2bIL381fS$Zr>hLLze+-^AxmUfGh9KXr zLNT(NvhmT(MWtZ zlzappKZWejKB_PClaFgHw4vx`44yr8bywbzvgVanH5qISf#SO|CmY(zfUaC{MGRPw z*4@R7Q@C1{6Y2}EeOC$)pNE{h1-&2*mC0&VQQZYt__#yel4Jv)XRQ(J+{3ZAR)R}T zL-c!{pTl2F4-(rnM-WAM70&+He%(c-pk3{x8y`0(2fX7L)V^2YwY2pQ@*pSX}0-=Ym;+tK#KKu*AQQ$@rwPman+jO z8ez=0r3 z*?PD6Me{RfgE7?^<(x1rbBfc!Wm!*v^JlF~=7&bP>qTppb=jD0jFt739>Gi9 z$@vvM+5>v#WDBHsoN+H+S9Muh=zM5wATC7Lap<@wS$IiE^O4;19ePMr08bO6Ax9eS z)A@S&^xxP_v`$v?8TJfI$@}fko~Q=hJ{DWfg6j99+jY9o6*TKwtea?L`9lAxm$vgH zx;Dc2hB(vbJo{VlRfqf!L3ck)C#A>X%>~2&vgtpe^Cez^dzEprj=fAediQnYmZCL9 zNX#i*`#-c}B+^J-Kia{M@+!zGTh0u!kv}%Ss!qNgNfeAcyn-Y+%y%AoEL=o(=Mn*& z4<{?b~jC50v0o6*k z#s2FE4odKxdl)epneYYjV>`1@FYPe2zBI^JNVNp6YsOMIg7k_;OX>`5Wh1Jmkd0)w zxh@oI6Z-iuc0i(R1H$%Di| zCt;nnVit?o@4Nx^yaF$3C!&18GBlF>qMf;NIIwdOKUI~cVhEarJOMG}!pM`|2TQIa zu)TSfSPWRNBU&_yRjT{Q7%-u0`v5J~{1;+xDVt~_bf>PhhtN?rR#yq%%IY}IDi*=H z%IepSO10jp@Q@;GvNvQi{SKu)k9~g-4O|0d9Re@XrrJ*{=SmS7b?R0Xqzm177X7B4 zq>45v4yj6Oox>_C`viECpIvp4uM@?R#2f`?bfS&UAZXxO{n6q&ckMZ-!pAuESZ9B* z79SW<*HYEnCS&2~Y!`!7Z-fKxK@Q#qg+9)%Kc3a9!(1}fzkKdG&n%v~+y<9sg3sy9 zN~cEM;PqJS+Nar>E`S2G!-&E{9u6*41*YE#(0L)_4B;ute$lxB35>d#U5?H$cc7#L s*qANJ4B1PafO5jr$MZ|9ffD%XGoIQWDI*WZcA#Ahj1M4lPvKkne{!l_kN^Mx literal 0 HcmV?d00001 diff --git a/ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns1-typing.s16 b/ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns1-typing.s16 new file mode 100644 index 0000000000000000000000000000000000000000..53f00f8ab29a85f7ba02fd626c6ecfb4dcf08e38 GIT binary patch literal 96000 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

mmO8&dCT6CVRjvqJ!h+N)XMkg)I`Ix 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 GjQ>CJLBU}F literal 0 HcmV?d00001 diff --git a/ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns2.s16 b/ts3-client/core/src/test/resources/com/ts3client/audio/processing/golden-ns2.s16 new file mode 100644 index 0000000000000000000000000000000000000000..b2f22664276e4a2d183c7837d7bcca760cc403bb GIT binary patch literal 96000 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 aKG)(tjmj