X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=filter_chain.c;h=7852220a21c416c6c7e747549e7f3ee68d2baf5f;hp=6265f19c931dc26b53a76eecfd887164961c928d;hb=32facbd1b7948f146515e53194cfd4f33c54353f;hpb=7533926d69875da66c5dc45940f67cb5d659738e diff --git a/filter_chain.c b/filter_chain.c index 6265f19c..7852220a 100644 --- a/filter_chain.c +++ b/filter_chain.c @@ -1,25 +1,18 @@ /* - * Copyright (C) 2005-2006 Andre Noll + * Copyright (C) 2005-2007 Andre Noll * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Licensed under the GPL v2. For licencing details see COPYING. */ /** \file filter_chain.c common helper functions for filter input/output */ +#include +#include + #include "para.h" #include "list.h" +#include "sched.h" +#include "fd.h" #include "filter.h" #include "error.h" #include "string.h" @@ -67,8 +60,11 @@ static void close_callbacks(struct filter_node *fn) { struct filter_callback *fcb, *tmp; - list_for_each_entry_safe(fcb, tmp, &fn->callbacks, node) + list_for_each_entry_safe(fcb, tmp, &fn->callbacks, node) { + PARA_INFO_LOG("closing %s filter callback\n", + fn->filter->name); close_filter_callback(fcb); + } } static void call_callbacks(struct filter_node *fn, char *inbuf, size_t inlen, @@ -95,83 +91,101 @@ static void call_callbacks(struct filter_node *fn, char *inbuf, size_t inlen, /** * call the convert function of each filter * - * \param fci the filter chain containing the list of filter nodes. + * \param s unused + * \param t the task containing the filter chain * * This is the core function of the filter subsystem. It loops over the list of - * filter nodes determined by \a fci and calls the filter's convert function if + * filter nodes determined by \a t and calls the filter's convert function if * there is input available for the filter node in question. If the convert * function consumed some or all of its input data, all registered input * callbacks are called. Similarly, if a convert function produced output, all * registerd output callbacks get called. * - * \return The sum of output bytes produced by the convert functions on success, - * negative return value on errors. + * \return The sum of output bytes produced by the convert functions on + * success, negative return value on errors (the return value is stored in + * t->ret). * * \sa filter_node, filter#convert, filter_callback */ -int filter_io(struct filter_chain_info *fci) +void filter_pre_select(__a_unused struct sched *s, struct task *t) { + struct filter_chain *fc = t->private_data; struct filter_node *fn; char *ib; size_t *loaded; int conv, conv_total = 0; + + t->ret = -E_FC_EOF; + if (fc->output_eof && *fc->output_eof) + goto err_out; again: - ib = fci->inbuf; - loaded = fci->in_loaded; + ib = fc->inbuf; + loaded = fc->in_loaded; conv = 0; - list_for_each_entry(fn, &fci->filters, node) { - int ret; + list_for_each_entry(fn, &fc->filters, node) { if (*loaded && fn->loaded < fn->bufsize) { - size_t old_fn_loaded = fn->loaded; - PARA_DEBUG_LOG("fc %p loaded: %zd, calling %s convert\n", fci, *loaded, fn->filter->name); - ret = fn->filter->convert(ib, *loaded, fn); - if (ret < 0) { - if (!fci->error) - fci->error = -ret; - return ret; - } - call_callbacks(fn, ib, ret, fn->buf + old_fn_loaded, fn->loaded - old_fn_loaded); - *loaded -= ret; - conv += ret; - if (*loaded && ret) { - PARA_DEBUG_LOG("moving %zd bytes in input buffer for %s filter\n", - *loaded, fn->filter->name); - memmove(ib, ib + ret, *loaded); + size_t size, old_fn_loaded = fn->loaded; +// PARA_DEBUG_LOG("fc %p loaded: %zd, calling %s convert\n", +// fc, *loaded, fn->filter->name); + t->ret = fn->filter->convert(ib, *loaded, fn); + if (t->ret < 0) + goto err_out; + size = t->ret; + call_callbacks(fn, ib, size, fn->buf + old_fn_loaded, + fn->loaded - old_fn_loaded); + *loaded -= size; + conv += size; + if (*loaded && size) { +// PARA_DEBUG_LOG("moving %zd bytes in input " +// "buffer for %s filter\n", +// *loaded, fn->filter->name); + memmove(ib, ib + size, *loaded); } } ib = fn->buf; loaded = &fn->loaded; } -// PARA_DEBUG_LOG("loaded: %d\n", *loaded); conv_total += conv; +// PARA_DEBUG_LOG("eof (in/out/fc): %d/%d/%d out_loaded: %zd, " +// "conv: %d, conv_total: %d\n", *fc->input_eof, +// fc->output_eof? *fc->output_eof : -42, +// fc->eof, *fc->out_loaded, conv, conv_total); if (conv) goto again; - return conv_total; + t->ret = 1; + if (!*fc->input_eof) + return; + if (*fc->out_loaded) + return; + if (*fc->in_loaded && conv_total) + return; + t->ret = -E_FC_EOF; +err_out: + fc->eof = 1; } /** * close all filter nodes and its callbacks * - * \param fci the filter chain to close + * \param fc the filter chain to close * - * For each filter node determined by \a fci, call the close function of each + * 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 */ -void close_filters(struct filter_chain_info *fci) +void close_filters(struct filter_chain *fc) { struct filter_node *fn, *tmp; - if (!fci) + if (!fc) return; - PARA_DEBUG_LOG("closing filter chain %p\n", fci); - list_for_each_entry_safe(fn, tmp, &fci->filters, node) { - PARA_NOTICE_LOG("closing %s filter callbacks (fci %p, fn %p)\n", fn->filter->name, fci, fn); + PARA_NOTICE_LOG("closing filter chain %p\n", fc); + list_for_each_entry_safe(fn, tmp, &fc->filters, node) { close_callbacks(fn); - PARA_NOTICE_LOG("closing %s filter (fci %p, fn %p)\n", fn->filter->name, fci, fn); + PARA_INFO_LOG("closing %s filter\n", fn->filter->name); fn->filter->close(fn); list_del(&fn->node); free(fn); @@ -186,32 +200,29 @@ static int parse_filter_args(int filter_num, char *options, void **conf) { struct filter *f = &filters[filter_num]; int i, argc = 2; - char *dummy_args[] = {"", "", NULL}; char **argv; // PARA_DEBUG_LOG("%s, options: %s, parser: %p\n", f->name, // options? options : "(none)", f->parse_config); if (!f->parse_config) - return options? -E_BAD_FILTER_OPTIONS : filter_num; - if (options) { -// PARA_DEBUG_LOG("options: %s\n", options); - argc = split_args(options, &argv, ' '); + return strlen(options)? -E_BAD_FILTER_OPTIONS : filter_num; +// PARA_DEBUG_LOG("options: %s\n", options); + argc = split_args(options, &argv, " \t"); // PARA_DEBUG_LOG("argc = %d, argv[0]: %s\n", argc, argv[0]); - for (i = argc; i >= 0; i--) - argv[i + 1] = argv[i]; - argc += 2; - *conf = f->parse_config(argc, argv); - } else { - /* is it OK to have no options? */ - *conf = f->parse_config(2, dummy_args); - } + for (i = argc - 1; i >= 0; i--) + argv[i + 1] = argv[i]; + argv[0] = para_strdup(f->name); + argc += 1; + *conf = f->parse_config(argc, argv); + free(argv[0]); + free(argv); return *conf? filter_num : -E_BAD_FILTER_OPTIONS; } /** * check the filter command line options * - * \param fa the command line options (values separated by colons) + * \param fa the command line options * \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 @@ -245,7 +256,8 @@ int check_filter_arg(char *fa, void **conf) continue; if (c && !filters[j].parse_config) return -E_BAD_FILTER_OPTIONS; - return parse_filter_args(j, c? fa + len + 1 : NULL, conf); + return parse_filter_args(j, c? fa + len + 1 : + fa + strlen(fa), conf); } return -E_UNSUPPORTED_FILTER; }