| /* |
| File autogenerated by gengetopt version 2.22.6 |
| generated with the following command: |
| gengetopt --input=/src/external/audio-tool/cmdline.ggo --file-name=cmdline --unamed-opts |
| |
| The developers of gengetopt consider the fixed text that goes in all |
| gengetopt output files to be in the public domain: |
| we make no copyright claims on it. |
| */ |
| |
| /* If we use autoconf. */ |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #ifndef FIX_UNUSED |
| #define FIX_UNUSED(X) (void) (X) /* avoid warnings for unused params */ |
| #endif |
| |
| #include <getopt.h> |
| |
| #include "cmdline.h" |
| |
| const char *gengetopt_args_info_purpose = ""; |
| |
| const char *gengetopt_args_info_usage = "Usage: audio-tool [options] command [command args]"; |
| |
| const char *gengetopt_args_info_versiontext = ""; |
| |
| const char *gengetopt_args_info_description = "Audio utility knife for playback, capture, and tests\n\nCommands:\n play <filename> - playback of an RIFF WAV file\n cap <filename> - capture to an RIFF WAV file\n mix <ctrl#> <value> - manipulate the ALSA mixer\n tone <wave> <freq> <vol dB> - generate a tone (sine wave, square wave, etc)\n pulse - generate impulses on the period boundaries\n save - save current mixer state to a file\n restore - restore mixer state from a file\n defaults - put card in audio-tool's 'default' state\n"; |
| |
| const char *gengetopt_args_info_help[] = { |
| " -h, --help Print help and exit", |
| " -V, --version Print version and exit", |
| "\nOptions:", |
| " -D, --card=INT audio card number (default=`0')", |
| " -d, --device=INT audio port (default=`0')", |
| " -p, --periods=INT frames per period (default=`1032')", |
| " -n, --num-periods=INT number of periods per buffer (default=`4')", |
| " -t, --time=INT maximum duration of command (default=`0')", |
| " -c, --channels=INT number of channels (default=`2')", |
| " -m, --channel-mask=INT Bit mask with enabled channels\n (default=`0xFFFFFFFF')", |
| " -b, --bits=INT Number of bits in output format (signed)\n (default=`16')", |
| " -r, --rate=INT Sample rate (default=`48000')", |
| "\nCopyright 2012 Texas Instruments Incorporated\nCopyright 2011 The Android Open Source Project\nCopyright 2011 Gabriel M. Beddingfield\n", |
| 0 |
| }; |
| |
| typedef enum {ARG_NO |
| , ARG_INT |
| } cmdline_parser_arg_type; |
| |
| static |
| void clear_given (struct gengetopt_args_info *args_info); |
| static |
| void clear_args (struct gengetopt_args_info *args_info); |
| |
| static int |
| cmdline_parser_internal (int argc, char **argv, struct gengetopt_args_info *args_info, |
| struct cmdline_parser_params *params, const char *additional_error); |
| |
| |
| static char * |
| gengetopt_strdup (const char *s); |
| |
| static |
| void clear_given (struct gengetopt_args_info *args_info) |
| { |
| args_info->help_given = 0 ; |
| args_info->version_given = 0 ; |
| args_info->card_given = 0 ; |
| args_info->device_given = 0 ; |
| args_info->periods_given = 0 ; |
| args_info->num_periods_given = 0 ; |
| args_info->time_given = 0 ; |
| args_info->channels_given = 0 ; |
| args_info->channel_mask_given = 0 ; |
| args_info->bits_given = 0 ; |
| args_info->rate_given = 0 ; |
| } |
| |
| static |
| void clear_args (struct gengetopt_args_info *args_info) |
| { |
| FIX_UNUSED (args_info); |
| args_info->card_arg = 0; |
| args_info->card_orig = NULL; |
| args_info->device_arg = 0; |
| args_info->device_orig = NULL; |
| args_info->periods_arg = 1032; |
| args_info->periods_orig = NULL; |
| args_info->num_periods_arg = 4; |
| args_info->num_periods_orig = NULL; |
| args_info->time_arg = 0; |
| args_info->time_orig = NULL; |
| args_info->channels_arg = 2; |
| args_info->channels_orig = NULL; |
| args_info->channel_mask_arg = 0xFFFFFFFF; |
| args_info->channel_mask_orig = NULL; |
| args_info->bits_arg = 16; |
| args_info->bits_orig = NULL; |
| args_info->rate_arg = 48000; |
| args_info->rate_orig = NULL; |
| |
| } |
| |
| static |
| void init_args_info(struct gengetopt_args_info *args_info) |
| { |
| |
| |
| args_info->help_help = gengetopt_args_info_help[0] ; |
| args_info->version_help = gengetopt_args_info_help[1] ; |
| args_info->card_help = gengetopt_args_info_help[3] ; |
| args_info->device_help = gengetopt_args_info_help[4] ; |
| args_info->periods_help = gengetopt_args_info_help[5] ; |
| args_info->num_periods_help = gengetopt_args_info_help[6] ; |
| args_info->time_help = gengetopt_args_info_help[7] ; |
| args_info->channels_help = gengetopt_args_info_help[8] ; |
| args_info->channel_mask_help = gengetopt_args_info_help[9] ; |
| args_info->bits_help = gengetopt_args_info_help[10] ; |
| args_info->rate_help = gengetopt_args_info_help[11] ; |
| |
| } |
| |
| void |
| cmdline_parser_print_version (void) |
| { |
| printf ("%s %s\n", |
| (strlen(CMDLINE_PARSER_PACKAGE_NAME) ? CMDLINE_PARSER_PACKAGE_NAME : CMDLINE_PARSER_PACKAGE), |
| CMDLINE_PARSER_VERSION); |
| |
| if (strlen(gengetopt_args_info_versiontext) > 0) |
| printf("\n%s\n", gengetopt_args_info_versiontext); |
| } |
| |
| static void print_help_common(void) { |
| cmdline_parser_print_version (); |
| |
| if (strlen(gengetopt_args_info_purpose) > 0) |
| printf("\n%s\n", gengetopt_args_info_purpose); |
| |
| if (strlen(gengetopt_args_info_usage) > 0) |
| printf("\n%s\n", gengetopt_args_info_usage); |
| |
| printf("\n"); |
| |
| if (strlen(gengetopt_args_info_description) > 0) |
| printf("%s\n\n", gengetopt_args_info_description); |
| } |
| |
| void |
| cmdline_parser_print_help (void) |
| { |
| int i = 0; |
| print_help_common(); |
| while (gengetopt_args_info_help[i]) |
| printf("%s\n", gengetopt_args_info_help[i++]); |
| } |
| |
| void |
| cmdline_parser_init (struct gengetopt_args_info *args_info) |
| { |
| clear_given (args_info); |
| clear_args (args_info); |
| init_args_info (args_info); |
| |
| args_info->inputs = 0; |
| args_info->inputs_num = 0; |
| } |
| |
| void |
| cmdline_parser_params_init(struct cmdline_parser_params *params) |
| { |
| if (params) |
| { |
| params->override = 0; |
| params->initialize = 1; |
| params->check_required = 1; |
| params->check_ambiguity = 0; |
| params->print_errors = 1; |
| } |
| } |
| |
| struct cmdline_parser_params * |
| cmdline_parser_params_create(void) |
| { |
| struct cmdline_parser_params *params = |
| (struct cmdline_parser_params *)malloc(sizeof(struct cmdline_parser_params)); |
| cmdline_parser_params_init(params); |
| return params; |
| } |
| |
| static void |
| free_string_field (char **s) |
| { |
| if (*s) |
| { |
| free (*s); |
| *s = 0; |
| } |
| } |
| |
| |
| static void |
| cmdline_parser_release (struct gengetopt_args_info *args_info) |
| { |
| unsigned int i; |
| free_string_field (&(args_info->card_orig)); |
| free_string_field (&(args_info->device_orig)); |
| free_string_field (&(args_info->periods_orig)); |
| free_string_field (&(args_info->num_periods_orig)); |
| free_string_field (&(args_info->time_orig)); |
| free_string_field (&(args_info->channels_orig)); |
| free_string_field (&(args_info->channel_mask_orig)); |
| free_string_field (&(args_info->bits_orig)); |
| free_string_field (&(args_info->rate_orig)); |
| |
| |
| for (i = 0; i < args_info->inputs_num; ++i) |
| free (args_info->inputs [i]); |
| |
| if (args_info->inputs_num) |
| free (args_info->inputs); |
| |
| clear_given (args_info); |
| } |
| |
| |
| static void |
| write_into_file(FILE *outfile, const char *opt, const char *arg, const char *values[]) |
| { |
| FIX_UNUSED (values); |
| if (arg) { |
| fprintf(outfile, "%s=\"%s\"\n", opt, arg); |
| } else { |
| fprintf(outfile, "%s\n", opt); |
| } |
| } |
| |
| |
| int |
| cmdline_parser_dump(FILE *outfile, struct gengetopt_args_info *args_info) |
| { |
| int i = 0; |
| |
| if (!outfile) |
| { |
| fprintf (stderr, "%s: cannot dump options to stream\n", CMDLINE_PARSER_PACKAGE); |
| return EXIT_FAILURE; |
| } |
| |
| if (args_info->help_given) |
| write_into_file(outfile, "help", 0, 0 ); |
| if (args_info->version_given) |
| write_into_file(outfile, "version", 0, 0 ); |
| if (args_info->card_given) |
| write_into_file(outfile, "card", args_info->card_orig, 0); |
| if (args_info->device_given) |
| write_into_file(outfile, "device", args_info->device_orig, 0); |
| if (args_info->periods_given) |
| write_into_file(outfile, "periods", args_info->periods_orig, 0); |
| if (args_info->num_periods_given) |
| write_into_file(outfile, "num-periods", args_info->num_periods_orig, 0); |
| if (args_info->time_given) |
| write_into_file(outfile, "time", args_info->time_orig, 0); |
| if (args_info->channels_given) |
| write_into_file(outfile, "channels", args_info->channels_orig, 0); |
| if (args_info->channel_mask_given) |
| write_into_file(outfile, "channel-mask", args_info->channel_mask_orig, 0); |
| if (args_info->bits_given) |
| write_into_file(outfile, "bits", args_info->bits_orig, 0); |
| if (args_info->rate_given) |
| write_into_file(outfile, "rate", args_info->rate_orig, 0); |
| |
| |
| i = EXIT_SUCCESS; |
| return i; |
| } |
| |
| int |
| cmdline_parser_file_save(const char *filename, struct gengetopt_args_info *args_info) |
| { |
| FILE *outfile; |
| int i = 0; |
| |
| outfile = fopen(filename, "w"); |
| |
| if (!outfile) |
| { |
| fprintf (stderr, "%s: cannot open file for writing: %s\n", CMDLINE_PARSER_PACKAGE, filename); |
| return EXIT_FAILURE; |
| } |
| |
| i = cmdline_parser_dump(outfile, args_info); |
| fclose (outfile); |
| |
| return i; |
| } |
| |
| void |
| cmdline_parser_free (struct gengetopt_args_info *args_info) |
| { |
| cmdline_parser_release (args_info); |
| } |
| |
| /** @brief replacement of strdup, which is not standard */ |
| char * |
| gengetopt_strdup (const char *s) |
| { |
| char *result = 0; |
| if (!s) |
| return result; |
| |
| result = (char*)malloc(strlen(s) + 1); |
| if (result == (char*)0) |
| return (char*)0; |
| strcpy(result, s); |
| return result; |
| } |
| |
| int |
| cmdline_parser (int argc, char **argv, struct gengetopt_args_info *args_info) |
| { |
| return cmdline_parser2 (argc, argv, args_info, 0, 1, 1); |
| } |
| |
| int |
| cmdline_parser_ext (int argc, char **argv, struct gengetopt_args_info *args_info, |
| struct cmdline_parser_params *params) |
| { |
| int result; |
| result = cmdline_parser_internal (argc, argv, args_info, params, 0); |
| |
| if (result == EXIT_FAILURE) |
| { |
| cmdline_parser_free (args_info); |
| exit (EXIT_FAILURE); |
| } |
| |
| return result; |
| } |
| |
| int |
| cmdline_parser2 (int argc, char **argv, struct gengetopt_args_info *args_info, int override, int initialize, int check_required) |
| { |
| int result; |
| struct cmdline_parser_params params; |
| |
| params.override = override; |
| params.initialize = initialize; |
| params.check_required = check_required; |
| params.check_ambiguity = 0; |
| params.print_errors = 1; |
| |
| result = cmdline_parser_internal (argc, argv, args_info, ¶ms, 0); |
| |
| if (result == EXIT_FAILURE) |
| { |
| cmdline_parser_free (args_info); |
| exit (EXIT_FAILURE); |
| } |
| |
| return result; |
| } |
| |
| int |
| cmdline_parser_required (struct gengetopt_args_info *args_info, const char *prog_name) |
| { |
| FIX_UNUSED (args_info); |
| FIX_UNUSED (prog_name); |
| return EXIT_SUCCESS; |
| } |
| |
| |
| static char *package_name = 0; |
| |
| /** |
| * @brief updates an option |
| * @param field the generic pointer to the field to update |
| * @param orig_field the pointer to the orig field |
| * @param field_given the pointer to the number of occurrence of this option |
| * @param prev_given the pointer to the number of occurrence already seen |
| * @param value the argument for this option (if null no arg was specified) |
| * @param possible_values the possible values for this option (if specified) |
| * @param default_value the default value (in case the option only accepts fixed values) |
| * @param arg_type the type of this option |
| * @param check_ambiguity @see cmdline_parser_params.check_ambiguity |
| * @param override @see cmdline_parser_params.override |
| * @param no_free whether to free a possible previous value |
| * @param multiple_option whether this is a multiple option |
| * @param long_opt the corresponding long option |
| * @param short_opt the corresponding short option (or '-' if none) |
| * @param additional_error possible further error specification |
| */ |
| static |
| int update_arg(void *field, char **orig_field, |
| unsigned int *field_given, unsigned int *prev_given, |
| char *value, const char *possible_values[], |
| const char *default_value, |
| cmdline_parser_arg_type arg_type, |
| int check_ambiguity, int override, |
| int no_free, int multiple_option, |
| const char *long_opt, char short_opt, |
| const char *additional_error) |
| { |
| char *stop_char = 0; |
| const char *val = value; |
| int found; |
| FIX_UNUSED (field); |
| |
| stop_char = 0; |
| found = 0; |
| |
| if (!multiple_option && prev_given && (*prev_given || (check_ambiguity && *field_given))) |
| { |
| if (short_opt != '-') |
| fprintf (stderr, "%s: `--%s' (`-%c') option given more than once%s\n", |
| package_name, long_opt, short_opt, |
| (additional_error ? additional_error : "")); |
| else |
| fprintf (stderr, "%s: `--%s' option given more than once%s\n", |
| package_name, long_opt, |
| (additional_error ? additional_error : "")); |
| return 1; /* failure */ |
| } |
| |
| FIX_UNUSED (default_value); |
| |
| if (field_given && *field_given && ! override) |
| return 0; |
| if (prev_given) |
| (*prev_given)++; |
| if (field_given) |
| (*field_given)++; |
| if (possible_values) |
| val = possible_values[found]; |
| |
| switch(arg_type) { |
| case ARG_INT: |
| if (val) *((int *)field) = strtol (val, &stop_char, 0); |
| break; |
| default: |
| break; |
| }; |
| |
| /* check numeric conversion */ |
| switch(arg_type) { |
| case ARG_INT: |
| if (val && !(stop_char && *stop_char == '\0')) { |
| fprintf(stderr, "%s: invalid numeric value: %s\n", package_name, val); |
| return 1; /* failure */ |
| } |
| break; |
| default: |
| ; |
| }; |
| |
| /* store the original value */ |
| switch(arg_type) { |
| case ARG_NO: |
| break; |
| default: |
| if (value && orig_field) { |
| if (no_free) { |
| *orig_field = value; |
| } else { |
| if (*orig_field) |
| free (*orig_field); /* free previous string */ |
| *orig_field = gengetopt_strdup (value); |
| } |
| } |
| }; |
| |
| return 0; /* OK */ |
| } |
| |
| |
| int |
| cmdline_parser_internal ( |
| int argc, char **argv, struct gengetopt_args_info *args_info, |
| struct cmdline_parser_params *params, const char *additional_error) |
| { |
| int c; /* Character of the parsed option. */ |
| |
| int error_occurred = 0; |
| struct gengetopt_args_info local_args_info; |
| |
| int override; |
| int initialize; |
| int check_required; |
| int check_ambiguity; |
| |
| package_name = argv[0]; |
| |
| override = params->override; |
| initialize = params->initialize; |
| check_required = params->check_required; |
| check_ambiguity = params->check_ambiguity; |
| |
| if (initialize) |
| cmdline_parser_init (args_info); |
| |
| cmdline_parser_init (&local_args_info); |
| |
| optarg = 0; |
| optind = 0; |
| opterr = params->print_errors; |
| optopt = '?'; |
| |
| while (1) |
| { |
| int option_index = 0; |
| |
| static struct option long_options[] = { |
| { "help", 0, NULL, 'h' }, |
| { "version", 0, NULL, 'V' }, |
| { "card", 1, NULL, 'D' }, |
| { "device", 1, NULL, 'd' }, |
| { "periods", 1, NULL, 'p' }, |
| { "num-periods", 1, NULL, 'n' }, |
| { "time", 1, NULL, 't' }, |
| { "channels", 1, NULL, 'c' }, |
| { "channel-mask", 1, NULL, 'm' }, |
| { "bits", 1, NULL, 'b' }, |
| { "rate", 1, NULL, 'r' }, |
| { 0, 0, 0, 0 } |
| }; |
| |
| c = getopt_long (argc, argv, "hVD:d:p:n:t:c:m:b:r:", long_options, &option_index); |
| |
| if (c == -1) break; /* Exit from `while (1)' loop. */ |
| |
| switch (c) |
| { |
| case 'h': /* Print help and exit. */ |
| cmdline_parser_print_help (); |
| cmdline_parser_free (&local_args_info); |
| exit (EXIT_SUCCESS); |
| |
| case 'V': /* Print version and exit. */ |
| cmdline_parser_print_version (); |
| cmdline_parser_free (&local_args_info); |
| exit (EXIT_SUCCESS); |
| |
| case 'D': /* audio card number. */ |
| |
| |
| if (update_arg( (void *)&(args_info->card_arg), |
| &(args_info->card_orig), &(args_info->card_given), |
| &(local_args_info.card_given), optarg, 0, "0", ARG_INT, |
| check_ambiguity, override, 0, 0, |
| "card", 'D', |
| additional_error)) |
| goto failure; |
| |
| break; |
| case 'd': /* audio port. */ |
| |
| |
| if (update_arg( (void *)&(args_info->device_arg), |
| &(args_info->device_orig), &(args_info->device_given), |
| &(local_args_info.device_given), optarg, 0, "0", ARG_INT, |
| check_ambiguity, override, 0, 0, |
| "device", 'd', |
| additional_error)) |
| goto failure; |
| |
| break; |
| case 'p': /* frames per period. */ |
| |
| |
| if (update_arg( (void *)&(args_info->periods_arg), |
| &(args_info->periods_orig), &(args_info->periods_given), |
| &(local_args_info.periods_given), optarg, 0, "1032", ARG_INT, |
| check_ambiguity, override, 0, 0, |
| "periods", 'p', |
| additional_error)) |
| goto failure; |
| |
| break; |
| case 'n': /* number of periods per buffer. */ |
| |
| |
| if (update_arg( (void *)&(args_info->num_periods_arg), |
| &(args_info->num_periods_orig), &(args_info->num_periods_given), |
| &(local_args_info.num_periods_given), optarg, 0, "4", ARG_INT, |
| check_ambiguity, override, 0, 0, |
| "num-periods", 'n', |
| additional_error)) |
| goto failure; |
| |
| break; |
| case 't': /* maximum duration of command. */ |
| |
| |
| if (update_arg( (void *)&(args_info->time_arg), |
| &(args_info->time_orig), &(args_info->time_given), |
| &(local_args_info.time_given), optarg, 0, "0", ARG_INT, |
| check_ambiguity, override, 0, 0, |
| "time", 't', |
| additional_error)) |
| goto failure; |
| |
| break; |
| case 'c': /* number of channels. */ |
| |
| |
| if (update_arg( (void *)&(args_info->channels_arg), |
| &(args_info->channels_orig), &(args_info->channels_given), |
| &(local_args_info.channels_given), optarg, 0, "2", ARG_INT, |
| check_ambiguity, override, 0, 0, |
| "channels", 'c', |
| additional_error)) |
| goto failure; |
| |
| break; |
| case 'm': /* Bit mask with enabled channels. */ |
| |
| |
| if (update_arg( (void *)&(args_info->channel_mask_arg), |
| &(args_info->channel_mask_orig), &(args_info->channel_mask_given), |
| &(local_args_info.channel_mask_given), optarg, 0, "0xFFFFFFFF", ARG_INT, |
| check_ambiguity, override, 0, 0, |
| "channel-mask", 'm', |
| additional_error)) |
| goto failure; |
| |
| break; |
| case 'b': /* Number of bits in output format (signed). */ |
| |
| |
| if (update_arg( (void *)&(args_info->bits_arg), |
| &(args_info->bits_orig), &(args_info->bits_given), |
| &(local_args_info.bits_given), optarg, 0, "16", ARG_INT, |
| check_ambiguity, override, 0, 0, |
| "bits", 'b', |
| additional_error)) |
| goto failure; |
| |
| break; |
| case 'r': /* Sample rate. */ |
| |
| |
| if (update_arg( (void *)&(args_info->rate_arg), |
| &(args_info->rate_orig), &(args_info->rate_given), |
| &(local_args_info.rate_given), optarg, 0, "48000", ARG_INT, |
| check_ambiguity, override, 0, 0, |
| "rate", 'r', |
| additional_error)) |
| goto failure; |
| |
| break; |
| |
| case 0: /* Long option with no short option */ |
| case '?': /* Invalid option. */ |
| /* `getopt_long' already printed an error message. */ |
| goto failure; |
| |
| default: /* bug: option not considered. */ |
| fprintf (stderr, "%s: option unknown: %c%s\n", CMDLINE_PARSER_PACKAGE, c, (additional_error ? additional_error : "")); |
| abort (); |
| } /* switch */ |
| } /* while */ |
| |
| |
| |
| |
| cmdline_parser_release (&local_args_info); |
| |
| if ( error_occurred ) |
| return (EXIT_FAILURE); |
| |
| if (optind < argc) |
| { |
| int i = 0 ; |
| int found_prog_name = 0; |
| /* whether program name, i.e., argv[0], is in the remaining args |
| (this may happen with some implementations of getopt, |
| but surely not with the one included by gengetopt) */ |
| |
| i = optind; |
| while (i < argc) |
| if (argv[i++] == argv[0]) { |
| found_prog_name = 1; |
| break; |
| } |
| i = 0; |
| |
| args_info->inputs_num = argc - optind - found_prog_name; |
| args_info->inputs = |
| (char **)(malloc ((args_info->inputs_num)*sizeof(char *))) ; |
| while (optind < argc) |
| if (argv[optind++] != argv[0]) |
| args_info->inputs[ i++ ] = gengetopt_strdup (argv[optind-1]) ; |
| } |
| |
| return 0; |
| |
| failure: |
| |
| cmdline_parser_release (&local_args_info); |
| return (EXIT_FAILURE); |
| } |