audio: webrtc_vad: add GMM voice activity detector module

Add the webrtc_vad SOF module wrapping libfvad — a standalone C port
of the WebRTC Gaussian mixture model VAD (identical to the algorithm
shipping in Chrome/WebRTC since 2011).

Module characteristics:
- Single-source, single-sink PCM pass-through
- Accumulates 10/20/30 ms frames (configurable via Kconfig)
- Broadcasts NOTIFIER_ID_VAD event on every frame classification
- Supports S16_LE and S32_LE at 8/16/32/48 kHz, mono or stereo
- Fixed-point; no FPU required
- Two backends: real (libfvad) and pass-through stub for CI/LLEXT

Build:
- libfvad is cross-compiled by src/audio/webrtc_vad/webrtc_vad.cmake
- Source is fetched via west (modules/audio/libfvad, pinned SHA
  532ab666c20d)
- LLEXT packaging supported via llext/ subdirectory

Add NOTIFIER_ID_VAD to the notifier_id enum so downstream components
(e.g. webrtc_ns2 / RNNoise) can share the same VAD event channel.

UUID: c790b11d-5d14-e54e-be36ba4ad732cc14

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

Author: lrgirdwo

src/audio/webrtc_vad/CMakeLists.txt

@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(CONFIG_COMP_WEBRTC_VAD STREQUAL "m" AND DEFINED CONFIG_LLEXT)
+  add_subdirectory(llext ${PROJECT_BINARY_DIR}/webrtc_vad_llext)
+  add_dependencies(app webrtc_vad)
+else()
+  add_local_sources(sof webrtc_vad.c)
+
+  if(CONFIG_COMP_WEBRTC_VAD_STUB)
+    add_local_sources(sof webrtc_vad-stub.c)
+  else()
+    add_local_sources(sof webrtc_vad-fvad.c)
+    # NOTE: the libc symbols needed by libfvad (malloc/free/memset/...) are
+    # already provided by the SOF core in built-in and testbench builds.
+    # For LLEXT the shims are in llext/CMakeLists.txt (webrtc_vad-shims.c).
+  endif()
+endif()

src/audio/webrtc_vad/Kconfig

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+config COMP_WEBRTC_VAD
+	tristate "WebRTC Voice Activity Detection (libfvad)"
+	help
+	  Select to include the WebRTC Voice Activity Detection module. It
+	  wraps the libfvad library (a standalone pure-C extraction of the
+	  WebRTC GMM VAD) behind the SOF module interface. The module
+	  inspects each 10/20/30 ms PCM frame and annotates it as speech or
+	  non-speech via a NOTIFIER_ID_VAD notifier event, leaving the audio
+	  stream unmodified (pass-through).
+
+	  libfvad supports 8, 16, 32 and 48 kHz; it resamples to 8 kHz
+	  internally. The GMM classifier operates in Q15 fixed-point and
+	  requires no FPU.
+
+	  The real backend requires libfvad cross-built for the target
+	  (west module: modules/audio/libfvad). Without the source, or for
+	  CI/stub builds, select COMP_WEBRTC_VAD_STUB.
+
+if COMP_WEBRTC_VAD
+
+config COMP_WEBRTC_VAD_STUB
+	bool "WebRTC VAD stub backend (no libfvad dependency)"
+	default y if COMP_STUBS
+	help
+	  Build the webrtc_vad module against a dependency-free stub backend
+	  instead of libfvad. The stub always reports speech (VAD = 1) so
+	  the audio data flow and LLEXT packaging can be validated without
+	  the libfvad source or a cross-built archive.
+
+config WEBRTC_VAD_MODE
+	int "VAD aggressiveness mode (0=quality ... 3=aggressive)"
+	range 0 3
+	default 2
+	help
+	  Sets the libfvad operating mode which controls the trade-off
+	  between false-positive rate and missed-speech rate:
+	    0 - highest quality (fewest false alarms, may miss quiet speech)
+	    1 - moderate quality
+	    2 - moderate aggressiveness (default)
+	    3 - most aggressive (detects most speech, more false alarms)
+	  This option is also used by the stub backend (mode value is ignored
+	  by the stub but must be a valid integer for compilation).
+
+config WEBRTC_VAD_FRAME_MS
+	int "VAD frame length in milliseconds (10, 20 or 30)"
+	default 10
+	help
+	  libfvad processes audio in fixed-size frames. Valid values are
+	  10, 20 and 30 ms. Smaller frames give lower latency; 10 ms is
+	  the recommended default and matches the WebRTC pipeline convention.
+	  The SOF pipeline period must be a multiple of this value (the
+	  module accumulates sub-frames internally if needed).
+
+endif # COMP_WEBRTC_VAD

src/audio/webrtc_vad/README.md

