Tools: Testbench: Add support for ALSA controls script

This patch adds to testbench command line option -s <controls file>.
The controls file can contain comments with line starting with #,
empty lines, amixer cset name= commands and sleep n commands.

The script format is similar to what can be applied to a real
SOF device running Linux OS. E.g.

amixer -c0 cset name='Post Mixer Analog Playback DRC switch' off
amixer -c0 cset name='Post Mixer Analog Playback Volume' 42,43
sleep 0.5
amixer -c0 cset name='Post Mixer Analog Playback Volume' 45

The result simulated waveform would show in the beginning left
channel set to gain value 42, and right channel to gain value 43.
After processing 0.5 seconds of audio both left and right
channel gains are set to 45.

The supported controls types are mixer, switch and enum.

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

Author: singalsu

tools/testbench/include/testbench/topology_ipc4.h

@@ -48,6 +48,10 @@ int tb_new_process(struct testbench_prm *tp);
 int tb_pipelines_set_state(struct testbench_prm *tp, int state, int dir);
 int tb_send_bytes_data(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
 		       uint32_t module_id, uint32_t instance_id, struct sof_abi_hdr *abi);
+int tb_send_volume_control(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
+			   struct tb_ctl *ctl, int *control_values, int num_values);
+int tb_send_alsa_control(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx, struct tb_ctl *ctl,
+			 int *control_values, int num_values, int param_id);
 int tb_set_reset_state(struct testbench_prm *tp);
 int tb_set_running_state(struct testbench_prm *tp);
 int tb_set_up_pipeline(struct testbench_prm *tp, struct tplg_pipeline_info *pipe_info);

tools/testbench/include/testbench/utils.h

