/**

 * \file mixer/simple_none.c

 * \brief Mixer Simple Element Class Interface

 * \author Jaroslav Kysela <perex@perex.cz>

 * \author Abramo Bagnara <abramo@alsa-project.org>

 * \date 2001-2004

 *

 * Mixer simple element class interface.

 */

/*

 *  Mixer Interface - simple controls

 *  Copyright (c) 2000,2004 by Jaroslav Kysela <perex@perex.cz>

 *  Copyright (c) 2001 by Abramo Bagnara <abramo@alsa-project.org>

 *

 *

 *   This library is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU Lesser General Public License as

 *   published by the Free Software Foundation; either version 2.1 of

 *   the License, or (at your option) any later version.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU Lesser General Public License for more details.

 *

 *   You should have received a copy of the GNU Lesser General Public

 *   License along with this library; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <assert.h>

#include <math.h>

#include <limits.h>

#include "local.h"

#include "config.h"

#include "mixer_simple.h"

#ifndef DOC_HIDDEN

#define MIXER_COMPARE_WEIGHT_SIMPLE_BASE        0

#define MIXER_COMPARE_WEIGHT_NEXT_BASE          10000000

#define MIXER_COMPARE_WEIGHT_NOT_FOUND          1000000000

typedef enum _selem_ctl_type {

	CTL_SINGLE,

	CTL_GLOBAL_ENUM,

	CTL_GLOBAL_SWITCH,

	CTL_GLOBAL_VOLUME,

	CTL_GLOBAL_ROUTE,

	CTL_PLAYBACK_ENUM,

	CTL_PLAYBACK_SWITCH,

	CTL_PLAYBACK_VOLUME,

	CTL_PLAYBACK_ROUTE,

	CTL_CAPTURE_ENUM,

	CTL_CAPTURE_SWITCH,

	CTL_CAPTURE_VOLUME,

	CTL_CAPTURE_ROUTE,

	CTL_CAPTURE_SOURCE,

	CTL_LAST = CTL_CAPTURE_SOURCE,

} selem_ctl_type_t;

typedef struct _selem_ctl {

	snd_hctl_elem_t *elem;

	snd_ctl_elem_type_t type;

	unsigned int inactive: 1;

	unsigned int values;

	long min, max;

} selem_ctl_t;

typedef struct _selem_none {

	sm_selem_t selem;

	selem_ctl_t ctls[CTL_LAST + 1];

	unsigned int capture_item;

	struct selem_str {

		unsigned int range: 1;	/* Forced range */

		unsigned int db_initialized: 1;

		unsigned int db_init_error: 1;

		long min, max;

		unsigned int channels;

		long vol[32];

		unsigned int sw;

		unsigned int *db_info;

	} str[2];

} selem_none_t;

static const struct mixer_name_table {

	const char *longname;

	const char *shortname;

} name_table[] = {

	{"Tone Control - Switch", "Tone"},

	{"Tone Control - Bass", "Bass"},

	{"Tone Control - Treble", "Treble"},

	{"Synth Tone Control - Switch", "Synth Tone"},

	{"Synth Tone Control - Bass", "Synth Bass"},

	{"Synth Tone Control - Treble", "Synth Treble"},

	{0, 0},

};

#endif /* !DOC_HIDDEN */

static const char *get_short_name(const char *lname)

{

	const struct mixer_name_table *p;

	for (p = name_table; p->longname; p++) {

		if (!strcmp(lname, p->longname))

			return p->shortname;

	}

	return lname;

}

static int compare_mixer_priority_lookup(const char **name, const char * const *names, int coef)

{

	int res;

	for (res = 0; *names; names++, res += coef) {

		if (!strncmp(*name, *names, strlen(*names))) {

			*name += strlen(*names);

			if (**name == ' ')

				(*name)++;

			return res+1;

		}

	}

	return MIXER_COMPARE_WEIGHT_NOT_FOUND;

}

static int get_compare_weight(const char *name, unsigned int idx)

