In aplay, many command-line options are supported. Some of them have dependency or conflicts. This commit adds a structure and a parser for the options. In this patch, minimal set of options is supported. Additional options will be supported later. Signed-off-by: Takashi Sakamoto <o-takashi@xxxxxxxxxxxxx> --- axfer/Makefile.am | 5 +- axfer/options.c | 594 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ axfer/options.h | 47 +++++ 3 files changed, 645 insertions(+), 1 deletion(-) create mode 100644 axfer/options.c create mode 100644 axfer/options.h diff --git a/axfer/Makefile.am b/axfer/Makefile.am index f17e59b0..3b1a87c8 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -19,6 +19,7 @@ noinst_HEADERS = \ subcmd.h \ container.h \ mapper.h + options.h axfer_SOURCES = \ misc.h \ @@ -34,4 +35,6 @@ axfer_SOURCES = \ mapper.h \ mapper.c \ mapper-single.c \ - mapper-multiple.c + mapper-multiple.c \ + options.h \ + options.c diff --git a/axfer/options.c b/axfer/options.c new file mode 100644 index 00000000..256f93a1 --- /dev/null +++ b/axfer/options.c @@ -0,0 +1,594 @@ +/* + * options.c - a parser of commandline options. + * + * Copyright (c) 2017 Takashi Sakamoto <o-takashi@xxxxxxxxxxxxx> + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "options.h" +#include "misc.h" + +#include <getopt.h> +#include <math.h> + +static const char *const allowed_duplication[] = { + "/dev/null", + "/dev/zero", + "/dev/full", + "/dev/random", + "/dev/urandom", +}; + +static long parse_l(const char *str, int *err) +{ + long val; + char *endptr; + + val = strtol(str, &endptr, 10); + if (errno) + return -errno; + if (*endptr != '\0') + return -EINVAL; + + return val; +} + +static int allocate_paths(struct context_options *opts, char *const *paths, + unsigned int count) +{ + bool stdio = false; + char *path; + int i; + + if (count == 0) { + stdio = true; + count = 1; + } + + opts->paths = calloc(count, sizeof(opts->paths[0])); + if (opts->paths == NULL) + return -ENOMEM; + opts->path_count = count; + + if (stdio) { + opts->paths[0] = malloc(2); + if (opts->paths[0] == NULL) + return -ENOMEM; + strcpy(opts->paths[0], "-"); + return 0; + } + + for (i = 0; i < count; ++i) { + path = malloc(strlen(paths[i]) + 1); + if (path == NULL) + return -ENOMEM; + strcpy(path, paths[i]); + opts->paths[i] = path; + } + + return 0; +} + +static int verify_cntr_format(struct context_options *opts, const char *literal) +{ + static const struct { + const char *const literal; + enum container_format cntr_format; + } *entry, entries[] = { + {"raw", CONTAINER_FORMAT_RAW}, + {"voc", CONTAINER_FORMAT_VOC}, + {"wav", CONTAINER_FORMAT_RIFF_WAVE}, + {"au", CONTAINER_FORMAT_AU}, + {"sparc", CONTAINER_FORMAT_AU}, + }; + int i; + + for (i = 0; i < ARRAY_SIZE(entries); ++i) { + entry = &entries[i]; + if (strcasecmp(literal, entry->literal)) + continue; + + opts->cntr_format = entry->cntr_format; + return 0; + } + + fprintf(stderr, "unrecognized file format '%s'\n", literal); + + return -EINVAL; +} + +/* This should be called after 'verify_cntr_format()'. */ +static int verify_sample_format(struct context_options *opts, + const char *literal) +{ + static const struct { + const char *const literal; + unsigned int frames_per_second; + unsigned int samples_per_frame; + snd_pcm_format_t le_format; + snd_pcm_format_t be_format; + } *entry, entries[] = { + {"cd", 44100, 2, SND_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S16_BE}, + {"cdr", 44100, 2, SND_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S16_BE}, + {"dat", 48000, 2, SND_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S16_BE}, + }; + int i; + + opts->sample_format = snd_pcm_format_value(literal); + if (opts->sample_format != SND_PCM_FORMAT_UNKNOWN) + return 0; + + for (i = 0; i < ARRAY_SIZE(entries); ++i) { + entry = &entries[i]; + if (strcmp(entry->literal, literal)) + continue; + + if (opts->frames_per_second > 0 && + opts->frames_per_second != entry->frames_per_second) { + fprintf(stderr, + "'%s' format can't be used with rate except " + "for %u.\n", + entry->literal, entry->frames_per_second); + return -EINVAL; + } + + if (opts->samples_per_frame > 0 && + opts->samples_per_frame != entry->samples_per_frame) { + fprintf(stderr, + "'%s' format can't be used with channel except " + "for %u.\n", + entry->literal, entry->samples_per_frame); + return -EINVAL; + } + + opts->frames_per_second = entry->frames_per_second; + opts->samples_per_frame = entry->samples_per_frame; + if (opts->cntr_format == CONTAINER_FORMAT_AU) + opts->sample_format = entry->be_format; + else + opts->sample_format = entry->le_format; + + return 0; + } + + fprintf(stderr, "wrong extended format '%s'\n", literal); + + return -EINVAL; +} + +static int apply_policies(struct context_options *opts, + snd_pcm_stream_t direction, + const char *cntr_format_literal, + const char *node_literal, + const char *sample_format_literal) +{ + int err; + + if (node_literal != NULL) { + opts->node = malloc(strlen(node_literal) + 1); + if (opts->node == NULL) { + fprintf(stderr, "Fail to allocate for node: %s\n", + node_literal); + return -ENOMEM; + } + strcpy(opts->node, node_literal); + } + + if (!cntr_format_literal) { + if (direction == SND_PCM_STREAM_CAPTURE) { + /* To stdout. */ + if (opts->path_count == 1 && + !strcmp(opts->paths[0], "-")) { + opts->cntr_format = CONTAINER_FORMAT_RAW; + } else { + /* Use first path as a representative. */ + opts->cntr_format = container_format_from_path( + opts->paths[0]); + } + } + /* For playback, perform auto-detection. */ + } else { + err = verify_cntr_format(opts, cntr_format_literal); + if (err < 0) + return err; + } + + if (opts->samples_per_frame > 0) { + if (opts->samples_per_frame < 1 || + opts->samples_per_frame > 256) { + fprintf(stderr, "invalid channels argument '%u'\n", + opts->samples_per_frame); + return -EINVAL; + } + } + + if (opts->multiple_cntrs) { + if (!strcmp(opts->paths[0], "-")) { + fprintf(stderr, + "An option for separated channels is not " + "available with stdin/stdout.\n"); + return -EINVAL; + } + + /* + * For captured PCM frames, even if one path is given for + * container files, it can be used to generate several paths. + * For this purpose, please see + * 'context_options_fixup_for_capture()'. + */ + if (direction == SND_PCM_STREAM_PLAYBACK) { + /* Require several paths for containers. */ + if (opts->path_count == 1) { + fprintf(stderr, + "An option for separated channels " + "requires several files to playback " + "PCM frames.\n"); + return -EINVAL; + } + } + } else { + /* A single path is available only. */ + if (opts->path_count > 1) { + fprintf(stderr, + "When using several files, an option for " + "sepatated channels is used with.\n"); + return -EINVAL; + } + } + + if (opts->frames_per_second > 0) { + unsigned int orig = opts->frames_per_second; + + /* For backward compatibility. */ + if (opts->frames_per_second < 300) + opts->frames_per_second *= 300; + if (opts->frames_per_second < 2000 || + opts->frames_per_second > 192000) { + fprintf(stderr, "bad speed value '%i'\n", orig); + return -EINVAL; + } + } + + opts->sample_format = SND_PCM_FORMAT_UNKNOWN; + if (sample_format_literal) { + err = verify_sample_format(opts, sample_format_literal); + if (err < 0) + return err; + } + + return 0; +} + +int context_options_init(struct context_options *opts, int argc, + char *const *argv, snd_pcm_stream_t direction) +{ + static const char *s_opts = "hvt:ID:f:c:r:"; + static const struct option l_opts[] = { + /* For generic purposes. */ + {"help", 0, 0, 'h'}, + {"verbose", 0, 0, 'v'}, + /* For containers. */ + {"file-type", 1, 0, 't'}, + /* For mapper. */ + {"separate-channels", 0, 0, 'I'}, + /* For transfer backend. */ + {"device", 1, 0, 'D'}, + {"format", 1, 0, 'f'}, + {"channels", 1, 0, 'c'}, + {"rate", 1, 0, 'r'}, + {NULL, 0, 0, 0}, + }; + const char *cntr_format_literal = NULL; + const char *node_literal = NULL; + const char *sample_format_literal = NULL; + int c; + int err = 0; + + optind = 0; + opterr = 0; + while (1) { + c = getopt_long(argc, argv, s_opts, l_opts, NULL); + if (c < 0) + break; + else if (c == 'h') + opts->help = true; + else if (c == 'v') + ++opts->verbose; + else if (c == 't') + cntr_format_literal = optarg; + else if (c == 'I') + opts->multiple_cntrs = true; + else if (c == 'D') + node_literal = optarg; + else if (c == 'f') + sample_format_literal = optarg; + else if (c == 'c') + opts->samples_per_frame = parse_l(optarg, &err); + else if (c == 'r') + opts->frames_per_second = parse_l(optarg, &err); + else + continue; + + if (err < 0) + return err; + } + + err = allocate_paths(opts, argv + optind, argc - optind); + if (err < 0) + return err; + + return apply_policies(opts, direction, cntr_format_literal, + node_literal, sample_format_literal); +} + +static int generate_path_with_suffix(struct context_options *opts, + const char *template, unsigned int index, + const char *suffix) +{ + static const char *const single_format = "%s%s"; + static const char *const multiple_format = "%s-%i%s"; + unsigned int len; + + len = strlen(template) + strlen(suffix) + 1; + if (opts->path_count > 1) + len += (unsigned int)log10(opts->path_count) + 2; + + opts->paths[index] = malloc(len); + if (opts->paths[index] == NULL) + return -ENOMEM; + + if (opts->path_count == 1) { + snprintf(opts->paths[index], len, single_format, template, + suffix); + } else { + snprintf(opts->paths[index], len, multiple_format, template, + index, suffix); + } + + return 0; +} + +static int generate_path_without_suffix(struct context_options *opts, + const char *template, + unsigned int index, const char *suffix) +{ + static const char *const single_format = "%s"; + static const char *const multiple_format = "%s-%i"; + unsigned int len; + + len = strlen(template) + 1; + if (opts->path_count > 1) + len += (unsigned int)log10(opts->path_count) + 2; + + opts->paths[index] = malloc(len); + if (opts->paths[index] == NULL) + return -ENOMEM; + + if (opts->path_count == 1) { + snprintf(opts->paths[index], len, single_format, template); + } else { + snprintf(opts->paths[index], len, multiple_format, template, + index); + } + + return 0; +} + +static int generate_path(struct context_options *opts, char *template, + unsigned int index, const char *suffix) +{ + int (*generator)(struct context_options *opts, const char *template, + unsigned int index, const char *suffix); + char *pos; + + if (strlen(suffix) > 0) { + pos = template + strlen(template) - strlen(suffix); + /* Separate filename and suffix. */ + if (!strcmp(pos, suffix)) + *pos = '\0'; + } + + /* Select handlers. */ + if (strlen(suffix) > 0) + generator = generate_path_with_suffix; + else + generator = generate_path_without_suffix; + + return generator(opts, template, index, suffix); +} + +static int create_paths(struct context_options *opts, unsigned int path_count) +{ + char *template; + const char *suffix; + int i, j; + int err = 0; + + /* Can cause memory leak. */ + assert(opts->path_count == 1); + assert(opts->paths); + assert(opts->paths[0]); + assert(opts->paths[0][0] != '\0'); + + /* Release at first. */ + template = opts->paths[0]; + free(opts->paths); + opts->paths = NULL; + + /* Allocate again. */ + opts->paths = calloc(path_count, sizeof(*opts->paths)); + if (opts->paths == NULL) { + err = -ENOMEM; + goto end; + } + opts->path_count = path_count; + + suffix = container_suffix_from_format(opts->cntr_format); + + for (i = 0; i < opts->path_count; ++i) { + /* Some file names are allowed to be duplicated. */ + for (j = 0; j < ARRAY_SIZE(allowed_duplication); ++j) { + if (!strcmp(opts->paths[i], allowed_duplication[j])) + break; + } + if (j < ARRAY_SIZE(allowed_duplication)) + continue; + + err = generate_path(opts, template, i, suffix); + if (err < 0) + break; + } +end: + free(template); + + return err; +} + +static int fixup_paths(struct context_options *opts) +{ + const char *suffix; + char *template; + int i, j; + int err = 0; + + suffix = container_suffix_from_format(opts->cntr_format); + + for (i = 0; i < opts->path_count; ++i) { + /* Some file names are allowed to be duplicated. */ + for (j = 0; j < ARRAY_SIZE(allowed_duplication); ++j) { + if (!strcmp(opts->paths[i], allowed_duplication[j])) + break; + } + if (j < ARRAY_SIZE(allowed_duplication)) + continue; + + template = opts->paths[i]; + opts->paths[i] = NULL; + err = generate_path(opts, template, i, suffix); + free(template); + if (err < 0) + break; + } + + return err; +} + +int context_options_fixup_for_capture(struct context_options *opts, + unsigned int samples_per_frame) +{ + int i, j; + int err; + + if (!opts->multiple_cntrs) { + if (opts->path_count == 1) + err = fixup_paths(opts); + else + return -EINVAL; + } else { + if (opts->path_count == 1) { + err = create_paths(opts, samples_per_frame); + } else { + if (opts->path_count == samples_per_frame) + err = fixup_paths(opts); + else + return -EINVAL; + } + } + if (err < 0) + return err; + + /* Check duplication of the paths. */ + for (i = 0; i < opts->path_count - 1; ++i) { + /* Some file names are allowed to be duplicated. */ + for (j = 0; j < ARRAY_SIZE(allowed_duplication); ++j) { + if (!strcmp(opts->paths[i], allowed_duplication[j])) + break; + } + if (j < ARRAY_SIZE(allowed_duplication)) + continue; + + for (j = i + 1; j < opts->path_count; ++j) { + if (!strcmp(opts->paths[i], opts->paths[j])) { + fprintf(stderr, + "Detect duplicated file names:\n"); + err = -EINVAL; + break; + } + } + if (j < opts->path_count) + break; + } + + if (opts->verbose > 1) + fprintf(stderr, "Handled file names:\n"); + if (err < 0 || opts->verbose > 1) { + for (i = 0; i < opts->path_count; ++i) + fprintf(stderr, " %d: %s\n", i, opts->paths[i]); + } + + return err; +} + +int context_options_fixup_for_playback(struct context_options *opts, + snd_pcm_format_t sample_format, + unsigned int samples_per_frame, + unsigned int frames_per_second) +{ + if (opts->sample_format != SND_PCM_FORMAT_UNKNOWN) { + if (sample_format != opts->sample_format) { + fprintf(stderr, + "Sample format mismatch: %s is given but %s by " + "files\n", + snd_pcm_format_name(opts->sample_format), + snd_pcm_format_name(sample_format)); + return -EINVAL; + } + } + + if (opts->samples_per_frame > 0) { + if (samples_per_frame != opts->samples_per_frame) { + fprintf(stderr, + "The number of channels mismatch: %u is given " + "but %u by files\n", + opts->samples_per_frame, samples_per_frame); + return -EINVAL; + } + } + + if (opts->frames_per_second > 0) { + if (frames_per_second != opts->frames_per_second) { + fprintf(stderr, + "Sampling rate mismatch: %u is given but %u by " + "files\n", + opts->frames_per_second, frames_per_second); + return -EINVAL; + } + } + + if (opts->verbose > 1) { + int i; + + fprintf(stderr, "Handled file names:\n"); + for (i = 0; i < opts->path_count; ++i) { + fprintf(stderr, " %d: %s\n", i, opts->paths[i]); + } + } + + return 0; +} + +void context_options_destroy(struct context_options *opts) +{ + int i; + + if (opts->paths) { + for (i = 0; i < opts->path_count; ++i) + free(opts->paths[i]); + free(opts->paths); + } + if (opts->node) + free(opts->node); + opts->paths = NULL; + opts->node = NULL; +} diff --git a/axfer/options.h b/axfer/options.h new file mode 100644 index 00000000..38bdbb74 --- /dev/null +++ b/axfer/options.h @@ -0,0 +1,47 @@ +/* + * options.h - a header for a parser of commandline options. + * + * Copyright (c) 2017 Takashi Sakamoto <o-takashi@xxxxxxxxxxxxx> + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#ifndef __ALSA_UTILS_AXFER_OPTIONS__H_ +#define __ALSA_UTILS_AXFER_OPTIONS__H_ + +#include "container.h" + +struct context_options { + bool help; + + /* For generic purposes. */ + unsigned int verbose; + + /* For containers. */ + char **paths; + unsigned int path_count; + enum container_format cntr_format; + + /* For mapper. */ + bool multiple_cntrs; + + /* For transfer backend. */ + char *node; + snd_pcm_format_t sample_format; + unsigned int samples_per_frame; + unsigned int frames_per_second; +}; + +int context_options_init(struct context_options *opts, int argc, + char *const *argv, snd_pcm_stream_t direction); +int context_options_fixup_for_playback(struct context_options *opts, + snd_pcm_format_t sample_format, + unsigned int samples_per_frame, + unsigned int frames_per_second); +int context_options_fixup_for_capture(struct context_options *opts, + unsigned int samples_per_frame); +void context_options_calculate_duration(struct context_options *opts, + unsigned int frames_per_second, uint64_t *total_frame_count); +void context_options_destroy(struct context_options *opts); + +#endif -- 2.11.0 _______________________________________________ Alsa-devel mailing list Alsa-devel@xxxxxxxxxxxxxxxx http://mailman.alsa-project.org/mailman/listinfo/alsa-devel