X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=play.c;h=2346c6b0101045d51e87b5d40abb5b983df6f014;hp=7ffcd9ed7b24a83d744d99d74f841128560c7c44;hb=62c0894fbb589dd45e69b7d9ef1fd152a9960d62;hpb=f90e920b43eb4035ded061bb889c8e4d819a2a97

diff --git a/play.c b/play.c
index 7ffcd9ed..2346c6b0 100644
--- a/play.c
+++ b/play.c
@@ -1,14 +1,9 @@
-/*
- * Copyright (C) 2012 Andre Noll <maan@tuebingen.mpg.de>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
+/* Copyright (C) 2012 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
 
 /** \file play.c Paraslash's standalone player. */
 
 #include <regex.h>
 #include <signal.h>
-#include <inttypes.h>
 #include <lopsub.h>
 
 #include "recv_cmd.lsg.h"
@@ -16,6 +11,7 @@
 #include "write_cmd.lsg.h"
 #include "play.lsg.h"
 #include "para.h"
+#include "lsu.h"
 #include "list.h"
 #include "error.h"
 #include "buffer_tree.h"
@@ -109,8 +105,7 @@ struct play_task {
 	char *afhi_txt;
 };
 
-typedef int (*play_cmd_handler_t)(struct play_task *pt,
-		struct lls_parse_result *lpr);
+typedef int (*play_cmd_handler_t)(struct lls_parse_result *lpr);
 struct play_command_info {
 	play_cmd_handler_t handler;
 };
@@ -127,7 +122,7 @@ INIT_STDERR_LOGGING(loglevel);
 char *stat_item_values[NUM_STAT_ITEMS] = {NULL};
 
 static struct sched sched = {.max_fileno = 0};
-static struct play_task play_task;
+static struct play_task play_task, *pt = &play_task;
 
 #define AFH_RECV_CMD (lls_cmd(LSG_RECV_CMD_CMD_AFH, recv_cmd_suite))
 #define AFH_RECV ((struct receiver *)lls_user_data(AFH_RECV_CMD))
@@ -145,7 +140,7 @@ static void handle_help_flags(void)
 
 	if (OPT_GIVEN(DETAILED_HELP))
 		help = lls_long_help(CMD_PTR);
-	else if (OPT_GIVEN(HELP))
+	else if (OPT_GIVEN(HELP) || lls_num_inputs(play_lpr) == 0)
 		help = lls_short_help(CMD_PTR);
 	else
 		return;
