X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=grab_client.c;h=8e6715036769dace2f633d867d4bdb436901b6e0;hp=77d3616d2c2e41b3caf32f5fea13d54cf778642b;hb=69a7e7aa11d8bf9b05d6431c57276befbc9b35a3;hpb=3dfab6fc800bec957eee78aa642d0b139300d470 diff --git a/grab_client.c b/grab_client.c index 77d3616d..8e671503 100644 --- a/grab_client.c +++ b/grab_client.c @@ -1,269 +1,295 @@ /* - * Copyright (C) 2006-2008 Andre Noll + * Copyright (C) 2006-2011 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ -/** - * \file grab_client.c Functions for grabbing the stream at any position - * in a filter chain. - * - * \sa filter_chain filter_chain_info filter. - */ +/** \file grab_client.c Functions for grabbing the audio stream. */ +#include #include #include +#include #include "para.h" -#include "grab_client.cmdline.h" #include "list.h" #include "sched.h" +#include "ggo.h" +#include "buffer_tree.h" #include "filter.h" #include "grab_client.h" #include "audiod.h" #include "error.h" #include "string.h" #include "fd.h" -#include "crypt.h" -/** Grab clients that are not yet attached to a filter node. */ -struct list_head inactive_grab_client_list; +/** + * How to handle blocking writes for the grab client fds. + */ +enum grab_mode { + /** Ignore the data and do not write. */ + GM_SLOPPY, + /** Write anyway (default). */ + GM_AGGRESSIVE, + /** Close fd if write would block. */ + GM_PEDANTIC, +}; -static int max_num_filters(void) -{ - int i, ret = 0; - for (i = 0; audio_formats[i]; i++) { - PARA_INFO_LOG("%s filter chain length: %d\n", audio_formats[i], - num_filters(i)); - ret = PARA_MAX(ret, num_filters(i)); - } - PARA_INFO_LOG("maximal filter chain length: %d\n", ret); - return ret; -} +/** Flags specified as arguments to the grab command. */ +enum grab_flags { + /** Stop grabbing if audio file changes. */ + GF_ONE_SHOT = 1, +}; -static int gc_write(char *buf, size_t len, struct filter_callback *fcb) -{ - struct grab_client *gc = fcb->data; - struct timeval tv = {0, 100}; - int ret; +/** Describes one active grab client. */ +struct grab_client { + /* The value of the -p option. */ + char *parent; + /* The value of the -n option. */ + char *name; + /** The file descriptor to send the grabbed stream to. */ + int fd; + /** See \ref grab_mode. */ + enum grab_mode mode; + /** Flags given at the command line. */ + enum grab_flags flags; + /** The point of the grab client's node in the buffer tree. */ + struct btr_node *btrn; + /* The task of this grab client. */ + struct task task; + /** Belongs to either the active or the inactive list. */ + struct list_head node; +}; -// PARA_INFO_LOG("writing %d bytes to fd %d\n", len, gc->fd); - fd_set wfds; - FD_ZERO(&wfds); - FD_SET(gc->fd, &wfds); - ret = para_select(gc->fd + 1, NULL, &wfds, &tv); - if (ret <= 0) { - if (gc->mode == GRAB_PEDANTIC) - return -E_PEDANTIC_GRAB; - if (gc->mode == GRAB_SLOPPY) - return 1; - } -rewrite: - ret = write(gc->fd, buf, len); - if (ret < 0) { - ret = -E_GC_WRITE; - gc->error = E_GC_WRITE; - } else { - if (ret != len) { - if (gc->mode == GRAB_PEDANTIC) - return -E_PEDANTIC_GRAB; - if (gc->mode == GRAB_AGGRESSIVE) { - len -= ret; - memmove(buf, buf + ret, len); - goto rewrite; - } - } - } - return ret; -} +/* Grab clients that are attached to a btr node. */ +INITIALIZED_LIST_HEAD(active_grab_client_list); +/* Grab clients that are not currently attached any btr node. */ +INITIALIZED_LIST_HEAD(inactive_grab_client_list); -/* TODO: gengetopt can handle the grab client modes */ -static int check_gc_args(struct grab_client *gc) +static int gc_write(struct grab_client *gc, char *buf, size_t len) { - int i; - struct grab_client_args_info *c = gc->conf; - char **mv = grab_client_cmdline_parser_mode_values; + int ret = write_ok(gc->fd); - PARA_INFO_LOG("filter_num: %d\n", c->filter_num_arg); - for (i = 0; mv[i]; i++) - if (!strcmp(c->mode_arg, mv[i])) - break; - if (!mv[i]) - return -E_GC_SYNTAX; - gc->mode = i; - gc->audio_format_num = -1; - if (c->audio_format_given) { - gc->audio_format_num = get_audio_format_num(c->audio_format_arg); - if (gc->audio_format_num < 0) - return gc->audio_format_num; + if (ret < 0) + goto err; + if (ret == 0) { /* fd not ready */ + if (gc->mode == GM_PEDANTIC) + goto err; + if (gc->mode == GM_SLOPPY) + return len; } - if (c->slot_arg >= MAX_STREAM_SLOTS) - return -E_BAD_GC_SLOT; - if (c->filter_num_arg < 0) - return -E_BAD_GC_FILTER_NUM; - if (c->audio_format_given) { - if (num_filters(gc->audio_format_num) <= c->filter_num_arg) - return -E_BAD_GC_FILTER_NUM; - } else - if (c->filter_num_arg >= max_num_filters()) - return -E_BAD_GC_FILTER_NUM; - - return 1; -} - -static void add_inactive_gc(struct grab_client *gc) -{ - PARA_INFO_LOG("adding grab client %p (fd %d) to inactive list\n", - gc, gc->fd); - para_list_add(&gc->node, &inactive_grab_client_list); -} - -static void gc_free(struct grab_client *gc) -{ - int i; - - for (i = 0; i < gc->argc; i++) - free(gc->argv[i]); - free(gc->argv); - free(gc->conf); - free(gc); - + ret = write_nonblock(gc->fd, buf, len); + if (ret < 0) + goto err; + if (ret > 0) + return ret; + if (ret == 0) { + if (gc->mode == GM_PEDANTIC) + goto err; + if (gc->mode == GM_SLOPPY) + return len; + } + return 0; +err: + return -E_GC_WRITE; } -static void gc_close(struct filter_callback *fcb) +static void gc_pre_select(struct sched *s, struct task *t) { - struct grab_client *gc = fcb->data; + struct grab_client *gc = container_of(t, struct grab_client, task); + int ret = btr_node_status(gc->btrn, 0, BTR_NT_LEAF); - if (gc->conf->one_shot_given || gc->error) { - PARA_INFO_LOG("closing fd %d (grab client %p)\n", gc->fd, gc); - close(gc->fd); - gc_free(gc); - /* close on fork ?*/ + if (ret == 0) return; - } - add_inactive_gc(gc); + if (ret < 0) + sched_min_delay(s); + para_fd_set(gc->fd, &s->wfds, &s->max_fileno); } +/* + * We need this forward declaration as post_select() needs + * activate_grab_client and vice versa. + */ +static void gc_post_select(struct sched *s, struct task *t); + /** - * Move a grab client from the inactive list to a filter node. + * Move a grab client to the active list and start it. * * \param gc The grab client to activate. - * \param fn The filter node \a gc gets attached to. - * - * \sa filter_node::callbacks, inactive_grab_client_list. */ -void activate_grab_client(struct grab_client *gc, struct filter_node *fn) +static void gc_activate(struct grab_client *gc) { - PARA_INFO_LOG("activating %p (fd %d, filter node: %p)\n", gc, gc->fd, fn); - list_del(&gc->node); - para_list_add(&gc->fcb.node, &fn->callbacks); + struct btr_node *root = audiod_get_btr_root(), *parent; + char *name = gc->name? gc->name : "grab"; + + if (!root) + return; + parent = btr_search_node(gc->parent, root); + if (!parent) + return; + PARA_INFO_LOG("activating fd %d\n", gc->fd); + list_move(&gc->node, &active_grab_client_list); + gc->btrn = btr_new_node(&(struct btr_node_description) + EMBRACE(.name = name, .parent = parent)); + if (!gc->task.pre_select) { + gc->task.pre_select = gc_pre_select; + gc->task.post_select = gc_post_select; + snprintf(gc->task.status, sizeof(gc->task.status) - 1, "%s", name); + gc->task.status[sizeof(gc->task.status) - 1] = '\0'; + register_task(&gc->task); + } } /** * Activate inactive grab clients if possible. * - * \param slot_num Audiod's slot for the new audio file. - * \param audio_format_num The number of the audio format of the new audio file. - * \param fc The filter chain containing the activated filters. - * * This is called from audiod.c when the current audio file changes. It loops * over all inactive grab clients and checks each grab client's configuration * to determine if the client in question wishes to grab the new stream. If - * yes, this grab client is moved from the inactive grab client list to an - * appropriate filter_node. + * yes, this grab client is moved from the inactive to the active grab client list. * - * \sa filter_chain_info::filters, inactive_grab_client_list, - * activate_grab_client. + * This function also garbage collects all grab clients whose tasks have been + * unscheduled. */ -void activate_inactive_grab_clients(int slot_num, int audio_format_num, - struct filter_chain *fc) +void activate_grab_clients(void) { struct grab_client *gc, *tmp; - int filter_num; - struct filter_node *fn; list_for_each_entry_safe(gc, tmp, &inactive_grab_client_list, node) { -// PARA_INFO_LOG("checking inactive grab client %p\n", gc); - if (gc->conf->slot_arg >= 0 && gc->conf->slot_arg != slot_num) + if (gc->task.error == -E_TASK_UNREGISTERED) { + list_del(&gc->node); + free(gc); continue; - if (gc->audio_format_num >= 0 && gc->audio_format_num != - audio_format_num) + } + gc_activate(gc); + } +} + +static int gc_close(struct grab_client *gc, int err) +{ + btr_remove_node(gc->btrn); + btr_free_node(gc->btrn); + gc->btrn = NULL; + PARA_INFO_LOG("closing gc: %s\n", para_strerror(-err)); + list_move(&gc->node, &inactive_grab_client_list); + if (err == -E_GC_WRITE || (gc->flags & GF_ONE_SHOT)) { + /* + * We must not free the gc structure here as it contains ->task + * which is still used because this function is called from + * post_select(). + */ + close(gc->fd); + free(gc->parent); + free(gc->name); + return 1; + } + gc_activate(gc); + return 0; +} + +static void gc_post_select(__a_unused struct sched *s, struct task *t) +{ + struct grab_client *gc = container_of(t, struct grab_client, task); + struct btr_node *btrn = gc->btrn; + int ret; + size_t sz; + char *buf; + + t->error = 0; + ret = btr_node_status(btrn, 0, BTR_NT_LEAF); + if (ret == 0) + return; + if (ret < 0) + goto err; + sz = btr_next_buffer(btrn, &buf); + assert(sz != 0); + ret = gc_write(gc, buf, sz); + if (ret < 0) + goto err; + if (ret > 0) + btr_consume(btrn, ret); + return; +err: + t->error = gc_close(gc, ret)? ret : 0; +} + +static int gc_check_args(int argc, char **argv, struct grab_client *gc) +{ + int i; + + for (i = 1; i < argc; i++) { + const char *arg = argv[i]; + if (arg[0] != '-') + break; + if (!strcmp(arg, "--")) { + i++; + break; + } + if (!strncmp(arg, "-m", 2)) { + if (*(arg + 3)) + return -E_GC_SYNTAX; + switch(*(arg + 2)) { + case 's': + gc->mode = GM_SLOPPY; + continue; + case 'a': + gc->mode = GM_AGGRESSIVE; + continue; + case 'p': + gc->mode = GM_PEDANTIC; + continue; + default: + return -E_GC_SYNTAX; + } + } + if (!strcmp(arg, "-o")) { + gc->flags |= GF_ONE_SHOT; continue; - filter_num = gc->conf->filter_num_arg; - if (filter_num >= num_filters(gc->audio_format_num)) + } + if (!strncmp(arg, "-p=", 3)) { + gc->parent = para_strdup(arg + 3); continue; - fn = fc->filter_nodes + filter_num; - activate_grab_client(gc, fn); + } + if (!strncmp(arg, "-n=", 3)) { + gc->name = para_strdup(arg + 3); + continue; + } + return -E_GC_SYNTAX; } + if (i != argc) + return -E_GC_SYNTAX; + return 1; } /** * Check the command line options and allocate a grab_client structure. * * \param fd The file descriptor of the client. - * \param line The command line. - * \param err Non-zero if an error occurred. + * \param argc Argument count. + * \param argv Argument vector. * * If the command line options given by \a argc and \a argv are valid. * allocate a struct grab_client and initialize it with this valid - * configuration. Moreover, add the new grab client to the inactive list. + * configuration. * - * \return On success, this function returns a pointer to the newly created - * struct. On errors, it returns NULL and sets \a err appropriately. + * If the new grab client can be added to an existing buffer tree, activate it. + * Otherwise, add it to the inactive list for later activation. * - * \sa grab_client, inactive_grab_client_list, activate_grab_client, - * filter_node::callbacks. + * \return Standard. */ -/* - * argc, argv get freed when com_grab() returns, so we have to make a - * copy. - */ -struct grab_client *grab_client_new(int fd, char *line, int *err) +int grab_client_new(int fd, int argc, char **argv) { int ret; struct grab_client *gc = para_calloc(sizeof(struct grab_client)); - gc->conf = para_calloc(sizeof(struct grab_client_args_info)); - - ret = grab_client_cmdline_parser_string(line, gc->conf, "grab"); - *err = -E_GC_SYNTAX; - if (ret) - goto err_out; - *err = -E_GC_HELP_GIVEN; - if (gc->conf->help_given) - goto err_out; - *err = -E_GC_VERSION_GIVEN; - if (gc->conf->version_given) + ret = gc_check_args(argc, argv, gc); + if (ret < 0) goto err_out; - *err = check_gc_args(gc); - if (*err < 0) - goto err_out; - if (gc->conf->input_grab_given) { - gc->fcb.input_cb = gc_write; - gc->fcb.output_cb = NULL; - } else { - gc->fcb.output_cb = gc_write; - gc->fcb.input_cb = NULL; - } gc->fd = fd; - gc->fcb.close = gc_close; - gc->fcb.data = gc; - add_inactive_gc(gc); - return gc; + para_list_add(&gc->node, &inactive_grab_client_list); + gc_activate(gc); + return 1; err_out: - free(gc->conf); free(gc); - return NULL; -} - -/** - * Initialize the grabbing subsystem. - * - * This has to be called once during startup before any other function from - * grab_client.c may be used. It initializes \a inactive_grab_client_list. - */ -void init_grabbing(void) -{ - PARA_INFO_LOG("grab init\n"); - INIT_LIST_HEAD(&inactive_grab_client_list); + return ret; }