X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=write_common.c;h=5988faf77a5cd13f1b4e1930299b8c90073efc3d;hp=e496c26ca7c547fe185e5f7df1156c230bcaaec1;hb=a22e734cd89015a71d0dd7cf895799c440805847;hpb=24495e62d3896d98d6c27f9665edfe6492ddd757 diff --git a/write_common.c b/write_common.c index e496c26c..5988faf7 100644 --- a/write_common.c +++ b/write_common.c @@ -1,158 +1,207 @@ /* - * Copyright (C) 2006 Andre Noll + * Copyright (C) 2006-2011 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 write_common.c common functions of para_audiod and para_write */ +#include +#include + #include "para.h" #include "string.h" +#include "list.h" +#include "sched.h" +#include "ggo.h" +#include "buffer_tree.h" #include "write.h" #include "error.h" +/** the array containing the names of all supported writers */ const char *writer_names[] ={WRITER_NAMES}; + +/** the array of supported writers */ struct writer writers[NUM_SUPPORTED_WRITERS] = {WRITER_ARRAY}; -int wng_write(struct writer_node_group *g, char *buf, size_t *loaded) +/** + * Call the init function of each supported paraslash writer. + */ +void writer_init(void) { - int ret, i, need_more_writes = 1; - size_t min_written = 0; - - while (need_more_writes) { - need_more_writes = 0; - FOR_EACH_WRITER_NODE(i, g) { - size_t w = g->written[i]; - unsigned char *p = buf + w; - int bytes_to_write; - struct writer_node *wn = &g->writer_nodes[i]; - if (!i) - min_written = w; - else - min_written = PARA_MIN(min_written, w); - if (w == *loaded) - continue; - if (!g->eof && (*loaded < wn->chunk_bytes + w)) - continue; - bytes_to_write = PARA_MIN(wn->chunk_bytes, - *loaded - w); - ret = wn->writer->write(p, bytes_to_write, wn); - if (ret < 0) - goto out; - if (ret != bytes_to_write) - PARA_WARNING_LOG("short write: %d/%d\n", ret, - bytes_to_write); - g->written[i] += ret; - need_more_writes = 1; - } - } - *loaded -= min_written; - ret = 0; - if (g->eof) - goto out; - if (*loaded) - memmove(buf, buf + min_written, *loaded); - FOR_EACH_WRITER_NODE(i, g) - g->written[i] -= min_written; - ret = 1; -out: - return ret; -} + int i; -int wng_open(struct writer_node_group *g) -{ - int i, ret = 1; - - FOR_EACH_WRITER_NODE(i, g) { - struct writer_node *wn = &g->writer_nodes[i]; - ret = wn->writer->open(wn); - if (ret < 0) - goto out; - wn->chunk_bytes = ret; - g->max_chunk_bytes = PARA_MAX(g->max_chunk_bytes, ret); - } -out: - return ret; + FOR_EACH_WRITER(i) + writers[i].init(&writers[i]); } - -void wng_close(struct writer_node_group *g) +/** + * check if given string is a valid command line for any writer + * + * \param \wa string of the form writer_name:options + * \param writer_num contains the number of the writer upon success + * + * This function checks whether \a wa starts with the name of a supported + * paraslash writer, optionally followed by a colon and any options for that + * writer. If a valid writer name was found and further are present, the + * remaining part of \a wa is passed to that writer's config parser. + * + * \return On success, a pointer to the gengetopt args info struct is returned + * and \a writer_num contains the number of the writer. Otherwise this function + * returns \p NULL. + */ +void *check_writer_arg(const char *wa, int *writer_num) { int i; - FOR_EACH_WRITER_NODE(i, g) { - struct writer_node *wn = &g->writer_nodes[i]; - wn->writer->close(wn); + *writer_num = -E_WRITE_COMMON_SYNTAX; + PARA_INFO_LOG("checking %s\n", wa); + FOR_EACH_WRITER(i) { + const char *name = writer_names[i]; + size_t len = strlen(name); + char c; + if (strlen(wa) < len) + continue; + if (strncmp(name, wa, len)) + continue; + c = wa[len]; + if (c && c != ' ') + continue; + *writer_num = i; + return writers[i].parse_config_or_die(c? wa + len + 1 : ""); } + PARA_ERROR_LOG("writer not found\n"); + return NULL; } -struct writer_node_group *wng_new(unsigned num_writers) +/** + * Open a writer node and register the corresponding task. + * + * \param wn The writer node to open. + * \param parent The parent btr node (the source for the writer node). + * + * The configuration of the writer node stored in \p wn->conf must be + * initialized before this function may be called. + */ +void register_writer_node(struct writer_node *wn, struct btr_node *parent) { - struct writer_node_group *g = para_calloc(sizeof(struct writer_node_group)); - g->num_writers = num_writers; - g->writer_nodes = para_calloc(num_writers - * sizeof(struct writer_node)); - g->written = para_calloc(num_writers * sizeof(size_t)); - return g; + struct writer *w = writers + wn->writer_num; + char *name = make_message("%s writer", writer_names[wn->writer_num]); + + wn->btrn = btr_new_node(&(struct btr_node_description) + EMBRACE(.name = name, .parent = parent, + .handler = w->execute, .context = wn)); + strcpy(wn->task.status, name); + free(name); + wn->task.post_select = w->post_select; + wn->task.pre_select = w->pre_select; + register_task(&wn->task); } -void wng_destroy(struct writer_node_group *g) +/** + * Setup a writer node with the default writer. + * + * If arg is \p NULL, the OS-dependent default writer is used with an empty + * configuration string. It defaults to alsa for Linux, osx for OS X, oss for + * *BSD and the file writer if neither of these is supported. + * + * Once the writer configuration has been retrieved, a writer node is created, + * its buffer tree node is added to the buffer tree as a child of the given + * parent. + * + * Finally, the new writer node's taks structure is initialized and registered + * to the paraslash scheduler. + * + * \return A pointer to the allocated writer node group. + */ +int setup_writer_node(const char *arg, struct btr_node *parent, + struct writer_node *wn) { - if (!g) - return; - free(g->written); - free(g->writer_nodes); - free(g); + if (arg) + wn->conf = check_writer_arg(arg, &wn->writer_num); + else { + wn->writer_num = DEFAULT_WRITER; + wn->conf = writers[DEFAULT_WRITER].parse_config_or_die(""); + } + if (!wn->conf) + return -E_WRITE_COMMON_SYNTAX; + register_writer_node(wn, parent); + return 1; } -void init_supported_writers(void) +/** + * Print the help text of all writers to stdout. + * + * \param detailed Whether to print the detailed help text. + */ +void print_writer_helps(int detailed) { int i; + printf_or_die("\nAvailable writers: \n\t"); FOR_EACH_WRITER(i) - writers[i].init(&writers[i]); + printf_or_die("%s%s", i? " " : "", writer_names[i]); + printf_or_die("\n\n"); + FOR_EACH_WRITER(i) { + struct writer *w = writers + i; + + if (!w->help.short_help) + continue; + printf_or_die("Options for %s:\n", writer_names[i]); + ggo_print_help(&w->help, detailed); + } } -int check_writer_arg(const char *arg) +static void get_btr_value(struct btr_node *btrn, const char *cmd, + int32_t *result) { - int i, ret = -E_WRITE_COMMON_SYNTAX; - char *a = para_strdup(arg), *p = strchr(a, ':'); - if (p) - *p = '\0'; - p++; - FOR_EACH_WRITER(i) { - if (strcmp(writer_names[i], a)) - continue; - ret = i; - goto out; + char *buf = NULL; + int ret = btr_exec_up(btrn, cmd, &buf); + + if (ret < 0) { + /* + * This really should not happen. It means one of our parent + * nodes died unexpectedly. Proceed with fingers crossed. + */ + PARA_CRIT_LOG("cmd %s: %s\n", cmd, para_strerror(-ret)); + *result = 0; + return; } -out: - free(a); - return ret; + ret = para_atoi32(buf, result); + assert(ret >= 0); + free(buf); } -struct writer_node_group *setup_default_wng(void) +/** + * Ask parent btr nodes for the sample rate of the current stream. + * + * \param btrn Where to start the search. + * \param result Filled in by this function. + * + * This function is assumed to succeed and terminates on errors. + */ +void get_btr_sample_rate(struct btr_node *btrn, int32_t *result) +{ + get_btr_value(btrn, "sample_rate", result); +} + +/** + * Ask parent btr nodes for the channel count of the current stream. + * + * \param btrn See \ref get_btr_sample_rate. + * \param result See \ref get_btr_sample_rate. + */ +void get_btr_channels(struct btr_node *btrn, int32_t *result) +{ + get_btr_value(btrn, "channels", result); +} + +/** + * Ask parent btr nodes for the number of bits per sample and the byte sex. + * + * \param btrn See \ref get_btr_sample_rate. + * \param result Contains the sample format as an enum sample_format type. + */ +void get_btr_sample_format(struct btr_node *btrn, int32_t *result) { - struct writer_node_group *wng = wng_new(1); - enum writer_enum default_writer; - - if (NUM_SUPPORTED_WRITERS == 1) - default_writer = FILE_WRITE; - else - default_writer = 1; - wng->writer_nodes[0].writer = &writers[default_writer]; - PARA_INFO_LOG("using default writer: %s\n", - writer_names[default_writer]); - return wng; + get_btr_value(btrn, "sample_format", result); }