/*

 *   ALSA command line mixer utility

 *   Copyright (c) 1999-2000 by Jaroslav Kysela <perex@perex.cz>

 *

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

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation; either version 2 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 General Public License for more details.

 *

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

 *   along with this program; 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 <string.h>

#include <getopt.h>

#include <stdarg.h>

#include <ctype.h>

#include <math.h>

#include <errno.h>

#include <assert.h>

#include <alsa/asoundlib.h>

#include <poll.h>

#include <stdint.h>

#include "amixer.h"

#include "../alsamixer/volume_mapping.h"

#define LEVEL_BASIC		(1<<0)

#define LEVEL_INACTIVE		(1<<1)

#define LEVEL_ID		(1<<2)

static int quiet = 0;

static int debugflag = 0;

static int no_check = 0;

static int smixer_level = 0;

static int ignore_error = 0;

static struct snd_mixer_selem_regopt smixer_options;

static char card[64] = "default";

static void error(const char *fmt,...)

{

	va_list va;

	va_start(va, fmt);

	fprintf(stderr, "amixer: ");

	vfprintf(stderr, fmt, va);

	fprintf(stderr, "\n");

	va_end(va);

}

static int help(void)

{

	printf("Usage: amixer <options> [command]\n");

	printf("\nAvailable options:\n");

	printf("  -h,--help       this help\n");

	printf("  -c,--card N     select the card\n");

	printf("  -D,--device N   select the device, default '%s'\n", card);

	printf("  -d,--debug      debug mode\n");

	printf("  -n,--nocheck    do not perform range checking\n");

	printf("  -v,--version    print version of this program\n");

	printf("  -q,--quiet      be quiet\n");

	printf("  -i,--inactive   show also inactive controls\n");

	printf("  -a,--abstract L select abstraction level (none or basic)\n");

	printf("  -s,--stdin      Read and execute commands from stdin sequentially\n");

	printf("  -R,--raw-volume Use the raw value (default)\n");

	printf("  -M,--mapped-volume Use the mapped volume\n");

	printf("\nAvailable commands:\n");

	printf("  scontrols       show all mixer simple controls\n");

	printf("  scontents	  show contents of all mixer simple controls (default command)\n");

	printf("  sset sID P      set contents for one mixer simple control\n");

	printf("  sget sID        get contents for one mixer simple control\n");

	printf("  controls        show all controls for given card\n");

	printf("  contents        show contents of all controls for given card\n");

	printf("  cset cID P      set control contents for one control\n");

	printf("  cget cID        get control contents for one control\n");

	return 0;

}

static int info(void)

{

	int err;

	snd_ctl_t *handle;

	snd_mixer_t *mhandle;

	snd_ctl_card_info_t *info;

	snd_ctl_elem_list_t *clist;

	snd_ctl_card_info_alloca(&info;;

	snd_ctl_elem_list_alloca(&clist);

	if ((err = snd_ctl_open(&handle, card, 0)) < 0) {

		error("Control device %s open error: %s", card, snd_strerror(err));

		return err;

	}

	if ((err = snd_ctl_card_info(handle, info)) < 0) {

		error("Control device %s hw info error: %s", card, snd_strerror(err));

		return err;

	}

	printf("Card %s '%s'/'%s'\n", card, snd_ctl_card_info_get_id(info),

	       snd_ctl_card_info_get_longname(info));

	printf("  Mixer name	: '%s'\n", snd_ctl_card_info_get_mixername(info));

	printf("  Components	: '%s'\n", snd_ctl_card_info_get_components(info));

	if ((err = snd_ctl_elem_list(handle, clist)) < 0) {

		error("snd_ctl_elem_list failure: %s", snd_strerror(err));

	} else {

		printf("  Controls      : %i\n", snd_ctl_elem_list_get_count(clist));

	}

	snd_ctl_close(handle);

	if ((err = snd_mixer_open(&mhandle, 0)) < 0) {

		error("Mixer open error: %s", snd_strerror(err));

		return err;

	}

	if (smixer_level == 0 && (err = snd_mixer_attach(mhandle, card)) < 0) {

		error("Mixer attach %s error: %s", card, snd_strerror(err));

		snd_mixer_close(mhandle);

		return err;

	}

	if ((err = snd_mixer_selem_register(mhandle, smixer_level > 0 ? &smixer_options : NULL, NULL)) < 0) {

		error("Mixer register error: %s", snd_strerror(err));

		snd_mixer_close(mhandle);

		return err;

	}

	err = snd_mixer_load(mhandle);

	if (err < 0) {

		error("Mixer load %s error: %s", card, snd_strerror(err));

		snd_mixer_close(mhandle);

		return err;

	}

	printf("  Simple ctrls  : %i\n", snd_mixer_get_count(mhandle));

	snd_mixer_close(mhandle);

	return 0;

}

static const char *control_type(snd_ctl_elem_info_t *info)

{

	return snd_ctl_elem_type_name(snd_ctl_elem_info_get_type(info));

}

static const char *control_access(snd_ctl_elem_info_t *info)

{

	static char result[10];

	char *res = result;

	*res++ = snd_ctl_elem_info_is_readable(info) ? 'r' : '-';

	*res++ = snd_ctl_elem_info_is_writable(info) ? 'w' : '-';

	*res++ = snd_ctl_elem_info_is_inactive(info) ? 'i' : '-';

	*res++ = snd_ctl_elem_info_is_volatile(info) ? 'v' : '-';

	*res++ = snd_ctl_elem_info_is_locked(info) ? 'l' : '-';

	*res++ = snd_ctl_elem_info_is_tlv_readable(info) ? 'R' : '-';

	*res++ = snd_ctl_elem_info_is_tlv_writable(info) ? 'W' : '-';

	*res++ = snd_ctl_elem_info_is_tlv_commandable(info) ? 'C' : '-';

	*res++ = '\0';

	return result;

}

#define check_range(val, min, max) \

	(no_check ? (val) : ((val < min) ? (min) : (val > max) ? (max) : (val))) 

#if 0

static int convert_range(int val, int omin, int omax, int nmin, int nmax)

{

	int orange = omax - omin, nrange = nmax - nmin;

	if (orange == 0)

		return 0;

	return rint((((double)nrange * ((double)val - (double)omin)) + ((double)orange / 2.0)) / ((double)orange + (double)nmin));

}

#endif

#if 0

static int convert_db_range(int val, int omin, int omax, int nmin, int nmax)

{

	int orange = omax - omin, nrange = nmax - nmin;

	if (orange == 0)

		return 0;

	return rint((((double)nrange * ((double)val - (double)omin)) + ((double)orange / 2.0)) / (double)orange + (double)nmin);

}

#endif

/* Fuction to convert from volume to percentage. val = volume */