{

	static const char *const names[] = {

		"Master",

		"Headphone",

		"Speaker",

		"Tone",

		"Bass",

		"Treble",

		"3D Control",

		"PCM",

		"Front",

		"Surround",

		"Center",

		"LFE",

		"Side",

		"Synth",

		"FM",

		"Wave",

		"Music",

		"DSP",

		"Line",

		"CD",

		"Mic",

		"Video",

		"Zoom Video",

		"Phone",

		"I2S",

		"IEC958",

		"PC Speaker",

		"Beep",

		"Aux",

		"Mono",

		"Playback",

		"Capture",

		"Mix",

		NULL

	};

	static const char *const names1[] = {

		"-",

		NULL,

	};

	static const char *const names2[] = {

		"Mono",

		"Digital",

		"Switch",

		"Depth",

		"Wide",

		"Space",

		"Level",

		"Center",

		"Output",

		"Boost",

		"Tone",

		"Bass",

		"Treble",

		NULL,

	};

	const char *name1;

	int res, res1;

	if ((res = compare_mixer_priority_lookup((const char **)&name, names, 1000)) == MIXER_COMPARE_WEIGHT_NOT_FOUND)

		return MIXER_COMPARE_WEIGHT_NOT_FOUND;

	if (*name == '\0')

		goto __res;

	for (name1 = name; *name1 != '\0'; name1++);

	for (name1--; name1 != name && *name1 != ' '; name1--);

	while (name1 != name && *name1 == ' ')

		name1--;

	if (name1 != name) {

		for (; name1 != name && *name1 != ' '; name1--);

		name = name1;

		if ((res1 = compare_mixer_priority_lookup((const char **)&name, names1, 200)) == MIXER_COMPARE_WEIGHT_NOT_FOUND)

			return res;

		res += res1;

	} else {

		name = name1;

	}

	if ((res1 = compare_mixer_priority_lookup((const char **)&name, names2, 20)) == MIXER_COMPARE_WEIGHT_NOT_FOUND)

		return res;

      __res:

	return MIXER_COMPARE_WEIGHT_SIMPLE_BASE + res + idx;

}

static long to_user(selem_none_t *s, int dir, selem_ctl_t *c, long value)

{

	int64_t n;

	if (c->max == c->min)

		return s->str[dir].min;

	n = (int64_t) (value - c->min) * (s->str[dir].max - s->str[dir].min);

	return s->str[dir].min + (n + (c->max - c->min) / 2) / (c->max - c->min);

}

static long from_user(selem_none_t *s, int dir, selem_ctl_t *c, long value)

{

	int64_t n;

	if (s->str[dir].max == s->str[dir].min)

		return c->min;

	n = (int64_t) (value - s->str[dir].min) * (c->max - c->min);

	return c->min + (n + (s->str[dir].max - s->str[dir].min) / 2) / (s->str[dir].max - s->str[dir].min);

}

static int elem_read_volume(selem_none_t *s, int dir, selem_ctl_type_t type)

{

	snd_ctl_elem_value_t ctl = {0};

	unsigned int idx;

	int err;

	selem_ctl_t *c = &s->ctls[type];

	if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

		return err;

	for (idx = 0; idx < s->str[dir].channels; idx++) {

		unsigned int idx1 = idx;

		if (idx >= c->values)

			idx1 = 0;

		s->str[dir].vol[idx] =

			to_user(s, dir, c,

				snd_ctl_elem_value_get_integer(&ctl, idx1));

	}

	return 0;

}

static int elem_read_switch(selem_none_t *s, int dir, selem_ctl_type_t type)

{

	snd_ctl_elem_value_t ctl = {0};

	unsigned int idx;

	int err;

	selem_ctl_t *c = &s->ctls[type];

	if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

		return err;

	for (idx = 0; idx < s->str[dir].channels; idx++) {

		unsigned int idx1 = idx;

		if (idx >= c->values)

			idx1 = 0;

		if (!snd_ctl_elem_value_get_integer(&ctl, idx1))

			s->str[dir].sw &= ~(1 << idx);

	}

	return 0;

}

static int elem_read_route(selem_none_t *s, int dir, selem_ctl_type_t type)

