/*
- * Copyright (C) 2012-2013 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2012 Andre Noll <maan@tuebingen.mpg.de>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
#include "para.h"
#include "list.h"
#include "play.cmdline.h"
-#include "filter.cmdline.h"
#include "error.h"
#include "ggo.h"
#include "buffer_tree.h"
* Playlist handling is done exclusively in play context.
*/
+/** Array of error strings. */
+DEFINE_PARA_ERRLIST;
+
/**
* Describes a request to change the state of para_play.
*
};
struct play_task {
- struct task task;
+ struct task *task;
/* A bit array of invalid files (those will be skipped). */
bool *invalid;
/* The file which is currently open. */
char *afhi_txt;
};
-/** Initialize the array of errors for para_play. */
-INIT_PLAY_ERRLISTS;
-
/* Activate the afh receiver. */
extern void afh_recv_init(struct receiver *r);
#undef AFH_RECEIVER
exit(EXIT_FAILURE);
}
-/** Description to be included in the --detailed-help output. */
-#define PP_DESC \
-"para_play is a command line audio player.\n" \
-"\n" \
-"It operates either in command mode or in insert mode. In insert mode it\n" \
-"presents a prompt and allows to enter para_play commands like stop, play, pause\n" \
-"etc. In command mode, the current audio file is shown and the program reads\n" \
-"single key strokes from stdin. Keys may be mapped to para_play commands.\n" \
-"Whenever a mapped key is pressed, the associated command is executed.\n" \
-
__noreturn static void print_help_and_die(void)
{
- int d = conf.detailed_help_given;
- const char **p = d? play_args_info_detailed_help
- : play_args_info_help;
-
-// printf_or_die("%s\n\n", PLAY_CMDLINE_PARSER_PACKAGE "-"
-// PLAY_CMDLINE_PARSER_VERSION);
-
- printf_or_die("%s\n\n", play_args_info_usage);
- if (d)
- printf_or_die("%s\n", PP_DESC);
- for (; *p; p++)
- printf_or_die("%s\n", *p);
+ struct ggo_help help = DEFINE_GGO_HELP(play);
+ unsigned flags = conf.detailed_help_given?
+ GPH_STANDARD_FLAGS_DETAILED : GPH_STANDARD_FLAGS;
+
+ ggo_print_help(&help, flags);
+ printf("supported audio formats: %s\n", AUDIO_FORMAT_HANDLERS);
exit(0);
}
.print_errors = 1
};
- if (play_cmdline_parser_ext(argc, argv, &conf, ¶ms))
- exit(EXIT_FAILURE);
- HANDLE_VERSION_FLAG("play", conf);
+ play_cmdline_parser_ext(argc, argv, &conf, ¶ms);
+ loglevel = get_loglevel_by_name(conf.loglevel_arg);
+ version_handle_flag("play", conf.version_given);
if (conf.help_given || conf.detailed_help_given)
print_help_and_die();
- loglevel = get_loglevel_by_name(conf.loglevel_arg);
if (conf.config_file_given)
config_file = para_strdup(conf.config_file_arg);
else {
params.initialize = 0;
params.check_required = 1;
play_cmdline_parser_config_file(config_file, &conf, ¶ms);
+ loglevel = get_loglevel_by_name(conf.loglevel_arg);
}
for (i = 0; i < conf.key_map_given; i++) {
- char *s = strchr(conf.key_map_arg[i] + 1, ':');
- if (s)
+ char *kma = conf.key_map_arg[i];
+ if (*kma && strchr(kma + 1, ':'))
continue;
- PARA_EMERG_LOG("invalid key map arg: %s\n", conf.key_map_arg[i]);
+ PARA_EMERG_LOG("invalid key map arg: %s\n", kma);
goto err;
}
free(config_file);
/* returns: 0 not eof, 1: eof, < 0: fatal error. */
static int get_playback_error(struct play_task *pt)
{
- int err = pt->wn.task.error;
+ int err;
+ if (!pt->wn.task)
+ return 0;
+ err = task_status(pt->wn.task);
if (err >= 0)
return 0;
- if (pt->fn.task.error >= 0)
+ if (task_status(pt->fn.task) >= 0)
return 0;
- if (pt->rn.task.error >= 0)
+ if (task_status(pt->rn.task) >= 0)
return 0;
if (err == -E_BTR_EOF || err == -E_RECV_EOF || err == -E_EOF
|| err == -E_WRITE_COMMON_EOF)
static int eof_cleanup(struct play_task *pt)
{
struct writer *w = writers + DEFAULT_WRITER;
- struct filter *decoder = filters + pt->fn.filter_num;
+ const struct filter *decoder = filter_get(pt->fn.filter_num);
int ret;
ret = get_playback_error(pt);
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);
w->free_config(pt->wn.conf);
memset(&pt->wn, 0, sizeof(struct writer_node));
- decoder->close(&pt->fn);
+ 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
static void shuffle(char **base, size_t num)
{
- srandom(now->tv_sec);
+ srandom(time(NULL));
qsort(base, num, sizeof(char *), shuffle_compare);
}
pt->rn.receiver = afh_recv;
ret = afh_recv->open(&pt->rn);
if (ret < 0) {
- PARA_ERROR_LOG("could not open %s: %s\n", path,
- para_strerror(-ret));
+ PARA_ERROR_LOG("could not open %s\n", path);
goto fail;
}
pt->audio_format_num = ret;
free(tmp);
tmp = NULL;
}
- pt->rn.task.pre_select = afh_recv->pre_select;
- pt->rn.task.post_select = afh_recv->post_select;
- sprintf(pt->rn.task.status, "%s receiver node", afh_recv->name);
return 1;
fail:
wipe_receiver_node(pt);
static int load_file(struct play_task *pt)
{
const char *af;
- char *tmp;
+ char *tmp, buf[20];
int ret;
- struct filter *decoder;
+ const struct filter *decoder;
btr_remove_node(&pt->rn.btrn);
if (!pt->rn.receiver || pt->next_file != pt->current_file) {
if (ret < 0)
return ret;
} else {
- char buf[20];
pt->rn.btrn = new_recv_btrn(&pt->rn);
sprintf(buf, "repos %lu", pt->start_chunk);
ret = btr_exec_up(pt->rn.btrn, buf, &tmp);
/* set up decoding filter */
af = audio_format_name(pt->audio_format_num);
tmp = make_message("%sdec", af);
+ PARA_INFO_LOG("decoder: %s\n", tmp);
ret = check_filter_arg(tmp, &pt->fn.conf);
freep(&tmp);
if (ret < 0)
goto fail;
pt->fn.filter_num = ret;
- decoder = filters + ret;
- pt->fn.task.pre_select = decoder->pre_select;
- pt->fn.task.post_select = decoder->post_select;
- sprintf(pt->fn.task.status, "%s decoder", af);
+ decoder = filter_get(ret);
pt->fn.btrn = btr_new_node(&(struct btr_node_description)
EMBRACE(.name = decoder->name, .parent = pt->rn.btrn,
.handler = decoder->execute, .context = &pt->fn));
- decoder->open(&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.conf = check_writer_arg_or_die(NULL, &pt->wn.writer_num);
- pt->wn.task.error = 0;
/* success, register tasks */
- register_task(&sched, &pt->rn.task);
- register_task(&sched, &pt->fn.task);
+ pt->rn.task = task_register(
+ &(struct task_info) {
+ .name = afh_recv->name,
+ .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:
int ret;
again:
- if (pt->rq == CRT_NONE || pt->rq == CRT_FILE_CHANGE) {
+ if (pt->rq == CRT_NONE) {
pt->start_chunk = 0;
ret = next_valid_file(pt);
if (ret < 0)
pt->next_file = pt->current_file;
ret = load_file(pt);
if (ret < 0) {
+ PARA_ERROR_LOG("%s: marking file as invalid\n",
+ para_strerror(-ret));
pt->invalid[pt->next_file] = true;
pt->rq = CRT_NONE;
goto again;
static void kill_stream(struct play_task *pt)
{
- task_notify(&pt->wn.task, E_EOF);
+ if (pt->wn.task)
+ task_notify(pt->wn.task, E_EOF);
}
#ifdef HAVE_READLINE
get_internal_key_map_seq(key) : get_user_key_map_seq(key);
}
+static char *get_key_map_seq_safe(int key)
+{
+ const char hex[] = "0123456789abcdef";
+ char *seq = get_key_map_seq(key), *sseq;
+ size_t n, len = strlen(seq);
+
+ if (len == 1 && isprint(*seq))
+ return seq;
+ sseq = para_malloc(2 + 2 * len + 1);
+ sseq[0] = '0';
+ sseq[1] = 'x';
+ for (n = 0; n < len; n++) {
+ uint8_t val = (seq[n] & 0xf0) >> 4;
+ sseq[2 + 2 * n] = hex[val];
+ val = seq[n] & 0xf;
+ sseq[2 + 2 * n + 1] = hex[val];
+ }
+ free(seq);
+ sseq[2 + 2 * n] = '\0';
+ return sseq;
+}
+
static inline char *get_internal_key_map_cmd(int key)
{
return para_strdup(default_commands[get_internal_key_map_idx(key)]);
result = para_malloc((NUM_MAPPED_KEYS + 1) * sizeof(char *));
FOR_EACH_MAPPED_KEY(i) {
- int idx = get_key_map_idx(i);
char *seq = get_key_map_seq(i);
- char *cmd = get_key_map_cmd(i);
- bool internal = is_internal_key(i);
- PARA_DEBUG_LOG("%s key sequence #%d: %s -> %s\n",
- internal? "internal" : "user-defined",
- idx, seq, cmd);
result[i] = seq;
- free(cmd);
}
result[i] = NULL;
return result;
}
-#include "play_completion.h"
+#include "play.command_list.h"
+typedef int play_command_handler_t(struct play_task *, int, char**);
+static play_command_handler_t PLAY_COMMAND_HANDLERS;
/* defines one command of para_play */
struct pp_command {
const char *name;
- int (*handler)(struct play_task *, int, char**);
+ play_command_handler_t *handler;
const char *description;
const char *usage;
const char *help;
};
-#include "play_command_list.h"
static struct pp_command pp_cmds[] = {DEFINE_PLAY_CMD_ARRAY};
#define FOR_EACH_COMMAND(c) for (c = 0; pp_cmds[c].name; c++)
-#include "play_completion.h"
+#include "play.completion.h"
static struct i9e_completer pp_completers[];
I9E_DUMMY_COMPLETER(jmp);
FOR_EACH_MAPPED_KEY(i) {
bool internal = is_internal_key(i);
int idx = get_key_map_idx(i);
- char *seq = get_key_map_seq(i);
+ char *seq = get_key_map_seq_safe(i);
char *cmd = get_key_map_cmd(i);
sz = xasprintf(&buf,
"%s key #%d: %s -> %s\n",
char *buf;
size_t sz;
- sz = xasprintf(&buf, "%s %4u %s\n", num == pt->current_file?
+ sz = xasprintf(&buf, "%s %4d %s\n", num == pt->current_file?
"*" : " ", num, conf.inputs[num]);
btr_add_output(buf, sz, pt->btrn);
}
kill_stream(pt);
pt->next_file = ret;
pt->rq = CRT_FILE_CHANGE;
+ pt->start_chunk = 0;
return 0;
}
kill_stream(pt);
pt->next_file = ret;
pt->rq = CRT_FILE_CHANGE;
+ pt->start_chunk = 0;
return 0;
}
return ret;
if (percent < 0 || percent > 100)
return -ERRNO_TO_PARA_ERROR(EINVAL);
+ if (percent == 100)
+ return com_next(pt, 1, (char *[]){"next", NULL});
if (pt->playing && !pt->fn.btrn)
return 0;
pt->start_chunk = percent * pt->num_chunks / 100;
* stderr. Once the i9e subsystem has been initialized, we switch to the i9e
* log facility.
*/
-static void session_open(__a_unused struct play_task *pt)
+static void session_open(struct play_task *pt)
{
int ret;
char *history_file;
struct sigaction act;
- PARA_NOTICE_LOG("\n%s\n", VERSION_TEXT("play"));
+ PARA_NOTICE_LOG("\n%s\n", version_text("play"));
if (conf.history_file_given)
history_file = para_strdup(conf.history_file_arg);
else {
* 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 task *t)
+static int session_post_select(__a_unused struct sched *s, struct play_task *pt)
{
- struct play_task *pt = container_of(t, struct play_task, task);
int ret;
if (pt->background)
#else /* HAVE_READLINE */
-static int session_post_select(struct sched *s, struct task *t)
+static int session_post_select(struct sched *s, struct play_task *pt)
{
- struct play_task *pt = container_of(t, struct play_task, task);
char c;
if (!FD_ISSET(STDIN_FILENO, &s->rfds))
}
#endif /* HAVE_READLINE */
-static void play_pre_select(struct sched *s, struct task *t)
+static void play_pre_select(struct sched *s, void *context)
{
- struct play_task *pt = container_of(t, struct play_task, task);
+ struct play_task *pt = context;
char state;
para_fd_set(STDIN_FILENO, &s->rfds, &s->max_fileno);
);
}
-static int play_post_select(struct sched *s, struct task *t)
+static int play_post_select(struct sched *s, void *context)
{
- struct play_task *pt = container_of(t, struct play_task, task);
+ struct play_task *pt = context;
int ret;
ret = eof_cleanup(pt);
pt->rq = CRT_TERM_RQ;
return 0;
}
- ret = session_post_select(s, t);
+ ret = session_post_select(s, pt);
if (ret < 0)
goto out;
if (!pt->wn.btrn && !pt->fn.btrn) {
filter_init();
writer_init();
- clock_get_realtime(now);
sched.default_timeout.tv_sec = 5;
parse_config_or_die(argc, argv);
pt->rq = CRT_FILE_CHANGE;
pt->current_file = conf.inputs_num - 1;
pt->playing = true;
- pt->task.pre_select = play_pre_select;
- pt->task.post_select = play_post_select;
- sprintf(pt->task.status, "play task");
- register_task(&sched, &pt->task);
+ pt->task = task_register(&(struct task_info){
+ .name = "play",
+ .pre_select = play_pre_select,
+ .post_select = play_post_select,
+ .context = pt,
+ }, &sched);
ret = schedule(&sched);
+ sched_shutdown(&sched);
if (ret < 0)
PARA_ERROR_LOG("%s\n", para_strerror(-ret));
return ret < 0? EXIT_FAILURE : EXIT_SUCCESS;
projects / paraslash.git / blobdiff