Audio: Sound Dose: Add new component

This patch adds a new SOF component Sound Dose. The purpose is
to calculate for audio playback MEL values (momentary sound
exposure level) to provide to user space the data to compute the
sound dose CSD as defined in EN 50332-3.

Signed-off-by: Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>

Author: singalsu

src/audio/CMakeLists.txt

@@ -120,6 +120,9 @@ if(NOT CONFIG_COMP_MODULE_SHARED_LIBRARY_BUILD)
 		list(APPEND base_files host-legacy.c)
 		sof_list_append_ifdef(CONFIG_COMP_DAI base_files dai-legacy.c)
 	endif()
+	if(CONFIG_COMP_SOUND_DOSE)
+		add_subdirectory(sound_dose)
+	endif()
 	if(CONFIG_COMP_TEMPLATE_COMP)
 		add_subdirectory(template_comp)
 	endif()

src/audio/Kconfig

@@ -168,6 +168,8 @@ rsource "mfcc/Kconfig"
 
 rsource "codec/Kconfig"
 
+rsource "sound_dose/Kconfig"
+
 rsource "template_comp/Kconfig"
 
 endmenu # "Audio components"

src/audio/sound_dose/CMakeLists.txt

@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(CONFIG_COMP_TEMPLATE_COMP STREQUAL "m")
+  add_subdirectory(llext ${PROJECT_BINARY_DIR}/sound_dose_llext)
+  add_dependencies(app sound_dose)
+else()
+  add_local_sources(sof sound_dose.c)
+  add_local_sources(sof sound_dose-generic.c)
+
+  if(CONFIG_IPC_MAJOR_3)
+    add_local_sources(sof sound_dose-ipc3.c)
+  elseif(CONFIG_IPC_MAJOR_4)
+    add_local_sources(sof sound_dose-ipc4.c)
+  endif()
+endif()

src/audio/sound_dose/Kconfig

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+config COMP_SOUND_DOSE
+	tristate "Sound Dose module"
+	default y
+	help
+	  Select this for Sound Dose SOF module. The purpose is
+	  to calculate for audio playback MEL values (momentary
+	  sound exposure level) to provide to user space the data
+	  to compute the sound dose CSD as defined in EN 50332-3.

src/audio/sound_dose/llext/CMakeLists.txt

@@ -0,0 +1,7 @@
+# Copyright (c) 2025 Intel Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+sof_llext_build("template_comp"
+	SOURCES ../sound_dose.c
+	LIB openmodules
+)

src/audio/sound_dose/llext/llext.toml.h

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

src/audio/sound_dose/sound_dose-generic.c