{

	snd_ctl_elem_value_t ctl = {0};

	unsigned int idx;

	int err;

	selem_ctl_t *c = &s->ctls[type];

	if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

		return err;

	for (idx = 0; idx < s->str[dir].channels; idx++) {

		unsigned int idx1 = idx;

		if (idx >= c->values)

			idx1 = 0;

		if (!snd_ctl_elem_value_get_integer(&ctl,

						    idx1 * c->values + idx1))

			s->str[dir].sw &= ~(1 << idx);

	}

	return 0;

}

static int elem_read_enum(selem_none_t *s)

{

	snd_ctl_elem_value_t ctl = {0};

	unsigned int idx;

	int err;

	int type;

	selem_ctl_t *c;

	type = CTL_GLOBAL_ENUM;

	if ((s->selem.caps & (SM_CAP_CENUM | SM_CAP_PENUM)) ==

						(SM_CAP_CENUM | SM_CAP_PENUM))

		type = CTL_GLOBAL_ENUM;

	else if (s->selem.caps & SM_CAP_PENUM)

		type = CTL_PLAYBACK_ENUM;

	else if (s->selem.caps & SM_CAP_CENUM)

		type = CTL_CAPTURE_ENUM;

	c = &s->ctls[type];

	if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

		return err;

	for (idx = 0; idx < s->str[0].channels; idx++) {

		unsigned int idx1 = idx;

		if (idx >= c->values)

			idx1 = 0;

		s->str[0].vol[idx] =

				snd_ctl_elem_value_get_enumerated(&ctl, idx1);

	}

	return 0;

}

static int selem_read(snd_mixer_elem_t *elem)