@@ -40,6 +40,9 @@ struct file_comp_lookup {
 #define TB_MAX_VOLUME_SIZE	120
 #define TB_MAX_DATA_SIZE	512
 #define TB_MAX_CTLS		16
+#define TB_MAX_CMD_CHARS	256
+#define TB_MAX_CTL_NAME_SIZE	128
+#define TB_MAX_CHANNELS		8
 
 struct tb_mq_desc {
 	char queue_name[TB_NAME_SIZE];
@@ -57,12 +60,14 @@ struct tb_config {
 };
 
 struct tb_ctl {
+	struct tplg_comp_info *comp_info;
 	unsigned int module_id;
 	unsigned int instance_id;
 	unsigned int type;
 	unsigned int volume_table[TB_MAX_VOLUME_SIZE];
 	unsigned int index;
 	char data[TB_MAX_DATA_SIZE];
+	char name[TB_MAX_CTL_NAME_SIZE];
 	union {
 		struct snd_soc_tplg_mixer_control mixer_ctl;
 		struct snd_soc_tplg_enum_control enum_ctl;
@@ -93,6 +98,7 @@ struct testbench_prm {
 	char *output_file[TB_MAX_OUTPUT_FILE_NUM]; /* output file names */
 	char *tplg_file; /* topology file to use */
 	char *bits_in; /* input bit format */
+	char *control_file;
 	int input_file_num; /* number of input files */
 	int output_file_num; /* number of output files */
 	int pipeline_num;
@@ -123,6 +129,8 @@ struct testbench_prm {
 	/* topology */
 	struct tplg_context tplg;
 
+	FILE *control_fh;
+
 #if CONFIG_IPC_MAJOR_4
 	struct list_item widget_list;
 	struct list_item route_list;
@@ -150,6 +158,7 @@ int tb_pipeline_params(struct testbench_prm *tp, struct ipc *ipc, struct pipelin
 int tb_pipeline_reset(struct ipc *ipc, struct pipeline *p);
 int tb_pipeline_start(struct ipc *ipc, struct pipeline *p);
 int tb_pipeline_stop(struct ipc *ipc, struct pipeline *p);
+int tb_read_controls(struct testbench_prm *tp, int64_t *sleep_ns);
 int tb_set_reset_state(struct testbench_prm *tp);
 int tb_set_running_state(struct testbench_prm *tp);
 int tb_set_up_all_pipelines(struct testbench_prm *tp);
@@ -162,5 +171,9 @@ void tb_free_topology(struct testbench_prm *tp);
 void tb_getcycles(uint64_t *cycles);
 void tb_gettime(struct timespec *td);
 void tb_show_file_stats(struct testbench_prm *tp, int pipeline_id);
+struct tb_ctl *tb_find_control_by_name(struct testbench_prm *tp, char *name);
+
+int tb_parse_amixer(struct testbench_prm *tp, char *line);
+
 
 #endif /* _TESTBENCH_UTILS_H */

tools/testbench/testbench.c

@@ -129,6 +129,7 @@ static void print_usage(char *executable)
 	printf("  -p <pipeline1,pipeline2,...>\n");
 	printf("  -C <number of copy() iterations>\n");
 	printf("  -P <number of dynamic pipeline iterations>\n");
+	printf("  -s <script file to set controls, with amixer and sleep commands>\n\n");
 	printf("Options for input and output format override:\n");
 	printf("  -b <input_format>, S16_LE, S24_LE, or S32_LE\n");
 	printf("  -c <input channels>\n");
@@ -146,7 +147,7 @@ static int parse_input_args(int argc, char **argv, struct testbench_prm *tp)
 	int option = 0;
 	int ret = 0;
 
-	while ((option = getopt(argc, argv, "hd:i:o:t:b:r:R:c:n:C:P:p:")) != -1) {
+	while ((option = getopt(argc, argv, "hd:i:o:t:b:r:R:c:n:C:P:p:s:")) != -1) {
 		switch (option) {
 		/* input sample file */
 		case 'i':
@@ -216,6 +217,11 @@ static int parse_input_args(int argc, char **argv, struct testbench_prm *tp)
 			ret = parse_pipelines(optarg, tp);
 			break;
 
+		/* control script file name */
+		case 's':
+			tp->control_file = strdup(optarg);
+			break;
+
 		/* print usage */
 		case 'h':
 			print_usage(argv[0]);
@@ -302,9 +308,13 @@ static void test_pipeline_stats(struct testbench_prm *tp, long long delta_t)
  */
 static int pipline_test(struct testbench_prm *tp)
 {
+	float samples_to_ns;
 	int dp_count = 0;
 	struct timespec td0, td1;
+	struct file_state *out_stat;
 	long long delta_t;
+	int64_t next_control_ns;
+	int64_t time_ns;
 	int err;
 
 	/* build, run and teardown pipelines */
@@ -341,17 +351,46 @@ static int pipline_test(struct testbench_prm *tp)
 			break;
 		}
 
+		/* Use first file writer to create simulation time. Calculate coefficient
+		 * to calculate current time from file write samples count
+		 */
+		out_stat = tp->fw[0].state;
+		samples_to_ns = 1.0e9 / ((float)out_stat->channels * out_stat->rate);
+
+		/* Apply initial controls time to call again controls handler */
+		err = tb_read_controls(tp, &next_control_ns);
+		if (err) {
+			fprintf(stderr, "error: failed to read control commands.\n");
+			goto out;
+		}
+
 		tb_gettime(&td0);
 
 		while (true) {
 			if (tb_schedule_pipeline_check_state(tp))
 				break;
+
+			if (next_control_ns) {
+				time_ns = (int64_t)(samples_to_ns * out_stat->n);
+				if (time_ns >= next_control_ns) {
+					err = tb_read_controls(tp, &next_control_ns);
+					if (err) {
+						fprintf(stderr,
+							"error: failed to read control commands.\n");
+						goto out;
+					}
+
+					if (next_control_ns)
+						next_control_ns += time_ns;
+				}
+			}
 		}
 
 		tb_schedule_pipeline_check_state(tp); /* Once more to flush out remaining data */
 
 		tb_gettime(&td1);
 
+out:
 		err = tb_set_reset_state(tp);
 		if (err < 0) {
 			fprintf(stderr, "error: pipeline reset %d failed %d\n",
@@ -445,6 +484,16 @@ int main(int argc, char **argv)
 		goto out;
 	}
 
+	if (tp->control_file) {
+		tp->control_fh = fopen(tp->control_file, "r");
+		if (!tp->control_fh) {
+			fprintf(stderr, "error: opening script %s (%s).\n",
+				tp->control_file, strerror(errno));
+			ret = -errno;
+			goto out;
+		}
+	}
+
 	/* build, run and teardown pipelines */
 	pipline_test(tp);
 
@@ -456,6 +505,10 @@ int main(int argc, char **argv)
 	/* free all other data */
 	free(tp->bits_in);
 	free(tp->tplg_file);
+	free(tp->control_file);
+	if (tp->control_fh)
+		fclose(tp->control_fh);
+
 	for (i = 0; i < tp->output_file_num; i++)
 		free(tp->output_file[i]);
 

tools/testbench/topology_ipc4.c

@@ -1316,6 +1316,8 @@ static int tb_kcontrol_cb_new(struct snd_soc_tplg_ctl_hdr *tplg_ctl,
 		ctl->type = tplg_ctl->type;
 		tlv = &tplg_ctl->tlv;
 		scale = &tlv->scale;
+		ctl->comp_info = comp_info;
+		strncpy(ctl->name, tplg_ctl->name, TB_MAX_CTL_NAME_SIZE);
 
 		/* populate the volume table */
 		for (i = 0; i < tplg_mixer->max + 1 ; i++) {
@@ -1338,6 +1340,8 @@ static int tb_kcontrol_cb_new(struct snd_soc_tplg_ctl_hdr *tplg_ctl,
 		ctl->enum_ctl = *tplg_enum;
 		ctl->index = index;
 		ctl->type = tplg_ctl->type;
+		ctl->comp_info = comp_info;
+		strncpy(ctl->name, tplg_ctl->name, TB_MAX_CTL_NAME_SIZE);
 		break;
 	case SND_SOC_TPLG_CTL_BYTES:
 	{
@@ -1350,6 +1354,8 @@ static int tb_kcontrol_cb_new(struct snd_soc_tplg_ctl_hdr *tplg_ctl,
 		ctl->index = index;
 		ctl->type = tplg_ctl->type;
 		memcpy(ctl->data, tplg_bytes->priv.data, tplg_bytes->priv.size);
+		ctl->comp_info = comp_info;
+		strncpy(ctl->name, tplg_ctl->name, TB_MAX_CTL_NAME_SIZE);
 		break;
 	}
 	default:
@@ -1735,4 +1741,146 @@ int tb_send_bytes_data(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
 	return ret;
 }
 
+int tb_send_volume_control(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
+			   struct tb_ctl *ctl, int *control_values, int num_values)
+{
+	struct ipc4_module_large_config config = {{ 0 }};
+	struct ipc4_peak_volume_config volume;
+	struct ipc4_message_reply reply;
+	struct ipc4_peak_volume_config *volume_config;
+	void *msg;
+	bool all_channels_equal = true;
+	int max_val;
+	int size;
+	int ret;
+	int val;
+	int i;
+
+	volume_config = ctl->comp_info->ipc_payload + sizeof(struct ipc4_base_module_cfg);
+	max_val = ctl->mixer_ctl.max;
+	val = control_values[0];
+	for (i = 0; i < num_values; i++) {
+		if (i > 0 && control_values[i] != val)
+			all_channels_equal = false;
+
+		if (control_values[i] < 0 || control_values[i] > max_val) {
+			fprintf(stderr, "error: control value %d is illegal.\n", control_values[i]);
+			return -EINVAL;
+		}
+	}
+
+	for (i = 0; i < num_values; i++) {
+		if (all_channels_equal) {
+			volume.channel_id = IPC4_ALL_CHANNELS_MASK;
+			volume.target_volume = ctl->volume_table[val];
+		} else {
+			volume.channel_id = i;
+			volume.target_volume = ctl->volume_table[control_values[i]];
+		}
+
+		/* TODO: get curve duration and type from topology */
+		volume.curve_type = volume_config->curve_type;
+		volume.curve_duration = volume_config->curve_duration;
+
+		/* configure the IPC message */
+		tb_ctl_ipc_message(&config, IPC4_VOLUME, sizeof(volume), ctl->module_id,
+				   ctl->instance_id, SOF_IPC4_MOD_LARGE_CONFIG_SET);
+		config.extension.r.final_block = 1;
+		config.extension.r.init_block = 1;
+
+		size = sizeof(config) + sizeof(volume);
+		msg = calloc(size, 1);
+		if (!msg)
+			return -ENOMEM;
+
+		memcpy(msg, &config, sizeof(config));
+		memcpy(msg + sizeof(config), &volume, sizeof(volume));
+
+		/* send the message and check status */
+		ret = tb_mq_cmd_tx_rx(ipc_tx, ipc_rx, msg, size, &reply, sizeof(reply));
+		free(msg);
+		if (ret < 0) {
+			fprintf(stderr, "failed to set volume control %s\n", ctl->name);
+			return ret;
+		}
+
+		if (reply.primary.r.status != IPC4_SUCCESS) {
+			fprintf(stderr, "volume control %s set failed with status %d\n",
+				ctl->name, reply.primary.r.status);
+			return -EINVAL;
+		}
+
+		if (all_channels_equal)
+			break;
+	}
+
+	return 0;
+}
+
+int tb_send_alsa_control(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
+			 struct tb_ctl *ctl, int *control_values, int num_values, int param_id)
+{
+	struct ipc4_module_large_config config = {{ 0 }};
+	struct sof_ipc4_control_msg_payload *data;
+	struct ipc4_message_reply reply;
+	void *msg;
+	int data_size;
+	int msg_size;
+	int ret;
+	int i;
+
+	/* size of control data */
+	data_size = num_values * sizeof(struct sof_ipc4_ctrl_value_chan) + sizeof(*data);
+
+	/* allocate memory for control data */
+	data = calloc(data_size, 1);
+	if (!data)
+		return -ENOMEM;
+
+	/* set param ID and number of channels */
+	data->id = ctl->index;
+	data->num_elems = num_values;
+
+	/* set the enum values */
+	for (i = 0; i < data->num_elems; i++) {
+		data->chanv[i].channel = i;
+		data->chanv[i].value = control_values[i];
+	}
+
+	/* configure the IPC message */
+	tb_ctl_ipc_message(&config, param_id, data_size, ctl->module_id, ctl->instance_id,
+			   SOF_IPC4_MOD_LARGE_CONFIG_SET);
+	config.extension.r.final_block = 1;
+	config.extension.r.init_block = 1;
+
+	/* allocate memory for IPC message */
+	msg_size = sizeof(config) + data_size;
+	msg = calloc(msg_size, 1);
+	if (!msg) {
+		free(data);
+		return -ENOMEM;
+	}
+
+	/* set the IPC message data */
+	memcpy(msg, &config, sizeof(config));
+	memcpy(msg + sizeof(config), data, data_size);
+	free(data);
+
+	/* send the message and check status */
+	ret = tb_mq_cmd_tx_rx(ipc_tx, ipc_rx, msg, msg_size, &reply, sizeof(reply));
+	free(msg);
+	if (ret < 0) {
+		fprintf(stderr, "error: failed to set control %s\n", ctl->name);
+		return ret;
+	}
+
+	if (reply.primary.r.status != IPC4_SUCCESS) {
+		fprintf(stderr, "error: control %s set failed with status %d\n",
+			ctl->name, reply.primary.r.status);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
 #endif /* CONFIG_IPC_MAJOR_4 */