X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=filter_common.c;h=add788a8f30465251ff111822b7131cd2e94054b;hp=415824adb65f872a1815fb1f3a0af3dbd7efae6f;hb=ebbea4043aa7c7f200e4f56c3bfa42f5c31f2e03;hpb=c5e38315901ea63efd169af5d4ba3f3c66db7de9 diff --git a/filter_common.c b/filter_common.c index 415824ad..add788a8 100644 --- a/filter_common.c +++ b/filter_common.c @@ -1,143 +1,188 @@ -/* - * Copyright (C) 2005-2013 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 2005 Andre Noll , see file COPYING. */ /** \file filter_common.c Common helper functions for filter input/output. */ #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; FILTER_CMD(j); 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, or + * NULL if the filter number is out of range. + * + * \sa filter_name(). */ -void filter_init(void) +const struct filter *filter_get(int filter_num) { - int i; + if (filter_num < 1 || filter_num > LSG_NUM_FILTER_CMD_SUBCOMMANDS) + return NULL; + 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 +/** + * Return the name of a filter, given its number. + * + * \param filter_num See \ref filter_get(). + * + * \return A pointer to a string literal, or NULL if filter_num is out of + * range. The caller must not attempt to call free(3) on the returned pointer. */ -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; + if (filter_num < 1 || filter_num > LSG_NUM_FILTER_CMD_SUBCOMMANDS) + return NULL; + 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. + * \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 filter_setup(const char *fa, void **conf, struct lls_parse_result **lprp) +{ + 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; + } + 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. * - * \sa filter::parse_config + * \param detailed Whether to print short or long help. */ -int check_filter_arg(char *fa, void **conf) +void print_filter_helps(bool detailed) { - 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) + int i, num = 0; + + printf("\nAvailable filters: "); + FOR_EACH_FILTER(i) { + if (!filter_supported(i)) continue; - if (strncmp(name, fa, len)) + if (num > 50) { + printf("\n "); + num = 0; + } + num += printf("%s%s", i? " " : "", filter_name(i)); + } + printf("\n"); + + FOR_EACH_FILTER(i) { + const struct lls_command *cmd = FILTER_CMD(i); + char *help; + + if (!filter_supported(i)) continue; - c = fa[len]; - if (c && c != ' ') + help = detailed? lls_long_help(cmd) : lls_short_help(cmd); + if (!help) 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); + printf("%s\n", help); + free(help); } - return -E_UNSUPPORTED_FILTER; } /** - * Print help text of each filter to stdout. + * Print a short summary of all available filters to stdout. * - * \param detailed If non-zero, print detailed help. + * For each supported filter, the filter name and the purpose text is printed + * in a single line. Since no options are shown, the filter list is more + * concise than the text obtained from print_filter_helps(). */ -void print_filter_helps(int detailed) +void print_filter_list(void) { int i; - 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"); - - FOR_EACH_SUPPORTED_FILTER(i) { - struct filter *f = filters + i; - - if (!f->help.short_help) + printf("Available filters:\n"); + FOR_EACH_FILTER(i) { + const struct lls_command *cmd = FILTER_CMD(i); + if (!filter_supported(i)) continue; - printf_or_die("Options for %s:\n", f->name); - ggo_print_help(&f->help, detailed); + printf("%-9s %s\n", filter_name(i), lls_purpose(cmd)); } } /** - * Set select timeout of the the scheduler. + * 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 occured, a minimal timeout + * 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 +223,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);