{

	selem_none_t *s;

	unsigned int idx;

	int err = 0;

	long pvol[32], cvol[32];

	unsigned int psw, csw;

	assert(snd_mixer_elem_get_type(elem) == SND_MIXER_ELEM_SIMPLE);

	s = snd_mixer_elem_get_private(elem);

	memcpy(pvol, s->str[SM_PLAY].vol, sizeof(pvol));

	memset(&s->str[SM_PLAY].vol, 0, sizeof(s->str[SM_PLAY].vol));

	psw = s->str[SM_PLAY].sw;

	s->str[SM_PLAY].sw = ~0U;

	memcpy(cvol, s->str[SM_CAPT].vol, sizeof(cvol));

	memset(&s->str[SM_CAPT].vol, 0, sizeof(s->str[SM_CAPT].vol));

	csw = s->str[SM_CAPT].sw;

	s->str[SM_CAPT].sw = ~0U;

	if (s->ctls[CTL_GLOBAL_ENUM].elem) {

		err = elem_read_enum(s);

		if (err < 0)

			return err;

		goto __skip_cswitch;

	}

	if (s->ctls[CTL_CAPTURE_ENUM].elem) {

		err = elem_read_enum(s);

		if (err < 0)

			return err;

		goto __skip_cswitch;

	}

	if (s->ctls[CTL_PLAYBACK_ENUM].elem) {

		err = elem_read_enum(s);

		if (err < 0)

			return err;

		goto __skip_cswitch;

	}

	if (s->ctls[CTL_PLAYBACK_VOLUME].elem)

		err = elem_read_volume(s, SM_PLAY, CTL_PLAYBACK_VOLUME);

	else if (s->ctls[CTL_GLOBAL_VOLUME].elem)

		err = elem_read_volume(s, SM_PLAY, CTL_GLOBAL_VOLUME);

	else if (s->ctls[CTL_SINGLE].elem &&

		 s->ctls[CTL_SINGLE].type == SND_CTL_ELEM_TYPE_INTEGER)

		err = elem_read_volume(s, SM_PLAY, CTL_SINGLE);

	if (err < 0)

		return err;

	if ((s->selem.caps & (SM_CAP_GSWITCH|SM_CAP_PSWITCH)) == 0) {

		s->str[SM_PLAY].sw = 0;

		goto __skip_pswitch;

	}

	if (s->ctls[CTL_PLAYBACK_SWITCH].elem) {

		err = elem_read_switch(s, SM_PLAY, CTL_PLAYBACK_SWITCH);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_GLOBAL_SWITCH].elem) {

		err = elem_read_switch(s, SM_PLAY, CTL_GLOBAL_SWITCH);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_SINGLE].elem &&

	    s->ctls[CTL_SINGLE].type == SND_CTL_ELEM_TYPE_BOOLEAN) {

		err = elem_read_switch(s, SM_PLAY, CTL_SINGLE);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_PLAYBACK_ROUTE].elem) {

		err = elem_read_route(s, SM_PLAY, CTL_PLAYBACK_ROUTE);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_GLOBAL_ROUTE].elem) {

		err = elem_read_route(s, SM_PLAY, CTL_GLOBAL_ROUTE);

		if (err < 0)

			return err;

	}

      __skip_pswitch:

	if (s->ctls[CTL_CAPTURE_VOLUME].elem)

		err = elem_read_volume(s, SM_CAPT, CTL_CAPTURE_VOLUME);

	else if (s->ctls[CTL_GLOBAL_VOLUME].elem)

		err = elem_read_volume(s, SM_CAPT, CTL_GLOBAL_VOLUME);

	else if (s->ctls[CTL_SINGLE].elem &&

		 s->ctls[CTL_SINGLE].type == SND_CTL_ELEM_TYPE_INTEGER)

		err = elem_read_volume(s, SM_CAPT, CTL_SINGLE);

	if (err < 0)

		return err;

	if ((s->selem.caps & (SM_CAP_GSWITCH|SM_CAP_CSWITCH)) == 0) {

		s->str[SM_CAPT].sw = 0;

		goto __skip_cswitch;

	}

	if (s->ctls[CTL_CAPTURE_SWITCH].elem) {

		err = elem_read_switch(s, SM_CAPT, CTL_CAPTURE_SWITCH);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_GLOBAL_SWITCH].elem) {

		err = elem_read_switch(s, SM_CAPT, CTL_GLOBAL_SWITCH);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_SINGLE].elem &&

	    s->ctls[CTL_SINGLE].type == SND_CTL_ELEM_TYPE_BOOLEAN) {

		err = elem_read_switch(s, SM_CAPT, CTL_SINGLE);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_CAPTURE_ROUTE].elem) {

		err = elem_read_route(s, SM_CAPT, CTL_CAPTURE_ROUTE);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_GLOBAL_ROUTE].elem) {

		err = elem_read_route(s, SM_CAPT, CTL_GLOBAL_ROUTE);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_CAPTURE_SOURCE].elem) {

		snd_ctl_elem_value_t ctl = {0};

		selem_ctl_t *c = &s->ctls[CTL_CAPTURE_SOURCE];

		err = snd_hctl_elem_read(c->elem, &ctl;;

		if (err < 0)

			return err;

		for (idx = 0; idx < s->str[SM_CAPT].channels; idx++) {

			unsigned int idx1 = idx;

			if (idx >= c->values)

				idx1 = 0;

			if (snd_ctl_elem_value_get_enumerated(&ctl, idx1) !=

								s->capture_item)

				s->str[SM_CAPT].sw &= ~(1 << idx);

		}

	}

      __skip_cswitch:

	if (memcmp(pvol, s->str[SM_PLAY].vol, sizeof(pvol)) ||

	    psw != s->str[SM_PLAY].sw ||

	    memcmp(cvol, s->str[SM_CAPT].vol, sizeof(cvol)) ||

	    csw != s->str[SM_CAPT].sw)

		return 1;

	return 0;

}

static int elem_write_volume(selem_none_t *s, int dir, selem_ctl_type_t type)

{

	snd_ctl_elem_value_t ctl = {0};

	unsigned int idx;

	int err;

	selem_ctl_t *c = &s->ctls[type];

	if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

		return err;

	for (idx = 0; idx < c->values; idx++)

		snd_ctl_elem_value_set_integer(&ctl, idx,

				from_user(s, dir, c, s->str[dir].vol[idx]));

	if ((err = snd_hctl_elem_write(c->elem, &ctl)) < 0)

		return err;

	return 0;

}

static int elem_write_switch(selem_none_t *s, int dir, selem_ctl_type_t type)

