btr support for the oss writer.

diff --git a/error.h b/error.h
index 5854dd37df934c02a47009f6fd955a0e612ac08a..237fbc23b8efbef763577215330db681898cff7b 100644 (file)
--- a/error.h
+++ b/error.h
@@ -79,6 +79,7 @@ extern const char **para_errlist[];
        PARA_ERROR(BAD_SAMPLE_FORMAT, "sample format not supported"), \
        PARA_ERROR(BAD_CHANNEL_COUNT, "channel count not supported"), \
        PARA_ERROR(BAD_SAMPLERATE, "sample rate not supported"), \
        PARA_ERROR(BAD_SAMPLE_FORMAT, "sample format not supported"), \
        PARA_ERROR(BAD_CHANNEL_COUNT, "channel count not supported"), \
        PARA_ERROR(BAD_SAMPLERATE, "sample rate not supported"), \

+       PARA_ERROR(OSS_EOF, "oss: end of file"), \

 
 
 #define COMPRESS_FILTER_ERRORS \
 
 
 #define COMPRESS_FILTER_ERRORS \

diff --git a/oss_write.c b/oss_write.c
index bda0ad4cb7189fec9311c1cdfb9896e3fe9b7598..f8feb43a03e90ebba8f1bed2a1f5f0c292501d81 100644 (file)
--- a/oss_write.c
+++ b/oss_write.c
@@ -21,6 +21,7 @@
 #include "ggo.h"
 #include "buffer_tree.h"
 #include "write.h"
 #include "ggo.h"
 #include "buffer_tree.h"
 #include "write.h"

+#include "write_common.h"

 #include "oss_write.cmdline.h"
 #include "error.h"
 
 #include "oss_write.cmdline.h"
 #include "error.h"
 


@@ -56,6 +57,26 @@ static int oss_pre_select(struct sched *s, struct writer_node *wn)
        return 1;
 }
 
        return 1;
 }
 

+static void oss_pre_select_btr(struct sched *s, struct task *t)
+{
+       struct writer_node *wn = container_of(t, struct writer_node, task);
+       struct private_oss_write_data *powd = wn->private_data;
+       int ret = btr_node_status(wn->btrn, wn->min_iqs);
+
+       t->error = 0;
+       if (ret < 0)
+               goto min_delay;
+       if (ret == 0)
+               return;
+       if (!powd)
+               goto min_delay;
+       para_fd_set(powd->fd, &s->wfds, &s->max_fileno);
+       return;
+min_delay:
+       s->timeout.tv_sec = 0;
+       s->timeout.tv_usec = 1;
+}
+

 static int oss_post_select(struct sched *s, struct writer_node *wn)
 {
        int ret;
 static int oss_post_select(struct sched *s, struct writer_node *wn)
 {
        int ret;


@@ -86,6 +107,7 @@ static void oss_close(struct writer_node *wn)
        struct private_oss_write_data *powd = wn->private_data;
 
        close(powd->fd);
        struct private_oss_write_data *powd = wn->private_data;
 
        close(powd->fd);

+       oss_cmdline_parser_free(wn->conf);

        free(powd);
 }
 
        free(powd);
 }
 


@@ -100,19 +122,16 @@ static void oss_close(struct writer_node *wn)
  * incorrectly believe that the device is still in 44.1 kHz mode when actually
  * the speed is decreased to 22.05 kHz.
  */
  * incorrectly believe that the device is still in 44.1 kHz mode when actually
  * the speed is decreased to 22.05 kHz.
  */

