openssl: Fix memory leak in read_rsa_bignums().
[paraslash.git] / ao_write.c
index ffe8669..e2858b9 100644 (file)
@@ -1,25 +1,20 @@
-/*
- * Copyright (C) 2011-2013 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
+/* Copyright (C) 2011 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
 
 /** \file ao_write.c Paraslash's libao output plugin. */
 
 #include <pthread.h>
 #include <ao/ao.h>
 #include <regex.h>
+#include <lopsub.h>
 
+#include "write_cmd.lsg.h"
 #include "para.h"
 #include "fd.h"
 #include "string.h"
 #include "list.h"
 #include "sched.h"
-#include "ggo.h"
 #include "buffer_tree.h"
 #include "write.h"
-#include "write_common.h"
-#include "ao_write.cmdline.h"
 #include "error.h"
 
 struct private_aow_data {
@@ -28,6 +23,7 @@ struct private_aow_data {
 
        pthread_t thread;
        pthread_attr_t attr;
+       /* The mutex and the condition variable serialize access to ->btrn */
        pthread_mutex_t mutex;
        pthread_cond_t data_available;
        struct btr_node *thread_btrn;
@@ -39,19 +35,47 @@ static void aow_close(struct writer_node *wn)
 
        if (!pawd)
                return;
+       assert(!pawd->thread_btrn);
        ao_close(pawd->dev);
        free(pawd);
        wn->private_data = NULL;
        ao_shutdown();
 }
 
-static void aow_pre_select(struct sched *s, struct task *t)
+static void aow_pre_select(struct sched *s, void *context)
 {
-       struct writer_node *wn = container_of(t, struct writer_node, task);
-       int ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF);
+       struct writer_node *wn = context;
+       struct private_aow_data *pawd = wn->private_data;
+       int ret;
 
-       if (ret == 0)
-               return;
+       if (!pawd) { /* not yet started */
+               assert(wn->btrn);
+               ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF);
+               if (ret != 0)
+                       goto min_delay;
+               return; /* no data available */
+       }
+       if (!wn->btrn) { /* EOF */
+               if (!pawd->thread_btrn) /* ready to exit */
+                       goto min_delay;
+               /* wait for the play thread to terminate */
+               goto timeout;
+       }
+       pthread_mutex_lock(&pawd->mutex);
+       ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF);
+       pthread_mutex_unlock(&pawd->mutex);
+       if (ret != 0)
+               goto min_delay;
+       /*
+        * Even though the node status is zero, we might have data available,
+        * but the output buffer is full. If we don't set a timeout here, we
+        * are woken up only if new data arrives, which might be too late and
+        * result in a buffer underrun in the playing thread. To avoid this we
+        * never sleep longer than the (default) buffer time.
+        */
+timeout:
+       return sched_request_timeout_ms(20, s);
+min_delay:
        sched_min_delay(s);
 }
 
@@ -119,6 +143,38 @@ static int aow_open_device(int id, ao_sample_format *asf, ao_option *options,
        return -E_AO_OPEN_LIVE;
 }
 