{

	snd_ctl_elem_value_t ctl = {0};

	unsigned int idx;

	int err;

	selem_ctl_t *c = &s->ctls[type];

	if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

		return err;

	for (idx = 0; idx < c->values; idx++)

		snd_ctl_elem_value_set_integer(&ctl, idx,

					!!(s->str[dir].sw & (1 << idx)));

	if ((err = snd_hctl_elem_write(c->elem, &ctl)) < 0)

		return err;

	return 0;

}

static int elem_write_switch_constant(selem_none_t *s, selem_ctl_type_t type, int val)

{

	snd_ctl_elem_value_t ctl = {0};

	unsigned int idx;

	int err;

	selem_ctl_t *c = &s->ctls[type];

	if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

		return err;

	for (idx = 0; idx < c->values; idx++)

		snd_ctl_elem_value_set_integer(&ctl, idx, !!val);

	if ((err = snd_hctl_elem_write(c->elem, &ctl)) < 0)

		return err;

	return 0;

}

static int elem_write_route(selem_none_t *s, int dir, selem_ctl_type_t type)

{

	snd_ctl_elem_value_t ctl = {0};

	unsigned int idx;

	int err;

	selem_ctl_t *c = &s->ctls[type];

	if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

		return err;

	for (idx = 0; idx < c->values * c->values; idx++)

		snd_ctl_elem_value_set_integer(&ctl, idx, 0);

	for (idx = 0; idx < c->values; idx++)

		snd_ctl_elem_value_set_integer(&ctl, idx * c->values + idx,

					       !!(s->str[dir].sw & (1 << idx)));

	if ((err = snd_hctl_elem_write(c->elem, &ctl)) < 0)

		return err;

	return 0;

}

static int elem_write_enum(selem_none_t *s)

{

	snd_ctl_elem_value_t ctl = {0};

	unsigned int idx;

	int err;

	int type;

	selem_ctl_t *c;

	type = CTL_GLOBAL_ENUM;

	if ((s->selem.caps & (SM_CAP_CENUM | SM_CAP_PENUM)) ==

						(SM_CAP_CENUM | SM_CAP_PENUM))

		type = CTL_GLOBAL_ENUM;

	else if (s->selem.caps & SM_CAP_PENUM)

		type = CTL_PLAYBACK_ENUM;

	else if (s->selem.caps & SM_CAP_CENUM)

		type = CTL_CAPTURE_ENUM;

	c = &s->ctls[type];

	if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

		return err;

	for (idx = 0; idx < c->values; idx++)

		snd_ctl_elem_value_set_enumerated(&ctl, idx,

					(unsigned int)s->str[0].vol[idx]);

	if ((err = snd_hctl_elem_write(c->elem, &ctl)) < 0)

		return err;

	return 0;

}

static int selem_write_main(snd_mixer_elem_t *elem)