-static int oss_open(struct writer_node *wn)
+static int oss_init(struct writer_node *wn, unsigned samplerate, unsigned channels)

 {
 {

-       int ret, format = FORMAT, channels, samplerate;
+       int ret, format = FORMAT, ch, rate;

        struct oss_write_args_info *conf = wn->conf;
        struct oss_write_args_info *conf = wn->conf;

-       struct writer_node_group *wng = wn->wng;
-       struct private_oss_write_data *powd;
+       struct private_oss_write_data *powd = wn->private_data;

 
        PARA_INFO_LOG("opening %s\n", conf->device_arg);
        ret = para_open(conf->device_arg, O_WRONLY, 0);
        if (ret < 0)
                return ret;
 
        PARA_INFO_LOG("opening %s\n", conf->device_arg);
        ret = para_open(conf->device_arg, O_WRONLY, 0);
        if (ret < 0)
                return ret;

-       powd = para_calloc(sizeof(*powd));
-       wn->private_data = powd;

        powd->fd = ret;
        ret = mark_fd_nonblocking(powd->fd);
        if (ret < 0)
        powd->fd = ret;
        ret = mark_fd_nonblocking(powd->fd);
        if (ret < 0)


@@ -127,22 +146,22 @@ static int oss_open(struct writer_node *wn)
        if (format != FORMAT)
                goto err;
        /* set number of channels */
        if (format != FORMAT)
                goto err;
        /* set number of channels */

-       if (!conf->channels_given && wng->channels)
-               channels = *wng->channels;
+       if (!conf->channels_given && channels != 0)
+               ch = channels;

        else
        else

-               channels = conf->channels_arg;
+               ch = conf->channels_arg;

        ret = -E_BAD_CHANNEL_COUNT;
        ret = -E_BAD_CHANNEL_COUNT;

-       if (channels == 0)
+       if (ch == 0)

                goto err;
                goto err;

-       powd->channels = channels;
-       ret = ioctl(powd->fd, SNDCTL_DSP_CHANNELS, &channels);
+       powd->channels = ch;
+       ret = ioctl(powd->fd, SNDCTL_DSP_CHANNELS, &ch);

        if (ret < 0) {
                ret = -ERRNO_TO_PARA_ERROR(errno);
                goto err;
        }
        if (ret < 0) {
                ret = -ERRNO_TO_PARA_ERROR(errno);
                goto err;
        }

-       if (powd->channels != channels)
+       if (powd->channels != ch)

                goto err;
                goto err;

-       powd->bytes_per_frame = channels * 2;
+       powd->bytes_per_frame = ch * 2;

 
        /*
         * Set sampling rate
 
        /*
         * Set sampling rate


@@ -151,19 +170,19 @@ static int oss_open(struct writer_node *wn)
         * device, the the highest possible speed is automatically used. The
         * value actually used is returned as the new value of the argument.
         */
         * device, the the highest possible speed is automatically used. The
         * value actually used is returned as the new value of the argument.
         */

-       if (!conf->samplerate_given && wng->samplerate)
-               samplerate = *wng->samplerate;
+       if (!conf->samplerate_given && samplerate != 0)
+               rate = samplerate;

        else
        else

-               samplerate = conf->samplerate_arg;
-       powd->samplerate = samplerate;
-       ret = ioctl(powd->fd, SNDCTL_DSP_SPEED, &samplerate);
+               rate = conf->samplerate_arg;
+       powd->samplerate = rate;
+       ret = ioctl(powd->fd, SNDCTL_DSP_SPEED, &rate);

        if (ret < 0) {
                ret = -ERRNO_TO_PARA_ERROR(errno);
                goto err;
        }
        if (ret < 0) {
                ret = -ERRNO_TO_PARA_ERROR(errno);
                goto err;
        }

-       if (samplerate != powd->samplerate) {
-               int min = PARA_MIN(samplerate, powd->samplerate),
-                       max = PARA_MAX(samplerate, powd->samplerate);
+       if (rate != powd->samplerate) {
+               int min = PARA_MIN(rate, powd->samplerate),
+                       max = PARA_MAX(rate, powd->samplerate);

                /*
                 * Check whether the returned sample rate differs significantly
                 * from the requested one.
                /*
                 * Check whether the returned sample rate differs significantly
                 * from the requested one.


@@ -171,10 +190,10 @@ static int oss_open(struct writer_node *wn)
                ret = -E_BAD_SAMPLERATE;
                if (100 * max > 110 * min) /* more than 10% deviation */
                        goto err;
                ret = -E_BAD_SAMPLERATE;
                if (100 * max > 110 * min) /* more than 10% deviation */
                        goto err;

-               PARA_NOTICE_LOG("using %dHz rather than %dHz\n", samplerate,
+               PARA_NOTICE_LOG("using %dHz rather than %dHz\n", rate,

                        powd->samplerate);
        }
                        powd->samplerate);
        }

-
+       wn->min_iqs = powd->bytes_per_frame;

        return 1;
 err:
        close(powd->fd);
        return 1;
 err:
        close(powd->fd);


@@ -182,6 +201,72 @@ err:
        return ret;
 }
 
        return ret;
 }
 