+static void aow_show_drivers(void)
+{
+       int i, j, num_drivers;
+       ao_info **driver_list;
+
+       PARA_DEBUG_LOG("libao drivers available on this host:\n");
+       PARA_DEBUG_LOG("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
+
+       driver_list = ao_driver_info_list(&num_drivers);
+
+       for (i = 0; i < num_drivers; i++) {
+               ao_info *info = driver_list[i];
+               char *keys = NULL, *tmp = NULL;
+
+               if (info->type == AO_TYPE_FILE)
+                       continue;
+               PARA_DEBUG_LOG("%s: %s", info->short_name, info->name);
+               PARA_DEBUG_LOG("priority: %d", info->priority);
+               for (j = 0; j < info->option_count; j++) {
+                       tmp = make_message("%s%s%s", keys? keys : "",
+                               keys? ", " : "",
+                               info->options[j]);
+                       free(keys);
+                       keys = tmp;
+               }
+               PARA_DEBUG_LOG("keys: %s", keys? keys : "[none]");
+               free(keys);
+               PARA_DEBUG_LOG("comment: %s", info->comment?
+                       info->comment : "[none]");
+       }
+}
+
 static int aow_init(struct writer_node *wn, unsigned sample_rate,
                unsigned channels, int sample_format)
 {
@@ -126,13 +182,15 @@ static int aow_init(struct writer_node *wn, unsigned sample_rate,
        ao_option *aoo = NULL;
        ao_sample_format asf;
        ao_info *info;
+       const struct lls_opt_result *r;
+       unsigned n;
        struct private_aow_data *pawd = para_malloc(sizeof(*pawd));
-       struct ao_write_args_info *conf = wn->conf;
 
        ao_initialize();
-       if (conf->driver_given) {
+       aow_show_drivers();
+       if (WRITE_CMD_OPT_GIVEN(AO, DRIVER, wn->lpr)) {
                ret = -E_AO_BAD_DRIVER;
-               id = ao_driver_id(conf->driver_arg);
+               id = ao_driver_id(WRITE_CMD_OPT_STRING_VAL(AO, DRIVER, wn->lpr));
        } else {
                ret = -E_AO_DEFAULT_DRIVER;
                id = ao_default_driver_id();
@@ -146,8 +204,11 @@ static int aow_init(struct writer_node *wn, unsigned sample_rate,
                goto fail;
        }
        PARA_INFO_LOG("using %s driver\n", info->short_name);
-       for (i = 0; i < conf->ao_option_given; i++) {
-               char *o = para_strdup(conf->ao_option_arg[i]), *value;
+       r = WRITE_CMD_OPT_RESULT(AO, AO_OPTION, wn->lpr);
+       n = lls_opt_given(r);
+       for (i = 0; i < n; i++) {
+               char *o = para_strdup(lls_string_val(i, r));
+               char *value;
 
                ret = -E_AO_BAD_OPTION;
                value = strchr(o, ':');
@@ -183,7 +244,7 @@ fail:
        return ret;
 }
 
-__noreturn static void *aow_play(void *priv)
+static void *aow_play(void *priv)
 {
        struct writer_node *wn = priv;
        struct private_aow_data *pawd = wn->private_data;
@@ -192,16 +253,12 @@ __noreturn static void *aow_play(void *priv)
        char *data;
        int ret;
 
+       pthread_mutex_lock(&pawd->mutex);
        for (;;) {
-               /*
-                * Lock mutex and wait for signal. pthread_cond_wait() will
-                * automatically and atomically unlock mutex while it waits.
-                */
-               pthread_mutex_lock(&pawd->mutex);
                for (;;) {
                        ret = btr_node_status(btrn, wn->min_iqs, BTR_NT_LEAF);
                        if (ret < 0)
-                               goto unlock;
+                               goto fail;
                        if (ret > 0) {
                                btr_merge(btrn, wn->min_iqs);
                                bytes = btr_next_buffer(btrn, &data);
@@ -210,26 +267,35 @@ __noreturn static void *aow_play(void *priv)
                                        break;
                                /* eof and less than a single frame available */
                                ret = -E_WRITE_COMMON_EOF;
-                               goto unlock;
+                               goto fail;
                        }
-                       //PARA_CRIT_LOG("waiting for data\n");
-                       //usleep(1000);
-                       //pthread_mutex_unlock(&pawd->mutex);
-                       pthread_cond_wait(&pawd->data_available, &pawd->mutex);
+                       /*
+                        * No data available, go to sleep and wait for the main
+                        * thread to wake us up. pthread_cond_wait() unlocks
+                        * the mutex while it waits and locks it again upon
+                        * return.
+                        */
+                       ret = pthread_cond_wait(&pawd->data_available,
+                               &pawd->mutex);
+                       /* pthread_cond_wait() can never fail here */
+                       assert(ret == 0);
                }
-               pthread_mutex_unlock(&pawd->mutex);
                assert(frames > 0);
                bytes = frames * pawd->bytes_per_frame;
-               ret = -E_AO_PLAY;
-               if (ao_play(pawd->dev, data, bytes) == 0) /* failure */
-                       goto out;
+               pthread_mutex_unlock(&pawd->mutex);
+               ret = ao_play(pawd->dev, data, bytes);
+               pthread_mutex_lock(&pawd->mutex);
+               if (ret == 0) { /* failure */
+                       ret = -E_AO_PLAY;
+                       goto fail;
+               }
                btr_consume(btrn, bytes);
        }
-unlock:
-       pthread_mutex_unlock(&pawd->mutex);
-out:
+fail:
+       btr_remove_node(&pawd->thread_btrn);
        assert(ret < 0);
        PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
+       pthread_mutex_unlock(&pawd->mutex);
        pthread_exit(NULL);
 }
 
@@ -276,10 +342,9 @@ fail:
        return -E_AO_PTHREAD;
 }
 
-static void aow_post_select(__a_unused struct sched *s,
-               struct task *t)
+static int aow_post_select(__a_unused struct sched *s, void *context)
 {
-       struct writer_node *wn = container_of(t, struct writer_node, task);
+       struct writer_node *wn = context;
        struct private_aow_data *pawd = wn->private_data;
        int ret;
 
@@ -291,7 +356,7 @@ static void aow_post_select(__a_unused struct sched *s,
                if (ret < 0)
                        goto remove_btrn;
                if (ret == 0)
-                       return;
+                       return 0;
                get_btr_sample_rate(wn->btrn, &rate);
                get_btr_channels(wn->btrn, &ch);
                get_btr_sample_format(wn->btrn, &format);
@@ -312,106 +377,45 @@ static void aow_post_select(__a_unused struct sched *s,
                ret = aow_create_thread(wn);
                if (ret < 0)
                        goto remove_thread_btrn;
-               return;
+               return 0;
+       }
+       if (!wn->btrn) {
+               if (!pawd->thread_btrn) {
+                       pthread_join(pawd->thread, NULL);
+                       return -E_AO_EOF;
+               }
+               PARA_INFO_LOG("waiting for play thread to terminate\n");
+               return 0;
        }
        pthread_mutex_lock(&pawd->mutex);
        ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF);
        if (ret > 0) {
                btr_pushdown(wn->btrn);
-               pthread_cond_signal(&pawd->data_available);
+               if (pthread_cond_signal(&pawd->data_available) != 0) {
+                       ret = -E_AO_PTHREAD;
+                       PARA_ERROR_LOG("pthread_cond_signal() failed\n");
+                       goto remove_thread_btrn;
+               }
        }
-       pthread_mutex_unlock(&pawd->mutex);
-       if (ret >= 0)
+       if (ret >= 0) {
+               pthread_mutex_unlock(&pawd->mutex);
                goto out;
-       pthread_mutex_lock(&pawd->mutex);
+       }
        btr_remove_node(&wn->btrn);
-       PARA_INFO_LOG("waiting for thread to terminate\n");
        pthread_cond_signal(&pawd->data_available);
        pthread_mutex_unlock(&pawd->mutex);
-       pthread_join(pawd->thread, NULL);
+       return 0;
 remove_thread_btrn:
        btr_remove_node(&pawd->thread_btrn);
 remove_btrn:
        btr_remove_node(&wn->btrn);
 out:
-       t->error = ret;
-}
-
-__malloc static void *aow_parse_config_or_die(int argc, char **argv)
-{
-       struct ao_write_args_info *conf = para_calloc(sizeof(*conf));
-
-       /* exits on errors */
-       ao_write_cmdline_parser(argc, argv, conf);
-       return conf;
-}
-
-static void aow_free_config(void *conf)
-{
-       ao_write_cmdline_parser_free(conf);
+       return ret;
 }
 
-/**
- * The init function of the ao writer.
- *
- * \param w Pointer to the writer to initialize.
- *
- * \sa struct writer.
- */
-void ao_write_init(struct writer *w)
-{
-       struct ao_write_args_info dummy;
-       int i, j, num_drivers, num_lines;
-       ao_info **driver_list;
-       char **dh; /* detailed help */
-
-       ao_write_cmdline_parser_init(&dummy);
-       w->close = aow_close;
-       w->pre_select = aow_pre_select;
-       w->post_select = aow_post_select;
-       w->parse_config_or_die = aow_parse_config_or_die;
-       w->free_config = aow_free_config;
-       w->help = (struct ggo_help) {
-               .short_help = ao_write_args_info_help,
-       };
-       /* create detailed help containing all supported drivers/options */
-       for (i = 0; ao_write_args_info_detailed_help[i]; i++)
-               ; /* nothing */
-       num_lines = i;
-       dh = para_malloc((num_lines + 3) * sizeof(char *));
-       for (i = 0; i < num_lines; i++)
-               dh[i] = para_strdup(ao_write_args_info_detailed_help[i]);
-       dh[num_lines++] = para_strdup("libao drivers available on this host:");
-       dh[num_lines++] = para_strdup("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
-
-       ao_initialize();
-       driver_list = ao_driver_info_list(&num_drivers);
-
-       for (i = 0; i < num_drivers; i++) {
-               ao_info *info = driver_list[i];
-               char *keys = NULL, *tmp = NULL;
-
-               if (info->type == AO_TYPE_FILE)
-                       continue;
-               for (j = 0; j < info->option_count; j++) {
-                       tmp = make_message("%s%s%s", keys? keys : "",
-                               keys? ", " : "",
-                               info->options[j]);
-                       free(keys);
-                       keys = tmp;
-               }
-               dh = para_realloc(dh, (num_lines + 6) * sizeof(char *));
-               dh[num_lines++] = make_message("%s: %s", info->short_name, info->name);
-               dh[num_lines++] = make_message("priority: %d", info->priority);
-               dh[num_lines++] = make_message("keys: %s", keys? keys : "[none]");
-               dh[num_lines++] = make_message("comment: %s", info->comment?
-                       info->comment : "[none]");
-               dh[num_lines++] = para_strdup(NULL);
-               free(keys);
-       }
-       dh[num_lines] = NULL;
-       w->help.detailed_help = (const char **)dh;
-       ao_write_cmdline_parser_free(&dummy);
-       ao_shutdown();
-}
+struct writer lsg_write_cmd_com_ao_user_data = {
+       .close = aow_close,
+       .pre_select = aow_pre_select,
+       .post_select = aow_post_select,
+};