X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=filter_common.c;h=cdd9f39855c8add2f5c4f4bdfdd88c65bbe72651;hp=7c71ff39243a7a63f7026c11726418377790c87e;hb=9005b5a064873fc1ec2af9fb76c61aa7cd60db9b;hpb=d4522ff1dcfdfff491ef3c27aca1dd1220af0c6f;ds=sidebyside diff --git a/filter_common.c b/filter_common.c index 7c71ff39..cdd9f398 100644 --- a/filter_common.c +++ b/filter_common.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2009 Andre Noll + * Copyright (C) 2005-2010 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -9,12 +9,14 @@ #include #include #include +#include #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" @@ -34,153 +36,6 @@ void filter_init(void) filters[i].init(filters + i); } -/** - * Close and destroy a filter callback. - * - * \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. - */ -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 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. - */ -static void close_callbacks(struct filter_node *fn) -{ - 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); - } -} - -static void call_callbacks(struct filter_node *fn, char *inbuf, size_t inlen, - char *outbuf, size_t outlen) -{ - struct filter_callback *fcb, *tmp; - list_for_each_entry_safe(fcb, tmp, &fn->callbacks, node) { - int ret; - if (inlen && fcb->input_cb) { - ret = fcb->input_cb(inbuf, inlen, fcb); - if (ret < 0) { - close_filter_callback(fcb); - continue; - } - } - if (!outlen || !fcb->output_cb) - continue; - ret = fcb->output_cb(outbuf, outlen, fcb); - if (ret < 0) - close_filter_callback(fcb); - } -} - -/** - * 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 - * 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 - * registered output callbacks get called. - * - * On errors a (negative) error code is stored in t->error. - * - * \sa filter_node, filter#convert, filter_callback. - */ -void filter_post_select(__a_unused struct sched *s, struct task *t) -{ - struct filter_chain *fc = container_of(t, struct filter_chain, task); - struct filter_node *fn; - char *ib; - size_t *loaded; - int i, conv, conv_total = 0; - - if (fc->output_error && *fc->output_error < 0) { - t->error = *fc->output_error; - return; - } -again: - ib = *fc->inbufp; - loaded = fc->in_loaded; - conv = 0; - FOR_EACH_FILTER_NODE(fn, fc, i) { - struct filter *f = filters + fn->filter_num; - if (fn->loaded < fn->bufsize) { - size_t size, old_fn_loaded = fn->loaded; - 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 -= size; - conv += size + fn->loaded - old_fn_loaded; - if (*loaded && size) - memmove(ib, ib + size, *loaded); - } - ib = fn->buf; - loaded = &fn->loaded; - } - conv_total += conv; - if (conv) - goto again; - if (*fc->input_error >= 0) - return; - if (*fc->out_loaded) - return; - if (*fc->in_loaded && conv_total) - return; - t->error = -E_FC_EOF; -} - -/** - * 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 - */ -void close_filters(struct filter_chain *fc) -{ - 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(fc->filter_nodes); -} - /* * If the filter has a command line parser and options is not NULL, run it. * Returns filter_num on success, negative on errors @@ -271,5 +126,53 @@ void print_filter_helps(int detailed) printf_or_die("Options for %s:\n", f->name); ggo_print_help(&f->help, detailed); } +} + +void generic_filter_pre_select(struct sched *s, struct task *t) +{ + struct filter_node *fn = container_of(t, struct filter_node, task); + t->error = 0; + 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. + */ +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); }