/*
- * Copyright (C) 2005-2010 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2005-2011 Andre Noll <maan@systemlinux.org>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
/** \file audiod.c the paraslash's audio daemon */
#include <regex.h>
#include <sys/types.h>
-#include <dirent.h>
#include <signal.h>
-#include <openssl/rc4.h>
#include <stdbool.h>
#include "para.h"
#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;
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. */
* \return The audio format number on success, -E_UNSUPPORTED_AUDIO_FORMAT if
* \a name is not a supported audio format.
*/
-int get_audio_format_num(const char *name)
+static int get_audio_format_num(const char *name)
{
int i;
return -E_UNSUPPORTED_AUDIO_FORMAT;
}
+static int get_matching_audio_format_nums(const char *re)
+{
+ int i, ret;
+ regex_t preg;
+
+ ret = para_regcomp(&preg, re, REG_EXTENDED | REG_NOSUB);
+ if (ret < 0)
+ return ret;
+ ret = 0;
+ FOR_EACH_AUDIO_FORMAT(i)
+ if (regexec(&preg, audio_formats[i], 0, NULL, 0) != REG_NOMATCH)
+ ret |= (1 << i);
+ regfree(&preg);
+ return ret;
+}
+
/**
* Compute the play time based on information 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 chain of the given slot.
+ * 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
length / 60,
length % 60
);
- PARA_DEBUG_LOG("slot %d: %s\n", slot_num, msg);
+ //PARA_DEBUG_LOG("slot %d: %s\n", slot_num, msg);
return msg;
empty:
return para_strdup(NULL);
btr_free_node(s->receiver_node->btrn);
free(s->receiver_node);
s->receiver_node = NULL;
+ tv_add(now, &(struct timeval)EMBRACE(0, 200 * 1000),
+ &a->restart_barrier);
}
static void writer_cleanup(struct writer_node *wn)
static void kill_all_decoders(int error)
{
- int i, j;
+ int i;
FOR_EACH_SLOT(i) {
- struct slot_info *s = &slot[i];
- struct audio_format_info *a;
+ struct slot_info *s = slot + i;
if (s->format < 0)
continue;
- a = afi + s->format;
- if (s->wns)
- for (j = 0; j < a->num_writers; j++)
- kill_btrn(s->wns[j].btrn, &s->wns[j].task, error);
- if (s->fns)
- for (j = 0; j < a->num_writers; j++)
- kill_btrn(s->fns[j].btrn, &s->wns[j].task, error);
- if (s->receiver_node)
- kill_btrn(s->receiver_node->btrn, &s->receiver_node->task,
+ if (!s->receiver_node)
+ continue;
+ kill_btrn(s->receiver_node->btrn, &s->receiver_node->task,
error);
}
}
return -E_NO_MORE_SLOTS;
}
-/**
- * get the number of filters
- *
- * \param audio_format_num the number identifying the audio format
- *
- * \return the number of filters for the given audio format
- *
- * \sa struct filter;
- */
-int num_filters(int audio_format_num)
-{
- return afi[audio_format_num].num_filters;
-}
-
static void open_filters(struct slot_info *s)
{
struct audio_format_info *a = afi + s->format;
assert(s->wns == NULL);
s->wns = para_calloc(PARA_MAX(1U, a->num_writers)
* sizeof(struct writer_node));
- if (a->num_writers == 0)
- setup_writer_node(NULL, parent, s->wns);
- else {
- PARA_INFO_LOG("opening %s writers\n", audio_formats[s->format]);
- for (i = 0; i < a->num_writers; i++) {
- wn = s->wns + i;
- wn->conf = a->writer_conf[i];
- wn->writer_num = a->writer_nums[i];
- register_writer_node(wn, parent);
- }
+ PARA_INFO_LOG("opening %s writers\n", audio_formats[s->format]);
+ for (i = 0; i < a->num_writers; i++) {
+ wn = s->wns + i;
+ wn->conf = a->writer_conf[i];
+ wn->writer_num = a->writer_nums[i];
+ register_writer_node(wn, parent);
}
}
int cafn = stat_task->current_audio_format_num;
unsigned vs = stat_task->vss_status;
+ if (audiod_status != AUDIOD_ON)
+ return false;
if (cafn < 0)
return false;
if (!stat_task->ct)
static int parse_stream_command(const char *txt, char **cmd)
{
- char *p = strchr(txt, ':');
- int i;
+ int ret, len;
+ char *re, *p = strchr(txt, ':');
if (!p)
return -E_MISSING_COLON;
- p++;
- FOR_EACH_AUDIO_FORMAT(i) {
- if (strncmp(txt, audio_formats[i], strlen(audio_formats[i])))
- continue;
- *cmd = p;
- return i;
- }
- return -E_UNSUPPORTED_AUDIO_FORMAT;
+ *cmd = p + 1;
+ len = p - txt;
+ re = malloc(len + 1);
+ strncpy(re, txt, len);
+ re[len] = '\0';
+ ret = get_matching_audio_format_nums(re);
+ free(re);
+ return ret;
}
static int add_filter(int format, char *cmdline)
{
struct audio_format_info *a = &afi[format];
int filter_num, nf = a->num_filters;
+ void *cfg;
- filter_num = check_filter_arg(cmdline, &a->filter_conf[nf]);
+ filter_num = check_filter_arg(cmdline, &cfg);
if (filter_num < 0)
return filter_num;
+ a->filter_conf = para_realloc(a->filter_conf,
+ (nf + 1) * sizeof(void *));
+ a->filter_nums = para_realloc(a->filter_nums,
+ (nf + 1) * sizeof(unsigned));
a->filter_nums[nf] = filter_num;
+ a->filter_conf[nf] = cfg;
a->num_filters++;
PARA_INFO_LOG("%s filter %d: %s\n", audio_formats[format], nf,
filters[filter_num].name);
static int parse_writer_args(void)
{
- int i, ret, nw;
+ int i, ret;
char *cmd;
struct audio_format_info *a;
- nw = PARA_MAX(1U, conf.writer_given);
- PARA_INFO_LOG("maximal number of writers: %d\n", nw);
- FOR_EACH_AUDIO_FORMAT(i) {
- a = &afi[i];
- a->writer_conf = para_malloc(nw * sizeof(void *));
- a->writer_nums = para_malloc(nw * sizeof(int));
- a->num_writers = 0;
- }
for (i = 0; i < conf.writer_given; i++) {
void *wconf;
- int writer_num;
+ int j, nw, writer_num, af_mask;
+
ret = parse_stream_command(conf.writer_arg[i], &cmd);
if (ret < 0)
- goto out;
- a = &afi[ret];
- nw = a->num_writers;
- wconf = check_writer_arg(cmd, &writer_num);
- if (!wconf) {
- ret = writer_num;
- goto out;
+ return ret;
+ af_mask = ret;
+ FOR_EACH_AUDIO_FORMAT(j) {
+ a = afi + j;
+ if ((af_mask & (1 << j)) == 0) /* no match */
+ continue;
+ wconf = check_writer_arg_or_die(cmd, &writer_num);
+ nw = a->num_writers;
+ a->writer_nums = para_realloc(a->writer_nums, (nw + 1) * sizeof(int));
+ a->writer_conf = para_realloc(a->writer_conf, (nw + 1) * sizeof(void *));
+ a->writer_nums[nw] = writer_num;
+ a->writer_conf[nw] = wconf;
+ PARA_INFO_LOG("%s writer #%d: %s\n", audio_formats[j],
+ nw, writer_names[writer_num]);
+ a->num_writers++;
}
- a->writer_nums[nw] = writer_num;
- a->writer_conf[nw] = wconf;
- PARA_INFO_LOG("%s writer #%d: %s\n", audio_formats[ret],
- nw, writer_names[writer_num]);
- a->num_writers++;
}
- ret = 1;
-out:
- return ret;
+ /* Use default writer for audio formats which are not yet set up. */
+ FOR_EACH_AUDIO_FORMAT(i) {
+ struct writer *w = writers + DEFAULT_WRITER;
+ a = afi + i;
+ if (a->num_writers > 0)
+ continue; /* already set up */
+ PARA_INFO_LOG("%s writer: %s (default)\n", audio_formats[i],
+ writer_names[DEFAULT_WRITER]);
+ a->writer_nums = para_malloc(sizeof(int));
+ a->writer_nums[0] = DEFAULT_WRITER;
+ a->writer_conf = para_malloc(sizeof(void *));
+ a->writer_conf[0] = w->parse_config_or_die("");
+ a->num_writers = 1;
+ }
+ return 1;
}
static int parse_receiver_args(void)
struct audio_format_info *a;
for (i = conf.receiver_given - 1; i >= 0; i--) {
- char *arg = conf.receiver_arg[i];
- char *recv_arg = strchr(arg, ':');
- ret = -E_MISSING_COLON;
- if (!recv_arg)
- goto out;
- *recv_arg = '\0';
- recv_arg++;
- ret = get_audio_format_num(arg);
+ char *arg;
+ int j, af_mask;
+
+ ret = parse_stream_command(conf.receiver_arg[i], &arg);
if (ret < 0)
goto out;
- afi[ret].receiver_conf = check_receiver_arg(recv_arg, &receiver_num);
- if (!afi[ret].receiver_conf) {
+ af_mask = ret;
+ FOR_EACH_AUDIO_FORMAT(j) {
+ a = afi + j;
+ if ((af_mask & (1 << j)) == 0) /* no match */
+ continue;
+ /*
+ * 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 (a->receiver_conf)
+ a->receiver->free_config(a->receiver_conf);
+ a->receiver_conf = check_receiver_arg(arg, &receiver_num);
ret = -E_RECV_SYNTAX;
- goto out;
+ if (!a->receiver_conf)
+ goto out;
+ a->receiver = receivers + receiver_num;
}
- 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) {
return -E_RECV_SYNTAX;
a->receiver = &receivers[receiver_num];
}
+ FOR_EACH_AUDIO_FORMAT(i) {
+ a = afi + i;
+ PARA_INFO_LOG("receiving %s streams via %s receiver\n",
+ audio_formats[i], a->receiver->name);
+ }
ret = 1;
out:
free(cmd);
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.
+ * udp and dccp streams are fec-encoded, so add fecdec as the
+ * first filter.
*/
- if (strcmp(afi[i].receiver->name, "udp") == 0) {
+ 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);
static int parse_filter_args(void)
{
- int i, ret, nf;
+ int i, j, ret, af_mask;
- 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 *));
- afi[i].filter_nums = para_malloc(nf * sizeof(unsigned));
- }
if (!conf.no_default_filters_given)
return init_default_filters();
for (i = 0; i < conf.filter_given; i++) {
- char *arg = conf.filter_arg[i];
- char *filter_name = strchr(arg, ':');
- ret = -E_MISSING_COLON;
- if (!filter_name)
- goto out;
- *filter_name = '\0';
- filter_name++;
- ret = get_audio_format_num(arg);
- if (ret < 0)
- goto out;
- ret = add_filter(ret, filter_name);
+ char *arg;
+ ret = parse_stream_command(conf.filter_arg[i], &arg);
if (ret < 0)
goto out;
+ af_mask = ret;
+ FOR_EACH_AUDIO_FORMAT(j) {
+ if ((af_mask & (1 << j)) == 0) /* no match */
+ continue;
+ ret = add_filter(j, arg);
+ if (ret < 0)
+ goto out;
+ }
}
ret = init_default_filters(); /* use default values for the rest */
out:
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);
+ int signum;
- if (!FD_ISSET(st->fd, &s->rfds))
- return;
-
- 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");
}
}
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)
{
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();
if (s->format < 0)
return;
- if (s->receiver_node && s->receiver_node->task.error != -E_TASK_UNREGISTERED)
+ if (s->receiver_node && s->receiver_node->task.error >= 0)
return;
for (i = 0; i < a->num_filters; i++)
- if (s->fns && s->fns[i].task.error != -E_TASK_UNREGISTERED)
+ if (s->fns && s->fns[i].task.error >= 0)
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)
+ if (s->wns && s->wns[i].task.error >= 0)
return;
} else {
- if (s->wns && s->wns[0].task.error != -E_TASK_UNREGISTERED)
+ if (s->wns && s->wns[0].task.error >= 0)
return;
}
PARA_INFO_LOG("closing slot %d\n", slot_num);
ret = btr_node_status(st->btrn, 0, BTR_NT_LEAF);
if (ret > 0)
goto min_delay;
- if (!st->ct)
+ 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);
kill_btrn(st->ct->btrn, &st->ct->task, -E_AUDIOD_OFF);
goto out;
}
- if (st->ct->task.error != -E_TASK_UNREGISTERED)
+ if (st->ct->task.error >= 0)
goto out;
close_stat_pipe();
st->clock_diff_count = conf.clock_diff_count_arg;
size_t sz;
int ret;
if (st->ct->task.error < 0) {
- if (st->ct->task.error != -E_TASK_UNREGISTERED)
+ if (st->ct->task.error >= 0)
goto out;
close_stat_pipe();
goto out;
}
if (st->ct->status != CL_RECEIVING)
goto out;
- ret = btr_node_status(st->btrn, 0, BTR_NT_LEAF);
- if (ret <= 0)
+ 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)
+ 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)
+ if (sz != ret) {
+ btr_consume(st->btrn, sz - ret);
st->last_status_read = *now;
- else {
- struct timeval diff;
- tv_diff(now, &st->last_status_read, &diff);
- if (diff.tv_sec > 61)
- kill_btrn(st->ct->btrn, &st->ct->task,
- -E_STATUS_TIMEOUT);
- }
- btr_consume(st->btrn, sz - ret);
+ 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 */
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]);
}
/**