X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=filter_common.c;h=6fb9bd96ef8278b3e328198e24db78664a956542;hp=0c92f42c1e4b96760667e63a9dbc65b6dbf2d2a6;hb=5e8d8a8eea6de9459ebdf4498f9f061c84bfa63a;hpb=8b280eb4e3b4f46a95eef251520bcce3c761c9ad diff --git a/filter_common.c b/filter_common.c index 0c92f42c..6fb9bd96 100644 --- a/filter_common.c +++ b/filter_common.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2009 Andre Noll + * Copyright (C) 2005 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -8,8 +8,6 @@ #include #include -#include -#include #include "para.h" #include "list.h" @@ -21,83 +19,39 @@ #include "error.h" #include "string.h" -/** The array of supported filters. */ -struct filter filters[NUM_SUPPORTED_FILTERS] = {FILTER_ARRAY}; +/** Iterate over the array of supported filters. */ +#define FOR_EACH_SUPPORTED_FILTER(j) for (j = 0; j < NUM_SUPPORTED_FILTERS; j++) -/** - * Call the init function of each supported filter. - * \sa filter::init - */ -void filter_init(void) -{ - int i; - - FOR_EACH_SUPPORTED_FILTER(i) - filters[i].init(filters + i); -} +/** The array of supported filters. */ +static struct filter filters[NUM_SUPPORTED_FILTERS] = {FILTER_ARRAY}; /** - * Close and destroy a filter callback. - * - * \param fcb The filter callback to close. + * Obtain a reference to a filter structure. * - * This removes \a fcb from the list of filter callbacks and calls - * the close callback associated with \a fcb. - */ -static void close_filter_callback(struct filter_callback *fcb) -{ - PARA_NOTICE_LOG("closing filter_callback %p\n", fcb); - list_del(&fcb->node); - fcb->close(fcb); -} - -/** - * Close all callbacks of a filter node. + * \param filter_num Between zero and NUM_SUPPORTED_FILTERS, inclusively. * - * \param fn The filter node which contains the filter callbacks to be closed. + * \return Pointer to the filter identified by the given filter number. * - * Call close_filter_callback() for each entry in the filter callback list - * of \a fn. + * It is a fatal error if the given number is out of range. In this case + * the function aborts. */ -static void close_callbacks(struct filter_node *fn) +const struct filter *filter_get(int filter_num) { - struct filter_callback *fcb, *tmp; - - list_for_each_entry_safe(fcb, tmp, &fn->callbacks, node) { - PARA_INFO_LOG("closing %s filter callback\n", - filters[fn->filter_num].name); - close_filter_callback(fcb); - } + assert(filter_num >= 0); + assert(filter_num < NUM_SUPPORTED_FILTERS); + return filters + filter_num; } /** - * Close all filter nodes and their callbacks. - * - * \param fc The filter chain to close. - * - * For each filter node determined by \a fc, call the close function of each - * registered filter callback as well as the close function of the - * corresponding filter. Free all resources and destroy all callback lists and - * the filter node list. - * - * \sa filter::close, filter_callback::close + * Call the init function of each supported filter. + * \sa filter::init */ -void close_filters(struct filter_chain *fc) +void filter_init(void) { - struct filter_node *fn; int i; - if (!fc) - return; - PARA_NOTICE_LOG("closing filter chain %p\n", fc); - FOR_EACH_FILTER_NODE(fn, fc, i) { - struct filter *f = filters + fn->filter_num; - close_callbacks(fn); - PARA_INFO_LOG("closing %s filter\n", f->name); - f->close(fn); - free(fn->conf); - } - free(fc->filter_nodes); + FOR_EACH_SUPPORTED_FILTER(i) + filter_get(i)->init((struct filter *)filter_get(i)); } /* @@ -106,26 +60,17 @@ void close_filters(struct filter_chain *fc) */ static int parse_filter_args(int filter_num, char *options, void **conf) { - struct filter *f = &filters[filter_num]; - int ret, i, argc = 2; + const struct filter *f = filter_get(filter_num); + int ret, argc; char **argv; -// PARA_DEBUG_LOG("%s, options: %s, parser: %p\n", f->name, -// options? options : "(none)", f->parse_config); if (!f->parse_config) return strlen(options)? -E_BAD_FILTER_OPTIONS : filter_num; -// PARA_DEBUG_LOG("options: %s\n", options); - argc = create_argv(options, " \t", &argv); + argc = create_shifted_argv(options, " \t", &argv); if (argc < 0) return -E_BAD_FILTER_OPTIONS; - PARA_DEBUG_LOG("argc = %d, argv[0]: %s\n", argc, argv[0]); - for (i = argc - 1; i >= 0; i--) - argv[i + 1] = argv[i]; argv[0] = para_strdup(f->name); - argc++; ret = f->parse_config(argc, argv, conf); - free(argv[argc - 1]); - argv[argc - 1] = NULL; free_argv(argv); return ret < 0? ret : filter_num; } @@ -155,7 +100,7 @@ int check_filter_arg(char *fa, void **conf) *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) @@ -165,7 +110,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); @@ -173,34 +118,93 @@ int check_filter_arg(char *fa, void **conf) return -E_UNSUPPORTED_FILTER; } -void print_filter_helps(int detailed) +/** + * Print help text of each filter to stdout. + * + * \param flags Passed to \ref ggo_print_help(). + */ +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); } - } -void generic_filter_pre_select(struct sched *s, struct task *t) +/** + * Set select timeout of the scheduler. + * + * \param s The scheduler. + * \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, 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) { - s->timeout.tv_sec = 0; - s->timeout.tv_usec = 1; - } + if (btr_node_status(fn->btrn, fn->min_iqs, BTR_NT_INTERNAL) != 0) + sched_min_delay(s); } +#ifdef WORDS_BIGENDIAN +#define DECODER_SAMPLE_FORMAT SF_S16_BE +#else +#define DECODER_SAMPLE_FORMAT SF_S16_LE +#endif + +/** + * Execute a btr command for a decoder. + * + * The buffer tree nodes of the writers ask the parent nodes about sample_rate, + * channels count and sample format. This function is called by all decoders to + * answer these queries. + * + * \param cmd The command to be executed by the child node. + * \param sample_rate Known to the decoder. + * \param channels Known to the decoder. + * \param result Ascii representation on the answer is stored here. + * + * \return Standard. + */ +int decoder_execute(const char *cmd, unsigned sample_rate, unsigned channels, + char **result) +{ + if (!strcmp(cmd, "sample_rate")) { + if (sample_rate == 0) + return -E_BTR_NAVAIL; + *result = make_message("%u", sample_rate); + return 1; + } + if (!strcmp(cmd, "channels")) { + if (channels == 0) + return -E_BTR_NAVAIL; + *result = make_message("%u", channels); + return 1; + } + if (!strcmp(cmd, "sample_format")) { + *result = make_message("%u", DECODER_SAMPLE_FORMAT); + return 1; + } + return -ERRNO_TO_PARA_ERROR(ENOTSUP); +}