audiod: Get rid of the audiod task.

It's simpler to start/stop the decoders from status_pre_select()
because this is the point where we get the recent status info from
para_server.

In particular, this allows to kill the min_delay crap in
the audiod_pre_select() which now gets called from
status_pre_select(). Rename it to start_stop_decoders() as
this is what that function does.

diff --git a/audiod.c b/audiod.c
index 615db847f05682288c926f68402028ca09cc6f36..9d32e889ea37364addb3258bd15458615e776a78 100644 (file)
--- a/audiod.c
+++ b/audiod.c
@@ -533,96 +533,6 @@ static int check_stat_line(char *line, __a_unused void *data)
        return 1;
 }
 
        return 1;
 }
 

-static void try_to_close_slot(int slot_num)
-{
-       struct slot_info *s = &slot[slot_num];
-
-       if (s->format < 0)
-               return;
-       if (s->receiver_node && s->receiver_node->task.error >= 0)
-               return;
-       if (s->fc && s->fc->task.error >= 0)
-               return;
-       if (s->wng && s->wng->task.error >= 0)
-               return;
-       PARA_INFO_LOG("closing slot %d\n", slot_num);
-       wng_close(s->wng);
-       close_filters(s->fc);
-       free(s->fc);
-       close_receiver(slot_num);
-       clear_slot(slot_num);
-}
-
-/*
- * Check if any receivers/filters/writers need to be started and do so if
- * necessary.  Since the pre_select function didn't have a chance yet to put
- * file descriptors into the fd sets given by s, make the upcoming select()
- * return immediately to avoid a long timeout in case we started something.
- */
-static void audiod_pre_select(struct sched *s, __a_unused struct task *t)
-{
-       int i;
-       struct timeval min_delay = {0, 1};
-
-       if (audiod_status != AUDIOD_ON || !stat_task->playing)
-               return kill_all_decoders(-E_NOT_PLAYING);
-       if (open_current_receiver(s))
-               s->timeout = min_delay;
-       FOR_EACH_SLOT(i) {
-               struct slot_info *sl = &slot[i];
-               struct audio_format_info *a;
-               struct timeval diff;
-
-               if (sl->format < 0)
-                       continue;
-               a = &afi[sl->format];
-               if (!sl->receiver_node)
-                       continue;
-               if ((!a->num_filters || sl->fc) && sl->wng)
-                       continue; /* everything already started */
-               if (!a->num_filters) {
-                       if (sl->receiver_node->loaded && !sl->wng) {
-                               open_writers(i);
-                               s->timeout = min_delay;
-                       }
-                       continue;
-               }
-               if (sl->receiver_node->loaded && !sl->fc) {
-                       open_filters(i);
-                       s->timeout = min_delay;
-                       continue;
-               }
-               if (sl->wng || !sl->fc || !*sl->fc->out_loaded)
-                       continue;
-               if (tv_diff(now, &initial_delay_barrier, &diff) > 0) {
-                       open_writers(i);
-                       s->timeout = min_delay;
-                       continue;
-               }
-               PARA_INFO_LOG("initial delay: %lu ms left\n", tv2ms(&diff));
-               if (tv_diff(&s->timeout, &diff, NULL) > 0) {
-                       s->timeout = diff;
-               }
-       }
-}
-
-static void audiod_post_select(__a_unused struct sched *s,
-       __a_unused struct task *t)
-{
-       int i;
-
-       FOR_EACH_SLOT(i)
-               try_to_close_slot(i);
-}
-
-static void init_audiod_task(struct task *t)
-{
-       t->pre_select = audiod_pre_select;
-       t->post_select = audiod_post_select;
-       t->error = 0;
-       sprintf(t->status, "audiod task");
-}
-

 static int parse_stream_command(const char *txt, char **cmd)
 {
        char *p = strchr(txt, ':');
 static int parse_stream_command(const char *txt, char **cmd)
 {
        char *p = strchr(txt, ':');


@@ -969,34 +879,103 @@ static void set_stat_task_restart_barrier(unsigned seconds)
        tv_add(now, &delay, &stat_task->restart_barrier);
 }
 
        tv_add(now, &delay, &stat_task->restart_barrier);
 }
 

