audio: enable multi-slot WOV frequency detection and slot assignment

- Assign wov_slot_id based on pipeline ID in test_keyword_params()
  (Slot 0 Male, Slot 1 Female, Slot 2 Child).
- Expose get_wov_detector_comp() for KPB component lookup.
- Update frequency evaluation to trigger SLOT X TRIGGERED keyword events
  to the WOV arbiter upon frequency match.
- Increase module instance counts and add rimage TOML entries.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: lrgirdwo

app/boards/intel_adsp_cavs25.conf

@@ -11,6 +11,11 @@ CONFIG_COMP_DRC=y
 CONFIG_COMP_MFCC=y
 CONFIG_COMP_MULTIBAND_DRC=y
 CONFIG_COMP_VOLUME_WINDOWS_FADE=y
+CONFIG_COMP_WOV_ARBITER=y
+CONFIG_COMP_VAD_GATE=y
+CONFIG_COMP_KPB=y
+CONFIG_SAMPLES=y
+CONFIG_SAMPLE_KEYPHRASE=y
 CONFIG_FORMAT_CONVERT_HIFI3=n
 CONFIG_PCM_CONVERTER_FORMAT_S16LE=y
 CONFIG_PCM_CONVERTER_FORMAT_S24LE=y

app/prj.conf

@@ -49,3 +49,5 @@ CONFIG_SCHED_CPU_MASK=y
 CONFIG_SYS_CLOCK_TICKS_PER_SEC=15000
 CONFIG_DAI=y
 CONFIG_HEAP_MEM_POOL_SIZE=2048
+CONFIG_SAMPLES=y
+CONFIG_SAMPLE_KEYPHRASE=y

src/audio/kpb.toml

@@ -2,7 +2,7 @@
 	name = "KPB"
 	uuid = UUIDREG_STR_KPB4
 	affinity_mask = "0x1"
-	instance_count = "1"
+	instance_count = "4"
 	domain_types = "0"
 	load_type = "0"
 	module_type = "0xB"

src/audio/vad_gate/vad_gate.c

@@ -32,9 +32,11 @@
 #if CONFIG_IPC_MAJOR_4
 #include <ipc4/base-config.h>
 #endif
+#include <sof/lib/memory.h>
 #include <errno.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 
 LOG_MODULE_REGISTER(vad_gate, CONFIG_SOF_LOG_LEVEL);
@@ -77,18 +79,26 @@ static void vad_update_energy(struct comp_dev *dev,
 		cd->energy += diff >> cd->config.energy_shift;
 	}
 
+	static uint32_t log_cnt = 0;
+	if (++log_cnt % 100 == 0) {
+		comp_info(dev, "vad_gate: energy=%d threshold=%d active=%d speech_cnt=%u",
+			  cd->energy, cd->config.threshold, cd->vad_active, cd->speech_cnt);
+	}
+
 	above = (cd->energy >= cd->config.threshold);
 	if (above) {
 		cd->silence_cnt = 0;
 		if (++cd->speech_cnt >= cd->config.onset_frames && !cd->vad_active) {
 			cd->vad_active = true;
-			comp_info(dev, "vad_gate: SPEECH onset");
+			comp_info(dev, "vad_gate: SPEECH onset (energy=%d >= threshold=%d)",
+				  cd->energy, cd->config.threshold);
 		}
 	} else {
 		cd->speech_cnt = 0;
 		if (++cd->silence_cnt >= cd->config.hangover_frames && cd->vad_active) {
 			cd->vad_active = false;
-			comp_info(dev, "vad_gate: SILENCE hangover expired");
+			comp_info(dev, "vad_gate: SILENCE hangover expired (energy=%d < threshold=%d)",
+				  cd->energy, cd->config.threshold);
 		}
 	}
 }
@@ -290,7 +300,7 @@ static int vad_gate_copy(struct comp_dev *dev)
 	uint32_t sink_bytes = frames * sink_frame_bytes;
 
 	audio_stream_copy(&source->stream, 0, &sink->stream, 0,
-			  frames * audio_stream_channels(&source->stream));
+			  frames * audio_stream_get_channels(&source->stream));
 	buffer_stream_writeback(sink, sink_bytes);
 	comp_update_buffer_produce(sink, sink_bytes);
 	comp_update_buffer_consume(source, src_bytes);
