#include "audiod.cmdline.h"
#include "list.h"
#include "close_on_fork.h"
+#include "sched.h"
#include "recv.h"
#include "filter.h"
#include "grab_client.cmdline.h"
#include "grab_client.h"
-#include "ringbuffer.h"
#include "error.h"
#include "audiod.h"
#include "net.h"
#include "daemon.h"
#include "string.h"
+#include "fd.h"
+#include "write.h"
+#include "write_common.h"
/** define the array of error lists needed by para_audiod */
INIT_AUDIOD_ERRLISTS;
/** defines how to handle one supported audio format */
struct audio_format_info {
-/** pointer to the receiver for this audio format */
+ /** pointer to the receiver for this audio format */
struct receiver *receiver;
-/** the receiver configuration */
+ /** the receiver configuration */
void *receiver_conf;
-/** the number of filters that should be activated for this audio format */
+ /** 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 */
+ /** pointer to the array of filters to be activated */
struct filter **filters;
-/** pointer to the array of filter configurations */
+ /** pointer to the array of filter configurations */
void **filter_conf;
-/** output of the last filter is written to stdin of this command */
- char *write_cmd;
-/** do not start receiver/filters/writer before this time */
+ /** the number of filters that should be activated for this audio format */
+ unsigned int num_writers;
+ /** pointer to the array of writers to be activated */
+ struct writer **writers;
+ /** pointer to the array of writer configurations */
+ void **writer_conf;
+ /** do not start receiver/filters/writer before this time */
struct timeval restart_barrier;
};
/**
* describes one instance of a receiver-filter-writer chain
*
- * \sa receier_node, receiver, filter, filter_node, filter_chain_info
+ * \sa receier_node, receiver, filter, filter_node, filter_chain, writer,
+ * writer_node, writer_node_group.
*/
struct slot_info {
-/** number of the audio format in this slot */
+ /** number of the audio format in this slot */
int format;
-/** the file descriptor of the writer */
- int write_fd;
-/** the process id of the writer */
- pid_t wpid;
-/** time of the last successful read from the receiver */
+ /** time of the last successful read from the receiver */
struct timeval rtime;
-/** time the last write to the write fd happend */
+ /** time the last write to the write fd happend */
struct timeval wtime;
-/** writer start time */
+ /** writer start time */
struct timeval wstime;
-/** did we include \a write_fd in the fdset */
- int wcheck;
-/** set to one if we have sent the TERM signal to \a wpid */
- int wkilled;
-/** the receiver info associated with this slot */
+ /** the receiver info associated with this slot */
struct receiver_node *receiver_node;
-/** the active filter chain */
- struct filter_chain_info *fci;
+ /** the active filter chain */
+ struct filter_chain *fc;
+ /** the active writer node group */
+ struct writer_node_group *wng;
};
-
static struct slot_info slot[MAX_STREAM_SLOTS];
-/** defines one command of para_audiod */
-struct audiod_command {
-/** the name of the command */
-const char *name;
-/** pointer to the function that handles the command */
-int (*handler)(int, int, char**);
-/** one-line description of the command */
-const char *description;
-/** summary of the command line options */
-const char *synopsis;
-/** the long help text */
-const char *help;
-};
-
extern const char *status_item_list[NUM_STAT_ITEMS];
-static int com_grab(int, int, char **);
-static int com_cycle(int, int, char **);
-static int com_help(int, int, char **);
-static int com_off(int, int, char **);
-static int com_on(int, int, char **);
-static int com_sb(int, int, char **);
-static int com_stat(int, int, char **);
-static int com_term(int, int, char **);
-static int stat_pipe = -1, signal_pipe;
-
static struct gengetopt_args_info conf;
static struct timeval server_stream_start, sa_time_diff;
static int playing, current_decoder = -1,
audiod_status = AUDIOD_ON, offset_seconds, length_seconds,
- sa_time_diff_sign = 1, audiod_socket = -1;
+ sa_time_diff_sign = 1;
static char *af_status, /* the audio format announced in server status */
*socket_name, *hostname;
-/** how many status items to remember */
-#define RINGBUFFER_SIZE 32
-static void *stat_item_ringbuf;
+static char *stat_item_values[NUM_STAT_ITEMS];
static FILE *logfile;
static const struct timeval restart_delay = {0, 300 * 1000};
-static struct audio_format_info afi[] = {
+static struct audio_format_info afi[NUM_AUDIO_FORMATS];
+
+static struct signal_task signal_task_struct, *sig_task = &signal_task_struct;
+
+struct command_task {
+ int fd;
+ struct task task;
+};
+static struct command_task command_task_struct, *cmd_task = &command_task_struct;
+
+struct status_task {
+ int fd;
+ struct task task;
+ char buf[STRINGSIZE];
+ unsigned loaded;
+};
+static struct status_task status_task_struct, *stat_task = &status_task_struct;
-[AUDIO_FORMAT_MP3] =
- {
- .write_cmd = "para_play",
- },
-[AUDIO_FORMAT_OGG] =
- {
- .write_cmd = "para_play",
- },
+struct audiod_task {
+ struct task task;
};
+static struct audiod_task audiod_task_struct, *at = &audiod_task_struct;
+struct signal_task {
+ int fd;
+ int signum;
+ struct task task;
+};
+
+
+/** defines one command of para_audiod */
+struct audiod_command {
+ /** the name of the command */
+ const char *name;
+ /** pointer to the function that handles the command */
+ int (*handler)(int, int, char**);
+ int (*line_handler)(int, char*);
+ /** one-line description of the command */
+ const char *description;
+ /** summary of the command line options */
+ const char *synopsis;
+ /** the long help text */
+ const char *help;
+};
+static int com_grab(int, char *);
+static int com_cycle(int, int, char **);
+static int com_help(int, int, char **);
+static int com_off(int, int, char **);
+static int com_on(int, int, char **);
+static int com_sb(int, int, char **);
+static int com_stat(int, int, char **);
+static int com_term(int, int, char **);
static struct audiod_command cmds[] = {
{
.name = "cycle",
},
{
.name = "grab",
-.handler = com_grab,
+.line_handler = com_grab,
.description = "grab the audio stream",
.synopsis = "-- grab [grab_options]",
.help =
+
"grab ('splice') the audio stream at any position in the filter \n"
-"chain and send that data back to the client. \n"
-"Available options:\n\n"
-GRAB_HELP_TXT
+"chain and send that data back to the client. Try\n"
+"\t para_audioc -- grab -h\n"
+"for the list of available options.\n"
},
+
{
.name = "help",
.handler = com_help,
.name = "stat",
.handler = com_stat,
.description = "print status information",
-.synopsis = "stat",
+.synopsis = "stat [item1 ...]",
.help =
-"Add para_audiod status information to para_server's status information\n"
-"and dump everything to stdout.\n"
+"Dump given status items (all if none given) to stdout.\n"
},
{
};
/** iterate over all slots */
-#define FOR_EACH_SLOT(slot) for (slot = 0; slot < MAX_STREAM_SLOTS; slot++)
+#define FOR_EACH_SLOT(_slot) for (_slot = 0; _slot < MAX_STREAM_SLOTS; _slot++)
/** iterate over all supported audio formats */
#define FOR_EACH_AUDIO_FORMAT(af) for (af = 0; af < NUM_AUDIO_FORMATS; af++)
/** iterate over the array of all audiod commands */
/*
* log function. first argument is loglevel.
*/
-void para_log(int ll, char* fmt,...)
+void para_log(int ll, const char* fmt,...)
{
va_list argp;
FILE *outfd;
if (ll < conf.loglevel_arg)
return;
- if (!logfile && conf.logfile_given)
- logfile = open_log(conf.logfile_arg);
- if (!logfile && conf.daemon_given)
- return;
- if (!logfile) {
- if (ll < WARNING)
- outfd = stdout;
- else
- outfd = stderr;
- } else
- outfd = logfile;
+ outfd = logfile? logfile : stderr;
time(&t1);
tm = localtime(&t1);
strftime(str, MAXLINE, "%b %d %H:%M:%S", tm);
struct timeval now, diff, adj_stream_start, tmp;
int total = 0, use_server_time = 1;
- if (!playing)
- return make_message("%s:", length_seconds?
- "" : status_item_list[SI_PLAY_TIME]);
+ if (!playing) {
+ if (length_seconds)
+ return NULL;
+ return make_message("%s:\n", status_item_list[SI_PLAY_TIME]);
+ }
if (audiod_status == AUDIOD_OFF)
goto out;
if (sa_time_diff_sign > 0)
total = 0;
out:
return make_message(
- "%s:%s%d:%02d [%d:%02d] (%d%%/%d:%02d)",
+ "%s:%s%d:%02d [%d:%02d] (%d%%/%d:%02d)\n",
status_item_list[SI_PLAY_TIME],
use_server_time? "~" : "",
total / 60,
);
}
-static char *audiod_status_string(void)
+__malloc static char *audiod_status_string(void)
+{
+ const char *status = (audiod_status == AUDIOD_ON)?
+ "on" : (audiod_status == AUDIOD_OFF)? "off": "sb";
+ return make_message("%s:%s\n", status_item_list[SI_AUDIOD_STATUS], status);
+}
+
+static struct timeval *wstime(void)
{
int i;
- struct timeval *newest_stime = NULL;
- char *ret, *time_string, *uptime_string, *decoder_flags =
- para_malloc((MAX_STREAM_SLOTS + 1) * sizeof(char));
+ struct timeval *max = NULL;
+ FOR_EACH_SLOT(i) {
+ struct slot_info *s = &slot[i];
+ if (!s->wng)
+ continue;
+ if (max && tv_diff(&s->wstime, max, NULL) <= 0)
+ continue;
+ max = &s->wstime;
+ }
+ return max;
+}
+__malloc static char *decoder_flags(void)
+{
+ int i;
+ char decoder_flags[MAX_STREAM_SLOTS + 1];
FOR_EACH_SLOT(i) {
struct slot_info *s = &slot[i];
char flag = '0';
if (s->receiver_node)
flag += 1;
- if (s->wpid > 0)
+ if (s->wng)
flag += 2;
- if (flag != '0')
- flag += s->format * 4;
decoder_flags[i] = flag;
- if (s->wpid <= 0)
- continue;
- if (newest_stime && tv_diff(&s->wstime, newest_stime, NULL) <= 0)
- continue;
- newest_stime = &s->wstime;
}
decoder_flags[MAX_STREAM_SLOTS] = '\0';
- time_string = get_time_string(newest_stime);
- uptime_string = uptime_str();
- ret = make_message("%s:%s\n%s:%s\n%s:%s\n%s",
- status_item_list[SI_AUDIOD_UPTIME], uptime_string,
- status_item_list[SI_DECODER_FLAGS], decoder_flags,
- status_item_list[SI_AUDIOD_STATUS], audiod_status == AUDIOD_ON?
- "on" : (audiod_status == AUDIOD_OFF? "off": "sb"),
- time_string);
- free(uptime_string);
- free(decoder_flags);
- free(time_string);
- return ret;
+ return make_message("%s:%s\n", status_item_list[SI_DECODER_FLAGS],
+ decoder_flags);
}
static char *configfile_exists(void)
static void setup_signal_handling(void)
{
- signal_pipe = para_signal_init();
- PARA_INFO_LOG("signal pipe: fd %d\n", signal_pipe);
+ sig_task->fd = para_signal_init();
+ PARA_INFO_LOG("signal pipe: fd %d\n", sig_task->fd);
para_install_sighandler(SIGINT);
para_install_sighandler(SIGTERM);
para_install_sighandler(SIGCHLD);
static void audiod_status_dump(void)
{
- static char *prev_status;
- char *tmp = audiod_status_string();
-
- if (!prev_status || strcmp(tmp, prev_status))
- stat_client_write(tmp);
- free(prev_status);
- prev_status = tmp;
+ static char *p_ts, *p_us, *p_as, *p_df;
+ struct timeval *t = wstime();
+ char *us, *tmp = get_time_string(t);
+
+ if (tmp && (!p_ts || strcmp(tmp, p_ts)))
+ stat_client_write(tmp, SI_PLAY_TIME);
+ free(p_ts);
+ p_ts = tmp;
+
+ us = uptime_str();
+ tmp = make_message("%s:%s\n", status_item_list[SI_AUDIOD_UPTIME], us);
+ free(us);
+ if (!p_us || strcmp(p_us, tmp))
+ stat_client_write(tmp, SI_AUDIOD_UPTIME);
+ free(p_us);
+ p_us = tmp;
+
+ tmp = audiod_status_string();
+ if (!p_as || strcmp(p_as, tmp))
+ stat_client_write(tmp, SI_AUDIOD_STATUS);
+ free(p_as);
+ p_as = tmp;
+
+ tmp = decoder_flags();
+ if (!p_df || strcmp(p_df, tmp))
+ stat_client_write(tmp, SI_DECODER_FLAGS);
+ free(p_df);
+ p_df = tmp;
}
static void clear_slot(int slot_num)
s->format = -1;
}
-static void kill_stream_writer(int slot_num)
+static void set_restart_barrier(int format, struct timeval *now)
{
- struct slot_info *s = &slot[slot_num];
+ struct timeval tmp;
- if (s->format < 0 || s->wkilled || s->wpid <= 0)
- return;
- PARA_DEBUG_LOG("kill -TERM %d (%s stream writer in slot %d)\n",
- s->wpid, audio_formats[s->format], slot_num);
- kill(s->wpid, SIGTERM);
- s->wkilled = 1;
- s->fci->error = 1;
+ if (now)
+ tmp = *now;
+ else
+ gettimeofday(&tmp, NULL);
+ tv_add(&tmp, &restart_delay, &afi[format].restart_barrier);
}
static void close_receiver(int slot_num)
{
struct slot_info *s = &slot[slot_num];
struct audio_format_info *a;
- struct timeval now;
if (s->format < 0 || !s->receiver_node)
return;
a = &afi[s->format];
- PARA_NOTICE_LOG("closing %s recevier in slot %d\n",
- audio_formats[s->format] , slot_num);
+ PARA_NOTICE_LOG("closing %s recevier in slot %d (eof = %d)\n",
+ audio_formats[s->format] , slot_num, s->receiver_node->eof);
+ if (!s->receiver_node->eof)
+ unregister_task(&s->receiver_node->task);
a->receiver->close(s->receiver_node);
free(s->receiver_node);
s->receiver_node = NULL;
- gettimeofday(&now, NULL);
- tv_add(&now, &restart_delay, &a->restart_barrier); /* FIXME: Use set_restart_barrier() */
+ set_restart_barrier(s->format, NULL);
}
static void kill_all_decoders(void)
{
int i;
- FOR_EACH_SLOT(i)
- if (slot[i].format >= 0) {
- PARA_INFO_LOG("stopping decoder in slot %d\n", i);
- kill_stream_writer(i);
- }
-}
-
-static void set_restart_barrier(int format, struct timeval *now)
-{
- struct timeval tmp;
-
- if (now)
- tmp = *now;
- else
- gettimeofday(&tmp, NULL);
- tv_add(&tmp, &restart_delay, &afi[format].restart_barrier);
+ FOR_EACH_SLOT(i) {
+ struct slot_info *s = &slot[i];
+ if (s->receiver_node)
+ s->receiver_node->eof = 1;
+ }
}
static void check_sigchld(void)
{
pid_t pid;
- int i;
struct timeval now;
gettimeofday(&now, NULL);
pid = para_reap_child();
if (pid <= 0)
return;
- FOR_EACH_SLOT(i) {
- struct slot_info *s = &slot[i];
- long lifetime;
- if (s->format < 0)
- continue;
- if (pid == s->wpid) {
- s->wpid = -1;
- lifetime = now.tv_sec - s->wstime.tv_sec;
- PARA_INFO_LOG("%s stream writer in slot %d died "
- "after %li secs\n",
- audio_formats[s->format], i, lifetime);
- set_restart_barrier(s->format, &now);
- goto reap_next_child;
- }
- }
PARA_CRIT_LOG("para_client died (pid %d)\n", pid);
goto reap_next_child;
}
clear_slot(i);
return i;
}
- if (s->write_fd > 0 || s->wpid > 0)
+ if (s->wng)
continue;
if (s->receiver_node)
continue;
- if (s->fci)
+ if (s->fc)
continue;
clear_slot(i);
return i;
s = &slot[i];
if (s->format == format && s->receiver_node)
ret |= 1;
- if (s->format == format && s->wpid > 0)
+ if (s->format == format && s->wng)
ret |= 2;
}
return ret;
static void close_stat_pipe(void)
{
- char *msg;
int i;
- if (stat_pipe < 0)
+ if (stat_task->fd < 0)
return;
PARA_NOTICE_LOG("%s", "closing status pipe\n");
- close(stat_pipe);
- del_close_on_fork_list(stat_pipe);
- stat_pipe = -1;
+ close(stat_task->fd);
+ del_close_on_fork_list(stat_task->fd);
+ stat_task->fd = -1;
kill_all_decoders();
- for (i = 0; i < RINGBUFFER_SIZE; i++)
- ringbuffer_add(stat_item_ringbuf, para_strdup(NULL));
+ for (i = 0; i < NUM_STAT_ITEMS; i++) {
+ free(stat_item_values[i]);
+ stat_item_values[i] = NULL;
+ }
dump_empty_status();
length_seconds = 0;
offset_seconds = 0;
audiod_status_dump();
playing = 0;
- msg = make_message("%s:no connection to para_server\n",
+ stat_item_values[SI_STATUS_BAR] = make_message("%s:no connection to para_server\n",
status_item_list[SI_STATUS_BAR]);
- ringbuffer_add(stat_item_ringbuf, msg);
- stat_client_write(msg);
- free(msg);
+ stat_client_write(stat_item_values[SI_STATUS_BAR], SI_STATUS_BAR);
}
static void __noreturn clean_exit(int status, const char *msg)
kill_all_decoders();
if (socket_name)
unlink(socket_name);
- if (stat_pipe >= 0)
+ if (stat_task->fd >= 0)
close_stat_pipe();
exit(status);
}
-static char *glob_cmd(char *cmd)
-{
- char *ret, *replacement;
- struct timeval tmp, delay, rss; /* real stream start */
-
- delay.tv_sec = conf.stream_delay_arg / 1000;
- delay.tv_usec = (conf.stream_delay_arg % 1000) * 1000;
-// PARA_INFO_LOG("delay: %lu:%lu\n", delay.tv_sec, delay.tv_usec);
- if (sa_time_diff_sign < 0)
- tv_add(&server_stream_start, &sa_time_diff, &rss);
- else
- tv_diff(&server_stream_start, &sa_time_diff, &rss);
- tv_add(&rss, &delay, &tmp);
- replacement = make_message("%lu:%lu", tmp.tv_sec, tmp.tv_usec);
- ret = s_a_r(cmd, "STREAM_START", replacement);
- free(replacement);
- if (!ret)
- goto out;
- PARA_INFO_LOG("cmd: %s, repl: %s\n", cmd, ret);
- {
- struct timeval now;
- gettimeofday(&now, NULL);
- PARA_INFO_LOG("now: %lu:%lu\n", now.tv_sec, now.tv_usec);
- }
-out:
- return ret;
-}
-
/** get the number of filters for the given audio format */
int num_filters(int audio_format_num)
{
return afi[audio_format_num].num_filters;
}
+void filter_event_handler(struct task *t)
+{
+ PARA_NOTICE_LOG("%s\n", PARA_STRERROR(-t->ret));
+ unregister_task(t);
+}
+
static void open_filters(int slot_num)
{
struct slot_info *s = &slot[slot_num];
int nf = a->num_filters;
int i;
- s->fci = para_calloc(sizeof(struct filter_chain_info));
- INIT_LIST_HEAD(&s->fci->filters);
+ s->fc = NULL;
if (!nf)
return;
- s->fci->inbuf = s->receiver_node->buf;
- s->fci->in_loaded = &s->receiver_node->loaded;
- s->fci->outbuf = s->receiver_node->buf;
- s->fci->out_loaded = &s->receiver_node->loaded;
- s->fci->eof = &s->receiver_node->eof;
+ 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->inbuf = s->receiver_node->buf;
+ s->fc->in_loaded = &s->receiver_node->loaded;
+ s->fc->input_eof = &s->receiver_node->eof;
+
+ 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->task.flags = 0;
+ s->fc->eof = 0;
+ sprintf(s->fc->task.status, "filter chain");
for (i = 0; i < nf; i++) {
struct filter_node *fn = para_calloc(sizeof(struct filter_node));
fn->conf = a->filter_conf[i];
- fn->fci = s->fci;
+ fn->fc = s->fc;
fn->filter = a->filters[i];
INIT_LIST_HEAD(&fn->callbacks);
- list_add_tail(&fn->node, &s->fci->filters);
+ list_add_tail(&fn->node, &s->fc->filters);
fn->filter->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);
- s->fci->outbuf = fn->buf;
- s->fci->out_loaded = &fn->loaded;
+ s->fc->outbuf = fn->buf;
+ s->fc->out_loaded = &fn->loaded;
}
- PARA_DEBUG_LOG("output buffer for filter chain %p: %p\n", s->fci,
- s->fci->outbuf);
+ register_task(&s->fc->task);
+// PARA_DEBUG_LOG("output loaded for filter chain %p: %p\n", s->fc,
+// s->fc->out_loaded);
}
static struct filter_node *find_filter_node(int slot_num, int format, int filternum)
FOR_EACH_SLOT(i) {
struct slot_info *s = &slot[i];
- if (s->format < 0 || !s->fci)
+ if (s->format < 0 || !s->fc)
continue;
if (slot_num >= 0 && slot_num != i)
continue;
continue;
/* success */
j = 1;
- list_for_each_entry(fn, &s->fci->filters, node)
+ list_for_each_entry(fn, &s->fc->filters, node)
if (filternum <= 0 || j++ == filternum)
break;
return fn;
return NULL;
}
-static void start_stream_writer(int slot_num)
+static void wng_event_handler(struct task *t)
{
- int ret, fds[3] = {1, -1, -1};
+ struct writer_node_group *g = t->private_data;
+ int i;
+
+ PARA_INFO_LOG("%s\n", PARA_STRERROR(-t->ret));
+ unregister_task(t);
+ FOR_EACH_SLOT(i) {
+ if (slot[i].wng != g)
+ continue;
+ wng_close(g);
+ wng_destroy(g);
+ slot[i].wng = NULL;
+ }
+}
+
+static void open_writer(int slot_num, struct timeval *now)
+{
+ int ret, i;
struct slot_info *s = &slot[slot_num];
struct audio_format_info *a = &afi[s->format];
- char *glob = glob_cmd(a->write_cmd);
- PARA_INFO_LOG("starting stream writer: %s\n", glob? glob : a->write_cmd);
- open_filters(slot_num);
-
- ret = para_exec_cmdline_pid(&s->wpid, glob? glob : a->write_cmd, fds);
- free(glob);
- if (ret < 0) {
- PARA_ERROR_LOG("exec failed (%d)\n", ret);
- return;
+ PARA_INFO_LOG("opening %s writers\n", audio_formats[s->format]);
+ if (!a->num_writers)
+ s->wng = setup_default_wng();
+ else
+ s->wng = wng_new(a->num_writers);
+ if (s->fc) {
+ s->wng->buf = s->fc->outbuf;
+ s->wng->loaded = s->fc->out_loaded;
+ s->wng->input_eof = &s->fc->eof;
+ s->fc->output_eof = &s->wng->eof;
+ } else {
+ s->wng->buf = s->receiver_node->buf;
+ s->wng->loaded = &s->receiver_node->loaded;
+ s->wng->input_eof = &s->receiver_node->eof;
+ }
+ 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];
+ sprintf(s->wng->writer_nodes[i].task.status, "writer_ node");
}
- s->write_fd = fds[0];
- add_close_on_fork_list(s->write_fd);
- /* we write to this fd in do_select, so we need non-blocking */
- fcntl(s->write_fd, F_SETFL, O_NONBLOCK);
- gettimeofday(&s->wstime, NULL);
+ ret = wng_open(s->wng);
+ s->wstime = *now;
current_decoder = slot_num;
- activate_inactive_grab_clients(slot_num, s->format, &s->fci->filters);
+ activate_inactive_grab_clients(slot_num, s->format, &s->fc->filters);
}
+void rn_event_handler(struct task *t)
+{
+// struct receiver_node *rn = t->private_data;
+ PARA_NOTICE_LOG("%s\n", PARA_STRERROR(-t->ret));
+ unregister_task(t);
+}
static void open_receiver(int format)
{
struct audio_format_info *a = &afi[format];
struct slot_info *s;
int ret, slot_num;
+ struct receiver_node *rn;
slot_num = get_empty_slot();
if (slot_num < 0)
gettimeofday(&s->rtime, NULL);
s->wtime = s->rtime;
s->receiver_node = para_calloc(sizeof(struct receiver_node));
- s->receiver_node->conf = a->receiver_conf;
+ rn = s->receiver_node;
+ rn->receiver = a->receiver;
+ rn->conf = a->receiver_conf;
ret = a->receiver->open(s->receiver_node);
if (ret < 0) {
PARA_ERROR_LOG("failed to open receiver (%s)\n",
}
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;
+ PARA_NOTICE_LOG("rn = %p\n", rn->task.private_data);
+ rn->task.pre_select = a->receiver->pre_select;
+ rn->task.post_select = a->receiver->post_select;
+ rn->task.event_handler = rn_event_handler;
+ rn->task.flags = 0;
+ sprintf(rn->task.status, "receiver node");
+ register_task(&rn->task);
}
-static int is_frozen(int format)
+static int is_frozen(int format, struct timeval *now)
{
- struct timeval now;
struct audio_format_info *a = &afi[format];
- gettimeofday(&now, NULL);
- return (tv_diff(&now, &a->restart_barrier, NULL) > 0)? 0 : 1;
+ return (tv_diff(now, &a->restart_barrier, NULL) > 0)? 0 : 1;
}
-static void start_current_receiver(void)
+static void start_current_receiver(struct timeval *now)
{
int i;
i = get_audio_format_num(af_status);
if (i < 0)
return;
- if ((decoder_running(i) & 1) || is_frozen(i))
+ if ((decoder_running(i) & 1) || is_frozen(i, now))
return;
open_receiver(i);
}
count > 10? sign : sign * time_smooth, &diff,
&tmp);
sa_time_diff = tmp;
- PARA_INFO_LOG("time diff (cur/avg): "
- "%li:%lu/%li:%lu\n",
- sign * diff.tv_sec, (diff.tv_usec + 500) / 1000,
- sa_time_diff_sign * sa_time_diff.tv_sec,
- (sa_time_diff.tv_usec + 500)/ 1000);
+ PARA_INFO_LOG("time diff (cur/avg): %s%lums/%s%lums\n",
+ sign > 0? "+" : "-",
+ tv2ms(&diff),
+ sa_time_diff_sign ? "+" : "-",
+ tv2ms(&sa_time_diff)
+ );
}
static void check_stat_line(char *line)
{
int itemnum;
size_t ilen = 0;
- struct timeval tv;
+ long unsigned sec, usec;
+ char *tmp;
+// PARA_INFO_LOG("line: %s\n", line);
if (!line)
return;
- ringbuffer_add(stat_item_ringbuf, line);
- stat_client_write(line);
itemnum = stat_line_valid(line);
- if (itemnum < 0)
+ if (itemnum < 0) {
+ PARA_WARNING_LOG("invalid status line: %s\n", line);
return;
+ }
+ tmp = make_message("%s\n", line);
+ stat_client_write(tmp, itemnum);
+ free(tmp);
+ free(stat_item_values[itemnum]);
+ stat_item_values[itemnum] = para_strdup(line);
ilen = strlen(status_item_list[itemnum]);
switch (itemnum) {
case SI_STATUS:
length_seconds = atoi(line + ilen + 1);
break;
case SI_STREAM_START:
- if (sscanf(line + ilen + 1, "%lu.%lu",
- &tv.tv_sec, &tv.tv_usec) == 2)
- server_stream_start = tv;
+ if (sscanf(line + ilen + 1, "%lu.%lu", &sec, &usec) == 2) {
+ server_stream_start.tv_sec = sec;
+ server_stream_start.tv_usec = usec;
+ }
break;
case SI_CURRENT_TIME:
- if (sscanf(line + ilen + 1, "%lu.%lu", &tv.tv_sec,
- &tv.tv_usec) == 2)
+ if (sscanf(line + ilen + 1, "%lu.%lu", &sec, &usec) == 2) {
+ struct timeval tv = {sec, usec};
compute_time_diff(&tv);
+ }
break;
}
}
/* check read time */
if (s->receiver_node &&
now.tv_sec > s->rtime.tv_sec + timeout) {
- PARA_INFO_LOG("%s input buffer (slot %d) not ready\n",
+ PARA_INFO_LOG("%s stream (slot %d) not ready\n",
audio_formats[s->format], slot_num);
- if (s->fci)
- s->fci->error = 42;
- else
- close_receiver(slot_num);
+ s->receiver_node->eof = 1;
}
- /* check write time */
- if (s->wpid > 0 && !s->wkilled &&
- now.tv_sec > s->wtime.tv_sec + timeout) {
- PARA_INFO_LOG("%s output buffer (slot %d) not ready\n",
- audio_formats[s->format], slot_num);
- if (s->fci)
- s->fci->error = 42;
- }
- }
-}
-
-static size_t get_loaded_bytes(int slot_num)
-{
- size_t loaded = 0;
- struct slot_info *s = &slot[slot_num];
- struct receiver_node *rn = s->receiver_node;
-
- if (s->format < 0)
- goto out;
-
- if (afi[s->format].num_filters) {
- if (s->fci)
- loaded = *s->fci->out_loaded;
- } else {
- if (rn)
- loaded = rn->loaded;
}
-out:
- return loaded;
}
-
static void close_decoder_if_idle(int slot_num)
{
struct slot_info *s = &slot[slot_num];
- struct receiver_node *rn = s->receiver_node;
if (s->format < 0)
return;
- if (!s->fci)
+ if (!s->fc)
return;
- if (!rn->eof && !s->fci->error && s->wpid > 0)
+ if (s->wng)
return;
- if (!s->fci->error && s->wpid > 0) { /* eof */
- if (filter_io(s->fci) > 0)
- return;
- if (get_loaded_bytes(slot_num))
- return;
- }
- if (s->write_fd > 0) {
- PARA_INFO_LOG("slot %d: closing write fd %d\n", slot_num,
- s->write_fd);
- close(s->write_fd);
- del_close_on_fork_list(s->write_fd);
- s->write_fd = -1;
- }
- if (s->wpid > 0)
- return; /* wait until writer dies before closing filters */
PARA_INFO_LOG("closing all filters in slot %d (filter_chain %p)\n",
- slot_num, s->fci);
- close_filters(s->fci);
- free(s->fci);
+ slot_num, s->fc);
+ close_filters(s->fc);
+ free(s->fc);
close_receiver(slot_num);
clear_slot(slot_num);
}
-static int set_stream_fds(fd_set *wfds)
+static void audiod_pre_select(struct sched *s, __a_unused struct task *t)
{
- int i, max_fileno = -1;
+ int i;
+ if (audiod_status != AUDIOD_ON)
+ kill_all_decoders();
+ else if (playing)
+ start_current_receiver(&s->now);
check_timeouts();
FOR_EACH_SLOT(i) {
- struct slot_info *s = &slot[i];
- struct audio_format_info *a;
struct receiver_node *rn;
close_decoder_if_idle(i);
- s->wcheck = 0;
- if (s->format < 0)
+ if (slot[i].format < 0)
continue;
- a = &afi[s->format];
- rn = s->receiver_node;
- if (rn && rn->loaded && !s->wpid) {
- PARA_INFO_LOG("no writer in slot %d\n", i);
- start_stream_writer(i);
+ rn = slot[i].receiver_node;
+ if (rn && rn->loaded && !slot[i].wng) {
+ open_filters(i);
+ open_writer(i, &s->now);
}
- if (s->write_fd <= 0)
- continue;
- if (!get_loaded_bytes(i))
- continue;
- FD_SET(s->write_fd, wfds);
- s->wcheck = 1;
- max_fileno = MAX(s->write_fd, max_fileno);
}
-// PARA_INFO_LOG("return %d\n", max_fileno);
- return max_fileno;
}
-static int write_audio_data(int slot_num)
+static void audiod_post_select(struct sched *s, __a_unused struct task *t)
{
- struct slot_info *s = &slot[slot_num];
- struct audio_format_info *a = &afi[s->format];
- struct receiver_node *rn = s->receiver_node;
- int rv;
- char **buf;
- size_t *len;
-
- if (a->num_filters) {
- buf = &s->fci->outbuf;
- len = s->fci->out_loaded;
- } else {
- buf = &rn->buf;
- len = &rn->loaded;
- }
- PARA_DEBUG_LOG("writing %p (%zd bytes)\n", *buf, *len);
- rv = write(s->write_fd, *buf, *len);
- PARA_DEBUG_LOG("wrote %d/%zd\n", rv, *len);
- if (rv < 0) {
- PARA_WARNING_LOG("write error in slot %d (fd %d): %s\n",
- slot_num, s->write_fd, strerror(errno));
- *len = 0;
- s->fci->error = E_WRITE_AUDIO_DATA;
- } else if (rv != *len) {
- PARA_DEBUG_LOG("partial %s write (%i/%zd) for slot %d\n",
- audio_formats[s->format], rv, *len, slot_num);
- *len -= rv;
- memmove(*buf, *buf + rv, *len);
- } else
- *len = 0;
- if (rv > 0)
- gettimeofday(&s->wtime, NULL);
- return rv;
-}
-
-static void slot_io(fd_set *wfds)
-{
- int ret, i;
+ int i;
FOR_EACH_SLOT(i) {
- struct slot_info *s = &slot[i];
- struct receiver_node *rn = s->receiver_node;
+ struct receiver_node *rn = slot[i].receiver_node;
if (rn && rn->loaded)
- gettimeofday(&s->rtime, NULL);
- if (s->format >= 0 && s->write_fd > 0 && s->fci) {
- ret = filter_io(s->fci);
- if (ret < 0)
- s->fci->error = -ret;
-// PARA_DEBUG_LOG("slot %d, filter io %d bytes, check write: %d, loaded: %d/%d, eof: %d\n",
-// i, ret, s->wcheck, rn->loaded, *s->fci->out_loaded, rn->eof);
- }
- if (s->write_fd <= 0 || !s->wcheck || !FD_ISSET(s->write_fd, wfds))
- continue;
- write_audio_data(i);
+ slot[i].rtime = s->now;
}
}
+static void init_audiod_task(struct audiod_task *at)
+{
+ at->task.pre_select = audiod_pre_select;
+ at->task.post_select = audiod_post_select;
+ at->task.private_data = at;
+ at->task.flags = 0;
+ sprintf(at->task.status, "audiod task");
+}
+
static int parse_stream_command(const char *txt, char **cmd)
{
char *p = strchr(txt, ':');
free(tmp);
if (ret < 0)
goto out;
- PARA_INFO_LOG("%s -> default filter: %s\n", audio_formats[i], filters[j].name);
+ PARA_INFO_LOG("%s -> default filter: %s\n", audio_formats[i],
+ filters[j].name);
ret = add_filter(i, "wav");
if (ret < 0)
goto out;
static int init_stream_io(void)
{
- int i, ret, receiver_num;
+ int i, ret, receiver_num, nf, nw;
char *cmd;
+ struct audio_format_info *a;
- for (i = 0; i < conf.stream_write_cmd_given; i++) {
- ret = parse_stream_command(conf.stream_write_cmd_arg[i], &cmd);
+ init_supported_writers();
+ nw = PARA_MAX(1, conf.writer_given);
+ PARA_INFO_LOG("allocating space for %d writers\n", nw);
+ FOR_EACH_AUDIO_FORMAT(i) {
+ a = &afi[i];
+ a->writer_conf = para_malloc(nw * sizeof(void *));
+ a->writers = para_malloc(nw * sizeof(struct writer *));
+ a->num_writers = 0;
+ }
+ for (i = 0; i < conf.writer_given; i++) {
+ void *wconf;
+ int writer_num;
+ ret = parse_stream_command(conf.writer_arg[i], &cmd);
if (ret < 0)
goto out;
- afi[ret].write_cmd = para_strdup(cmd);
- PARA_INFO_LOG("%s write command: %s\n", audio_formats[ret], afi[ret].write_cmd);
+ a = &afi[ret];
+ nw = a->num_writers;
+ wconf = check_writer_arg(cmd, &writer_num);
+ if (!wconf) {
+ ret = writer_num;
+ goto out;
+ }
+ a->writers[nw] = &writers[ret];
+ a->writer_conf[nw] = wconf;
+ PARA_INFO_LOG("%s writer #%d: %s\n", audio_formats[ret],
+ nw, writer_names[writer_num]);
+ a->num_writers++;
}
for (i = 0; receivers[i].name; i++) {
PARA_INFO_LOG("initializing %s receiver\n", receivers[i].name);
*/
cmd = para_strdup(receivers[0].name);
FOR_EACH_AUDIO_FORMAT(i) {
- struct audio_format_info *a = &afi[i];
+ a = &afi[i];
if (a->receiver_conf)
continue;
a->receiver_conf = check_receiver_arg(cmd, &receiver_num);
free(cmd);
/* filters */
filter_init(filters);
+ nf = PARA_MAX(2, conf.filter_given) + 1;
+ PARA_INFO_LOG("allocating space for %d filters\n", nf);
FOR_EACH_AUDIO_FORMAT(i) {
- afi[i].filter_conf = para_malloc((conf.filter_given + 1) * sizeof(char *));
- afi[i].filters = para_malloc((conf.filter_given + 1) * sizeof(struct filter *));
+ afi[i].filter_conf = para_malloc(nf * sizeof(void *));
+ afi[i].filters = para_malloc(nf * sizeof(struct filter *));
}
if (!conf.no_default_filters_given)
return setup_default_filters();
/*
* command handlers don't close their fd on errors (ret < 0) so that
* its caller can send an error message. Otherwise (ret >= 0) it's up
- * to each individual command to close the fd if necessary.
+ * to each individual command to close the fd if necessary.
*/
static int com_help(int fd, int argc, char **argv)
return ret;
}
-static int com_stat(int fd, __unused int argc, __unused char **argv)
+static int com_stat(int fd, __a_unused int argc, __a_unused char **argv)
{
int i, ret;
- char *buf = audiod_status_string();
+ char *buf = NULL;
+ long unsigned mask = ~0LU;
- buf = para_strcat(buf, "\n");
- for (i = RINGBUFFER_SIZE - 1; i >= 0; i--) {
- char *tmp, *line = ringbuffer_get(stat_item_ringbuf, i);
- if (!line)
- continue;
- tmp = make_message("%s\n", line);
- buf = para_strcat(buf, tmp);
+ if (argc > 1) {
+ mask = 0;
+ for (i = 1; i < argc; i++) {
+ ret = stat_item_valid(argv[i]);
+ if (ret < 0)
+ return ret;
+ mask |= (1 << ret);
+ }
+ }
+ PARA_INFO_LOG("mask: 0x%lx\n", mask);
+ if (mask & (1 << SI_PLAY_TIME)) {
+ struct timeval *t = wstime();
+ char *ts = get_time_string(t);
+ if (ts) {
+ ret = client_write(fd, ts);
+ if (ret < 0)
+ goto out;
+ free(ts);
+ }
+ }
+ if (mask & (1 << SI_AUDIOD_UPTIME)) {
+ char *tmp, *us = uptime_str();
+ tmp = make_message("%s:%s\n",
+ status_item_list[SI_AUDIOD_UPTIME], us);
+ free(us);
+ ret = client_write(fd, tmp);
+ if (ret < 0)
+ goto out;
free(tmp);
}
+ if (mask & (1 << SI_AUDIOD_STATUS)) {
+ char *s = audiod_status_string();
+ ret = client_write(fd, s);
+ if (ret < 0)
+ goto out;
+ free(s);
+ }
+ if (mask & (1 << SI_DECODER_FLAGS)) {
+ char *df =decoder_flags();
+ ret = client_write(fd, df);
+ if (ret < 0)
+ goto out;
+ free(df);
+ }
+
+ for (i = 0; i < NUM_STAT_ITEMS; i++) {
+ char *tmp, *v;
+ if (!((1 << i) & mask))
+ continue;
+ v = stat_item_values[i];
+ tmp = make_message("%s%s%s", buf? buf: "",
+ v? v : "", v? "\n" : "");
+ free(buf);
+ buf = tmp;
+ }
ret = client_write(fd, buf);
+out:
if (ret > 0)
- ret = stat_client_add(fd);
+ ret = stat_client_add(fd, mask);
free(buf);
return ret;
}
-#if 0
-static char *list_filters(void)
-{
- int i, j;
- char *tmp, *msg = make_message("format\tnum\tcmd\n");
-
- FOR_EACH_AUDIO_FORMAT(i) {
- for (j = 0; j < afi[i].num_filters; j++) {
- tmp = make_message("%s\t%i\t%s\n",
- afi[i].name, j, afi[i].filter_cmds[j]);
- msg = para_strcat(msg, tmp);
- free(tmp);
- }
- tmp = make_message("%s\t%i\t%s\n", afi[i].name,
- j, afi[i].write_cmd);
- msg = para_strcat(msg, tmp);
- free(tmp);
- }
- return msg;
-}
-#endif
-
-static int com_grab(int fd, int argc, char **argv)
+static int com_grab(int fd, char *cmdline)
{
struct grab_client *gc;
struct filter_node *fn;
- int err;
+ int i, err;
+ char *msg;
- PARA_INFO_LOG("argc: %d, argv[0]: %s, optind: %d\n", argc, argv[0], optind);
- gc = grab_client_new(fd, argc, argv, &err);
- PARA_INFO_LOG("argc: %d, argv[0]: %s, optind: %d\n", argc, argv[0], optind);
+ gc = grab_client_new(fd, cmdline, &err);
if (!gc)
goto err_out;
fn = find_filter_node(gc->conf->slot_arg, gc->audio_format_num, gc->conf->filter_num_arg);
activate_grab_client(gc, fn);
return 1;
err_out:
- if (err != -E_GC_HELP_GIVEN)
+ if (err != -E_GC_HELP_GIVEN && err != -E_GC_VERSION_GIVEN)
return err;
- err = client_write(fd, "Usage: para_audioc [audioc_options] -- "
- "grab [grab_options]\nAvailable options:\n");
- if (err < 0)
- return err;
- err = client_write(fd, GRAB_HELP_TXT);
+ if (err == -E_GC_HELP_GIVEN) {
+ msg = make_message("%s\n\n", grab_client_args_info_usage);
+ for (i = 0; grab_client_args_info_help[i]; i++) {
+ char *tmp = make_message("%s%s\n", msg,
+ grab_client_args_info_help[i]);
+ free(msg);
+ msg = tmp;
+ }
+ } else
+ msg = make_message("%s %s\n",
+ GRAB_CLIENT_CMDLINE_PARSER_PACKAGE,
+ GRAB_CLIENT_CMDLINE_PARSER_VERSION);
+ err = client_write(fd, msg);
+ free(msg);
if (err < 0)
return err;
close(fd);
return 1;
}
-static int __noreturn com_term(int fd, __unused int argc, __unused char **argv)
+static int __noreturn com_term(int fd, __a_unused int argc, __a_unused char **argv)
{
close(fd);
clean_exit(EXIT_SUCCESS, "terminating on user request");
}
-static int com_on(int fd, __unused int argc, __unused char **argv)
+static int com_on(int fd, __a_unused int argc, __a_unused char **argv)
{
audiod_status = AUDIOD_ON;
close(fd);
return 1;
}
-static int com_off(int fd, __unused int argc, __unused char **argv)
+static int com_off(int fd, __a_unused int argc, __a_unused char **argv)
{
audiod_status = AUDIOD_OFF;
close(fd);
return 1;
}
-static int com_sb(int fd, __unused int argc, __unused char **argv)
+static int com_sb(int fd, __a_unused int argc, __a_unused char **argv)
{
audiod_status = AUDIOD_STANDBY;
close(fd);
return 1;
}
-static int check_perms(struct ucred *c)
+static int check_perms(uid_t uid)
{
int i;
if (!conf.user_allow_given)
return 1;
for (i = 0; i < conf.user_allow_given; i++)
- if (c->uid == conf.user_allow_arg[i])
+ if (uid == conf.user_allow_arg[i])
return 1;
return -E_UCRED_PERM;
}
static int handle_connect(void)
{
int i, argc, ret, clifd = -1;
- struct ucred c;
- char *buf = para_malloc(MAXLINE), **argv = NULL;
+ char *cmd = NULL, *p, *buf = para_calloc(MAXLINE), **argv = NULL;
struct sockaddr_un unix_addr;
- ret = para_accept(audiod_socket, &unix_addr, sizeof(struct sockaddr_un));
+ ret = para_accept(cmd_task->fd, &unix_addr, sizeof(struct sockaddr_un));
if (ret < 0)
goto out;
clifd = ret;
- ret = recv_cred_buffer(clifd, buf, MAXLINE - 1, &c);
+ ret = recv_cred_buffer(clifd, buf, MAXLINE - 1);
if (ret < 0)
goto out;
- PARA_INFO_LOG("pid: %i, uid: %i, gid: %i, ret: %i, buf: %s\n", c.pid, c.uid, c.gid, ret, buf);
- buf[ret] = '\0';
- ret = check_perms(&c);
+ PARA_INFO_LOG("connection from user %i, buf: %s\n", ret, buf);
+ ret = check_perms(ret);
if (ret < 0)
goto out;
- argc = split_args(buf, &argv, '\n');
- PARA_INFO_LOG("argv[0]: %s\n", argv[0]);
+ ret = -E_INVALID_AUDIOD_CMD;
+ cmd = para_strdup(buf);
+ p = strchr(cmd, '\n');
+ if (!p)
+ p = "";
+ else {
+ *p = '\0';
+ p++;
+ }
for (i = 0; cmds[i].name; i++) {
- if (strcmp(cmds[i].name, argv[0]))
+ int j;
+ if (strcmp(cmds[i].name, cmd))
continue;
- ret = cmds[i].handler(clifd, argc + 1, argv);
+ if (cmds[i].handler) {
+ argc = split_args(buf, &argv, "\n");
+ PARA_INFO_LOG("argv[0]: %s, argc= %d\n", argv[0], argc);
+ ret = cmds[i].handler(clifd, argc, argv);
+ goto out;
+ }
+ for (j = 0; p[j]; j++)
+ if (p[j] == '\n')
+ p[j] = ' ';
+ PARA_INFO_LOG("cmd: %s, options: %s\n", cmd, p);
+ ret = cmds[i].line_handler(clifd, p);
goto out;
}
ret = -E_INVALID_AUDIOD_CMD; /* cmd not found */
out:
+ free(cmd);
free(buf);
free(argv);
if (clifd > 0 && ret < 0 && ret != -E_CLIENT_WRITE) {
PARA_NOTICE_LOG("connecting to local socket %s\n", socket_name);
if (conf.force_given)
unlink(socket_name);
- audiod_socket = create_pf_socket(socket_name, &unix_addr,
+ cmd_task->fd = create_pf_socket(socket_name, &unix_addr,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IWOTH);
- if (audiod_socket < 0) {
+ if (cmd_task->fd < 0) {
PARA_EMERG_LOG("%s", "can not connect to socket\n");
exit(EXIT_FAILURE); /* do not unlink socket */
}
- if (listen(audiod_socket, 5) < 0) {
+ if (listen(cmd_task->fd , 5) < 0) {
PARA_EMERG_LOG("%s", "can not listen on socket\n");
exit(EXIT_FAILURE); /* do not unlink socket */
}
- add_close_on_fork_list(audiod_socket);
+ add_close_on_fork_list(cmd_task->fd);
}
static int open_stat_pipe(void)
{
int ret, fd[3] = {-1, 1, 0};
- char *argv[] = {BINDIR "/para_client", "stat", NULL};
pid_t pid;
- ret = para_exec(&pid, BINDIR "/para_client", argv, fd);
+ ret = para_exec_cmdline_pid(&pid, BINDIR "/para_client stat", fd);
if (ret >= 0) {
ret = fd[1];
PARA_NOTICE_LOG("stat pipe opened, fd %d\n", ret);
return ret;
}
-static int pre_select(fd_set *rfds, fd_set *wfds, struct timeval *tv)
+void signal_event_handler(struct task *t)
{
- int i, ret, max = -1;
+ struct signal_task *st = t->private_data;
+ handle_signal(st->signum);
+}
- FOR_EACH_SLOT(i) {
- struct slot_info *s = &slot[i];
- struct audio_format_info *a;
- struct receiver_node *rn = s->receiver_node;
- if (s->format < 0 || !rn)
- continue;
- a = &afi[s->format];
- ret = a->receiver->pre_select(rn, rfds, wfds, tv);
-// PARA_NOTICE_LOG("%s preselect: %d\n", a->receiver->name, ret);
- max = MAX(max, ret);
- }
- return max;
+void signal_pre_select(struct sched *s, struct task *t)
+{
+ struct signal_task *st = t->private_data;
+ t->ret = 1;
+ para_fd_set(st->fd, &s->rfds, &s->max_fileno);
+}
+void signal_post_select(struct sched *s, struct task *t)
+{
+ struct signal_task *st = t->private_data;
+ t->ret = 1;
+ if (!FD_ISSET(st->fd, &s->rfds))
+ return;
+ t->ret = -E_SIGNAL_CAUGHT;
+ st->signum = para_next_signal();
}
-static void audiod_post_select(int select_ret, fd_set *rfds, fd_set *wfds)
+
+void signal_setup_default(struct signal_task *st)
{
- int i, ret;
+ st->task.pre_select = signal_pre_select;
+ st->task.post_select = signal_post_select;
+ st->task.private_data = st;
+ st->task.flags = 0;
+ sprintf(st->task.status, "signal task");
+}
+
+static void command_pre_select(struct sched *s, struct task *t)
+{
+ struct command_task *ct = t->private_data;
+ para_fd_set(ct->fd, &s->rfds, &s->max_fileno);
- FOR_EACH_SLOT(i) {
- struct slot_info *s = &slot[i];
- struct audio_format_info *a;
- struct receiver_node *rn = s->receiver_node;
- if (s->format < 0 || !rn || rn->eof)
- continue;
- a = &afi[s->format];
- ret = a->receiver->post_select(rn, select_ret, rfds, wfds);
- if (ret <= 0) {
- if (ret)
- PARA_ERROR_LOG("%s post select failed: %s (slot %d)\n",
- a->receiver->name, PARA_STRERROR(-ret), i);
- else
- PARA_INFO_LOG("eof in slot %d\n", i);
- rn->eof = 1;
- }
- if (ret < 0 && s->fci)
- s->fci->error = ret;
- }
}
-/* TODO: move everything before the select call to pre_select() */
-static void __noreturn audiod_mainloop(void)
+static void command_post_select(struct sched *s, struct task *t)
{
- fd_set rfds, wfds;
- int ret, max_fileno, sbo = 0;
- char status_buf[STRINGSIZE] = "";
- struct timeval tv;
-repeat:
- FD_ZERO(&rfds);
- FD_ZERO(&wfds);
- max_fileno = 0;
- if (audiod_status != AUDIOD_ON)
- kill_all_decoders();
- else if (playing)
- start_current_receiver();
- max_fileno = set_stream_fds(&wfds);
- /* stat pipe (read) */
- if (stat_pipe >= 0 && audiod_status == AUDIOD_OFF)
- close_stat_pipe();
- if (stat_pipe < 0 && audiod_status != AUDIOD_OFF) {
- stat_pipe = open_stat_pipe();
- sbo = 0;
- status_buf[0] = '\0';
- }
- if (stat_pipe >= 0 && audiod_status != AUDIOD_OFF) {
- FD_SET(stat_pipe, &rfds);
- max_fileno = MAX(max_fileno, stat_pipe);
- }
- /* always check signal pipe */
- FD_SET(signal_pipe, &rfds);
- max_fileno = MAX(max_fileno, signal_pipe);
- /* local socket */
- if (audiod_socket < 0)
- audiod_get_socket(); /* doesn't return on errors */
- FD_SET(audiod_socket, &rfds);
- max_fileno = MAX(max_fileno, audiod_socket);
- tv.tv_sec = 0;
- tv.tv_usec = 200 * 1000;
- ret = pre_select(&rfds, &wfds, &tv);
- max_fileno = MAX(max_fileno, ret);
- ret = select(max_fileno + 1, &rfds, &wfds, NULL, &tv);
- if (ret < 0 && errno != EINTR)
- PARA_ERROR_LOG("select returned %d (%s)\n", ret,
- strerror(errno));
+ int ret;
+ struct command_task *ct = t->private_data;
+
if (audiod_status != AUDIOD_OFF)
audiod_status_dump();
+ t->ret = 1; /* always successful */
+ if (!FD_ISSET(ct->fd, &s->rfds))
+ return;
+ ret = handle_connect();
if (ret < 0)
- goto repeat;
- audiod_post_select(ret, &rfds, &wfds);
- /* read status pipe */
- if (stat_pipe >=0 && FD_ISSET(stat_pipe, &rfds)) {
- ret = read(stat_pipe, status_buf + sbo, STRINGSIZE - 1 - sbo);
- if (ret <= 0) {
- close_stat_pipe();
- /* avoid busy loop if server is down */
- while (sleep(1) > 0)
- ; /* try again*/
- } else {
- status_buf[ret + sbo] = '\0';
- sbo = for_each_line(status_buf, ret + sbo,
- &check_stat_line, 0);
- }
- }
- slot_io(&wfds);
- if (FD_ISSET(audiod_socket, &rfds)) {
- ret = handle_connect();
- if (ret < 0) {
- PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret));
- }
+ PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret));
+}
+
+void init_command_task(struct command_task *ct)
+{
+ ct->task.pre_select = command_pre_select;
+ ct->task.post_select = command_post_select;
+ ct->task.private_data = ct;
+ ct->task.flags = 0;
+ sprintf(ct->task.status, "command task");
+}
+
+static void status_pre_select(struct sched *s, struct task *t)
+{
+ struct status_task *st = t->private_data;
+ t->ret = 1;
+ if (st->fd >= 0 && audiod_status == AUDIOD_OFF)
+ close_stat_pipe();
+ if (st->fd < 0 && audiod_status != AUDIOD_OFF) {
+ st->fd = open_stat_pipe();
+ st->loaded = 0;
+ st->buf[0] = '\0';
}
- /* signals */
- if (FD_ISSET(signal_pipe, &rfds)) {
- int sig_nr = para_next_signal();
- if (sig_nr > 0)
- handle_signal(sig_nr);
+ if (st->fd >= 0 && audiod_status != AUDIOD_OFF)
+ para_fd_set(st->fd, &s->rfds, &s->max_fileno);
+}
+
+static void status_post_select(struct sched *s, struct task *t)
+{
+ struct status_task *st = t->private_data;
+ int ret;
+
+ t->ret = 1;
+ if (st->fd < 0 || !FD_ISSET(st->fd, &s->rfds))
+ return;
+ ret = read(st->fd, st->buf + st->loaded,
+ STRINGSIZE - 1 - st->loaded);
+ if (ret <= 0) {
+ close_stat_pipe();
+ /* avoid busy loop if server is down */
+ while (sleep(1) > 0)
+ ; /* try again*/
+ } else {
+ st->buf[ret + st->loaded] = '\0';
+ st->loaded = for_each_line(st->buf, ret + st->loaded,
+ &check_stat_line);
}
- goto repeat;
+}
+
+static void init_status_task(struct status_task *st)
+{
+ st->task.pre_select = status_pre_select;
+ st->task.post_select = status_post_select;
+ st->task.private_data = st;
+ st->task.flags = 0;
+ st->loaded = 0;
+ st->fd = -1;
+ st->buf[0] = '\0';
+ sprintf(st->task.status, "status task");
}
static void set_initial_status(void)
PARA_WARNING_LOG("%s", "invalid mode\n");
}
-int __noreturn main(int argc, char *argv[])
+int main(int argc, char *argv[])
{
char *cf;
- int i;
+ int ret, i;
+ struct sched s;
+
+ init_sched();
valid_fd_012();
hostname = para_hostname();
cmdline_parser(argc, argv, &conf);
- para_drop_privileges(conf.user_arg);
+ para_drop_privileges(conf.user_arg, conf.group_arg);
cf = configfile_exists();
if (cf) {
if (cmdline_parser_configfile(cf, &conf, 0, 0, 0)) {
- fprintf(stderr, "parse error in config file\n");
+ PARA_EMERG_LOG("%s", "parse error in config file\n");
exit(EXIT_FAILURE);
}
}
+ if (conf.logfile_given)
+ logfile = open_log(conf.logfile_arg);
log_welcome("para_audiod", conf.loglevel_arg);
i = init_stream_io();
if (i < 0) {
- fprintf(stderr, "init stream io error: %s\n",
- PARA_STRERROR(-i));
+ PARA_EMERG_LOG("init stream io error: %s\n", PARA_STRERROR(-i));
exit(EXIT_FAILURE);
}
server_uptime(UPTIME_SET);
set_initial_status();
FOR_EACH_SLOT(i)
clear_slot(i);
- stat_item_ringbuf = ringbuffer_new(RINGBUFFER_SIZE);
init_grabbing();
setup_signal_handling();
if (conf.daemon_given)
daemon_init();
- audiod_mainloop();
+ audiod_get_socket(); /* doesn't return on errors */
+
+ signal_setup_default(sig_task);
+ sig_task->task.event_handler = signal_event_handler;
+
+ init_status_task(stat_task);
+ init_command_task(cmd_task);
+ init_audiod_task(at);
+
+ register_task(&sig_task->task);
+ register_task(&cmd_task->task);
+ register_task(&stat_task->task);
+ register_task(&at->task);
+ s.default_timeout.tv_sec = 0;
+ s.default_timeout.tv_usec = 99 * 1000;
+ ret = sched(&s);
+
+ PARA_EMERG_LOG("%s\n", PARA_STRERROR(-ret));
+ return EXIT_FAILURE;
}