@@ -156,79 +151,41 @@ static void handle_help_flags(void)
 
 static void parse_config_or_die(int argc, char *argv[])
 {
-	const struct lls_command *cmd = CMD_PTR;
-	int i, ret, cf_argc;
-	char *cf, *errctx, **cf_argv;
-	struct lls_parse_result *cf_lpr, *merged_lpr;
+	int i, ret;
 	unsigned num_kmas;
-	void *map;
-	size_t sz;
+	char *errctx;
 
-	ret = lls(lls_parse(argc, argv, cmd, &play_lpr, &errctx));
-	if (ret < 0)
-		goto fail;
+	ret = lls(lls_parse(argc, argv, CMD_PTR, &play_lpr, &errctx));
+	if (ret < 0) {
+		if (errctx)
+			PARA_EMERG_LOG("%s\n", errctx);
+		free(errctx);
+		PARA_EMERG_LOG("failed to parse command line options: %s\n",
+			para_strerror(-ret));
+		exit(EXIT_FAILURE);
+	}
 	loglevel = OPT_UINT32_VAL(LOGLEVEL);
 	version_handle_flag("play", OPT_GIVEN(VERSION));
-	handle_help_flags();
-	if (OPT_GIVEN(CONFIG_FILE))
-		cf = para_strdup(OPT_STRING_VAL(CONFIG_FILE));
-	else {
-		char *home = para_homedir();
-		cf = make_message("%s/.paraslash/play.conf", home);
-		free(home);
-	}
-	ret = mmap_full_file(cf, O_RDONLY, &map, &sz, NULL);
+	handle_help_flags(); /* also handles the zero-arg case */
+	ret = lsu_merge_config_file_options(OPT_STRING_VAL(CONFIG_FILE),
+		"play.conf", &play_lpr, CMD_PTR, play_suite, 0 /* flags */);
 	if (ret < 0) {
-		if (ret != -E_EMPTY && ret != -ERRNO_TO_PARA_ERROR(ENOENT))
-			goto free_cf;
-		if (ret == -ERRNO_TO_PARA_ERROR(ENOENT) && OPT_GIVEN(CONFIG_FILE))
-			goto free_cf;
-		ret = 0;
-		goto free_cf;
+		PARA_EMERG_LOG("failed to parse config file: %s\n",
+			para_strerror(-ret));
+		exit(EXIT_FAILURE);
 	}
-	ret = lls(lls_convert_config(map, sz, NULL, &cf_argv, &errctx));
-	para_munmap(map, sz);
-	if (ret < 0)
-		goto free_cf;
-	cf_argc = ret;
-	ret = lls(lls_parse(cf_argc, cf_argv, cmd, &cf_lpr, &errctx));
-	lls_free_argv(cf_argv);
-	if (ret < 0)
-		goto free_cf;
-	ret = lls(lls_merge(play_lpr, cf_lpr, cmd, &merged_lpr, &errctx));
-	lls_free_parse_result(cf_lpr, cmd);
-	if (ret < 0)
-		goto free_cf;
-	lls_free_parse_result(play_lpr, cmd);
-	play_lpr = merged_lpr;
 	loglevel = OPT_UINT32_VAL(LOGLEVEL);
-
-	ret = lls(lls_check_arg_count(play_lpr, 1, INT_MAX, &errctx));
-	if (ret < 0)
-		goto free_cf;
 	num_kmas = OPT_GIVEN(KEY_MAP);
 	for (i = 0; i < num_kmas; i++) {
 		const char *kma = lls_string_val(i, OPT_RESULT(KEY_MAP));
 		if (*kma && strchr(kma + 1, ':'))
 			continue;
 		PARA_EMERG_LOG("invalid key map arg: %s\n", kma);
-		goto free_cf;
+		exit(EXIT_FAILURE);
 	}
-	ret = 1;
-free_cf:
-	free(cf);
-	if (ret >= 0)
-		return;
-	lls_free_parse_result(play_lpr, cmd);
-fail:
-	if (errctx)
-		PARA_EMERG_LOG("%s\n", errctx);
-	free(errctx);
-	PARA_EMERG_LOG("%s\n", para_strerror(-ret));
-	exit(EXIT_FAILURE);
 }
 
-static char get_playback_state(struct play_task *pt)
+static char get_playback_state(void)
 {
 	switch (pt->rq) {
 	case CRT_NONE: return pt->playing? 'P' : 'U';
@@ -239,9 +196,9 @@ static char get_playback_state(struct play_task *pt)
 	assert(false);
 };
 
-static long unsigned get_play_time(struct play_task *pt)
+static long unsigned get_play_time(void)
 {
-	char state = get_playback_state(pt);
+	char state = get_playback_state();
 	long unsigned result;
 
 	if (state != 'P' && state != 'U')
@@ -262,8 +219,7 @@ static long unsigned get_play_time(struct play_task *pt)
 	return result;
 }
 
-
-static void wipe_receiver_node(struct play_task *pt)
+static void wipe_receiver_node(void)
 {
 	PARA_NOTICE_LOG("cleaning up receiver node\n");
 	btr_remove_node(&pt->rn.btrn);
@@ -273,7 +229,7 @@ static void wipe_receiver_node(struct play_task *pt)
 }
 
 /* returns: 0 not eof, 1: eof, < 0: fatal error.  */
-static int get_playback_error(struct play_task *pt)
+static int get_playback_error(void)
 {
 	int err;
 
@@ -292,13 +248,13 @@ static int get_playback_error(struct play_task *pt)
 	return err;
 }
 
-static int eof_cleanup(struct play_task *pt)
+static int eof_cleanup(void)
 {
 	const struct filter *decoder;
 	const struct writer *w = writer_get(-1); /* default writer */
 	int ret;
 
-	ret = get_playback_error(pt);
+	ret = get_playback_error();
 	if (ret == 0)
 		return ret;
 	PARA_NOTICE_LOG("cleaning up wn/fn nodes\n");
@@ -324,7 +280,7 @@ static int eof_cleanup(struct play_task *pt)
 	 * paused.
 	 */
 	if (ret < 0)
-		wipe_receiver_node(pt);
+		wipe_receiver_node();
 	return ret;
 }
 
@@ -352,7 +308,7 @@ static struct btr_node *new_recv_btrn(struct receiver_node *rn)
 			.handler = AFH_RECV->execute));
 }
 
