Replace eof by error in receivers/filters/writers.

[paraslash.git] / audiod.c

diff --git a/audiod.c b/audiod.c
index d2d0004a157f961b239cf4a89f66fcf8c86c72a2..f83943a682f5c86496f1bd6efe1cd6b265443268 100644 (file)
--- a/audiod.c
+++ b/audiod.c
@@ -119,7 +119,7 @@ int get_audio_format_num(char *name)
 {
        int i;
 
-       while (isspace(*name))
+       while (para_isspace(*name))
                name++;
        FOR_EACH_AUDIO_FORMAT(i)
                if (!strcmp(name, audio_formats[i]))
@@ -197,34 +197,34 @@ static void close_receiver(int slot_num)
        if (s->format < 0 || !s->receiver_node)
                return;
        a = &afi[s->format];
-       PARA_NOTICE_LOG("closing %s receiver in slot %d (eof = %d)\n",
-               audio_formats[s->format] , slot_num, s->receiver_node->eof);
+       PARA_NOTICE_LOG("closing %s receiver in slot %d\n",
+               audio_formats[s->format], slot_num);
        a->receiver->close(s->receiver_node);
        free(s->receiver_node);
        s->receiver_node = NULL;
 }
 
-static void kill_all_decoders(void)
+static void kill_all_decoders(int error)
 {
        int i;
 
        FOR_EACH_SLOT(i) {
                struct slot_info *s = &slot[i];
-               if (s->wng && !s->wng->eof) {
+               if (s->wng && !s->wng->error) {
                        PARA_INFO_LOG("unregistering writer node group in slot %d\n",
                                i);
                        wng_unregister(s->wng);
-                       s->wng->eof = 1;
+                       s->wng->error = error;
                }
-               if (s->fc && !s->fc->eof) {
+               if (s->fc && !s->fc->error) {
                        PARA_INFO_LOG("unregistering filter chain in slot %d\n", i);
                        unregister_task(&s->fc->task);
-                       s->fc->eof = 1;
+                       s->fc->error = error;
                }
-               if (s->receiver_node && !s->receiver_node->eof) {
+               if (s->receiver_node && !s->receiver_node->error) {
                        PARA_INFO_LOG("unregistering receiver_node in slot %d\n", i);
                        unregister_task(&s->receiver_node->task);
-                       s->receiver_node->eof = 1;
+                       s->receiver_node->error = error;
                }
        }
 }
@@ -266,7 +266,7 @@ 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->eof = 1;
+       fc->error = t->ret;
        unregister_task(t);
 }
 
@@ -285,13 +285,13 @@ static void open_filters(int slot_num)
        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->input_error = &s->receiver_node->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->eof = 0;
+       s->fc->error = 0;
 
-       s->receiver_node->output_eof = &s->fc->eof;
+       s->receiver_node->output_error = &s->fc->error;
        sprintf(s->fc->task.status, "filter chain");
        for (i = 0; i < nf; i++) {
                struct filter_node *fn = para_calloc(sizeof(struct filter_node));
@@ -315,7 +315,7 @@ 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->eof = 1;
+       wng->error = t->ret;
        wng_unregister(wng);
 }
 
@@ -333,15 +333,15 @@ static void open_writers(int slot_num)
        if (s->fc) {
                s->wng->buf = s->fc->outbuf;
                s->wng->loaded = s->fc->out_loaded;
-               s->wng->input_eof = &s->fc->eof;
+               s->wng->input_error = &s->fc->error;
                s->wng->channels = &s->fc->channels;
                s->wng->samplerate = &s->fc->samplerate;
-               s->fc->output_eof = &s->wng->eof;
+               s->fc->output_error = &s->wng->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_eof = &s->receiver_node->eof;
+               s->wng->input_error = &s->receiver_node->error;
        }
        s->wng->task.event_handler = wng_event_handler;
        for (i = 0; i < a->num_writers; i++) {
@@ -360,16 +360,19 @@ static void open_writers(int slot_num)
 static void rn_event_handler(struct task *t)
 {
        struct receiver_node *rn = t->private_data;
-       const struct timeval restart_delay = {0, 10 * 1000};
        int i;
 
        PARA_NOTICE_LOG("%s\n", PARA_STRERROR(-t->ret));
        unregister_task(t);
-       rn->eof = 1;
+       rn->error = t->ret;
        /* set restart barrier */
        FOR_EACH_SLOT(i) {
+               struct timeval restart_delay = {0, 10 * 1000};
                if (slot[i].receiver_node != rn)
                        continue;
+               if (rn->error != -E_RECV_EOF)
+                       /* don't reconnect immediately on errors */
+                       restart_delay.tv_sec = 5;
                tv_add(now, &restart_delay, &afi[slot[i].format].restart_barrier);
        }
 }
@@ -420,7 +423,7 @@ static int receiver_running(int format)
        FOR_EACH_SLOT(i) {
                struct slot_info *s = &slot[i];
                if (s->format == format && s->receiver_node
-                               && !s->receiver_node->eof)
+                               && !s->receiver_node->error)
                        return 1;
        }
        return 0;
@@ -519,7 +522,7 @@ static int check_stat_line(char *line, __a_unused void *data)
        case SI_OFFSET:
                stat_task->offset_seconds = atoi(line + ilen + 1);
                break;
-       case SI_LENGTH:
+       case SI_SECONDS_TOTAL:
                stat_task->length_seconds = atoi(line + ilen + 1);
                break;
        case SI_STREAM_START:
@@ -558,13 +561,13 @@ static void try_to_close_slot(int slot_num)
 
        if (s->format < 0)
                return;
-       if (s->receiver_node && !s->receiver_node->eof)
+       if (s->receiver_node && !s->receiver_node->error)
                return;
-       if (s->fc && !s->fc->eof)
+       if (s->fc && !s->fc->error)
                return;
-       if (s->wng && !s->wng->eof)
+       if (s->wng && !s->wng->error)
                return;
-       PARA_INFO_LOG("closing slot %d \n", slot_num);
+       PARA_INFO_LOG("closing slot %d\n", slot_num);
        wng_close(s->wng);
        close_filters(s->fc);
        free(s->fc);
@@ -585,7 +588,7 @@ static void audiod_pre_select(struct sched *s, __a_unused struct task *t)
 
        t->ret = 1;
        if (audiod_status != AUDIOD_ON || !stat_task->playing)
-               return kill_all_decoders();
+               return kill_all_decoders(-E_NOT_PLAYING);
        if (open_current_receiver(s))
                s->timeout = min_delay;
        FOR_EACH_SLOT(i) {
@@ -869,7 +872,7 @@ static int audiod_get_socket(void)
                PARA_EMERG_LOG("can not listen on socket\n");
                exit(EXIT_FAILURE); /* do not unlink socket */
        }
-       mark_fd_nonblock(fd);
+       mark_fd_nonblocking(fd);
        return fd;
 }
 
@@ -951,7 +954,7 @@ static void close_stat_pipe(void)
                return;
        client_close(stat_task->pcd);
        stat_task->pcd = NULL;
-       for (i = 0; i < NUM_STAT_ITEMS; i++) {
+       FOR_EACH_STATUS_ITEM(i) {
                free(stat_task->stat_item_values[i]);
                stat_task->stat_item_values[i] = NULL;
        }
@@ -961,7 +964,7 @@ static void close_stat_pipe(void)
        audiod_status_dump();
        stat_task->playing = 0;
        stat_task->stat_item_values[SI_BASENAME] = make_message(
-               "%s:no connection to para_server\n",
+               "%s: no connection to para_server\n",
                status_item_list[SI_BASENAME]);
        stat_client_write(stat_task->stat_item_values[SI_BASENAME],
                SI_BASENAME);
@@ -1168,7 +1171,7 @@ int main(int argc, char *argv[])
        register_task(audiod_task);
        s.default_timeout.tv_sec = 0;
        s.default_timeout.tv_usec = 99 * 1000;
-       ret = sched(&s);
+       ret = schedule(&s);
 
        PARA_EMERG_LOG("%s\n", PARA_STRERROR(-ret));
        return EXIT_FAILURE;