static int convert_prange(long val, long min, long max)

{

	long range = max - min;

	int tmp;

	if (range == 0)

		return min;

	val -= min;

	tmp = rint((double)val/(double)range * 100);

	return tmp;

}

/* Function to convert from percentage to volume. perc = percentage */

static long convert_prange1(long perc, long min, long max)

{

	long tmp;

	tmp = rint((double)perc * (double)(max - min) * 0.01);

	if (tmp == 0 && perc > 0)

		tmp++;

	return tmp + min;

}

struct volume_ops {

	int (*get_range)(snd_mixer_elem_t *elem, long *min, long *max);

	int (*get)(snd_mixer_elem_t *elem, snd_mixer_selem_channel_id_t c,

		   long *value);

	int (*set)(snd_mixer_elem_t *elem, snd_mixer_selem_channel_id_t c,

		   long value, int dir);

};

enum { VOL_RAW, VOL_DB, VOL_MAP };

struct volume_ops_set {

	int (*has_volume)(snd_mixer_elem_t *elem);

	struct volume_ops v[3];

};

static int set_playback_dB(snd_mixer_elem_t *elem,

			   snd_mixer_selem_channel_id_t c, long value, int dir)

{

	return snd_mixer_selem_set_playback_dB(elem, c, value, dir);

}

static int set_capture_dB(snd_mixer_elem_t *elem,

			  snd_mixer_selem_channel_id_t c, long value, int dir)

{

	return snd_mixer_selem_set_capture_dB(elem, c, value, dir);

}

static int set_playback_raw_volume(snd_mixer_elem_t *elem,

				   snd_mixer_selem_channel_id_t c,

				   long value, int dir)

{

	return snd_mixer_selem_set_playback_volume(elem, c, value);

}

static int set_capture_raw_volume(snd_mixer_elem_t *elem,

				  snd_mixer_selem_channel_id_t c,

				  long value, int dir)

{

	return snd_mixer_selem_set_capture_volume(elem, c, value);

}