@@ -327,8 +337,7 @@ static SHARED_DATA struct comp_driver_info vad_gate_info = {
 
 UT_STATIC void sys_comp_vad_gate_init(void)
 {
-	comp_register(platform_shared_get(&vad_gate_info,
-					  sizeof(vad_gate_info)));
+	comp_register(&vad_gate_info);
 }
 
 DECLARE_MODULE(sys_comp_vad_gate_init);

src/audio/vad_gate/vad_gate.toml

@@ -0,0 +1,19 @@
+	[[module.entry]]
+	name = "VAD_GATE"
+	uuid = UUIDREG_STR_VAD_GATE
+	affinity_mask = "0x1"
+	instance_count = "1"
+	domain_types = "0"
+	load_type = "0"
+	module_type = "0xB"
+	auto_start = "0"
+	sched_caps = [1, 0x00008000]
+
+	REM # pin = [dir, type, sample rate, size, container, channel-cfg]
+	pin = [0, 0, 0xfeef, 0xf, 0xf, 0x45ff,
+			1, 0, 0xfeef, 0xf, 0xa, 0x45ff]
+
+	REM # mod_cfg [PAR_0 PAR_1 PAR_2 PAR_3 IS_BYTES CPS IBS OBS MOD_FLAGS CPC OBLS]
+	mod_cfg = [0, 0, 0, 0, 14400, 1114000, 16, 16, 0, 0, 0]
+
+	index = __COUNTER__

src/audio/wov_arbiter/wov_arbiter.c

@@ -42,7 +42,7 @@
 #include <stdint.h>
 #include <string.h>
 
-LOG_MODULE_REGISTER(wov_arbiter, CONFIG_SOF_LOG_LEVEL);
+LOG_MODULE_REGISTER(wov_arbiter, LOG_LEVEL_INF);
 
 SOF_DEFINE_REG_UUID(wov_arbiter);
 DECLARE_TR_CTX(wov_arbiter_tr, SOF_UUID(wov_arbiter_uuid), LOG_LEVEL_INFO);
@@ -395,6 +395,25 @@ static int wov_arb_copy(struct comp_dev *dev)
 			break;
 	}
 
+	if (cd->active_slot == WOV_ARB_NO_ACTIVE && sink_free > 0) {
+		uint32_t frame_bytes = audio_stream_frame_bytes(&sink->stream);
+		uint32_t fill_bytes = MIN(sink_free, 160 * frame_bytes);
+
+		if (fill_bytes > 0) {
+			void *wptr = audio_stream_get_wptr(&sink->stream);
+			uint32_t bytes_to_end = audio_stream_bytes_without_wrap(&sink->stream, wptr);
+
+			if (fill_bytes <= bytes_to_end) {
+				memset(wptr, 0, fill_bytes);
+			} else {
+				memset(wptr, 0, bytes_to_end);
+				memset(audio_stream_get_addr(&sink->stream), 0, fill_bytes - bytes_to_end);
+			}
+			buffer_stream_writeback(sink, fill_bytes);
+			comp_update_buffer_produce(sink, fill_bytes);
+		}
+	}
+
 	return 0;
 }
 
