audio: webrtc_ns2: add RNNoise deep-learning noise suppressor module

Add the webrtc_ns2 SOF module wrapping xiph/rnnoise — a recurrent
neural network (GRU-based) noise suppressor originally developed by
Jean-Marc Valin at Mozilla.

Module characteristics:
- Single-source, single-sink PCM effect
- Floating-point; internal float math, hardware FPU beneficial
- Hard requirement: pipeline sample rate MUST be 48000 Hz
- Processes 480-sample (10 ms) frames; partial periods accumulated
  internally
- Supports S16_LE and S32_LE, mono or stereo (one DenoiseState per
  channel; up to WEBRTC_NS2_CHANNELS_MAX channels)
- Float scale bridging: pipeline samples normalised to ±1.0 are
  scaled to RNNoise's native ±32768 range and back
- VAD dual-use: rnnoise_process_frame() returns per-frame speech
  probability [0.0, 1.0]; this fires NOTIFIER_ID_VAD events at a
  configurable threshold (WEBRTC_NS2_VAD_THRESHOLD_PCT)
- Two backends: real (RNNoise) and pass-through stub for CI/LLEXT

Design notes:
- rnnoise_init() used at prepare/reset instead of rnnoise_create()
  to avoid per-init heap allocation (embedded-friendly path)
- Model weights (rnn_data.c) are const float[] placed in .rodata
  (Flash/ROM); ~85-340 KB depending on model variant
- Peak stack ~12-16 KB per rnnoise_process_frame() call
- No expf/tanhf in hot path: replaced by 201-entry tansig LUT

Build:
- RNNoise cross-compiled by src/audio/webrtc_ns2/webrtc_ns2.cmake
  (6 C files: denoise.c rnn.c rnn_data.c pitch.c celt_lpc.c kiss_fft.c)
- Source fetched via west (modules/audio/rnnoise, SHA 70f1d256)
- LLEXT packaging supported

UUID: eacfacdc-2a87-c942-97e894c917a740db

Signed-off-by: Liam Girdwood <liam.r.girdwood@linux.intel.com>

Author: lrgirdwo

src/audio/webrtc_ns2/CMakeLists.txt

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(CONFIG_COMP_WEBRTC_NS2 STREQUAL "m" AND DEFINED CONFIG_LLEXT)
+  add_subdirectory(llext ${PROJECT_BINARY_DIR}/webrtc_ns2_llext)
+  add_dependencies(app webrtc_ns2)
+else()
+  add_local_sources(sof webrtc_ns2.c)
+  if(CONFIG_COMP_WEBRTC_NS2_STUB)
+    add_local_sources(sof webrtc_ns2-stub.c)
+  else()
+    add_local_sources(sof webrtc_ns2-rnn.c)
+  endif()
+endif()