-static int open_new_file(struct play_task *pt)
+static int open_new_file(void)
 {
 	int ret;
 	const char *path = get_playlist_file(pt->next_file);
@@ -360,7 +316,7 @@ static int open_new_file(struct play_task *pt)
 	char *argv[] = {"play", "-f", tmp, "-b", "0", NULL};
 
 	PARA_NOTICE_LOG("next file: %s\n", path);
-	wipe_receiver_node(pt);
+	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,
@@ -400,11 +356,11 @@ static int open_new_file(struct play_task *pt)
 	}
 	return 1;
 fail:
-	wipe_receiver_node(pt);
+	wipe_receiver_node();
 	return ret;
 }
 
-static int load_file(struct play_task *pt)
+static int load_file(void)
 {
 	const char *af;
 	char *tmp, buf[20];
@@ -414,7 +370,7 @@ static int load_file(struct play_task *pt)
 
 	btr_remove_node(&pt->rn.btrn);
 	if (!pt->rn.receiver || pt->next_file != pt->current_file) {
-		ret = open_new_file(pt);
+		ret = open_new_file();
 		if (ret < 0)
 			return ret;
 	} else {
@@ -468,15 +424,24 @@ static int load_file(struct play_task *pt)
 	register_writer_node(&pt->wn, pt->fn.btrn, &sched);
 	return 1;
 fail:
-	wipe_receiver_node(pt);
+	wipe_receiver_node();
 	return ret;
 }
 
-static int next_valid_file(struct play_task *pt)
+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;
+		}
+	}
 	for (i = 0; i < num_inputs; i++) {
 		j = (j + 1) % num_inputs;
 		if (!pt->invalid[j])
@@ -485,20 +450,20 @@ static int next_valid_file(struct play_task *pt)
 	return -E_NO_VALID_FILES;
 }
 
