X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=grab_client.c;h=df5b40a3143f843b17e97a69662f9345d6cc15e6;hp=efe9cf613b13720684b24cf2a0db85799fcd3aef;hb=a601afd9c3c5819a0f2361bf073b7c737dcdab45;hpb=8a8cd0f5bb40dcfad68608193e8c57decd90b25e diff --git a/grab_client.c b/grab_client.c index efe9cf61..df5b40a3 100644 --- a/grab_client.c +++ b/grab_client.c @@ -1,32 +1,23 @@ /* - * Copyright (C) 2006 Andre Noll + * Copyright (C) 2006-2009 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 grab_client.c functions for grabbing the stream at any position - * in a filter chain + * \file grab_client.c Functions for grabbing the stream at any position + * in a filter chain. * - * \sa filter_chain filter_chain_info filter + * \sa filter_chain filter_chain_info filter. */ +#include +#include + #include "para.h" -#include "grab_client.cmdline.h" #include "list.h" #include "sched.h" +#include "ggo.h" #include "filter.h" #include "grab_client.h" #include "audiod.h" @@ -34,12 +25,13 @@ #include "string.h" #include "fd.h" -/** grab clients that are not yet attached to a filter node */ +/** Grab clients that are not yet attached to a filter node. */ struct list_head inactive_grab_client_list; 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)); @@ -49,130 +41,96 @@ static int max_num_filters(void) return ret; } -static int gc_write(char *buf, size_t len, struct filter_callback *fcb) +static struct filter_node *find_filter_node(int format, int filternum) { - struct grab_client *gc = fcb->data; - struct timeval tv = {0, 100}; - int ret; + int i; -// 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; - } - } + FOR_EACH_SLOT(i) { + struct slot_info *s = &slot[i]; + if (s->format < 0 || !s->fc) + continue; + if (format >= 0 && s->format != format) + continue; + if (num_filters(i) <= filternum) + continue; + /* success */ + return s->fc->filter_nodes + filternum; } - return ret; + return NULL; } -/* TODO: gengetopt can handle the grab client modes */ -static int check_gc_args(struct grab_client *gc) +static int gc_write(char *buf, size_t len, struct filter_callback *fcb) { - int i; - struct grab_client_args_info *c = gc->conf; - char **mv = grab_client_cmdline_parser_mode_values; + struct grab_client *gc = container_of(fcb, struct grab_client, fcb); + size_t written = 0; - 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; + while (written < len) { + int ret = write_ok(gc->fd); + if (ret < 0) + goto err; + if (ret == 0) { /* fd not ready */ + if (gc->mode == GM_PEDANTIC) + goto err; + if (gc->mode == GM_SLOPPY) + return 1; + } + ret = write(gc->fd, buf + written, len - written); + if (ret < 0) { + if (errno != EAGAIN && errno != EINTR) + goto err; + if (gc->mode == GM_PEDANTIC) + goto err; + if (gc->mode == GM_SLOPPY) + return 1; + } else + written += ret; } - 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; +err: + gc->error = -E_GC_WRITE; + return -E_GC_WRITE; } 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); - 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); - + para_list_add(&gc->node, &inactive_grab_client_list); } static void gc_close(struct filter_callback *fcb) { - struct grab_client *gc = fcb->data; + struct grab_client *gc = container_of(fcb, struct grab_client, fcb); - if (gc->conf->one_shot_given || gc->error) { + if ((gc->flags & GF_ONE_SHOT) || gc->error < 0) { PARA_INFO_LOG("closing fd %d (grab client %p)\n", gc->fd, gc); close(gc->fd); - gc_free(gc); - /* close on fork ?*/ + free(gc); return; } add_inactive_gc(gc); } /** - * move a grab client from the inactive list to a filter node + * Move a grab client from the inactive list to a filter node. * - * \param gc the grab client to activate - * \param fn the filter node \a gc gets attached to + * \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 + * \sa filter_node::callbacks, inactive_grab_client_list. */ void activate_grab_client(struct grab_client *gc, struct filter_node *fn) { PARA_INFO_LOG("activating %p (fd %d, filter node: %p)\n", gc, gc->fd, fn); list_del(&gc->node); - list_add(&gc->fcb.node, &fn->callbacks); + para_list_add(&gc->fcb.node, &fn->callbacks); } /** - * activate inactive grab clients if possible + * Activate inactive grab clients if possible. * - * \param slot audiod's slot for the new audio file - * \param audio_format_num the number of the audio format of the new audio file - * \param filter_list the list of activated filters for that 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 @@ -181,104 +139,137 @@ void activate_grab_client(struct grab_client *gc, struct filter_node *fn) * appropriate filter_node. * * \sa filter_chain_info::filters, inactive_grab_client_list, - * activate_grab_client + * activate_grab_client. */ -void activate_inactive_grab_clients(int slot_num, int audio_format_num, - struct list_head *filter_list) +void activate_inactive_grab_clients(int audio_format_num, + struct filter_chain *fc) { struct grab_client *gc, *tmp; - int i; 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) - continue; if (gc->audio_format_num >= 0 && gc->audio_format_num != audio_format_num) continue; - if (gc->conf->filter_num_arg >= 0 && - num_filters(gc->audio_format_num) - < gc->conf->filter_num_arg) + if (gc->filter_num >= num_filters(audio_format_num)) continue; - i = 1; - list_for_each_entry(fn, filter_list, node) { - if (gc->conf->filter_num_arg <= 0 - || i == gc->conf->filter_num_arg) - break; + fn = fc->filter_nodes + gc->filter_num; + activate_grab_client(gc, fn); + } +} + +static int check_gc_args(int argc, char **argv, struct grab_client *gc) +{ + int i, ret; + + gc->audio_format_num = -1; /* default: grab any audio format */ + for (i = 1; i < argc; i++) { + const char *arg = argv[i]; + if (arg[0] != '-') + break; + if (!strcmp(arg, "--")) { i++; + break; } - activate_grab_client(gc, fn); + if (!strncmp(arg, "-n=", 3)) { + ret = para_atoi32(arg + 3, &gc->filter_num); + if (ret < 0) + return ret; + if (gc->filter_num < 0) + return -E_BAD_GC_FILTER_NUM; + if (gc->filter_num >= max_num_filters()) + return -E_BAD_GC_FILTER_NUM; + continue; + } + 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, "-i")) { + gc->flags |= GF_INPUT_GRAB; + continue; + } + if (!strcmp(arg, "-o")) { + gc->flags |= GF_ONE_SHOT; + continue; + } + if (!strncmp(arg, "-f=", 3)) { + ret = get_audio_format_num(arg + 3); + if (ret < 0) + return ret; + gc->audio_format_num = ret; + 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 + * 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 occured + * \param fd The file descriptor of the client. + * \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. * - * \return On success, this function returns a pointer to the newly created - * struct. On errors, it returns NULL and sets \a err appropriately. + * \return Standard. * * \sa grab_client, inactive_grab_client_list, activate_grab_client, - * filter_node::callbacks - */ -/* - * argc, argv get freed when com_grab() returns, so we have to make a - * copy. + * filter_node::callbacks. */ -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)); + struct filter_node *fn; - 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 = check_gc_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) { + if (gc->flags & GF_INPUT_GRAB) gc->fcb.input_cb = gc_write; - gc->fcb.output_cb = NULL; - } else { + 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; + fn = find_filter_node(gc->audio_format_num, gc->filter_num); + if (fn) + para_list_add(&gc->fcb.node, &fn->callbacks); + else + add_inactive_gc(gc); + return 1; err_out: - free(gc->conf); free(gc); - return NULL; + return ret; } -/** initialize the grabbing subsystem. +/** + * 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 init_grabbing(void) { - PARA_INFO_LOG("%s", "grab init\n"); + PARA_INFO_LOG("grab init\n"); INIT_LIST_HEAD(&inactive_grab_client_list); } -