@@ -11,7 +11,8 @@ noinst_HEADERS = \
aligner.h \
waiter.h \
options.h \
- xfer.h
+ xfer.h \
+ xfer-alsa.h
aplay_SOURCES = \
formats.h \
@@ -32,7 +33,9 @@ aplay_SOURCES = \
options.h \
options.c \
xfer.h \
- xfer.c
+ xfer.c \
+ xfer-alsa.h \
+ xfer-alsa.c
EXTRA_DIST = aplay.1 arecord.1
EXTRA_CLEAN = arecord
new file mode 100644
@@ -0,0 +1,537 @@
+/*
+ * xfer-alsa.c - receive/transmit frames by ALSA.
+ *
+ * Copyright (c) 2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
+ *
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#include "xfer-alsa.h"
+#include <gettext.h>
+
+static int get_mode(struct context_options *options)
+{
+ int mode = 0;
+
+ if (options->nonblock)
+ mode |= SND_PCM_NONBLOCK;
+ if (options->no_auto_resample)
+ mode |= SND_PCM_NO_AUTO_RESAMPLE;
+ if (options->no_auto_channels)
+ mode |= SND_PCM_NO_AUTO_CHANNELS;
+ if (options->no_auto_format)
+ mode |= SND_PCM_NO_AUTO_FORMAT;
+ if (options->no_softvol)
+ mode |= SND_PCM_NO_SOFTVOL;
+
+ return mode;
+}
+
+static int set_access_hw_param(snd_pcm_t *handle,
+ snd_pcm_hw_params_t *hw_params,
+ struct context_options *opts)
+{
+ snd_pcm_access_mask_t *mask;
+ int err;
+
+ err = snd_pcm_access_mask_malloc(&mask);
+ if (err < 0)
+ return err;
+ snd_pcm_access_mask_none(mask);
+ if (opts->mmap) {
+ snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
+ snd_pcm_access_mask_set(mask,
+ SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
+ } else {
+ snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_RW_INTERLEAVED);
+ snd_pcm_access_mask_set(mask,
+ SND_PCM_ACCESS_RW_NONINTERLEAVED);
+ }
+ err = snd_pcm_hw_params_set_access_mask(handle, hw_params, mask);
+ snd_pcm_access_mask_free(mask);
+
+ return err;
+}
+
+static void dump_available_hw_params(snd_pcm_hw_params_t *hw_params,
+ const char *const node)
+{
+ unsigned int min_i, max_i;
+ snd_pcm_uframes_t min_l, max_l;
+ snd_pcm_access_mask_t *access_mask;
+ snd_pcm_format_mask_t *format_mask;
+ snd_pcm_subformat_mask_t *subformat_mask;
+ int i;
+ int err;
+
+ printf("Avail params for node: %s\n", node);
+
+ err = snd_pcm_hw_params_get_channels_min(hw_params, &min_i);
+ if (err < 0)
+ return;
+ err = snd_pcm_hw_params_get_channels_max(hw_params, &max_i);
+ if (err < 0)
+ return;
+ printf(" samples/frame: %u to %u\n", min_i, max_i);
+
+ err = snd_pcm_hw_params_get_rate_min(hw_params, &min_i, NULL);
+ if (err < 0)
+ return;
+ err = snd_pcm_hw_params_get_rate_max(hw_params, &max_i, NULL);
+ if (err < 0)
+ return;
+ printf(" frames/second: %u to %u\n", min_i, max_i);
+
+ err = snd_pcm_hw_params_get_period_time_min(hw_params, &min_i, NULL);
+ if (err < 0)
+ return;
+ err = snd_pcm_hw_params_get_period_time_max(hw_params, &max_i, NULL);
+ if (err < 0)
+ return;
+ printf(" msec/period: %u to %u\n", min_i, max_i);
+
+ err = snd_pcm_hw_params_get_period_size_min(hw_params, &min_l, NULL);
+ if (err < 0)
+ return;
+ err = snd_pcm_hw_params_get_period_size_max(hw_params, &max_l, NULL);
+ if (err < 0)
+ return;
+ printf(" frames/period: %lu to %lu\n", min_l, max_l);
+
+ err = snd_pcm_hw_params_get_periods_min(hw_params, &min_i, NULL);
+ if (err < 0)
+ return;
+ err = snd_pcm_hw_params_get_periods_max(hw_params, &max_i, NULL);
+ if (err < 0)
+ return;
+ printf(" periods/buffer: %u to %u\n", min_i, max_i);
+
+ err = snd_pcm_hw_params_get_buffer_time_min(hw_params, &min_i, NULL);
+ if (err < 0)
+ return;
+ err = snd_pcm_hw_params_get_buffer_time_max(hw_params, &max_i, NULL);
+ if (err < 0)
+ return;
+ printf(" msec/buffer: %u to %u\n", min_i, max_i);
+
+ err = snd_pcm_hw_params_get_buffer_size_min(hw_params, &min_l);
+ if (err < 0)
+ return;
+ err = snd_pcm_hw_params_get_buffer_size_max(hw_params, &max_l);
+ if (err < 0)
+ return;
+ printf(" frames/buffer: %lu to %lu\n", min_l, max_l);
+
+ err = snd_pcm_access_mask_malloc(&access_mask);
+ if (err < 0)
+ return;
+ err = snd_pcm_hw_params_get_access_mask(hw_params, access_mask);
+ if (err < 0)
+ return;
+ printf(" supported access methods:\n");
+ for (i = 0; i <= SND_PCM_ACCESS_LAST; ++i) {
+ if (!snd_pcm_access_mask_test(access_mask, i))
+ continue;
+ printf(" '%s'\n", snd_pcm_access_name(i));
+ }
+ snd_pcm_access_mask_free(access_mask);
+
+ err = snd_pcm_format_mask_malloc(&format_mask);
+ if (err < 0)
+ return;
+ snd_pcm_hw_params_get_format_mask(hw_params, format_mask);
+ printf(" supported sample formats:\n");
+ for (i = 0; i <= SND_PCM_FORMAT_LAST; ++i) {
+ if (!snd_pcm_format_mask_test(format_mask, i))
+ continue;
+ printf(" '%s'\n", snd_pcm_format_name(i));
+ }
+ snd_pcm_format_mask_free(format_mask);
+
+ err = snd_pcm_subformat_mask_malloc(&subformat_mask);
+ if (err < 0)
+ return;
+ snd_pcm_hw_params_get_subformat_mask(hw_params, subformat_mask);
+ printf(" supported sample sub-formats:\n");
+ for (i = 0; i <= SND_PCM_SUBFORMAT_LAST; ++i) {
+ if (!snd_pcm_subformat_mask_test(subformat_mask, i))
+ continue;
+ printf(" '%s'\n", snd_pcm_subformat_name(i));
+ }
+ printf("\n");
+}
+
+static int xfer_alsa_init(struct xfer_context *xfer,
+ snd_pcm_stream_t direction,
+ struct context_options *opts)
+{
+ struct alsa_state *state = xfer->private_data;
+ char *node;
+ int mode = 0;
+ int err;
+
+ state->verbose = xfer->verbose;
+
+ if (opts->node == NULL)
+ node = "default";
+ else
+ node = opts->node;
+
+ mode = get_mode(opts);
+ if (mode & SND_PCM_NONBLOCK) {
+ state->waiter = malloc(sizeof(*state->waiter));
+ if (state->waiter == NULL)
+ return -ENOMEM;
+
+ /* TODO: configurable. */
+ err = waiter_context_init(state->waiter, WAITER_TYPE_POLL);
+ if (err < 0)
+ return err;
+ }
+
+ err = snd_pcm_open(&state->handle, node, direction, mode);
+ if (err < 0)
+ return err;
+
+ err = snd_pcm_hw_params_malloc(&state->hw_params);
+ if (err < 0)
+ return err;
+ err = snd_pcm_sw_params_malloc(&state->sw_params);
+ if (err < 0)
+ return err;
+
+ err = snd_pcm_hw_params_any(state->handle, state->hw_params);
+ if (err < 0)
+ return err;
+
+ if (xfer->verbose)
+ dump_available_hw_params(state->hw_params, node);
+
+ return set_access_hw_param(state->handle, state->hw_params, opts);
+}
+
+static int prepare_waiter(struct alsa_state *state)
+{
+ int fd_count;
+ int *fds;
+ struct pollfd *pfds;
+ int i;
+ int err;
+
+ fd_count = snd_pcm_poll_descriptors_count(state->handle);
+
+ fds = calloc(fd_count, sizeof(int));
+ if (fds == NULL)
+ return -ENOMEM;
+
+ pfds = calloc(fd_count, sizeof(struct pollfd));
+ if (pfds == NULL) {
+ free(fds);
+ return -ENOMEM;
+ }
+
+ err = snd_pcm_poll_descriptors(state->handle, pfds, fd_count);
+ if (err < 0)
+ goto end;
+
+ for (i = 0; i < fd_count; ++i)
+ fds[i] = pfds[i].fd;
+
+ err = waiter_context_prepare(state->waiter, fds, fd_count);
+end:
+ free(pfds);
+ free(fds);
+ return err;
+}
+
+static int configure_requested_params(struct alsa_state *state,
+ snd_pcm_format_t format,
+ unsigned int samples_per_frame,
+ unsigned int frames_per_second)
+{
+ int err;
+
+ if (format != SND_PCM_FORMAT_UNKNOWN) {
+ err = snd_pcm_hw_params_set_format(state->handle,
+ state->hw_params, format);
+ if (err < 0) {
+ printf(_("Sample format '%s' is not available: %s\n"),
+ snd_pcm_format_name(format), snd_strerror(err));
+ return err;
+ }
+ }
+
+ if (samples_per_frame > 0) {
+ err = snd_pcm_hw_params_set_channels(state->handle,
+ state->hw_params,
+ samples_per_frame);
+ if (err < 0) {
+ printf(_("Channels count '%u' is not available: %s\n"),
+ samples_per_frame, snd_strerror(err));
+ return err;
+ }
+ }
+
+ if (frames_per_second > 0) {
+ err = snd_pcm_hw_params_set_rate(state->handle,
+ state->hw_params,
+ frames_per_second, 0);
+ if (err < 0) {
+ printf(_("Sampling rate '%u' is not available: %s\n"),
+ frames_per_second, snd_strerror(err));
+ return err;
+ }
+ }
+
+ return 0;
+}
+
+static int retrieve_actual_params(snd_pcm_hw_params_t *hw_params,
+ snd_pcm_format_t *format,
+ unsigned int *samples_per_frame,
+ unsigned int *frames_per_second,
+ snd_pcm_access_t *access,
+ snd_pcm_uframes_t *frames_per_buffer)
+{
+ int err;
+
+ err = snd_pcm_hw_params_get_format(hw_params, format);
+ if (err < 0)
+ return err;
+
+ err = snd_pcm_hw_params_get_channels(hw_params,
+ samples_per_frame);
+ if (err < 0)
+ return err;
+
+ err = snd_pcm_hw_params_get_rate(hw_params, frames_per_second,
+ NULL);
+ if (err < 0)
+ return err;
+
+ err = snd_pcm_hw_params_get_access(hw_params, access);
+ if (err < 0)
+ return err;
+
+ return snd_pcm_hw_params_get_buffer_size(hw_params, frames_per_buffer);
+}
+
+static void dump_sw_params(struct alsa_state *state)
+{
+ snd_pcm_uframes_t val_l;
+ int val_i;
+ int err;
+
+ printf("sw params\n");
+
+ err = snd_pcm_sw_params_get_avail_min(state->sw_params, &val_l);
+ if (err < 0)
+ return;
+ printf(" avail-min: %lu\n", val_l);
+
+ err = snd_pcm_sw_params_get_period_event(state->sw_params, &val_i);
+ if (err < 0)
+ return;
+ printf(" period-event: %d\n", val_i);
+
+ err = snd_pcm_sw_params_get_start_threshold(state->sw_params, &val_l);
+ if (err < 0)
+ return;
+ printf(" start-threshold: %lu\n", val_l);
+
+ err = snd_pcm_sw_params_get_stop_threshold(state->sw_params, &val_l);
+ if (err < 0)
+ return;
+ printf(" stop-threshold: %lu\n", val_l);
+
+ err = snd_pcm_sw_params_get_silence_threshold(state->sw_params, &val_l);
+ if (err < 0)
+ return;
+ printf(" silence-threshold: %lu\n", val_l);
+
+ err = snd_pcm_sw_params_get_silence_size(state->sw_params, &val_l);
+ if (err < 0)
+ return;
+ printf(" silence-size: %lu\n", val_l);
+
+ printf("\n");
+}
+
+static int xfer_alsa_pre_process(struct xfer_context *xfer,
+ snd_pcm_format_t *format,
+ unsigned int *samples_per_frame,
+ unsigned int *frames_per_second,
+ snd_pcm_access_t *access,
+ snd_pcm_uframes_t *frames_per_buffer)
+{
+ struct alsa_state *state = xfer->private_data;
+ int err;
+
+ err = configure_requested_params(state, *format, *samples_per_frame,
+ *frames_per_second);
+ if (err < 0)
+ return err;
+
+ /* Configure hardware parameters. */
+ err = snd_pcm_hw_params(state->handle, state->hw_params);
+ if (err < 0)
+ return err;
+
+ /* Retrieve actual parameters. */
+ err = retrieve_actual_params(state->hw_params, format,
+ samples_per_frame, frames_per_second,
+ access, frames_per_buffer);
+ if (err < 0)
+ return err;
+ state->frames_per_buffer = *frames_per_buffer;
+
+ /* Query software parameters. */
+ err = snd_pcm_sw_params_current(state->handle, state->sw_params);
+ if (err < 0)
+ return err;
+
+ /* Assign I/O operation. */
+ if (state->io_ops->private_size > 0) {
+ state->io_private_data = malloc(state->io_ops->private_size);
+ if (state->io_private_data == NULL)
+ return -ENOMEM;
+ memset(state->io_private_data, 0, state->io_ops->private_size);
+ }
+ state->access = *access;
+ err = state->io_ops->pre_process(state);
+ if (err < 0)
+ return err;
+
+ /* Assign scheduling operation. */
+ err = state->sched_ops->pre_process(xfer);
+ if (err < 0)
+ return err;
+
+ err = snd_pcm_sw_params(state->handle, state->sw_params);
+ if (err < 0)
+ return err;
+
+ if (state->waiter) {
+ /*
+ * NOTE: This should be after configuring sw_params due to
+ * timer descriptor.
+ */
+ err = prepare_waiter(state);
+ if (err < 0)
+ return err;
+ }
+
+ if (xfer->verbose)
+ dump_sw_params(state);
+
+ return 0;
+}
+
+static int xfer_alsa_process_frames(struct xfer_context *xfer,
+ unsigned int *frame_count,
+ struct aligner_context *aligner,
+ struct container_context *cntrs)
+{
+ struct alsa_state *state = xfer->private_data;
+ int err;
+ err = state->io_ops->process_frames(state, frame_count, aligner, cntrs);
+ if (err < 0) {
+ if (err == -EPIPE)
+ err = snd_pcm_prepare(state->handle);
+ }
+
+ return err;
+}
+
+static void xfer_alsa_pause(struct xfer_context *xfer, bool enable)
+{
+ struct alsa_state *state = xfer->private_data;
+ snd_pcm_state_t s = snd_pcm_state(state->handle);
+ int err;
+
+ if (enable) {
+ if (s != SND_PCM_STATE_RUNNING)
+ return;
+ } else {
+ if (s != SND_PCM_STATE_PAUSED)
+ return;
+ }
+
+ /* Not supported. Leave the substream to enter XRUN state. */
+ if (!snd_pcm_hw_params_can_pause(state->hw_params))
+ return;
+
+ err = snd_pcm_pause(state->handle, enable);
+ if (err < 0 && xfer->verbose > 0) {
+ printf("snd_pcm_pause(): %s\n",
+ snd_strerror(err));
+ }
+}
+
+static void xfer_alsa_post_process(struct xfer_context *xfer)
+{
+ struct alsa_state *state = xfer->private_data;
+ snd_pcm_state_t pcm_state;
+ int err;
+
+ pcm_state = snd_pcm_state(state->handle);
+ if (pcm_state != SND_PCM_STATE_OPEN &&
+ pcm_state != SND_PCM_STATE_DISCONNECTED) {
+ if (snd_pcm_stream(state->handle) == SND_PCM_STREAM_CAPTURE) {
+ err = snd_pcm_drop(state->handle);
+ if (err < 0)
+ printf("snd_pcm_drop(): %s\n",
+ snd_strerror(err));
+ } else {
+ err = snd_pcm_drain(state->handle);
+ if (err < 0)
+ printf("snd_pcm_drain(): %s\n",
+ snd_strerror(err));
+ }
+ }
+
+ err = snd_pcm_hw_free(state->handle);
+ if (err < 0)
+ printf("snd_pcm_hw_free(): %s\n", snd_strerror(err));
+
+ snd_pcm_close(state->handle);
+ state->handle = NULL;
+
+ if (state->io_ops && state->io_ops->post_process)
+ state->io_ops->post_process(state);
+ if (state->io_private_data)
+ free(state->io_private_data);
+ state->io_private_data = NULL;
+
+ if (state->waiter)
+ waiter_context_release(state->waiter);
+}
+
+static void xfer_alsa_destroy(struct xfer_context *xfer)
+{
+ struct alsa_state *state = xfer->private_data;
+
+ if (state->waiter)
+ waiter_context_destroy(state->waiter);
+ free(state->waiter);
+ state->waiter = NULL;
+
+ if (state->hw_params)
+ snd_pcm_hw_params_free(state->hw_params);
+ if (state->sw_params)
+ snd_pcm_sw_params_free(state->sw_params);
+ state->hw_params = NULL;
+ state->sw_params = NULL;
+}
+
+const struct xfer_data xfer_alsa = {
+ .ops = {
+ .init = xfer_alsa_init,
+ .pre_process = xfer_alsa_pre_process,
+ .process_frames = xfer_alsa_process_frames,
+ .pause = xfer_alsa_pause,
+ .post_process = xfer_alsa_post_process,
+ .destroy = xfer_alsa_destroy,
+ },
+ .private_size = sizeof(struct alsa_state),
+};
new file mode 100644
@@ -0,0 +1,57 @@
+/*
+ * xfer-alsa.h - a header for receiver/transmitter of frames by ALSA.
+ *
+ * Copyright (c) 2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
+ *
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#ifndef __ALSA_UTILS_APLAY_XFER_ALSA__H_
+#define __ALSA_UTILS_APLAY_XFER_ALSA__H_
+
+#include "xfer.h"
+#include "waiter.h"
+
+enum xfer_alsa_sched_mode {
+ XFER_ALSA_SCHED_MODE_IRQ = 0,
+ XFER_ALSA_SCHED_MODE_TIMER,
+};
+
+struct xfer_alsa_io_ops;
+struct xfer_alsa_sched_ops;
+
+struct alsa_state {
+ snd_pcm_t *handle;
+ snd_pcm_hw_params_t *hw_params;
+ snd_pcm_sw_params_t *sw_params;
+
+ struct waiter_context *waiter;
+
+ snd_pcm_access_t access;
+ snd_pcm_uframes_t frames_per_buffer;
+ bool running;
+
+ const struct xfer_alsa_io_ops *io_ops;
+ void *io_private_data;
+
+ const struct xfer_alsa_sched_ops *sched_ops;
+ void *private_data;
+
+ bool verbose;
+};
+
+struct xfer_alsa_io_ops {
+ int (*pre_process)(struct alsa_state *state);
+ int (*process_frames)(struct alsa_state *state,
+ unsigned int *frame_count,
+ struct aligner_context *aligner,
+ struct container_context *cntrs);
+ void (*post_process)(struct alsa_state *state);
+ unsigned int private_size;
+};
+
+struct xfer_alsa_sched_ops {
+ int (*pre_process)(struct xfer_context *xfer);
+};
+
+#endif
@@ -21,7 +21,7 @@ int xfer_context_init(struct xfer_context *xfer, enum xfer_type type,
enum xfer_type type;
const struct xfer_data *data;
} entries[] = {
- {XFER_TYPE_ALSA, NULL},
+ {XFER_TYPE_ALSA, &xfer_alsa},
};
int i;