audio: webrtc_aec: add AECm echo cancellation module

Add the webrtc_aec SOF module wrapping WebRTC AECm (Acoustic Echo
Canceller Mobile) — the fixed-point Q15 echo canceller designed for
mobile and embedded devices.

Module characteristics:
- Dual-source (2 input pins): pin 0 = microphone capture,
  pin 1 = playback echo reference
- Single-sink: echo-cancelled microphone output
- Fixed-point Q15; no FPU required
- Operates at 8 or 16 kHz on 10 ms frames
- Supports S16_LE and S32_LE, up to WEBRTC_AEC_CHANNELS_MAX channels
  (one AecmCore handle per channel)
- Pipeline-ID heuristic (matching google_rtc_audio_processing) used to
  distinguish mic vs. reference at prepare() time
- Two backends: real (AECm) and pass-through stub for CI/LLEXT

Pin binding follows the same pattern as google-rtc-aec: both DAI
capture copiers are connected as sources; the firmware resolves
mic-vs-ref from pipeline membership.

Reference topology: tools/topology/topology2/development/
  cavs-nocodec-webrtc-aec.conf (dual SSP: SSP0=mic, SSP2=ref)

UUID: e5da7b5b-133a-ba46-b517651d6300bb83

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

Author: lrgirdwo

src/audio/webrtc_aec/CMakeLists.txt

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

src/audio/webrtc_aec/Kconfig

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+config COMP_WEBRTC_AEC
+	tristate "WebRTC AECm — fixed-point Acoustic Echo Canceller"
+	help
+	  Select to include the WebRTC AECm (Mobile) acoustic echo canceller.
+	  AECm is a fixed-point Q15 implementation derived from the WebRTC
+	  audio processing library. It requires no floating-point unit and is
+	  well suited to Xtensa HiFi3/HiFi4 class DSPs.
+
+	  The module accepts two input streams (2 input pins):
+	    Pin 0 — microphone capture (same pipeline as the output)
+	    Pin 1 — playback echo reference (from the render pipeline)
+	  and produces one denoised microphone output stream.
+
+	  This module is intended as an open-source drop-in replacement for
+	  the google_rtc_audio_processing module that requires a proprietary
+	  library. Both implement the same two-input / one-output topology so
+	  topologies are interchangeable.
+
+	  The real backend requires webrtc-audio-processing 0.3.x source
+	  (west module modules/audio/webrtc-apm, same as COMP_WEBRTC_NS).
+	  For CI/testing without that source, select COMP_WEBRTC_AEC_STUB.
+
+if COMP_WEBRTC_AEC
+
+config COMP_WEBRTC_AEC_STUB
+	bool "WebRTC AECm stub backend (no WebRTC source dependency)"
+	default y if COMP_STUBS
+	help
+	  Build the webrtc_aec module against a dependency-free stub backend
+	  that passes microphone audio through without modification. Useful
+	  for CI validation, topology testing, and LLEXT packaging without
+	  the cross-built WebRTC AECm archive.
+
+config WEBRTC_AEC_FILTER_LEN_MS
+	int "AECm adaptive filter length in ms (32, 64 or 128)"
+	default 64
+	help
+	  Length of the adaptive echo-cancellation filter. Longer filters
+	  can handle larger acoustic echo delays (e.g. in rooms with long
+	  reverb tails) at the cost of increased memory and CPU.
+	  Valid values: 32, 64, 128.
+
+config WEBRTC_AEC_SUPPRESSION_LEVEL
+	int "AECm comfort-noise suppression level (0=off, 1=low, 2=medium)"
+	range 0 2
+	default 1
+	help
+	  Controls how aggressively residual echo / background noise is
+	  suppressed in the CNG (comfort noise generator) post-filter:
+	    0 - disabled (only echo suppression, no CNG)
+	    1 - low suppression (recommended)
+	    2 - medium suppression
+
+config WEBRTC_AEC_SAMPLE_RATE_HZ
+	int "AECm processing sample rate in Hz"
+	default 16000
+	help
+	  AECm operates at 8000 or 16000 Hz. When the pipeline runs at a
+	  higher rate (e.g. 48 kHz), the module downsamples before AEC
+	  processing and upsamples afterward. 16 kHz is recommended for
+	  best echo suppression quality.
+	  Valid values: 8000, 16000.
+
+endif # COMP_WEBRTC_AEC

src/audio/webrtc_aec/llext/CMakeLists.txt

