Attachment #645272 for bug #727838

View | Details | Raw Unified | Return to bug 727838
Collapse All | Expand All

Lines 1-6 Link Here

(-)a/configure.ac (-1 / +1 lines)
1	dnl Process this file with autoconf to produce a configure script.	1	dnl Process this file with autoconf to produce a configure script.
2	AC_PREREQ(2.59)	2	AC_PREREQ(2.59)
3	AC_INIT(alsa-lib, 1.2.3)	3	AC_INIT(alsa-lib, 1.2.3.1)
4		4
5	AC_CONFIG_SRCDIR([src/control/control.c])	5	AC_CONFIG_SRCDIR([src/control/control.c])
6	AC_CONFIG_MACRO_DIR([m4])	6	AC_CONFIG_MACRO_DIR([m4])




defaults.pcm.ipc_key 5678293
defaults.pcm.ipc_gid audio
defaults.pcm.ipc_perm 0660
defaults.pcm.tstamp_type default
defaults.pcm.dmix.max_periods 0
defaults.pcm.dmix.channels 2
defaults.pcm.dmix.rate 48000
defaults.pcm.dmix.format unchanged
defaults.pcm.dmix.card defaults.pcm.card
defaults.pcm.dmix.device defaults.pcm.device
defaults.pcm.dsnoop.card defaults.pcm.card

defaults.pcm.iec958.device defaults.pcm.device
defaults.pcm.modem.card defaults.pcm.card
defaults.pcm.modem.device defaults.pcm.device
defaults.pcm.file_format raw
defaults.pcm.file_truncate true		# truncate files via file or tee PCM
defaults.pcm.file_truncate	true
defaults.rawmidi.card 0
defaults.rawmidi.device 0
defaults.rawmidi.subdevice -1




	return -1;
}

static unsigned int get_ctl_type_max_elements(snd_ctl_elem_type_t type)
{
	struct snd_ctl_elem_value value;

	switch (type) {
	case SND_CTL_ELEM_TYPE_BOOLEAN:
	case SND_CTL_ELEM_TYPE_INTEGER:
		return ARRAY_SIZE(value.value.integer.value);
	case SND_CTL_ELEM_TYPE_INTEGER64:
		return ARRAY_SIZE(value.value.integer64.value);
	case SND_CTL_ELEM_TYPE_ENUMERATED:
		return ARRAY_SIZE(value.value.enumerated.item);
	case SND_CTL_ELEM_TYPE_BYTES:
		return ARRAY_SIZE(value.value.bytes.data);
	default:
		return 0;
	}
}

/**
 * \brief parse ASCII string as CTL element value
 * \param handle CTL handle

	type = snd_ctl_elem_info_get_type(info);
	count = snd_ctl_elem_info_get_count(info);
	snd_ctl_elem_value_set_id(dst, &myid);

	if (count > get_ctl_type_max_elements(type))
		count = get_ctl_type_max_elements(type);
	
	for (idx = 0; idx < count && ptr && *ptr; idx++) {
		if (*ptr == ',')
			goto skip;
		switch (type) {

Lines 34-47 Link Here

(-)a/src/dlmisc.c (-12 / +25 lines)
34	#endif	34	#endif
35	#include <limits.h>	35	#include <limits.h>
36		36
		37	#if defined(HAVE_LIBDL) && defined(__GLIBC__) && !defined(__UCLIBC__)
		38	#define DL_ORIGIN_AVAILABLE 1
		39	#endif
		40
37	#ifndef DOC_HIDDEN	41	#ifndef DOC_HIDDEN
38	#ifndef PIC	42	#ifndef PIC
39	struct snd_dlsym_link *snd_dlsym_start = NULL;	43	struct snd_dlsym_link *snd_dlsym_start = NULL;
40	#endif	44	#endif
		45	#ifdef DL_ORIGIN_AVAILABLE
		46	static int snd_libdir_plugin_dir_set = 0;
41	static char *snd_libdir_origin = NULL;	47	static char *snd_libdir_origin = NULL;
42	#endif	48	#endif
		49	#endif
43		50
44	#ifdef HAVE_LIBPTHREAD	51	#if defined(DL_ORIGIN_AVAILABLE) && defined(HAVE_LIBPTHREAD)
45	static pthread_mutex_t snd_dlpath_mutex = PTHREAD_MUTEX_INITIALIZER;	52	static pthread_mutex_t snd_dlpath_mutex = PTHREAD_MUTEX_INITIALIZER;
46		53
47	static inline void snd_dlpath_lock(void)	54	static inline void snd_dlpath_lock(void)
Lines 68-78 static inline void snd_dlpath_unlock(void) {} Link Here
68	*/	75	*/
69	int snd_dlpath(char path, size_t path_len, const char name)	76	int snd_dlpath(char path, size_t path_len, const char name)
70	{	77	{
71	#ifdef HAVE_LIBDL	78	#ifdef DL_ORIGIN_AVAILABLE
72	#ifdef __GLIBC__
73	static int plugin_dir_set = 0;
74	snd_dlpath_lock();	79	snd_dlpath_lock();
75	if (!plugin_dir_set) {	80	if (!snd_libdir_plugin_dir_set) {
76	struct link_map *links;	81	struct link_map *links;
77	Dl_info info;	82	Dl_info info;
78	char origin[PATH_MAX];	83	char origin[PATH_MAX];
Lines 83-97 int snd_dlpath(char path, size_t path_len, const char name) Link Here
83	if (access(path, X_OK) == 0)	88	if (access(path, X_OK) == 0)
84	snd_libdir_origin = strdup(origin);	89	snd_libdir_origin = strdup(origin);
85	}	90	}
86	plugin_dir_set = 1;	91	snd_libdir_plugin_dir_set = 1;
87	}	92	}
88	snd_dlpath_unlock();	93	if (snd_libdir_origin) {
89	#endif
90	#endif
91	if (snd_libdir_origin)
92	snprintf(path, path_len, "%s/alsa-lib/%s", snd_libdir_origin, name);	94	snprintf(path, path_len, "%s/alsa-lib/%s", snd_libdir_origin, name);
93	else	95	} else {
94	snprintf(path, path_len, "%s/%s", ALSA_PLUGIN_DIR, name);	96	snprintf(path, path_len, "%s/%s", ALSA_PLUGIN_DIR, name);
		97	}
		98	snd_dlpath_unlock();
		99	#else
		100	snprintf(path, path_len, "%s/%s", ALSA_PLUGIN_DIR, name);
		101	#endif
