| /* 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> |
| |
| static void tinymix_list_controls(struct mixer *mixer); |
| static void tinymix_detail_control(struct mixer *mixer, const char *control, |
| int print_all); |
| static void tinymix_set_value(struct mixer *mixer, const char *control, |
| char **values, unsigned int num_values); |
| static void tinymix_print_enum(struct mixer_ctl *ctl, int print_all); |
| |
| int main(int argc, char **argv) |
| { |
| struct mixer *mixer; |
| int card = 0; |
| |
| if ((argc > 2) && (strcmp(argv[1], "-D") == 0)) { |
| argv++; |
| if (argv[1]) { |
| card = atoi(argv[1]); |
| argv++; |
| argc -= 2; |
| } else { |
| argc -= 1; |
| } |
| } |
| |
| mixer = mixer_open(card); |
| if (!mixer) { |
| fprintf(stderr, "Failed to open mixer\n"); |
| return EXIT_FAILURE; |
| } |
| |
| |
| if (argc == 1) { |
| printf("Mixer name: '%s'\n", mixer_get_name(mixer)); |
| tinymix_list_controls(mixer); |
| } else if (argc == 2) { |
| tinymix_detail_control(mixer, argv[1], 1); |
| } else if (argc >= 3) { |
| tinymix_set_value(mixer, argv[1], &argv[2], argc - 2); |
| } else { |
| printf("Usage: tinymix [-D card] [control id] [value to set]\n"); |
| } |
| |
| mixer_close(mixer); |
| |
| return 0; |
| } |
| |
| 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: %d\n", num_ctls); |
| |
| printf("ctl\ttype\tnum\t%-40s value\n", "name"); |
| 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); |
| printf("%d\t%s\t%d\t%-40s", i, type, num_values, name); |
| tinymix_detail_control(mixer, name, 0); |
| } |
| } |
| |
| static void tinymix_print_enum(struct mixer_ctl *ctl, int print_all) |
| { |
| unsigned int num_enums; |
| unsigned int i; |
| const char *string; |
| |
| num_enums = mixer_ctl_get_num_enums(ctl); |
| |
| for (i = 0; i < num_enums; i++) { |
| string = mixer_ctl_get_enum_string(ctl, i); |
| if (print_all) |
| printf("\t%s%s", mixer_ctl_get_value(ctl, 0) == (int)i ? ">" : "", |
| string); |
| else if (mixer_ctl_get_value(ctl, 0) == (int)i) |
| printf(" %-s", string); |
| } |
| } |
| |
| static void tinymix_detail_control(struct mixer *mixer, const char *control, |
| 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; |
| |
| 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\n"); |
| return; |
| } |
| |
| type = mixer_ctl_get_type(ctl); |
| num_values = mixer_ctl_get_num_values(ctl); |
| |
| if (type == MIXER_CTL_TYPE_BYTE) { |
| |
| buf = calloc(1, num_values); |
| if (buf == NULL) { |
| fprintf(stderr, "Failed to alloc mem for bytes %d\n", num_values); |
| return; |
| } |
| |
| len = num_values; |
| ret = mixer_ctl_get_array(ctl, buf, len); |
| if (ret < 0) { |
| fprintf(stderr, "Failed to mixer_ctl_get_array\n"); |
| free(buf); |
| return; |
| } |
| } |
| |
| if (print_all) |
| printf("%s:", mixer_ctl_get_name(ctl)); |
| |
| 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, print_all); |
| break; |
| case MIXER_CTL_TYPE_BYTE: |
| printf("%02x", buf[i]); |
| break; |
| default: |
| printf(" unknown"); |
| break; |
| }; |
| } |
| |
| if (print_all) { |
| if (type == MIXER_CTL_TYPE_INT) { |
| min = mixer_ctl_get_range_min(ctl); |
| max = mixer_ctl_get_range_max(ctl); |
| printf(" (range %d->%d)", min, max); |
| } |
| } |
| |
| free(buf); |
| |
| printf("\n"); |
| } |
| |
| static void tinymix_set_byte_ctl(struct mixer_ctl *ctl, const char *control, |
| char **values, unsigned int num_values) |
| { |
| int ret; |
| char *buf; |
| char *end; |
| unsigned int i; |
| long n; |
| |
| buf = calloc(1, num_values); |
| if (buf == NULL) { |
| fprintf(stderr, "set_byte_ctl: Failed to alloc mem for bytes %d\n", num_values); |
| exit(EXIT_FAILURE); |
| } |
| |
| 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; |
| } |
| buf[i] = n; |
| } |
| |
| ret = mixer_ctl_set_array(ctl, buf, num_values); |
| if (ret < 0) { |
| fprintf(stderr, "Failed to set binary control\n"); |
| goto fail; |
| } |
| |
| free(buf); |
| return; |
| |
| fail: |
| free(buf); |
| exit(EXIT_FAILURE); |
| } |
| |
| static void 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\n"); |
| return; |
| } |
| |
| 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, control, values, num_values); |
| return; |
| } |
| |
| 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; |
| } |
| } |
| } else { |
| /* Set multiple values */ |
| if (num_values > num_ctl_values) { |
| fprintf(stderr, |
| "Error: %d values given, but control only takes %d\n", |
| num_values, num_ctl_values); |
| return; |
| } |
| 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; |
| } |
| } |
| } |
| } else { |
| if (type == MIXER_CTL_TYPE_ENUM) { |
| if (num_values != 1) { |
| fprintf(stderr, "Enclose strings in quotes and try again\n"); |
| return; |
| } |
| if (mixer_ctl_set_enum_by_string(ctl, values[0])) |
| fprintf(stderr, "Error: invalid enum value\n"); |
| } else { |
| fprintf(stderr, "Error: only enum types can be set with strings\n"); |
| } |
| } |
| } |
| |