/*
- * Copyright (C) 2012-2014 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2012 Andre Noll <maan@tuebingen.mpg.de>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
};
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. */
/* 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)
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));
+ task_reap(&pt->fn.task);
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);
}
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;
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);
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);
pt->fn.btrn = btr_new_node(&(struct btr_node_description)
EMBRACE(.name = decoder->name, .parent = pt->rn.btrn,
.handler = decoder->execute, .context = &pt->fn));
/* 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:
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
return result;
}
-#include "play_completion.h"
-
-
/* defines one command of para_play */
struct pp_command {
const char *name;
const char *help;
};
-#include "play_command_list.h"
+#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);
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;
}
* 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