{

	selem_none_t *s;

	unsigned int idx;

	int err;

	assert(snd_mixer_elem_get_type(elem) == SND_MIXER_ELEM_SIMPLE);

	s = snd_mixer_elem_get_private(elem);

	if (s->ctls[CTL_GLOBAL_ENUM].elem)

		return elem_write_enum(s);

	if (s->ctls[CTL_PLAYBACK_ENUM].elem)

		return elem_write_enum(s);

	if (s->ctls[CTL_CAPTURE_ENUM].elem)

		return elem_write_enum(s);

	if (s->ctls[CTL_SINGLE].elem) {

		if (s->ctls[CTL_SINGLE].type == SND_CTL_ELEM_TYPE_INTEGER)

			err = elem_write_volume(s, SM_PLAY, CTL_SINGLE);

		else

			err = elem_write_switch(s, SM_PLAY, CTL_SINGLE);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_GLOBAL_VOLUME].elem) {

		err = elem_write_volume(s, SM_PLAY, CTL_GLOBAL_VOLUME);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_GLOBAL_SWITCH].elem) {

		if (s->ctls[CTL_PLAYBACK_SWITCH].elem &&

					s->ctls[CTL_CAPTURE_SWITCH].elem)

			err = elem_write_switch_constant(s, CTL_GLOBAL_SWITCH,

							 1);

		else

			err = elem_write_switch(s, SM_PLAY, CTL_GLOBAL_SWITCH);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_PLAYBACK_VOLUME].elem) {

		err = elem_write_volume(s, SM_PLAY, CTL_PLAYBACK_VOLUME);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_PLAYBACK_SWITCH].elem) {

		err = elem_write_switch(s, SM_PLAY, CTL_PLAYBACK_SWITCH);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_PLAYBACK_ROUTE].elem) {

		err = elem_write_route(s, SM_PLAY, CTL_PLAYBACK_ROUTE);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_CAPTURE_VOLUME].elem) {

		err = elem_write_volume(s, SM_CAPT, CTL_CAPTURE_VOLUME);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_CAPTURE_SWITCH].elem) {

		err = elem_write_switch(s, SM_CAPT, CTL_CAPTURE_SWITCH);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_CAPTURE_ROUTE].elem) {

		err = elem_write_route(s, SM_CAPT, CTL_CAPTURE_ROUTE);

		if (err < 0)

			return err;

	}

	if (s->ctls[CTL_CAPTURE_SOURCE].elem) {

		snd_ctl_elem_value_t ctl = {0};

		selem_ctl_t *c = &s->ctls[CTL_CAPTURE_SOURCE];

		if ((err = snd_hctl_elem_read(c->elem, &ctl)) < 0)

			return err;

		for (idx = 0; idx < c->values; idx++) {

			if (s->str[SM_CAPT].sw & (1 << idx))

				snd_ctl_elem_value_set_enumerated(&ctl,

							idx, s->capture_item);

		}

		if ((err = snd_hctl_elem_write(c->elem, &ctl)) < 0)

			return err;

		/* update the element, don't remove */

		err = selem_read(elem);

		if (err < 0)

			return err;

	}

	return 0;

}

static int selem_write(snd_mixer_elem_t *elem)

{

	int err;

	err = selem_write_main(elem);

	if (err < 0)

		selem_read(elem);

	return err;

}

static void selem_free(snd_mixer_elem_t *elem)

{

	selem_none_t *simple = snd_mixer_elem_get_private(elem);

	assert(snd_mixer_elem_get_type(elem) == SND_MIXER_ELEM_SIMPLE);

	if (simple->selem.id)

		snd_mixer_selem_id_free(simple->selem.id);

	/* free db range information */

	free(simple->str[0].db_info);

	free(simple->str[1].db_info);

	free(simple);

}

static int simple_update(snd_mixer_elem_t *melem)

