X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=alsa_write.c;h=363e39301651bc47881f850f0235c13f6a016c62;hp=016d8ab3c32547e2ab6fcc46902860db9a713271;hb=6bded356ec89b1344049ff702e6c6babaeccd439;hpb=71b24ff5561efe1ae93176f8d2ef707d94b6b222 diff --git a/alsa_write.c b/alsa_write.c index 016d8ab3..363e3930 100644 --- a/alsa_write.c +++ b/alsa_write.c @@ -1,8 +1,4 @@ -/* - * Copyright (C) 2005-2009 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 2005 Andre Noll , see file COPYING. */ /** \file alsa_write.c paraslash's alsa output plugin */ @@ -14,265 +10,227 @@ #include #include -#include #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 "alsa_write.cmdline.h" #include "error.h" -/** always use 16 bit little endian */ -#define FORMAT SND_PCM_FORMAT_S16_LE - /** Data specific to the alsa writer. */ struct private_alsa_write_data { /** The alsa handle */ snd_pcm_t *handle; - /** Determined and set by alsa_open(). */ - int bytes_per_frame; /* TODO: Kill this after btr switch */ - /** The approximate maximum buffer duration in us. */ - unsigned buffer_time; - /* Number of frames that fit into the buffer. */ - snd_pcm_uframes_t buffer_frames; - /** - * The samplerate given by command line option or the decoder - * of the writer node group. + /** Determined and set by alsa_init(). */ + int bytes_per_frame; + /* + * If the sample rate is not given at the command line and no wav + * header was detected, the btr exec mechanism is employed to query the + * ancestor buffer tree nodes for this information. In a typical setup + * the decoder passes the sample rate back to the alsa writer. + * + * \sa \ref btr_exec_up(). */ - unsigned samplerate; - /** - * The number of channels, given by command line option or the - * decoder of the writer node group. + unsigned sample_rate; + /* + * The sample format (8/16 bit, signed/unsigned, little/big endian) is + * determined in the same way as the \a sample_rate. */ + snd_pcm_format_t sample_format; + /* The number of channels, again determined like \a sample_rate. */ unsigned channels; + /* time until buffer underrun occurs, in milliseconds */ + unsigned buffer_time; + struct timeval drain_barrier; + /* File descriptor for select(). */ + int poll_fd; }; +static snd_pcm_format_t get_alsa_pcm_format(enum sample_format sf) +{ + switch (sf) { + case SF_S8: return SND_PCM_FORMAT_S8; + case SF_U8: return SND_PCM_FORMAT_U8; + case SF_S16_LE: return SND_PCM_FORMAT_S16_LE; + case SF_S16_BE: return SND_PCM_FORMAT_S16_BE; + case SF_U16_LE: return SND_PCM_FORMAT_U16_LE; + case SF_U16_BE: return SND_PCM_FORMAT_U16_BE; + default: return SND_PCM_FORMAT_S16_LE; + } +} + /* Install PCM software and hardware configuration. */ -static int alsa_init(struct private_alsa_write_data *pad, - struct alsa_write_args_info *conf) +static int alsa_init(struct writer_node *wn) { - snd_pcm_hw_params_t *hwparams; - snd_pcm_sw_params_t *swparams; + struct private_alsa_write_data *pad = wn->private_data; + snd_pcm_hw_params_t *hwparams = NULL; + snd_pcm_sw_params_t *swparams = NULL; snd_pcm_uframes_t start_threshold, stop_threshold; - snd_pcm_uframes_t period_size; - int err; - - err = snd_pcm_open(&pad->handle, conf->device_arg, - SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK); - if (err < 0) - return -E_PCM_OPEN; + snd_pcm_uframes_t buffer_size, period_size; + snd_output_t *output_log; + int ret; + const char *msg, *dev = WRITE_CMD_OPT_STRING_VAL(ALSA, DEVICE, wn->lpr); + unsigned period_time; - snd_pcm_hw_params_alloca(&hwparams); - snd_pcm_sw_params_alloca(&swparams); - if (snd_pcm_hw_params_any(pad->handle, hwparams) < 0) - return -E_BROKEN_CONF; - if (snd_pcm_hw_params_set_access(pad->handle, hwparams, - SND_PCM_ACCESS_RW_INTERLEAVED) < 0) - return -E_ACCESS_TYPE; - if (snd_pcm_hw_params_set_format(pad->handle, hwparams, FORMAT) < 0) - return -E_SAMPLE_FORMAT; - if (snd_pcm_hw_params_set_channels(pad->handle, hwparams, - pad->channels) < 0) - return -E_CHANNEL_COUNT; - if (snd_pcm_hw_params_set_rate_near(pad->handle, hwparams, - &pad->samplerate, NULL) < 0) - return -E_SET_RATE; - err = snd_pcm_hw_params_get_buffer_time_max(hwparams, + PARA_INFO_LOG("opening %s\n", dev); + msg = "unable to open pcm"; + ret = snd_pcm_open(&pad->handle, dev, SND_PCM_STREAM_PLAYBACK, + SND_PCM_NONBLOCK); + if (ret < 0) + goto fail; + ret = snd_pcm_hw_params_malloc(&hwparams); + assert(ret >= 0); + msg = "Broken alsa configuration"; + ret = snd_pcm_hw_params_any(pad->handle, hwparams); + if (ret < 0) + goto fail; + msg = "access type not available"; + ret = snd_pcm_hw_params_set_access(pad->handle, hwparams, + SND_PCM_ACCESS_RW_INTERLEAVED); + if (ret < 0) + goto fail; + msg = "sample format not available"; + ret = snd_pcm_hw_params_set_format(pad->handle, hwparams, + pad->sample_format); + if (ret < 0) + goto fail; + msg = "channels count not available"; + ret = snd_pcm_hw_params_set_channels(pad->handle, hwparams, + pad->channels); + if (ret < 0) + goto fail; + msg = "could not set sample rate"; + ret = snd_pcm_hw_params_set_rate_near(pad->handle, hwparams, + &pad->sample_rate, NULL); + if (ret < 0) + goto fail; + /* alsa wants microseconds */ + pad->buffer_time = 1000U * WRITE_CMD_OPT_UINT32_VAL(ALSA, BUFFER_TIME, + wn->lpr); + msg = "could not set buffer time"; + ret = snd_pcm_hw_params_set_buffer_time_near(pad->handle, hwparams, &pad->buffer_time, NULL); - if (err < 0 || !pad->buffer_time) - return -E_GET_BUFFER_TIME; - PARA_INFO_LOG("buffer time: %d\n", pad->buffer_time); - if (snd_pcm_hw_params_set_buffer_time_near(pad->handle, hwparams, - &pad->buffer_time, NULL) < 0) - return -E_SET_BUFFER_TIME; - if (snd_pcm_hw_params(pad->handle, hwparams) < 0) - return -E_HW_PARAMS; + if (ret < 0) + goto fail; + pad->buffer_time /= 1000; /* we prefer milliseconds */ + period_time = pad->buffer_time * 250; /* buffer time / 4 */ + msg = "could not set period time"; + ret = snd_pcm_hw_params_set_period_time_near(pad->handle, hwparams, + &period_time, NULL); + if (ret < 0) + goto fail; + + msg = "unable to install hw params"; + ret = snd_pcm_hw_params(pad->handle, hwparams); + if (ret < 0) + goto fail; snd_pcm_hw_params_get_period_size(hwparams, &period_size, NULL); - snd_pcm_hw_params_get_buffer_size(hwparams, &pad->buffer_frames); - PARA_INFO_LOG("buffer size: %lu, period_size: %lu\n", pad->buffer_frames, - period_size); - if (period_size == pad->buffer_frames) - return -E_BAD_PERIOD; + snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size); + msg = "period size equals buffer size"; + if (period_size == buffer_size) + goto fail; + + /* software parameter setup */ + ret = snd_pcm_sw_params_malloc(&swparams); + assert(ret >= 0); snd_pcm_sw_params_current(pad->handle, swparams); snd_pcm_sw_params_set_avail_min(pad->handle, swparams, period_size); - if (pad->buffer_frames < 1) + if (buffer_size < 1) start_threshold = 1; else - start_threshold = PARA_MIN(pad->buffer_frames, - (snd_pcm_uframes_t)pad->samplerate); - if (snd_pcm_sw_params_set_start_threshold(pad->handle, swparams, - start_threshold) < 0) - return -E_START_THRESHOLD; - stop_threshold = pad->buffer_frames; - if (snd_pcm_sw_params_set_stop_threshold(pad->handle, swparams, - stop_threshold) < 0) - return -E_STOP_THRESHOLD; - if (snd_pcm_sw_params(pad->handle, swparams) < 0) - PARA_WARNING_LOG("unable to install sw params\n"); - pad->bytes_per_frame = snd_pcm_format_physical_width(FORMAT) - * pad->channels / 8; - if (pad->bytes_per_frame <= 0) - return -E_PHYSICAL_WIDTH; - PARA_INFO_LOG("bytes per frame: %d\n", pad->bytes_per_frame); - if (snd_pcm_nonblock(pad->handle, 1)) - PARA_ERROR_LOG("failed to set nonblock mode\n"); - return 1; -} - -/* Open an instance of the alsa writer. */ -static int alsa_open_nobtr(struct writer_node *wn) -{ - struct alsa_write_args_info *conf = wn->conf; - struct writer_node_group *wng = wn->wng; - struct private_alsa_write_data *pad = para_calloc(sizeof(*pad)); - - wn->private_data = pad; - if (!conf->samplerate_given && wng->samplerate) - pad->samplerate = *wng->samplerate; - else - pad->samplerate = conf->samplerate_arg; - if (!conf->channels_given && wng->channels) - pad->channels = *wng->channels; - else - pad->channels = conf->channels_arg; - PARA_INFO_LOG("%d channel(s), %dHz\n", pad->channels, pad->samplerate); - return 1; -} - -static int alsa_open_btr(struct writer_node *wn) -{ - struct private_alsa_write_data *pad = para_calloc(sizeof(*pad)); - - wn->private_data = pad; - return 1; -} -static int alsa_open(struct writer_node *wn) -{ - if (wn->btrn) - return alsa_open_btr(wn); - return alsa_open_nobtr(wn); -} - -static int alsa_write_pre_select(struct sched *s, struct writer_node *wn) -{ - struct private_alsa_write_data *pad = wn->private_data; - struct writer_node_group *wng = wn->wng; - struct timeval tv; - snd_pcm_sframes_t avail, underrun; - - if (!pad->handle) - return 1; - if (wn->btrn) { - int ret = btr_node_status(wn->btrn, wn->min_iqs); - if (ret == 0) - return 1; - if (ret < 0) { - underrun = 10; - goto timeout; + start_threshold = PARA_MIN(buffer_size, + (snd_pcm_uframes_t)pad->sample_rate); + msg = "could not set start threshold"; + ret = snd_pcm_sw_params_set_start_threshold(pad->handle, swparams, + start_threshold); + if (ret < 0) + goto fail; + stop_threshold = buffer_size; + msg = "could not set stop threshold"; + ret = snd_pcm_sw_params_set_stop_threshold(pad->handle, swparams, + stop_threshold); + if (ret < 0) + goto fail; + msg = "unable to install sw params"; + ret = snd_pcm_sw_params(pad->handle, swparams); + if (ret < 0) + goto fail; + msg = "unable to determine bytes per frame"; + ret = snd_pcm_format_physical_width(pad->sample_format); + if (ret <= 0) + goto fail; + pad->bytes_per_frame = ret * pad->channels / 8; + msg = "failed to set alsa handle to nonblock mode"; + ret = snd_pcm_nonblock(pad->handle, 1); + if (ret < 0) + goto fail; + ret = snd_output_buffer_open(&output_log); + if (ret == 0) { + char *buf, *p; + size_t sz; + PARA_DEBUG_LOG("dumping alsa configuration\n"); + snd_pcm_dump(pad->handle, output_log); + snd_pcm_hw_params_dump(hwparams, output_log); + sz = snd_output_buffer_string(output_log, &buf); + for (p = buf; p < buf + sz;) { + char *q = memchr(p, '\n', buf + sz - p); + if (!q) + break; + *q = '\0'; + PARA_DEBUG_LOG("%s\n", p); + p = q + 1; } - } else { - if (*wng->loaded - wn->written < pad->bytes_per_frame) - return 1; + snd_output_close(output_log); } - /* - * Data is available to be written to the alsa handle. Compute number - * of milliseconds until next buffer underrun would occur. - * - * snd_pcm_avail_update() updates the current available count of - * samples for writing. It is a light method to obtain current stream - * position, because it does not require the user <-> kernel context - * switch, but the value is less accurate, because ring buffer pointers - * are updated in kernel drivers only when an interrupt occurs. - */ - avail = snd_pcm_avail_update(pad->handle); - if (avail < 0) - avail = 0; - underrun = (pad->buffer_frames - avail) * pad->buffer_time - / pad->buffer_frames / 1000; - if (underrun < 50) - underrun = 50; - underrun -= 50; -timeout: - ms2tv(underrun, &tv); - if (tv_diff(&s->timeout, &tv, NULL) > 0) - s->timeout = tv; - //PARA_CRIT_LOG("timout: %lu\n", tv2ms(&s->timeout)); - return 1; -} - -static void alsa_write_pre_select_btr(struct sched *s, struct task *t) -{ - struct writer_node *wn = container_of(t, struct writer_node, task); - alsa_write_pre_select(s, wn); -} - -static void xrun(snd_pcm_t *handle) -{ - snd_pcm_status_t *status; - int ret; - struct timeval tv, diff; - - snd_pcm_status_alloca(&status); - ret = snd_pcm_status(handle, status); + ret = 1; + goto out; +fail: if (ret < 0) - return; - if (snd_pcm_status_get_state(status) != SND_PCM_STATE_XRUN) - return; - snd_pcm_status_get_trigger_tstamp(status, &tv); - tv_diff(now, &tv, &diff); - PARA_WARNING_LOG("underrun: %lums\n", tv2ms(&diff)); + PARA_ERROR_LOG("%s: %s\n", msg, snd_strerror(-ret)); + else + PARA_ERROR_LOG("%s\n", msg); + ret = -E_ALSA; +out: + snd_pcm_hw_params_free(hwparams); + snd_pcm_sw_params_free(swparams); + return ret; } -static int alsa_write_post_select(__a_unused struct sched *s, - struct writer_node *wn) +static void alsa_write_pre_select(struct sched *s, void *context) { + struct pollfd pfd; + struct writer_node *wn = context; struct private_alsa_write_data *pad = wn->private_data; - struct writer_node_group *wng = wn->wng; - size_t bytes = *wng->loaded - wn->written; - unsigned char *data = (unsigned char*)*wng->bufp + wn->written; - snd_pcm_sframes_t ret, frames, avail; + int ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF); - if (*wng->input_error < 0 && (!pad->handle || bytes < pad->bytes_per_frame)) { - wn->written = *wng->loaded; - return *wng->input_error; - } - if (!bytes) /* no data available */ - return 0; - if (!pad->handle) { - int err = alsa_init(pad, wn->conf); - if (err < 0) - return err; + if (pad) + pad->poll_fd = -1; + if (ret == 0) + return; + if (!pad) { + sched_min_delay(s); + return; } - frames = bytes / pad->bytes_per_frame; - if (!frames) /* less than a single frame available */ - return 0; - avail = snd_pcm_avail_update(pad->handle); - if (avail <= 0) - return 0; - frames = PARA_MIN(frames, avail); - ret = snd_pcm_writei(pad->handle, data, frames); - if (ret >= 0) { - wn->written += ret * pad->bytes_per_frame; - return 1; + if (ret < 0) { + sched_request_barrier_or_min_delay(&pad->drain_barrier, s); + return; } - if (ret == -EPIPE) { - xrun(pad->handle); - snd_pcm_prepare(pad->handle); - return 0; + /* wait at most 50% of the buffer time */ + sched_request_timeout_ms(pad->buffer_time / 2, s); + ret = snd_pcm_poll_descriptors(pad->handle, &pfd, 1); + if (ret < 0) { + PARA_ERROR_LOG("could not get alsa poll fd: %s\n", + snd_strerror(-ret)); + return; } - PARA_WARNING_LOG("%s\n", snd_strerror(-ret)); - if (ret == -EAGAIN) - return 0; - return -E_ALSA_WRITE; + pad->poll_fd = pfd.fd; + para_fd_set(pfd.fd, &s->rfds, &s->max_fileno); } static void alsa_close(struct writer_node *wn) @@ -280,143 +238,107 @@ static void alsa_close(struct writer_node *wn) struct private_alsa_write_data *pad = wn->private_data; PARA_INFO_LOG("closing writer node %p\n", wn); - if (pad->handle) { - /* - * It's OK to have a blocking operation here because we already - * made sure that the PCM output buffer is (nearly) empty. - */ - snd_pcm_nonblock(pad->handle, 0); - snd_pcm_drain(pad->handle); - snd_pcm_close(pad->handle); - snd_config_update_free_global(); - } - alsa_cmdline_parser_free(wn->conf); + if (!pad) + return; + /* + * It's OK to have a blocking operation here because we already made + * sure that the PCM output buffer is (nearly) empty. + */ + snd_pcm_nonblock(pad->handle, 0); + snd_pcm_drain(pad->handle); + snd_pcm_close(pad->handle); + snd_config_update_free_global(); free(pad); } -static void alsa_write_post_select_btr(__a_unused struct sched *s, - struct task *t) +static int alsa_write_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_alsa_write_data *pad = wn->private_data; struct btr_node *btrn = wn->btrn; char *data; size_t bytes; - snd_pcm_sframes_t frames, avail; + snd_pcm_sframes_t frames; int ret; + ret = task_get_notification(wn->task); + if (ret < 0) + goto err; again: - t->error = 0; - ret = btr_node_status(btrn, wn->min_iqs); + ret = btr_node_status(btrn, wn->min_iqs, BTR_NT_LEAF); if (ret == 0) - return; + return 0; btr_merge(btrn, wn->min_iqs); bytes = btr_next_buffer(btrn, &data); - if (bytes < pad->bytes_per_frame) { /* eof */ + if (ret < 0 || bytes < wn->min_iqs) { /* eof */ assert(btr_no_parent(btrn)); - ret = -E_ALSA_EOF; - if (!pad->handle) + ret = -E_WRITE_COMMON_EOF; + if (!pad) goto err; /* wait until pending frames are played */ - avail = snd_pcm_avail_update(pad->handle); - if (avail + 1000 > pad->buffer_frames) + if (pad->drain_barrier.tv_sec == 0) { + PARA_DEBUG_LOG("waiting for device to drain\n"); + tv_add(now, &(struct timeval)EMBRACE(0, 200 * 1000), + &pad->drain_barrier); + return 0; + } + if (tv_diff(now, &pad->drain_barrier, NULL) > 0) goto err; - return; + return 0; } - if (!pad->handle) { - struct alsa_write_args_info *conf = wn->conf; + if (!pad) { + int32_t val; + if (bytes == 0) /* no data available */ - return; - PARA_CRIT_LOG("alsa init\n"); - /* defaults */ - pad->samplerate = conf->samplerate_arg; - pad->channels = conf->channels_arg; - if (!conf->samplerate_given) { /* config option trumps btr_exec */ - int32_t rate; - ret = get_btr_samplerate(btrn, &rate); - if (ret < 0) - goto err; - pad->samplerate = rate; - } - if (!conf->channels_given) { - int32_t ch; - ret = get_btr_channels(btrn, &ch); - if (ret < 0) - goto err; - pad->channels = ch; - } - PARA_INFO_LOG("%d channel(s), %dHz\n", pad->channels, pad->samplerate); - ret = 1; - ret = alsa_init(pad, wn->conf); - if (ret < 0) + return 0; + pad = wn->private_data = para_calloc(sizeof(*pad)); + get_btr_sample_rate(btrn, &val); + pad->sample_rate = val; + get_btr_channels(btrn, &val); + pad->channels = val; + get_btr_sample_format(btrn, &val); + pad->sample_format = get_alsa_pcm_format(val); + + PARA_INFO_LOG("%u channel(s), %uHz\n", pad->channels, + pad->sample_rate); + ret = alsa_init(wn); + if (ret < 0) { + free(wn->private_data); + wn->private_data = NULL; goto err; + } wn->min_iqs = pad->bytes_per_frame; + goto again; } frames = bytes / pad->bytes_per_frame; - avail = snd_pcm_avail_update(pad->handle); - if (avail <= 0) - return; - frames = PARA_MIN(frames, avail); - //PARA_CRIT_LOG("writing %ld frames\n", frames); frames = snd_pcm_writei(pad->handle, data, frames); - if (frames >= 0) { + if (frames == 0 || frames == -EAGAIN) { + char buf[100]; + if (pad->poll_fd >= 0 && FD_ISSET(pad->poll_fd, &s->rfds)) + if (read(pad->poll_fd, buf, 100)) + do_nothing; + return 0; + } + if (frames > 0) { btr_consume(btrn, frames * pad->bytes_per_frame); goto again; } if (frames == -EPIPE) { - xrun(pad->handle); + PARA_WARNING_LOG("underrun (tried to write %zu bytes)\n", bytes); snd_pcm_prepare(pad->handle); - return; + return 0; } - PARA_WARNING_LOG("%s\n", snd_strerror(-frames)); - if (frames == -EAGAIN) - return; - ret = -E_ALSA_WRITE; + PARA_ERROR_LOG("alsa write error: %s\n", snd_strerror(-frames)); + ret = -E_ALSA; err: assert(ret < 0); - t->error = ret; + btr_remove_node(&wn->btrn); + return ret; } -__malloc static void *alsa_parse_config(const char *options) -{ - int ret; - struct alsa_write_args_info *conf - = para_calloc(sizeof(struct alsa_write_args_info)); +struct writer lsg_write_cmd_com_alsa_user_data = { - PARA_INFO_LOG("options: %s, %zd\n", options, strcspn(options, " \t")); - ret = alsa_cmdline_parser_string(options, conf, "alsa_write"); - if (ret) - goto err_out; - PARA_INFO_LOG("help given: %d\n", conf->help_given); - return conf; -err_out: - free(conf); - return NULL; -} - -/** - * the init function of the alsa writer - * - * \param w pointer to the writer to initialize - * - * \sa struct writer - */ -void alsa_write_init(struct writer *w) -{ - struct alsa_write_args_info dummy; - - alsa_cmdline_parser_init(&dummy); - w->open = alsa_open; - w->close = alsa_close; - w->pre_select = alsa_write_pre_select; - w->pre_select_btr = alsa_write_pre_select_btr; - w->post_select = alsa_write_post_select; - w->post_select_btr = alsa_write_post_select_btr; - w->parse_config = alsa_parse_config; - w->shutdown = NULL; /* nothing to do */ - w->help = (struct ggo_help) { - .short_help = alsa_write_args_info_help, - .detailed_help = alsa_write_args_info_detailed_help - }; - alsa_cmdline_parser_free(&dummy); -} + .pre_select = alsa_write_pre_select, + .post_select = alsa_write_post_select, + .close = alsa_close, +};