/* tinymix.c
**
** Copyright 2011, The Android Open Source Project
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** * Neither the name of The Android Open Source Project nor the names of
** its contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY The Android Open Source Project ``AS IS'' AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
** ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
** DAMAGE.
*/
#include <tinyalsa/asoundlib.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <getopt.h>
#include <errno.h>
static void tinymix_list_controls(struct mixer *mixer);
static int tinymix_detail_control(struct mixer *mixer, const char *control,
int prefix, int print_all);
static int tinymix_set_value(struct mixer *mixer, const char *control,
char **values, unsigned int num_values);
static void tinymix_print_enum(struct mixer_ctl *ctl, const char *space,
int print_all);
static const char *tinymix_short_options = "D:atvh";
static struct option tinymix_long_options[] = {
{"device", required_argument, 0, 'D'},
{"all-values", no_argument, 0, 'a'},
{"tabs-only", no_argument, 0, 't'},
{"value-only", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
static int g_tabs_only = 0;
static int g_all_values = 0;
static int g_value_only = 0;
static void usage (void) {
fprintf(stderr,
"tinymix [options] [control name/#] [value to set]\n"
" options:\n"
" --device|-D <card#> - use the given card # instead of 0.\n"
" --all-values|-a - show all possible values/ranges for control.\n"
" --tabs-only|-t - separate all output columns/values with tabs.\n"
" --value-only|-v - show only the value for the selected control.\n"
);
}
int main(int argc, char **argv)
{
struct mixer *mixer;
int card = 0;
int ret = 0;
while (1) {
int option_index = 0;
int option_char = 0;
option_char = getopt_long(argc, argv, tinymix_short_options,
tinymix_long_options, &option_index);
if (option_char == -1)
break;
switch (option_char) {
case 'D':
card = atoi(optarg);
break;
case 'a':
g_all_values = 1;
break;
case 't':
g_tabs_only = 1;
break;
case 'v':
g_value_only = 1;
break;
case 'h':
usage();
return 0;
default:
usage();
return EINVAL;
}
}
mixer = mixer_open(card);
if (!mixer) {
fprintf(stderr, "Failed to open mixer\n");
return ENODEV;
}
if (argc == optind) {
printf("Mixer name: '%s'\n", mixer_get_name(mixer));
tinymix_list_controls(mixer);
} else if (argc == optind + 1) {
ret = tinymix_detail_control(mixer, argv[optind], !g_value_only, !g_value_only);
} else if (argc >= optind + 2) {
ret = tinymix_set_value(mixer, argv[optind], &argv[optind + 1], argc - optind - 1);
}
mixer_close(mixer);
return ret;
}
static void tinymix_list_controls(struct mixer *mixer)
{
struct mixer_ctl *ctl;
const char *name, *type;
unsigned int num_ctls, num_values;
unsigned int i;
num_ctls = mixer_get_num_ctls(mixer);
printf("Number of controls: %u\n", num_ctls);
if (g_tabs_only)
printf("ctl\ttype\tnum\tname\tvalue");
else
printf("ctl\ttype\tnum\t%-40s value\n", "name");
if (g_all_values)
printf("\trange/values\n");
else
printf("\n");
for (i = 0; i < num_ctls; i++) {
ctl = mixer_get_ctl(mixer, i);
name = mixer_ctl_get_name(ctl);
type = mixer_ctl_get_type_string(ctl);
num_values = mixer_ctl_get_num_values(ctl);
if (g_tabs_only)
printf("%d\t%s\t%d\t%s\t", i, type, num_values, name);
else
printf("%d\t%s\t%d\t%-40s ", i, type, num_values, name);
tinymix_detail_control(mixer, name, 0, g_all_values);
}
}
static void tinymix_print_enum(struct mixer_ctl *ctl, const char *space,
int print_all)
{
unsigned int num_enums;
unsigned int i;
const char *string;
int control_value = mixer_ctl_get_value(ctl, 0);
if (print_all) {
num_enums = mixer_ctl_get_num_enums(ctl);
for (i = 0; i < num_enums; i++) {
string = mixer_ctl_get_enum_string(ctl, i);
printf("%s%s%s",
control_value == (int)i ? ">" : "", string,
(i < num_enums - 1) ? space : "");
}
}
else {
string = mixer_ctl_get_enum_string(ctl, control_value);
printf("%s", string);
}
}
static int tinymix_detail_control(struct mixer *mixer, const char *control,
int prefix, int print_all)
{
struct mixer_ctl *ctl;
enum mixer_ctl_type type;
unsigned int num_values;
unsigned int i;
int min, max;
int ret;
char *buf = NULL;
size_t len;
unsigned int tlv_header_size = 0;
const char *space = g_tabs_only ? "\t" : " ";
if (isdigit(control[0]))
ctl = mixer_get_ctl(mixer, atoi(control));
else
ctl = mixer_get_ctl_by_name(mixer, control);
if (!ctl) {
fprintf(stderr, "Invalid mixer control: %s\n", control);
return ENOENT;
}
type = mixer_ctl_get_type(ctl);
num_values = mixer_ctl_get_num_values(ctl);
if (type == MIXER_CTL_TYPE_BYTE) {
if (mixer_ctl_is_access_tlv_rw(ctl)) {
tlv_header_size = TLV_HEADER_SIZE;
}
buf = calloc(1, num_values + tlv_header_size);
if (buf == NULL) {
fprintf(stderr, "Failed to alloc mem for bytes %d\n", num_values);
return ENOENT;
}
len = num_values;
ret = mixer_ctl_get_array(ctl, buf, len + tlv_header_size);
if (ret < 0) {
fprintf(stderr, "Failed to mixer_ctl_get_array\n");
free(buf);
return ENOENT;
}
}
if (prefix)
printf("%s:%s", mixer_ctl_get_name(ctl), space);
for (i = 0; i < num_values; i++) {
switch (type)
{
case MIXER_CTL_TYPE_INT:
printf("%d", mixer_ctl_get_value(ctl, i));
break;
case MIXER_CTL_TYPE_BOOL:
printf("%s", mixer_ctl_get_value(ctl, i) ? "On" : "Off");
break;
case MIXER_CTL_TYPE_ENUM:
tinymix_print_enum(ctl, space, print_all);
break;
case MIXER_CTL_TYPE_BYTE:
/* skip printing TLV header if exists */
printf(" %02x", buf[i + tlv_header_size]);
break;
default:
printf("unknown");
break;
}
if (i < num_values - 1)
printf("%s", space);
}
if (print_all) {
if (type == MIXER_CTL_TYPE_INT) {
min = mixer_ctl_get_range_min(ctl);
max = mixer_ctl_get_range_max(ctl);
printf("%s(dsrange %d->%d)", space, min, max);
}
}
free(buf);
printf("\n");
return 0;
}
static void tinymix_set_byte_ctl(struct mixer_ctl *ctl,
char **values, unsigned int num_values)
{
int ret;
char *buf;
char *end;
unsigned int i;
long n;
unsigned int *tlv, tlv_size;
unsigned int tlv_header_size = 0;
if (mixer_ctl_is_access_tlv_rw(ctl)) {
tlv_header_size = TLV_HEADER_SIZE;
}
tlv_size = num_values + tlv_header_size;
buf = calloc(1, tlv_size);
if (buf == NULL) {
fprintf(stderr, "set_byte_ctl: Failed to alloc mem for bytes %d\n", num_values);
exit(EXIT_FAILURE);
}
tlv = (unsigned int *)buf;
tlv[0] = 0;
tlv[1] = num_values;
for (i = 0; i < num_values; i++) {
errno = 0;
n = strtol(values[i], &end, 0);
if (*end) {
fprintf(stderr, "%s not an integer\n", values[i]);
goto fail;
}
if (errno) {
fprintf(stderr, "strtol: %s: %s\n", values[i],
strerror(errno));
goto fail;
}
if (n < 0 || n > 0xff) {
fprintf(stderr, "%s should be between [0, 0xff]\n",
values[i]);
goto fail;
}
/* start filling after the TLV header */
buf[i + tlv_header_size] = n;
}
ret = mixer_ctl_set_array(ctl, buf, tlv_size);
if (ret < 0) {
fprintf(stderr, "Failed to set binary control\n");
goto fail;
}
free(buf);
return;
fail:
free(buf);
exit(EXIT_FAILURE);
}
static int tinymix_set_value(struct mixer *mixer, const char *control,
char **values, unsigned int num_values)
{
struct mixer_ctl *ctl;
enum mixer_ctl_type type;
unsigned int num_ctl_values;
unsigned int i;
if (isdigit(control[0]))
ctl = mixer_get_ctl(mixer, atoi(control));
else
ctl = mixer_get_ctl_by_name(mixer, control);
if (!ctl) {
fprintf(stderr, "Invalid mixer control: %s\n", control);
return ENOENT;
}
type = mixer_ctl_get_type(ctl);
num_ctl_values = mixer_ctl_get_num_values(ctl);
if (type == MIXER_CTL_TYPE_BYTE) {
tinymix_set_byte_ctl(ctl, values, num_values);
return ENOENT;
}
if (isdigit(values[0][0])) {
if (num_values == 1) {
/* Set all values the same */
int value = atoi(values[0]);
for (i = 0; i < num_ctl_values; i++) {
if (mixer_ctl_set_value(ctl, i, value)) {
fprintf(stderr, "Error: invalid value\n");
return EINVAL;
}
}
} else {
/* Set multiple values */
if (num_values > num_ctl_values) {
fprintf(stderr,
"Error: %u values given, but control only takes %u\n",
num_values, num_ctl_values);
return EINVAL;
}
for (i = 0; i < num_values; i++) {
if (mixer_ctl_set_value(ctl, i, atoi(values[i]))) {
fprintf(stderr, "Error: invalid value for index %d\n", i);
return EINVAL;
}
}
}
} else {
if (type == MIXER_CTL_TYPE_ENUM) {
if (num_values != 1) {
fprintf(stderr, "Enclose strings in quotes and try again\n");
return EINVAL;
}
if (mixer_ctl_set_enum_by_string(ctl, values[0])) {
fprintf(stderr, "Error: invalid enum value\n");
return EINVAL;
}
} else {
fprintf(stderr, "Error: only enum types can be set with strings\n");
return EINVAL;
}
}
return 0;
}