@@ -0,0 +1,24 @@
+# Copyright (c) 2026 Intel Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+if(CONFIG_COMP_WEBRTC_AEC_STUB)
+  sof_llext_build("webrtc_aec"
+    SOURCES ../webrtc_aec.c
+            ../webrtc_aec-stub.c
+    LIB openmodules
+  )
+else()
+  include(${CMAKE_CURRENT_LIST_DIR}/../webrtc_aec.cmake)
+
+  sof_llext_build("webrtc_aec"
+    SOURCES ../webrtc_aec.c
+            ../webrtc_aec-aecm.c
+    INCLUDES "${WEBRTC_AECM_INSTALL_DIR}/include"
+    LIBS_PATH "${WEBRTC_AECM_INSTALL_DIR}/lib"
+    LIBS webrtc_aecm
+    LIB openmodules
+  )
+
+  add_dependencies(webrtc_aec_llext_lib webrtc_aecm_ext)
+  add_dependencies(webrtc_aec webrtc_aecm_ext)
+endif()

src/audio/webrtc_aec/llext/llext.toml.h

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

src/audio/webrtc_aec/webrtc_aec-aecm.c

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2026 Intel Corporation.
+//
+// Real AECm backend for the webrtc_aec module.
+//
+// Wraps WebRtcAecm_Create/Init/BufferFarend/Process from the WebRTC AECm
+// (Mobile) fixed-point library extracted from webrtc-audio-processing 0.3.x.
+//
+// API summary:
+//   WebRtcAecm_Create()       — allocate AecmCore handle
+//   WebRtcAecm_Init()         — configure sample rate (8000 or 16000 Hz)
+//   WebRtcAecm_BufferFarend() — queue 10 ms of echo reference (far-end)
+//   WebRtcAecm_Process()      — cancel echo from near-end mic frame
+//   WebRtcAecm_Enable()       — configure filter length and CNG suppression
+//   WebRtcAecm_Free()         — release handle
+//
+// All operations are Q15 fixed-point on int16_t. One handle per channel.
+
+#include <sof/audio/module_adapter/module/generic.h>
+#include <errno.h>
+#include "webrtc_aec.h"
+
+#include <echo_control_mobile.h>   /* from cross-built webrtc-audio-processing 0.3.x */
+
+LOG_MODULE_DECLARE(webrtc_aec, CONFIG_SOF_LOG_LEVEL);
+
+struct webrtc_aec_real_data {
+	void   *aecm[WEBRTC_AEC_CHANNELS_MAX];
+	int     num_channels;
+	int     filter_len_ms;
+	int     suppression;
+};
+
+static int webrtc_aec_real_init(struct processing_module *mod)
+{
+	struct webrtc_aec_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_aec_real_data *rd;
+
+	rd = mod_zalloc(mod, sizeof(*rd));
+	if (!rd)
+		return -ENOMEM;
+
+	cd->backend_data = rd;
+	comp_info(mod->dev, "webrtc_aec: AECm real backend initialised");
+	return 0;
+}
+
+static int webrtc_aec_real_configure(struct processing_module *mod, int sample_rate_hz,
+				     int filter_len_ms, int suppression, int num_channels)
+{
+	struct webrtc_aec_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_aec_real_data *rd = cd->backend_data;
+	AecmConfig config;
+	int c, ret;
+
+	/* Free previously allocated handles. */
+	for (c = 0; c < rd->num_channels; c++) {
+		if (rd->aecm[c]) {
+			WebRtcAecm_Free(rd->aecm[c]);
+			rd->aecm[c] = NULL;
+		}
+	}
+	rd->num_channels  = 0;
+	rd->filter_len_ms = filter_len_ms;
+	rd->suppression   = suppression;
+
+	for (c = 0; c < num_channels; c++) {
+		rd->aecm[c] = WebRtcAecm_Create();
+		if (!rd->aecm[c]) {
+			comp_err(mod->dev, "webrtc_aec: WebRtcAecm_Create() failed ch%d", c);
+			goto err;
+		}
+
+		ret = WebRtcAecm_Init(rd->aecm[c], sample_rate_hz);
+		if (ret) {
+			comp_err(mod->dev,
+				 "webrtc_aec: WebRtcAecm_Init(ch%d, %d) failed %d",
+				 c, sample_rate_hz, ret);
+			goto err;
+		}
+
+		config.cngMode         = suppression;
+		config.echoMode        = (filter_len_ms == 128) ? 4 :
+					 (filter_len_ms == 64)  ? 3 :
+					 (filter_len_ms == 32)  ? 2 : 3;
+		ret = WebRtcAecm_set_config(rd->aecm[c], config);
+		if (ret) {
+			comp_err(mod->dev, "webrtc_aec: set_config ch%d failed %d", c, ret);
+			goto err;
+		}
+	}
+
+	rd->num_channels = num_channels;
+	comp_info(mod->dev, "webrtc_aec: AECm rate=%d filter=%dms cng=%d ch=%d",
+		  sample_rate_hz, filter_len_ms, suppression, num_channels);
+	return 0;
+
+err:
+	for (c = 0; c < num_channels; c++) {
+		if (rd->aecm[c]) {
+			WebRtcAecm_Free(rd->aecm[c]);
+			rd->aecm[c] = NULL;
+		}
+	}
+	return -ENOMEM;
+}
+
+static int webrtc_aec_real_process_ch(struct processing_module *mod,
+				      const int16_t *mic, const int16_t *ref, int16_t *out,
+				      int frame_samples, int ch)
+{
+	struct webrtc_aec_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_aec_real_data *rd = cd->backend_data;
+	int ret;
+
+	/* Queue the far-end (reference/playback) frame first. */
+	ret = WebRtcAecm_BufferFarend(rd->aecm[ch], ref, frame_samples);
+	if (ret) {
+		comp_err(mod->dev, "webrtc_aec: BufferFarend ch%d failed %d", ch, ret);
+		return ret;
+	}
+
+	/* Process near-end (mic) and produce echo-cancelled output.
+	 * The third parameter (near_end_noiseless) can be NULL. */
+	ret = WebRtcAecm_Process(rd->aecm[ch], mic, NULL, out, frame_samples, 0);
+	if (ret) {
+		comp_err(mod->dev, "webrtc_aec: Process ch%d failed %d", ch, ret);
+		return ret;
+	}
+
+	return 0;
+}
+
+static int webrtc_aec_real_reset(struct processing_module *mod)
+{
+	struct webrtc_aec_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_aec_real_data *rd = cd->backend_data;
+	int c, ret;
+
+	for (c = 0; c < rd->num_channels; c++) {
+		if (!rd->aecm[c])
+			continue;
+		ret = WebRtcAecm_Init(rd->aecm[c], cd->proc_rate);
+		if (ret)
+			comp_warn(mod->dev, "webrtc_aec: reset ch%d failed %d", c, ret);
+	}
+	return 0;
+}
+
+static int webrtc_aec_real_free(struct processing_module *mod)
+{
+	struct webrtc_aec_comp_data *cd = module_get_private_data(mod);
+	struct webrtc_aec_real_data *rd = cd->backend_data;
+	int c;
+
+	if (!rd)
+		return 0;
+
+	for (c = 0; c < rd->num_channels; c++) {
+		if (rd->aecm[c]) {
+			WebRtcAecm_Free(rd->aecm[c]);
+			rd->aecm[c] = NULL;
+		}
+	}
+	mod_free(mod, rd);
+	cd->backend_data = NULL;
+	return 0;
+}
+
+const struct webrtc_aec_backend webrtc_aec_backend = {
+	.name       = "aecm",
+	.init       = webrtc_aec_real_init,
+	.configure  = webrtc_aec_real_configure,
+	.process_ch = webrtc_aec_real_process_ch,
+	.reset      = webrtc_aec_real_reset,
+	.free       = webrtc_aec_real_free,
+};

