Replace eof by error in receivers/filters/writers.
[paraslash.git] / audiod.c
index dfb61db..f83943a 100644 (file)
--- a/audiod.c
+++ b/audiod.c
@@ -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;
@@ -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) {