X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=filter_common.c;h=5a5e9d037a96ce1e8db44ae9f60964688ae8a5f5;hp=907912fd06d9f0e4a78a53c7a5026c4a0a9d4846;hb=4adde8dae3317fa83b81e7a860c9ed9133e99bb0;hpb=58864df1c0784c58e421949b67a091fd0a60e140 diff --git a/filter_common.c b/filter_common.c index 907912fd..5a5e9d03 100644 --- a/filter_common.c +++ b/filter_common.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2013 Andre Noll + * Copyright (C) 2005 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -8,117 +8,137 @@ #include #include +#include +#include "filter_cmd.lsg.h" #include "para.h" #include "list.h" #include "sched.h" #include "fd.h" -#include "ggo.h" #include "buffer_tree.h" #include "filter.h" #include "error.h" #include "string.h" -/** The array of supported filters. */ -struct filter filters[NUM_SUPPORTED_FILTERS] = {FILTER_ARRAY}; +/** Iterate over all filters. */ +#define FOR_EACH_FILTER(j) for (j = 1; lls_cmd(j, filter_cmd_suite); j++) /** - * Call the init function of each supported filter. - * \sa filter::init + * Obtain a reference to a filter structure. + * + * \param filter_num Between zero and NUM_SUPPORTED_FILTERS, inclusively. + * + * \return Pointer to the filter identified by the given filter number. + * + * It is a fatal error if the given number is out of range. In this case + * the function aborts. */ -void filter_init(void) +const struct filter *filter_get(int filter_num) { - int i; + assert(filter_num >= 1); + assert(filter_num <= LSG_NUM_FILTER_CMD_SUBCOMMANDS); + return lls_user_data(FILTER_CMD(filter_num)); +} - FOR_EACH_SUPPORTED_FILTER(i) - filters[i].init(filters + i); +static inline bool filter_supported(int filter_num) +{ + return lls_user_data(FILTER_CMD(filter_num)); } -/* - * If the filter has a command line parser and options is not NULL, run it. - * Returns filter_num on success, negative on errors - */ -static int parse_filter_args(int filter_num, char *options, void **conf) +const char *filter_name(int filter_num) { - struct filter *f = &filters[filter_num]; - int ret, argc; - char **argv; - - if (!f->parse_config) - return strlen(options)? -E_BAD_FILTER_OPTIONS : filter_num; - argc = create_shifted_argv(options, " \t", &argv); - if (argc < 0) - return -E_BAD_FILTER_OPTIONS; - argv[0] = para_strdup(f->name); - ret = f->parse_config(argc, argv, conf); - free_argv(argv); - return ret < 0? ret : filter_num; + return lls_command_name(FILTER_CMD(filter_num)); } /** - * Check the filter command line options. - * - * \param fa The command line options. - * \param conf Points to the filter configuration upon successful return. + * Parse a filter command line and call the corresponding ->setup method. * - * Check if \a fa starts with a the name of a supported filter, followed by - * a colon. If yes, call the command line parser of that filter. + * \param fa The filter argument. + * \param conf Points to filter-specific setup upon successful return. + * \param lprp Parsed command line options are returned here. * - * \return On success, the number of the filter is returned and \a conf - * is initialized to point to the filter configuration determined by \a fa. - * On errors, a negative value is returned. + * Check if the given filter argument starts with the name of a supported + * filter, optionally followed by options for this filter. If yes, call the + * command line parser of that filter and its ->setup method. * - * Note: If \a fa specifies a filter that has no command line parser success is - * returned, and \a conf is initialized to \p NULL. - * - * \sa filter::parse_config + * \return This function either succeeds or does not return. On success, the + * number of the filter is returned and conf is initialized to point to the + * filter configuration as returned by the filter's ->setup() method, if any. + * Moreover, *lprp is initialized to contain the parsed command line options. + * On errors, the function calls exit(EXIT_FAILURE). */ -int check_filter_arg(char *fa, void **conf) +int filter_setup(const char *fa, void **conf, struct lls_parse_result **lprp) { - int j; - - *conf = NULL; -// PARA_DEBUG_LOG("arg: %s\n", fa); - FOR_EACH_SUPPORTED_FILTER(j) { - const char *name = filters[j].name; - size_t len = strlen(name); - char c; - if (strlen(fa) < len) - continue; - if (strncmp(name, fa, len)) - continue; - c = fa[len]; - if (c && c != ' ') - continue; - if (c && !filters[j].parse_config) - return -E_BAD_FILTER_OPTIONS; - return parse_filter_args(j, c? fa + len + 1 : - fa + strlen(fa), conf); + int ret, filter_num, argc; + char *errctx = NULL, **argv; + const struct lls_command *cmd; + const struct filter *f; + + ret = create_argv(fa, " \t\n", &argv); + if (ret < 0) + goto fail; + argc = ret; + ret = lls(lls_lookup_subcmd(argv[0], filter_cmd_suite, &errctx)); + if (ret < 0) + goto free_argv; + filter_num = ret; + cmd = FILTER_CMD(filter_num); + if (!filter_supported(filter_num)) { + ret = -E_UNSUPPORTED_FILTER; + errctx = make_message("bad filter name: %s", + lls_command_name(cmd)); + goto free_argv; } - return -E_UNSUPPORTED_FILTER; + ret = lls(lls_parse(argc, argv, cmd, lprp, &errctx)); + if (ret < 0) + goto free_argv; + f = filter_get(filter_num); + *conf = f->setup? f->setup(*lprp) : NULL; + ret = filter_num; +free_argv: + free_argv(argv); + if (ret >= 0) + return ret; +fail: + if (errctx) + PARA_ERROR_LOG("%s\n", errctx); + free(errctx); + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); + exit(EXIT_FAILURE); } /** * Print help text of each filter to stdout. * - * \param detailed If non-zero, print detailed help. + * \param detailed Whether to print short or long help. */ -void print_filter_helps(int detailed) +void print_filter_helps(bool detailed) { - int i; + int i, num = 0; - printf_or_die("\nAvailable filters: \n\t"); - FOR_EACH_SUPPORTED_FILTER(i) - printf_or_die("%s%s", i? " " : "", filters[i].name); - printf_or_die("\n\n"); + printf("\nAvailable filters: "); + FOR_EACH_FILTER(i) { + if (!filter_supported(i)) + continue; + if (num > 50) { + printf("\n "); + num = 0; + } + num += printf("%s%s", i? " " : "", filter_name(i)); + } + printf("\n"); - FOR_EACH_SUPPORTED_FILTER(i) { - struct filter *f = filters + i; + FOR_EACH_FILTER(i) { + const struct lls_command *cmd = FILTER_CMD(i); + char *help; - if (!f->help.short_help) + if (!filter_supported(i)) + continue; + help = detailed? lls_long_help(cmd) : lls_short_help(cmd); + if (!help) continue; - printf_or_die("Options for %s:\n", f->name); - ggo_print_help(&f->help, detailed); + printf("%s\n", help); + free(help); } } @@ -126,18 +146,17 @@ void print_filter_helps(int detailed) * Set select timeout of the scheduler. * * \param s The scheduler. - * \param t The task struct of this filter. + * \param context Pointer to the filter node (task context). * * This looks at the status of the btr node of the filter. If data is available * in the input queue of the filter, or if an error occurred, a minimal timeout * for the next select call is requested from the scheduler. Otherwise the * scheduler timeout is left unchanged. */ -void generic_filter_pre_select(struct sched *s, struct task *t) +void generic_filter_pre_select(struct sched *s, void *context) { - struct filter_node *fn = container_of(t, struct filter_node, task); + struct filter_node *fn = context; - t->error = 0; if (btr_node_status(fn->btrn, fn->min_iqs, BTR_NT_INTERNAL) != 0) sched_min_delay(s); } @@ -178,7 +197,7 @@ int decoder_execute(const char *cmd, unsigned sample_rate, unsigned channels, return 1; } if (!strcmp(cmd, "sample_format")) { - *result = make_message("%u", DECODER_SAMPLE_FORMAT); + *result = make_message("%d", DECODER_SAMPLE_FORMAT); return 1; } return -ERRNO_TO_PARA_ERROR(ENOTSUP);