src/audio/webrtc_ns2/Kconfig

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+config COMP_WEBRTC_NS2
+	tristate "RNNoise deep-learning noise suppressor (floating-point)"
+	help
+	  Select to include the RNNoise module — a recurrent neural network
+	  noise suppressor originally developed by Jean-Marc Valin (Mozilla /
+	  Opus). RNNoise operates at 48 kHz on 10 ms (480-sample) mono frames
+	  and achieves significantly better suppression of non-stationary noise
+	  (music, babble, keyboard) than the classic spectral Wiener filter
+	  (COMP_WEBRTC_NS).
+
+	  The module is single-input, single-output and internally emits a
+	  per-frame VAD probability (0.0–1.0) via NOTIFIER_ID_VAD, making it
+	  a combined denoiser and activity detector.
+
+	  Requirements:
+	    - Floating-point unit (FPU=y on ACE30/PTL; soft-float also works
+	      but at significant CPU cost)
+	    - ~30 KB of state per channel (DenoiseState + RNN weights)
+	    - Pipeline sample rate exactly 48000 Hz
+	    - Pipeline period must be a multiple of 480 samples (10 ms)
+
+	  The real backend builds RNNoise from source (west module rnnoise,
+	  pinned at commit 70f1d256). For CI/stub builds select
+	  COMP_WEBRTC_NS2_STUB.
+
+	  License: BSD-3-Clause (xiph/rnnoise).
+
+if COMP_WEBRTC_NS2
+
+config COMP_WEBRTC_NS2_STUB
+	bool "RNNoise stub backend (no RNNoise source dependency)"
+	default y if COMP_STUBS
+	help
+	  Build webrtc_ns2 against a dependency-free pass-through stub instead
+	  of the real RNNoise library. The stub passes audio through unmodified
+	  and always reports VAD probability = 1.0. Used for CI and LLEXT
+	  packaging validation without the RNNoise source.
+
+config WEBRTC_NS2_CHANNELS_MAX
+	int "Maximum channel count (each channel gets its own RNNoise instance)"
+	range 1 8
+	default 2
+	help
+	  RNNoise is strictly mono; the module runs one DenoiseState per
+	  channel. Increasing this raises SRAM usage by ~30 KB per extra
+	  channel. Set to 1 for pure mono capture pipelines.
+
+config WEBRTC_NS2_VAD_NOTIFY
+	bool "Emit NOTIFIER_ID_VAD event from RNNoise VAD probability"
+	default y
+	help
+	  RNNoise returns a per-frame speech probability in [0.0, 1.0]. When
+	  this option is enabled the module broadcasts a NOTIFIER_ID_VAD event
+	  (speech=1 / silence=0) using a configurable threshold, providing a
+	  combined denoiser + VAD without running a separate webrtc_vad module.
+
+config WEBRTC_NS2_VAD_THRESHOLD_PCT
+	int "VAD threshold as percentage of max probability (0-100)"
+	range 0 100
+	default 50
+	depends on WEBRTC_NS2_VAD_NOTIFY
+	help
+	  Speech is declared when rnnoise_process_frame() returns a probability
+	  >= this value / 100.0. 50 is a good default; lower values increase
+	  sensitivity (more false positives), higher values reduce it.
+
+endif # COMP_WEBRTC_NS2

src/audio/webrtc_ns2/llext/CMakeLists.txt

@@ -0,0 +1,24 @@
+# Copyright (c) 2026 Intel Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+if(CONFIG_COMP_WEBRTC_NS2_STUB)
+  sof_llext_build("webrtc_ns2"
+    SOURCES ../webrtc_ns2.c
+            ../webrtc_ns2-stub.c
+    LIB openmodules
+  )
+else()
+  include(${CMAKE_CURRENT_LIST_DIR}/../webrtc_ns2.cmake)
+
+  sof_llext_build("webrtc_ns2"
+    SOURCES ../webrtc_ns2.c
+            ../webrtc_ns2-rnn.c
+    INCLUDES "${WEBRTC_NS2_INSTALL_DIR}/include"
+    LIBS_PATH "${WEBRTC_NS2_INSTALL_DIR}/lib"
+    LIBS rnnoise
+    LIB openmodules
+  )
+
+  add_dependencies(webrtc_ns2_llext_lib rnnoise_ext)
+  add_dependencies(webrtc_ns2 rnnoise_ext)
+endif()

src/audio/webrtc_ns2/llext/llext.toml.h

@@ -0,0 +1,6 @@
+#include <tools/rimage/config/platform.toml>
+#define LOAD_TYPE "2"
+#include "../webrtc_ns2.toml"
+
+[module]
+count = __COUNTER__

