+static int eof_cleanup(void)
+{
+ const struct filter *decoder;
+ const struct writer *w = writer_get(-1); /* default writer */
+ int ret;
+
+ ret = get_playback_error();
+ if (ret == 0)
+ return ret;
+ PARA_NOTICE_LOG("cleaning up wn/fn nodes\n");
+ task_reap(&pt->wn.task);
+ w->close(&pt->wn);
+ btr_remove_node(&pt->wn.btrn);
+ lls_free_parse_result(pt->wn.lpr, WRITE_CMD(pt->wn.wid));
+ memset(&pt->wn, 0, sizeof(struct writer_node));
+
+ decoder = filter_get(pt->fn.filter_num);
+ task_reap(&pt->fn.task);
+ if (decoder->close)
+ decoder->close(&pt->fn);
+ btr_remove_node(&pt->fn.btrn);
+ free(pt->fn.conf);
+ memset(&pt->fn, 0, sizeof(struct filter_node));
+
+ task_reap(&pt->rn.task);
+ btr_remove_node(&pt->rn.btrn);
+ /*
+ * On eof (ret > 0), we do not wipe the receiver node struct until a
+ * new file is loaded because we still need it for jumping around when
+ * paused.
+ */
+ if (ret < 0)
+ wipe_receiver_node();
+ return ret;
+}
+
+static int shuffle_compare(__a_unused const void *a, __a_unused const void *b)
+{
+ return para_random(100) - 50;
+}
+
+static void init_shuffle_map(void)
+{
+ unsigned n, num_inputs = lls_num_inputs(play_lpr);
+ shuffle_map = para_malloc(num_inputs * sizeof(unsigned));
+ for (n = 0; n < num_inputs; n++)
+ shuffle_map[n] = n;
+ if (!OPT_GIVEN(RANDOMIZE))
+ return;
+ srandom(time(NULL));
+ qsort(shuffle_map, num_inputs, sizeof(unsigned), shuffle_compare);
+}
+
+static struct btr_node *new_recv_btrn(struct receiver_node *rn)
+{
+ return btr_new_node(&(struct btr_node_description)
+ EMBRACE(.name = lls_command_name(AFH_RECV_CMD), .context = rn,
+ .handler = AFH_RECV->execute));
+}
+
+static int open_new_file(void)
+{
+ int ret;
+ const char *path = get_playlist_file(pt->next_file);
+ char *tmp = para_strdup(path), *errctx;
+ char *argv[] = {"play", "-f", tmp, "-b", "0", NULL};
+
+ PARA_NOTICE_LOG("next file: %s\n", path);
+ wipe_receiver_node();
+ pt->start_chunk = 0;
+ pt->rn.btrn = new_recv_btrn(&pt->rn);
+ ret = lls(lls_parse(ARRAY_SIZE(argv) - 1, argv, AFH_RECV_CMD,
+ &pt->rn.lpr, &errctx));
+ free(tmp);
+ assert(ret >= 0);
+ pt->rn.receiver = AFH_RECV;
+ ret = AFH_RECV->open(&pt->rn);
+ if (ret < 0) {
+ PARA_ERROR_LOG("could not open %s\n", path);
+ goto fail;
+ }
+ pt->audio_format_num = ret;
+ free(pt->afhi_txt);
+ ret = btr_exec_up(pt->rn.btrn, "afhi", &pt->afhi_txt);
+ if (ret < 0)
+ pt->afhi_txt = make_message("[afhi command failed]\n");
+ ret = btr_exec_up(pt->rn.btrn, "seconds_total", &tmp);
+ if (ret < 0)
+ pt->seconds = 1;
+ else {
+ int32_t x;
+ ret = para_atoi32(tmp, &x);
+ pt->seconds = ret < 0? 1 : x;
+ free(tmp);
+ tmp = NULL;
+ }
+ ret = btr_exec_up(pt->rn.btrn, "chunks_total", &tmp);
+ if (ret < 0)
+ pt->num_chunks = 1;
+ else {
+ int32_t x;
+ ret = para_atoi32(tmp, &x);
+ pt->num_chunks = ret < 0? 1 : x;
+ free(tmp);
+ tmp = NULL;
+ }
+ return 1;
+fail:
+ wipe_receiver_node();
+ return ret;
+}
+
+static int load_file(void)
+{
+ const char *af;
+ char *tmp, buf[20];
+ int ret;
+ const struct filter *decoder;
+ static struct lls_parse_result *filter_lpr, *writer_lpr;
+
+ btr_remove_node(&pt->rn.btrn);
+ if (!pt->rn.receiver || pt->next_file != pt->current_file) {
+ ret = open_new_file();
+ if (ret < 0)
+ return ret;
+ } else {
+ pt->rn.btrn = new_recv_btrn(&pt->rn);
+ sprintf(buf, "repos %lu", pt->start_chunk);
+ ret = btr_exec_up(pt->rn.btrn, buf, &tmp);
+ if (ret < 0)
+ PARA_CRIT_LOG("repos failed: %s\n", para_strerror(-ret));
+ freep(&tmp);
+ }
+ if (!pt->playing)
+ return 0;
+ /* set up decoding filter */
+ af = audio_format_name(pt->audio_format_num);
+ tmp = make_message("%sdec", af);
+ ret = filter_setup(tmp, &pt->fn.conf, &filter_lpr);
+ freep(&tmp);
+ if (ret < 0)
+ goto fail;
+ pt->fn.filter_num = ret;
+ pt->fn.lpr = filter_lpr;
+ decoder = filter_get(ret);
+ pt->fn.btrn = btr_new_node(&(struct btr_node_description)
+ EMBRACE(.name = filter_name(pt->fn.filter_num),
+ .parent = pt->rn.btrn, .handler = decoder->execute,
+ .context = &pt->fn));
+ if (decoder->open)
+ decoder->open(&pt->fn);
+ PARA_INFO_LOG("buffer tree:\n");
+ btr_log_tree(pt->rn.btrn, LL_INFO);
+
+ /* setup default writer */
+ pt->wn.wid = check_writer_arg_or_die(NULL, &writer_lpr);
+ pt->wn.lpr = writer_lpr;
+ /* success, register tasks */
+ pt->rn.task = task_register(
+ &(struct task_info) {
+ .name = lls_command_name(AFH_RECV_CMD),
+ .pre_select = AFH_RECV->pre_select,
+ .post_select = AFH_RECV->post_select,
+ .context = &pt->rn
+ }, &sched);
+ sprintf(buf, "%s decoder", af);
+ pt->fn.task = task_register(
+ &(struct task_info) {
+ .name = buf,
+ .pre_select = decoder->pre_select,
+ .post_select = decoder->post_select,
+ .context = &pt->fn
+ }, &sched);
+ register_writer_node(&pt->wn, pt->fn.btrn, &sched);
+ return 1;
+fail:
+ wipe_receiver_node();
+ return ret;
+}
+
+static int next_valid_file(void)
+{
+ int i, j = pt->current_file;
+ unsigned num_inputs = lls_num_inputs(play_lpr);
+
+ if (j == num_inputs - 1) {
+ switch (OPT_UINT32_VAL(END_OF_PLAYLIST)) {
+ case EOP_LOOP: break;
+ case EOP_STOP:
+ pt->playing = false;
+ return 0;
+ case EOP_QUIT: return -E_EOP;