/* FIXME: normalize to int32 space to be compatible with other types */

#define MAP_VOL_RES	(INT32_MAX / 100)

static int get_mapped_volume_range(snd_mixer_elem_t *elem,

				   long *pmin, long *pmax)

{

	*pmin = 0;

	*pmax = MAP_VOL_RES;

	return 0;

}

static int get_playback_mapped_volume(snd_mixer_elem_t *elem,

				      snd_mixer_selem_channel_id_t c,

				      long *value)

{

	*value = (rint)(get_normalized_playback_volume(elem, c) * MAP_VOL_RES);

	return 0;

}

static int set_playback_mapped_volume(snd_mixer_elem_t *elem,

				      snd_mixer_selem_channel_id_t c,

				      long value, int dir)

{

	return set_normalized_playback_volume(elem, c,

					      (double)value / MAP_VOL_RES, dir);

}

static int get_capture_mapped_volume(snd_mixer_elem_t *elem,

				     snd_mixer_selem_channel_id_t c,

				     long *value)

{

	*value = (rint)(get_normalized_capture_volume(elem, c) * MAP_VOL_RES);

	return 0;

}

static int set_capture_mapped_volume(snd_mixer_elem_t *elem,

				     snd_mixer_selem_channel_id_t c,

				     long value, int dir)

{

	return set_normalized_capture_volume(elem, c,

					     (double)value / MAP_VOL_RES, dir);

}

static const struct volume_ops_set vol_ops[2] = {

	{

		.has_volume = snd_mixer_selem_has_playback_volume,

		.v = {{ snd_mixer_selem_get_playback_volume_range,

			snd_mixer_selem_get_playback_volume,

			set_playback_raw_volume },

		      { snd_mixer_selem_get_playback_dB_range,

			snd_mixer_selem_get_playback_dB,

			set_playback_dB },

		      { get_mapped_volume_range,

			get_playback_mapped_volume,

			set_playback_mapped_volume },

		},

	},

	{

		.has_volume = snd_mixer_selem_has_capture_volume,

		.v = {{ snd_mixer_selem_get_capture_volume_range,

			snd_mixer_selem_get_capture_volume,

			set_capture_raw_volume },

		      { snd_mixer_selem_get_capture_dB_range,

			snd_mixer_selem_get_capture_dB,

			set_capture_dB },

		      { get_mapped_volume_range,

			get_capture_mapped_volume,

			set_capture_mapped_volume },

		},

	},

};

static int std_vol_type = VOL_RAW;

static int set_volume_simple(snd_mixer_elem_t *elem,

			     snd_mixer_selem_channel_id_t chn,

			     char **ptr, int dir)

{

	long val, orig, pmin, pmax;

	char *p = *ptr, *s;

	int invalid = 0, percent = 0, err = 0;

	int vol_type;

	double scale = 1.0;

	int correct = 0;

	if (! vol_ops[dir].has_volume(elem))

		invalid = 1;

	if (*p == ':')

		p++;

	if (*p == '\0' || (!isdigit(*p) && *p != '-'))

		goto skip;

	s = p;

	val = strtol(s, &p, 10);

	if (*p == '.') {

		p++;

		strtol(p, &p, 10);

	}

	if (*p == '%') {

		vol_type = std_vol_type;

		percent = 1;

		p++;

	} else if (toupper(p[0]) == 'D' && toupper(p[1]) == 'B') {

		vol_type = VOL_DB;

		p += 2;

		scale = 100;

	} else {

		vol_type = VOL_RAW;

	}

	if (*p && !strchr(",:+-", *p))

		invalid = 1;

	val = (long)(strtod(s, NULL) * scale);

	if (vol_ops[dir].v[vol_type].get_range(elem, &pmin, &pmax) < 0)

		invalid = 1;

	if (percent)

		val = (long)convert_prange1(val, pmin, pmax);

	if (*p == '+' || *p == '-') {

		if (! invalid) {

			if (vol_ops[dir].v[vol_type].get(elem, chn, &orig) < 0)

				invalid = 1;

			if (*p == '+') {

				val = orig + val;

				correct = 1;

			} else {

				val = orig - val;

				correct = -1;

			}

		}

		p++;

	}

	if (*p && !strchr(",:", *p))

		invalid = 1;

	if (! invalid) {

		val = check_range(val, pmin, pmax);

		err = vol_ops[dir].v[vol_type].set(elem, chn, val, correct);

	}

 skip:

	if (*p == ',')

		p++;

	*ptr = p;

	return err ? err : (invalid ? -ENOENT : 0);

}