src/audio/webrtc_ns2/webrtc_ns2-rnn.c

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2026 Intel Corporation.
+//
+// Real RNNoise backend for webrtc_ns2.
+//
+// RNNoise public API (rnnoise.h / denoise.c):
+//
+//   int rnnoise_get_size(void);
+//       Returns sizeof(DenoiseState). Use this instead of sizeof() so the
+//       wrapper doesn't need to know the internal layout.
+//
+//   int rnnoise_init(DenoiseState *st, const RNNModel *model);
+//       Initialise state in-place. model=NULL uses the built-in weights
+//       (rnnoise_model_orig compiled into rnnoise_tables.c).
+//
+//   DenoiseState *rnnoise_create(const RNNModel *model);
+//       Allocate + init. Calls malloc() internally.
+//
+//   void rnnoise_destroy(DenoiseState *st);
+//       Free. Calls free() internally.
+//
+//   float rnnoise_process_frame(DenoiseState *st, float *out, const float *in);
+//       Process one 480-sample (10 ms at 48 kHz) mono frame.
+//       Samples are in full-scale float (not normalised to [-1,1]).
+//       Returns speech probability in [0, 1].
+//
+// Memory: ~30 KB per DenoiseState (including RNN state).
+// Dependencies: libm (expf, tanhf, sinf, cosf, sqrtf).
+
+#include <sof/audio/module_adapter/module/generic.h>
+#include <errno.h>
+#include "webrtc_ns2.h"
+
+#include <rnnoise.h>   /* from cross-built rnnoise library */
+
+LOG_MODULE_DECLARE(webrtc_ns2, CONFIG_SOF_LOG_LEVEL);
+
+/* RNNoise uses full-scale float (raw amplitude, not normalised). */
+#define RNN_FULL_SCALE	32768.0f
+
+struct webrtc_ns2_rnn_data {
+	DenoiseState *st[WEBRTC_NS2_CHANNELS_MAX];
+	int	      num_channels;
+};
+
+/* Per-frame scratch buffer at full scale. */
+static float rnn_in[WEBRTC_NS2_FRAME_SAMPLES];
+static float rnn_out[WEBRTC_NS2_FRAME_SAMPLES];
+
+static int webrtc_ns2_rnn_init(struct processing_module *mod)
+{
+	struct webrtc_ns2_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_ns2_rnn_data *rd;
+
+	rd = mod_zalloc(mod, sizeof(*rd));
+	if (!rd)
+		return -ENOMEM;
+
+	cd->backend_data = rd;
+	comp_info(mod->dev, "webrtc_ns2: RNNoise real backend, frame=%d rate=%d",
+		  WEBRTC_NS2_FRAME_SAMPLES, WEBRTC_NS2_SAMPLE_RATE);
+	return 0;
+}
+
+static int webrtc_ns2_rnn_configure(struct processing_module *mod, int num_channels)
+{
+	struct webrtc_ns2_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_ns2_rnn_data *rd = cd->backend_data;
+	int c;
+
+	/* Free any previous instances from a re-prepare. */
+	for (c = 0; c < rd->num_channels; c++) {
+		if (rd->st[c]) {
+			rnnoise_destroy(rd->st[c]);
+			rd->st[c] = NULL;
+		}
+	}
+	rd->num_channels = 0;
+
+	for (c = 0; c < num_channels; c++) {
+		/* Pass NULL to use the built-in model weights. */
+		rd->st[c] = rnnoise_create(NULL);
+		if (!rd->st[c]) {
+			comp_err(mod->dev,
+				 "webrtc_ns2: rnnoise_create() failed ch%d", c);
+			goto err;
+		}
+	}
+
+	rd->num_channels = num_channels;
+	comp_info(mod->dev, "webrtc_ns2: %d RNNoise instance(s) created", num_channels);
+	return 0;
+
+err:
+	for (c = 0; c < num_channels; c++) {
+		if (rd->st[c]) {
+			rnnoise_destroy(rd->st[c]);
+			rd->st[c] = NULL;
+		}
+	}
+	return -ENOMEM;
+}
+
+static float webrtc_ns2_rnn_process_ch(struct processing_module *mod,
+					const float *in, float *out, int ch)
+{
+	struct webrtc_ns2_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_ns2_rnn_data *rd = cd->backend_data;
+	float vad_prob;
+	int i;
+
+	/*
+	 * RNNoise expects full-scale float (raw PCM amplitude), but the SOF
+	 * glue normalises to [-1, +1]. Scale up before processing and back
+	 * down afterward.
+	 */
+	for (i = 0; i < WEBRTC_NS2_FRAME_SAMPLES; i++)
+		rnn_in[i] = in[i] * RNN_FULL_SCALE;
+
+	vad_prob = rnnoise_process_frame(rd->st[ch], rnn_out, rnn_in);
+
+	for (i = 0; i < WEBRTC_NS2_FRAME_SAMPLES; i++)
+		out[i] = rnn_out[i] / RNN_FULL_SCALE;
+
+	return vad_prob;
+}
+
+static int webrtc_ns2_rnn_reset(struct processing_module *mod)
+{
+	struct webrtc_ns2_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_ns2_rnn_data *rd = cd->backend_data;
+	int c;
+
+	/*
+	 * RNNoise has no reset API; re-initialise each instance in-place
+	 * using rnnoise_init() to clear the GRU hidden state.
+	 */
+	for (c = 0; c < rd->num_channels; c++) {
+		if (rd->st[c])
+			rnnoise_init(rd->st[c], NULL);
+	}
+	return 0;
+}
+
+static int webrtc_ns2_rnn_free(struct processing_module *mod)
+{
+	struct webrtc_ns2_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_ns2_rnn_data *rd = cd->backend_data;
+	int c;
+
+	if (!rd)
+		return 0;
+
+	for (c = 0; c < rd->num_channels; c++) {
+		if (rd->st[c]) {
+			rnnoise_destroy(rd->st[c]);
+			rd->st[c] = NULL;
+		}
+	}
+	mod_free(mod, rd);
+	cd->backend_data = NULL;
+	return 0;
+}
+
+const struct webrtc_ns2_backend webrtc_ns2_backend = {
+	.name       = "rnnoise",
+	.init       = webrtc_ns2_rnn_init,
+	.configure  = webrtc_ns2_rnn_configure,
+	.process_ch = webrtc_ns2_rnn_process_ch,
+	.reset      = webrtc_ns2_rnn_reset,
+	.free       = webrtc_ns2_rnn_free,
+};

