X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=filter_chain.c;h=1a2902477c85d78b2c84739ca5c9d374f5f38a6a;hp=4797b256caf9d6af2c868ee232f733aad19ec18f;hb=98e61f7563ae284e058ce6251b89626ab6254ff7;hpb=a95093cd8b62d411b9448aa77768774e1bdd81e5;ds=sidebyside diff --git a/filter_chain.c b/filter_chain.c index 4797b256..1a290247 100644 --- a/filter_chain.c +++ b/filter_chain.c @@ -1,22 +1,13 @@ /* - * Copyright (C) 2005-2006 Andre Noll + * Copyright (C) 2005-2008 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 */ +/** \file filter_chain.c Common helper functions for filter input/output. */ + +#include +#include #include "para.h" #include "list.h" @@ -29,9 +20,10 @@ DEFINE_FILTER_ARRAY(filters); /** - * call the init function of each supported filter + * Call the init function of each supported filter. + * + * \param all_filters the array of all supported filters. * - * \param all_filters the array of all supported filters * \sa filter::init */ void filter_init(struct filter *all_filters) @@ -43,9 +35,9 @@ void filter_init(struct filter *all_filters) } /** - * close and destroy a filter callback + * Close and destroy a filter callback. * - * \param fcb the filter callback to close + * \param fcb The filter callback to close. * * This removes \a fcb from the list of filter callbacks and calls * the close callback associated with \a fcb. @@ -58,9 +50,9 @@ static void close_filter_callback(struct filter_callback *fcb) } /** - * close all callbacks of a filter node + * Close all callbacks of a filter node. * - * \param fn the filter node which contains the filter callbacks to be closed + * \param fn The filter node which contains the filter callbacks to be closed. * * Call close_filter_callback() for each entry in the filter callback list * of \a fn. @@ -71,7 +63,7 @@ static void close_callbacks(struct filter_node *fn) list_for_each_entry_safe(fcb, tmp, &fn->callbacks, node) { PARA_INFO_LOG("closing %s filter callback\n", - fn->filter->name); + filters[fn->filter_num].name); close_filter_callback(fcb); } } @@ -98,7 +90,10 @@ static void call_callbacks(struct filter_node *fn, char *inbuf, size_t inlen, } /** - * call the convert function of each filter + * Call the convert function of each filter. + * + * \param s Unused. + * \param t The task identifying the filter chain. * * This is the core function of the filter subsystem. It loops over the list of * filter nodes determined by \a t and calls the filter's convert function if @@ -107,69 +102,70 @@ static void call_callbacks(struct filter_node *fn, char *inbuf, size_t inlen, * 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 (the return value is stored in - * t->ret). + * On errors a (negative) error code is stored in t->error. * - * \sa filter_node, filter#convert, filter_callback + * \sa filter_node, filter#convert, filter_callback. */ void filter_pre_select(__a_unused struct sched *s, struct task *t) { - struct filter_chain *fc = t->private_data; + struct filter_chain *fc = container_of(t, struct filter_chain, task); struct filter_node *fn; char *ib; size_t *loaded; - int conv, conv_total = 0; + int i, conv, conv_total = 0; - t->ret = -E_FC_EOF; - if (fc->output_eof && *fc->output_eof) - goto err_out; + if (fc->output_error && *fc->output_error < 0) { + t->error = *fc->output_error; + return; + } again: ib = fc->inbuf; loaded = fc->in_loaded; conv = 0; - list_for_each_entry(fn, &fc->filters, node) { + FOR_EACH_FILTER_NODE(fn, fc, i) { + struct filter *f = filters + fn->filter_num; if (*loaded && fn->loaded < fn->bufsize) { - size_t 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; - call_callbacks(fn, ib, t->ret, fn->buf + old_fn_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->error = f->convert(ib, *loaded, fn); + if (t->error < 0) + return; + size = t->error; + call_callbacks(fn, ib, size, fn->buf + old_fn_loaded, fn->loaded - old_fn_loaded); - *loaded -= t->ret; - conv += t->ret; - if (*loaded && t->ret) { - PARA_INFO_LOG("moving %zd bytes in input buffer for %s filter\n", - *loaded, fn->filter->name); - memmove(ib, ib + t->ret, *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; } conv_total += conv; -// PARA_INFO_LOG("eof (in/out/fc): %d/%d/%d out_loaded: %d, conv: %d, conv_total: %d\n", *fc->input_eof, -// *fc->output_eof, fc->eof, *fc->out_loaded, conv, conv_total); +// 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; - t->ret = 1; - if (!*fc->input_eof) + if (!*fc->input_error) return; if (*fc->out_loaded) return; if (*fc->in_loaded && conv_total) return; - t->ret = -E_FC_EOF; -err_out: - fc->eof = 1; + t->error = -E_FC_EOF; } /** - * close all filter nodes and its callbacks + * Close all filter nodes and their callbacks. * - * \param fc the filter chain to close + * \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 @@ -180,18 +176,19 @@ err_out: */ void close_filters(struct filter_chain *fc) { - struct filter_node *fn, *tmp; + struct filter_node *fn; + int i; if (!fc) return; PARA_NOTICE_LOG("closing filter chain %p\n", fc); - list_for_each_entry_safe(fn, tmp, &fc->filters, node) { + FOR_EACH_FILTER_NODE(fn, fc, i) { + struct filter *f = filters + fn->filter_num; close_callbacks(fn); - PARA_INFO_LOG("closing %s filter\n", fn->filter->name); - fn->filter->close(fn); - list_del(&fn->node); - free(fn); + PARA_INFO_LOG("closing %s filter\n", f->name); + f->close(fn); } + free(fc->filter_nodes); } /* @@ -216,14 +213,16 @@ static int parse_filter_args(int filter_num, char *options, void **conf) 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 + * Check the filter command line options. * - * \param fa the command line options - * \param conf points to the filter configuration upon successful return + * \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 * a colon. If yes, call the command line parser of that filter.