+static void oss_post_select_btr(__a_unused struct sched *s,
+               struct task *t)
+{
+       struct writer_node *wn = container_of(t, struct writer_node, task);
+       struct oss_write_args_info *conf = wn->conf;
+       struct private_oss_write_data *powd = wn->private_data;
+       struct btr_node *btrn = wn->btrn;
+       size_t frames, bytes;
+       int ret = btr_node_status(btrn, wn->min_iqs);
+       char *data;
+
+       if (ret < 0)
+               goto out;
+       if (ret == 0)
+               return;
+       if (powd->fd < 0) {
+               int32_t rate, ch;
+               ret = -1;
+               if (!conf->samplerate_given) /* config option trumps btr_exec */
+                       ret = get_btr_samplerate(wn->btrn, &rate);
+               if (ret < 0)
+                       rate = conf->samplerate_arg;
+               ret = -1;
+               if (!conf->channels_given)
+                       ret = get_btr_channels(wn->btrn, &ch);
+               if (ret < 0)
+                       ch = conf->channels_arg;
+               ret = oss_init(wn, rate, ch);
+               if (ret < 0)
+                       goto out;
+               return;
+       }
+       bytes = btr_next_buffer(btrn, &data);
+       frames = bytes / powd->bytes_per_frame;
+       if (!frames) { /* eof and less than a single frame available */
+               ret = -E_OSS_EOF;
+               goto out;
+       }
+       ret = 0;
+       if (!FD_ISSET(powd->fd, &s->wfds))
+               goto out;
+       ret = write_nonblock(powd->fd, data, frames * powd->bytes_per_frame, 0);
+       if (ret < 0)
+               goto out;
+       btr_consume(btrn, ret);
+       ret = 0;
+out:
+       t->error = ret;
+}
+
+static int oss_open(struct writer_node *wn)
+{
+       struct writer_node_group *wng;
+       struct private_oss_write_data *powd;
+
+       powd = para_calloc(sizeof(*powd));
+       wn->private_data = powd;
+       if (!wn->btrn) {
+               wng = wn->wng;
+               return oss_init(wn, wng->samplerate ? *wng->samplerate : 0,
+                       wng->channels? *wng->channels : 0);
+       }
+       powd->fd = -1;
+       return 1;
+}
+

 __malloc static void *oss_parse_config(const char *options)
 {
        int ret;
 __malloc static void *oss_parse_config(const char *options)
 {
        int ret;


@@ -212,7 +297,9 @@ void oss_write_init(struct writer *w)
        w->open = oss_open;
        w->close = oss_close;
        w->pre_select = oss_pre_select;
        w->open = oss_open;
        w->close = oss_close;
        w->pre_select = oss_pre_select;

+       w->pre_select_btr = oss_pre_select_btr;

        w->post_select = oss_post_select;
        w->post_select = oss_post_select;

+       w->post_select_btr = oss_post_select_btr;

        w->parse_config = oss_parse_config;
        w->shutdown = NULL;
        w->help = (struct ggo_help) {
        w->parse_config = oss_parse_config;
        w->shutdown = NULL;
        w->help = (struct ggo_help) {