95	return 0;	102	return 0;
96	}	103	}
97		104
Lines 440-446 void snd_dlobj_cache_cleanup(void) Link Here
440	free((void )c->lib); / shut up gcc warning */	447	free((void )c->lib); / shut up gcc warning */
441	free(c);	448	free(c);
442	}	449	}
443	free(snd_libdir_origin);
444	snd_dlobj_unlock();	450	snd_dlobj_unlock();
		451	#ifdef DL_ORIGIN_AVAILABLE
		452	snd_dlpath_lock();
		453	snd_libdir_plugin_dir_set = 0;
		454	free(snd_libdir_origin);
		455	snd_libdir_origin = NULL;
		456	snd_dlpath_unlock();
		457	#endif
445	}	458	}
446	#endif	459	#endif

Lines 929-938 int snd_pcm_direct_hw_refine(snd_pcm_t pcm, snd_pcm_hw_params_t params) Link Here

(-)a/src/pcm/pcm_direct.c (-2 / +6 lines)
929	return err;	929	return err;
930	if (dshare->var_periodsize) {	930	if (dshare->var_periodsize) {
931	/* more tolerant settings... */	931	/* more tolerant settings... */
932	if (dshare->shmptr->hw.buffer_size.max / 2 > period_size.max)	932	if (dshare->shmptr->hw.buffer_size.max / 2 > period_size.max) {
933	period_size.max = dshare->shmptr->hw.buffer_size.max / 2;	933	period_size.max = dshare->shmptr->hw.buffer_size.max / 2;
934	if (dshare->shmptr->hw.buffer_time.max / 2 > period_time.max)	934	period_size.openmax = dshare->shmptr->hw.buffer_size.openmax;
		935	}
		936	if (dshare->shmptr->hw.buffer_time.max / 2 > period_time.max) {
935	period_time.max = dshare->shmptr->hw.buffer_time.max / 2;	937	period_time.max = dshare->shmptr->hw.buffer_time.max / 2;
		938	period_time.openmax = dshare->shmptr->hw.buffer_time.openmax;
		939	}
936	}	940	}
937		941
938	err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_SIZE,	942	err = hw_param_interval_refine_one(params, SND_PCM_HW_PARAM_PERIOD_SIZE,

Lines 58-66 static void MIX_AREAS_16(unsigned int size, Link Here

(-)a/src/pcm/pcm_dmix_x86_64.h (-9 / +45 lines)
58	/*	58	/*
59	* initialization, load RSI, RDI, RBX registers	59	* initialization, load RSI, RDI, RBX registers
60	*/	60	*/
		61	#ifndef _ILP32
61	"\tmovq %[dst], %%rdi\n"	62	"\tmovq %[dst], %%rdi\n"
62	"\tmovq %[src], %%rsi\n"	63	"\tmovq %[src], %%rsi\n"
63	"\tmovq %[sum], %%rbx\n"	64	"\tmovq %[sum], %%rbx\n"
		65	#else
		66	"\tmovl %[dst], %%edi\n"
		67	"\tmovl %[src], %%esi\n"
		68	"\tmovl %[sum], %%ebx\n"
		69	#endif
64		70
65	/*	71	/*
66	* while (size-- > 0) {	72	* while (size-- > 0) {
Lines 109-117 static void MIX_AREAS_16(unsigned int size, Link Here
109	/*	115	/*
110	* while (size-- > 0)	116	* while (size-- > 0)
111	*/	117	*/
112	"\tadd %[dst_step], %%rdi\n"	118	#ifndef _ILP32
113	"\tadd %[src_step], %%rsi\n"	119	"\taddq %[dst_step], %%rdi\n"
114	"\tadd %[sum_step], %%rbx\n"	120	"\taddq %[src_step], %%rsi\n"
		121	"\taddq %[sum_step], %%rbx\n"
		122	#else
		123	"\taddl %[dst_step], %%edi\n"
		124	"\taddl %[src_step], %%esi\n"
		125	"\taddl %[sum_step], %%ebx\n"
		126	#endif
115	"\tdecl %[size]\n"	127	"\tdecl %[size]\n"
116	"\tjnz 1b\n"	128	"\tjnz 1b\n"
117		129
Lines 168-176 static void MIX_AREAS_32(unsigned int size, Link Here
168	/*	180	/*
169	* initialization, load RSI, RDI, RBX registers	181	* initialization, load RSI, RDI, RBX registers
170	*/	182	*/
		183	#ifndef _ILP32
171	"\tmovq %[dst], %%rdi\n"	184	"\tmovq %[dst], %%rdi\n"
172	"\tmovq %[src], %%rsi\n"	185	"\tmovq %[src], %%rsi\n"
173	"\tmovq %[sum], %%rbx\n"	186	"\tmovq %[sum], %%rbx\n"
		187	#else
		188	"\tmovl %[dst], %%edi\n"
		189	"\tmovl %[src], %%esi\n"
		190	"\tmovl %[sum], %%ebx\n"
		191	#endif
174		192
175	/*	193	/*
176	* while (size-- > 0) {	194	* while (size-- > 0) {
Lines 241-249 static void MIX_AREAS_32(unsigned int size, Link Here
241	/*	259	/*
242	* while (size-- > 0)	260	* while (size-- > 0)
243	*/	261	*/
244	"\tadd %[dst_step], %%rdi\n"	262	#ifndef _ILP32
245	"\tadd %[src_step], %%rsi\n"	263	"\taddq %[dst_step], %%rdi\n"
246	"\tadd %[sum_step], %%rbx\n"	264	"\taddq %[src_step], %%rsi\n"
		265	"\taddq %[sum_step], %%rbx\n"
		266	#else
		267	"\taddl %[dst_step], %%edi\n"
		268	"\taddl %[src_step], %%esi\n"
		269	"\taddl %[sum_step], %%ebx\n"
		270	#endif
247	"\tdecl %[size]\n"	271	"\tdecl %[size]\n"
248	"\tjnz 1b\n"	272	"\tjnz 1b\n"
249		273
Lines 292-300 static void MIX_AREAS_24(unsigned int size, Link Here
292	/*	316	/*
293	* initialization, load RSI, RDI, RBX registers	317	* initialization, load RSI, RDI, RBX registers
294	*/	318	*/
		319	#ifndef _ILP32
295	"\tmovq %[dst], %%rdi\n"	320	"\tmovq %[dst], %%rdi\n"
296	"\tmovq %[src], %%rsi\n"	321	"\tmovq %[src], %%rsi\n"
297	"\tmovq %[sum], %%rbx\n"	322	"\tmovq %[sum], %%rbx\n"
		323	#else
		324	"\tmovl %[dst], %%edi\n"
		325	"\tmovl %[src], %%esi\n"
		326	"\tmovl %[sum], %%ebx\n"
		327	#endif
298		328
299	/*	329	/*
300	* while (size-- > 0) {	330	* while (size-- > 0) {
Lines 353-361 static void MIX_AREAS_24(unsigned int size, Link Here
353	/*	383	/*
354	* while (size-- > 0)	384	* while (size-- > 0)
355	*/	385	*/
356	"\tadd %[dst_step], %%rdi\n"	386	#ifndef _ILP32
357	"\tadd %[src_step], %%rsi\n"	387	"\taddq %[dst_step], %%rdi\n"
358	"\tadd %[sum_step], %%rbx\n"	388	"\taddq %[src_step], %%rsi\n"
		389	"\taddq %[sum_step], %%rbx\n"
		390	#else
		391	"\taddl %[dst_step], %%edi\n"
		392	"\taddl %[src_step], %%esi\n"
		393	"\taddl %[sum_step], %%ebx\n"
		394	#endif
359	"\tdecl %[size]\n"	395	"\tdecl %[size]\n"
360	"\tjnz 1b\n"	396	"\tjnz 1b\n"
361		397

Lines 732-737 int snd_pcm_extplug_create(snd_pcm_extplug_t extplug, const char name, Link Here

(-)a/src/pcm/pcm_extplug.c (+1 lines)
732	pcm->private_data = ext;	732	pcm->private_data = ext;
733	pcm->poll_fd = spcm->poll_fd;	733	pcm->poll_fd = spcm->poll_fd;
734	pcm->poll_events = spcm->poll_events;	734	pcm->poll_events = spcm->poll_events;
		735	pcm->tstamp_type = spcm->tstamp_type;
735	snd_pcm_set_hw_ptr(pcm, &ext->plug.hw_ptr, -1, 0);	736	snd_pcm_set_hw_ptr(pcm, &ext->plug.hw_ptr, -1, 0);
736	snd_pcm_set_appl_ptr(pcm, &ext->plug.appl_ptr, -1, 0);	737	snd_pcm_set_appl_ptr(pcm, &ext->plug.appl_ptr, -1, 0);
737		738




		return err;

	cmpt_seq->device = find_component_dev(uc_mgr, val);
	free(val);
	if (!cmpt_seq->device) {
		uc_error("error: Cannot find component device %s", val);
		free(val);
		return -EINVAL;
	}
	free(val);

	/* Parent needs its enable or disable sequence */
	cmpt_seq->enable = enable;




	}

	idx = 0;

	/* for array, use a temporary non-clashing identifier */
	if (array > 0) {
		snd_config_for_each(i, next, dst) {
			n = snd_config_iterator_entry(i);
			snprintf(tmpid, sizeof(tmpid), "_tmp_%d", idx++);
			err = snd_config_set_id(n, tmpid);
			if (err < 0)
				return err;
		}
	}

	snd_config_for_each(i, next, src) {
		n = snd_config_iterator_entry(i);
		err = snd_config_remove(n);




	return NULL;
}

static char *get_card_number(struct ctl_list *ctl_list)
{
	struct ctl_list *ctl_list;
	char num[16];

	if (uc_mgr->conf_format < 3)
		return NULL;
	ctl_list = uc_mgr_get_master_ctl(uc_mgr);
	if (ctl_list == NULL)
		return strdup("");
	snprintf(num, sizeof(num), "%i", snd_ctl_card_info_get_card(ctl_list->ctl_info));
	return strdup(num);
}

static char *rval_card_number(snd_use_case_mgr_t *uc_mgr)
{
	if (uc_mgr->conf_format < 3)
		return NULL;
	return get_card_number(uc_mgr_get_master_ctl(uc_mgr));
}

static char *rval_card_id(snd_use_case_mgr_t *uc_mgr)
{
	struct ctl_list *ctl_list;

	return strdup(snd_ctl_card_info_get_components(ctl_list->ctl_info));
}

static struct ctl_list *get_ctl_list_by_name(snd_use_case_mgr_t *uc_mgr, const char *id)
{
	struct ctl_list *ctl_list;
	char *name, *index;
	long idx = 0;

	if (uc_mgr->conf_format < 3) {
		uc_error("CardIdByName substitution is supported in v3+ syntax");
		return NULL;
	}

	name = alloca(strlen(id) + 1);
	strcpy(name, id);
	index = strchr(name, '#');

		if (safe_strtol(index + 1, &idx))
			return NULL;
	}
	return uc_mgr_get_ctl_by_name(uc_mgr, name, idx);
}

static char *rval_card_number_by_name(snd_use_case_mgr_t *uc_mgr, const char *id)
{
	if (uc_mgr->conf_format < 3) {
		uc_error("CardNumberByName substitution is supported in v3+ syntax");
		return NULL;
	}

	return get_card_number(get_ctl_list_by_name(uc_mgr, id));
}

static char *rval_card_id_by_name(snd_use_case_mgr_t *uc_mgr, const char *id)
{
	struct ctl_list *ctl_list;

	if (uc_mgr->conf_format < 3) {
		uc_error("CardIdByName substitution is supported in v3+ syntax");
		return NULL;
	}

	ctl_list = get_ctl_list_by_name(uc_mgr, id);
	if (ctl_list == NULL)
		return NULL;
	return strdup(snd_ctl_card_info_get_id(ctl_list->ctl_info));

#define MATCH_VARIABLE2(name, id, fcn)					\
	if (strncmp((name), (id), sizeof(id) - 1) == 0) {		\
		idsize = sizeof(id) - 1;				\
		fcn2 = (fcn);						\
		goto __match2;						\
			rvalsize = tmp - (value + idsize);		\
			if (rvalsize > sizeof(v2)) {			\
				err = -ENOMEM;				\
				goto __error;				\
			}						\
			strncpy(v2, value + idsize, rvalsize);		\
			v2[rvalsize] = '\0';				\
			idsize += rvalsize + 1;				\
			rval = fcn(uc_mgr, v2);				\
			goto __rval;					\
		}							\
	}

int uc_mgr_get_substituted_value(snd_use_case_mgr_t *uc_mgr,

{
	size_t size, nsize, idsize, rvalsize, dpos = 0;
	const char *tmp;
	char *r, *nr, *rval, v2[48];
	bool ignore_error, allow_empty;
	char *(*fcn2)(snd_use_case_mgr_t *, const char *id);
	int err;

	if (value == NULL)

		return -ENOMEM;

	while (*value) {
		if (*value != '$') {
__std:
			r[dpos++] = *value;
			value++;
			continue;
		}
		ignore_error = false;
		if (value[1] == '$' && value[2] == '{' && uc_mgr->conf_format >= 3) {
			value++;
			ignore_error = true;
		} else if (value[1] != '{') {
			goto __std;
		}
		allow_empty = false;
		fcn2 = NULL;
		MATCH_VARIABLE(value, "${OpenName}", rval_open_name, false);
		MATCH_VARIABLE(value, "${ConfTopDir}", rval_conf_topdir, false);
		MATCH_VARIABLE(value, "${ConfDir}", rval_conf_dir, false);
		MATCH_VARIABLE(value, "${ConfName}", rval_conf_name, false);
		MATCH_VARIABLE(value, "${CardNumber}", rval_card_number, true);
		MATCH_VARIABLE(value, "${CardId}", rval_card_id, false);
		MATCH_VARIABLE(value, "${CardDriver}", rval_card_driver, false);
		MATCH_VARIABLE(value, "${CardName}", rval_card_name, false);
		MATCH_VARIABLE(value, "${CardLongName}", rval_card_longname, false);
		MATCH_VARIABLE(value, "${CardComponents}", rval_card_components, true);
		MATCH_VARIABLE2(value, "${env:", rval_env);
		MATCH_VARIABLE2(value, "${sys:", rval_sysfs);
		MATCH_VARIABLE2(value, "${var:", rval_var);
		MATCH_VARIABLE2(value, "${CardNumberByName:", rval_card_number_by_name);
		MATCH_VARIABLE2(value, "${CardIdByName:", rval_card_id_by_name);
__merr:
		err = -EINVAL;
		tmp = strchr(value, '}');
		if (tmp) {
			strncpy(r, value, tmp + 1 - value);
			r[tmp + 1 - value] = '\0';
			uc_error("variable '%s' is not known!", r);
		} else {
			uc_error("variable reference '%s' is not complete", value);
		}
		goto __error;
__match2:
		tmp = strchr(value + idsize, '}');
		if (tmp) {
			rvalsize = tmp - (value + idsize);
			if (rvalsize > sizeof(v2)) {
				err = -ENOMEM;
				goto __error;
			}
			strncpy(v2, value + idsize, rvalsize);
			v2[rvalsize] = '\0';
			idsize += rvalsize + 1;
			if (*v2 == '$' && uc_mgr->conf_format >= 3) {
				tmp = uc_mgr_get_variable(uc_mgr, v2 + 1);
				if (tmp == NULL) {
					uc_error("define '%s' is not reachable in this context!", v2 + 1);
					rval = NULL;
				} else {
					rval = fcn2(uc_mgr, tmp);
				}
			} else {
				rval = fcn2(uc_mgr, v2);
			}
			goto __rval;
		}
		goto __merr;
__rval:
		if (rval == NULL || (!allow_empty && rval[0] == '\0')) {
			free(rval);
			if (ignore_error) {
				value += idsize;
				continue;
			}
			strncpy(r, value, idsize);
			r[idsize] = '\0';
			uc_error("variable '%s' is not defined in this context!", r);
			err = -EINVAL;
			goto __error;
		}
		value += idsize;
		rvalsize = strlen(rval);
		nsize = size + rvalsize - idsize;
		if (nsize > size) {
			nr = realloc(r, nsize);
			if (nr == NULL) {
				free(rval);
				err = -ENOMEM;
				r[idsize] = '\0';
				uc_error("variable '%s' is not defined in this context!", r);
				err = -EINVAL;
				goto __error;
			}
			size = nsize;
			r = nr;
			nsize = size + rvalsize - idsize;
			if (nsize > size) {
				nr = realloc(r, nsize);
				if (nr == NULL) {
					free(rval);
					err = -ENOMEM;
					goto __error;
				}
				size = nsize;
				r = nr;
			}
			strcpy(r + dpos, rval);
			dpos += rvalsize;
			free(rval);
		} else {
			r[dpos++] = *value;
			value++;
		}
		strcpy(r + dpos, rval);
		dpos += rvalsize;
		free(rval);
	}
	r[dpos] = '\0';


Return to bug 727838

Lines 617-627 static int parse_component_seq(snd_use_case_mgr_t *uc_mgr, Link Here

(-)a/src/ucm/parser.c (-1 / +2 lines)
617	return err;	617	return err;
618		618
619	cmpt_seq->device = find_component_dev(uc_mgr, val);	619	cmpt_seq->device = find_component_dev(uc_mgr, val);
620	free(val);
621	if (!cmpt_seq->device) {	620	if (!cmpt_seq->device) {
622	uc_error("error: Cannot find component device %s", val);	621	uc_error("error: Cannot find component device %s", val);
		622	free(val);
623	return -EINVAL;	623	return -EINVAL;
624	}	624	}
		625	free(val);
625		626
626	/* Parent needs its enable or disable sequence */	627	/* Parent needs its enable or disable sequence */
627	cmpt_seq->enable = enable;	628	cmpt_seq->enable = enable;

Lines 149-154 static int compound_merge(const char *id, Link Here

(-)a/src/ucm/ucm_include.c (+12 lines)
149	}	149	}
150		150
151	idx = 0;	151	idx = 0;
		152
		153	/* for array, use a temporary non-clashing identifier */
		154	if (array > 0) {
		155	snd_config_for_each(i, next, dst) {
		156	n = snd_config_iterator_entry(i);
		157	snprintf(tmpid, sizeof(tmpid), "_tmp_%d", idx++);
		158	err = snd_config_set_id(n, tmpid);
		159	if (err < 0)
		160	return err;
		161	}
		162	}
		163
152	snd_config_for_each(i, next, src) {	164	snd_config_for_each(i, next, src) {
153	n = snd_config_iterator_entry(i);	165	n = snd_config_iterator_entry(i);
154	err = snd_config_remove(n);	166	err = snd_config_remove(n);

Lines 82-92 defaults.pcm.minperiodtime 5000 # in us Link Here

(-)a/src/conf/alsa.conf (-5 / +4 lines)
82	defaults.pcm.ipc_key 5678293	82	defaults.pcm.ipc_key 5678293
83	defaults.pcm.ipc_gid audio	83	defaults.pcm.ipc_gid audio
84	defaults.pcm.ipc_perm 0660	84	defaults.pcm.ipc_perm 0660
85	defaults.pcm.tstamp_type "default"	85	defaults.pcm.tstamp_type default
86	defaults.pcm.dmix.max_periods 0	86	defaults.pcm.dmix.max_periods 0
87	defaults.pcm.dmix.channels 2	87	defaults.pcm.dmix.channels 2
88	defaults.pcm.dmix.rate 48000	88	defaults.pcm.dmix.rate 48000
89	defaults.pcm.dmix.format "unchanged"	89	defaults.pcm.dmix.format unchanged
90	defaults.pcm.dmix.card defaults.pcm.card	90	defaults.pcm.dmix.card defaults.pcm.card
91	defaults.pcm.dmix.device defaults.pcm.device	91	defaults.pcm.dmix.device defaults.pcm.device
92	defaults.pcm.dsnoop.card defaults.pcm.card	92	defaults.pcm.dsnoop.card defaults.pcm.card
Lines 115-123 defaults.pcm.iec958.card defaults.pcm.card Link Here
115	defaults.pcm.iec958.device defaults.pcm.device	115	defaults.pcm.iec958.device defaults.pcm.device
116	defaults.pcm.modem.card defaults.pcm.card	116	defaults.pcm.modem.card defaults.pcm.card
117	defaults.pcm.modem.device defaults.pcm.device	117	defaults.pcm.modem.device defaults.pcm.device
118	# truncate files via file or tee PCM	118	defaults.pcm.file_format raw
119	defaults.pcm.file_format "raw"	119	defaults.pcm.file_truncate true # truncate files via file or tee PCM
120	defaults.pcm.file_truncate true
121	defaults.rawmidi.card 0	120	defaults.rawmidi.card 0
122	defaults.rawmidi.device 0	121	defaults.rawmidi.device 0
123	defaults.rawmidi.subdevice -1	122	defaults.rawmidi.subdevice -1

Lines 304-309 static int get_ctl_enum_item_index(snd_ctl_t *handle, Link Here

(-)a/src/control/ctlparse.c (-1 / +23 lines)
304	return -1;	304	return -1;
305	}	305	}
306		306
		307	static unsigned int get_ctl_type_max_elements(snd_ctl_elem_type_t type)
		308	{
		309	struct snd_ctl_elem_value value;
		310
		311	switch (type) {
		312	case SND_CTL_ELEM_TYPE_BOOLEAN:
		313	case SND_CTL_ELEM_TYPE_INTEGER:
		314	return ARRAY_SIZE(value.value.integer.value);
		315	case SND_CTL_ELEM_TYPE_INTEGER64:
		316	return ARRAY_SIZE(value.value.integer64.value);
		317	case SND_CTL_ELEM_TYPE_ENUMERATED:
		318	return ARRAY_SIZE(value.value.enumerated.item);
		319	case SND_CTL_ELEM_TYPE_BYTES:
		320	return ARRAY_SIZE(value.value.bytes.data);
		321	default:
		322	return 0;
		323	}
		324	}
		325
307	/**	326	/**
308	* \brief parse ASCII string as CTL element value	327	* \brief parse ASCII string as CTL element value
309	* \param handle CTL handle	328	* \param handle CTL handle
Lines 331-338 int snd_ctl_ascii_value_parse(snd_ctl_t *handle, Link Here
331	type = snd_ctl_elem_info_get_type(info);	350	type = snd_ctl_elem_info_get_type(info);
332	count = snd_ctl_elem_info_get_count(info);	351	count = snd_ctl_elem_info_get_count(info);
333	snd_ctl_elem_value_set_id(dst, &myid);	352	snd_ctl_elem_value_set_id(dst, &myid);
		353
		354	if (count > get_ctl_type_max_elements(type))
		355	count = get_ctl_type_max_elements(type);
334		356
335	for (idx = 0; idx < count && idx < 128 && ptr && *ptr; idx++) {	357	for (idx = 0; idx < count && ptr && *ptr; idx++) {
336	if (*ptr == ',')	358	if (*ptr == ',')
337	goto skip;	359	goto skip;
338	switch (type) {	360	switch (type) {

Lines 71-90 static char rval_conf_name(snd_use_case_mgr_t uc_mgr) Link Here

(-)a/src/ucm/ucm_subs.c (-76 / +125 lines)
71	return NULL;	71	return NULL;
72	}	72	}
73		73
74	static char rval_card_number(snd_use_case_mgr_t uc_mgr)	74	static char get_card_number(struct ctl_list ctl_list)
75	{	75	{
76	struct ctl_list *ctl_list;
77	char num[16];	76	char num[16];
78		77
79	if (uc_mgr->conf_format < 3)
80	return NULL;
81	ctl_list = uc_mgr_get_master_ctl(uc_mgr);
82	if (ctl_list == NULL)	78	if (ctl_list == NULL)
83	return strdup("");	79	return strdup("");
84	snprintf(num, sizeof(num), "%i", snd_ctl_card_info_get_card(ctl_list->ctl_info));	80	snprintf(num, sizeof(num), "%i", snd_ctl_card_info_get_card(ctl_list->ctl_info));
85	return strdup(num);	81	return strdup(num);
86	}	82	}
87		83
		84	static char rval_card_number(snd_use_case_mgr_t uc_mgr)
		85	{
		86	if (uc_mgr->conf_format < 3)
		87	return NULL;
		88	return get_card_number(uc_mgr_get_master_ctl(uc_mgr));
		89	}
		90
88	static char rval_card_id(snd_use_case_mgr_t uc_mgr)	91	static char rval_card_id(snd_use_case_mgr_t uc_mgr)
89	{	92	{
90	struct ctl_list *ctl_list;	93	struct ctl_list *ctl_list;
Lines 135-151 static char rval_card_components(snd_use_case_mgr_t uc_mgr) Link Here
135	return strdup(snd_ctl_card_info_get_components(ctl_list->ctl_info));	138	return strdup(snd_ctl_card_info_get_components(ctl_list->ctl_info));
136	}	139	}
137		140
138	static char rval_card_id_by_name(snd_use_case_mgr_t uc_mgr, const char *id)	141	static struct ctl_list get_ctl_list_by_name(snd_use_case_mgr_t uc_mgr, const char *id)
139	{	142	{
140	struct ctl_list *ctl_list;
141	char name, index;	143	char name, index;
142	long idx = 0;	144	long idx = 0;
143		145
144	if (uc_mgr->conf_format < 3) {
145	uc_error("CardIdByName substitution is supported in v3+ syntax");
146	return NULL;
147	}
148
149	name = alloca(strlen(id) + 1);	146	name = alloca(strlen(id) + 1);
150	strcpy(name, id);	147	strcpy(name, id);
151	index = strchr(name, '#');	148	index = strchr(name, '#');
Lines 154-160 static char rval_card_id_by_name(snd_use_case_mgr_t uc_mgr, const char *id) Link Here
154	if (safe_strtol(index + 1, &idx))	151	if (safe_strtol(index + 1, &idx))
155	return NULL;	152	return NULL;
156	}	153	}
157	ctl_list = uc_mgr_get_ctl_by_name(uc_mgr, name, idx);	154	return uc_mgr_get_ctl_by_name(uc_mgr, name, idx);
		155	}
		156
		157	static char rval_card_number_by_name(snd_use_case_mgr_t uc_mgr, const char *id)
		158	{
		159	if (uc_mgr->conf_format < 3) {
		160	uc_error("CardNumberByName substitution is supported in v3+ syntax");
		161	return NULL;
		162	}
		163
		164	return get_card_number(get_ctl_list_by_name(uc_mgr, id));
		165	}
		166
		167	static char rval_card_id_by_name(snd_use_case_mgr_t uc_mgr, const char *id)
		168	{
		169	struct ctl_list *ctl_list;
		170
		171	if (uc_mgr->conf_format < 3) {
		172	uc_error("CardIdByName substitution is supported in v3+ syntax");
		173	return NULL;
		174	}
		175
		176	ctl_list = get_ctl_list_by_name(uc_mgr, id);
158	if (ctl_list == NULL)	177	if (ctl_list == NULL)
159	return NULL;	178	return NULL;
160	return strdup(snd_ctl_card_info_get_id(ctl_list->ctl_info));	179	return strdup(snd_ctl_card_info_get_id(ctl_list->ctl_info));
Lines 246-264 static char rval_var(snd_use_case_mgr_t uc_mgr, const char *id) Link Here
246	#define MATCH_VARIABLE2(name, id, fcn) \	265	#define MATCH_VARIABLE2(name, id, fcn) \
247	if (strncmp((name), (id), sizeof(id) - 1) == 0) { \	266	if (strncmp((name), (id), sizeof(id) - 1) == 0) { \
248	idsize = sizeof(id) - 1; \	267	idsize = sizeof(id) - 1; \
249	tmp = strchr(value + idsize, '}'); \	268	fcn2 = (fcn); \
250	if (tmp) { \	269	goto __match2; \
251	rvalsize = tmp - (value + idsize); \
252	if (rvalsize > sizeof(v2)) { \
253	err = -ENOMEM; \
254	goto __error; \
255	} \
256	strncpy(v2, value + idsize, rvalsize); \
257	v2[rvalsize] = '\0'; \
258	idsize += rvalsize + 1; \
259	rval = fcn(uc_mgr, v2); \
260	goto __rval; \
261	} \
262	}	270	}
263		271
264	int uc_mgr_get_substituted_value(snd_use_case_mgr_t *uc_mgr,	272	int uc_mgr_get_substituted_value(snd_use_case_mgr_t *uc_mgr,
Lines 267-273 int uc_mgr_get_substituted_value(snd_use_case_mgr_t *uc_mgr, Link Here
267	{	275	{
268	size_t size, nsize, idsize, rvalsize, dpos = 0;	276	size_t size, nsize, idsize, rvalsize, dpos = 0;
269	const char *tmp;	277	const char *tmp;
270	char r, nr, *rval, v2[32];	278	char r, nr, *rval, v2[48];
		279	bool ignore_error, allow_empty;
		280	char (fcn2)(snd_use_case_mgr_t , const char id);
271	int err;	281	int err;
272		282
273	if (value == NULL)	283	if (value == NULL)
Lines 279-340 int uc_mgr_get_substituted_value(snd_use_case_mgr_t *uc_mgr, Link Here
279	return -ENOMEM;	289	return -ENOMEM;
280		290
281	while (*value) {	291	while (*value) {
282	if (value == '$' && (value+1) == '{') {	292	if (*value != '$') {
283	bool allow_empty = false;	293	__std:
284		294	r[dpos++] = *value;
285	MATCH_VARIABLE(value, "${OpenName}", rval_open_name, false);	295	value++;
286	MATCH_VARIABLE(value, "${ConfTopDir}", rval_conf_topdir, false);	296	continue;
287	MATCH_VARIABLE(value, "${ConfDir}", rval_conf_dir, false);	297	}
288	MATCH_VARIABLE(value, "${ConfName}", rval_conf_name, false);	298	ignore_error = false;
289	MATCH_VARIABLE(value, "${CardNumber}", rval_card_number, true);	299	if (value[1] == '$' && value[2] == '{' && uc_mgr->conf_format >= 3) {
290	MATCH_VARIABLE(value, "${CardId}", rval_card_id, false);	300	value++;
291	MATCH_VARIABLE(value, "${CardDriver}", rval_card_driver, false);	301	ignore_error = true;
292	MATCH_VARIABLE(value, "${CardName}", rval_card_name, false);	302	} else if (value[1] != '{') {
293	MATCH_VARIABLE(value, "${CardLongName}", rval_card_longname, false);	303	goto __std;
294	MATCH_VARIABLE(value, "${CardComponents}", rval_card_components, true);	304	}
295	MATCH_VARIABLE2(value, "${env:", rval_env);	305	allow_empty = false;
296	MATCH_VARIABLE2(value, "${sys:", rval_sysfs);	306	fcn2 = NULL;
297	MATCH_VARIABLE2(value, "${var:", rval_var);	307	MATCH_VARIABLE(value, "${OpenName}", rval_open_name, false);
298	MATCH_VARIABLE2(value, "${CardIdByName:", rval_card_id_by_name);	308	MATCH_VARIABLE(value, "${ConfTopDir}", rval_conf_topdir, false);
299	err = -EINVAL;	309	MATCH_VARIABLE(value, "${ConfDir}", rval_conf_dir, false);
300	tmp = strchr(value, '}');	310	MATCH_VARIABLE(value, "${ConfName}", rval_conf_name, false);
301	if (tmp) {	311	MATCH_VARIABLE(value, "${CardNumber}", rval_card_number, true);
302	strncpy(r, value, tmp + 1 - value);	312	MATCH_VARIABLE(value, "${CardId}", rval_card_id, false);
303	r[tmp + 1 - value] = '\0';	313	MATCH_VARIABLE(value, "${CardDriver}", rval_card_driver, false);
304	uc_error("variable '%s' is not known!", r);	314	MATCH_VARIABLE(value, "${CardName}", rval_card_name, false);
		315	MATCH_VARIABLE(value, "${CardLongName}", rval_card_longname, false);
		316	MATCH_VARIABLE(value, "${CardComponents}", rval_card_components, true);
		317	MATCH_VARIABLE2(value, "${env:", rval_env);
		318	MATCH_VARIABLE2(value, "${sys:", rval_sysfs);
		319	MATCH_VARIABLE2(value, "${var:", rval_var);
		320	MATCH_VARIABLE2(value, "${CardNumberByName:", rval_card_number_by_name);
		321	MATCH_VARIABLE2(value, "${CardIdByName:", rval_card_id_by_name);
		322	__merr:
		323	err = -EINVAL;
		324	tmp = strchr(value, '}');
		325	if (tmp) {
		326	strncpy(r, value, tmp + 1 - value);
		327	r[tmp + 1 - value] = '\0';
		328	uc_error("variable '%s' is not known!", r);
		329	} else {
		330	uc_error("variable reference '%s' is not complete", value);
		331	}
		332	goto __error;
		333	__match2:
		334	tmp = strchr(value + idsize, '}');
		335	if (tmp) {
		336	rvalsize = tmp - (value + idsize);
		337	if (rvalsize > sizeof(v2)) {
		338	err = -ENOMEM;
		339	goto __error;
		340	}
		341	strncpy(v2, value + idsize, rvalsize);
		342	v2[rvalsize] = '\0';
		343	idsize += rvalsize + 1;
		344	if (*v2 == '$' && uc_mgr->conf_format >= 3) {
		345	tmp = uc_mgr_get_variable(uc_mgr, v2 + 1);
		346	if (tmp == NULL) {
		347	uc_error("define '%s' is not reachable in this context!", v2 + 1);
		348	rval = NULL;
		349	} else {
		350	rval = fcn2(uc_mgr, tmp);
		351	}
305	} else {	352	} else {
306	uc_error("variable reference '%s' is not complete", value);	353	rval = fcn2(uc_mgr, v2);
307	}	354	}
308	goto __error;	355	goto __rval;
		356	}
		357	goto __merr;
309	__rval:	358	__rval:
310	if (rval == NULL \|\| (!allow_empty && rval[0] == '\0')) {	359	if (rval == NULL \|\| (!allow_empty && rval[0] == '\0')) {
		360	free(rval);
		361	if (ignore_error) {
		362	value += idsize;
		363	continue;
		364	}
		365	strncpy(r, value, idsize);
		366	r[idsize] = '\0';
		367	uc_error("variable '%s' is not defined in this context!", r);
		368	err = -EINVAL;
		369	goto __error;
		370	}
		371	value += idsize;
		372	rvalsize = strlen(rval);
		373	nsize = size + rvalsize - idsize;
		374	if (nsize > size) {
		375	nr = realloc(r, nsize);
		376	if (nr == NULL) {
311	free(rval);	377	free(rval);
312	strncpy(r, value, idsize);	378	err = -ENOMEM;
313	r[idsize] = '\0';
314	uc_error("variable '%s' is not defined in this context!", r);
315	err = -EINVAL;
316	goto __error;	379	goto __error;
317	}	380	}
318	value += idsize;	381	size = nsize;
319	rvalsize = strlen(rval);	382	r = nr;
320	nsize = size + rvalsize - idsize;
321	if (nsize > size) {
322	nr = realloc(r, nsize);
323	if (nr == NULL) {
324	free(rval);
325	err = -ENOMEM;
326	goto __error;
327	}
328	size = nsize;
329	r = nr;
330	}
331	strcpy(r + dpos, rval);
332	dpos += rvalsize;
333	free(rval);
334	} else {
335	r[dpos++] = *value;
336	value++;
337	}	383	}
		384	strcpy(r + dpos, rval);
		385	dpos += rvalsize;
		386	free(rval);
338	}	387	}
339	r[dpos] = '\0';	388	r[dpos] = '\0';
340		389