src/audio/webrtc_ns2/webrtc_ns2-stub.c

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2026 Intel Corporation.
+//
+// Stub backend for webrtc_ns2. Passes audio through unchanged.
+// Returns VAD probability = 1.0 (always speech).
+
+#include <sof/audio/module_adapter/module/generic.h>
+#include <rtos/string.h>
+#include "webrtc_ns2.h"
+
+LOG_MODULE_DECLARE(webrtc_ns2, CONFIG_SOF_LOG_LEVEL);
+
+static int webrtc_ns2_stub_init(struct processing_module *mod)
+{
+	comp_info(mod->dev, "webrtc_ns2 stub: no RNNoise library linked");
+	return 0;
+}
+
+static int webrtc_ns2_stub_configure(struct processing_module *mod, int num_channels)
+{
+	comp_info(mod->dev, "webrtc_ns2 stub: ch=%d (ignored)", num_channels);
+	return 0;
+}
+
+static float webrtc_ns2_stub_process_ch(struct processing_module *mod,
+					const float *in, float *out, int ch)
+{
+	memcpy(out, in, WEBRTC_NS2_FRAME_SAMPLES * sizeof(float));
+	(void)ch;
+	return 1.0f; /* always report speech */
+}
+
+static int webrtc_ns2_stub_reset(struct processing_module *mod)
+{
+	(void)mod;
+	return 0;
+}
+
+static int webrtc_ns2_stub_free(struct processing_module *mod)
+{
+	(void)mod;
+	return 0;
+}
+
+const struct webrtc_ns2_backend webrtc_ns2_backend = {
+	.name       = "stub",
+	.init       = webrtc_ns2_stub_init,
+	.configure  = webrtc_ns2_stub_configure,
+	.process_ch = webrtc_ns2_stub_process_ch,
+	.reset      = webrtc_ns2_stub_reset,
+	.free       = webrtc_ns2_stub_free,
+};