gitcompile: restore ACLOCAL_FLAGS ability to use

Fixes cryptic "error macro 'AM_PATH_ALSA' not found in library
configure.ac:22" when attempting a local install as described at
https://thesofproject.github.io/latest/getting_started/build-guide/build-from-scratch.html#build-alsa-lib-and-alsa-utils-from-source

Fixes giant commit f9e6010d5e ("topology: plugins - add Intel nhlt
encoder plugin") which added a second invocation of `aclocal` in 2021
but forgot the extra `$alsa_m4_flags`.

To avoid duplication, do not fix by adding the missing `$alsa_m4_flags`
to the second aclocal invocation. Instead, drop that variable and append
`-I ../alsa-lib/utils` directly to $ACLOCAL_FLAGS

Closes: https://github.com/alsa-project/alsa-utils/pull/272
Signed-off-by: Marc Herbert <marc.herbert@intel.com>
Signed-off-by: Jaroslav Kysela <perex@perex.cz>

aplay/aplay.c

@@ -1618,6 +1618,8 @@ static void do_pause(void)
 		error(_("pause push error: %s"), snd_strerror(err));
 		return;
 	}
+	fprintf(stderr, _("\r=== PAUSE ===                                                            "));
+	fflush(stderr);
 	while (1) {
 		b = wait_for_input();
 		if (b == ' ' || b == '\r') {
@@ -1642,8 +1644,6 @@ static void check_stdin(void)
 		while (read(fileno(stdin), &b, 1) == 1) {
 			if (b == ' ' || b == '\r') {
 				while (read(fileno(stdin), &b, 1) == 1);
-				fprintf(stderr, _("\r=== PAUSE ===                                                            "));
-				fflush(stderr);
 				do_pause();
 				fprintf(stderr, "                                                                          \r");
 				fflush(stderr);

gitcompile

@@ -1,9 +1,9 @@
 #!/bin/bash
 
 if test -d ../alsa-lib/utils && ! test -r `aclocal --print-ac-dir`/alsa.m4; then
-  alsa_m4_flags="-I ../alsa-lib/utils"
+  ACLOCAL_FLAGS="$ACLOCAL_FLAGS -I ../alsa-lib/utils"
 fi
-aclocal $alsa_m4_flags $ACLOCAL_FLAGS
+aclocal $ACLOCAL_FLAGS
 # save original files to avoid stupid modifications by gettextize
 cp Makefile.am Makefile.am.ok
 cp configure.ac configure.ac.ok

topology/pre-processor.c

@@ -921,6 +921,172 @@ static int pre_process_arrays(struct tplg_pre_processor *tplg_pp, snd_config_t *
 	return 0;
 }
 
+static int pre_process_subtree_copy(struct tplg_pre_processor *tplg_pp, snd_config_t *curr,
+				    snd_config_t *top)
+{
+	snd_config_iterator_t i, next;
+	snd_config_t *subtrees;
+	int ret;
+
+	ret = snd_config_search(curr, "SubTreeCopy", &subtrees);
+	if (ret < 0)
+		return 0;
+
+	snd_config_for_each(i, next, subtrees) {
+		snd_config_t *n, *source_cfg, *target_cfg, *type_cfg;
+		snd_config_t *source_tree, *target_tree, *tmp, *subtree_cfg;
+		const char *id, *source_id;
+		const char *type = NULL;
+		const char *target_id = NULL;
+		bool override = false;
+
+		n = snd_config_iterator_entry(i);
+		ret = snd_config_get_id(n, &id);
+		if (ret < 0) {
+			SNDERR("Failed to get ID for subtree copy\n");
+			return ret;
+		}
+
+		/* get the type of copy ex: override/extend if set, by default override is false */
+		ret = snd_config_search(n, "type", &type_cfg);
+		if (ret >= 0) {
+			ret = snd_config_get_string(type_cfg, &type);
+			if (ret >= 0) {
+				if (strcmp(type, "override") && strcmp(type, "extend")) {
+					SNDERR("Invalid value for sub tree copy type %s\n", type);
+					return ret;
+				}
+
+				if (!strcmp(type, "override"))
+					override = true;
+			}
+		}
+
+		ret = snd_config_search(n, "source", &source_cfg);
+		if (ret < 0) {
+			SNDERR("failed to get source config for subtree %s\n", id);
+			return ret;
+		}
+
+		/* if the target node is not set, the subtree will be copied to current node */
+		ret = snd_config_search(n, "target", &target_cfg);
+		if (ret >= 0) {
+			snd_config_t *temp_target;
+			char *s;
+
+			ret = snd_config_get_string(target_cfg, &target_id);
+			if (ret < 0) {
+				SNDERR("Invalid target id for subtree %s\n", id);
+				return ret;
+			}
+
+			/*
+			 * create a temporary node with target_id and merge with top to avoid
+			 * failure in case the target node ID doesn't exist already
+			 */
+			s = tplg_snprintf("%s {}", target_id);
+			if (!s)
+				return -ENOMEM;
+
+			ret = snd_config_load_string(&temp_target, s, 0);
+			free(s);
+			if (ret < 0) {
+				SNDERR("Cannot create temp node with target id %s\n", target_id);
+				return ret;
+			}
+
+			ret = snd_config_merge(top, temp_target, false);
+			if (ret < 0) {
+				SNDERR("Cannot merge temp node with target id %s\n", target_id);
+				return ret;
+			}
+
+			ret = snd_config_search(top, target_id, &target_tree);
+			if (ret < 0) {
+				SNDERR("failed to get target tree %s\n", target_id);
+				return ret;
+			}
+		} else {
+			target_tree = curr;
+		}
+
+		/* get the source tree node */
+		ret = snd_config_get_string(source_cfg, &source_id);
+		if (ret < 0) {
+			SNDERR("Invalid source node id for subtree %s\n", id);
+			return ret;
+		}
+
+		ret = snd_config_search(top, source_id, &source_tree);
+		if (ret < 0) {
+			SNDERR("failed to get source tree %s\n", source_id);
+			return ret;
+		}
+
+		/* get the subtree to be merged */
+		ret = snd_config_search(n, "tree", &subtree_cfg);
+		if (ret < 0)
+			subtree_cfg = NULL;
+
+		/* make a temp copy of the source tree */
+		ret = snd_config_copy(&tmp, source_tree);
+		if (ret < 0) {
+			SNDERR("failed to copy source tree for subtreecopy %s\n", id);
+			return ret;
+		}
+
+		/* merge the current block with the source tree */
+		ret = snd_config_merge(tmp, subtree_cfg, override);
+		if (ret < 0) {
+			snd_config_delete(tmp);
+			SNDERR("Failed to merge source tree w/ subtree %s\n", id);
+			return ret;
+		}
+
+		/* merge the merged block to the target tree */
+		ret = snd_config_merge(target_tree, tmp, override);
+		if (ret < 0) {
+			snd_config_delete(tmp);
+			SNDERR("Failed to merge subtree %s w/ target\n", id);
+			return ret;
+		}
+	}
+
+	/* all subtree copies have been processed, remove the node */
+	snd_config_delete(subtrees);
+
+	return 0;
+}
+
+static int pre_process_subtree_copies(struct tplg_pre_processor *tplg_pp, snd_config_t *top,
+				      snd_config_t *curr)
+{
+	snd_config_iterator_t i, next;
+	int ret;
+
+	if (snd_config_get_type(curr) != SND_CONFIG_TYPE_COMPOUND)
+		return 0;
+
+	/* process subtreecopies at this node */
+	ret = pre_process_subtree_copy(tplg_pp, curr, top);
+	if (ret < 0)
+		return ret;
+
+	/* process subtreecopies at all child nodes */
+	snd_config_for_each(i, next, curr) {
+		snd_config_t *n;
+
+		n = snd_config_iterator_entry(i);
+
+		/* process subtreecopies at this node */
+		ret = pre_process_subtree_copies(tplg_pp, top, n);
+		if (ret < 0)
+			return ret;
+	}
+
+	return 0;
+}
+
 #endif /* version < 1.2.6 */
 
 int pre_process(struct tplg_pre_processor *tplg_pp, char *config, size_t config_size,
@@ -980,6 +1146,12 @@ int pre_process(struct tplg_pre_processor *tplg_pp, char *config, size_t config_
 		fprintf(stderr, "Failed to process object arrays in input config\n");
 		goto err;
 	}
+
+	err = pre_process_subtree_copies(tplg_pp, tplg_pp->input_cfg, tplg_pp->input_cfg);
+	if (err < 0) {
+		SNDERR("Failed to process subtree copies in input config\n");
+		goto err;
+	}
 #endif
 
 	err = pre_process_config(tplg_pp, tplg_pp->input_cfg);