static int get_bool_simple(char **ptr, char *str, int invert, int orig)

{

	if (**ptr == ':')

		(*ptr)++;

	if (!strncasecmp(*ptr, str, strlen(str))) {

		orig = 1 ^ (invert ? 1 : 0);

		while (**ptr != '\0' && **ptr != ',' && **ptr != ':')

			(*ptr)++;

	}

	if (**ptr == ',' || **ptr == ':')

		(*ptr)++;

	return orig;

}

static int simple_skip_word(char **ptr, char *str)

{

	char *xptr = *ptr;

	if (*xptr == ':')

		xptr++;

	if (!strncasecmp(xptr, str, strlen(str))) {

		while (*xptr != '\0' && *xptr != ',' && *xptr != ':')

			xptr++;

		if (*xptr == ',' || *xptr == ':')

			xptr++;

		*ptr = xptr;

		return 1;

	}

	return 0;

}

static void show_control_id(snd_ctl_elem_id_t *id)

{

	char *str;

	str = snd_ctl_ascii_elem_id_get(id);

	if (str)

		printf("%s", str);

	free(str);

}

static void print_spaces(unsigned int spaces)

{

	while (spaces-- > 0)

		putc(' ', stdout);

}

static void print_dB(long dB)

{

	if (dB < 0) {

		printf("-%li.%02lidB", -dB / 100, -dB % 100);

	} else {

		printf("%li.%02lidB", dB / 100, dB % 100);

	}

}

static void decode_tlv(unsigned int spaces, unsigned int *tlv, unsigned int tlv_size)

{

	unsigned int type = tlv[0];

	unsigned int size;

	unsigned int idx = 0;

	const char *chmap_type = NULL;

	int lf = 1;

	if (tlv_size < 2 * sizeof(unsigned int)) {

		printf("TLV size error!\n");

		return;

	}

	print_spaces(spaces);

	printf("| ");

	type = tlv[idx++];

	size = tlv[idx++];

	tlv_size -= 2 * sizeof(unsigned int);

	if (size > tlv_size) {

		printf("TLV size error (%u, %u, %u)!\n", type, size, tlv_size);

		return;

	}

	switch (type) {

	case SND_CTL_TLVT_CONTAINER:

		printf("container\n");

		size += sizeof(unsigned int) -1;

		size /= sizeof(unsigned int);

		while (idx < size) {

			if (tlv[idx+1] > (size - idx) * sizeof(unsigned int)) {

				printf("TLV size error in compound!\n");

				return;

			}

			decode_tlv(spaces + 2, tlv + idx, tlv[idx+1] + 8);

			idx += 2 + (tlv[idx+1] + sizeof(unsigned int) - 1) / sizeof(unsigned int);

		}

		lf = 0;

		break;

	case SND_CTL_TLVT_DB_SCALE:

		printf("dBscale-");

		if (size != 2 * sizeof(unsigned int)) {

			while (size > 0) {

				printf("0x%08x,", tlv[idx++]);

				size -= sizeof(unsigned int);

			}

		} else {

			printf("min=");

			print_dB((int)tlv[2]);

			printf(",step=");

			print_dB(tlv[3] & 0xffff);

			printf(",mute=%i", (tlv[3] >> 16) & 1);

		}

		break;

#ifdef SND_CTL_TLVT_DB_LINEAR

	case SND_CTL_TLVT_DB_LINEAR:

		printf("dBlinear-");

		if (size != 2 * sizeof(unsigned int)) {

			while (size > 0) {

				printf("0x%08x,", tlv[idx++]);

				size -= sizeof(unsigned int);

			}

		} else {

			printf("min=");

			print_dB((int)tlv[2]);

			printf(",max=");

			print_dB((int)tlv[3]);

		}

		break;

#endif

#ifdef SND_CTL_TLVT_DB_RANGE

	case SND_CTL_TLVT_DB_RANGE:

		printf("dBrange-\n");

		if ((size % (6 * sizeof(unsigned int))) != 0) {

			while (size > 0) {

				printf("0x%08x,", tlv[idx++]);

				size -= sizeof(unsigned int);

			}

			break;

		}

		while (size > 0) {

			print_spaces(spaces + 2);

			printf("rangemin=%i,", tlv[idx++]);

			printf(",rangemax=%i\n", tlv[idx++]);

			decode_tlv(spaces + 4, tlv + idx, 4 * sizeof(unsigned int));

			idx += 4;

			size -= 6 * sizeof(unsigned int);

		}

		break;

#endif

#ifdef SND_CTL_TLVT_DB_MINMAX

	case SND_CTL_TLVT_DB_MINMAX:

	case SND_CTL_TLVT_DB_MINMAX_MUTE:

		if (type == SND_CTL_TLVT_DB_MINMAX_MUTE)

			printf("dBminmaxmute-");

		else

			printf("dBminmax-");

		if (size != 2 * sizeof(unsigned int)) {

			while (size > 0) {

				printf("0x%08x,", tlv[idx++]);

				size -= sizeof(unsigned int);

			}

		} else {

			printf("min=");

			print_dB((int)tlv[2]);

			printf(",max=");

			print_dB((int)tlv[3]);

		}

		break;

#endif

#ifdef SND_CTL_TLVT_CHMAP_FIXED

	case SND_CTL_TLVT_CHMAP_FIXED:

		chmap_type = "fixed";

		/* Fall through */

	case SND_CTL_TLVT_CHMAP_VAR:

		if (!chmap_type)

			chmap_type = "variable";

		/* Fall through */

	case SND_CTL_TLVT_CHMAP_PAIRED:

		if (!chmap_type)

			chmap_type = "paired";

		printf("chmap-%s=", chmap_type);

		while (size > 0) {

			printf("%s", snd_pcm_chmap_name(tlv[idx++]));

			size -= sizeof(unsigned int);

			if (size > 0)

				printf(",");

		}

		break;

#endif

	default:

		printf("unk-%u-", type);

		while (size > 0) {

			printf("0x%08x,", tlv[idx++]);

			size -= sizeof(unsigned int);

		}

		break;

	}

	if (lf)

		putc('\n', stdout);

}

