module-adapter: allow multiple processing modes to be implemented

The module-adapter API has 3 processing modes: raw, stream and
source-sink, and until now only one of them can be implemented by any
module. However, the "modules" module, that loads loadable modules,
has to implement all of them to be prepared to handle any loadable
modules. This adds support for such modules.

Signed-off-by: Guennadi Liakhovetski <guennadi.liakhovetski@linux.intel.com>

Author: lyakh

src/audio/module_adapter/module/generic.c

@@ -98,7 +98,7 @@ int module_init(struct processing_module *mod, const struct module_interface *in
 	/* check interface, there must be one and only one of processing procedure */
 	if (!interface->init ||
 	    (!!interface->process + !!interface->process_audio_stream +
-	     !!interface->process_raw_data != 1)) {
+	     !!interface->process_raw_data < 1)) {
 		comp_err(dev, "module_init(): comp %d is missing mandatory interfaces",
 			 dev_comp_id(dev));
 		return -EIO;

src/audio/module_adapter/module/modules.c

@@ -142,10 +142,21 @@ static int modules_init(struct processing_module *mod)
 		struct module_interface *mod_in =
 					(struct module_interface *)md->module_adapter;
 
+		/* The order of preference */
+		if (mod_in->process)
+			mod->proc_type = MODULE_PROCESS_TYPE_SOURCE_SINK;
+		else if (mod_in->process_audio_stream)
+			mod->proc_type = MODULE_PROCESS_TYPE_STREAM;
+		else if (mod_in->process_raw_data)
+			mod->proc_type = MODULE_PROCESS_TYPE_RAW;
+		else
+			return -EINVAL;
+
 		ret = mod_in->init(mod);
 	} else {
 		ret = iadk_wrapper_init(md->module_adapter);
 	}
+
 	return ret;
 }
 
@@ -195,18 +206,45 @@ static int modules_init_process(struct processing_module *mod)
 	return 0;
 }
 
+static int modules_process(struct processing_module *mod,
+			   struct sof_source **sources, int num_of_sources,
+			   struct sof_sink **sinks, int num_of_sinks)
+{
+	if (!mod->is_native_sof)
+		return -EOPNOTSUPP;
+
+	struct module_interface *mod_in = (struct module_interface *)mod->priv.module_adapter;
+
+	return mod_in->process(mod, sources, num_of_sources, sinks, num_of_sinks);
+}
+
+static int modules_process_audio_stream(struct processing_module *mod,
+					struct input_stream_buffer *input_buffers,
+					int num_input_buffers,
+					struct output_stream_buffer *output_buffers,
+					int num_output_buffers)
+{
+	if (!mod->is_native_sof)
+		return -EOPNOTSUPP;
+
+	struct module_interface *mod_in = (struct module_interface *)mod->priv.module_adapter;
+
+	return mod_in->process_audio_stream(mod, input_buffers, num_input_buffers,
+					    output_buffers, num_output_buffers);
+}
+
 /*
- * \brief modules_process.
+ * \brief modules_process_raw.
  * \param[in] mod - processing module pointer.
  *
  * \return: zero on success
  *          error code on failure
  */
-static int modules_process(struct processing_module *mod,
-			   struct input_stream_buffer *input_buffers,
-			   int num_input_buffers,
-			   struct output_stream_buffer *output_buffers,
-			   int num_output_buffers)
+static int modules_process_raw(struct processing_module *mod,
+			       struct input_stream_buffer *input_buffers,
+			       int num_input_buffers,
+			       struct output_stream_buffer *output_buffers,
+			       int num_output_buffers)
 {
 	struct comp_dev *dev = mod->dev;
 	struct module_data *md = &mod->priv;
@@ -384,7 +422,9 @@ static int modules_reset(struct processing_module *mod)
 static const struct module_interface interface = {
 	.init = modules_init,
 	.prepare = modules_prepare,
-	.process_raw_data = modules_process,
+	.process_raw_data = modules_process_raw,
+	.process = modules_process,
+	.process_audio_stream = modules_process_audio_stream,
 	.set_processing_mode = modules_set_processing_mode,
 	.get_processing_mode = modules_get_processing_mode,
 	.set_configuration = modules_set_configuration,

src/audio/module_adapter/module_adapter.c

@@ -94,6 +94,16 @@ struct comp_dev *module_adapter_new(const struct comp_driver *drv,
 	mod->max_sources = 1;
 	mod->max_sinks = 1;
 
+	/* The order of preference */
+	if (interface->process)
+		mod->proc_type = MODULE_PROCESS_TYPE_SOURCE_SINK;
+	else if (interface->process_audio_stream)
+		mod->proc_type = MODULE_PROCESS_TYPE_STREAM;
+	else if (interface->process_raw_data)
+		mod->proc_type = MODULE_PROCESS_TYPE_RAW;
+	else
+		goto err;
+
 	/* Init processing module */
 	ret = module_init(mod, interface);
 	if (ret) {

src/include/module/module/base.h

@@ -60,6 +60,12 @@ struct module_data {
 #endif /* SOF_MODULE_PRIVATE */
 };
 
+enum module_processing_type {
+	MODULE_PROCESS_TYPE_SOURCE_SINK,
+	MODULE_PROCESS_TYPE_STREAM,
+	MODULE_PROCESS_TYPE_RAW,
+};
+
 /*
  * A pointer to this structure is passed to module API functions (from struct module_interface).
  * This structure should contain only fields that should be available to a module.
@@ -154,6 +160,8 @@ struct processing_module {
 	uint32_t max_sources;
 	uint32_t max_sinks;
 #endif /* SOF_MODULE_PRIVATE */
+
+	enum module_processing_type proc_type;
 };
 
 #endif /* __MODULE_MODULE_GENERIC__ */

src/include/sof/audio/module_adapter/module/generic.h

@@ -25,14 +25,9 @@
  * helpers to determine processing type
  * Needed till all the modules use PROCESSING_MODE_SINK_SOURCE
  */
-#define IS_PROCESSING_MODE_AUDIO_STREAM(mod) \
-		(!!((struct module_data *)&(mod)->priv)->ops->process_audio_stream)
-
-#define IS_PROCESSING_MODE_RAW_DATA(mod) \
-		(!!((struct module_data *)&(mod)->priv)->ops->process_raw_data)
-
-#define IS_PROCESSING_MODE_SINK_SOURCE(mod) \
-		(!!((struct module_data *)&(mod)->priv)->ops->process)
+#define IS_PROCESSING_MODE_AUDIO_STREAM(mod) ((mod)->proc_type == MODULE_PROCESS_TYPE_STREAM)
+#define IS_PROCESSING_MODE_RAW_DATA(mod) ((mod)->proc_type == MODULE_PROCESS_TYPE_RAW)
+#define IS_PROCESSING_MODE_SINK_SOURCE(mod) ((mod)->proc_type == MODULE_PROCESS_TYPE_SOURCE_SINK)
 
 #define MAX_BLOB_SIZE 8192
 #define MODULE_MAX_SOURCES 8