+static void try_to_close_slot(int slot_num)
+{
+       struct slot_info *s = &slot[slot_num];
+
+       if (s->format < 0)
+               return;
+       if (s->receiver_node && s->receiver_node->task.error != -E_TASK_UNREGISTERED)
+               return;
+       if (s->fc && s->fc->task.error != -E_TASK_UNREGISTERED)
+               return;
+       if (s->wng && s->wng->task.error != -E_TASK_UNREGISTERED)
+               return;
+       PARA_INFO_LOG("closing slot %d\n", slot_num);
+       wng_close(s->wng);
+       close_filters(s->fc);
+       free(s->fc);
+       close_receiver(slot_num);
+       clear_slot(slot_num);
+}
+
+/*
+ * Check if any receivers/filters/writers need to be started and do so if
+ * necessary.
+ */
+static void start_stop_decoders(struct sched *s)
+{
+       int i;
+
+       FOR_EACH_SLOT(i)
+               try_to_close_slot(i);
+       if (audiod_status != AUDIOD_ON || !stat_task->playing)
+               return kill_all_decoders(-E_NOT_PLAYING);
+       open_current_receiver(s);
+       FOR_EACH_SLOT(i) {
+               struct slot_info *sl = &slot[i];
+               struct audio_format_info *a;
+               struct timeval diff;
+
+               if (sl->format < 0)
+                       continue;
+               a = &afi[sl->format];
+               if (!sl->receiver_node)
+                       continue;
+               if ((!a->num_filters || sl->fc) && sl->wng)
+                       continue; /* everything already started */
+               if (!a->num_filters) {
+                       if (sl->receiver_node->loaded && !sl->wng) {
+                               open_writers(i);
+                       }
+                       continue;
+               }
+               if (sl->receiver_node->loaded && !sl->fc) {
+                       open_filters(i);
+                       continue;
+               }
+               if (sl->wng || !sl->fc || !*sl->fc->out_loaded)
+                       continue;
+               if (tv_diff(now, &initial_delay_barrier, &diff) > 0) {
+                       open_writers(i);
+                       continue;
+               }
+               PARA_INFO_LOG("initial delay: %lu ms left\n", tv2ms(&diff));
+               if (tv_diff(&s->timeout, &diff, NULL) > 0) {
+                       s->timeout = diff;
+               }
+       }
+}
+
+

 /* restart the client task if necessary */
 /* restart the client task if necessary */