{

	selem_none_t *simple;

	unsigned int caps, pchannels, cchannels;

	long pmin, pmax, cmin, cmax;

	selem_ctl_t *ctl;

	caps = 0;

	pchannels = 0;

	pmin = LONG_MAX;

	pmax = LONG_MIN;

	cchannels = 0;

	cmin = LONG_MAX;

	cmax = LONG_MIN;

	assert(snd_mixer_elem_get_type(melem) == SND_MIXER_ELEM_SIMPLE);

	simple = snd_mixer_elem_get_private(melem);

	ctl = &simple->ctls[CTL_SINGLE];

	if (ctl->elem) {

		pchannels = cchannels = ctl->values;

		if (ctl->type == SND_CTL_ELEM_TYPE_INTEGER) {

			caps |= SM_CAP_GVOLUME;

			pmin = cmin = ctl->min;

			pmax = cmax = ctl->max;

		} else

			caps |= SM_CAP_GSWITCH;

	}

	ctl = &simple->ctls[CTL_GLOBAL_SWITCH];

	if (ctl->elem) {

		if (pchannels < ctl->values)

			pchannels = ctl->values;

		if (cchannels < ctl->values)

			cchannels = ctl->values;

		caps |= SM_CAP_GSWITCH;

	}

	ctl = &simple->ctls[CTL_GLOBAL_ROUTE];

	if (ctl->elem) {

		if (pchannels < ctl->values)

			pchannels = ctl->values;

		if (cchannels < ctl->values)

			cchannels = ctl->values;

		caps |= SM_CAP_GSWITCH;

	}

	ctl = &simple->ctls[CTL_GLOBAL_VOLUME];

	if (ctl->elem) {

		if (pchannels < ctl->values)

			pchannels = ctl->values;

		if (pmin > ctl->min)

			pmin = ctl->min;

		if (pmax < ctl->max)

			pmax = ctl->max;

		if (cchannels < ctl->values)

			cchannels = ctl->values;

		if (cmin > ctl->min)

			cmin = ctl->min;

		if (cmax < ctl->max)

			cmax = ctl->max;

		caps |= SM_CAP_GVOLUME;

	}

	ctl = &simple->ctls[CTL_PLAYBACK_SWITCH];

	if (ctl->elem) {

		if (pchannels < ctl->values)

			pchannels = ctl->values;

		caps |= SM_CAP_PSWITCH;

		caps &= ~SM_CAP_GSWITCH;

	}

	ctl = &simple->ctls[CTL_PLAYBACK_ROUTE];

	if (ctl->elem) {

		if (pchannels < ctl->values)

			pchannels = ctl->values;

		caps |= SM_CAP_PSWITCH;

		caps &= ~SM_CAP_GSWITCH;

	}

	ctl = &simple->ctls[CTL_CAPTURE_SWITCH];

	if (ctl->elem) {

		if (cchannels < ctl->values)

			cchannels = ctl->values;

		caps |= SM_CAP_CSWITCH;

		caps &= ~SM_CAP_GSWITCH;

	}

	ctl = &simple->ctls[CTL_CAPTURE_ROUTE];

	if (ctl->elem) {

		if (cchannels < ctl->values)

			cchannels = ctl->values;

		caps |= SM_CAP_CSWITCH;

		caps &= ~SM_CAP_GSWITCH;

	}

	ctl = &simple->ctls[CTL_PLAYBACK_VOLUME];

	if (ctl->elem) {

		if (pchannels < ctl->values)

			pchannels = ctl->values;

		if (pmin > ctl->min)

			pmin = ctl->min;

		if (pmax < ctl->max)

			pmax = ctl->max;

		caps |= SM_CAP_PVOLUME;

		caps &= ~SM_CAP_GVOLUME;

	}

	ctl = &simple->ctls[CTL_CAPTURE_VOLUME];

	if (ctl->elem) {

		if (cchannels < ctl->values)

			cchannels = ctl->values;

		if (cmin > ctl->min)

			cmin = ctl->min;

		if (cmax < ctl->max)

			cmax = ctl->max;

		caps |= SM_CAP_CVOLUME;

		caps &= ~SM_CAP_GVOLUME;

	}

	ctl = &simple->ctls[CTL_CAPTURE_SOURCE];

	if (ctl->elem) {

		if (cchannels < ctl->values)

			cchannels = ctl->values;

		caps |= SM_CAP_CSWITCH | SM_CAP_CSWITCH_EXCL;

		caps &= ~SM_CAP_GSWITCH;

	}

	ctl = &simple->ctls[CTL_GLOBAL_ENUM];

	if (ctl->elem) {

		if (pchannels < ctl->values)

			pchannels = ctl->values;

		caps |= SM_CAP_PENUM | SM_CAP_CENUM;

	}

	ctl = &simple->ctls[CTL_PLAYBACK_ENUM];

	if (ctl->elem) {

		if (pchannels < ctl->values)

			pchannels = ctl->values;

		caps |= SM_CAP_PENUM;

	}

	ctl = &simple->ctls[CTL_CAPTURE_ENUM];

	if (ctl->elem) {

		if (pchannels < ctl->values)

			pchannels = ctl->values;

		caps |= SM_CAP_CENUM;

	}

	if (pchannels > 32)

		pchannels = 32;

	if (cchannels > 32)

		cchannels = 32;

	if (caps & (SM_CAP_GSWITCH|SM_CAP_PSWITCH))

		caps |= SM_CAP_PSWITCH_JOIN;

	if (caps & (SM_CAP_GVOLUME|SM_CAP_PVOLUME))

		caps |= SM_CAP_PVOLUME_JOIN;

	if (caps & (SM_CAP_GSWITCH|SM_CAP_CSWITCH))

		caps |= SM_CAP_CSWITCH_JOIN;

	if (caps & (SM_CAP_GVOLUME|SM_CAP_CVOLUME))

		caps |= SM_CAP_CVOLUME_JOIN;

	if (pchannels > 1 || cchannels > 1) {

		if (simple->ctls[CTL_SINGLE].elem &&

		    simple->ctls[CTL_SINGLE].values > 1) {

			if (caps & SM_CAP_GSWITCH)

				caps &= ~(SM_CAP_PSWITCH_JOIN|SM_CAP_CSWITCH_JOIN);

			else

				caps &= ~(SM_CAP_PVOLUME_JOIN|SM_CAP_CVOLUME_JOIN);

		}

		if (simple->ctls[CTL_GLOBAL_ROUTE].elem ||

		    (simple->ctls[CTL_GLOBAL_SWITCH].elem &&

		     simple->ctls[CTL_GLOBAL_SWITCH].values > 1)) {

			caps &= ~(SM_CAP_PSWITCH_JOIN|SM_CAP_CSWITCH_JOIN);

		}

		if (simple->ctls[CTL_GLOBAL_VOLUME].elem &&

		    simple->ctls[CTL_GLOBAL_VOLUME].values > 1) {

			caps &= ~(SM_CAP_PVOLUME_JOIN|SM_CAP_CVOLUME_JOIN);

		}

	}

	if (pchannels > 1) {

		if (simple->ctls[CTL_PLAYBACK_ROUTE].elem ||

		    (simple->ctls[CTL_PLAYBACK_SWITCH].elem &&

		     simple->ctls[CTL_PLAYBACK_SWITCH].values > 1)) {

			caps &= ~SM_CAP_PSWITCH_JOIN;

		}

		if (simple->ctls[CTL_PLAYBACK_VOLUME].elem &&

		    simple->ctls[CTL_PLAYBACK_VOLUME].values > 1) {

			caps &= ~SM_CAP_PVOLUME_JOIN;

		}

	}

	if (cchannels > 1) {

		if (simple->ctls[CTL_CAPTURE_ROUTE].elem ||

		    (simple->ctls[CTL_CAPTURE_SWITCH].elem &&

		     simple->ctls[CTL_CAPTURE_SWITCH].values > 1) ||

		    (simple->ctls[CTL_CAPTURE_SOURCE].elem &&

		     simple->ctls[CTL_CAPTURE_SOURCE].values > 1)) {

			caps &= ~SM_CAP_CSWITCH_JOIN;

		}

		if (simple->ctls[CTL_CAPTURE_VOLUME].elem &&

		    simple->ctls[CTL_CAPTURE_VOLUME].values > 1) {

			caps &= ~SM_CAP_CVOLUME_JOIN;

		}

	}

	/* exceptions */

	if ((caps & (SM_CAP_GSWITCH|SM_CAP_PSWITCH|SM_CAP_CSWITCH)) &&

	    (caps & (SM_CAP_GSWITCH|SM_CAP_PSWITCH|SM_CAP_CSWITCH)) == (caps & SM_CAP_GSWITCH)) {

		caps &= ~(SM_CAP_GSWITCH|SM_CAP_CSWITCH_JOIN|SM_CAP_CSWITCH_EXCL);

		caps |= SM_CAP_PSWITCH;

	}

	if ((caps & SM_CAP_GSWITCH) &&

	    (caps & (SM_CAP_PSWITCH|SM_CAP_CSWITCH)) == 0)

		caps |= SM_CAP_PSWITCH|SM_CAP_CSWITCH;

	if ((caps & SM_CAP_GVOLUME) &&

	    (caps & (SM_CAP_PVOLUME|SM_CAP_CVOLUME)) == 0)

		caps |= SM_CAP_PVOLUME|SM_CAP_CVOLUME;

	simple->selem.caps = caps;

	simple->str[SM_PLAY].channels = pchannels;

	if (!simple->str[SM_PLAY].range) {

		simple->str[SM_PLAY].min = pmin != LONG_MAX ? pmin : 0;

		simple->str[SM_PLAY].max = pmax != LONG_MIN ? pmax : 0;

	}