@@ -0,0 +1,330 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2025 Intel Corporation.
+
+#include <sof/audio/module_adapter/module/generic.h>
+#include <sof/audio/component.h>
+#include <sof/audio/sink_api.h>
+#include <sof/audio/sink_source_utils.h>
+#include <sof/audio/source_api.h>
+#include <sof/math/log.h>
+#include <sof/math/iir_df1.h>
+#include <user/eq.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "sound_dose.h"
+#include "sound_dose_iir_48k.h"
+
+LOG_MODULE_DECLARE(sound_dose, CONFIG_SOF_LOG_LEVEL);
+
+int sound_dose_filters_init(struct processing_module *mod)
+{
+	struct sound_dose_comp_data *cd = module_get_private_data(mod);
+	struct comp_dev *dev = mod->dev;
+	struct sof_abi_hdr *blob;
+	struct sof_eq_iir_config *iir_config;
+	struct sof_eq_iir_header *iir_coef;
+	size_t iir_size, alloc_size;
+	int32_t *data;
+	int i;
+
+	/* Initialize FIR */
+	switch (cd->rate) {
+	case 48000:
+		blob = (struct sof_abi_hdr *)sound_dose_iir_48k;
+		iir_config = (struct sof_eq_iir_config *)blob->data;
+		cd->log_offset_for_mean = SOUND_DOSE_LOG2_INV_48K_Q16;
+		break;
+	default:
+		/* TODO: Add 44100 rate handling and integer ratio decimation code from
+		 * e.g. 96 kHz to 48 kHz. The A-weight is not defined above 20 kHz, so
+		 * high frequency energy is not needed. Also it will help keep the
+		 * module load reasonable.
+		 */
+		comp_err(dev, "error: unsupported sample rate %d", cd->rate);
+		return -EINVAL;
+	}
+
+	/* Apply the first responses in the blobs */
+	iir_coef = (struct sof_eq_iir_header *)&iir_config->data[iir_config->channels_in_config];
+	iir_size = iir_delay_size_df1(iir_coef);
+	alloc_size = cd->channels * iir_size;
+	cd->delay_lines = rzalloc(SOF_MEM_ZONE_RUNTIME, 0, SOF_MEM_CAPS_RAM, alloc_size);
+	if (!cd->delay_lines) {
+		comp_err(dev, "Failed to allocate memory for weighting filters.");
+		return -ENOMEM;
+	}
+
+	data = cd->delay_lines;
+	for (i = 0; i < cd->channels; i++) {
+		iir_init_coef_df1(&cd->iir[i], iir_coef);
+		iir_init_delay_df1(&cd->iir[i], &data);
+		cd->energy[i] = 0;
+	}
+
+	cd->frames_count = 0;
+	cd->report_count = cd->rate; /* report every 1s, for 48k frames */
+	return 0;
+}
+
+void sound_dose_filters_free(struct sound_dose_comp_data *cd)
+{
+	rfree(cd->delay_lines);
+}
+
+#if CONFIG_FORMAT_S16LE
+
+/**
+ * sound_dose_s16() - Process S16_LE format.
+ * @mod: Pointer to module data.
+ * @source: Source for PCM samples data.
+ * @sink: Sink for PCM samples data.
+ * @frames: Number of audio data frames to process.
+ *
+ * This is the processing function for 16-bit signed integer PCM formats. The
+ * audio samples in every frame are re-order to channels order defined in
+ * component data channel_map[].
+ *
+ * Return: Value zero for success, otherwise an error code.
+ */
+static int sound_dose_s16(const struct processing_module *mod,
+			  struct sof_source *source,
+			  struct sof_sink *sink,
+			  uint32_t frames)
+{
+	struct sound_dose_comp_data *cd = module_get_private_data(mod);
+	int16_t const *x, *x_start, *x_end;
+	int16_t *y, *y_start, *y_end;
+	int x_size, y_size;
+	int source_samples_without_wrap;
+	int samples_without_wrap;
+	int samples = frames * cd->channels;
+	int bytes = frames * cd->frame_bytes;
+	int ret;
+	int ch;
+	int i;
+
+	/* Get pointer to source data in circular buffer, get buffer start and size to
+	 * check for wrap. The size in bytes is converted to number of s16 samples to
+	 * control the samples process loop. If the number of bytes requested is not
+	 * possible, an error is returned.
+	 */
+	ret = source_get_data_s16(source, bytes, &x, &x_start, &x_size);
+	if (ret)
+		return ret;
+
+	/* Similarly get pointer to sink data in circular buffer, buffer start and size. */
+	ret = sink_get_buffer_s16(sink, bytes, &y, &y_start, &y_size);
+	if (ret)
+		return ret;
+
+	/* Set helper pointers to buffer end for wrap check. Then loop until all
+	 * samples are processed.
+	 */
+	x_end = x_start + x_size;
+	y_end = y_start + y_size;
+	while (samples) {
+		/* Find out samples to process before first wrap or end of data. */
+		source_samples_without_wrap = x_end - x;
+		samples_without_wrap = y_end - y;
+		samples_without_wrap = MIN(samples_without_wrap, source_samples_without_wrap);
+		samples_without_wrap = MIN(samples_without_wrap, samples);
+
+		/* Since the example processing is for frames of audio channels, process
+		 * with step of channels count.
+		 */
+		for (i = 0; i < samples_without_wrap; i += cd->channels) {
+			/* In inner loop process the frame. As example re-arrange the channels
+			 * as defined in array channel_map[].
+			 */
+			for (ch = 0; ch < cd->channels; ch++) {
+				*y = x[ch];
+				y++;
+			}
+			x += cd->channels;
+		}
+
+		/* One of the buffers needs a wrap (or end of data), so check for wrap */
+		x = (x >= x_end) ? x - x_size : x;
+		y = (y >= y_end) ? y - y_size : y;
+
+		/* Update processed samples count for next loop iteration. */
+		samples -= samples_without_wrap;
+	}
+
+	/* Update the source and sink for bytes consumed and produced. Return success. */
+	source_release_data(source, bytes);
+	sink_commit_buffer(sink, bytes);
+	return 0;
+}
+#endif /* CONFIG_FORMAT_S16LE */
+
+#if CONFIG_FORMAT_S32LE || CONFIG_FORMAT_S32LE
+
+/**
+ * sound_dose_s32() - Process S32_LE or S24_4LE format.
+ * @mod: Pointer to module data.
+ * @source: Source for PCM samples data.
+ * @sink: Sink for PCM samples data.
+ * @frames: Number of audio data frames to process.
+ *
+ * Processing function for signed integer 32-bit PCM formats. The same
+ * function works for s24 and s32 formats since the samples values are
+ * not modified in computation. The audio samples in every frame are
+ * re-order to channels order defined in component data channel_map[].
+ *
+ * Return: Value zero for success, otherwise an error code.
+ */
+static int sound_dose_s32(const struct processing_module *mod,
+			  struct sof_source *source,
+			  struct sof_sink *sink,
+			  uint32_t frames)
+{
+	struct sound_dose_comp_data *cd = module_get_private_data(mod);
+	struct iir_state_df1 *iir;
+	uint64_t energy_sum;
+	uint32_t log_arg;
+	int32_t mel;
+	int32_t tmp;
+	int32_t sample;
+	int32_t const *x0, *x, *x_start, *x_end;
+	int32_t *y0, *y, *y_start, *y_end;
+	int32_t weighted;
+	int x_size, y_size;
+	int source_samples_without_wrap;
+	int samples_without_wrap;
+	int samples = frames * cd->channels;
+	int bytes = frames * cd->frame_bytes;
+	int ret;
+	int ch;
+	int i;
+	const int channels = cd->channels;
+
+	/* Get pointer to source data in circular buffer, get buffer start and size to
+	 * check for wrap. The size in bytes is converted to number of s16 samples to
+	 * control the samples process loop. If the number of bytes requested is not
+	 * possible, an error is returned.
+	 */
+	ret = source_get_data_s32(source, bytes, &x0, &x_start, &x_size);
+	if (ret)
+		return ret;
+
+	/* Similarly get pointer to sink data in circular buffer, buffer start and size. */
+	ret = sink_get_buffer_s32(sink, bytes, &y0, &y_start, &y_size);
+	if (ret)
+		return ret;
+
+	/* Set helper pointers to buffer end for wrap check. Then loop until all
+	 * samples are processed.
+	 */
+	x_end = x_start + x_size;
+	y_end = y_start + y_size;
+	while (samples) {
+		/* Find out samples to process before first wrap or end of data. */
+		source_samples_without_wrap = x_end - x0;
+		samples_without_wrap = y_end - y0;
+		samples_without_wrap = MIN(samples_without_wrap, source_samples_without_wrap);
+		samples_without_wrap = MIN(samples_without_wrap, samples);
+		for (ch = 0; ch < cd->channels; ch++) {
+			iir = &cd->iir[ch];
+			x = x0++;
+			y = y0++;
+			for (i = 0; i < samples_without_wrap; i += channels) {
+				sample = *x;
+				*y = sample;
+				x += channels;
+				y += channels;
+				weighted = iir_df1(iir, sample) >> 16;
+
+				/* Update sound dose, energy is Q1.15 * Q1.15 --> Q2.30 */
+				cd->energy[ch] += weighted * weighted;
+			}
+		}
+
+		/* One of the buffers needs a wrap (or end of data), so check for wrap */
+		x0 += samples_without_wrap;
+		y0 += samples_without_wrap;
+		x0 = (x0 >= x_end) ? x0 - x_size : x0;
+		y0 = (y0 >= y_end) ? y0 - y_size : y0;
+
+		/* Update processed samples count for next loop iteration. */
+		samples -= samples_without_wrap;
+	}
+
+	cd->frames_count += frames;
+	if (cd->frames_count >= cd->report_count) {
+		energy_sum = 0;
+		for (ch = 0; ch < cd->channels; ch++)
+			energy_sum += cd->energy[ch];
+
+		/* Log2 argument is Q32.0 unsigned, log2 returns Q16.16 signed.
+		 * Energy is Qx.30, so the argument 2^30 times scaled. Also to keep
+		 * argument within uint32_t range, need to scale it down by 19.
+		 * To compensate these, need to add 19 (Q16.16) and subtract 30 (Q16.16)
+		 * from logarithm value.
+		 */
+		log_arg = (uint32_t)(energy_sum >> SOUND_DOSE_ENERGY_SHIFT);
+		log_arg = MAX(log_arg, 1);
+		tmp = base2_logarithm(log_arg);
+		tmp += SOUND_DOSE_LOG_FIXED_OFFSET; /* Compensate Q2.30 and energy shift */
+		tmp += cd->log_offset_for_mean; /* logarithm subtract for mean */
+		tmp = Q_MULTSR_32X32((int64_t)tmp, SOUND_DOSE_TEN_OVER_LOG2_10_Q29, 16, 29, 16);
+		mel = tmp + SOUND_DOSE_WEIGHT_FILTERS_OFFS_Q16;
+
+		/* If stereo sum channel level values and subtract 3 dB, to generalize
+		 * For stereo or more subtract -1.5 dB per channel.
+		 */
+		if (cd->channels > 1)
+			mel += cd->channels * SOUND_DOSE_MEL_CHANNELS_SUM_FIX;
+
+		comp_info(mod->dev, "MEL %d %d", mel, ((mel >> 15) + 1) >> 1);
+
+		/* Prepare for next MEL value */
+		cd->frames_count = 0;
+		for (ch = 0; ch < cd->channels; ch++)
+			cd->energy[ch] = 0;
+	}
+
+	/* Update the source and sink for bytes consumed and produced. Return success. */
+	source_release_data(source, bytes);
+	sink_commit_buffer(sink, bytes);
+	return 0;
+}
+#endif /* CONFIG_FORMAT_S32LE || CONFIG_FORMAT_S24LE */
+
+/* This struct array defines the used processing functions for
+ * the PCM formats
+ */
+const struct sound_dose_proc_fnmap sound_dose_proc_fnmap[] = {
+#if CONFIG_FORMAT_S16LE
+	{ SOF_IPC_FRAME_S16_LE, sound_dose_s16},
+#endif
+#if CONFIG_FORMAT_S24LE
+	{ SOF_IPC_FRAME_S24_4LE, sound_dose_s32},
+#endif
+#if CONFIG_FORMAT_S32LE
+	{ SOF_IPC_FRAME_S32_LE, sound_dose_s32},
+#endif
+};
+
+/**
+ * sound_dose_find_proc_func() - Find suitable processing function.
+ * @src_fmt: Enum value for PCM format.
+ *
+ * This function finds the suitable processing function to use for
+ * the used PCM format. If not found, return NULL.
+ *
+ * Return: Pointer to processing function for the requested PCM format.
+ */
+sound_dose_func sound_dose_find_proc_func(enum sof_ipc_frame src_fmt)
+{
+	int i;
+
+	/* Find suitable processing function from map */
+	for (i = 0; i < ARRAY_SIZE(sound_dose_proc_fnmap); i++)
+		if (src_fmt == sound_dose_proc_fnmap[i].frame_fmt)
+			return sound_dose_proc_fnmap[i].sound_dose_proc_func;
+
+	return NULL;
+}