@@ -0,0 +1,82 @@
+# WebRTC Voice Activity Detection module (`webrtc_vad`)
+
+Wraps [libfvad](https://github.com/dpirch/libfvad) — a standalone pure-C
+BSD-3 extraction of the WebRTC GMM Voice Activity Detection algorithm — behind
+the SOF `module_interface`.
+
+## What it does
+
+The module is a **pass-through PCM effect**: audio is copied from source to
+sink without modification. On each complete VAD frame (10, 20 or 30 ms,
+Kconfig-selectable), the module classifies channel-0 audio as speech or
+non-speech using the libfvad GMM classifier and broadcasts the binary decision
+(`WEBRTC_VAD_SPEECH` / `WEBRTC_VAD_SILENCE`) via `NOTIFIER_ID_VAD`.
+
+Downstream consumers (keyword detection gating, host-side VAD forwarding,
+noise suppression activation) subscribe to this notifier without needing to
+poll the module.
+
+## Algorithm
+
+libfvad implements the WebRTC Gaussian Mixture Model VAD:
+- Operates in **Q15 fixed-point** — no FPU required
+- Internally resamples any 8/16/32/48 kHz input to **8 kHz** for classification
+- 6 sub-band log-energy features feed a per-band GMM; bands are aggregated to
+  a single speech/non-speech bit
+- Four aggressiveness modes (0 = most conservative, 3 = most aggressive)
+
+## Design
+
+```
+webrtc_vad.c       — SOF module_interface glue (init/prepare/process/reset/free)
+webrtc_vad.h       — private data (struct webrtc_vad_comp_data) + backend API
+webrtc_vad-stub.c  — dependency-free passthrough stub; always reports SPEECH
+webrtc_vad-fvad.c  — real libfvad backend
+webrtc_vad-shims.c — malloc/free/mem* shims for LLEXT (backed by rballoc)
+webrtc_vad.cmake   — ExternalProject cross-build of libfvad static library
+```
+
+The `struct webrtc_vad_backend` interface mirrors `struct ffmpeg_dec_backend`:
+a named set of function pointers (`init`, `configure`, `classify`, `reset`,
+`free`). The SOF glue calls only these and remains independent of libfvad.
+
+## Build
+
+**Stub (CI/testing):**
+```
+CONFIG_COMP_WEBRTC_VAD=y   # or =m for LLEXT
+CONFIG_COMP_WEBRTC_VAD_STUB=y
+```
+No external dependencies. The stub always reports speech.
+
+**Real libfvad backend:**
+```
+CONFIG_COMP_WEBRTC_VAD=m    # LLEXT
+CONFIG_COMP_WEBRTC_VAD_STUB=n
+```
+Requires `west update` to pull `modules/audio/libfvad` (pinned in
+`west.yml`). The cross-build is driven by `webrtc_vad.cmake` invoked from
+`llext/CMakeLists.txt`.
+
+## Kconfig options
+
+| Option | Default | Description |
+|---|---|---|
+| `COMP_WEBRTC_VAD` | — | Enable module (y=built-in, m=LLEXT) |
+| `COMP_WEBRTC_VAD_STUB` | y if COMP_STUBS | Use passthrough stub backend |
+| `WEBRTC_VAD_MODE` | 2 | Aggressiveness 0–3 |
+| `WEBRTC_VAD_FRAME_MS` | 10 | VAD frame size in ms (10/20/30) |
+
+## Frame accumulation
+
+SOF pipeline periods may be shorter than the VAD frame size. The module
+accumulates channel-0 S16 samples in a ring buffer (`accumulator[]`) and
+calls `classify()` once per full frame, introducing at most `WEBRTC_VAD_FRAME_MS`
+ms of additional latency.
+
+## Status / TODO
+
+- Topology wiring for IPC4 (`.toml` mod_cfg tuning for target platform)
+- `set_configuration` handler for runtime mode/frame-ms changes via IPC
+- Forward VAD decision to host via a SOF IPC notification message
+- Unit test with reference speech/noise WAV files in `west twister`

src/audio/webrtc_vad/llext/CMakeLists.txt

@@ -0,0 +1,28 @@
+# Copyright (c) 2026 Intel Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+if(CONFIG_COMP_WEBRTC_VAD_STUB)
+  # Dependency-free build: SOF glue + passthrough stub backend, no libfvad.
+  sof_llext_build("webrtc_vad"
+    SOURCES ../webrtc_vad.c
+            ../webrtc_vad-stub.c
+    LIB openmodules
+  )
+else()
+  # Real VAD: cross-build libfvad and link it.
+  include(${CMAKE_CURRENT_LIST_DIR}/../webrtc_vad.cmake)
+
+  sof_llext_build("webrtc_vad"
+    SOURCES ../webrtc_vad.c
+            ../webrtc_vad-fvad.c
+            ../webrtc_vad-shims.c
+    INCLUDES "${LIBFVAD_INSTALL_DIR}/include"
+    LIBS_PATH "${LIBFVAD_INSTALL_DIR}/lib"
+    LIBS fvad
+    LIB openmodules
+  )
+
+  # The archive must be built before the module compiles/links against it.
+  add_dependencies(webrtc_vad_llext_lib fvad_ext)
+  add_dependencies(webrtc_vad fvad_ext)
+endif()

src/audio/webrtc_vad/llext/llext.toml.h

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

src/audio/webrtc_vad/webrtc_vad-fvad.c

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2026 Intel Corporation.
+//
+// libfvad backend for the webrtc_vad module.
+//
+// libfvad is a standalone pure-C BSD-3 extraction of the WebRTC GMM Voice
+// Activity Detection algorithm. It operates in Q15 fixed-point and requires
+// no FPU, making it well suited to Xtensa DSPs and Cortex-M class targets.
+//
+// The backend wraps the following minimal libfvad API:
+//
+//   fvad_new()             — allocate a FvadState
+//   fvad_set_mode()        — aggressiveness 0..3
+//   fvad_set_sample_rate() — 8000/16000/32000/48000 Hz
+//   fvad_process()         — classify num_samples of int16 mono audio
+//   fvad_free()            — release FvadState
+//
+// Requires cross-compiled libfvad static library and headers (west module
+// modules/audio/libfvad; see webrtc_vad.cmake for the cross-build recipe).
+// Only compiled when CONFIG_COMP_WEBRTC_VAD_STUB is not selected.
+
+#include <sof/audio/module_adapter/module/generic.h>
+#include <errno.h>
+#include <stdlib.h>
+#include "webrtc_vad.h"
+
+#include <fvad.h>	/* from cross-built libfvad install */
+
+LOG_MODULE_DECLARE(webrtc_vad, CONFIG_SOF_LOG_LEVEL);
+
+static int webrtc_vad_fvad_init(struct processing_module *mod)
+{
+	struct webrtc_vad_comp_data *cd = module_get_private_data(mod);
+	Fvad *fvad;
+
+	fvad = fvad_new();
+	if (!fvad) {
+		comp_err(mod->dev, "webrtc_vad: fvad_new() failed");
+		return -ENOMEM;
+	}
+
+	cd->backend_data = fvad;
+	comp_info(mod->dev, "webrtc_vad: libfvad backend initialised");
+	return 0;
+}
+
+static int webrtc_vad_fvad_configure(struct processing_module *mod,
+				     int sample_rate_hz, int mode)
+{
+	struct webrtc_vad_comp_data *cd = module_get_private_data(mod);
+	Fvad *fvad = cd->backend_data;
+	int ret;
+
+	ret = fvad_set_sample_rate(fvad, sample_rate_hz);
+	if (ret < 0) {
+		comp_err(mod->dev, "webrtc_vad: fvad_set_sample_rate(%d) failed %d",
+			 sample_rate_hz, ret);
+		return -EINVAL;
+	}
+
+	ret = fvad_set_mode(fvad, mode);
+	if (ret < 0) {
+		comp_err(mod->dev, "webrtc_vad: fvad_set_mode(%d) failed %d",
+			 mode, ret);
+		return -EINVAL;
+	}
+
+	comp_info(mod->dev, "webrtc_vad: libfvad rate=%d mode=%d",
+		  sample_rate_hz, mode);
+	return 0;
+}
+
+static int webrtc_vad_fvad_classify(struct processing_module *mod,
+				    const int16_t *samples, int num_samples)
+{
+	struct webrtc_vad_comp_data *cd = module_get_private_data(mod);
+	Fvad *fvad = cd->backend_data;
+	int decision;
+
+	/* fvad_process returns 1 (speech), 0 (non-speech), or <0 on error. */
+	decision = fvad_process(fvad, samples, num_samples);
+	if (decision < 0) {
+		comp_err(mod->dev, "webrtc_vad: fvad_process error %d", decision);
+		return -EIO;
+	}
+
+	return decision;
+}
+
+static int webrtc_vad_fvad_reset(struct processing_module *mod)
+{
+	struct webrtc_vad_comp_data *cd = module_get_private_data(mod);
+	Fvad *fvad = cd->backend_data;
+
+	/* libfvad has no explicit reset API; re-init the state via free+new. */
+	int rate = cd->sample_rate;
+	int mode = CONFIG_WEBRTC_VAD_MODE;
+
+	fvad_free(fvad);
+	fvad = fvad_new();
+	if (!fvad)
+		return -ENOMEM;
+
+	cd->backend_data = fvad;
+	return webrtc_vad_fvad_configure(mod, rate, mode);
+}
+
+static int webrtc_vad_fvad_free(struct processing_module *mod)
+{
+	struct webrtc_vad_comp_data *cd = module_get_private_data(mod);
+
+	if (cd->backend_data) {
+		fvad_free(cd->backend_data);
+		cd->backend_data = NULL;
+	}
+	return 0;
+}
+
+const struct webrtc_vad_backend webrtc_vad_backend = {
+	.name      = "fvad",
+	.init      = webrtc_vad_fvad_init,
+	.configure = webrtc_vad_fvad_configure,
+	.classify  = webrtc_vad_fvad_classify,
+	.reset     = webrtc_vad_fvad_reset,
+	.free      = webrtc_vad_fvad_free,
+};