STM32F401RET6 Speech Denoising — Wiener Filter Output is More Noisy Than Original Input

Question

I am implementing a real-time speech denoising pipeline on an STM32F401RE microcontroller running at 84 MHz. The goal is to denoise speech audio recorded at 16 kHz that contains background hiss and low-frequency hum (50/60 Hz). Audio is sent from a PC over UART at 921600 baud in blocks of 400 samples (int16), processed on the STM32, and sent back to the PC. **Pipeline Design** The processing pipeline is: ``` Input (int16) → HPF (80 Hz cutoff) → LPF (4000 Hz cutoff) → Wiener Filter → Output (int16) ``` Stage 1 — High-Pass Filter (2nd order Butterworth, 80 Hz cutoff @ 16 kHz) Removes 50/60 Hz hum while preserving speech fundamentals. Stage 2 — Low-Pass Filter (2nd order Butterworth, 4000 Hz cutoff @ 16 kHz) Limits bandwidth to speech range (80–4000 Hz). Stage 3 — Wiener Filter SNR-based adaptive gain suppression with: Recursive smoothed power estimate (alpha = 0.85) Continuous noise tracking from quiet regions (noise_alpha = 0.9999) Minimum gain floor of 0.15 to prevent over-suppression Temporal gain smoothing (gain_alpha = 0.92) to prevent musical noise ## STM32 Code (main.c) C ``` #include "main.h" #include #include #include #define BLOCK_SIZE 400 int16_t rx_buffer[BLOCK_SIZE]; int16_t tx_buffer[BLOCK_SIZE]; UART_HandleTypeDef huart2; /* High-pass filter states */ float x1_hp = 0.0f, x2_hp = 0.0f; float y1_hp = 0.0f, y2_hp = 0.0f; /* Low-pass filter states */ float x1_lp = 0.0f, x2_lp = 0.0f; float y1_lp = 0.0f, y2_lp = 0.0f; /* High-pass filter coefficients — 80 Hz cutoff @ 16 kHz */ float b0_hp = 0.99219543f; float b1_hp = -1.98439086f; float b2_hp = 0.99219543f; float a1_hp = -1.98431126f; float a2_hp = 0.98447046f; /* Low-pass filter coefficients — 4000 Hz cutoff @ 16 kHz */ float b0_lp = 0.20657209f; float b1_lp = 0.41314418f; float b2_lp = 0.20657209f; float a1_lp = -0.36939806f; float a2_lp = 0.19568642f; /* Wiener filter variables */ float noise_est = 50000.0f; float alpha = 0.85f; float noise_alpha = 0.9999f; /* Spectral floor variables */ float smooth_gain = 1.0f; float gain_alpha = 0.92f; /* Smoothed power variable */ float smooth_power = 0.0f; uint32_t start_cycles; uint32_t end_cycles; uint32_t processing_cycles; char msg[50]; int main(void) { HAL_Init(); SystemClock_Config(); MX_GPIO_Init(); MX_USART2_UART_Init(); CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk; DWT->CYCCNT = 0; DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk; while(1) { HAL_UART_Receive(&huart2, (uint8_t*)rx_buffer, sizeof(rx_buffer), HAL_MAX_DELAY); start_cycles = DWT->CYCCNT; for(int i = 0; i < BLOCK_SIZE; i++) { float x = (float)rx_buffer[i]; /* High-Pass Filter */ float y_hp = b0_hp*x + b1_hp*x1_hp + b2_hp*x2_hp - a1_hp*y1_hp - a2_hp*y2_hp; x2_hp = x1_hp; x1_hp = x; y2_hp = y1_hp; y1_hp = y_hp; /* Low-Pass Filter */ float y_lp = b0_lp*y_hp + b1_lp*x1_lp + b2_lp*x2_lp - a1_lp*y1_lp - a2_lp*y2_lp; x2_lp = x1_lp; x1_lp = y_hp; y2_lp = y1_lp; y1_lp = y_lp; /* Wiener Filter */ float power = y_lp * y_lp; smooth_power = alpha * smooth_power + (1.0f - alpha) * power; /* Update noise only during quiet regions */ if (smooth_power < noise_est * 1.2f) { noise_est = noise_alpha * noise_est + (1.0f - noise_alpha) * smooth_power; } float signal_est = smooth_power - noise_est; if (signal_est < 0.0f) signal_est = 0.0f; float gain = signal_est / (signal_est + noise_est + 1e-6f); if (gain < 0.15f) gain = 0.15f; smooth_gain = gain_alpha * smooth_gain + (1.0f - gain_alpha) * gain; float y_wiener = smooth_gain * y_lp; if (y_wiener > 32767.0f) y_wiener = 32767.0f; if (y_wiener < -32768.0f) y_wiener = -32768.0f; tx_buffer[i] = (int16_t)y_wiener; } end_cycles = DWT->CYCCNT; processing_cycles = end_cycles - start_cycles; HAL_UART_Transmit(&huart2, (uint8_t*)tx_buffer, sizeof(tx_buffer), HAL_MAX_DELAY); sprintf(msg, "Cycles:%u ", processing_cycles); HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY); } } ``` Problem Despite the pipeline design, the denoised output audio sounds MORE noisy than the original clean recording. Specifically: The output is noisier than the input — the added white noise is not being suppressed; in fact it seems amplified. Speech is being cut intermittently — analysis of block-level RMS shows large sections of near-zero output even where the original has clear speech. Block RMS drops to ~20–40 in sections where original speech blocks have RMS of ~600–900. The noise tracker seems to be adapting to speech — the condition smooth_power < noise_est * 1.2f allows noise_est to track upward toward speech-level power, causing the Wiener filter to treat speech as noise and suppress it. What We Have Tried Started with a basic noise learning phase (10 blocks of silence from Python) — noise_est became ~0 because silence blocks have zero power, making the Wiener gain permanently 1.0 (no denoising at all). Replaced silence-based learning with continuous noise tracking using noise_alpha = 0.9999 and threshold smooth_power < noise_est * 1.2f — noise tracker still adapts upward to speech level over time. Tried initializing noise_est = 50000.0f as a realistic starting floor — helps initially but degrades as noise tracker adapts. Tried alpha = 0.85 for faster smooth_power attack to fix speech onset cutting — partially helps but speech is still being suppressed. Tried gain floor of 0.15 — prevents complete silence but doesn't fix the underlying noise tracking problem. Questions How should noise estimation be done correctly in a time-domain single-channel Wiener filter on a microcontroller where: We cannot guarantee silence at startup Audio is fed as pre-recorded file blocks (not live microphone) noise_est must not adapt to speech power Is the noise tracker threshold approach (smooth_power < noise_est * K) fundamentally flawed for this use case? What is the correct approach? Should the Wiener filter be operating on a smoothed power envelope (as we have) or should it use a different signal power estimation method for better speech/noise discrimination? Any suggestions for a better but still MCU-feasible noise estimation method given the 84 MHz clock and 400-sample block size constraint? System Info MCU: STM32F401RE @ 84 MHz Audio: 16 kHz, 16-bit PCM mono Block size: 400 samples (25 ms per block) UART: 921600 baud Toolchain: Keil MDK v5, ARM Compiler V6.24 Python: 3.x with pyserial, numpy

STM32F401RET6 Speech Denoising — Wiener Filter Output is More Noisy Than Original Input

Related Questions

Same Tag Questions

Popular Questions

0 Answers