static int show_control(const char *space, snd_hctl_elem_t *elem,

			int level)

{

	int err;

	unsigned int item, idx, count, *tlv;

	snd_ctl_elem_type_t type;

	snd_ctl_elem_id_t *id;

	snd_ctl_elem_info_t *info;

	snd_ctl_elem_value_t *control;

	snd_aes_iec958_t iec958;

	snd_ctl_elem_id_alloca(&id;;

	snd_ctl_elem_info_alloca(&info;;

	snd_ctl_elem_value_alloca(&control);

	if ((err = snd_hctl_elem_info(elem, info)) < 0) {

		error("Control %s snd_hctl_elem_info error: %s\n", card, snd_strerror(err));

		return err;

	}

	if (level & LEVEL_ID) {

		snd_hctl_elem_get_id(elem, id);

		show_control_id(id);

		printf("\n");

	}

	count = snd_ctl_elem_info_get_count(info);

	type = snd_ctl_elem_info_get_type(info);

	printf("%s; type=%s,access=%s,values=%u", space, control_type(info), control_access(info), count);

	switch (type) {

	case SND_CTL_ELEM_TYPE_INTEGER:

		printf(",min=%li,max=%li,step=%li\n", 

		       snd_ctl_elem_info_get_min(info),

		       snd_ctl_elem_info_get_max(info),

		       snd_ctl_elem_info_get_step(info));

		break;

	case SND_CTL_ELEM_TYPE_INTEGER64:

		printf(",min=%lli,max=%lli,step=%lli\n",

		       snd_ctl_elem_info_get_min64(info),

		       snd_ctl_elem_info_get_max64(info),

		       snd_ctl_elem_info_get_step64(info));

		break;

	case SND_CTL_ELEM_TYPE_ENUMERATED:

	{

		unsigned int items = snd_ctl_elem_info_get_items(info);

		printf(",items=%u\n", items);

		for (item = 0; item < items; item++) {

			snd_ctl_elem_info_set_item(info, item);

			if ((err = snd_hctl_elem_info(elem, info)) < 0) {

				error("Control %s element info error: %s\n", card, snd_strerror(err));

				return err;

			}

			printf("%s; Item #%u '%s'\n", space, item, snd_ctl_elem_info_get_item_name(info));

		}

		break;

	}

	default:

		printf("\n");

		break;

	}

	if (level & LEVEL_BASIC) {

		if (!snd_ctl_elem_info_is_readable(info))

			goto __skip_read;

		if ((err = snd_hctl_elem_read(elem, control)) < 0) {

			error("Control %s element read error: %s\n", card, snd_strerror(err));

			return err;

		}

		printf("%s: values=", space);

		for (idx = 0; idx < count; idx++) {

			if (idx > 0)

				printf(",");

			switch (type) {

			case SND_CTL_ELEM_TYPE_BOOLEAN:

				printf("%s", snd_ctl_elem_value_get_boolean(control, idx) ? "on" : "off");

				break;

			case SND_CTL_ELEM_TYPE_INTEGER:

				printf("%li", snd_ctl_elem_value_get_integer(control, idx));

				break;

			case SND_CTL_ELEM_TYPE_INTEGER64:

				printf("%lli", snd_ctl_elem_value_get_integer64(control, idx));

				break;

			case SND_CTL_ELEM_TYPE_ENUMERATED:

				printf("%u", snd_ctl_elem_value_get_enumerated(control, idx));

				break;

			case SND_CTL_ELEM_TYPE_BYTES:

				printf("0x%02x", snd_ctl_elem_value_get_byte(control, idx));

				break;

			case SND_CTL_ELEM_TYPE_IEC958:

				snd_ctl_elem_value_get_iec958(control, &iec958);

				printf("[AES0=0x%02x AES1=0x%02x AES2=0x%02x AES3=0x%02x]",

				       iec958.status[0], iec958.status[1],

				       iec958.status[2], iec958.status[3]);

				break;

			default:

				printf("?");

				break;

			}

		}

		printf("\n");

	      __skip_read:

		if (!snd_ctl_elem_info_is_tlv_readable(info))

			goto __skip_tlv;

		/* skip ASoC ext bytes controls that may have huge binary TLV data */

		if (type == SND_CTL_ELEM_TYPE_BYTES &&

				!snd_ctl_elem_info_is_readable(info) &&

				!snd_ctl_elem_info_is_writable(info)) {

			printf("%s; ASoC TLV Byte control, skipping bytes dump\n", space);

			goto __skip_tlv;

		}

		tlv = malloc(4096);

		if ((err = snd_hctl_elem_tlv_read(elem, tlv, 4096)) < 0) {

			error("Control %s element TLV read error: %s\n", card, snd_strerror(err));

			free(tlv);

			return err;

		}

		decode_tlv(strlen(space), tlv, 4096);

		free(tlv);

	}

      __skip_tlv:

	return 0;

}

static int controls(int level)

{

	int err;

	snd_hctl_t *handle;

	snd_hctl_elem_t *elem;

	snd_ctl_elem_id_t *id;

	snd_ctl_elem_info_t *info;

	snd_ctl_elem_id_alloca(&id;;

	snd_ctl_elem_info_alloca(&info;;

	if ((err = snd_hctl_open(&handle, card, 0)) < 0) {

		error("Control %s open error: %s", card, snd_strerror(err));

		return err;

	}

	if ((err = snd_hctl_load(handle)) < 0) {

		error("Control %s local error: %s\n", card, snd_strerror(err));

		return err;

	}

	for (elem = snd_hctl_first_elem(handle); elem; elem = snd_hctl_elem_next(elem)) {

		if ((err = snd_hctl_elem_info(elem, info)) < 0) {

			error("Control %s snd_hctl_elem_info error: %s\n", card, snd_strerror(err));

			return err;

		}

		if (!(level & LEVEL_INACTIVE) && snd_ctl_elem_info_is_inactive(info))

			continue;

		snd_hctl_elem_get_id(elem, id);

		show_control_id(id);

		printf("\n");

		if (level & LEVEL_BASIC)

			show_control("  ", elem, 1);

	}

	snd_hctl_close(handle);

	return 0;

}

static void show_selem_volume(snd_mixer_elem_t *elem, 

			      snd_mixer_selem_channel_id_t chn, int dir,

			      long min, long max)

{

	long raw, val;

	vol_ops[dir].v[VOL_RAW].get(elem, chn, &raw;;

	if (std_vol_type == VOL_RAW)

		val = convert_prange(raw, min, max);

	else {

		vol_ops[dir].v[std_vol_type].get(elem, chn, &val;;

		val = convert_prange(val, 0, MAP_VOL_RES);

	}

	printf(" %li [%li%%]", raw, val);

	if (!vol_ops[dir].v[VOL_DB].get(elem, chn, &val)) {

		printf(" [");

		print_dB(val);

		printf("]");

	}

}

static int show_selem(snd_mixer_t *handle, snd_mixer_selem_id_t *id, const char *space, int level)

{

	snd_mixer_selem_channel_id_t chn;

	long pmin = 0, pmax = 0;

	long cmin = 0, cmax = 0;

	int psw, csw;

	int pmono, cmono, mono_ok = 0;

	snd_mixer_elem_t *elem;

	elem = snd_mixer_find_selem(handle, id);

	if (!elem) {

		error("Mixer %s simple element not found", card);

		return -ENOENT;

	}

	if (level & LEVEL_BASIC) {

		printf("%sCapabilities:", space);

		if (snd_mixer_selem_has_common_volume(elem)) {

			printf(" volume");

			if (snd_mixer_selem_has_playback_volume_joined(elem))

				printf(" volume-joined");

		} else {

			if (snd_mixer_selem_has_playback_volume(elem)) {

				printf(" pvolume");

				if (snd_mixer_selem_has_playback_volume_joined(elem))

					printf(" pvolume-joined");

			}

			if (snd_mixer_selem_has_capture_volume(elem)) {

				printf(" cvolume");

				if (snd_mixer_selem_has_capture_volume_joined(elem))

					printf(" cvolume-joined");

			}

		}

		if (snd_mixer_selem_has_common_switch(elem)) {

			printf(" switch");

			if (snd_mixer_selem_has_playback_switch_joined(elem))

				printf(" switch-joined");

		} else {

			if (snd_mixer_selem_has_playback_switch(elem)) {

				printf(" pswitch");

				if (snd_mixer_selem_has_playback_switch_joined(elem))

					printf(" pswitch-joined");

			}

			if (snd_mixer_selem_has_capture_switch(elem)) {

				printf(" cswitch");

				if (snd_mixer_selem_has_capture_switch_joined(elem))

					printf(" cswitch-joined");

				if (snd_mixer_selem_has_capture_switch_exclusive(elem))

					printf(" cswitch-exclusive");

			}

		}

		if (snd_mixer_selem_is_enum_playback(elem)) {

			printf(" penum");

		} else if (snd_mixer_selem_is_enum_capture(elem)) {

			printf(" cenum");

		} else if (snd_mixer_selem_is_enumerated(elem)) {

			printf(" enum");

		}

		printf("\n");

		if (snd_mixer_selem_is_enumerated(elem)) {

			int i, items;

			unsigned int idx;

			/*

			 * See snd_ctl_elem_init_enum_names() in

			 * sound/core/control.c.

			 */

			char itemname[64];

			items = snd_mixer_selem_get_enum_items(elem);

			printf("  Items:");

			for (i = 0; i < items; i++) {

				snd_mixer_selem_get_enum_item_name(elem, i, sizeof(itemname) - 1, itemname);

				printf(" '%s'", itemname);

			}

			printf("\n");

			for (i = 0; !snd_mixer_selem_get_enum_item(elem, i, &idx); i++) {

				snd_mixer_selem_get_enum_item_name(elem, idx, sizeof(itemname) - 1, itemname);

				printf("  Item%d: '%s'\n", i, itemname);

			}

			return 0; /* no more thing to do */

		}

		if (snd_mixer_selem_has_capture_switch_exclusive(elem))

			printf("%sCapture exclusive group: %i\n", space,

			       snd_mixer_selem_get_capture_group(elem));

		if (snd_mixer_selem_has_playback_volume(elem) ||

		    snd_mixer_selem_has_playback_switch(elem)) {

			printf("%sPlayback channels:", space);

			if (snd_mixer_selem_is_playback_mono(elem)) {

				printf(" Mono");

			} else {

				int first = 1;

				for (chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++){

					if (!snd_mixer_selem_has_playback_channel(elem, chn))

						continue;

					if (!first)

						printf(" -");

					printf(" %s", snd_mixer_selem_channel_name(chn));

					first = 0;

				}

			}

			printf("\n");

		}

		if (snd_mixer_selem_has_capture_volume(elem) ||

		    snd_mixer_selem_has_capture_switch(elem)) {

			printf("%sCapture channels:", space);

			if (snd_mixer_selem_is_capture_mono(elem)) {

				printf(" Mono");

			} else {

				int first = 1;

				for (chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++){

					if (!snd_mixer_selem_has_capture_channel(elem, chn))

						continue;