void *receiver_conf;
/** the number of filters that should be activated for this audio format */
unsigned int num_filters;
- /** pointer to the array of filters to be activated */
- struct filter **filters;
- /** pointer to the array of filter configurations */
+ /** Array of filter numbers to be activated. */
+ unsigned *filter_nums;
+ /** Pointer to the array of filter configurations. */
void **filter_conf;
/** the number of filters that should be activated for this audio format */
unsigned int num_writers;
if (ll < conf.loglevel_arg)
return;
+ if (!logfile && conf.daemon_given)
+ return;
if (!hostname)
hostname = para_hostname();
outfd = logfile? logfile : stderr;
FOR_EACH_SLOT(i) {
struct slot_info *s = &slot[i];
- if (s->wng && !s->wng->error) {
+ if (s->wng && !s->wng->task.error) {
PARA_INFO_LOG("unregistering writer node group in slot %d\n",
i);
wng_unregister(s->wng);
- s->wng->error = error;
+ s->wng->task.error = error;
}
- if (s->fc && !s->fc->error) {
+ if (s->fc && !s->fc->task.error) {
PARA_INFO_LOG("unregistering filter chain in slot %d\n", i);
unregister_task(&s->fc->task);
- s->fc->error = error;
+ s->fc->task.error = error;
}
- if (s->receiver_node && !s->receiver_node->error) {
+ if (s->receiver_node && !s->receiver_node->task.error) {
PARA_INFO_LOG("unregistering receiver_node in slot %d\n", i);
unregister_task(&s->receiver_node->task);
- s->receiver_node->error = error;
+ s->receiver_node->task.error = error;
}
}
}
return afi[audio_format_num].num_filters;
}
-static void filter_event_handler(struct task *t)
-{
- PARA_NOTICE_LOG("%s\n", para_strerror(-t->ret));
- struct filter_chain *fc = t->private_data;
- fc->error = t->ret;
- unregister_task(t);
-}
-
static void open_filters(int slot_num)
{
struct slot_info *s = &slot[slot_num];
struct audio_format_info *a = &afi[s->format];
+ struct filter_node *fn;
int nf = a->num_filters;
int i;
return;
PARA_INFO_LOG("opening %s filters\n", audio_formats[s->format]);
s->fc = para_calloc(sizeof(struct filter_chain));
- INIT_LIST_HEAD(&s->fc->filters);
+ s->fc->filter_nodes = para_malloc(nf * sizeof(struct filter_chain));
s->fc->inbuf = s->receiver_node->buf;
s->fc->in_loaded = &s->receiver_node->loaded;
- s->fc->input_error = &s->receiver_node->error;
+ s->fc->input_error = &s->receiver_node->task.error;
s->fc->task.pre_select = filter_pre_select;
- s->fc->task.event_handler = filter_event_handler;
- s->fc->task.private_data = s->fc;
- s->fc->error = 0;
+ s->fc->task.post_select = NULL;
+ s->fc->task.error = 0;
+ s->fc->num_filters = nf;
- s->receiver_node->output_error = &s->fc->error;
+ s->receiver_node->output_error = &s->fc->task.error;
sprintf(s->fc->task.status, "filter chain");
- for (i = 0; i < nf; i++) {
- struct filter_node *fn = para_calloc(sizeof(struct filter_node));
+ FOR_EACH_FILTER_NODE(fn, s->fc, i) {
+ struct filter *f = filters + a->filter_nums[i];
+ fn->filter_num = a->filter_nums[i];
fn->conf = a->filter_conf[i];
fn->fc = s->fc;
- fn->filter = a->filters[i];
+ fn->loaded = 0;
INIT_LIST_HEAD(&fn->callbacks);
- list_add_tail(&fn->node, &s->fc->filters);
- fn->filter->open(fn);
+ f->open(fn);
PARA_NOTICE_LOG("%s filter %d/%d (%s) started in slot %d\n",
- audio_formats[s->format], i + 1, nf,
- fn->filter->name, slot_num);
+ audio_formats[s->format], i + 1, nf, f->name, slot_num);
s->fc->outbuf = fn->buf;
s->fc->out_loaded = &fn->loaded;
}
register_task(&s->fc->task);
}
-static void wng_event_handler(struct task *t)
-{
- struct writer_node_group *wng = t->private_data;
-
- PARA_INFO_LOG("%s\n", para_strerror(-t->ret));
- wng->error = t->ret;
- wng_unregister(wng);
-}
-
static void open_writers(int slot_num)
{
int ret, i;
if (s->fc) {
s->wng->buf = s->fc->outbuf;
s->wng->loaded = s->fc->out_loaded;
- s->wng->input_error = &s->fc->error;
+ s->wng->input_error = &s->fc->task.error;
s->wng->channels = &s->fc->channels;
s->wng->samplerate = &s->fc->samplerate;
- s->fc->output_error = &s->wng->error;
+ s->fc->output_error = &s->wng->task.error;
PARA_INFO_LOG("samplerate: %d\n", *s->wng->samplerate);
} else {
s->wng->buf = s->receiver_node->buf;
s->wng->loaded = &s->receiver_node->loaded;
- s->wng->input_error = &s->receiver_node->error;
+ s->wng->input_error = &s->receiver_node->task.error;
}
- s->wng->task.event_handler = wng_event_handler;
for (i = 0; i < a->num_writers; i++) {
s->wng->writer_nodes[i].conf = a->writer_conf[i];
s->wng->writer_nodes[i].writer = a->writers[i];
return;
}
s->wstime = *now;
- activate_inactive_grab_clients(slot_num, s->format, &s->fc->filters);
+ activate_inactive_grab_clients(slot_num, s->format, s->fc);
}
+#if 0
static void rn_event_handler(struct task *t)
{
struct receiver_node *rn = t->private_data;
tv_add(now, &restart_delay, &afi[slot[i].format].restart_barrier);
}
}
+#endif
static int open_receiver(int format)
{
}
PARA_NOTICE_LOG("started %s: %s receiver in slot %d\n",
audio_formats[s->format], a->receiver->name, slot_num);
- rn->task.private_data = s->receiver_node;
rn->task.pre_select = a->receiver->pre_select;
rn->task.post_select = a->receiver->post_select;
- rn->task.event_handler = rn_event_handler;
sprintf(rn->task.status, "%s receiver node", rn->receiver->name);
register_task(&rn->task);
return 1;
FOR_EACH_SLOT(i) {
struct slot_info *s = &slot[i];
if (s->format == format && s->receiver_node
- && !s->receiver_node->error)
+ && s->receiver_node->task.error >= 0)
return 1;
}
return 0;
struct timeval diff;
int cafn = stat_task->current_audio_format_num;
- if (cafn < 0 || !stat_task->pcd)
+ if (cafn < 0 || !stat_task->ct)
return 0;
if (receiver_running(cafn))
return 0;
long unsigned sec, usec;
char *tmp;
-// PARA_INFO_LOG("line: %s\n", line);
+ //PARA_INFO_LOG("line: %s\n", line);
if (!line)
return 1;
itemnum = stat_line_valid(line);
switch (itemnum) {
case SI_STATUS:
stat_task->playing = strstr(line, "playing")? 1 : 0;
+ PARA_INFO_LOG("stat task playing: %d\n", stat_task->playing);
break;
case SI_OFFSET:
stat_task->offset_seconds = atoi(line + ilen + 1);
if (s->format < 0)
return;
- if (s->receiver_node && !s->receiver_node->error)
+ if (s->receiver_node && s->receiver_node->task.error >= 0)
return;
- if (s->fc && !s->fc->error)
+ if (s->fc && s->fc->task.error >= 0)
return;
- if (s->wng && !s->wng->error)
+ if (s->wng && s->wng->task.error >= 0)
return;
PARA_INFO_LOG("closing slot %d\n", slot_num);
wng_close(s->wng);
int i;
struct timeval min_delay = {0, 1};
- t->ret = 1;
if (audiod_status != AUDIOD_ON || !stat_task->playing)
return kill_all_decoders(-E_NOT_PLAYING);
if (open_current_receiver(s))
{
int i;
- t->ret = 1;
FOR_EACH_SLOT(i)
try_to_close_slot(i);
}
{
t->pre_select = audiod_pre_select;
t->post_select = audiod_post_select;
- t->event_handler = NULL;
- t->private_data = t;
+ t->error = 0;
sprintf(t->status, "audiod task");
}
filter_num = check_filter_arg(cmdline, &a->filter_conf[nf]);
if (filter_num < 0)
return filter_num;
- a->filters[nf] = &filters[filter_num];
+ a->filter_nums[nf] = filter_num;
a->num_filters++;
PARA_INFO_LOG("%s filter %d: %s\n", audio_formats[format], nf + 1,
- a->filters[nf]->name);
+ filters[filter_num].name);
return filter_num;
}
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].filters = para_malloc(nf * sizeof(struct filter *));
+ afi[i].filter_nums = para_malloc(nf * sizeof(unsigned));
}
if (!conf.no_default_filters_given)
return init_default_filters();
exit(EXIT_FAILURE);
}
-static void signal_event_handler(struct task *t)
-{
- struct signal_task *st = t->private_data;
-
- switch (st->signum) {
- case SIGINT:
- case SIGTERM:
- case SIGHUP:
- PARA_EMERG_LOG("terminating on signal %d\n", st->signum);
- clean_exit(EXIT_FAILURE, "caught deadly signal");
- }
-}
-
static void signal_pre_select(struct sched *s, struct task *t)
{
- struct signal_task *st = t->private_data;
- t->ret = 1;
+ struct signal_task *st = container_of(t, struct signal_task, task);
para_fd_set(st->fd, &s->rfds, &s->max_fileno);
}
static void signal_post_select(struct sched *s, struct task *t)
{
- struct signal_task *st = t->private_data;
- t->ret = 1;
+ struct signal_task *st = container_of(t, struct signal_task, task);
+ int signum;
+
if (!FD_ISSET(st->fd, &s->rfds))
return;
- t->ret = -E_SIGNAL_CAUGHT;
- st->signum = para_next_signal();
+
+ signum = para_next_signal();
+ switch (signum) {
+ case SIGINT:
+ case SIGTERM:
+ case SIGHUP:
+ PARA_EMERG_LOG("terminating on signal %d\n", st->signum);
+ clean_exit(EXIT_FAILURE, "caught deadly signal");
+ }
}
static void signal_setup_default(struct signal_task *st)
{
st->task.pre_select = signal_pre_select;
st->task.post_select = signal_post_select;
- st->task.private_data = st;
sprintf(st->task.status, "signal task");
}
static void command_pre_select(struct sched *s, struct task *t)
{
- struct command_task *ct = t->private_data;
- t->ret = 1;
+ struct command_task *ct = container_of(t, struct command_task, task);
para_fd_set(ct->fd, &s->rfds, &s->max_fileno);
-
}
static void command_post_select(struct sched *s, struct task *t)
{
int ret;
- struct command_task *ct = t->private_data;
+ struct command_task *ct = container_of(t, struct command_task, task);
- t->ret = 1; /* always successful */
audiod_status_dump();
if (!FD_ISSET(ct->fd, &s->rfds))
return;
{
ct->task.pre_select = command_pre_select;
ct->task.post_select = command_post_select;
- ct->task.event_handler = NULL;
- ct->task.private_data = ct;
+ ct->task.error = 0;
ct->fd = audiod_get_socket(); /* doesn't return on errors */
sprintf(ct->task.status, "command task");
}
{
int i;
- if (!stat_task->pcd)
+ if (!stat_task->ct)
return;
- client_close(stat_task->pcd);
- stat_task->pcd = NULL;
+ client_close(stat_task->ct);
+ stat_task->ct = NULL;
FOR_EACH_STATUS_ITEM(i) {
free(stat_task->stat_item_values[i]);
stat_task->stat_item_values[i] = NULL;
tv_add(now, &delay, &stat_task->restart_barrier);
}
-static void client_task_event_handler(__a_unused struct task *t)
-{
- int i;
-
- if (t->ret == -E_HANDSHAKE_COMPLETE)
- return;
- unregister_task(t);
- close_stat_pipe();
- if (t->ret != -E_SERVER_EOF)
- stat_task->clock_diff_count = conf.clock_diff_count_arg;
- set_stat_task_restart_barrier();
- FOR_EACH_AUDIO_FORMAT(i)
- afi[i].restart_barrier = stat_task->restart_barrier;
-}
-
+/* restart the client task if necessary */
static void status_pre_select(struct sched *s, struct task *t)
{
- struct status_task *st = t->private_data;
+ struct status_task *st = container_of(t, struct status_task, task);
int ret;
- t->ret = 1; /* always successful */
- if (st->pcd || audiod_status == AUDIOD_OFF)
+ if (st->ct || audiod_status == AUDIOD_OFF) /* no need to restart */
return;
if (!st->clock_diff_count && tv_diff(now, &st->restart_barrier, NULL)
< 0)
return;
- if (st->clock_diff_count) {
+ if (st->clock_diff_count) { /* get status only one time */
char *argv[] = {"audiod", "stat", "1", NULL};
int argc = 3;
if (tv_diff(now, &st->clock_diff_barrier, NULL) < 0)
return;
PARA_INFO_LOG("clock diff count: %d\n", st->clock_diff_count);
- ret = client_open(argc, argv, &st->pcd);
+ ret = client_open(argc, argv, &st->ct);
} else {
char *argv[] = {"audiod", "stat", NULL};
int argc = 2;
- ret = client_open(argc, argv, &st->pcd);
+ ret = client_open(argc, argv, &st->ct);
}
set_stat_task_restart_barrier();
if (ret < 0)
return;
- st->pcd->task.event_handler = client_task_event_handler;
s->timeout.tv_sec = 0;
s->timeout.tv_usec = 1;
}
static void status_post_select(__a_unused struct sched *s, struct task *t)
{
- struct status_task *st = t->private_data;
+ struct status_task *st = container_of(t, struct status_task, task);
unsigned bytes_left;
- t->ret = 1;
- if (!st->pcd || st->pcd->status != CL_RECEIVING)
+ if (!st->ct || st->ct->status != CL_RECEIVING)
return;
- if (st->pcd && audiod_status == AUDIOD_OFF) {
- unregister_task(&st->pcd->task);
+ if (audiod_status == AUDIOD_OFF || st->ct->task.error < 0) {
+ if (st->ct->task.error >= 0)
+ unregister_task(&st->ct->task);
+ if (audiod_status == AUDIOD_OFF)
+ st->clock_diff_count = conf.clock_diff_count_arg;
close_stat_pipe();
- st->clock_diff_count = conf.clock_diff_count_arg;
return;
}
- bytes_left = for_each_line(st->pcd->buf, st->pcd->loaded,
+ bytes_left = for_each_line(st->ct->buf, st->ct->loaded,
&check_stat_line, NULL);
- if (st->pcd->loaded != bytes_left) {
+ if (st->ct->loaded != bytes_left) {
st->last_status_read = *now;
- st->pcd->loaded = bytes_left;
+ st->ct->loaded = bytes_left;
} else {
struct timeval diff;
tv_diff(now, &st->last_status_read, &diff);
memset(st, 0, sizeof(struct status_task));
st->task.pre_select = status_pre_select;
st->task.post_select = status_post_select;
- st->task.private_data = st;
st->sa_time_diff_sign = 1;
st->clock_diff_count = conf.clock_diff_count_arg;
st->current_audio_format_num = -1;
return;
}
if (strcmp(conf.mode_arg, "on"))
- PARA_WARNING_LOG("%s", "invalid mode\n");
+ PARA_WARNING_LOG("invalid mode\n");
}
/**
};
if (audiod_cmdline_parser_config_file(config_file, &conf, ¶ms)) {
- PARA_EMERG_LOG("%s", "parse error in config file\n");
+ PARA_EMERG_LOG("parse error in config file\n");
exit(EXIT_FAILURE);
}
free(config_file);
init_grabbing();
setup_signal_handling();
signal_setup_default(sig_task);
- sig_task->task.event_handler = signal_event_handler;
init_status_task(stat_task);
init_command_task(cmd_task);
projects / paraslash.git / blobdiff