-static void status_pre_select(__a_unused struct sched *s, struct task *t)
+static void status_pre_select(struct sched *s, struct task *t)

 {
        struct status_task *st = container_of(t, struct status_task, task);
 
        if (audiod_status == AUDIOD_OFF) {
                if (!st->ct)
 {
        struct status_task *st = container_of(t, struct status_task, task);
 
        if (audiod_status == AUDIOD_OFF) {
                if (!st->ct)

-                       return;
+                       goto out;

                if (st->ct->task.error >= 0) {
                        st->ct->task.error = -E_AUDIOD_OFF;
                if (st->ct->task.error >= 0) {
                        st->ct->task.error = -E_AUDIOD_OFF;

-                       return;
+                       goto out;

                }
                if (st->ct->task.error != -E_TASK_UNREGISTERED)
                }
                if (st->ct->task.error != -E_TASK_UNREGISTERED)

-                       return;
+                       goto out;

                close_stat_pipe();
                st->clock_diff_count = conf.clock_diff_count_arg;
                close_stat_pipe();
                st->clock_diff_count = conf.clock_diff_count_arg;

-               return;
+               goto out;

        }
        if (st->ct) {
                unsigned bytes_left;
                if (st->ct->task.error < 0) {
                        if (st->ct->task.error != -E_TASK_UNREGISTERED)
        }
        if (st->ct) {
                unsigned bytes_left;
                if (st->ct->task.error < 0) {
                        if (st->ct->task.error != -E_TASK_UNREGISTERED)

-                               return;
+                               goto out;

                        close_stat_pipe();
                        close_stat_pipe();

-                       return;
+                       goto out;

                }
                if (st->ct->status != CL_RECEIVING)
                }
                if (st->ct->status != CL_RECEIVING)

-                       return;
+                       goto out;

                bytes_left = for_each_line(st->ct->buf, st->ct->loaded,
                        &check_stat_line, NULL);
                if (st->ct->loaded != bytes_left) {
                bytes_left = for_each_line(st->ct->buf, st->ct->loaded,
                        &check_stat_line, NULL);
                if (st->ct->loaded != bytes_left) {


@@ -1008,10 +987,10 @@ static void status_pre_select(__a_unused struct sched *s, struct task *t)
                        if (diff.tv_sec > 61)
                                st->ct->task.error = -E_STATUS_TIMEOUT;
                }
                        if (diff.tv_sec > 61)
                                st->ct->task.error = -E_STATUS_TIMEOUT;
                }

-               return;
+               goto out;

        }
        if (tv_diff(now, &st->restart_barrier, NULL) < 0)
        }
        if (tv_diff(now, &st->restart_barrier, NULL) < 0)

-               return;
+               goto out;

        if (st->clock_diff_count) { /* get status only one time */
                char *argv[] = {"audiod", "stat", "1", NULL};
                int argc = 3;
        if (st->clock_diff_count) { /* get status only one time */
                char *argv[] = {"audiod", "stat", "1", NULL};
                int argc = 3;


@@ -1027,6 +1006,8 @@ static void status_pre_select(__a_unused struct sched *s, struct task *t)
                set_stat_task_restart_barrier(5);
        }
        st->last_status_read = *now;
                set_stat_task_restart_barrier(5);
        }
        st->last_status_read = *now;

+out:
+       start_stop_decoders(s);

 }
 
 static void init_status_task(struct status_task *st)
 }
 
 static void init_status_task(struct status_task *st)


@@ -1072,7 +1053,6 @@ int main(int argc, char *argv[])
        int ret, i;
        struct sched s;
        struct command_task command_task_struct, *cmd_task = &command_task_struct;
        int ret, i;
        struct sched s;
        struct command_task command_task_struct, *cmd_task = &command_task_struct;

-       struct task audiod_task_struct, *audiod_task = &audiod_task_struct;

 
        valid_fd_012();
        audiod_cmdline_parser(argc, argv, &conf);
 
        valid_fd_012();
        audiod_cmdline_parser(argc, argv, &conf);


@@ -1111,7 +1091,6 @@ int main(int argc, char *argv[])
 
        init_status_task(stat_task);
        init_command_task(cmd_task);
 
        init_status_task(stat_task);
        init_command_task(cmd_task);

-       init_audiod_task(audiod_task);

 
        if (conf.daemon_given)
                daemon_init();
 
        if (conf.daemon_given)
                daemon_init();


@@ -1119,7 +1098,6 @@ int main(int argc, char *argv[])
        register_task(&sig_task->task);
        register_task(&cmd_task->task);
        register_task(&stat_task->task);
        register_task(&sig_task->task);
        register_task(&cmd_task->task);
        register_task(&stat_task->task);

-       register_task(audiod_task);

        s.default_timeout.tv_sec = 0;
        s.default_timeout.tv_usec = 99 * 1000;
        ret = schedule(&s);
        s.default_timeout.tv_sec = 0;
        s.default_timeout.tv_usec = 99 * 1000;
        ret = schedule(&s);