X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=audiod.c;h=8dd69c60910a725999b193c3e254df9f9c69c2a3;hp=2819091b80a2c27991df0ae0f3a95290e7423916;hb=be9f7c9b442f7b723427a79f85774d5fa7718425;hpb=c057c50d3d6e4c8d61e9c6db3e120270793e270e diff --git a/audiod.c b/audiod.c index 2819091b..8dd69c60 100644 --- a/audiod.c +++ b/audiod.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2009 Andre Noll + * Copyright (C) 2005-2011 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -33,6 +33,7 @@ #include "write.h" #include "write_common.h" #include "signal.h" +#include "version.h" /** define the array of error lists needed by para_audiod */ INIT_AUDIOD_ERRLISTS; @@ -92,6 +93,7 @@ struct status_task { struct timeval restart_barrier; /** Last time we received status data from para_server. */ struct timeval last_status_read; + size_t min_iqs; /** The offset value announced by para_server. */ int offset_seconds; /** The length of the current audio file as announced by para_server. */ @@ -110,6 +112,8 @@ struct status_task { struct timeval clock_diff_barrier; /** Number of the audio format as announced by para_server. */ int current_audio_format_num; + /* The status task btrn is the child of the client task. */ + struct btr_node *btrn; }; /** The array of status items sent by para_server. */ @@ -140,7 +144,6 @@ static struct status_task status_task_struct; * \sa struct status_task */ static struct status_task *stat_task = &status_task_struct; -static struct timeval initial_delay_barrier; /** * the task for handling audiod commands @@ -158,8 +161,9 @@ struct command_task { #define FOR_EACH_AUDIO_FORMAT(af) for (af = 0; af < NUM_AUDIO_FORMATS; af++) /** - * get the audio format number - * \param name the name of the audio format + * Get the audio format number. + * + * \param name The name of the audio format. * * \return The audio format number on success, -E_UNSUPPORTED_AUDIO_FORMAT if * \a name is not a supported audio format. @@ -176,6 +180,27 @@ int get_audio_format_num(const char *name) return -E_UNSUPPORTED_AUDIO_FORMAT; } +/** + * Compute the play time based on information of the given slot. + * + * \param slot_num The slot number (negative means: no slot). + * + * This computes a string of the form "0:07 [3:33] (3%/3:40)" using information + * from the status items received from para_server and the start time of the + * (first) writer of the given slot. + * + * It has to to take into account that probably the stream was not started at + * the beginning of the file, that the clock between the server and the client + * host may differ and that playback of the stream was delayed, e.g. because + * the prebuffer filter is used in the filter configuration of the given slot. + * + * If no writer is active in the given slot, or \a slot_num is negative + * (indicating that para_audiod runs in standby mode), an approximation based + * only on the status items is computed and the returned string is prefixed + * with "~". + * + * \return A string that must be freed by the caller. + */ char *get_time_string(int slot_num) { int ret, seconds = 0, length; @@ -324,7 +349,6 @@ static void close_receiver(int slot_num) { struct slot_info *s = &slot[slot_num]; struct audio_format_info *a; - struct timeval restart_delay = {0, 200 * 1000}; if (s->format < 0 || !s->receiver_node) return; @@ -335,7 +359,8 @@ static void close_receiver(int slot_num) btr_free_node(s->receiver_node->btrn); free(s->receiver_node); s->receiver_node = NULL; - tv_add(now, &restart_delay, &afi[s->format].restart_barrier); + tv_add(now, &(struct timeval)EMBRACE(0, 200 * 1000), + &a->restart_barrier); } static void writer_cleanup(struct writer_node *wn) @@ -357,6 +382,7 @@ static void close_writers(struct slot_info *s) if (s->format < 0) return; + assert(s->wns); a = afi + s->format; if (a->num_writers == 0) writer_cleanup(s->wns); @@ -479,13 +505,17 @@ static void open_filters(struct slot_info *s) fn->conf = a->filter_conf[i]; fn->task.pre_select = f->pre_select; fn->task.post_select = f->post_select; - fn->btrn = btr_new_node(f->name, parent, f->execute, fn); + + fn->btrn = btr_new_node(&(struct btr_node_description) + EMBRACE(.name = f->name, .parent = parent, + .handler = f->execute, .context = fn)); + f->open(fn); register_task(&fn->task); parent = fn->btrn; PARA_NOTICE_LOG("%s filter %d/%d (%s) started in slot %d\n", - audio_formats[s->format], i, nf, f->name, s - slot); - sprintf(fn->task.status, "%s (slot %d)", f->name, s - slot); + audio_formats[s->format], i, nf, f->name, (int)(s - slot)); + sprintf(fn->task.status, "%s (slot %d)", f->name, (int)(s - slot)); } } @@ -520,58 +550,63 @@ static int open_receiver(int format) int ret, slot_num; struct receiver *r = a->receiver; struct receiver_node *rn; - const struct timeval restart_delay = {2, 0}; + tv_add(now, &(struct timeval)EMBRACE(2, 0), &a->restart_barrier); ret = get_empty_slot(); if (ret < 0) - goto err; + return ret; slot_num = ret; - s = &slot[slot_num]; - s->format = format; - s->receiver_node = para_calloc(sizeof(struct receiver_node)); - rn = s->receiver_node; + rn = para_calloc(sizeof(*rn)); rn->receiver = r; rn->conf = a->receiver_conf; - rn->btrn = btr_new_node(r->name, NULL, NULL, rn); + rn->btrn = btr_new_node(&(struct btr_node_description) + EMBRACE(.name = r->name, .context = rn)); ret = r->open(rn); if (ret < 0) { btr_free_node(rn->btrn); free(rn); - s->receiver_node = NULL; - goto err; + return ret; } + s = &slot[slot_num]; + s->format = format; + s->receiver_node = rn; PARA_NOTICE_LOG("started %s: %s receiver in slot %d\n", - audio_formats[s->format], r->name, slot_num); + audio_formats[format], r->name, slot_num); rn->task.pre_select = r->pre_select; rn->task.post_select = r->post_select; sprintf(rn->task.status, "%s receiver node", r->name); register_task(&rn->task); - ret = slot_num; -err: - if (ret < 0) - PARA_ERROR_LOG("%s\n", para_strerror(-ret)); - tv_add(now, &restart_delay, &afi[format].restart_barrier); - return ret; + return slot_num; } -/* return: 0: Not running, 1: Running, -1: Running but eof (or error) */ -static int receiver_running(int format) +static bool receiver_running(void) { - int i, ret = 0; + int i; + long unsigned ss1 = stat_task->server_stream_start.tv_sec; FOR_EACH_SLOT(i) { struct slot_info *s = &slot[i]; - if (s->format != format) - continue; + long unsigned ss2 = s->server_stream_start.tv_sec; + if (!s->receiver_node) continue; if (s->receiver_node->task.error >= 0) - return 1; - ret = -1; + return true; + if (ss1 == ss2) + return true; } - return ret; + return false; } +/** + * Return the root node of the current buffer tree. + * + * This is only used for stream grabbing. + * + * \return \p NULL if no slot is currently active. If more than one buffer tree + * exists, the node corresponding to the most recently started receiver is + * returned. + */ struct btr_node *audiod_get_btr_root(void) { int i, newest_slot = -1; @@ -595,41 +630,27 @@ struct btr_node *audiod_get_btr_root(void) return slot[newest_slot].receiver_node->btrn; } -/* returns slot num on success. */ -static int open_current_receiver(struct sched *s) +/* whether a new instance of a decoder should be started. */ +static bool must_start_decoder(void) { - struct timeval diff; - int ret, cafn = stat_task->current_audio_format_num; + int cafn = stat_task->current_audio_format_num; + unsigned vs = stat_task->vss_status; - if (cafn < 0 || !stat_task->ct) - return -1; - /* Do nothing if the 'N' flag is set or the 'P' flag is unset */ - if (stat_task->vss_status != VSS_STATUS_FLAG_PLAYING) - return -1; - ret = receiver_running(cafn); - if (ret > 0) /* already running and not eof */ - return -1; - if (ret < 0) { /* eof */ - /* - * para_server uses a zero start time during the announcement - * period, i.e. before it sends the first chunk. Wait until - * this period begins to avoid restarting the receiver that - * belongs to the file just completed. - */ - if (stat_task->server_stream_start.tv_sec != 0) { - sched_request_timeout_ms(100, s); - return -1; - } - } - if (tv_diff(now, &afi[cafn].restart_barrier, &diff) < 0) { - if (tv_diff(&s->timeout, &diff, NULL) > 0) - sched_request_timeout(&diff, s); - else - sched_min_delay(s); - return -1; - } - /* start a new receiver */ - return open_receiver(cafn); + if (audiod_status != AUDIOD_ON) + return false; + if (cafn < 0) + return false; + if (!stat_task->ct) + return false; + if (vs & VSS_STATUS_FLAG_NEXT) + return false; + if (!(vs & VSS_STATUS_FLAG_PLAYING)) + return false; + if (receiver_running()) + return false; + if (tv_diff(now, &afi[cafn].restart_barrier, NULL) < 0) + return false; + return true; } static unsigned compute_time_diff(const struct timeval *status_time) @@ -664,9 +685,9 @@ static unsigned compute_time_diff(const struct timeval *status_time) &tmp); stat_task->sa_time_diff = tmp; PARA_INFO_LOG("time diff (cur/avg): %s%lums/%s%lums\n", - sign > 0? "+" : "-", + sign < 0? "-" : "+", tv2ms(&diff), - sa_time_diff_sign ? "+" : "-", + sa_time_diff_sign < 0? "-" : "+", tv2ms(&stat_task->sa_time_diff) ); out: @@ -699,20 +720,8 @@ static int update_item(int itemnum, char *buf) break; case SI_STREAM_START: if (sscanf(buf, "%lu.%lu", &sec, &usec) == 2) { - struct timeval a_start, delay; - delay.tv_sec = conf.stream_delay_arg / 1000; - delay.tv_usec = (conf.stream_delay_arg % 1000) * 1000; stat_task->server_stream_start.tv_sec = sec; stat_task->server_stream_start.tv_usec = usec; - if (compute_time_diff(NULL) > 2) { - if (stat_task->sa_time_diff_sign < 0) - tv_add(&stat_task->server_stream_start, - &stat_task->sa_time_diff, &a_start); - else - tv_diff(&stat_task->server_stream_start, - &stat_task->sa_time_diff, &a_start); - tv_add(&a_start, &delay, &initial_delay_barrier); - } } break; case SI_CURRENT_TIME: @@ -815,6 +824,14 @@ static int parse_receiver_args(void) ret = get_audio_format_num(arg); if (ret < 0) goto out; + /* + * If multiple receivers are given for this audio format, the + * last one wins and we have to free the previous receiver + * config here. Since we are iterating backwards, the winning + * receiver arg is in fact the first one given. + */ + if (afi[ret].receiver_conf) + afi[ret].receiver->free_config(afi[ret].receiver_conf); afi[ret].receiver_conf = check_receiver_arg(recv_arg, &receiver_num); if (!afi[ret].receiver_conf) { ret = -E_RECV_SYNTAX; @@ -822,9 +839,9 @@ static int parse_receiver_args(void) } afi[ret].receiver = &receivers[receiver_num]; } - /* use the first available receiver with no arguments - * for those audio formats for which no receiver - * was specified + /* + * Use the first available receiver with no arguments for those audio + * formats for which no receiver was specified. */ cmd = para_strdup(receivers[0].name); FOR_EACH_AUDIO_FORMAT(i) { @@ -853,6 +870,18 @@ static int init_default_filters(void) if (a->num_filters) continue; /* no default -- nothing to to */ + /* + * If udp is used to receive this audiod format, add fecdec as + * the first filter. + */ + if (strcmp(afi[i].receiver->name, "udp") == 0 || + strcmp(afi[i].receiver->name, "dccp") == 0) { + tmp = para_strdup("fecdec"); + add_filter(i, tmp); + free(tmp); + if (ret < 0) + goto out; + } /* add "dec" to audio format name */ tmp = make_message("%sdec", audio_formats[i]); for (j = 0; filters[j].name; j++) @@ -878,7 +907,7 @@ static int parse_filter_args(void) { int i, ret, nf; - nf = PARA_MAX(1U, conf.filter_given); + nf = PARA_MAX(2U, conf.filter_given); PARA_INFO_LOG("maximal number of filters: %d\n", nf); FOR_EACH_AUDIO_FORMAT(i) { afi[i].filter_conf = para_malloc(nf * sizeof(void *)); @@ -963,19 +992,16 @@ static void signal_pre_select(struct sched *s, struct task *t) para_fd_set(st->fd, &s->rfds, &s->max_fileno); } -static void signal_post_select(struct sched *s, struct task *t) +static void signal_post_select(struct sched *s, __a_unused struct task *t) { - struct signal_task *st = container_of(t, struct signal_task, task); - - if (!FD_ISSET(st->fd, &s->rfds)) - return; + int signum; - st->signum = para_next_signal(); - switch (st->signum) { + signum = para_next_signal(&s->rfds); + switch (signum) { case SIGINT: case SIGTERM: case SIGHUP: - PARA_EMERG_LOG("terminating on signal %d\n", st->signum); + PARA_EMERG_LOG("terminating on signal %d\n", signum); clean_exit(EXIT_FAILURE, "caught deadly signal"); } } @@ -1006,11 +1032,10 @@ static void command_post_select(struct sched *s, struct task *t) last_status_dump = *now; } - if (!FD_ISSET(ct->fd, &s->rfds)) - return; - ret = handle_connect(ct->fd); + ret = handle_connect(ct->fd, &s->rfds); if (ret < 0) PARA_ERROR_LOG("%s\n", para_strerror(-ret)); + audiod_status_dump(); } static void init_command_task(struct command_task *ct) @@ -1026,6 +1051,7 @@ static void close_stat_pipe(void) { if (!stat_task->ct) return; + btr_free_node(stat_task->ct->btrn); client_close(stat_task->ct); stat_task->ct = NULL; clear_and_dump_items(); @@ -1064,54 +1090,56 @@ static void set_stat_task_restart_barrier(unsigned seconds) tv_add(now, &delay, &stat_task->restart_barrier); } -static bool try_to_close_slot(int slot_num) +static void try_to_close_slot(int slot_num) { struct slot_info *s = &slot[slot_num]; struct audio_format_info *a = afi + s->format; int i; if (s->format < 0) - return false; + return; if (s->receiver_node && s->receiver_node->task.error != -E_TASK_UNREGISTERED) - return false; + return; for (i = 0; i < a->num_filters; i++) if (s->fns && s->fns[i].task.error != -E_TASK_UNREGISTERED) - return false; + return; if (a->num_writers > 0) { for (i = 0; i < a->num_writers; i++) if (s->wns && s->wns[i].task.error != -E_TASK_UNREGISTERED) - return false; + return; } else { if (s->wns && s->wns[0].task.error != -E_TASK_UNREGISTERED) - return false; + return; } PARA_INFO_LOG("closing slot %d\n", slot_num); close_writers(s); close_filters(s); close_receiver(slot_num); clear_slot(slot_num); - return true; } /* * Check if any receivers/filters/writers need to be started and do so if * necessary. */ -static void start_stop_decoders(struct sched *s) +static void start_stop_decoders(void) { int i, ret; struct slot_info *sl; struct audio_format_info *a; FOR_EACH_SLOT(i) - if (try_to_close_slot(i)) - sched_min_delay(s); + try_to_close_slot(i); if (audiod_status != AUDIOD_ON || !(stat_task->vss_status & VSS_STATUS_FLAG_PLAYING)) return kill_all_decoders(-E_NOT_PLAYING); - ret = open_current_receiver(s); - if (ret < 0) + if (!must_start_decoder()) return; + ret = open_receiver(stat_task->current_audio_format_num); + if (ret < 0) { + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); + return; + } sl = slot + ret; a = afi + sl->format; if (a->num_filters) @@ -1119,11 +1147,38 @@ static void start_stop_decoders(struct sched *s) open_writers(sl); activate_grab_clients(); btr_log_tree(sl->receiver_node->btrn, LL_NOTICE); +} + +static void status_pre_select(struct sched *s, struct task *t) +{ + struct status_task *st = container_of(t, struct status_task, task); + int ret, cafn = stat_task->current_audio_format_num; + + if (must_start_decoder()) + goto min_delay; + ret = btr_node_status(st->btrn, 0, BTR_NT_LEAF); + if (ret > 0) + goto min_delay; + if (st->ct && audiod_status == AUDIOD_OFF) + goto min_delay; + if (!st->ct && audiod_status != AUDIOD_OFF) + sched_request_barrier_or_min_delay(&st->restart_barrier, s); + if (cafn >= 0) + sched_request_barrier(&afi[cafn].restart_barrier, s); + /* + * If para_server is playing we'd like to have a smooth time display + * even if we are running in standby mode. So we request a timeout that + * expires at the next full second. + */ + if (stat_task->vss_status & VSS_STATUS_FLAG_PLAYING) + sched_request_timeout_ms(1000 - now->tv_usec / 1000, s); + return; +min_delay: sched_min_delay(s); } /* restart the client task if necessary */ -static void status_pre_select(struct sched *s, struct task *t) +static void status_post_select(__a_unused struct sched *s, struct task *t) { struct status_task *st = container_of(t, struct status_task, task); @@ -1131,7 +1186,7 @@ static void status_pre_select(struct sched *s, struct task *t) if (!st->ct) goto out; if (st->ct->task.error >= 0) { - st->ct->task.error = -E_AUDIOD_OFF; + kill_btrn(st->ct->btrn, &st->ct->task, -E_AUDIOD_OFF); goto out; } if (st->ct->task.error != -E_TASK_UNREGISTERED) @@ -1141,6 +1196,8 @@ static void status_pre_select(struct sched *s, struct task *t) goto out; } if (st->ct) { + char *buf; + size_t sz; int ret; if (st->ct->task.error < 0) { if (st->ct->task.error != -E_TASK_UNREGISTERED) @@ -1150,23 +1207,32 @@ static void status_pre_select(struct sched *s, struct task *t) } if (st->ct->status != CL_RECEIVING) goto out; - ret = for_each_stat_item(st->ct->buf, st->ct->loaded, - update_item); - if (ret < 0) { - st->ct->task.error = ret; - goto out; - } - if (st->ct->loaded != ret) { - st->last_status_read = *now; - st->ct->loaded = ret; - } else { + ret = btr_node_status(st->btrn, st->min_iqs, BTR_NT_LEAF); + if (ret <= 0) { struct timeval diff; tv_diff(now, &st->last_status_read, &diff); if (diff.tv_sec > 61) - st->ct->task.error = -E_STATUS_TIMEOUT; + kill_btrn(st->ct->btrn, &st->ct->task, + -E_STATUS_TIMEOUT); + goto out; + } + btr_merge(st->btrn, st->min_iqs); + sz = btr_next_buffer(st->btrn, &buf); + ret = for_each_stat_item(buf, sz, update_item); + if (ret < 0) { + kill_btrn(st->ct->btrn, &st->ct->task, ret); + goto out; } + if (sz != ret) { + btr_consume(st->btrn, sz - ret); + st->last_status_read = *now; + st->min_iqs = 0; + } else /* current status item crosses buffers */ + st->min_iqs = sz + 1; goto out; } + btr_drain(st->btrn); + st->current_audio_format_num = -1; if (tv_diff(now, &st->restart_barrier, NULL) < 0) goto out; if (st->clock_diff_count) { /* get status only one time */ @@ -1174,16 +1240,14 @@ static void status_pre_select(struct sched *s, struct task *t) int argc = 5; PARA_INFO_LOG("clock diff count: %d\n", st->clock_diff_count); st->clock_diff_count--; - client_open(argc, argv, &st->ct, NULL); + client_open(argc, argv, &st->ct, NULL, NULL, st->btrn); set_stat_task_restart_barrier(2); - sched_min_delay(s); } else { char *argv[] = {"audiod", "--", "stat", "-p", NULL}; int argc = 4; - client_open(argc, argv, &st->ct, NULL); + client_open(argc, argv, &st->ct, NULL, NULL, st->btrn); set_stat_task_restart_barrier(5); - sched_min_delay(s); } free(stat_item_values[SI_BASENAME]); stat_item_values[SI_BASENAME] = para_strdup( @@ -1191,17 +1255,20 @@ static void status_pre_select(struct sched *s, struct task *t) stat_client_write_item(SI_BASENAME); st->last_status_read = *now; out: - start_stop_decoders(s); + start_stop_decoders(); } static void init_status_task(struct status_task *st) { memset(st, 0, sizeof(struct status_task)); st->task.pre_select = status_pre_select; + st->task.post_select = status_post_select; st->sa_time_diff_sign = 1; st->clock_diff_count = conf.clock_diff_count_arg; st->current_audio_format_num = -1; - sprintf(st->task.status, "status task"); + sprintf(st->task.status, "stat"); + st->btrn = btr_new_node(&(struct btr_node_description) + EMBRACE(.name = "stat")); } static void set_initial_status(void) @@ -1240,17 +1307,14 @@ __noreturn static void print_help_and_die(void) static void init_colors_or_die(void) { - int ret, i; + int i; if (!want_colors()) return; daemon_set_default_log_colors(); daemon_set_flag(DF_COLOR_LOG); - for (i = 0; i < conf.log_color_given; i++) { - ret = daemon_set_log_color(conf.log_color_arg[i]); - if (ret < 0) - exit(EXIT_FAILURE); - } + for (i = 0; i < conf.log_color_given; i++) + daemon_set_log_color_or_die(conf.log_color_arg[i]); } /**