X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=filter_common.c;h=e9b97e54633a8770009c0f746b7daa712d4135fb;hp=415824adb65f872a1815fb1f3a0af3dbd7efae6f;hb=121015ff5cdbe6af7b84f6245ebe62fe2a52a859;hpb=c5e38315901ea63efd169af5d4ba3f3c66db7de9 diff --git a/filter_common.c b/filter_common.c index 415824ad..e9b97e54 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. */ @@ -19,8 +19,28 @@ #include "error.h" #include "string.h" +/** Iterate over the array of supported filters. */ +#define FOR_EACH_SUPPORTED_FILTER(j) for (j = 0; j < NUM_SUPPORTED_FILTERS; j++) + /** The array of supported filters. */ -struct filter filters[NUM_SUPPORTED_FILTERS] = {FILTER_ARRAY}; +static struct filter filters[NUM_SUPPORTED_FILTERS] = {FILTER_ARRAY}; + +/** + * 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. + */ +const struct filter *filter_get(int filter_num) +{ + assert(filter_num >= 0); + assert(filter_num < NUM_SUPPORTED_FILTERS); + return filters + filter_num; +} /** * Call the init function of each supported filter. @@ -31,16 +51,16 @@ void filter_init(void) int i; FOR_EACH_SUPPORTED_FILTER(i) - filters[i].init(filters + i); + filter_get(i)->init((struct filter *)filter_get(i)); } /* * 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) +static int parse_filter_args(int filter_num, const char *options, void **conf) { - struct filter *f = &filters[filter_num]; + const struct filter *f = filter_get(filter_num); int ret, argc; char **argv; @@ -58,11 +78,12 @@ static int parse_filter_args(int filter_num, char *options, void **conf) /** * Check the filter command line options. * - * \param fa The command line options. + * \param fa The filter argument. * \param conf Points to the filter configuration upon successful return. * - * 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. + * 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. * * \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. @@ -73,14 +94,14 @@ static int parse_filter_args(int filter_num, char *options, void **conf) * * \sa filter::parse_config */ -int check_filter_arg(char *fa, void **conf) +int check_filter_arg(const char *fa, void **conf) { int j; *conf = NULL; // PARA_DEBUG_LOG("arg: %s\n", fa); FOR_EACH_SUPPORTED_FILTER(j) { - const char *name = filters[j].name; + const char *name = filter_get(j)->name; size_t len = strlen(name); char c; if (strlen(fa) < len) @@ -90,7 +111,7 @@ int check_filter_arg(char *fa, void **conf) c = fa[len]; if (c && c != ' ') continue; - if (c && !filters[j].parse_config) + if (c && !filter_get(j)->parse_config) return -E_BAD_FILTER_OPTIONS; return parse_filter_args(j, c? fa + len + 1 : fa + strlen(fa), conf); @@ -101,43 +122,48 @@ int check_filter_arg(char *fa, void **conf) /** * Print help text of each filter to stdout. * - * \param detailed If non-zero, print detailed help. + * \param flags Passed to \ref ggo_print_help(). */ -void print_filter_helps(int detailed) +void print_filter_helps(unsigned flags) { - 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_or_die("\nAvailable filters: "); + FOR_EACH_SUPPORTED_FILTER(i) { + if (num > 50) { + printf_or_die("\n "); + num = 0; + } + num += printf_or_die("%s%s", i? " " : "", filter_get(i)->name); + } + printf_or_die("\n"); FOR_EACH_SUPPORTED_FILTER(i) { - struct filter *f = filters + i; + struct filter *f = (struct filter *)filter_get(i); if (!f->help.short_help) continue; - printf_or_die("Options for %s:\n", f->name); - ggo_print_help(&f->help, detailed); + printf_or_die("\nOptions for %s (%s):", f->name, + f->help.purpose); + ggo_print_help(&f->help, flags); } } /** - * 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 +204,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);