simplify osx_write_pre_select()
[paraslash.git] / write.c
diff --git a/write.c b/write.c
index 43c0690..7f29665 100644 (file)
--- a/write.c
+++ b/write.c
 #include "para.h"
 #include "string.h"
 #include "write.cmdline.h"
+#include "list.h"
+#include "sched.h"
+#include "stdin.h"
 #include "write.h"
 #include "write_common.h"
 #include "fd.h"
-
-#include <sys/time.h> /* gettimeofday */
-
 #include "error.h"
 
-#define WAV_HEADER_LEN 44
-
-static char *audiobuf;
-static struct timeval *start_time;
-struct gengetopt_args_info conf;
-
 INIT_WRITE_ERRLISTS;
 
-void para_log(int ll, const char* fmt,...)
-{
-       va_list argp;
+struct check_wav_task {
+       char *buf;
+       size_t *loaded;
+       int *eof;
+       unsigned channels;
+       unsigned samplerate;
+       struct task task;
+};
+
+struct initial_delay_task {
+       struct timeval start_time;
+       struct task task;
+};
+
+static struct write_args_info conf;
+struct stdin_task sit;
+struct check_wav_task cwt;
+struct initial_delay_task idt;
+static struct writer_node_group *wng;
 
-       if (ll < conf.loglevel_arg)
-               return;
-       va_start(argp, fmt);
-       vfprintf(stderr, fmt, argp);
-       va_end(argp);
-}
+#define WAV_HEADER_LEN 44
 
 /**
- * read WAV_HEADER_LEN bytes from stdin to audio buffer
+ * test if audio buffer contains a valid wave header
  *
- * \return -E_READ_HDR on errors and on eof before WAV_HEADER_LEN could be
- * read. A positive return value indicates success.
+ * \return If not, return -E_NO_WAV_HEADER, otherwise, return zero. If
+ * there is less than WAV_HEADER_LEN bytes awailable, return one.
  */