src/audio/webrtc_aec/webrtc_aec-stub.c

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2026 Intel Corporation.
+//
+// Stub backend for webrtc_aec: passes mic audio through unchanged.
+// Reference audio is consumed and discarded.
+
+#include <sof/audio/module_adapter/module/generic.h>
+#include <rtos/string.h>
+#include <errno.h>
+#include "webrtc_aec.h"
+
+LOG_MODULE_DECLARE(webrtc_aec, CONFIG_SOF_LOG_LEVEL);
+
+static int webrtc_aec_stub_init(struct processing_module *mod)
+{
+	comp_info(mod->dev, "webrtc_aec stub: no AECm library linked");
+	return 0;
+}
+
+static int webrtc_aec_stub_configure(struct processing_module *mod, int sample_rate_hz,
+				     int filter_len_ms, int suppression, int num_channels)
+{
+	comp_info(mod->dev, "webrtc_aec stub: rate=%d filter=%dms sup=%d ch=%d (ignored)",
+		  sample_rate_hz, filter_len_ms, suppression, num_channels);
+	return 0;
+}
+
+static int webrtc_aec_stub_process_ch(struct processing_module *mod,
+				      const int16_t *mic, const int16_t *ref, int16_t *out,
+				      int frame_samples, int ch)
+{
+	/* Pass mic straight to output; ref is silently discarded. */
+	memcpy(out, mic, (size_t)frame_samples * sizeof(int16_t));
+	(void)ref;
+	(void)ch;
+	return 0;
+}
+
+static int webrtc_aec_stub_reset(struct processing_module *mod)
+{
+	(void)mod;
+	return 0;
+}
+
+static int webrtc_aec_stub_free(struct processing_module *mod)
+{
+	(void)mod;
+	return 0;
+}
+
+const struct webrtc_aec_backend webrtc_aec_backend = {
+	.name       = "stub",
+	.init       = webrtc_aec_stub_init,
+	.configure  = webrtc_aec_stub_configure,
+	.process_ch = webrtc_aec_stub_process_ch,
+	.reset      = webrtc_aec_stub_reset,
+	.free       = webrtc_aec_stub_free,
+};