X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=ao_write.c;h=447dea84c00a468330fe8229bfd70b74292264bd;hp=93861ab63f50baf478bf74fe6f216fce6cf39f53;hb=HEAD;hpb=02dd632ab2a6696aff7b6c6d108069704cfe871a diff --git a/ao_write.c b/ao_write.c index 93861ab6..43a58dd6 100644 --- a/ao_write.c +++ b/ao_write.c @@ -1,25 +1,20 @@ -/* - * Copyright (C) 2011-2012 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 2011 Andre Noll , see file COPYING. */ /** \file ao_write.c Paraslash's libao output plugin. */ #include #include #include +#include +#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_monitor(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); } @@ -63,7 +87,7 @@ static int aow_set_sample_format(unsigned sample_rate, unsigned channels, case SF_U8: case SF_U16_LE: case SF_U16_BE: - return -E_AO_BAD_SAMPLE_FORMAT; + return -E_BAD_SAMPLE_FORMAT; case SF_S8: /* no need to set byte_format */ result->bits = 8; @@ -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("name: %s: %s\n", info->short_name, info->name); + PARA_DEBUG_LOG("priority: %d\n", 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\n", keys? keys : "[none]"); + free(keys); + PARA_DEBUG_LOG("comment: %s\n", 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; - struct private_aow_data *pawd = para_malloc(sizeof(*pawd)); - struct ao_write_args_info *conf = wn->conf; + const struct lls_opt_result *r; + unsigned n; + struct private_aow_data *pawd = alloc(sizeof(*pawd)); 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); @@ -209,27 +266,36 @@ __noreturn static void *aow_play(void *priv) if (frames > 0) break; /* eof and less than a single frame available */ - ret = -E_WRITE_COMMON_EOF; - goto unlock; + ret = -E_EOF; + 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,11 +342,9 @@ fail: return -E_AO_PTHREAD; } -static void aow_post_select(__a_unused struct sched *s, - struct task *t) +static int aow_post_monitor(__a_unused struct sched *s, void *context) { - struct writer_node *wn = container_of(t, struct writer_node, task); - struct btr_node *btrn = wn->btrn; + struct writer_node *wn = context; struct private_aow_data *pawd = wn->private_data; int ret; @@ -288,14 +352,20 @@ static void aow_post_select(__a_unused struct sched *s, int32_t rate, ch, format; struct btr_node_description bnd; - ret = btr_node_status(btrn, wn->min_iqs, BTR_NT_LEAF); + ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF); if (ret < 0) goto remove_btrn; if (ret == 0) - return; - get_btr_sample_rate(btrn, &rate); - get_btr_channels(btrn, &ch); - get_btr_sample_format(btrn, &format); + return 0; + ret = get_btr_sample_rate(wn->btrn, &rate); + if (ret < 0) + goto remove_btrn; + ret = get_btr_channels(wn->btrn, &ch); + if (ret < 0) + goto remove_btrn; + ret = get_btr_sample_format(wn->btrn, &format); + if (ret < 0) + goto remove_btrn; ret = aow_init(wn, rate, ch, format); if (ret < 0) goto remove_btrn; @@ -303,7 +373,7 @@ static void aow_post_select(__a_unused struct sched *s, /* set up thread btr node */ bnd.name = "ao_thread_btrn"; - bnd.parent = btrn; + bnd.parent = wn->btrn; bnd.child = NULL; bnd.handler = NULL; bnd.context = pawd; @@ -313,109 +383,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_EOF; + } + PARA_INFO_LOG("waiting for play thread to terminate\n"); + return 0; } pthread_mutex_lock(&pawd->mutex); - ret = btr_node_status(btrn, wn->min_iqs, BTR_NT_LEAF); + ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF); if (ret > 0) { - btr_pushdown(btrn); - pthread_cond_signal(&pawd->data_available); + btr_pushdown(wn->btrn); + 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(btrn); - btrn = NULL; - PARA_INFO_LOG("waiting for thread to terminate\n"); + } + btr_remove_node(&wn->btrn); 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); - btr_free_node(pawd->thread_btrn); + btr_remove_node(&pawd->thread_btrn); remove_btrn: - if (btrn) - btr_remove_node(btrn); + btr_remove_node(&wn->btrn); out: - t->error = ret; -} - -__malloc static void *aow_parse_config_or_die(const char *options) -{ - struct ao_write_args_info *conf = para_calloc(sizeof(*conf)); - - /* exits on errors */ - ao_cmdline_parser_string(options, conf, "ao_write"); - return conf; -} - -static void aow_free_config(void *conf) -{ - ao_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_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_cmdline_parser_free(&dummy); - ao_shutdown(); -} +struct writer lsg_write_cmd_com_ao_user_data = { + .close = aow_close, + .pre_monitor = aow_pre_monitor, + .post_monitor = aow_post_monitor, +};