-static int load_next_file(struct play_task *pt)
+static int load_next_file(void)
 {
 	int ret;
 
 again:
 	if (pt->rq == CRT_NONE) {
 		pt->start_chunk = 0;
-		ret = next_valid_file(pt);
+		ret = next_valid_file();
 		if (ret < 0)
 			return ret;
 		pt->next_file = ret;
 	} else if (pt->rq == CRT_REPOS)
 		pt->next_file = pt->current_file;
-	ret = load_file(pt);
+	ret = load_file();
 	if (ret < 0) {
 		PARA_ERROR_LOG("%s: marking file as invalid\n",
 			para_strerror(-ret));
@@ -511,7 +476,7 @@ again:
 	return ret;
 }
 
-static void kill_stream(struct play_task *pt)
+static void kill_stream(void)
 {
 	if (pt->wn.task)
 		task_notify(pt->wn.task, E_EOF);
@@ -520,7 +485,7 @@ static void kill_stream(struct play_task *pt)
 #ifdef HAVE_READLINE
 
 /* only called from com_prev(), nec. only if we have readline */
-static int previous_valid_file(struct play_task *pt)
+static int previous_valid_file(void)
 {
 	int i, j = pt->current_file;
 	unsigned num_inputs = lls_num_inputs(play_lpr);
@@ -715,12 +680,17 @@ I9E_DUMMY_COMPLETER(quit);
 I9E_DUMMY_COMPLETER(ff);
 
 static void help_completer(struct i9e_completion_info *ci,
-		struct i9e_completion_result *result)
+		struct i9e_completion_result *cr)
 {
-	result->matches = i9e_complete_commands(ci->word, pp_completers);
+	char *opts[] = {LSG_PLAY_CMD_HELP_OPTS, NULL};
+
+	if (ci->word[0] == '-') {
+		i9e_complete_option(opts, ci, cr);
+		return;
+	}
+	cr->matches = i9e_complete_commands(ci->word, pp_completers);
 }
 
-I9E_DUMMY_COMPLETER(SUPERCOMMAND_UNAVAILABLE);
 static struct i9e_completer pp_completers[] = {
 #define LSG_PLAY_CMD_CMD(_name) {.name = #_name, \
 	.completer = _name ## _completer}
@@ -729,7 +699,7 @@ static struct i9e_completer pp_completers[] = {
 	{.name = NULL}
 };
 
-static void attach_stdout(struct play_task *pt, const char *name)
+static void attach_stdout(const char *name)
 {
 	if (pt->btrn)
 		return;
@@ -738,42 +708,29 @@ static void attach_stdout(struct play_task *pt, const char *name)
 	i9e_attach_to_stdout(pt->btrn);
 }
 
-static void detach_stdout(struct play_task *pt)
+static void detach_stdout(void)
 {
 	btr_remove_node(&pt->btrn);
 }
 
-static int com_quit(struct play_task *pt,
-		__a_unused struct lls_parse_result *lpr)
+static int com_quit(__a_unused struct lls_parse_result *lpr)
 {
 	pt->rq = CRT_TERM_RQ;
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(quit);
 
-static int com_help(struct play_task *pt, struct lls_parse_result *lpr)
+static int com_help(struct lls_parse_result *lpr)
 {
-	int i, ret;
-	char *buf, *errctx;
+	int i;
+	char *buf;
 	size_t sz;
-	const struct lls_command *cmd;
+	unsigned n;
+	const struct lls_opt_result *r =
+		lls_opt_result(LSG_PLAY_CMD_HELP_OPT_LONG, lpr);
+	bool long_help = lls_opt_given(r);
 
-	ret = lls(lls_check_arg_count(lpr, 0, 1, &errctx));
-	if (ret < 0) {
-		if (errctx)
-			PARA_ERROR_LOG("%s\n", errctx);
-		free(errctx);
-		return ret;
-	}
-	if (lls_num_inputs(lpr) == 0) {
-		if (pt->background) {
-			for (i = 1; (cmd = lls_cmd(i, play_cmd_suite)); i++) {
-				sz = xasprintf(&buf, "%s\t%s\n",
-					lls_command_name(cmd), lls_purpose(cmd));
-				btr_add_output(buf, sz, pt->btrn);
-			}
-			return 0;
-		}
+	if (!pt->background) {
 		FOR_EACH_MAPPED_KEY(i) {
 			bool internal = is_internal_key(i);
 			int idx = get_key_map_idx(i);
@@ -788,24 +745,13 @@ static int com_help(struct play_task *pt, struct lls_parse_result *lpr)
 		}
 		return 0;
 	}
-	ret = lls(lls_lookup_subcmd(lls_input(0, lpr), play_cmd_suite,
-		&errctx));
-	if (ret < 0) {
-		if (errctx)
-			PARA_ERROR_LOG("%s\n", errctx);
-		free(errctx);
-		return ret;
-	}
-	cmd = lls_cmd(ret, play_cmd_suite);
-	buf = lls_long_help(cmd);
-	assert(buf);
-	btr_add_output(buf, strlen(buf), pt->btrn);
+	lsu_com_help(long_help, lpr, play_cmd_suite, NULL, &buf, &n);
+	btr_add_output(buf, n, pt->btrn);
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(help);
 
-static int com_info(struct play_task *pt,
-		__a_unused struct lls_parse_result *lpr)
+static int com_info(__a_unused struct lls_parse_result *lpr)
 {
 	char *buf;
 	size_t sz;
@@ -820,7 +766,7 @@ static int com_info(struct play_task *pt,
 }
 EXPORT_PLAY_CMD_HANDLER(info);
 
-static void list_file(struct play_task *pt, int num)
+static void list_file(int num)
 {
 	char *buf;
 	size_t sz;
@@ -830,8 +776,7 @@ static void list_file(struct play_task *pt, int num)
 	btr_add_output(buf, sz, pt->btrn);
 }
 
-static int com_tasks(struct play_task *pt,
-		__a_unused struct lls_parse_result *lpr)
+static int com_tasks(__a_unused struct lls_parse_result *lpr)
 {
 	static char state;
 	char *buf;
@@ -839,26 +784,25 @@ static int com_tasks(struct play_task *pt,
 
 	buf = get_task_list(&sched);
 	btr_add_output(buf, strlen(buf), pt->btrn);
-	state = get_playback_state(pt);
+	state = get_playback_state();
 	sz = xasprintf(&buf, "state: %c\n", state);
 	btr_add_output(buf, sz, pt->btrn);
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(tasks);
 
-static int com_ls(struct play_task *pt,
-	__a_unused struct lls_parse_result *lpr)
+static int com_ls(__a_unused struct lls_parse_result *lpr)
 {
 	int i;
 	unsigned num_inputs = lls_num_inputs(play_lpr);
 
 	for (i = 0; i < num_inputs; i++)
-		list_file(pt, i);
+		list_file(i);
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(ls);
 
-static int com_play(struct play_task *pt, struct lls_parse_result *lpr)
+static int com_play(struct lls_parse_result *lpr)
 {
 	int32_t x;
 	int ret;
@@ -871,7 +815,7 @@ static int com_play(struct play_task *pt, struct lls_parse_result *lpr)
 		free(errctx);
 		return ret;
 	}
-	state = get_playback_state(pt);
+	state = get_playback_state();
 	if (lls_num_inputs(lpr) == 0) {
 		if (state == 'P')
 			return 0;
@@ -885,24 +829,23 @@ static int com_play(struct play_task *pt, struct lls_parse_result *lpr)
 		return ret;
 	if (x < 0 || x >= lls_num_inputs(play_lpr))
 		return -ERRNO_TO_PARA_ERROR(EINVAL);
-	kill_stream(pt);
+	kill_stream();
 	pt->next_file = x;
 	pt->rq = CRT_FILE_CHANGE;
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(play);
 
-static int com_pause(struct play_task *pt,
-		__a_unused struct lls_parse_result *lpr)
+static int com_pause(__a_unused struct lls_parse_result *lpr)
 {
 	char state;
 	long unsigned seconds, ss;
 
-	state = get_playback_state(pt);
+	state = get_playback_state();
 	pt->playing = false;
 	if (state != 'P')
 		return 0;
-	seconds = get_play_time(pt);
+	seconds = get_play_time();
 	pt->playing = false;
 	ss = 0;
 	if (pt->seconds > 0)
@@ -910,20 +853,19 @@ static int com_pause(struct play_task *pt,
 	ss = PARA_MAX(ss, 0UL);
 	ss = PARA_MIN(ss, pt->num_chunks);
 	pt->start_chunk = ss;
-	kill_stream(pt);
+	kill_stream();
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(pause);
 
-static int com_prev(struct play_task *pt,
-	__a_unused struct lls_parse_result *lpr)
+static int com_prev(__a_unused struct lls_parse_result *lpr)
 {
 	int ret;
 
-	ret = previous_valid_file(pt);
+	ret = previous_valid_file();
 	if (ret < 0)
 		return ret;
-	kill_stream(pt);
+	kill_stream();
 	pt->next_file = ret;
 	pt->rq = CRT_FILE_CHANGE;
 	pt->start_chunk = 0;
@@ -931,15 +873,14 @@ static int com_prev(struct play_task *pt,
 }
 EXPORT_PLAY_CMD_HANDLER(prev);
 
-static int com_next(struct play_task *pt,
-		__a_unused struct lls_parse_result *lpr)
+static int com_next(__a_unused struct lls_parse_result *lpr)
 {
 	int ret;
 
-	ret = next_valid_file(pt);
+	ret = next_valid_file();
 	if (ret < 0)
 		return ret;
-	kill_stream(pt);
+	kill_stream();
 	pt->next_file = ret;
 	pt->rq = CRT_FILE_CHANGE;
 	pt->start_chunk = 0;
@@ -947,23 +888,21 @@ static int com_next(struct play_task *pt,
 }
 EXPORT_PLAY_CMD_HANDLER(next);
 
-static int com_fg(struct play_task *pt,
-		__a_unused struct lls_parse_result *lpr)
+static int com_fg(__a_unused struct lls_parse_result *lpr)
 {
 	pt->background = false;
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(fg);
 
-static int com_bg(struct play_task *pt,
-	__a_unused struct lls_parse_result *lpr)
+static int com_bg(__a_unused struct lls_parse_result *lpr)
 {
 	pt->background = true;
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(bg);
 
-static int com_jmp(struct play_task *pt, struct lls_parse_result *lpr)
+static int com_jmp(struct lls_parse_result *lpr)
 {
 	int32_t percent;
 	int ret;
@@ -982,19 +921,19 @@ static int com_jmp(struct play_task *pt, struct lls_parse_result *lpr)
 	if (percent < 0 || percent > 100)
 		return -ERRNO_TO_PARA_ERROR(EINVAL);
 	if (percent == 100)
-		return com_next(pt, NULL);
+		return com_next(NULL);
 	if (pt->playing && !pt->fn.btrn)
 		return 0;
 	pt->start_chunk = percent * pt->num_chunks / 100;
 	if (!pt->playing)
 		return 0;
 	pt->rq = CRT_REPOS;
-	kill_stream(pt);
+	kill_stream();
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(jmp);
 
-static int com_ff(struct play_task *pt, struct lls_parse_result *lpr)
+static int com_ff(struct lls_parse_result *lpr)
 {
 	int32_t seconds;
 	char *errctx;
@@ -1012,7 +951,7 @@ static int com_ff(struct play_task *pt, struct lls_parse_result *lpr)
 		return ret;
 	if (pt->playing && !pt->fn.btrn)
 		return 0;
-	seconds += get_play_time(pt);
+	seconds += get_play_time();
 	seconds = PARA_MIN(seconds, (typeof(seconds))pt->seconds - 4);
 	seconds = PARA_MAX(seconds, 0);
 	pt->start_chunk = pt->num_chunks * seconds / pt->seconds;
@@ -1021,12 +960,12 @@ static int com_ff(struct play_task *pt, struct lls_parse_result *lpr)
 	if (!pt->playing)
 		return 0;
 	pt->rq = CRT_REPOS;
-	kill_stream(pt);
+	kill_stream();
 	return 0;
 }
 EXPORT_PLAY_CMD_HANDLER(ff);
 
-static int run_command(char *line, struct play_task *pt)
+static int run_command(char *line)
 {
 	int ret, argc;
 	char **argv = NULL;
@@ -1035,7 +974,7 @@ static int run_command(char *line, struct play_task *pt)
 	struct lls_parse_result *lpr;
 	const struct lls_command *cmd;
 
-	attach_stdout(pt, __FUNCTION__);
+	attach_stdout(__FUNCTION__);
 	ret = create_argv(line, " ", &argv);
 	if (ret < 0)
 		goto out;
@@ -1050,7 +989,7 @@ static int run_command(char *line, struct play_task *pt)
 	if (ret < 0)
 		goto out;
 	pci = lls_user_data(cmd);
-	ret = pci->handler(pt, lpr);
+	ret = pci->handler(lpr);
 	lls_free_parse_result(lpr, cmd);
 out:
 	if (errctx)
@@ -1062,12 +1001,11 @@ out:
 
 static int play_i9e_line_handler(char *line)
 {
-	return run_command(line, &play_task);
+	return run_command(line);
 }
 
 static int play_i9e_key_handler(int key)
 {
-	struct play_task *pt = &play_task;
 	int idx = get_key_map_idx(key);
 	char *seq = get_key_map_seq(key);
 	char *cmd = get_key_map_cmd(key);
@@ -1076,7 +1014,7 @@ static int play_i9e_key_handler(int key)
 	PARA_NOTICE_LOG("pressed %d: %s key #%d (%s -> %s)\n",
 		key, internal? "internal" : "user-defined",
 		idx, seq, cmd);
-	run_command(cmd, pt);
+	run_command(cmd);
 	free(seq);
 	free(cmd);
 	pt->next_update = *now;
@@ -1093,7 +1031,7 @@ static struct i9e_client_info ici = {
 
 static void sigint_handler(int sig)
 {
-	play_task.background = true;
+	pt->background = true;
 	i9e_signal_dispatch(sig);
 }
 
@@ -1102,7 +1040,7 @@ static void sigint_handler(int sig)
  * stderr. Once the i9e subsystem has been initialized, we switch to the i9e
  * log facility.
  */
-static void session_open(struct play_task *pt)
+static void session_open(void)
 {
 	int ret;
 	char *history_file;
@@ -1146,7 +1084,7 @@ out:
 	exit(EXIT_FAILURE);
 }
 
-static void session_update_time_string(struct play_task *pt, char *str, unsigned len)
+static void session_update_time_string(char *str, unsigned len)
 {
 	if (pt->background)
 		return;
@@ -1171,30 +1109,30 @@ static void session_update_time_string(struct play_task *pt, char *str, unsigned
  * terminates. Subsequent calls to i9e_get_error() then return negative and we
  * are allowed to call i9e_close() and terminate as well.
  */
-static int session_post_select(__a_unused struct sched *s, struct play_task *pt)
+static int session_post_select(__a_unused struct sched *s)
 {
 	int ret;
 
 	if (pt->background)
-		detach_stdout(pt);
+		detach_stdout();
 	else
-		attach_stdout(pt, __FUNCTION__);
+		attach_stdout(__FUNCTION__);
 	ret = i9e_get_error();
 	if (ret < 0) {
-		kill_stream(pt);
+		kill_stream();
 		i9e_close();
 		para_log = stderr_log;
 		free(ici.history_file);
 		return ret;
 	}
-	if (get_playback_state(pt) == 'X')
+	if (get_playback_state() == 'X')
 		i9e_signal_dispatch(SIGTERM);
 	return 0;
 }
 
 #else /* HAVE_READLINE */
 
-static int session_post_select(struct sched *s, struct play_task *pt)
+static int session_post_select(struct sched *s)
 {
 	char c;
 
@@ -1202,38 +1140,36 @@ static int session_post_select(struct sched *s, struct play_task *pt)
 		return 0;
 	if (read(STDIN_FILENO, &c, 1))
 		do_nothing;
-	kill_stream(pt);
+	kill_stream();
 	return 1;
 }
 
-static void session_open(__a_unused struct play_task *pt)
+static void session_open(void)
 {
 }
 
-static void session_update_time_string(__a_unused struct play_task *pt,
-		char *str, __a_unused unsigned len)
+static void session_update_time_string(char *str, __a_unused unsigned len)
 {
 	printf("\r%s     ", str);
 	fflush(stdout);
 }
 #endif /* HAVE_READLINE */
 
-static void play_pre_select(struct sched *s, void *context)
+static void play_pre_select(struct sched *s, __a_unused void *context)
 {
-	struct play_task *pt = context;
 	char state;
 
 	para_fd_set(STDIN_FILENO, &s->rfds, &s->max_fileno);
-	state = get_playback_state(pt);
+	state = get_playback_state();
 	if (state == 'R' || state == 'F' || state == 'X')
 		return sched_min_delay(s);
 	sched_request_barrier_or_min_delay(&pt->next_update, s);
 }
 
-static unsigned get_time_string(struct play_task *pt, char **result)
+static unsigned get_time_string(char **result)
 {
 	int seconds, length;
-	char state = get_playback_state(pt);
+	char state = get_playback_state();
 
 	/* do not return anything if things are about to change */
 	if (state != 'P' && state != 'U') {
@@ -1243,7 +1179,7 @@ static unsigned get_time_string(struct play_task *pt, char **result)
 	length = pt->seconds;
 	if (length == 0)
 		return xasprintf(result, "0:00 [0:00] (0%%/0:00)");
-	seconds = get_play_time(pt);
+	seconds = get_play_time();
 	return xasprintf(result, "#%u: %d:%02d [%d:%02d] (%d%%/%d:%02d) %s",
 		pt->current_file,
 		seconds / 60,
@@ -1257,24 +1193,23 @@ static unsigned get_time_string(struct play_task *pt, char **result)
 	);
 }
 
-static int play_post_select(struct sched *s, void *context)
+static int play_post_select(struct sched *s, __a_unused void *context)
 {
-	struct play_task *pt = context;
 	int ret;
 
-	ret = eof_cleanup(pt);
+	ret = eof_cleanup();
 	if (ret < 0) {
 		pt->rq = CRT_TERM_RQ;
 		return 0;
 	}
-	ret = session_post_select(s, pt);
+	ret = session_post_select(s);
 	if (ret < 0)
 		goto out;
 	if (!pt->wn.btrn && !pt->fn.btrn) {
-		char state = get_playback_state(pt);
+		char state = get_playback_state();
 		if (state == 'P' || state == 'R' || state == 'F') {
 			PARA_NOTICE_LOG("state: %c\n", state);
-			ret = load_next_file(pt);
+			ret = load_next_file();
 			if (ret < 0) {
 				PARA_ERROR_LOG("%s\n", para_strerror(-ret));
 				pt->rq = CRT_TERM_RQ;
@@ -1286,10 +1221,10 @@ static int play_post_select(struct sched *s, void *context)
 	}
 	if (tv_diff(now, &pt->next_update, NULL) >= 0) {
 		char *str;
-		unsigned len = get_time_string(pt, &str);
+		unsigned len = get_time_string(&str);
 		struct timeval delay = {.tv_sec = 0, .tv_usec = 100 * 1000};
 		if (str && len > 0)
-			session_update_time_string(pt, str, len);
+			session_update_time_string(str, len);
 		free(str);
 		tv_add(now, &delay, &pt->next_update);
 	}
@@ -1309,21 +1244,15 @@ out:
 int main(int argc, char *argv[])
 {
 	int ret;
-	struct play_task *pt = &play_task;
 	unsigned num_inputs;
 
-	/* needed this early to make help work */
-	recv_init();
-
 	sched.default_timeout.tv_sec = 5;
 	parse_config_or_die(argc, argv);
-	AFH_RECV->init();
-	session_open(pt);
+	session_open();
 	num_inputs = lls_num_inputs(play_lpr);
 	init_shuffle_map();
 	pt->invalid = para_calloc(sizeof(*pt->invalid) * num_inputs);
 	pt->rq = CRT_FILE_CHANGE;
-	pt->current_file = num_inputs - 1;
 	pt->playing = true;
 	pt->task = task_register(&(struct task_info){
 		.name = "play",