-static int read_wav_header(void)
+static void check_wav_pre_select(__a_unused struct sched *s, struct task *t)
 {
-       ssize_t ret, count = 0;
+       struct check_wav_task *wt = t->private_data;
+       unsigned char *a;
 
-       while (count < WAV_HEADER_LEN) {
-               ret = read(STDIN_FILENO, audiobuf + count, WAV_HEADER_LEN - count);
-               if (ret <= 0)
-                       return -E_READ_HDR;
-               count += ret;
+       if (*wt->loaded < WAV_HEADER_LEN) {
+               t->ret = *wt->eof? -E_PREMATURE_END : 1;
+               return;
        }
-       return 1;
+       wt->channels = 2;
+       wt->samplerate = 44100;
+       a = (unsigned char*)wt->buf;
+       t->ret = -E_NO_WAV_HEADER;
+       if (a[0] != 'R' || a[1] != 'I' || a[2] != 'F' || a[3] != 'F')
+               return;
+       wt->channels = (unsigned) a[22];
+       wt->samplerate = a[24] + (a[25] << 8) + (a[26] << 16) + (a[27] << 24);
+       *wt->loaded -= WAV_HEADER_LEN;
+       memmove(wt->buf, wt->buf + WAV_HEADER_LEN, *wt->loaded);
+       t->ret = -E_WAV_HEADER_SUCCESS;
+       PARA_INFO_LOG("channels: %d, sample rate: %d\n", wt->channels, wt->samplerate);
 }
 
-/**
- * check if current time is later than start_time
- * \param diff pointer to write remaining time to
- *
- * If start_time was not given, or current time is later than given
- * start_time, return 0. Otherwise, return 1 and write the time
- * difference between current time and start_time to diff. diff may be
- * NULL.
- *
- */
-static int start_time_in_future(struct timeval *diff)
+static void initial_delay_pre_select(struct sched *s, struct task *t)
 {
-       struct timeval now;
-
-       if (!conf.start_time_given)
-               return 0;
-       gettimeofday(&now, NULL);
-       return tv_diff(start_time, &now, diff) > 0? 1 : 0;
-}
+       struct initial_delay_task *dt = t->private_data;
+       struct timeval diff;
 
-/**
- * sleep until time given at command line
- *
- * This is called if the initial buffer is filled. It returns
- * immediately if no start_time was given at the command line
- * or if the given start time is in the past.
- *
- */
-static void do_initial_delay(struct timeval *delay)
-{
-       do
-               para_select(1, NULL, NULL, delay);
-       while (start_time_in_future(delay));
+       t->ret = -E_NO_DELAY;
+       if (!dt->start_time.tv_sec && !dt->start_time.tv_usec)
+               return;
+       t->ret = -E_DELAY_TIMEOUT;
+       if (tv_diff(now, &dt->start_time, &diff) > 0)
+               return;
+       t->ret = 1;
+       if (tv_diff(&s->timeout , &diff, NULL) > 0)
+               s->timeout = diff;
 }
 
-static int read_stdin(char *buf, size_t bytes_to_load, size_t *loaded)
-{
-       ssize_t ret;
-
-       while (*loaded < bytes_to_load) {
-               ret = read(STDIN_FILENO, buf + *loaded, bytes_to_load - *loaded);
-               if (ret <= 0) {
-                       if (ret < 0)
-                               ret = -E_READ_STDIN;
-                       return ret;
-               }
-               *loaded += ret;
-       }
-       return 1;
-}
-/**
- * play raw pcm data
- * \param loaded number of bytes already loaded
- *
- * If start_time was given, prebuffer data until buffer is full or
- * start_time is reached. In any case, do not start playing before
- * start_time.
- *
- * \return positive on success, negative on errors.
- */
-static int pcm_write(struct writer_node_group *wng, size_t loaded)
+void para_log(int ll, const char* fmt,...)
 {
-       size_t bufsize, prebuf_size, bytes_to_load;
-       struct timeval delay;
-       int ret, not_yet_started = 1;
+       va_list argp;
 
-       ret = wng_open(wng);
-       if (ret < 0)
-               goto out;
-       PARA_INFO_LOG("max chunk_bytes: %zd\n", wng->max_chunk_bytes);
-       bufsize = (conf.bufsize_arg * 1024 / wng->max_chunk_bytes)
-               * wng->max_chunk_bytes;
-       audiobuf = para_realloc(audiobuf, bufsize);
-       prebuf_size = conf.prebuffer_arg * bufsize / 100;
-       bytes_to_load =  PARA_MIN(prebuf_size, wng->max_chunk_bytes);
-       ret = read_stdin(audiobuf, bytes_to_load, &loaded);
-       if (ret <= 0 || loaded < bytes_to_load) {
-               if (ret >= 0)
-                       ret = -E_PREMATURE_END;
-               goto out;
-       }
-       if (not_yet_started && start_time && start_time_in_future(&delay))
-               do_initial_delay(&delay);
-       not_yet_started = 0;
-again:
-       ret = wng_write(wng, audiobuf, &loaded);
-       if (ret <= 0)
-               goto out;
-       ret = -E_WRITE_OVERRUN;
-       if (loaded >= bufsize)
-               goto out;
-       bytes_to_load = PARA_MIN(wng->max_chunk_bytes, bufsize);
-       ret = read_stdin(audiobuf, bytes_to_load, &loaded);
-       if (ret < 0)
-               goto out;
-       if (!ret)
-               wng->eof = 1;
-       goto again;
-out:
-       wng_close(wng);
-       return ret;
+       if (ll < conf.loglevel_arg)
+               return;
+       va_start(argp, fmt);
+       vfprintf(stderr, fmt, argp);
+       va_end(argp);
 }
 
 static struct writer_node_group *check_args(void)
 {
        int i, ret = -E_WRITE_SYNTAX;
-       static struct timeval tv;
-       struct writer_node_group *wng = NULL;
+       struct writer_node_group *g = NULL;
 
        if (conf.list_writers_given) {
                char *msg = NULL;
@@ -188,72 +126,120 @@ static struct writer_node_group *check_args(void)
                free(msg);
                exit(EXIT_SUCCESS);
        }
-       if (conf.prebuffer_arg < 0 || conf.prebuffer_arg > 100)
-               goto out;
        if (conf.start_time_given) {
                long unsigned sec, usec;
                if (sscanf(conf.start_time_arg, "%lu:%lu",
                                &sec, &usec) != 2)
                        goto out;
-               tv.tv_sec = sec;
-               tv.tv_usec = usec;
-               start_time = &tv;
+               idt.start_time.tv_sec = sec;
+               idt.start_time.tv_usec = usec;
        }
        if (!conf.writer_given) {
-               wng = setup_default_wng();
+               g = setup_default_wng();
                ret = 1;
                goto out;
        }
-       wng = wng_new(conf.writer_given);
+       g = wng_new(conf.writer_given);
+       ret = -E_WRITE_SYNTAX;
        for (i = 0; i < conf.writer_given; i++) {
-               ret = check_writer_arg(conf.writer_arg[i]);
-               if (ret < 0)
+               int writer_num;
+               g->writer_nodes[i].conf = check_writer_arg(
+                       conf.writer_arg[i], &writer_num);
+               if (!g->writer_nodes[i].conf)
                        goto out;
-               wng->writer_nodes[i].writer = &writers[ret];
+               g->writer_nodes[i].writer = &writers[writer_num];
        }
        ret = 1;
 out:
        if (ret > 0)
-               return wng;
-       free(wng);
+               return g;
+       free(g);
        return NULL;
 }
 
-/**
- * test if audio buffer contains a valid wave header
- *
- * \return If not, return 0, otherwise, store number of channels and sample rate
- * in struct conf and return WAV_HEADER_LEN.
- */
-static size_t check_wave(void)
+static void wng_event_handler(struct task *t)
 {
-       unsigned char *a = (unsigned char*)audiobuf;
-       if (a[0] != 'R' || a[1] != 'I' || a[2] != 'F' || a[3] != 'F')
-               return WAV_HEADER_LEN;
-       conf.channels_arg = (unsigned) a[22];
-       conf.sample_rate_arg = a[24] + (a[25] << 8) + (a[26] << 16) + (a[27] << 24);
-       return 0;
+       struct writer_node_group *g = t->private_data;
+
+       PARA_INFO_LOG("%s\n", PARA_STRERROR(-t->ret));
+       unregister_task(t);
+       wng_close(g);
+}
+
+
+static void idt_event_handler(struct task *t)
+{
+       int ret;
+
+       PARA_INFO_LOG("%s\n", PARA_STRERROR(-t->ret));
+       unregister_task(t);
+       wng->buf = sit.buf;
+       wng->loaded = &sit.loaded;
+       wng->input_eof = &sit.eof;
+       wng->task.event_handler = wng_event_handler;
+       wng->channels = &cwt.channels;
+       wng->samplerate = &cwt.samplerate;
+       ret = wng_open(wng);
+       if (ret < 0) {
+               PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret));
+               exit(EXIT_FAILURE);
+       }
+}
+
+static void cwt_event_handler(struct task *t)
+{
+       if (t->ret != -E_NO_WAV_HEADER && t->ret != -E_WAV_HEADER_SUCCESS) {
+               PARA_ERROR_LOG("%s\n", PARA_STRERROR(-t->ret));
+               exit(EXIT_FAILURE);
+       }
+       PARA_INFO_LOG("%s\n", PARA_STRERROR(-t->ret));
+       unregister_task(t);
+//     if (t->ret == -E_WAV_HEADER_SUCCESS) {
+//             conf.channels_arg = cwt.channels;
+//             conf.sample_rate_arg = cwt.sample_rate;
+//     }
+       idt.task.pre_select = initial_delay_pre_select;
+       idt.task.private_data = &idt;
+       idt.task.event_handler = idt_event_handler;
+       sprintf(idt.task.status, "initial_delay");
+       register_task(&idt.task);
 }
 
 int main(int argc, char *argv[])
 {
        int ret = -E_WRITE_SYNTAX;
-       struct writer_node_group *wng = NULL;
+       struct sched s;
+
+       write_cmdline_parser(argc, argv, &conf);
+       init_supported_writers();
 
-       cmdline_parser(argc, argv, &conf);
        wng = check_args();
        if (!wng)
                goto out;
-       init_supported_writers();
-       audiobuf = para_malloc(WAV_HEADER_LEN);
-       ret = read_wav_header();
-       if (ret < 0)
-               goto out;
-       ret = pcm_write(wng, check_wave());
+       stdin_set_defaults(&sit);
+       if (conf.bufsize_given)
+               sit.bufsize = conf.bufsize_arg;
+       sit.buf = para_malloc(sit.bufsize),
+       register_task(&sit.task);
+
+       cwt.task.pre_select = check_wav_pre_select;
+       cwt.task.private_data = &cwt;
+       cwt.task.event_handler = cwt_event_handler;
+       cwt.buf = sit.buf;
+       cwt.loaded = &sit.loaded;
+       cwt.eof = &sit.eof;
+       sprintf(cwt.task.status, "check wav");
+       register_task(&cwt.task);
+
+       s.default_timeout.tv_sec = 1;
+       s.default_timeout.tv_usec = 0;
+       ret = sched(&s);
+
 out:
-       wng_destroy(wng);
-       free(audiobuf);
-       if (ret < 0)
+       if (ret < 0) {
                PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret));
+               ret = EXIT_FAILURE;
+       } else
+               ret = EXIT_SUCCESS;
        return ret;
 }