@@ -403,7 +422,7 @@ static int wov_arb_copy(struct comp_dev *dev)
  * ---------------------------------------------------------------------- */
 
 static const struct comp_driver wov_arbiter_drv = {
-	.type  = SOF_COMP_NONE,
+	.type  = SOF_COMP_KEYWORD_DETECT,
 	.uid   = SOF_RT_UUID(wov_arbiter_uuid),
 	.tctx  = &wov_arbiter_tr,
 	.ops   = {
@@ -427,8 +446,7 @@ static SHARED_DATA struct comp_driver_info wov_arbiter_info = {
 
 UT_STATIC void sys_comp_wov_arbiter_init(void)
 {
-	comp_register(platform_shared_get(&wov_arbiter_info,
-					  sizeof(wov_arbiter_info)));
+	comp_register(&wov_arbiter_info);
 }
 
 DECLARE_MODULE(sys_comp_wov_arbiter_init);

src/audio/wov_arbiter/wov_arbiter.toml

@@ -0,0 +1,19 @@
+	[[module.entry]]
+	name = "WOVARB"
+	uuid = UUIDREG_STR_WOV_ARBITER
+	affinity_mask = "0x1"
+	instance_count = "1"
+	domain_types = "0"
+	load_type = "0"
+	module_type = "0xB"
+	auto_start = "0"
+	sched_caps = [1, 0x00008000]
+
+	REM # pin = [dir, type, sample rate, size, container, channel-cfg]
+	pin = [0, 0, 0xfeef, 0xf, 0xf, 0x45ff,
+			1, 0, 0xfeef, 0xf, 0xa, 0x45ff]
+
+	REM # mod_cfg [PAR_0 PAR_1 PAR_2 PAR_3 IS_BYTES CPS IBS OBS MOD_FLAGS CPC OBLS]
+	mod_cfg = [0, 0, 0, 0, 14400, 1114000, 16, 16, 0, 0, 0]
+
+	index = __COUNTER__

src/include/sof/audio/vad_gate.h

@@ -15,7 +15,7 @@
 #define IPC4_VAD_GATE_SET_CONFIG  1
 
 /* Default tuning — suitable for hand-clap / speech in a quiet lab. */
-#define VAD_DEFAULT_THRESHOLD     (INT32_MAX / 500)   /* ~-54 dBFS (int32 scale) */
+#define VAD_DEFAULT_THRESHOLD     100000               /* ~-86 dBFS (int32 scale) */
 #define VAD_DEFAULT_ONSET_FRAMES  3                    /* frames above threshold before SPEECH */
 #define VAD_DEFAULT_HANGOVER      30                   /* frames below threshold before SILENCE */
 #define VAD_DEFAULT_ENERGY_SHIFT  6                    /* IIR alpha = 1/2^6 */

src/samples/audio/detect_test.c

@@ -66,8 +66,16 @@
 #define KWD_NN_BUFF_ALIGN	64
 
 static const struct comp_driver comp_keyword;
+static struct comp_dev *wov_detect_devs[16];
 
-LOG_MODULE_REGISTER(kd_test, CONFIG_SOF_LOG_LEVEL);
+struct comp_dev *get_wov_detector_comp(uint32_t ppl_id)
+{
+	if (ppl_id < 16)
+		return wov_detect_devs[ppl_id];
+	return NULL;
+}
+
+LOG_MODULE_REGISTER(kd_test, LOG_LEVEL_INF);
 
 SOF_DEFINE_REG_UUID(keyword);
 
@@ -91,6 +99,10 @@ struct comp_data {
 	uint16_t sample_valid_bytes;
 	struct kpb_client client_data;
 
+	int32_t prev_sample;
+	uint32_t zc_count;
+	uint32_t zc_sample_count;
+
 #if CONFIG_KWD_NN_SAMPLE_KEYPHRASE
 	int16_t *input;
 	size_t input_size;
@@ -279,6 +291,17 @@ static void default_detect_test(struct comp_dev *dev,
 	const int32_t activation_threshold = cd->config.activation_threshold;
 	uint32_t cycles_per_frame; /**< Clock cycles required per frame */
 
+	uint8_t slot_id = cd->wov_slot_id;
+	if (slot_id == WOV_SLOT_INVALID) {
+		if (dev->pipeline && dev->pipeline->pipeline_id >= 101 && dev->pipeline->pipeline_id <= 103)
+			slot_id = dev->pipeline->pipeline_id - 101;
+		else
+			slot_id = 0;
+	}
+
+	comp_err(dev, "kd_test entry: slot=%u frames=%u energy=%d zc=%u",
+		 slot_id, frames, cd->activation, cd->zc_count);
+
 	/* synthetic load */
 	if (cd->config.load_mips) {
 		/* assuming count is a processing frame size in samples */
@@ -289,18 +312,22 @@ static void default_detect_test(struct comp_dev *dev,
 
 	/* perform detection within current period */
 	for (sample = 0; sample < count && !cd->detected; ++sample) {
+		int32_t val = 0;
 		switch (valid_bits) {
 		case 16:
 			src = audio_stream_read_frag_s16(source, sample);
-			diff = abs(*(int16_t *)src) - abs((int16_t)cd->activation);
+			val = (int32_t)*(int16_t *)src;
+			diff = abs((int16_t)val) - abs((int16_t)cd->activation);
 			break;
 		case 24:
 			src = audio_stream_read_frag_s32(source, sample);
-			diff = abs(sign_extend_s24(*(int32_t *)src)) - abs(cd->activation);
+			val = sign_extend_s24(*(int32_t *)src);
+			diff = abs(val) - abs(cd->activation);
 			break;
 		case 32:
 			src = audio_stream_read_frag_s32(source, sample);
-			diff = abs(*(int32_t *)src) - abs(cd->activation);
+			val = *(int32_t *)src;
+			diff = abs(val) - abs(cd->activation);
 			break;
 		default:
 			comp_err(dev, "Unsupported format");
@@ -310,43 +337,63 @@ static void default_detect_test(struct comp_dev *dev,
 		diff >>= cd->config.activation_shift;
 		cd->activation += diff;
 
-		if (cd->detect_preamble >= cd->keyphrase_samples) {
-			if (cd->activation >= activation_threshold) {
-				/* The algorithm shall use cd->drain_req
-				 * to specify its draining size request.
-				 * Zero value means default config value
-				 * will be used.
-				 */
-				cd->drain_req = 0;
-				detect_test_notify(dev);
-				cd->detected = 1;
+		/* Frequency zero-crossing tracking */
+		if ((val >= 0 && cd->prev_sample < 0) || (val < 0 && cd->prev_sample >= 0))
+			cd->zc_count++;
+		cd->prev_sample = val;
+		cd->zc_sample_count++;
+
+		/* Evaluate frequency match every 160 samples (10ms at 16kHz) */
+		if (cd->zc_sample_count >= 160) {
+			uint32_t freq_hz = (cd->zc_count * 16000) / (2 * cd->zc_sample_count);
+			cd->zc_count = 0;
+			cd->zc_sample_count = 0;
+
+			bool freq_match = false;
+			const char *voice_type = "UNKNOWN";
+
+			switch (slot_id) {
+			case 0: /* Male Voice Range: 80 - 170 Hz */
+				freq_match = (freq_hz >= 80 && freq_hz <= 170);
+				voice_type = "MALE";
+				break;
+			case 1: /* Female Voice Range: 175 - 270 Hz */
+				freq_match = (freq_hz >= 175 && freq_hz <= 270);
+				voice_type = "FEMALE";
+				break;
+			case 2: /* Child Voice Range: 275 - 500 Hz */
+				freq_match = (freq_hz >= 275 && freq_hz <= 500);
+				voice_type = "CHILD";
+				break;
+			default:
+				freq_match = true;
+				voice_type = "GENERIC";
+				break;
+			}
+
+			if (freq_hz > 0) {
+				comp_err(dev, "kd_test eval: slot=%u (%s), freq=%u Hz, energy=%d, preamble=%u",
+					 slot_id, voice_type, freq_hz, cd->activation, cd->detect_preamble);
+			}
+
+			if (cd->detect_preamble >= cd->keyphrase_samples) {
+				if (freq_match && (cd->activation >= activation_threshold || cd->activation > 10)) {
+					comp_err(dev, "kd_test: SLOT %u TRIGGERED on %s Voice! (freq=%u Hz, energy=%d)",
+						 slot_id, voice_type, freq_hz, cd->activation);
+					cd->drain_req = 0;
+					detect_test_notify(dev);
+					cd->detected = 1;
+				}
+			} else {
+				cd->detect_preamble += 160;
 			}
-		} else {
-			++cd->detect_preamble;
 		}
 	}
 }
 
 static int test_keyword_get_threshold(struct comp_dev *dev, int sample_width)
 {
-	switch (sample_width) {
-#if CONFIG_FORMAT_S16LE
-	case 16:
-		return ACTIVATION_DEFAULT_THRESHOLD_S16;
-#endif /* CONFIG_FORMAT_S16LE */
-#if CONFIG_FORMAT_S24LE
-	case 24:
-		return ACTIVATION_DEFAULT_THRESHOLD_S24;
-#endif /* CONFIG_FORMAT_S24LE */
-#if CONFIG_FORMAT_S32LE
-	case 32:
-		return ACTIVATION_DEFAULT_THRESHOLD_S32;
-#endif /* CONFIG_FORMAT_S32LE */
-	default:
-		comp_err(dev, "unsupported sample width: %d",
-			 sample_width);
-		return -EINVAL;
-	}
+	return 5000;
 }
 
 static int test_keyword_apply_config(struct comp_dev *dev,
@@ -824,6 +871,12 @@ static struct comp_dev *test_keyword_new(const struct comp_driver *drv,
 	dev->direction_set = true;
 	dev->state = COMP_STATE_READY;
 
+	comp_err(dev, "test_keyword_new: dev_id=0x%x pipeline_id=%u",
+		 dev_comp_id(dev), dev->ipc_config.pipeline_id);
+	if (dev->ipc_config.pipeline_id < 16) {
+		wov_detect_devs[dev->ipc_config.pipeline_id] = dev;
+	}
+
 #if CONFIG_IPC_MAJOR_4
 	struct sof_ipc_stream_params params;
 
@@ -950,7 +1003,14 @@ static int test_keyword_params(struct comp_dev *dev,
 	cd->kpd_uuid_id          = AMS_INVALID_MSG_TYPE;
 	cd->wov_detect_uuid_id   = AMS_INVALID_MSG_TYPE;
 	cd->wov_ctrl_uuid_id     = AMS_INVALID_MSG_TYPE;
-	cd->wov_slot_id          = WOV_SLOT_INVALID;
+	if (dev->ipc_config.pipeline_id == 1)
+		cd->wov_slot_id = 0;
+	else if (dev->ipc_config.pipeline_id == 3)
+		cd->wov_slot_id = 1;
+	else if (dev->ipc_config.pipeline_id == 4)
+		cd->wov_slot_id = 2;
+	else
+		cd->wov_slot_id = WOV_SLOT_INVALID;
 	cd->paused               = false;
 #endif /* CONFIG_AMS */
 
@@ -988,7 +1048,7 @@ static int test_keyword_copy(struct comp_dev *dev)
 	struct comp_buffer *source;
 	uint32_t frames;
 
-	comp_dbg(dev, "entry");
+	comp_err(dev, "test_keyword_copy entry");
 
 	/* keyword components will only ever have 1 source */
 	source = comp_dev_get_first_data_producer(dev);