This commit adds a new command, 'axfer' ('ALSA transfer'), to transfer data frames described in asound.h. This command is intended to replace current aplay. The most of features and command line parameters come from aplay as much as possible, while it has more better feature and code to maintain.

This commit adds an entry point for this command. Current option system of aplay is still available, while this command has a sub-command system like commands in iproute2.

Currently, two sub-commands are supported; 'list' and 'transfer'. The 'list' sub-command has the same effect as '-l' and '-L' options of aplay. The 'transfer' sub-command has the same effect as the main feature of aplay. For the sub-command system, an option for stream direction is required; '-P' for playback and '-C' for capture. If you create symbolic links to this binary for aplay/arecord, please execute: $ ln -s axfer aplay $ ln -s axfer arecord

This commit adds an entry point of the command. For backward compatibility, this includes a parser of command line parameters. Actual code for each sub-command will be implemented in later commits.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- Makefile.am | 2 +- axfer/Makefile.am | 23 +++++++ axfer/main.c | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ axfer/misc.h | 16 +++++ axfer/subcmd.h | 14 ++++ configure.ac | 2 +- 6 files changed, 249 insertions(+), 2 deletions(-) create mode 100644 axfer/Makefile.am create mode 100644 axfer/main.c create mode 100644 axfer/misc.h create mode 100644 axfer/subcmd.h

diff --git a/Makefile.am b/Makefile.am index 3d24b87c..a4e25ae7 100644 --- a/Makefile.am +++ b/Makefile.am @@ -14,7 +14,7 @@ if ALSACONF SUBDIRS += alsaconf endif if HAVE_PCM -SUBDIRS += aplay iecset speaker-test +SUBDIRS += aplay iecset speaker-test axfer if ALSALOOP SUBDIRS += alsaloop endif diff --git a/axfer/Makefile.am b/axfer/Makefile.am new file mode 100644 index 00000000..b48b9c57 --- /dev/null +++ b/axfer/Makefile.am @@ -0,0 +1,23 @@ +bin_PROGRAMS = \ + axfer + +# To include headers for gettext and version. +AM_CPPFLAGS = \ + -I$(top_srcdir)/include + +# Unit tests. +SUBDIRS = + +LIBRT = @LIBRT@ +LDADD = \ + $(LIBINTL) \ + $(LIBRT) + +noinst_HEADERS = \ + misc.h \ + subcmd.h + +axfer_SOURCES = \ + misc.h \ + subcmd.h \ + main.c diff --git a/axfer/main.c b/axfer/main.c new file mode 100644 index 00000000..6ea10842 --- /dev/null +++ b/axfer/main.c @@ -0,0 +1,194 @@ +/* + * main.c - an entry point for this program. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Originally written as 'aplay', by Michael Beck and Jaroslav Kysela. + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "subcmd.h" +#include "misc.h" + +#include "version.h" + +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> + +enum subcmds { + SUBCMD_TRANSFER = 0, + SUBCMD_LIST, + SUBCMD_HELP, + SUBCMD_VERSION, +}; + +static void print_version(const char *const cmdname) +{ + printf("%s: version %s\n", cmdname, SND_UTIL_VERSION_STR); +} + +static void print_help(void) +{ + printf("help\n"); +} + +static void decide_subcmd(int argc, char *const *argv, enum subcmds *subcmd) +{ + static const char *const subcmds[] = { + [SUBCMD_TRANSFER] = "transfer", + [SUBCMD_LIST] = "list", + [SUBCMD_HELP] = "help", + [SUBCMD_VERSION] = "version", + }; + static const struct { + const char *const name; + enum subcmds subcmd; + } long_opts[] = { + {"--list-devices", SUBCMD_LIST}, + {"--list-pcms", SUBCMD_LIST}, + {"--help", SUBCMD_HELP}, + {"--version", SUBCMD_VERSION}, + }; + static const struct { + unsigned char c; + enum subcmds subcmd; + } short_opts[] = { + {'l', SUBCMD_LIST}, + {'L', SUBCMD_LIST}, + {'h', SUBCMD_HELP}, + }; + char *pos; + int i, j; + + if (argc == 1) { + *subcmd = SUBCMD_HELP; + return; + } + + /* sub-command system. */ + for (i = 0; i < ARRAY_SIZE(subcmds); ++i) { + if (!strcmp(argv[1], subcmds[i])) { + *subcmd = i; + return; + } + } + + /* Original command system. For long options. */ + for (i = 0; i < ARRAY_SIZE(long_opts); ++i) { + for (j = 0; j < argc; ++j) { + if (!strcmp(long_opts[i].name, argv[j])) { + *subcmd = long_opts[i].subcmd; + return; + } + } + } + + /* Original command system. For short options. */ + for (i = 1; i < argc; ++i) { + /* Pick up short options only. */ + if (argv[i][0] != '-' || argv[i][0] == '\0' || + argv[i][1] == '-' || argv[i][1] == '\0') + continue; + for (pos = argv[i]; *pos != '\0'; ++pos) { + for (j = 0; j < ARRAY_SIZE(short_opts); ++j) { + if (*pos == short_opts[j].c) { + *subcmd = short_opts[j].subcmd; + return; + } + } + } + } + + *subcmd = SUBCMD_TRANSFER; +} + +static bool decide_direction(int argc, char *const *argv, + snd_pcm_stream_t *direction) +{ + static const struct { + const char *const name; + snd_pcm_stream_t direction; + } long_opts[] = { + {"--capture", SND_PCM_STREAM_CAPTURE}, + {"--playback", SND_PCM_STREAM_PLAYBACK}, + }; + static const struct { + unsigned char c; + snd_pcm_stream_t direction; + } short_opts[] = { + {'C', SND_PCM_STREAM_CAPTURE}, + {'P', SND_PCM_STREAM_PLAYBACK}, + }; + static const char *const directions[] = { + [SND_PCM_STREAM_CAPTURE] = "arecord", + [SND_PCM_STREAM_PLAYBACK] = "aplay", + }; + int i, j; + char *pos; + + /* Original command system. For long options. */ + for (i = 0; i < ARRAY_SIZE(long_opts); ++i) { + for (j = 0; j < argc; ++j) { + if (!strcmp(long_opts[i].name, argv[j])) { + *direction = long_opts[i].direction; + return true; + } + } + } + + /* Original command system. For short options. */ + for (i = 1; i < argc; ++i) { + /* Pick up short options only. */ + if (argv[i][0] != '-' || argv[i][0] == '\0' || + argv[i][1] == '-' || argv[i][1] == '\0') + continue; + for (pos = argv[i]; *pos != '\0'; ++pos) { + for (j = 0; j < ARRAY_SIZE(short_opts); ++j) { + if (*pos == short_opts[j].c) { + *direction = short_opts[j].direction; + return true; + } + } + } + } + + /* If not decided yet, judge according to command name. */ + for (i = 0; i < ARRAY_SIZE(directions); ++i) { + for (pos = argv[0] + strlen(argv[0]); pos != argv[0]; --pos) { + if (strstr(pos, directions[i]) != NULL) { + *direction = i; + return true; + } + } + } + + return false; +} + +int main(int argc, char *const *argv) +{ + snd_pcm_stream_t direction; + enum subcmds subcmd; + int err = 0; + + if (!decide_direction(argc, argv, &direction)) + subcmd = SUBCMD_HELP; + else + decide_subcmd(argc, argv, &subcmd); + + if (subcmd == SUBCMD_TRANSFER) + printf("execute 'transfer' subcmd.\n"); + else if (subcmd == SUBCMD_LIST) + printf("execute 'list' subcmd.\n"); + else if (subcmd == SUBCMD_VERSION) + print_version(argv[0]); + else + print_help(); + if (err < 0) + return EXIT_FAILURE; + + return EXIT_SUCCESS; +} diff --git a/axfer/misc.h b/axfer/misc.h new file mode 100644 index 00000000..824617a2 --- /dev/null +++ b/axfer/misc.h @@ -0,0 +1,16 @@ +/* + * misc.h - a header file for miscellaneous tools. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#ifndef __ALSA_UTILS_AXFER_MISC__H_ +#define __ALSA_UTILS_AXFER_MISC__H_ + +#include <gettext.h> + +#define ARRAY_SIZE(array) (sizeof(array)/sizeof(array[0])) + +#endif diff --git a/axfer/subcmd.h b/axfer/subcmd.h new file mode 100644 index 00000000..7b52ddc7 --- /dev/null +++ b/axfer/subcmd.h @@ -0,0 +1,14 @@ +/* + * subcmd.h - a header for each sub-commands. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#ifndef __ALSA_UTILS_AXFER_SUBCMD__H_ +#define __ALSA_UTILS_AXFER_SUBCMD__H_ + +#include <alsa/asoundlib.h> + +#endif diff --git a/configure.ac b/configure.ac index 0ff4fad1..41fac0cb 100644 --- a/configure.ac +++ b/configure.ac @@ -426,4 +426,4 @@ AC_OUTPUT(Makefile alsactl/Makefile alsactl/init/Makefile \ utils/alsa-utils.spec seq/Makefile seq/aconnect/Makefile \ seq/aplaymidi/Makefile seq/aseqdump/Makefile seq/aseqnet/Makefile \ speaker-test/Makefile speaker-test/samples/Makefile \ - alsaloop/Makefile alsa-info/Makefile) + alsaloop/Makefile alsa-info/Makefile axfer/Makefile)

Current aplay supports several types of data format for file; Microsoft/IBM RIFF/Wave (.wav), Sparc AU (.au) and Creative Tech. voice (.voc). These formats were designed to handle audio-related data with interleaved frame alignment.

This commit adds a common interface to handle the file format, named as 'container' module. This includes several functions to build/parse the format data from any file descriptors. Furthermore, this includes several helper functions for implementations of each builder/parser.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 7 +- axfer/container.c | 434 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ axfer/container.h | 110 ++++++++++++++ 3 files changed, 549 insertions(+), 2 deletions(-) create mode 100644 axfer/container.c create mode 100644 axfer/container.h

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index 4e37b92f..3913d0c6 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -15,10 +15,13 @@ LDADD = \

noinst_HEADERS = \ misc.h \ - subcmd.h + subcmd.h \ + container.h

axfer_SOURCES = \ misc.h \ subcmd.h \ main.c \ - subcmd-list.c + subcmd-list.c \ + container.h \ + container.c diff --git a/axfer/container.c b/axfer/container.c new file mode 100644 index 00000000..5cb879e1 --- /dev/null +++ b/axfer/container.c @@ -0,0 +1,434 @@ +/* + * container.c - an interface of parser/builder for formatted files. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "container.h" +#include "misc.h" + +#include <stdio.h> +#include <errno.h> +#include <string.h> +#include <fcntl.h> + +static const char *const cntr_type_labels[] = { + [CONTAINER_TYPE_PARSER] = "parser", + [CONTAINER_TYPE_BUILDER] = "builder", +}; + +static const char *const cntr_format_labels[] = { + [CONTAINER_FORMAT_COUNT] = "", +}; + +static const char *const suffixes[] = { + [CONTAINER_FORMAT_COUNT] = "", +}; + +const char *const container_suffix_from_format(enum container_format format) +{ + return suffixes[format]; +} + +int container_recursive_read(struct container_context *cntr, void *buf, + unsigned int byte_count) +{ + char *dst = buf; + ssize_t result; + size_t consumed = 0; + + while (consumed < byte_count && !cntr->interrupted) { + result = read(cntr->fd, dst + consumed, byte_count - consumed); + if (result < 0) { + /* + * This descriptor was configured with non-blocking + * mode. EINTR is not cought when get any interrupts. + */ + if (cntr->interrupted) + return -EINTR; + if (errno == EAGAIN) + continue; + return -errno; + } + /* Reach EOF. */ + if (result == 0) { + cntr->eof = true; + return 0; + } + + consumed += result; + } + + return 0; +} + +int container_recursive_write(struct container_context *cntr, void *buf, + unsigned int byte_count) +{ + char *src = buf; + ssize_t result; + size_t consumed = 0; + + while (consumed < byte_count && !cntr->interrupted) { + result = write(cntr->fd, src + consumed, byte_count - consumed); + if (result < 0) { + /* + * This descriptor was configured with non-blocking + * mode. EINTR is not cought when get any interrupts. + */ + if (cntr->interrupted) + return -EINTR; + if (errno == EAGAIN) + continue; + return -errno; + } + + consumed += result; + } + + return 0; +} + +enum container_format container_format_from_path(const char *path) +{ + const char *suffix; + const char *pos; + int i; + + for (i = 0; i < ARRAY_SIZE(suffixes); ++i) { + suffix = suffixes[i]; + + /* Check last part of the string. */ + pos = path + strlen(path) - strlen(suffix); + if (!strcmp(pos, suffix)) + return i; + } + + /* Unsupported. */ + return CONTAINER_FORMAT_COUNT; +} + +int container_seek_offset(struct container_context *cntr, off64_t offset) +{ + off64_t pos; + + pos = lseek64(cntr->fd, offset, SEEK_SET); + if (pos < 0) + return -errno; + if (pos != offset) + return -EIO; + + return 0; +} + +/* + * To avoid blocking execution at system call iteration after receiving UNIX + * signals. + */ +static int set_nonblock_flag(int fd) +{ + int flags; + + flags = fcntl(fd, F_GETFL); + if (flags < 0) + return -errno; + + flags |= O_NONBLOCK; + if (fcntl(fd, F_SETFL, flags) < 0) + return -errno; + + return 0; +} + +int container_parser_init(struct container_context *cntr, + const char *const path, unsigned int verbose) +{ + const struct container_parser *parsers[] = { + NULL, + }; + const struct container_parser *parser; + unsigned int size; + int i; + int err; + + assert(cntr); + assert(path); + assert(path[0] != '\0'); + + /* Detect forgotten to destruct. */ + assert(cntr->fd == 0); + assert(cntr->private_data == NULL); + + memset(cntr, 0, sizeof(*cntr)); + + /* Open a target descriptor. */ + if (!strcmp(path, "-")) { + cntr->fd = fileno(stdin); + err = set_nonblock_flag(cntr->fd); + if (err < 0) + return err; + cntr->stdio = true; + } else { + cntr->fd = open(path, O_RDONLY | O_NONBLOCK); + if (cntr->fd < 0) + return -errno; + } + + /* 4 bytes are enough to detect supported containers. */ + err = container_recursive_read(cntr, cntr->magic, sizeof(cntr->magic)); + if (err < 0) + return err; + for (i = 0; i < ARRAY_SIZE(parsers); ++i) { + parser = parsers[i]; + size = strlen(parser->magic); + if (size > 4) + size = 4; + if (!strncmp(cntr->magic, parser->magic, size)) + break; + } + /* + * Don't forget that the first 4 bytes were already read for magic + * bytes. + */ + cntr->magic_handled = false; + + /* + * Unless detected, use raw container. + */ + if (i == ARRAY_SIZE(parsers)) + return -EINVAL; + + /* Allocate private data for the parser. */ + if (parser->private_size > 0) { + cntr->private_data = malloc(parser->private_size); + if (cntr->private_data == NULL) + return -ENOMEM; + memset(cntr->private_data, 0, parser->private_size); + } + + cntr->type = CONTAINER_TYPE_PARSER; + cntr->process_bytes = container_recursive_read; + cntr->format = parser->format; + cntr->ops = &parser->ops; + cntr->max_size = parser->max_size; + cntr->verbose = verbose; + + return 0; +} + +int container_builder_init(struct container_context *cntr, + const char *const path, enum container_format format, + unsigned int verbose) +{ + const struct container_builder *builders[] = { + NULL, + }; + const struct container_builder *builder; + int err; + + assert(cntr); + assert(path); + assert(path[0] != '\0'); + + /* Detect forgotten to destruct. */ + assert(cntr->fd == 0); + assert(cntr->private_data == NULL); + + memset(cntr, 0, sizeof(*cntr)); + + /* Open a target descriptor. */ + if (path == NULL || path == '\0') + return -EINVAL; + if (!strcmp(path, "-")) { + cntr->fd = fileno(stdout); + err = set_nonblock_flag(cntr->fd); + if (err < 0) + return err; + cntr->stdio = true; + } else { + cntr->fd = open(path, O_RDWR | O_NONBLOCK | O_CREAT | O_TRUNC, + 0644); + if (cntr->fd < 0) + return -errno; + } + + builder = builders[format]; + + /* Allocate private data for the builder. */ + if (builder->private_size > 0) { + cntr->private_data = malloc(builder->private_size); + if (cntr->private_data == NULL) + return -ENOMEM; + memset(cntr->private_data, 0, builder->private_size); + } + + cntr->type = CONTAINER_TYPE_BUILDER; + cntr->process_bytes = container_recursive_write; + cntr->format = builder->format; + cntr->ops = &builder->ops; + cntr->max_size = builder->max_size; + cntr->verbose = verbose; + + return 0; +} + +int container_context_pre_process(struct container_context *cntr, + snd_pcm_format_t *format, + unsigned int *samples_per_frame, + unsigned int *frames_per_second, + uint64_t *frame_count) +{ + uint64_t byte_count; + unsigned int bytes_per_frame; + int err; + + assert(cntr); + assert(format); + assert(samples_per_frame); + assert(frames_per_second); + assert(frame_count); + + if (cntr->type == CONTAINER_TYPE_BUILDER) + byte_count = cntr->max_size; + + if (cntr->ops->pre_process) { + err = cntr->ops->pre_process(cntr, format, samples_per_frame, + frames_per_second, &byte_count); + if (err < 0) + return err; + if (cntr->eof) + return 0; + } + + assert(*format >= SND_PCM_FORMAT_S8); + assert(*format <= SND_PCM_FORMAT_LAST); + assert(*samples_per_frame > 0); + assert(*frames_per_second > 0); + assert(byte_count > 0); + + cntr->bytes_per_sample = snd_pcm_format_physical_width(*format) / 8; + cntr->samples_per_frame = *samples_per_frame; + cntr->frames_per_second = *frames_per_second; + + bytes_per_frame = cntr->bytes_per_sample * *samples_per_frame; + *frame_count = byte_count / bytes_per_frame; + cntr->max_size -= cntr->max_size / bytes_per_frame; + + if (cntr->verbose > 0) { + fprintf(stderr, "Container: %s\n", + cntr_type_labels[cntr->type]); + fprintf(stderr, " format: %s\n", + cntr_format_labels[cntr->format]); + fprintf(stderr, " sample format: %s\n", + snd_pcm_format_name(*format)); + fprintf(stderr, " bytes/sample: %u\n", + cntr->bytes_per_sample); + fprintf(stderr, " samples/frame: %u\n", + cntr->samples_per_frame); + fprintf(stderr, " frames/second: %u\n", + cntr->frames_per_second); + if (cntr->type == CONTAINER_TYPE_PARSER) { + fprintf(stderr, " frames: %lu\n", + *frame_count); + } else { + fprintf(stderr, " max frames: %lu\n", + *frame_count); + } + } + + return 0; +} + +int container_context_process_frames(struct container_context *cntr, + void *frame_buffer, + unsigned int *frame_count) +{ + char *buf = frame_buffer; + unsigned int bytes_per_frame; + unsigned int byte_count; + int err; + + assert(cntr); + assert(!cntr->eof); + assert(frame_buffer); + assert(frame_count); + + bytes_per_frame = cntr->bytes_per_sample * cntr->samples_per_frame; + byte_count = *frame_count * bytes_per_frame; + + /* Each container has limitation for its volume for sample data. */ + if (cntr->handled_byte_count > cntr->max_size - byte_count) + byte_count = cntr->max_size - cntr->handled_byte_count; + + /* All of supported containers include interleaved PCM frames. */ + /* TODO: process frames for truncate case. */ + err = cntr->process_bytes(cntr, buf, byte_count); + if (err < 0) { + *frame_count = 0; + return err; + } + + cntr->handled_byte_count += byte_count; + if (cntr->handled_byte_count == cntr->max_size) + cntr->eof = true; + + *frame_count = byte_count / bytes_per_frame; + + return 0; +} + +int container_context_post_process(struct container_context *cntr, + uint64_t *frame_count) +{ + int err = 0; + + assert(cntr); + assert(frame_count); + + if (cntr->verbose && cntr->handled_byte_count > 0) { + fprintf(stderr, " Handled bytes: %lu\n", + cntr->handled_byte_count); + } + + /* NOTE* we cannot seek when using standard input/output. */ + if (!cntr->stdio && cntr->ops && cntr->ops->post_process) { + /* + * Usually, need to write out processed bytes in container + * header even it this program is interrupted. + */ + cntr->interrupted = false; + + err = cntr->ops->post_process(cntr, cntr->handled_byte_count); + } + + /* Ensure to perform write-back from disk cache. */ + if (cntr->type == CONTAINER_TYPE_BUILDER) + fsync(cntr->fd); + + if (err < 0) + return err; + + if (cntr->bytes_per_sample == 0 || cntr->samples_per_frame == 0) { + *frame_count = 0; + } else { + *frame_count = cntr->handled_byte_count / + cntr->bytes_per_sample / + cntr->samples_per_frame; + } + + return 0; +} + +void container_context_destroy(struct container_context *cntr) +{ + assert(cntr); + + close(cntr->fd); + if (cntr->private_data) + free(cntr->private_data); + + cntr->fd = 0; + cntr->private_data = NULL; +} diff --git a/axfer/container.h b/axfer/container.h new file mode 100644 index 00000000..7b1f80c6 --- /dev/null +++ b/axfer/container.h @@ -0,0 +1,110 @@ +/* + * container.h - an interface of parser/builder for formatted files. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#ifndef __ALSA_UTILS_AXFER_CONTAINER__H_ +#define __ALSA_UTILS_AXFER_CONTAINER__H_ + +#define _LARGEFILE64_SOURCE +#include <sys/types.h> +#include <unistd.h> + +#include <stdbool.h> +#include <stdint.h> + +#include <alsa/asoundlib.h> + +enum container_type { + CONTAINER_TYPE_PARSER = 0, + CONTAINER_TYPE_BUILDER, + CONTAINER_TYPE_COUNT, +}; + +enum container_format { + CONTAINER_FORMAT_COUNT, +}; + +struct container_ops; + +struct container_context { + enum container_type type; + int fd; + int (*process_bytes)(struct container_context *cntr, + void *buffer, unsigned int byte_count); + bool magic_handled; + bool eof; + bool interrupted; + bool stdio; + + enum container_format format; + uint64_t max_size; + char magic[4]; + const struct container_ops *ops; + void *private_data; + + /* Available after pre-process. */ + unsigned int bytes_per_sample; + unsigned int samples_per_frame; + unsigned int frames_per_second; + + unsigned int verbose; + uint64_t handled_byte_count; +}; + +const char *const container_suffix_from_format(enum container_format format); +enum container_format container_format_from_path(const char *path); +int container_parser_init(struct container_context *cntr, + const char *const path, unsigned int verbose); +int container_builder_init(struct container_context *cntr, + const char *const path, enum container_format format, + unsigned int verbose); +void container_context_destroy(struct container_context *cntr); +int container_context_pre_process(struct container_context *cntr, + snd_pcm_format_t *format, + unsigned int *samples_per_frame, + unsigned int *frames_per_second, + uint64_t *frame_count); +int container_context_process_frames(struct container_context *cntr, + void *frame_buffer, + unsigned int *frame_count); +int container_context_post_process(struct container_context *cntr, + uint64_t *frame_count); + +/* For internal use in 'container' module. */ + +struct container_ops { + int (*pre_process)(struct container_context *cntr, + snd_pcm_format_t *format, + unsigned int *samples_per_frame, + unsigned int *frames_per_second, + uint64_t *byte_count); + int (*post_process)(struct container_context *cntr, + uint64_t handled_byte_count); +}; +struct container_parser { + enum container_format format; + const char const *magic; + uint64_t max_size; + struct container_ops ops; + unsigned int private_size; +}; + +struct container_builder { + enum container_format format; + const char const *suffix; + uint64_t max_size; + struct container_ops ops; + unsigned int private_size; +}; + +int container_recursive_read(struct container_context *cntr, void *buf, + unsigned int byte_count); +int container_recursive_write(struct container_context *cntr, void *buf, + unsigned int byte_count); +int container_seek_offset(struct container_context *cntr, off64_t offset); + +#endif

This commit adds support for data of Sparc AU format. In this data format, values in each of field are encoded in big-endian byte order and available formats of data sample are restricted in big-endian byte order.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 3 +- axfer/container-au.c | 207 +++++++++++++++++++++++++++++++++++++++++++++++++++ axfer/container.c | 6 +- axfer/container.h | 4 + 4 files changed, 218 insertions(+), 2 deletions(-) create mode 100644 axfer/container-au.c

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index 092c9662..35aa2261 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -25,4 +25,5 @@ axfer_SOURCES = \ subcmd-list.c \ container.h \ container.c \ - container-riff-wave.c + container-riff-wave.c \ + container-au.c diff --git a/axfer/container-au.c b/axfer/container-au.c new file mode 100644 index 00000000..b0ac13c6 --- /dev/null +++ b/axfer/container-au.c @@ -0,0 +1,207 @@ +/* + * container-au.c - a parser/builder for a container of Sun Audio File. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "container.h" +#include "misc.h" + +/* Not portable to all of UNIX platforms. */ +#include <endian.h> + +/* + * Reference: + * * http://pubs.opengroup.org/external/auformat.html + */ + +#define AU_MAGIC ".snd" +#define UNKNOWN_SIZE UINT32_MAX + +enum code_id { + CODE_ID_CCIT_MU_LAW_BE = 0x01, + CODE_ID_GENERIC_MBLA_S8 = 0x02, + CODE_ID_GENERIC_MBLA_S16_BE = 0x03, + CODE_ID_GENERIC_MBLA_S32_BE = 0x05, + CODE_ID_IEEE754_FLOAT_S32_BE = 0x06, + CODE_ID_IEEE754_DOUBLE_S64_BE = 0x07, + CODE_ID_CCIT_ADPCM_G721_4BIT_BE = 0x17, + CODE_ID_CCIT_ADPCM_G723_3BIT_BE = 0x19, + CODE_ID_CCIT_A_LAW_BE = 0x1b, +}; + +struct format_map { + enum code_id code_id; + snd_pcm_format_t format; +}; + +static const struct format_map format_maps[] = { + {CODE_ID_GENERIC_MBLA_S8, SND_PCM_FORMAT_S8}, + {CODE_ID_GENERIC_MBLA_S16_BE, SND_PCM_FORMAT_S16_BE}, + {CODE_ID_GENERIC_MBLA_S32_BE, SND_PCM_FORMAT_S32_BE}, + {CODE_ID_IEEE754_FLOAT_S32_BE, SND_PCM_FORMAT_FLOAT_BE}, + {CODE_ID_IEEE754_DOUBLE_S64_BE, SND_PCM_FORMAT_FLOAT64_BE}, + /* + * CODE_ID_CCIT_ADPCM_G721_4BIT_BE is not supported by ALSA. + * CODE_ID_CCIT_ADPCM_G723_3BIT_BE is not supported due to width of + * its sample. + */ + {CODE_ID_CCIT_A_LAW_BE, SND_PCM_FORMAT_A_LAW}, + {CODE_ID_CCIT_MU_LAW_BE, SND_PCM_FORMAT_MU_LAW}, +}; + +struct container_header { + uint8_t magic[4]; + uint32_t hdr_size; + uint32_t data_size; + uint32_t code_id; + uint32_t frames_per_second; + uint32_t samples_per_frame; +}; + +struct container_annotation { + uint32_t chunks[0]; +}; + +struct parser_state { + enum code_id code_id; + unsigned int samples_per_frame; + unsigned int bytes_per_sample; +}; + +static int au_parser_pre_process(struct container_context *cntr, + snd_pcm_format_t *format, + unsigned int *samples_per_frame, + unsigned int *frames_per_second, + uint64_t *byte_count) +{ + struct parser_state *state = cntr->private_data; + struct container_header header; + enum code_id code_id; + int i; + int err; + + /* Parse header. 4 bytes are enough to detect supported containers. */ + memcpy(&header.magic, cntr->magic, sizeof(cntr->magic)); + err = container_recursive_read(cntr, + (char *)&header + sizeof(cntr->magic), + sizeof(header) - sizeof(cntr->magic)); + if (err < 0) + return err; + if (cntr->eof) + return 0; + + if (memcmp(header.magic, AU_MAGIC, sizeof(header.magic)) != 0) + return -EINVAL; + if (be32toh(header.hdr_size) != sizeof(struct container_header)) + return -EINVAL; + + code_id = be32toh(header.code_id); + for (i = 0; i < ARRAY_SIZE(format_maps); ++i) { + if (format_maps[i].code_id == code_id) + break; + } + if (i == ARRAY_SIZE(format_maps)) + return -EINVAL; + *format = format_maps[i].format; + *frames_per_second = be32toh(header.frames_per_second); + *samples_per_frame = be32toh(header.samples_per_frame); + + state->code_id = code_id; + state->samples_per_frame = *samples_per_frame; + state->bytes_per_sample = snd_pcm_format_physical_width(*format) / 8; + + *byte_count = be32toh(header.data_size); + + return 0; +} + +struct builder_state { + unsigned int bytes_per_sample; + unsigned int samples_per_frame; + unsigned int frames_per_second; + enum code_id code_id; +}; + +static void build_container_header(struct builder_state *state, + struct container_header *header, + unsigned int frames_per_second, + uint64_t byte_count) +{ + memcpy(header->magic, AU_MAGIC, sizeof(header->magic)); + header->hdr_size = htobe32(sizeof(struct container_header)); + header->data_size = htobe32(byte_count); + header->code_id = htobe32(state->code_id); + header->frames_per_second = htobe32(frames_per_second); + header->samples_per_frame = htobe32(state->samples_per_frame); +} + +static int write_container_header(struct container_context *cntr, + uint64_t byte_count) +{ + struct builder_state *state = cntr->private_data; + struct container_header header; + + build_container_header(state, &header, state->frames_per_second, + byte_count); + + return container_recursive_write(cntr, &header, sizeof(header)); +} + +static int au_builder_pre_process(struct container_context *cntr, + snd_pcm_format_t *format, + unsigned int *samples_per_frame, + unsigned int *frames_per_second, + uint64_t *byte_count) +{ + struct builder_state *status = cntr->private_data; + int i; + + for (i = 0; i < ARRAY_SIZE(format_maps); ++i) { + if (format_maps[i].format == *format) + break; + } + if (i == ARRAY_SIZE(format_maps)) + return -EINVAL; + + status->code_id = format_maps[i].code_id; + status->bytes_per_sample = snd_pcm_format_physical_width(*format) / 8; + status->frames_per_second = *frames_per_second; + status->samples_per_frame = *samples_per_frame; + + return write_container_header(cntr, *byte_count); +} + +static int au_builder_post_process(struct container_context *cntr, + uint64_t handled_byte_count) +{ + int err; + + err = container_seek_offset(cntr, 0); + if (err < 0) + return err; + + return write_container_header(cntr, handled_byte_count); +} + +const struct container_parser container_parser_au = { + .format = CONTAINER_FORMAT_AU, + .magic = AU_MAGIC, + .max_size = UINT32_MAX, + .ops = { + .pre_process = au_parser_pre_process, + }, + .private_size = sizeof(struct parser_state), +}; + +const struct container_builder container_builder_au = { + .format = CONTAINER_FORMAT_AU, + .max_size = UINT32_MAX, + .ops = { + .pre_process = au_builder_pre_process, + .post_process = au_builder_post_process, + }, + .private_size = sizeof(struct builder_state), +}; diff --git a/axfer/container.c b/axfer/container.c index c20af463..0e208aba 100644 --- a/axfer/container.c +++ b/axfer/container.c @@ -21,10 +21,12 @@ static const char *const cntr_type_labels[] = {

static const char *const cntr_format_labels[] = { [CONTAINER_FORMAT_RIFF_WAVE] = "riff/wave", + [CONTAINER_FORMAT_AU] = "au", };

static const char *const suffixes[] = { - [CONTAINER_FORMAT_RIFF_WAVE] = ".wav", + [CONTAINER_FORMAT_RIFF_WAVE] = ".wav", + [CONTAINER_FORMAT_AU] = ".au", };

@@ -148,6 +150,7 @@ int container_parser_init(struct container_context *cntr, { const struct container_parser *parsers[] = { [CONTAINER_FORMAT_RIFF_WAVE] = &container_parser_riff_wave, + [CONTAINER_FORMAT_AU] = &container_parser_au, }; const struct container_parser *parser; unsigned int size; @@ -225,6 +228,7 @@ int container_builder_init(struct container_context *cntr, { const struct container_builder *builders[] = { [CONTAINER_FORMAT_RIFF_WAVE] = &container_builder_riff_wave, + [CONTAINER_FORMAT_AU] = &container_builder_au, }; const struct container_builder *builder; int err; diff --git a/axfer/container.h b/axfer/container.h index 3c27c26f..3042e1e9 100644 --- a/axfer/container.h +++ b/axfer/container.h @@ -26,6 +26,7 @@ enum container_type {

enum container_format { CONTAINER_FORMAT_RIFF_WAVE = 0, + CONTAINER_FORMAT_AU, CONTAINER_FORMAT_COUNT, };

@@ -111,4 +112,7 @@ int container_seek_offset(struct container_context *cntr, off64_t offset); extern const struct container_parser container_parser_riff_wave; extern const struct container_builder container_builder_riff_wave;

+extern const struct container_parser container_parser_au; +extern const struct container_builder container_builder_au; + #endif

This commit adds support for raw data without any headers/chunks/blocks. A parser of container cannot recognize format of sample without supplemental information.

Additionally, it includes no magic bytes. A parser of container should process first several bytes as a part of PCM frames, instead of magic bytes.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 3 ++- axfer/container-raw.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++ axfer/container.c | 39 +++++++++++++++++++++++++----- axfer/container.h | 4 ++++ 4 files changed, 105 insertions(+), 7 deletions(-) create mode 100644 axfer/container-raw.c

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index 48d046e1..f1ec1d1d 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -27,4 +27,5 @@ axfer_SOURCES = \ container.c \ container-riff-wave.c \ container-au.c \ - container-voc.c + container-voc.c \ + container-raw.c diff --git a/axfer/container-raw.c b/axfer/container-raw.c new file mode 100644 index 00000000..b5e11e44 --- /dev/null +++ b/axfer/container-raw.c @@ -0,0 +1,66 @@ +/* + * container-raw.c - a parser/builder for a container with raw data frame. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "container.h" +#include "misc.h" + +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> + +static int raw_builder_pre_process(struct container_context *cntr, + snd_pcm_format_t *sample_format, + unsigned int *samples_per_frame, + unsigned int *frames_per_second, + uint64_t *byte_count) +{ + *byte_count = UINT64_MAX; + + return 0; +} + +static int raw_parser_pre_process(struct container_context *cntr, + snd_pcm_format_t *sample_format, + unsigned int *samples_per_frame, + unsigned int *frames_per_second, + uint64_t *byte_count) +{ + struct stat buf = {0}; + int err; + + if (cntr->stdio) { + *byte_count = UINT64_MAX; + return 0; + } + + err = fstat(cntr->fd, &buf); + if (err < 0) + return err; + + *byte_count = buf.st_size; + if (*byte_count == 0) + *byte_count = UINT64_MAX; + + return 0; +} + +const struct container_parser container_parser_raw = { + .format = CONTAINER_FORMAT_RAW, + .max_size = UINT64_MAX, + .ops = { + .pre_process = raw_parser_pre_process, + }, +}; + +const struct container_builder container_builder_raw = { + .format = CONTAINER_FORMAT_RAW, + .max_size = UINT64_MAX, + .ops = { + .pre_process = raw_builder_pre_process, + }, +}; diff --git a/axfer/container.c b/axfer/container.c index 99652e65..bdaf99ab 100644 --- a/axfer/container.c +++ b/axfer/container.c @@ -23,15 +23,16 @@ static const char *const cntr_format_labels[] = { [CONTAINER_FORMAT_RIFF_WAVE] = "riff/wave", [CONTAINER_FORMAT_AU] = "au", [CONTAINER_FORMAT_VOC] = "voc", + [CONTAINER_FORMAT_RAW] = "raw", };

static const char *const suffixes[] = { [CONTAINER_FORMAT_RIFF_WAVE] = ".wav", [CONTAINER_FORMAT_AU] = ".au", [CONTAINER_FORMAT_VOC] = ".voc", + [CONTAINER_FORMAT_RAW] = "", };

- const char *const container_suffix_from_format(enum container_format format) { return suffixes[format]; @@ -112,7 +113,7 @@ enum container_format container_format_from_path(const char *path) }

/* Unsupported. */ - return CONTAINER_FORMAT_COUNT; + return CONTAINER_FORMAT_RAW; }

int container_seek_offset(struct container_context *cntr, off64_t offset) @@ -205,7 +206,7 @@ int container_parser_init(struct container_context *cntr, * Unless detected, use raw container. */ if (i == ARRAY_SIZE(parsers)) - return -EINVAL; + parser = &container_parser_raw;

/* Allocate private data for the parser. */ if (parser->private_size > 0) { @@ -233,6 +234,7 @@ int container_builder_init(struct container_context *cntr, [CONTAINER_FORMAT_RIFF_WAVE] = &container_builder_riff_wave, [CONTAINER_FORMAT_AU] = &container_builder_au, [CONTAINER_FORMAT_VOC] = &container_builder_voc, + [CONTAINER_FORMAT_RAW] = &container_builder_raw, }; const struct container_builder *builder; int err; @@ -311,6 +313,16 @@ int container_context_pre_process(struct container_context *cntr, return 0; }

+ if (cntr->format == CONTAINER_FORMAT_RAW) { + if (*format == SND_PCM_FORMAT_UNKNOWN || + *samples_per_frame == 0 || *frames_per_second == 0) { + fprintf(stderr, + "Any file format is not detected. Need to " + "indicate all of sample format, channels and " + "rate explicitly.\n"); + return -EINVAL; + } + } assert(*format >= SND_PCM_FORMAT_S8); assert(*format <= SND_PCM_FORMAT_LAST); assert(*samples_per_frame > 0); @@ -357,6 +369,7 @@ int container_context_process_frames(struct container_context *cntr, char *buf = frame_buffer; unsigned int bytes_per_frame; unsigned int byte_count; + unsigned int target_byte_count; int err;

assert(cntr); @@ -365,7 +378,21 @@ int container_context_process_frames(struct container_context *cntr, assert(frame_count);

bytes_per_frame = cntr->bytes_per_sample * cntr->samples_per_frame; - byte_count = *frame_count * bytes_per_frame; + target_byte_count = *frame_count * bytes_per_frame; + + /* + * A parser of cotainers already read first 4 bytes to detect format + * of container, however they includes PCM frames when any format was + * undetected. Surely to write out them. + */ + byte_count = target_byte_count; + if (cntr->format == CONTAINER_FORMAT_RAW && + cntr->type == CONTAINER_TYPE_PARSER && !cntr->magic_handled) { + memcpy(buf, cntr->magic, sizeof(cntr->magic)); + buf += sizeof(cntr->magic); + byte_count -= sizeof(cntr->magic); + cntr->magic_handled = true; + }

/* Each container has limitation for its volume for sample data. */ if (cntr->handled_byte_count > cntr->max_size - byte_count) @@ -379,11 +406,11 @@ int container_context_process_frames(struct container_context *cntr, return err; }

- cntr->handled_byte_count += byte_count; + cntr->handled_byte_count += target_byte_count; if (cntr->handled_byte_count == cntr->max_size) cntr->eof = true;

- *frame_count = byte_count / bytes_per_frame; + *frame_count = target_byte_count / bytes_per_frame;

return 0; } diff --git a/axfer/container.h b/axfer/container.h index caba7398..9825f48d 100644 --- a/axfer/container.h +++ b/axfer/container.h @@ -28,6 +28,7 @@ enum container_format { CONTAINER_FORMAT_RIFF_WAVE = 0, CONTAINER_FORMAT_AU, CONTAINER_FORMAT_VOC, + CONTAINER_FORMAT_RAW, CONTAINER_FORMAT_COUNT, };

@@ -119,4 +120,7 @@ extern const struct container_builder container_builder_au; extern const struct container_parser container_parser_voc; extern const struct container_builder container_builder_voc;

+const struct container_parser container_parser_raw; +const struct container_builder container_builder_raw; + #endif

In current aplay, several files can be handled as source of data frames for playback, or destination of captured data frames by an option '--separate-channels' (-I).

On the other hand, in ALSA PCM kernel/user interface, several types of buffer are used to communicate between application/hardware; - mapped page frame for data frames with interleaved alignment - mapped page frame for data frames with non-interleaved alignment - buffer in user space for data frames with interleaved alignment - a list of buffer in user space for data frames with non-interleaved alignment

This commit adds a common interface, named as 'mapper' to convert frame alignment between these two sides. This interface includes two types; 'muxer' and 'demuxer'. The 'muxer' is for playback direction, to construct playback buffer with PCM frames from several files. The 'demuxer' is for capture direction, to split PCM frames from capture buffer to each of file. Unlike multimedia containers such as MPEG 2/4 Systems, the 'muxer' and 'demuxer' are for playback/capture buffer, not for file contents.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 7 ++- axfer/mapper.c | 125 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ axfer/mapper.h | 79 ++++++++++++++++++++++++++++++++++ 3 files changed, 209 insertions(+), 2 deletions(-) create mode 100644 axfer/mapper.c create mode 100644 axfer/mapper.h

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index 55fcf716..cb4b188d 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -17,7 +17,8 @@ LDADD = \ noinst_HEADERS = \ misc.h \ subcmd.h \ - container.h + container.h \ + mapper.h

axfer_SOURCES = \ misc.h \ @@ -29,4 +30,6 @@ axfer_SOURCES = \ container-riff-wave.c \ container-au.c \ container-voc.c \ - container-raw.c + container-raw.c \ + mapper.h \ + mapper.c diff --git a/axfer/mapper.c b/axfer/mapper.c new file mode 100644 index 00000000..3073c713 --- /dev/null +++ b/axfer/mapper.c @@ -0,0 +1,125 @@ +/* + * mapper.c - an interface of muxer/demuxer between buffer with data frames and + * formatted files. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "mapper.h" +#include "misc.h" + +#include <stdio.h> + +static const char *const mapper_type_labels[] = { + [MAPPER_TYPE_MUXER] = "muxer", + [MAPPER_TYPE_DEMUXER] = "demuxer", +}; + +static const char *const mapper_target_labels[] = { + [MAPPER_TARGET_COUNT] = "", +}; + +int mapper_context_init(struct mapper_context *mapper, + enum mapper_type type, unsigned int cntr_count, + unsigned int verbose) +{ + const struct mapper_data *data = NULL; + + assert(mapper); + assert(cntr_count > 0); + + /* Detect forgotten to destruct. */ + assert(mapper->private_data == NULL); + + memset(mapper, 0, sizeof(*mapper)); + + mapper->ops = &data->ops; + mapper->type = type; + + mapper->private_data = malloc(data->private_size); + if (mapper->private_data == NULL) + return -ENOMEM; + memset(mapper->private_data, 0, data->private_size); + + mapper->cntr_count = cntr_count; + mapper->verbose = verbose; + + return 0; +} + +int mapper_context_pre_process(struct mapper_context *mapper, + snd_pcm_access_t access, + unsigned int bytes_per_sample, + unsigned int samples_per_frame, + unsigned int frames_per_buffer, + struct container_context *cntrs) +{ + int err; + + assert(mapper); + assert(access >= SND_PCM_ACCESS_MMAP_INTERLEAVED); + assert(access <= SND_PCM_ACCESS_RW_NONINTERLEAVED); + assert(bytes_per_sample > 0); + assert(samples_per_frame > 0); + assert(cntrs); + + mapper->access = access; + mapper->bytes_per_sample = bytes_per_sample; + mapper->samples_per_frame = samples_per_frame; + mapper->frames_per_buffer = frames_per_buffer; + + err = mapper->ops->pre_process(mapper, cntrs, mapper->cntr_count); + if (err < 0) + return err; + + if (mapper->verbose > 0) { + fprintf(stderr, "Mapper: %s\n", + mapper_type_labels[mapper->type]); + fprintf(stderr, " target: %s\n", + mapper_target_labels[mapper->target]); + fprintf(stderr, " access: %s\n", + snd_pcm_access_name(mapper->access)); + fprintf(stderr, " bytes/sample: %u\n", + mapper->bytes_per_sample); + fprintf(stderr, " samples/frame: %u\n", + mapper->samples_per_frame); + fprintf(stderr, " frames/buffer: %lu\n", + mapper->frames_per_buffer); + } + + return 0; +} + +int mapper_context_process_frames(struct mapper_context *mapper, + void *frame_buffer, + unsigned int *frame_count, + struct container_context *cntrs) +{ + assert(mapper); + assert(frame_buffer); + assert(frame_count); + assert(*frame_count <= mapper->frames_per_buffer); + assert(cntrs); + + return mapper->ops->process_frames(mapper, frame_buffer, frame_count, + cntrs, mapper->cntr_count); +} + +void mapper_context_post_process(struct mapper_context *mapper) +{ + assert(mapper); + + if (mapper->ops && mapper->ops->post_process) + mapper->ops->post_process(mapper); +} + +void mapper_context_destroy(struct mapper_context *mapper) +{ + assert(mapper); + + if (mapper->private_data) + free(mapper->private_data); + mapper->private_data = NULL; +} diff --git a/axfer/mapper.h b/axfer/mapper.h new file mode 100644 index 00000000..0a6c7f1c --- /dev/null +++ b/axfer/mapper.h @@ -0,0 +1,79 @@ +/* + * mapper.h - an interface of muxer/demuxer between buffer with data frames and + * formatted files. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#ifndef __ALSA_UTILS_AXFER_MAPPER__H_ +#define __ALSA_UTILS_AXFER_MAPPER__H_ + +#include "container.h" + +enum mapper_type { + MAPPER_TYPE_MUXER = 0, + MAPPER_TYPE_DEMUXER, + MAPPER_TYPE_COUNT, +}; + +enum mapper_target { + MAPPER_TARGET_COUNT, +}; + +struct mapper_ops; + +struct mapper_context { + enum mapper_type type; + enum mapper_target target; + const struct mapper_ops *ops; + unsigned int private_size; + + void *private_data; + unsigned int cntr_count; + + /* A part of parameters of PCM substream. */ + snd_pcm_access_t access; + unsigned int bytes_per_sample; + unsigned int samples_per_frame; + snd_pcm_uframes_t frames_per_buffer; + + unsigned int verbose; +}; + +int mapper_context_init(struct mapper_context *mapper, + enum mapper_type type, unsigned int cntr_count, + unsigned int verbose); +int mapper_context_pre_process(struct mapper_context *mapper, + snd_pcm_access_t access, + unsigned int bytes_per_sample, + unsigned int samples_per_frame, + unsigned int frames_per_buffer, + struct container_context *cntrs); +int mapper_context_process_frames(struct mapper_context *mapper, + void *frame_buffer, + unsigned int *frame_count, + struct container_context *cntrs); +void mapper_context_post_process(struct mapper_context *mapper); +void mapper_context_destroy(struct mapper_context *mapper); + +/* For internal use in 'mapper' module. */ + +struct mapper_ops { + int (*pre_process)(struct mapper_context *mapper, + struct container_context *cntrs, + unsigned int cntr_count); + int (*process_frames)(struct mapper_context *mapper, + void *frame_buffer, unsigned int *frame_count, + struct container_context *cntrs, + unsigned int cntr_count); + void (*post_process)(struct mapper_context *mapper); +}; + +struct mapper_data { + struct mapper_ops ops; + unsigned int private_size; +}; + +#endif

This commit adds support of mapper for 'multiple' target. This handles several files via 'container' functions, and constructs data frame buffer for playback, or splits data frames from data frame buffer for capture. When playback source files includes data frames with several channels, the first channel is used to construct buffer. For capture direction, each of channel of data frame is stored in one file, thus the file includes one channel of data frame. When handling non-interleaved buffer, a caller should use an array of buffer for each of channels with non-interleaved data frames.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 3 +- axfer/mapper-multiple.c | 271 ++++++++++++++++++++++++++++++++++++++++++++++++ axfer/mapper.c | 15 +++ axfer/mapper.h | 4 + 4 files changed, 292 insertions(+), 1 deletion(-) create mode 100644 axfer/mapper-multiple.c

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index baf9b898..f17e59b0 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -33,4 +33,5 @@ axfer_SOURCES = \ container-raw.c \ mapper.h \ mapper.c \ - mapper-single.c + mapper-single.c \ + mapper-multiple.c diff --git a/axfer/mapper-multiple.c b/axfer/mapper-multiple.c new file mode 100644 index 00000000..c40d0bd6 --- /dev/null +++ b/axfer/mapper-multiple.c @@ -0,0 +1,271 @@ +/* + * mapper-multiple.c - a muxer/demuxer for multiple containers. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "mapper.h" +#include "misc.h" + +struct multiple_state { + void (*align_frames)(void *frame_buf, unsigned int frame_count, + char **buf, unsigned int bytes_per_sample, + struct container_context *cntrs, + unsigned int cntr_count); + char **bufs; + unsigned int cntr_count; +}; + +static void align_to_i(void *frame_buf, unsigned int frame_count, + char **src_bufs, unsigned int bytes_per_sample, + struct container_context *cntrs, unsigned int cntr_count) +{ + char *dst = frame_buf; + char *src; + unsigned int dst_pos; + unsigned int src_pos; + struct container_context *cntr; + int i, j; + + /* + * src: first channel in each of interleaved buffers in containers => + * dst:interleaved. + */ + for (i = 0; i < cntr_count; ++i) { + src = src_bufs[i]; + cntr = cntrs + i; + + for (j = 0; j < frame_count; ++j) { + /* Use first src channel for each of dst channel. */ + src_pos = bytes_per_sample * cntr->samples_per_frame * j; + dst_pos = bytes_per_sample * (cntr_count * j + i); + + memcpy(dst + dst_pos, src + src_pos, bytes_per_sample); + } + } +} + +static void align_from_i(void *frame_buf, unsigned int frame_count, + char **dst_bufs, unsigned int bytes_per_sample, + struct container_context *cntrs, + unsigned int cntr_count) +{ + char *src = frame_buf; + char *dst; + unsigned int src_pos; + unsigned int dst_pos; + struct container_context *cntr; + int i, j; + + for (i = 0; i < cntr_count; ++i) { + dst = dst_bufs[i]; + cntr = cntrs + i; + + for (j = 0; j < frame_count; ++j) { + /* Use first src channel for each of dst channel. */ + src_pos = bytes_per_sample * (cntr_count * j + i); + dst_pos = bytes_per_sample * cntr->samples_per_frame * j; + + memcpy(dst + dst_pos, src + src_pos, bytes_per_sample); + } + } +} + +static int multiple_pre_process(struct mapper_context *mapper, + struct container_context *cntrs, + unsigned int cntr_count) +{ + struct multiple_state *state = mapper->private_data; + struct container_context *cntr; + int i; + + /* + * Additionally, format of samples in the containers should be the same + * as the format in PCM substream. + */ + for (i = 0; i < cntr_count; ++i) { + cntr = cntrs + i; + if (mapper->bytes_per_sample != cntr->bytes_per_sample) + return -EINVAL; + } + state->cntr_count = cntr_count; + + /* Decide method to align frames. */ + if (mapper->type == MAPPER_TYPE_DEMUXER) { + if (mapper->access == SND_PCM_ACCESS_RW_INTERLEAVED || + mapper->access == SND_PCM_ACCESS_MMAP_INTERLEAVED) + state->align_frames = align_from_i; + else if (mapper->access == SND_PCM_ACCESS_RW_NONINTERLEAVED || + mapper->access == SND_PCM_ACCESS_MMAP_NONINTERLEAVED) + state->align_frames = NULL; + else + return -EINVAL; + } else { + if (mapper->access == SND_PCM_ACCESS_RW_INTERLEAVED || + mapper->access == SND_PCM_ACCESS_MMAP_INTERLEAVED) + state->align_frames = align_to_i; + else if (mapper->access == SND_PCM_ACCESS_RW_NONINTERLEAVED || + mapper->access == SND_PCM_ACCESS_MMAP_NONINTERLEAVED) + state->align_frames = NULL; + else + return -EINVAL; + } + + if (state->align_frames) { + /* + * Furthermore, in demuxer case, each container should be + * configured to store one sample per frame. + */ + if (mapper->type == MAPPER_TYPE_DEMUXER) { + for (i = 0; i < cntr_count; ++i) { + cntr = cntrs + i; + if (cntrs->samples_per_frame != 1) + return -EINVAL; + } + } + + state->bufs = calloc(cntr_count, sizeof(char *)); + if (state->bufs == NULL) + return -ENOMEM; + + for (i = 0; i < cntr_count; ++i) { + unsigned int bytes_per_buffer; + + /* + * Allocate intermediate buffer as the same size as a + * period for each of containers. + */ + cntr = cntrs + i; + + bytes_per_buffer = mapper->bytes_per_sample * + cntr->samples_per_frame * + mapper->frames_per_buffer; + + state->bufs[i] = malloc(bytes_per_buffer); + if (state->bufs[i] == NULL) + return -ENOMEM; + memset(state->bufs[i], 0, bytes_per_buffer); + } + } + + return 0; +} + +static int process_containers(char **src_bufs, unsigned int *frame_count, + struct container_context *cntrs, + unsigned int cntr_count) +{ + struct container_context *cntr; + char *src; + int i; + int err = 0; + + /* TODO: arrangement for *frame_count. */ + for (i = 0; i < cntr_count; ++i) { + cntr = &cntrs[i]; + src = src_bufs[i]; + + err = container_context_process_frames(cntr, src, frame_count); + if (err < 0) + break; + } + + return err; +} + +static int multiple_muxer_process_frames(struct mapper_context *mapper, + void *frame_buf, + unsigned int *frame_count, + struct container_context *cntrs, + unsigned int cntr_count) +{ + struct multiple_state *state = mapper->private_data; + char **src_bufs; + int err; + + /* + * If need to align PCM frames, process PCM frames to the intermediate + * buffer once. + */ + if (!state->align_frames) { + /* The most likely. */ + src_bufs = frame_buf; + } else { + src_bufs = state->bufs; + } + err = process_containers(src_bufs, frame_count, cntrs, cntr_count); + if (err < 0) + return err; + + /* Unlikely. */ + if (src_bufs != frame_buf && *frame_count > 0) { + state->align_frames(frame_buf, *frame_count, src_bufs, + mapper->bytes_per_sample, cntrs, + cntr_count); + } + + return 0; +} + +static int multiple_demuxer_process_frames(struct mapper_context *mapper, + void *frame_buf, + unsigned int *frame_count, + struct container_context *cntrs, + unsigned int cntr_count) +{ + struct multiple_state *state = mapper->private_data; + char **dst_bufs; + + /* + * If need to align PCM frames, process PCM frames to the intermediate + * buffer once. + */ + if (!state->align_frames) { + /* The most likely. */ + dst_bufs = frame_buf; + } else { + dst_bufs = state->bufs; + state->align_frames(frame_buf, *frame_count, dst_bufs, + mapper->bytes_per_sample, cntrs, + cntr_count); + } + + return process_containers(dst_bufs, frame_count, cntrs, cntr_count); +} + +static void multiple_post_process(struct mapper_context *mapper) +{ + struct multiple_state *state = mapper->private_data; + int i; + + if (state->bufs) { + for (i = 0; i < state->cntr_count; ++i) { + if (state->bufs[i]) + free(state->bufs[i]); + } + free(state->bufs); + } + + state->bufs = NULL; + state->align_frames = NULL; +} + +const struct mapper_data mapper_muxer_multiple = { + .ops = { + .pre_process = multiple_pre_process, + .process_frames = multiple_muxer_process_frames, + .post_process = multiple_post_process, + }, + .private_size = sizeof(struct multiple_state), +}; + +const struct mapper_data mapper_demuxer_multiple = { + .ops = { + .pre_process = multiple_pre_process, + .process_frames = multiple_demuxer_process_frames, + .post_process = multiple_post_process, + }, + .private_size = sizeof(struct multiple_state), +}; diff --git a/axfer/mapper.c b/axfer/mapper.c index 3ba2d5e1..20baef85 100644 --- a/axfer/mapper.c +++ b/axfer/mapper.c @@ -19,6 +19,7 @@ static const char *const mapper_type_labels[] = {

static const char *const mapper_target_labels[] = { [MAPPER_TARGET_SINGLE] = "single", + [MAPPER_TARGET_MULTIPLE] = "multiple", };

int mapper_context_init(struct mapper_context *mapper, @@ -39,11 +40,17 @@ int mapper_context_init(struct mapper_context *mapper, if (cntr_count == 1) { data = &mapper_muxer_single; mapper->target = MAPPER_TARGET_SINGLE; + } else { + data = &mapper_muxer_multiple; + mapper->target = MAPPER_TARGET_MULTIPLE; } } else { if (cntr_count == 1) { data = &mapper_demuxer_single; mapper->target = MAPPER_TARGET_SINGLE; + } else { + data = &mapper_demuxer_multiple; + mapper->target = MAPPER_TARGET_MULTIPLE; } }

@@ -77,6 +84,14 @@ int mapper_context_pre_process(struct mapper_context *mapper, assert(samples_per_frame > 0); assert(cntrs);

+ /* + * The purpose of multiple target is to mux/demux each channels to/from + * containers. + */ + if (mapper->target == MAPPER_TARGET_MULTIPLE && + samples_per_frame != mapper->cntr_count) + return -EINVAL; + mapper->access = access; mapper->bytes_per_sample = bytes_per_sample; mapper->samples_per_frame = samples_per_frame; diff --git a/axfer/mapper.h b/axfer/mapper.h index 2e553666..3b32e93c 100644 --- a/axfer/mapper.h +++ b/axfer/mapper.h @@ -20,6 +20,7 @@ enum mapper_type {

enum mapper_target { MAPPER_TARGET_SINGLE = 0, + MAPPER_TARGET_MULTIPLE, MAPPER_TARGET_COUNT, };

@@ -80,4 +81,7 @@ struct mapper_data { extern const struct mapper_data mapper_muxer_single; extern const struct mapper_data mapper_demuxer_single;

+extern const struct mapper_data mapper_muxer_multiple; +extern const struct mapper_data mapper_demuxer_multiple; + #endif

In aplay, many command-line options are supported. Some of them have dependency or conflicts.

This commit adds a structure and a parser for the options. In this patch, minimal set of options is supported. Additional options will be supported later.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 5 +- axfer/options.c | 594 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ axfer/options.h | 47 +++++ 3 files changed, 645 insertions(+), 1 deletion(-) create mode 100644 axfer/options.c create mode 100644 axfer/options.h

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index f17e59b0..3b1a87c8 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -19,6 +19,7 @@ noinst_HEADERS = \ subcmd.h \ container.h \ mapper.h + options.h

axfer_SOURCES = \ misc.h \ @@ -34,4 +35,6 @@ axfer_SOURCES = \ mapper.h \ mapper.c \ mapper-single.c \ - mapper-multiple.c + mapper-multiple.c \ + options.h \ + options.c diff --git a/axfer/options.c b/axfer/options.c new file mode 100644 index 00000000..256f93a1 --- /dev/null +++ b/axfer/options.c @@ -0,0 +1,594 @@ +/* + * options.c - a parser of commandline options. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "options.h" +#include "misc.h" + +#include <getopt.h> +#include <math.h> + +static const char *const allowed_duplication[] = { + "/dev/null", + "/dev/zero", + "/dev/full", + "/dev/random", + "/dev/urandom", +}; + +static long parse_l(const char *str, int *err) +{ + long val; + char *endptr; + + val = strtol(str, &endptr, 10); + if (errno) + return -errno; + if (*endptr != '\0') + return -EINVAL; + + return val; +} + +static int allocate_paths(struct context_options *opts, char *const *paths, + unsigned int count) +{ + bool stdio = false; + char *path; + int i; + + if (count == 0) { + stdio = true; + count = 1; + } + + opts->paths = calloc(count, sizeof(opts->paths[0])); + if (opts->paths == NULL) + return -ENOMEM; + opts->path_count = count; + + if (stdio) { + opts->paths[0] = malloc(2); + if (opts->paths[0] == NULL) + return -ENOMEM; + strcpy(opts->paths[0], "-"); + return 0; + } + + for (i = 0; i < count; ++i) { + path = malloc(strlen(paths[i]) + 1); + if (path == NULL) + return -ENOMEM; + strcpy(path, paths[i]); + opts->paths[i] = path; + } + + return 0; +} + +static int verify_cntr_format(struct context_options *opts, const char *literal) +{ + static const struct { + const char *const literal; + enum container_format cntr_format; + } *entry, entries[] = { + {"raw", CONTAINER_FORMAT_RAW}, + {"voc", CONTAINER_FORMAT_VOC}, + {"wav", CONTAINER_FORMAT_RIFF_WAVE}, + {"au", CONTAINER_FORMAT_AU}, + {"sparc", CONTAINER_FORMAT_AU}, + }; + int i; + + for (i = 0; i < ARRAY_SIZE(entries); ++i) { + entry = &entries[i]; + if (strcasecmp(literal, entry->literal)) + continue; + + opts->cntr_format = entry->cntr_format; + return 0; + } + + fprintf(stderr, "unrecognized file format '%s'\n", literal); + + return -EINVAL; +} + +/* This should be called after 'verify_cntr_format()'. */ +static int verify_sample_format(struct context_options *opts, + const char *literal) +{ + static const struct { + const char *const literal; + unsigned int frames_per_second; + unsigned int samples_per_frame; + snd_pcm_format_t le_format; + snd_pcm_format_t be_format; + } *entry, entries[] = { + {"cd", 44100, 2, SND_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S16_BE}, + {"cdr", 44100, 2, SND_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S16_BE}, + {"dat", 48000, 2, SND_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S16_BE}, + }; + int i; + + opts->sample_format = snd_pcm_format_value(literal); + if (opts->sample_format != SND_PCM_FORMAT_UNKNOWN) + return 0; + + for (i = 0; i < ARRAY_SIZE(entries); ++i) { + entry = &entries[i]; + if (strcmp(entry->literal, literal)) + continue; + + if (opts->frames_per_second > 0 && + opts->frames_per_second != entry->frames_per_second) { + fprintf(stderr, + "'%s' format can't be used with rate except " + "for %u.\n", + entry->literal, entry->frames_per_second); + return -EINVAL; + } + + if (opts->samples_per_frame > 0 && + opts->samples_per_frame != entry->samples_per_frame) { + fprintf(stderr, + "'%s' format can't be used with channel except " + "for %u.\n", + entry->literal, entry->samples_per_frame); + return -EINVAL; + } + + opts->frames_per_second = entry->frames_per_second; + opts->samples_per_frame = entry->samples_per_frame; + if (opts->cntr_format == CONTAINER_FORMAT_AU) + opts->sample_format = entry->be_format; + else + opts->sample_format = entry->le_format; + + return 0; + } + + fprintf(stderr, "wrong extended format '%s'\n", literal); + + return -EINVAL; +} + +static int apply_policies(struct context_options *opts, + snd_pcm_stream_t direction, + const char *cntr_format_literal, + const char *node_literal, + const char *sample_format_literal) +{ + int err; + + if (node_literal != NULL) { + opts->node = malloc(strlen(node_literal) + 1); + if (opts->node == NULL) { + fprintf(stderr, "Fail to allocate for node: %s\n", + node_literal); + return -ENOMEM; + } + strcpy(opts->node, node_literal); + } + + if (!cntr_format_literal) { + if (direction == SND_PCM_STREAM_CAPTURE) { + /* To stdout. */ + if (opts->path_count == 1 && + !strcmp(opts->paths[0], "-")) { + opts->cntr_format = CONTAINER_FORMAT_RAW; + } else { + /* Use first path as a representative. */ + opts->cntr_format = container_format_from_path( + opts->paths[0]); + } + } + /* For playback, perform auto-detection. */ + } else { + err = verify_cntr_format(opts, cntr_format_literal); + if (err < 0) + return err; + } + + if (opts->samples_per_frame > 0) { + if (opts->samples_per_frame < 1 || + opts->samples_per_frame > 256) { + fprintf(stderr, "invalid channels argument '%u'\n", + opts->samples_per_frame); + return -EINVAL; + } + } + + if (opts->multiple_cntrs) { + if (!strcmp(opts->paths[0], "-")) { + fprintf(stderr, + "An option for separated channels is not " + "available with stdin/stdout.\n"); + return -EINVAL; + } + + /* + * For captured PCM frames, even if one path is given for + * container files, it can be used to generate several paths. + * For this purpose, please see + * 'context_options_fixup_for_capture()'. + */ + if (direction == SND_PCM_STREAM_PLAYBACK) { + /* Require several paths for containers. */ + if (opts->path_count == 1) { + fprintf(stderr, + "An option for separated channels " + "requires several files to playback " + "PCM frames.\n"); + return -EINVAL; + } + } + } else { + /* A single path is available only. */ + if (opts->path_count > 1) { + fprintf(stderr, + "When using several files, an option for " + "sepatated channels is used with.\n"); + return -EINVAL; + } + } + + if (opts->frames_per_second > 0) { + unsigned int orig = opts->frames_per_second; + + /* For backward compatibility. */ + if (opts->frames_per_second < 300) + opts->frames_per_second *= 300; + if (opts->frames_per_second < 2000 || + opts->frames_per_second > 192000) { + fprintf(stderr, "bad speed value '%i'\n", orig); + return -EINVAL; + } + } + + opts->sample_format = SND_PCM_FORMAT_UNKNOWN; + if (sample_format_literal) { + err = verify_sample_format(opts, sample_format_literal); + if (err < 0) + return err; + } + + return 0; +} + +int context_options_init(struct context_options *opts, int argc, + char *const *argv, snd_pcm_stream_t direction) +{ + static const char *s_opts = "hvt:ID:f:c:r:"; + static const struct option l_opts[] = { + /* For generic purposes. */ + {"help", 0, 0, 'h'}, + {"verbose", 0, 0, 'v'}, + /* For containers. */ + {"file-type", 1, 0, 't'}, + /* For mapper. */ + {"separate-channels", 0, 0, 'I'}, + /* For transfer backend. */ + {"device", 1, 0, 'D'}, + {"format", 1, 0, 'f'}, + {"channels", 1, 0, 'c'}, + {"rate", 1, 0, 'r'}, + {NULL, 0, 0, 0}, + }; + const char *cntr_format_literal = NULL; + const char *node_literal = NULL; + const char *sample_format_literal = NULL; + int c; + int err = 0; + + optind = 0; + opterr = 0; + while (1) { + c = getopt_long(argc, argv, s_opts, l_opts, NULL); + if (c < 0) + break; + else if (c == 'h') + opts->help = true; + else if (c == 'v') + ++opts->verbose; + else if (c == 't') + cntr_format_literal = optarg; + else if (c == 'I') + opts->multiple_cntrs = true; + else if (c == 'D') + node_literal = optarg; + else if (c == 'f') + sample_format_literal = optarg; + else if (c == 'c') + opts->samples_per_frame = parse_l(optarg, &err); + else if (c == 'r') + opts->frames_per_second = parse_l(optarg, &err); + else + continue; + + if (err < 0) + return err; + } + + err = allocate_paths(opts, argv + optind, argc - optind); + if (err < 0) + return err; + + return apply_policies(opts, direction, cntr_format_literal, + node_literal, sample_format_literal); +} + +static int generate_path_with_suffix(struct context_options *opts, + const char *template, unsigned int index, + const char *suffix) +{ + static const char *const single_format = "%s%s"; + static const char *const multiple_format = "%s-%i%s"; + unsigned int len; + + len = strlen(template) + strlen(suffix) + 1; + if (opts->path_count > 1) + len += (unsigned int)log10(opts->path_count) + 2; + + opts->paths[index] = malloc(len); + if (opts->paths[index] == NULL) + return -ENOMEM; + + if (opts->path_count == 1) { + snprintf(opts->paths[index], len, single_format, template, + suffix); + } else { + snprintf(opts->paths[index], len, multiple_format, template, + index, suffix); + } + + return 0; +} + +static int generate_path_without_suffix(struct context_options *opts, + const char *template, + unsigned int index, const char *suffix) +{ + static const char *const single_format = "%s"; + static const char *const multiple_format = "%s-%i"; + unsigned int len; + + len = strlen(template) + 1; + if (opts->path_count > 1) + len += (unsigned int)log10(opts->path_count) + 2; + + opts->paths[index] = malloc(len); + if (opts->paths[index] == NULL) + return -ENOMEM; + + if (opts->path_count == 1) { + snprintf(opts->paths[index], len, single_format, template); + } else { + snprintf(opts->paths[index], len, multiple_format, template, + index); + } + + return 0; +} + +static int generate_path(struct context_options *opts, char *template, + unsigned int index, const char *suffix) +{ + int (*generator)(struct context_options *opts, const char *template, + unsigned int index, const char *suffix); + char *pos; + + if (strlen(suffix) > 0) { + pos = template + strlen(template) - strlen(suffix); + /* Separate filename and suffix. */ + if (!strcmp(pos, suffix)) + *pos = '\0'; + } + + /* Select handlers. */ + if (strlen(suffix) > 0) + generator = generate_path_with_suffix; + else + generator = generate_path_without_suffix; + + return generator(opts, template, index, suffix); +} + +static int create_paths(struct context_options *opts, unsigned int path_count) +{ + char *template; + const char *suffix; + int i, j; + int err = 0; + + /* Can cause memory leak. */ + assert(opts->path_count == 1); + assert(opts->paths); + assert(opts->paths[0]); + assert(opts->paths[0][0] != '\0'); + + /* Release at first. */ + template = opts->paths[0]; + free(opts->paths); + opts->paths = NULL; + + /* Allocate again. */ + opts->paths = calloc(path_count, sizeof(*opts->paths)); + if (opts->paths == NULL) { + err = -ENOMEM; + goto end; + } + opts->path_count = path_count; + + suffix = container_suffix_from_format(opts->cntr_format); + + for (i = 0; i < opts->path_count; ++i) { + /* Some file names are allowed to be duplicated. */ + for (j = 0; j < ARRAY_SIZE(allowed_duplication); ++j) { + if (!strcmp(opts->paths[i], allowed_duplication[j])) + break; + } + if (j < ARRAY_SIZE(allowed_duplication)) + continue; + + err = generate_path(opts, template, i, suffix); + if (err < 0) + break; + } +end: + free(template); + + return err; +} + +static int fixup_paths(struct context_options *opts) +{ + const char *suffix; + char *template; + int i, j; + int err = 0; + + suffix = container_suffix_from_format(opts->cntr_format); + + for (i = 0; i < opts->path_count; ++i) { + /* Some file names are allowed to be duplicated. */ + for (j = 0; j < ARRAY_SIZE(allowed_duplication); ++j) { + if (!strcmp(opts->paths[i], allowed_duplication[j])) + break; + } + if (j < ARRAY_SIZE(allowed_duplication)) + continue; + + template = opts->paths[i]; + opts->paths[i] = NULL; + err = generate_path(opts, template, i, suffix); + free(template); + if (err < 0) + break; + } + + return err; +} + +int context_options_fixup_for_capture(struct context_options *opts, + unsigned int samples_per_frame) +{ + int i, j; + int err; + + if (!opts->multiple_cntrs) { + if (opts->path_count == 1) + err = fixup_paths(opts); + else + return -EINVAL; + } else { + if (opts->path_count == 1) { + err = create_paths(opts, samples_per_frame); + } else { + if (opts->path_count == samples_per_frame) + err = fixup_paths(opts); + else + return -EINVAL; + } + } + if (err < 0) + return err; + + /* Check duplication of the paths. */ + for (i = 0; i < opts->path_count - 1; ++i) { + /* Some file names are allowed to be duplicated. */ + for (j = 0; j < ARRAY_SIZE(allowed_duplication); ++j) { + if (!strcmp(opts->paths[i], allowed_duplication[j])) + break; + } + if (j < ARRAY_SIZE(allowed_duplication)) + continue; + + for (j = i + 1; j < opts->path_count; ++j) { + if (!strcmp(opts->paths[i], opts->paths[j])) { + fprintf(stderr, + "Detect duplicated file names:\n"); + err = -EINVAL; + break; + } + } + if (j < opts->path_count) + break; + } + + if (opts->verbose > 1) + fprintf(stderr, "Handled file names:\n"); + if (err < 0 || opts->verbose > 1) { + for (i = 0; i < opts->path_count; ++i) + fprintf(stderr, " %d: %s\n", i, opts->paths[i]); + } + + return err; +} + +int context_options_fixup_for_playback(struct context_options *opts, + snd_pcm_format_t sample_format, + unsigned int samples_per_frame, + unsigned int frames_per_second) +{ + if (opts->sample_format != SND_PCM_FORMAT_UNKNOWN) { + if (sample_format != opts->sample_format) { + fprintf(stderr, + "Sample format mismatch: %s is given but %s by " + "files\n", + snd_pcm_format_name(opts->sample_format), + snd_pcm_format_name(sample_format)); + return -EINVAL; + } + } + + if (opts->samples_per_frame > 0) { + if (samples_per_frame != opts->samples_per_frame) { + fprintf(stderr, + "The number of channels mismatch: %u is given " + "but %u by files\n", + opts->samples_per_frame, samples_per_frame); + return -EINVAL; + } + } + + if (opts->frames_per_second > 0) { + if (frames_per_second != opts->frames_per_second) { + fprintf(stderr, + "Sampling rate mismatch: %u is given but %u by " + "files\n", + opts->frames_per_second, frames_per_second); + return -EINVAL; + } + } + + if (opts->verbose > 1) { + int i; + + fprintf(stderr, "Handled file names:\n"); + for (i = 0; i < opts->path_count; ++i) { + fprintf(stderr, " %d: %s\n", i, opts->paths[i]); + } + } + + return 0; +} + +void context_options_destroy(struct context_options *opts) +{ + int i; + + if (opts->paths) { + for (i = 0; i < opts->path_count; ++i) + free(opts->paths[i]); + free(opts->paths); + } + if (opts->node) + free(opts->node); + opts->paths = NULL; + opts->node = NULL; +} diff --git a/axfer/options.h b/axfer/options.h new file mode 100644 index 00000000..38bdbb74 --- /dev/null +++ b/axfer/options.h @@ -0,0 +1,47 @@ +/* + * options.h - a header for a parser of commandline options. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#ifndef __ALSA_UTILS_AXFER_OPTIONS__H_ +#define __ALSA_UTILS_AXFER_OPTIONS__H_ + +#include "container.h" + +struct context_options { + bool help; + + /* For generic purposes. */ + unsigned int verbose; + + /* For containers. */ + char **paths; + unsigned int path_count; + enum container_format cntr_format; + + /* For mapper. */ + bool multiple_cntrs; + + /* For transfer backend. */ + char *node; + snd_pcm_format_t sample_format; + unsigned int samples_per_frame; + unsigned int frames_per_second; +}; + +int context_options_init(struct context_options *opts, int argc, + char *const *argv, snd_pcm_stream_t direction); +int context_options_fixup_for_playback(struct context_options *opts, + snd_pcm_format_t sample_format, + unsigned int samples_per_frame, + unsigned int frames_per_second); +int context_options_fixup_for_capture(struct context_options *opts, + unsigned int samples_per_frame); +void context_options_calculate_duration(struct context_options *opts, + unsigned int frames_per_second, uint64_t *total_frame_count); +void context_options_destroy(struct context_options *opts); + +#endif

This commit adds support fo alsa-lib PCM API as a backend of 'xfer' module. In a set of alsa-lib PCM API, there're two ways to handle data frames; by calling ioctl(2) with some specific commands and buffer in user space, or copying data frames on mapped page frames. To support these two ways, this commit adds operation structure.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 7 +- axfer/xfer-libasound.c | 374 +++++++++++++++++++++++++++++++++++++++++++++++++ axfer/xfer-libasound.h | 45 ++++++ axfer/xfer.c | 4 +- axfer/xfer.h | 4 +- 5 files changed, 428 insertions(+), 6 deletions(-) create mode 100644 axfer/xfer-libasound.c create mode 100644 axfer/xfer-libasound.h

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index c1534411..ab4e3ae1 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -20,7 +20,8 @@ noinst_HEADERS = \ container.h \ mapper.h options.h \ - xfer.h + xfer.h \ + xfer-alsa.h

axfer_SOURCES = \ misc.h \ @@ -40,4 +41,6 @@ axfer_SOURCES = \ options.h \ options.c \ xfer.h \ - xfer.c + xfer.c \ + xfer-libasound.h \ + xfer-libasound.c diff --git a/axfer/xfer-libasound.c b/axfer/xfer-libasound.c new file mode 100644 index 00000000..66e8e1de --- /dev/null +++ b/axfer/xfer-libasound.c @@ -0,0 +1,374 @@ +/* + * xfer-libasound.c - receive/transmit frames by alsa-lib. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "xfer-libasound.h" +#include "misc.h" + +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); + 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 int xfer_libasound_init(struct xfer_context *xfer, + snd_pcm_stream_t direction, + struct context_options *opts) +{ + struct libasound_state *state = xfer->private_data; + char *node; + int err; + + err = snd_output_stdio_attach(&state->log, stderr, 0); + if (err < 0) + return err; + + state->verbose = xfer->verbose > 1; + + if (opts->node == NULL) + node = "default"; + else + node = opts->node; + + err = snd_pcm_open(&state->handle, node, direction, 0); + if (err < 0) { + logging(state, "Fail to open libasound PCM node for %s: %s\n", + snd_pcm_stream_name(direction), node); + 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; + + /* TODO: Applying NO_PERIOD_WAKEUP should be done here. */ + + return set_access_hw_param(state->handle, state->hw_params, opts); +} + +static int configure_hw_params(struct libasound_state *state, + snd_pcm_format_t format, + unsigned int samples_per_frame, + unsigned int frames_per_second) +{ + int err; + + /* Configure sample format. */ + if (format == SND_PCM_FORMAT_UNKNOWN) { + snd_pcm_format_mask_t *mask; + + err = snd_pcm_format_mask_malloc(&mask); + if (err < 0) + return err; + snd_pcm_hw_params_get_format_mask(state->hw_params, mask); + for (format = 0; format <= SND_PCM_FORMAT_LAST; ++format) { + if (snd_pcm_format_mask_test(mask, format)) + break; + } + snd_pcm_format_mask_free(mask); + if (format > SND_PCM_FORMAT_LAST) { + logging(state, + "Any sample format is not available.\n"); + return -EINVAL; + } + } + err = snd_pcm_hw_params_set_format(state->handle, state->hw_params, + format); + if (err < 0) { + logging(state, + _("Sample format '%s' is not available: %s\n"), + snd_pcm_format_name(format), snd_strerror(err)); + return err; + } + + /* Configure channels. */ + if (samples_per_frame == 0) { + err = snd_pcm_hw_params_get_channels_min(state->hw_params, + &samples_per_frame); + if (err < 0) { + logging(state, + _("Any channel number is not available.\n")); + return err; + } + } + err = snd_pcm_hw_params_set_channels(state->handle, state->hw_params, + samples_per_frame); + if (err < 0) { + logging(state, + _("Channels count '%u' is not available: %s\n"), + samples_per_frame, snd_strerror(err)); + return err; + } + + /* Configure rate. */ + if (frames_per_second == 0) { + err = snd_pcm_hw_params_get_rate_min(state->hw_params, + &frames_per_second, NULL); + if (err < 0) { + logging(state, + _("Any rate is not available.\n")); + return err; + } + + } + err = snd_pcm_hw_params_set_rate(state->handle, state->hw_params, + frames_per_second, 0); + if (err < 0) { + logging(state, + _("Sampling rate '%u' is not available: %s\n"), + frames_per_second, snd_strerror(err)); + return err; + } + + return snd_pcm_hw_params(state->handle, state->hw_params); +} + +static int retrieve_actual_hw_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 int configure_sw_params(struct libasound_state *state, + unsigned int frames_per_second, + unsigned int frames_per_buffer) +{ + return snd_pcm_sw_params(state->handle, state->sw_params); +} + +static int xfer_libasound_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 libasound_state *state = xfer->private_data; + int err; + + if (state->handle == NULL) + return -ENXIO; + + err = configure_hw_params(state, *format, *samples_per_frame, + *frames_per_second); + if (err < 0) { + logging(state, _("Current hardware parameters:\n")); + snd_pcm_hw_params_dump(state->hw_params, state->log); + return err; + } + + /* Retrieve actual parameters. */ + err = retrieve_actual_hw_params(state->hw_params, format, + samples_per_frame, frames_per_second, + access, frames_per_buffer); + if (err < 0) + return err; + + /* 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->ops->private_size > 0) { + state->private_data = malloc(state->ops->private_size); + if (state->private_data == NULL) + return -ENOMEM; + memset(state->private_data, 0, state->ops->private_size); + } + err = state->ops->pre_process(state); + if (err < 0) + return err; + + err = configure_sw_params(state, *frames_per_second, + *frames_per_buffer); + if (err < 0) { + logging(state, _("Current software parameters:\n")); + snd_pcm_sw_params_dump(state->sw_params, state->log); + return err; + } + + if (xfer->verbose > 0) + snd_pcm_dump(state->handle, state->log); + + return 0; +} + +static int xfer_libasound_process_frames(struct xfer_context *xfer, + unsigned int *frame_count, + struct mapper_context *mapper, + struct container_context *cntrs) +{ + struct libasound_state *state = xfer->private_data; + int err; + + if (state->handle == NULL) + return -ENXIO; + + err = state->ops->process_frames(state, frame_count, mapper, cntrs); + if (err < 0) { + if (err == -EPIPE) { + /* + * Recover the stream and continue processing + * immediately. In this program -EPIPE comes from + * libasound implementation instead of file I/O. + */ + + err = snd_pcm_prepare(state->handle); + } + + if (err < 0) { + /* + * TODO: -EIO from libasound for hw PCM node means + * that IRQ disorder. This should be reported to help + * developers for drivers. + */ + logging(state, "Fail to process frames: %s\n", + snd_strerror(err)); + } + } + + return err; +} + +static void xfer_libasound_pause(struct xfer_context *xfer, bool enable) +{ + struct libasound_state *state = xfer->private_data; + snd_pcm_state_t s = snd_pcm_state(state->handle); + int err; + + if (state->handle == NULL) + return; + + 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 && state->verbose) { + logging(state, "snd_pcm_pause(): %s\n", snd_strerror(err)); + } +} + +static void xfer_libasound_post_process(struct xfer_context *xfer) +{ + struct libasound_state *state = xfer->private_data; + snd_pcm_state_t pcm_state; + int err; + + if (state->handle == NULL) + return; + + 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) + logging(state, "snd_pcm_drop(): %s\n", + snd_strerror(err)); + } else { + err = snd_pcm_drain(state->handle); + if (err < 0) + logging(state, "snd_pcm_drain(): %s\n", + snd_strerror(err)); + } + } + + err = snd_pcm_hw_free(state->handle); + if (err < 0) + logging(state, "snd_pcm_hw_free(): %s\n", snd_strerror(err)); + + snd_pcm_close(state->handle); + state->handle = NULL; + + if (state->ops && state->ops->post_process) + state->ops->post_process(state); + if (state->private_data) + free(state->private_data); + state->private_data = NULL; +} + +static void xfer_libasound_destroy(struct xfer_context *xfer) +{ + struct libasound_state *state = xfer->private_data; + + 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; + + if (state->log) + snd_output_close(state->log); + state->log = NULL; +} + +const struct xfer_data xfer_libasound = { + .ops = { + .init = xfer_libasound_init, + .pre_process = xfer_libasound_pre_process, + .process_frames = xfer_libasound_process_frames, + .pause = xfer_libasound_pause, + .post_process = xfer_libasound_post_process, + .destroy = xfer_libasound_destroy, + }, + .private_size = sizeof(struct libasound_state), +}; diff --git a/axfer/xfer-libasound.h b/axfer/xfer-libasound.h new file mode 100644 index 00000000..72807cdd --- /dev/null +++ b/axfer/xfer-libasound.h @@ -0,0 +1,45 @@ +/* + * xfer-libasound.h - a header for receiver/transmitter of frames by alsa-lib. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#ifndef __ALSA_UTILS_AXFER_XFER_LIBASOUND__H_ +#define __ALSA_UTILS_AXFER_XFER_LIBASOUND__H_ + +#include "xfer.h" + +#define logging(state, ...) \ + snd_output_printf(state->log, __VA_ARGS__) + +struct xfer_libasound_ops; + +struct libasound_state { + snd_pcm_t *handle; + snd_output_t *log; + + snd_pcm_hw_params_t *hw_params; + + snd_pcm_sw_params_t *sw_params; + + bool running; + + const struct xfer_libasound_ops *ops; + void *private_data; + + bool verbose; +}; + +struct xfer_libasound_ops { + int (*pre_process)(struct libasound_state *state); + int (*process_frames)(struct libasound_state *state, + unsigned int *frame_count, + struct mapper_context *mapper, + struct container_context *cntrs); + void (*post_process)(struct libasound_state *state); + unsigned int private_size; +}; + +#endif diff --git a/axfer/xfer.c b/axfer/xfer.c index 46b36d42..4677bd5b 100644 --- a/axfer/xfer.c +++ b/axfer/xfer.c @@ -12,7 +12,7 @@ #include <stdio.h>

static const char *const xfer_type_labels[] = { - [XFER_TYPE_COUNT] = "", + [XFER_TYPE_LIBASOUND] = "libasound", };

int xfer_context_init(struct xfer_context *xfer, enum xfer_type type, @@ -22,7 +22,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_COUNT, NULL}, + {XFER_TYPE_LIBASOUND, &xfer_libasound}, }; int i;

diff --git a/axfer/xfer.h b/axfer/xfer.h index 4e3f1f37..b90c005b 100644 --- a/axfer/xfer.h +++ b/axfer/xfer.h @@ -13,7 +13,7 @@ #include "options.h"

enum xfer_type { - XFER_TYPE_COUNT, + XFER_TYPE_LIBASOUND = 0, };

struct xfer_ops; @@ -66,6 +66,6 @@ struct xfer_data { unsigned int private_size; };

-extern const struct xfer_data xfer_alsa; +extern const struct xfer_data xfer_libasound;

#endif

In current aplay, default action is to transfer data frames from/to devices. This commit adds support for this functionality.

Event loop is included in an added file. In the loop, the number of handled data frames is manipulated by an appropriate way. As a result, users can stop data transmission frames by frame.

At present, below command line options are supported as a minimal set: * --help (-h) * Just output 'help' string (not written yet). * --verbose (-v) * For verbose output, including information about xfer, mapper and container. * --file-type (-f): string. one of ['wav'|'au'|'voc'|'raw'] * For format of files of given paths. For playback, this is optional because the format is auto-detected. For capture, this is optional too because the format is decided according to suffix of given path. Anyway, this option is used for cases to fail to detect or decide. * --separate-channels (-I) * When using several files as source or destination for data transmission, this option can be used with several file paths. * --device (-D): string * For PCM node in alsa-lib configuration. When this option is not used, 'default' node is used for data transmission. * --format (-f): string. format literals or one of ['cd'|'cdr'|'dat'] * For sample format supported by ALSA PCM interface. Special format can be used. For playback, this is auto-detected according to actual file format. * --channels (-c) * For the number of samples included in one data frame. For playback, this is auto-detected according to actual file format, except for 'raw' format. * --rate (-r) * For the number of data frames transferred in one second. For playback, this is auto-detected according to actual file format, except for 'raw' format.

When '--separate-channels' option is used, users can give several file paths to source/destination of data transmission, else they can give single file path for the purpose. When multiple files are handled by this option, for playback, data frames in first channel is used to construct buffer for data transmission with multi channel. For capture, data frames in each channel of buffer is written to each of given path. Furthermore, when a single path is given for capture, file paths are auto-generated according to available number of channels. For example, 'name.wav' is given for 2 channels capture, 'name-0.wav' and 'name-1.wav' are generated. Without suffix, 'name-0' and 'name-1' are generated.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 3 +- axfer/main.c | 2 +- axfer/subcmd-transfer.c | 470 ++++++++++++++++++++++++++++++++++++++++++++++++ axfer/subcmd.h | 2 + 4 files changed, 475 insertions(+), 2 deletions(-) create mode 100644 axfer/subcmd-transfer.c

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index e928f796..b378442b 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -44,4 +44,5 @@ axfer_SOURCES = \ xfer.c \ xfer-libasound.h \ xfer-libasound.c \ - xfer-libasound-irq-rw.c + xfer-libasound-irq-rw.c \ + subcmd-transfer.c diff --git a/axfer/main.c b/axfer/main.c index 9bf02fd9..fecf397a 100644 --- a/axfer/main.c +++ b/axfer/main.c @@ -180,7 +180,7 @@ int main(int argc, char *const *argv) decide_subcmd(argc, argv, &subcmd);

if (subcmd == SUBCMD_TRANSFER) - printf("execute 'transfer' subcmd.\n"); + err = subcmd_transfer(argc, argv, direction); else if (subcmd == SUBCMD_LIST) err = subcmd_list(argc, argv, direction); else if (subcmd == SUBCMD_VERSION) diff --git a/axfer/subcmd-transfer.c b/axfer/subcmd-transfer.c new file mode 100644 index 00000000..5ce312e0 --- /dev/null +++ b/axfer/subcmd-transfer.c @@ -0,0 +1,470 @@ +/* + * subcmd-transfer.c - operations for transfer sub command. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "xfer.h" +#include "subcmd.h" +#include "misc.h" + +#include <signal.h> + +struct context { + struct xfer_context xfer; + struct mapper_context mapper; + struct container_context *cntrs; + unsigned int cntr_count; + + struct context_options opts; + + /* NOTE: To handling Unix signal. */ + bool interrupted; + int signal; +}; + +/* NOTE: To handling Unix signal. */ +static struct context *ctx_ptr; + +static void handle_unix_signal_for_finish(int sig) +{ + int i; + + for (i = 0; i < ctx_ptr->cntr_count; ++i) + ctx_ptr->cntrs[i].interrupted = true; + + ctx_ptr->signal = sig; + ctx_ptr->interrupted = true; +} + +static void handle_unix_signal_for_suspend(int sig) +{ + sigset_t curr, prev; + struct sigaction sa = {0}; + + /* + * 1. suspend substream. + */ + xfer_context_pause(&ctx_ptr->xfer, true); + + /* + * 2. Prepare for default handler(SIG_DFL) of SIGTSTP to stop this + * process. + */ + if (sigaction(SIGTSTP, NULL, &sa) < 0) { + fprintf(stderr, "sigaction(2)\n"); + exit(EXIT_FAILURE); + } + if (sa.sa_handler == SIG_ERR) + exit(EXIT_FAILURE); + if (sa.sa_handler == handle_unix_signal_for_suspend) + sa.sa_handler = SIG_DFL; + if (sigaction(SIGTSTP, &sa, NULL) < 0) { + fprintf(stderr, "sigaction(2)\n"); + exit(EXIT_FAILURE); + } + + /* Queue SIGTSTP. */ + raise(SIGTSTP); + + /* + * Release the queued signal from being blocked. This causes an + * additional interrupt for the default handler. + */ + sigemptyset(&curr); + sigaddset(&curr, SIGTSTP); + if (sigprocmask(SIG_UNBLOCK, &curr, &prev) < 0) { + fprintf(stderr, "sigprocmask(2)\n"); + exit(EXIT_FAILURE); + } + + /* + * 3. SIGCONT is cought and rescheduled. Recover blocking status of + * UNIX signals. + */ + if (sigprocmask(SIG_SETMASK, &prev, NULL) < 0) { + fprintf(stderr, "sigprocmask(2)\n"); + exit(EXIT_FAILURE); + } + + /* Reconfigure this handler for SIGTSTP, instead of default one. */ + sigemptyset(&sa.sa_mask); + sa.sa_flags = SA_RESTART; + sa.sa_handler = handle_unix_signal_for_suspend; + if (sigaction(SIGTSTP, &sa, NULL) < 0) { + fprintf(stderr, "sigaction(2)\n"); + exit(EXIT_FAILURE); + } + + /* 4. Continue the PCM substream. */ + xfer_context_pause(&ctx_ptr->xfer, false); +} + +static int prepare_signal_handler(struct context *ctx) +{ + struct sigaction sa = {0}; + + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + sa.sa_handler = handle_unix_signal_for_finish; + + if (sigaction(SIGINT, &sa, NULL) < 0) + return -errno; + if (sigaction(SIGTERM, &sa, NULL) < 0) + return -errno; + + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + sa.sa_handler = handle_unix_signal_for_suspend; + if (sigaction(SIGTSTP, &sa, NULL) < 0) + return -errno; + + ctx_ptr = ctx; + + return 0; +} + +static int context_init(struct context *ctx, snd_pcm_stream_t direction) +{ + /* Initialize transfer. */ + return xfer_context_init(&ctx->xfer, XFER_TYPE_LIBASOUND, direction, + &ctx->opts); +} + +static int capture_pre_process(struct context *ctx, snd_pcm_access_t *access, + snd_pcm_format_t *sample_format, + unsigned int *samples_per_frame, + unsigned int *frames_per_second, + snd_pcm_uframes_t *frames_per_buffer, + uint64_t *total_frame_count) +{ + unsigned int channels; + int i; + int err; + + /* + * Use given options for common parameters. Else, leave the decition to + * each backend. + */ + if (ctx->opts.sample_format != SND_PCM_FORMAT_UNKNOWN) + *sample_format = ctx->opts.sample_format; + if (ctx->opts.samples_per_frame > 0) + *samples_per_frame = ctx->opts.samples_per_frame; + if (ctx->opts.frames_per_second > 0) + *frames_per_second = ctx->opts.frames_per_second; + + err = xfer_context_pre_process(&ctx->xfer, sample_format, + samples_per_frame, frames_per_second, + access, frames_per_buffer); + if (err < 0) + return err; + + err = context_options_fixup_for_capture(&ctx->opts, *samples_per_frame); + if (err < 0) + return err; + + ctx->cntr_count = ctx->opts.path_count; + if (ctx->cntr_count > 1) + channels = 1; + else + channels = *samples_per_frame; + + /* Prepare for containers. */ + ctx->cntrs = calloc(ctx->cntr_count, sizeof(*ctx->cntrs)); + if (ctx->cntrs == NULL) + return -ENOMEM; + + *total_frame_count = 0; + for (i = 0; i < ctx->cntr_count; ++i) { + uint64_t frame_count; + + err = container_builder_init(ctx->cntrs + i, ctx->opts.paths[i], + ctx->opts.cntr_format, + ctx->opts.verbose > 1); + if (err < 0) + return err; + + err = container_context_pre_process(ctx->cntrs + i, + sample_format, &channels, + frames_per_second, + &frame_count); + if (err < 0) + return err; + + if (*total_frame_count == 0) + *total_frame_count = frame_count; + if (frame_count < *total_frame_count) + *total_frame_count = frame_count; + } + + return 0; +} + +static int playback_pre_process(struct context *ctx, snd_pcm_access_t *access, + snd_pcm_format_t *sample_format, + unsigned int *samples_per_frame, + unsigned int *frames_per_second, + snd_pcm_uframes_t *frames_per_buffer, + uint64_t *total_frame_count) +{ + int i; + int err; + + /* Prepare for containers. */ + ctx->cntrs = calloc(ctx->opts.path_count, sizeof(*ctx->cntrs)); + if (ctx->cntrs == NULL) + return -ENOMEM; + ctx->cntr_count = ctx->opts.path_count; + + for (i = 0; i < ctx->cntr_count; ++i) { + snd_pcm_format_t format; + unsigned int channels; + unsigned int rate; + uint64_t frame_count; + + err = container_parser_init(ctx->cntrs + i, ctx->opts.paths[i], + ctx->opts.verbose > 1); + if (err < 0) + return err; + + if (i == 0) { + /* For a raw container. */ + format = ctx->opts.sample_format; + channels = ctx->opts.samples_per_frame; + rate = ctx->opts.frames_per_second; + } else { + format = *sample_format; + channels = *samples_per_frame; + rate = *frames_per_second; + } + + err = container_context_pre_process(ctx->cntrs + i, &format, + &channels, &rate, + &frame_count); + if (err < 0) + return err; + + if (format == SND_PCM_FORMAT_UNKNOWN || channels == 0 || + rate == 0) { + fprintf(stderr, + _("Sample format, channels and rate should be " + "indicated for given files.\n")); + return -EINVAL; + } + + if (i == 0) { + *sample_format = format; + *samples_per_frame = channels; + *frames_per_second = rate; + *total_frame_count = frame_count; + } else { + if (format != *sample_format) { + fprintf(stderr, + _("When using several files, they " + "should include the same sample " + "format.\n")); + return -EINVAL; + } + /* + * No need to check channels to handle multiple + * containers. + */ + if (rate != *frames_per_second) { + fprintf(stderr, + _("When using several files, they " + "should include samples at the same " + "sampling rate.\n")); + return -EINVAL; + } + if (frame_count < *total_frame_count) + *total_frame_count = frame_count; + } + } + + if (ctx->cntr_count > 1) + *samples_per_frame = ctx->cntr_count; + err = context_options_fixup_for_playback(&ctx->opts, *sample_format, + *samples_per_frame, + *frames_per_second); + if (err < 0) + return err; + + /* Configure hardware with these parameters. */ + err = xfer_context_pre_process(&ctx->xfer, sample_format, + samples_per_frame, frames_per_second, + access, frames_per_buffer); + if (err < 0) + return err; + + return 0; +} + +static int context_pre_process(struct context *ctx, snd_pcm_stream_t direction, + uint64_t *total_frame_count) +{ + snd_pcm_access_t access; + snd_pcm_format_t sample_format = SND_PCM_FORMAT_UNKNOWN; + unsigned int samples_per_frame = 0; + unsigned int frames_per_second = 0; + snd_pcm_uframes_t frames_per_buffer = 0; + unsigned int bytes_per_sample = 0; + enum mapper_type mapper_type; + int err; + + if (direction == SND_PCM_STREAM_CAPTURE) { + mapper_type = MAPPER_TYPE_DEMUXER; + err = capture_pre_process(ctx, &access, &sample_format, + &samples_per_frame, + &frames_per_second, + &frames_per_buffer, + total_frame_count); + } else { + mapper_type = MAPPER_TYPE_MUXER; + err = playback_pre_process(ctx, &access, &sample_format, + &samples_per_frame, + &frames_per_second, + &frames_per_buffer, + total_frame_count); + } + if (err < 0) + return err; + + /* Prepare for mapper. */ + err = mapper_context_init(&ctx->mapper, mapper_type, ctx->cntr_count, + ctx->opts.verbose > 1); + if (err < 0) + return err; + + bytes_per_sample = snd_pcm_format_physical_width(sample_format) / 8; + if (bytes_per_sample <= 0) + return -ENXIO; + err = mapper_context_pre_process(&ctx->mapper, access, bytes_per_sample, + samples_per_frame, frames_per_buffer, + ctx->cntrs); + if (err < 0) + return err; + + ctx->opts.sample_format = sample_format; + ctx->opts.samples_per_frame = samples_per_frame; + ctx->opts.frames_per_second = frames_per_second; + + return 0; +} + +static int context_process_frames(struct context *ctx, + snd_pcm_stream_t direction, + uint64_t expected_frame_count, + uint64_t *actual_frame_count) +{ + bool verbose = ctx->opts.verbose > 2; + unsigned int frame_count; + int i; + int err = 0; + + *actual_frame_count = 0; + while (!ctx->interrupted) { + struct container_context *cntr; + + /* Tell remains to expected frame count. */ + frame_count = expected_frame_count - *actual_frame_count; + err = xfer_context_process_frames(&ctx->xfer, &ctx->mapper, + ctx->cntrs, &frame_count); + if (err < 0) { + if (err == -EAGAIN || err == -EINTR) + continue; + break; + } + if (verbose) { + fprintf(stderr, + " handled: %u\n", frame_count); + } + for (i = 0; i < ctx->cntr_count; ++i) { + cntr = &ctx->cntrs[i]; + if (cntr->eof) + break; + } + if (i < ctx->cntr_count) + break; + + *actual_frame_count += frame_count; + if (*actual_frame_count >= expected_frame_count) + break; + } + + return err; +} + +static void context_post_process(struct context *ctx, + uint64_t accumulated_frame_count) +{ + uint64_t total_frame_count; + int i; + + xfer_context_post_process(&ctx->xfer); + + if (ctx->cntrs) { + for (i = 0; i < ctx->cntr_count; ++i) { + container_context_post_process(ctx->cntrs + i, + &total_frame_count); + container_context_destroy(ctx->cntrs + i); + } + free(ctx->cntrs); + } + + mapper_context_post_process(&ctx->mapper); + mapper_context_destroy(&ctx->mapper); +} + +static void context_destroy(struct context *ctx) +{ + xfer_context_destroy(&ctx->xfer); + context_options_destroy(&ctx->opts); +} + +int subcmd_transfer(int argc, char *const *argv, snd_pcm_stream_t direction) +{ + struct context ctx = {0}; + + uint64_t expected_frame_count = 0; + uint64_t actual_frame_count = 0; + + int err = 0; + + /* Renewed command system. */ + if (argc > 2 && !strcmp(argv[1], "transfer")) { + /* Go ahead to parse file paths properly. */ + --argc; + ++argv; + } + + err = context_options_init(&ctx.opts, argc, argv, direction); + if (err < 0) + return err; + if (ctx.opts.help) { + printf("xfer help.\n"); + return 0; + } + + err = prepare_signal_handler(&ctx); + if (err < 0) + return err; + + err = context_init(&ctx, direction); + if (err < 0) + goto end; + + err = context_pre_process(&ctx, direction, &expected_frame_count); + if (err < 0) + goto end; + + err = context_process_frames(&ctx, direction, expected_frame_count, + &actual_frame_count); +end: + context_post_process(&ctx, actual_frame_count); + + context_destroy(&ctx); + + return err; +} diff --git a/axfer/subcmd.h b/axfer/subcmd.h index 940d6814..25bfa4f8 100644 --- a/axfer/subcmd.h +++ b/axfer/subcmd.h @@ -13,4 +13,6 @@

int subcmd_list(int argc, char *const *argv, snd_pcm_stream_t direction);

+int subcmd_transfer(int argc, char *const *argv, snd_pcm_stream_t direction); + #endif

In ALSA PCM interface, before configuring hardware actually, applications can request available set of hardware parameters for runtime of PCM substream. The set of parameters are represented and delivered by a structure.

In alsa-lib PCM API, the above design is abstracted by a series of snd_pcm_hw_params_xxx() functions. An actual layout of the structure is hidden from applications by an opaque pointer.

In aplay, '--dump-hw-params' option is for this purpose. With this option, the command output available set of the hardware parameters.

This commit adds support for the option. Unlike aplay, this commit takes this program to finish after dumping the parameters for simplicity of usage.

I note that all of combinations in the set are not necessarily available when the PCM substream includes dependencies of parameters described by constraints and rules.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/options.c | 9 +++++++++ axfer/options.h | 3 +++ axfer/subcmd-transfer.c | 2 ++ axfer/xfer-libasound.c | 11 +++++++++++ 4 files changed, 25 insertions(+)

diff --git a/axfer/options.c b/axfer/options.c index 6154c0c2..08a047dd 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -12,6 +12,11 @@ #include <getopt.h> #include <math.h>

+enum no_short_opts { + /* 128 belongs to non us-ascii character set. */ + OPT_DUMP_HW_PARAMS = 128, +}; + static const char *const allowed_duplication[] = { "/dev/null", "/dev/zero", @@ -278,6 +283,8 @@ int context_options_init(struct context_options *opts, int argc, {"format", 1, 0, 'f'}, {"channels", 1, 0, 'c'}, {"rate", 1, 0, 'r'}, + /* For debugging. */ + {"dump-hw-params", 0, 0, OPT_DUMP_HW_PARAMS}, {NULL, 0, 0, 0}, }; const char *cntr_format_literal = NULL; @@ -310,6 +317,8 @@ int context_options_init(struct context_options *opts, int argc, opts->samples_per_frame = parse_l(optarg, &err); else if (c == 'r') opts->frames_per_second = parse_l(optarg, &err); + else if (c == OPT_DUMP_HW_PARAMS) + opts->dump_hw_params = true; else continue;

diff --git a/axfer/options.h b/axfer/options.h index 9c9b46d7..743279af 100644 --- a/axfer/options.h +++ b/axfer/options.h @@ -31,6 +31,9 @@ struct context_options { snd_pcm_format_t sample_format; unsigned int samples_per_frame; unsigned int frames_per_second; + + /* For debugging. */ + bool dump_hw_params; };

int context_options_init(struct context_options *opts, int argc, diff --git a/axfer/subcmd-transfer.c b/axfer/subcmd-transfer.c index 25fa6715..317a57e3 100644 --- a/axfer/subcmd-transfer.c +++ b/axfer/subcmd-transfer.c @@ -481,6 +481,8 @@ int subcmd_transfer(int argc, char *const *argv, snd_pcm_stream_t direction) err = context_init(&ctx, direction); if (err < 0) goto end; + if (ctx.opts.dump_hw_params) + goto end;

err = context_pre_process(&ctx, direction, &expected_frame_count); if (err < 0) diff --git a/axfer/xfer-libasound.c b/axfer/xfer-libasound.c index 52451fff..f75dc176 100644 --- a/axfer/xfer-libasound.c +++ b/axfer/xfer-libasound.c @@ -67,6 +67,17 @@ static int xfer_libasound_init(struct xfer_context *xfer,

/* TODO: Applying NO_PERIOD_WAKEUP should be done here. */

+ if (opts->dump_hw_params) { + logging(state, _("Available HW Params of node: %s\n"), + snd_pcm_name(state->handle)); + snd_pcm_hw_params_dump(state->hw_params, state->log); + /* + * TODO: there're more parameters which are not dumped by + * alsa-lib. + */ + return 0; + } + return set_access_hw_param(state->handle, state->hw_params, opts); }

In aplay, '--fatal-errors' option has an effect to give up recovery of PCM substream from XRUN state. This commit adds support for this option.

In original implementation, this option brings program abort. This seems to generate core dump of process VMA. However, typically, XRUN comes from timing mismatch between hardware and application, therefore core dump has less helpful. This commit finishes this program in usual way with this option at XRUN.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/options.c | 4 ++++ axfer/options.h | 1 + axfer/xfer-libasound.c | 4 ++-- axfer/xfer-libasound.h | 1 + 4 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/axfer/options.c b/axfer/options.c index f3d2dfcf..91708bb4 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -15,6 +15,7 @@ enum no_short_opts { /* 128 belongs to non us-ascii character set. */ OPT_DUMP_HW_PARAMS = 128, + OPT_FATAL_ERRORS, /* Obsoleted. */ OPT_MAX_FILE_TIME, }; @@ -307,6 +308,7 @@ int context_options_init(struct context_options *opts, int argc, {"rate", 1, 0, 'r'}, /* For debugging. */ {"dump-hw-params", 0, 0, OPT_DUMP_HW_PARAMS}, + {"fatal-errors", 0, 0, OPT_FATAL_ERRORS}, /* Obsoleted. */ {"max-file-time", 1, 0, OPT_MAX_FILE_TIME}, {NULL, 0, 0, 0}, @@ -348,6 +350,8 @@ int context_options_init(struct context_options *opts, int argc, opts->frames_per_second = parse_l(optarg, &err); else if (c == OPT_DUMP_HW_PARAMS) opts->dump_hw_params = true; + else if (c == OPT_FATAL_ERRORS) + opts->finish_at_xrun = true; else if (c == OPT_MAX_FILE_TIME) { fprintf(stderr, "An option '--%s' is obsoleted and has no " diff --git a/axfer/options.h b/axfer/options.h index ddbdbfa9..de9ac998 100644 --- a/axfer/options.h +++ b/axfer/options.h @@ -36,6 +36,7 @@ struct context_options {

/* For debugging. */ bool dump_hw_params; + bool finish_at_xrun; };

int context_options_init(struct context_options *opts, int argc, diff --git a/axfer/xfer-libasound.c b/axfer/xfer-libasound.c index f75dc176..7ffbc287 100644 --- a/axfer/xfer-libasound.c +++ b/axfer/xfer-libasound.c @@ -41,6 +41,7 @@ static int xfer_libasound_init(struct xfer_context *xfer, return err;

state->verbose = xfer->verbose > 1; + state->finish_at_xrun = opts->finish_at_xrun;

if (opts->node == NULL) node = "default"; @@ -272,13 +273,12 @@ static int xfer_libasound_process_frames(struct xfer_context *xfer,

err = state->ops->process_frames(state, frame_count, mapper, cntrs); if (err < 0) { - if (err == -EPIPE) { + if (err == -EPIPE && !state->finish_at_xrun) { /* * Recover the stream and continue processing * immediately. In this program -EPIPE comes from * libasound implementation instead of file I/O. */ - err = snd_pcm_prepare(state->handle); }

diff --git a/axfer/xfer-libasound.h b/axfer/xfer-libasound.h index 97b26634..25768c41 100644 --- a/axfer/xfer-libasound.h +++ b/axfer/xfer-libasound.h @@ -30,6 +30,7 @@ struct libasound_state { void *private_data;

bool verbose; + bool finish_at_xrun; };

struct xfer_libasound_ops {

This commit adds support of waiter for poll(2) system call.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 3 ++- axfer/waiter-poll.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++++ axfer/waiter.c | 2 +- axfer/waiter.h | 3 +++ 4 files changed, 74 insertions(+), 2 deletions(-) create mode 100644 axfer/waiter-poll.c

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index f290cca8..a4e9f1bc 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -48,4 +48,5 @@ axfer_SOURCES = \ xfer-libasound-irq-rw.c \ subcmd-transfer.c \ waiter.h \ - waiter.c + waiter.c \ + waiter-poll.c diff --git a/axfer/waiter-poll.c b/axfer/waiter-poll.c new file mode 100644 index 00000000..70813ee0 --- /dev/null +++ b/axfer/waiter-poll.c @@ -0,0 +1,68 @@ +/* + * waiter-waiter-poll.c - Waiter for event notification by poll(2). + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "waiter.h" +#include "misc.h" + +#include <stdlib.h> +#include <errno.h> +#include <poll.h> + +struct poll_state { + struct pollfd *pfds; + unsigned int count; +}; + +static int poll_prepare(struct waiter_context *waiter, int *fds, + unsigned int fd_count) +{ + struct poll_state *state = waiter->private_data; + int i; + + state->pfds = calloc(fd_count, sizeof(struct pollfd)); + if (state->pfds == NULL) + return -ENOMEM; + + for (i = 0; i < fd_count; ++i) { + state->pfds[i].fd = fds[i]; + state->pfds[i].events = POLLIN | POLLOUT; + } + + state->count = fd_count; + + return 0; +} + +static int poll_wait_event(struct waiter_context *waiter, int timeout_msec) +{ + struct poll_state *state = waiter->private_data; + int err; + + err = poll(state->pfds, state->count, timeout_msec); + if (err < 0) + return -errno; + + return 0; +} + +static void poll_release(struct waiter_context *waiter) +{ + struct poll_state *state = waiter->private_data; + + free(state->pfds); + state->pfds = 0; +} + +const struct waiter_data waiter_poll = { + .ops = { + .prepare = poll_prepare, + .wait_event = poll_wait_event, + .release = poll_release, + }, + .private_size = sizeof(struct poll_state), +}; diff --git a/axfer/waiter.c b/axfer/waiter.c index dfe42f84..045b7f31 100644 --- a/axfer/waiter.c +++ b/axfer/waiter.c @@ -20,7 +20,7 @@ int waiter_context_init(struct waiter_context *waiter, enum waiter_type type) enum waiter_type type; const struct waiter_data *waiter; } entries[] = { - {WAITER_TYPE_COUNT, NULL}, + {WAITER_TYPE_POLL, &waiter_poll}, }; int i;

diff --git a/axfer/waiter.h b/axfer/waiter.h index dbd7ca70..00147f45 100644 --- a/axfer/waiter.h +++ b/axfer/waiter.h @@ -10,6 +10,7 @@ #define __ALSA_UTILS_AXFER_WAITER__H_

enum waiter_type { + WAITER_TYPE_POLL = 0, WAITER_TYPE_COUNT, };

@@ -42,4 +43,6 @@ struct waiter_data { unsigned int private_size; };

+extern const struct waiter_data waiter_poll; + #endif

In alsa-lib PCM API, data frames can be handled in mapped page frame, instead of calling any system calls.

This commit support for this type of operation. To reduce CPU usage, added waiter interface is used for event notification.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 3 +- axfer/options.c | 12 +- axfer/options.h | 1 + axfer/xfer-libasound-irq-mmap.c | 264 ++++++++++++++++++++++++++++++++++++++++ axfer/xfer-libasound.c | 22 +++- axfer/xfer-libasound.h | 4 +- 6 files changed, 300 insertions(+), 6 deletions(-) create mode 100644 axfer/xfer-libasound-irq-mmap.c

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index a4e9f1bc..79592bc8 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -49,4 +49,5 @@ axfer_SOURCES = \ subcmd-transfer.c \ waiter.h \ waiter.c \ - waiter-poll.c + waiter-poll.c \ + xfer-libasound-irq-mmap.c diff --git a/axfer/options.c b/axfer/options.c index a8deaf98..3fa29341 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -265,6 +265,13 @@ static int apply_policies(struct context_options *opts, return err; }

+ if (opts->mmap && opts->nonblock) { + fprintf(stderr, + "An option for mmap operation should not be used with " + "nonblocking option.\n"); + return -EINVAL; + } + return 0; }

@@ -289,7 +296,7 @@ void context_options_calculate_duration(struct context_options *opts, int context_options_init(struct context_options *opts, int argc, char *const *argv, snd_pcm_stream_t direction) { - static const char *s_opts = "hvqd:s:t:ID:f:c:r:N"; + static const char *s_opts = "hvqd:s:t:ID:f:c:r:NM"; static const struct option l_opts[] = { /* For generic purposes. */ {"help", 0, 0, 'h'}, @@ -307,6 +314,7 @@ int context_options_init(struct context_options *opts, int argc, {"channels", 1, 0, 'c'}, {"rate", 1, 0, 'r'}, {"nonblock", 0, 0, 'N'}, + {"mmap", 0, 0, 'M'}, /* For debugging. */ {"dump-hw-params", 0, 0, OPT_DUMP_HW_PARAMS}, {"fatal-errors", 0, 0, OPT_FATAL_ERRORS}, @@ -351,6 +359,8 @@ int context_options_init(struct context_options *opts, int argc, opts->frames_per_second = parse_l(optarg, &err); else if (c == 'N') opts->nonblock = true; + else if (c == 'M') + opts->mmap = true; else if (c == OPT_DUMP_HW_PARAMS) opts->dump_hw_params = true; else if (c == OPT_FATAL_ERRORS) diff --git a/axfer/options.h b/axfer/options.h index fc4f03c1..272ce9b9 100644 --- a/axfer/options.h +++ b/axfer/options.h @@ -34,6 +34,7 @@ struct context_options { unsigned int samples_per_frame; unsigned int frames_per_second; bool nonblock; + bool mmap;

/* For debugging. */ bool dump_hw_params; diff --git a/axfer/xfer-libasound-irq-mmap.c b/axfer/xfer-libasound-irq-mmap.c new file mode 100644 index 00000000..f798c4da --- /dev/null +++ b/axfer/xfer-libasound-irq-mmap.c @@ -0,0 +1,264 @@ +/* + * xfer-libasound-irq-mmap.c - Timer-based I/O helper for mmap operation. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "xfer-libasound.h" +#include "misc.h" + +struct map_layout { + snd_pcm_status_t *status; + + char **vector; + unsigned int samples_per_frame; +}; + +static int irq_mmap_pre_process(struct libasound_state *state) +{ + struct map_layout *layout = state->private_data; + snd_pcm_access_t access; + snd_pcm_uframes_t frame_offset; + snd_pcm_uframes_t avail = 0; + int i; + int err; + + err = snd_pcm_status_malloc(&layout->status); + if (err < 0) + return err; + + err = snd_pcm_hw_params_get_access(state->hw_params, &access); + if (err < 0) + return err; + + err = snd_pcm_hw_params_get_channels(state->hw_params, + &layout->samples_per_frame); + if (err < 0) + return err; + + if (access == SND_PCM_ACCESS_MMAP_NONINTERLEAVED) { + layout->vector = calloc(layout->samples_per_frame, + sizeof(*layout->vector)); + if (layout->vector == NULL) + return err; + } + + if (state->verbose) { + const snd_pcm_channel_area_t *areas; + err = snd_pcm_mmap_begin(state->handle, &areas, &frame_offset, + &avail); + if (err < 0) + return err; + + logging(state, "attributes for mapped page frame:\n"); + for (i = 0; i < layout->samples_per_frame; ++i) { + const snd_pcm_channel_area_t *area = areas + i; + + logging(state, " sample number: %d\n", i); + logging(state, " address: %p\n", area->addr); + logging(state, " bits for offset: %u\n", area->first); + logging(state, " bits/frame: %u\n", area->step); + } + logging(state, "\n"); + } + + return 0; +} + +static int irq_mmap_process_frames(struct libasound_state *state, + unsigned int *frame_count, + struct mapper_context *mapper, + struct container_context *cntrs) +{ + struct map_layout *layout = state->private_data; + const snd_pcm_channel_area_t *areas; + snd_pcm_uframes_t frame_offset; + snd_pcm_uframes_t avail; + unsigned int avail_count; + void *frame_buf; + snd_pcm_sframes_t consumed_count; + int err; + + if (state->waiter) { + /* Wait for hardware IRQ when no avail space in buffer.*/ + err = waiter_context_wait_event(state->waiter, -1); + if (err < 0) + goto error; + /* + * When rescheduled, current position of data transmission was + * queried to actual hardware by a handler of IRQ. No need to + * perform it; e.g. ioctl(2) with SNDRV_PCM_IOCTL_HWSYNC. + */ + } + + avail = *frame_count; + err = snd_pcm_mmap_begin(state->handle, &areas, &frame_offset, &avail); + if (err < 0) + goto error; + + /* Trim according up to expected frame count. */ + if (*frame_count < avail) + avail_count = *frame_count; + else + avail_count = (unsigned int)avail; + + /* + * TODO: Perhaps, the complex layout can be supported as a variation of + * vector type. However, there's no driver with this layout. + */ + if (layout->vector == NULL) { + frame_buf = areas[0].addr; + frame_buf += snd_pcm_frames_to_bytes(state->handle, + frame_offset); + } else { + int i; + for (i = 0; i < layout->samples_per_frame; ++i) { + layout->vector[i] = areas[i].addr; + layout->vector[i] += snd_pcm_samples_to_bytes( + state->handle, frame_offset); + } + frame_buf = layout->vector; + } + + err = mapper_context_process_frames(mapper, frame_buf, &avail_count, + cntrs); + if (err < 0) + goto error; + if (avail_count == 0) + goto error; + + consumed_count = snd_pcm_mmap_commit(state->handle, frame_offset, + avail_count); + if (consumed_count < 0) { + err = consumed_count; + goto error; + } + if (consumed_count != avail_count) + logging(state, "A bug of access plugin for this PCM node.\n"); + + *frame_count = consumed_count; + + return 0; +error: + *frame_count = 0; + return err; +} + +static int irq_mmap_r_process_frames(struct libasound_state *state, + unsigned *frame_count, + struct mapper_context *mapper, + struct container_context *cntrs) +{ + struct map_layout *layout = state->private_data; + snd_pcm_state_t s; + int err; + + /* + * To querying current status of hardware, we need to care of 3 levels: + * 1. querying status to actual hardware by driver. + * 2. status data in kernel space. + * 3. status data in user space. + * + * Kernel driver perform 1 according to requests of some ioctl(2) + * commands. Between 2 and 3, we need to care of cache coherency on used + * architecture, or concurrent access by IRQ context and process + * context. + * A call of ioctl(2) with SNDRV_PCM_IOCTL_STATUS and + * SNDRV_PCM_IOCTL_STATUS_EXT has enough care of the above three levels. + */ + err = snd_pcm_status(state->handle, layout->status); + if (err < 0) + goto error; + s = snd_pcm_status_get_state(layout->status); + + /* TODO: if reporting something, do here with the status data. */ + + /* For capture direction, need to start stream explicitly. */ + if (s != SND_PCM_STATE_RUNNING) { + if (s != SND_PCM_STATE_PREPARED) { + err = -EPIPE; + goto error; + } + + err = snd_pcm_start(state->handle); + if (err < 0) + goto error; + } + + err = irq_mmap_process_frames(state, frame_count, mapper, cntrs); + if (err < 0) + goto error; + + return 0; +error: + *frame_count = 0; + return err; +} + +static int irq_mmap_w_process_frames(struct libasound_state *state, + unsigned *frame_count, + struct mapper_context *mapper, + struct container_context *cntrs) +{ + struct map_layout *layout = state->private_data; + snd_pcm_state_t s; + int err; + + /* Read my comment in 'irq_mmap_r_process_frames(). */ + err = snd_pcm_status(state->handle, layout->status); + if (err < 0) + goto error; + s = snd_pcm_status_get_state(layout->status); + + /* TODO: if reporting something, do here with the status data. */ + + err = irq_mmap_process_frames(state, frame_count, mapper, cntrs); + if (err < 0) + goto error; + + /* Need to start playback stream explicitly */ + if (s != SND_PCM_STATE_RUNNING) { + if (s != SND_PCM_STATE_PREPARED) { + err = -EPIPE; + goto error; + } + + err = snd_pcm_start(state->handle); + if (err < 0) + goto error; + } + + return 0; +error: + *frame_count = 0; + return err; +} + +static void irq_mmap_post_process(struct libasound_state *state) +{ + struct map_layout *layout = state->private_data; + + if (layout->status) + snd_pcm_status_free(layout->status); + layout->status = NULL; + + if (layout->vector) + free(layout->vector); + layout->vector = NULL; +} + +const struct xfer_libasound_ops xfer_libasound_irq_mmap_w_ops = { + .pre_process = irq_mmap_pre_process, + .process_frames = irq_mmap_w_process_frames, + .post_process = irq_mmap_post_process, + .private_size = sizeof(struct map_layout), +}; + +const struct xfer_libasound_ops xfer_libasound_irq_mmap_r_ops = { + .pre_process = irq_mmap_pre_process, + .process_frames = irq_mmap_r_process_frames, + .post_process = irq_mmap_post_process, + .private_size = sizeof(struct map_layout), +}; diff --git a/axfer/xfer-libasound.c b/axfer/xfer-libasound.c index 1987b573..dd882e62 100644 --- a/axfer/xfer-libasound.c +++ b/axfer/xfer-libasound.c @@ -30,8 +30,15 @@ static int set_access_hw_param(snd_pcm_t *handle, if (err < 0) return err; snd_pcm_access_mask_none(mask); - snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_RW_INTERLEAVED); - snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_RW_NONINTERLEAVED); + 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);

@@ -68,7 +75,7 @@ static int xfer_libasound_init(struct xfer_context *xfer, }

state->nonblock = !!(mode & SND_PCM_NONBLOCK); - if (opts->nonblock) { + if (opts->nonblock || opts->mmap) { state->waiter = malloc(sizeof(*state->waiter)); if (state->waiter == NULL) return -ENOMEM; @@ -290,6 +297,12 @@ static int xfer_libasound_pre_process(struct xfer_context *xfer, if (*access == SND_PCM_ACCESS_RW_INTERLEAVED || *access == SND_PCM_ACCESS_RW_NONINTERLEAVED) { state->ops = &xfer_libasound_irq_rw_ops; + } else if (*access == SND_PCM_ACCESS_MMAP_INTERLEAVED || + *access == SND_PCM_ACCESS_MMAP_NONINTERLEAVED) { + if (snd_pcm_stream(state->handle) == SND_PCM_STREAM_CAPTURE) + state->ops = &xfer_libasound_irq_mmap_r_ops; + else + state->ops = &xfer_libasound_irq_mmap_w_ops; } else { return -ENXIO; } @@ -432,6 +445,9 @@ static void xfer_libasound_post_process(struct xfer_context *xfer) if (state->private_data) free(state->private_data); state->private_data = NULL; + + if (state->waiter) + waiter_context_release(state->waiter); }

static void xfer_libasound_destroy(struct xfer_context *xfer) diff --git a/axfer/xfer-libasound.h b/axfer/xfer-libasound.h index 342651d1..d0771f8a 100644 --- a/axfer/xfer-libasound.h +++ b/axfer/xfer-libasound.h @@ -47,7 +47,9 @@ struct xfer_libasound_ops { unsigned int private_size; };

-extern const struct xfer_libasound_ops xfer_libasound_irq_mmap_ops; extern const struct xfer_libasound_ops xfer_libasound_irq_rw_ops;

+extern const struct xfer_libasound_ops xfer_libasound_irq_mmap_r_ops; +extern const struct xfer_libasound_ops xfer_libasound_irq_mmap_w_ops; + #endif

In ALSA PCM interface, two parameters are used for size of intermediate buffer for data frames; period size and buffer size. Actual effects of these sizes differs depending on hardware, but basically the size of period is used for intervals of hardware interrupts and the size of buffer is used to maintain the intermediate buffer as ring buffer. These parameters can be configured as a part of hardware parameters by data frame unit or micro second. PCM API in alsa-lib also includes helper functions to configure them by the two units.

This commit adds support for options to the parameters by both units. When no options are given, default values are applied according to current aplay; available maximum size of buffer up to 500msec, a quarter of the size of buffer for period size. These calculation should be reconsidered perhaps.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/options.c | 30 +++++++++++++++- axfer/options.h | 5 +++ axfer/subcmd-transfer.c | 6 ++-- axfer/xfer-libasound.c | 92 +++++++++++++++++++++++++++++++++++++++++++++++-- axfer/xfer-libasound.h | 1 - axfer/xfer.c | 5 +-- axfer/xfer.h | 6 ++-- 7 files changed, 134 insertions(+), 11 deletions(-)

diff --git a/axfer/options.c b/axfer/options.c index b0ea99c3..325bc16b 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -17,6 +17,8 @@ enum no_short_opts { OPT_DUMP_HW_PARAMS = 128, OPT_FATAL_ERRORS, OPT_TEST_NOWAIT, + OPT_PERIOD_SIZE, + OPT_BUFFER_SIZE, /* Obsoleted. */ OPT_MAX_FILE_TIME, }; @@ -266,6 +268,20 @@ static int apply_policies(struct context_options *opts, return err; }

+ if (opts->msec_per_period > 0 && opts->msec_per_buffer > 0) { + if (opts->msec_per_period > opts->msec_per_buffer) { + opts->msec_per_period = opts->msec_per_buffer; + opts->msec_per_buffer = 0; + } + } + + if (opts->frames_per_period > 0 && opts->frames_per_buffer > 0) { + if (opts->frames_per_period > opts->frames_per_buffer) { + opts->frames_per_period = opts->frames_per_buffer; + opts->frames_per_buffer = 0; + } + } + if (opts->mmap && opts->nonblock) { fprintf(stderr, "An option for mmap operation should not be used with " @@ -306,7 +322,7 @@ void context_options_calculate_duration(struct context_options *opts, int context_options_init(struct context_options *opts, int argc, char *const *argv, snd_pcm_stream_t direction) { - static const char *s_opts = "hvqd:s:t:ID:f:c:r:NM"; + static const char *s_opts = "hvqd:s:t:ID:f:c:r:NMF:B:"; static const struct option l_opts[] = { /* For generic purposes. */ {"help", 0, 0, 'h'}, @@ -325,6 +341,10 @@ int context_options_init(struct context_options *opts, int argc, {"rate", 1, 0, 'r'}, {"nonblock", 0, 0, 'N'}, {"mmap", 0, 0, 'M'}, + {"period-time", 1, 0, 'F'}, + {"buffer-time", 1, 0, 'B'}, + {"period-size", 1, 0, OPT_PERIOD_SIZE}, + {"buffer-size", 1, 0, OPT_BUFFER_SIZE}, /* For debugging. */ {"dump-hw-params", 0, 0, OPT_DUMP_HW_PARAMS}, {"fatal-errors", 0, 0, OPT_FATAL_ERRORS}, @@ -372,6 +392,14 @@ int context_options_init(struct context_options *opts, int argc, opts->nonblock = true; else if (c == 'M') opts->mmap = true; + else if (c == 'F') + opts->msec_per_period = parse_l(optarg, &err); + else if (c == 'B') + opts->msec_per_buffer = parse_l(optarg, &err); + else if (c == OPT_PERIOD_SIZE) + opts->frames_per_period = parse_l(optarg, &err); + else if (c == OPT_BUFFER_SIZE) + opts->frames_per_buffer = parse_l(optarg, &err); else if (c == OPT_DUMP_HW_PARAMS) opts->dump_hw_params = true; else if (c == OPT_FATAL_ERRORS) diff --git a/axfer/options.h b/axfer/options.h index 3052d01a..f4ac6c64 100644 --- a/axfer/options.h +++ b/axfer/options.h @@ -36,6 +36,11 @@ struct context_options { bool nonblock; bool mmap;

+ unsigned int msec_per_period; + unsigned int msec_per_buffer; + unsigned int frames_per_period; + unsigned int frames_per_buffer; + /* For debugging. */ bool dump_hw_params; bool finish_at_xrun; diff --git a/axfer/subcmd-transfer.c b/axfer/subcmd-transfer.c index 6c7e6ad8..e9a8c181 100644 --- a/axfer/subcmd-transfer.c +++ b/axfer/subcmd-transfer.c @@ -157,7 +157,8 @@ static int capture_pre_process(struct context *ctx, snd_pcm_access_t *access,

err = xfer_context_pre_process(&ctx->xfer, sample_format, samples_per_frame, frames_per_second, - access, frames_per_buffer); + access, frames_per_buffer, + &ctx->opts); if (err < 0) return err;

@@ -294,7 +295,8 @@ static int playback_pre_process(struct context *ctx, snd_pcm_access_t *access, /* Configure hardware with these parameters. */ err = xfer_context_pre_process(&ctx->xfer, sample_format, samples_per_frame, frames_per_second, - access, frames_per_buffer); + access, frames_per_buffer, + &ctx->opts); if (err < 0) return err;

diff --git a/axfer/xfer-libasound.c b/axfer/xfer-libasound.c index 5271d230..1911c160 100644 --- a/axfer/xfer-libasound.c +++ b/axfer/xfer-libasound.c @@ -149,7 +149,11 @@ end: static int configure_hw_params(struct libasound_state *state, snd_pcm_format_t format, unsigned int samples_per_frame, - unsigned int frames_per_second) + unsigned int frames_per_second, + unsigned int msec_per_period, + unsigned int msec_per_buffer, + snd_pcm_uframes_t frames_per_period, + snd_pcm_uframes_t frames_per_buffer) { int err;

@@ -220,6 +224,84 @@ static int configure_hw_params(struct libasound_state *state, return err; }

+ /* Keep one of 'frames_per_buffer' and 'msec_per_buffer'. */ + if (frames_per_buffer == 0) { + if (msec_per_buffer == 0) { + err = snd_pcm_hw_params_get_buffer_time_max( + state->hw_params, &msec_per_buffer, NULL); + if (err < 0) { + logging(state, + _("The maximum msec per buffer is not " + "available.\n")); + return err; + } + if (msec_per_buffer > 500000) + msec_per_buffer = 500000; + } + } else if (msec_per_buffer > 0) { + uint64_t msec; + + msec = 1000000 * frames_per_buffer / frames_per_second; + if (msec < msec_per_buffer) + msec_per_buffer = 0; + } + + /* Keep one of 'frames_per_period' and 'msec_per_period'. */ + if (frames_per_period == 0) { + if (msec_per_period == 0) { + if (msec_per_buffer > 0) + msec_per_period = msec_per_buffer / 4; + else + frames_per_period = frames_per_buffer / 4; + } + } else if (msec_per_period > 0) { + uint64_t msec; + + msec = 1000000 * frames_per_period / frames_per_second; + if (msec < msec_per_period) + msec_per_period = 0; + } + + if (msec_per_period) { + err = snd_pcm_hw_params_set_period_time_near(state->handle, + state->hw_params, &msec_per_period, NULL); + if (err < 0) { + logging(state, + _("Fail to configure period time: %u msec\n"), + msec_per_period); + return err; + } + } else { + err = snd_pcm_hw_params_set_period_size_near(state->handle, + state->hw_params, &frames_per_period, NULL); + if (err < 0) { + logging(state, + _("Fail to configure period size: %lu frames\n"), + frames_per_period); + return err; + } + } + + if (msec_per_buffer) { + err = snd_pcm_hw_params_set_buffer_time_near(state->handle, + state->hw_params, &msec_per_buffer, NULL); + if (err < 0) { + logging(state, + _("Fail to configure buffer time: %u msec\n"), + msec_per_buffer); + return err; + } + } else { + err = snd_pcm_hw_params_set_buffer_size_near(state->handle, + state->hw_params, &frames_per_buffer); + if (err < 0) { + logging(state, + _("Fail to configure buffer size: %lu frames\n"), + frames_per_buffer); + return err; + } + } + return snd_pcm_hw_params(state->handle, state->hw_params); }

@@ -265,7 +347,8 @@ static int xfer_libasound_pre_process(struct xfer_context *xfer, unsigned int *samples_per_frame, unsigned int *frames_per_second, snd_pcm_access_t *access, - snd_pcm_uframes_t *frames_per_buffer) + snd_pcm_uframes_t *frames_per_buffer, + struct context_options *opts) { struct libasound_state *state = xfer->private_data; int err; @@ -274,7 +357,10 @@ static int xfer_libasound_pre_process(struct xfer_context *xfer, return -ENXIO;

err = configure_hw_params(state, *format, *samples_per_frame, - *frames_per_second); + *frames_per_second, opts->msec_per_period, + opts->msec_per_buffer, + opts->frames_per_period, + opts->frames_per_buffer); if (err < 0) { logging(state, _("Current hardware parameters:\n")); snd_pcm_hw_params_dump(state->hw_params, state->log); diff --git a/axfer/xfer-libasound.h b/axfer/xfer-libasound.h index d0771f8a..db85e604 100644 --- a/axfer/xfer-libasound.h +++ b/axfer/xfer-libasound.h @@ -22,7 +22,6 @@ struct libasound_state { snd_output_t *log;

snd_pcm_hw_params_t *hw_params; - snd_pcm_sw_params_t *sw_params;

bool running; diff --git a/axfer/xfer.c b/axfer/xfer.c index 4677bd5b..2f9f9422 100644 --- a/axfer/xfer.c +++ b/axfer/xfer.c @@ -68,7 +68,8 @@ int xfer_context_pre_process(struct xfer_context *xfer, unsigned int *samples_per_frame, unsigned int *frames_per_second, snd_pcm_access_t *access, - snd_pcm_uframes_t *frames_per_buffer) + snd_pcm_uframes_t *frames_per_buffer, + struct context_options *opts) { int err;

@@ -84,7 +85,7 @@ int xfer_context_pre_process(struct xfer_context *xfer,

err = xfer->ops->pre_process(xfer, format, samples_per_frame, frames_per_second, access, - frames_per_buffer); + frames_per_buffer, opts); if (err < 0) return err;

diff --git a/axfer/xfer.h b/axfer/xfer.h index b90c005b..167c9903 100644 --- a/axfer/xfer.h +++ b/axfer/xfer.h @@ -34,7 +34,8 @@ int xfer_context_pre_process(struct xfer_context *xfer, unsigned int *samples_per_frame, unsigned int *frames_per_second, snd_pcm_access_t *access, - snd_pcm_uframes_t *frames_per_buffer); + snd_pcm_uframes_t *frames_per_buffer, + struct context_options *opts); int xfer_context_process_frames(struct xfer_context *xfer, struct mapper_context *mapper, struct container_context *cntrs, @@ -51,7 +52,8 @@ struct xfer_ops { unsigned int *samples_per_frame, unsigned int *frames_per_second, snd_pcm_access_t *access, - snd_pcm_uframes_t *frames_per_buffer); + snd_pcm_uframes_t *frames_per_buffer, + struct context_options *opts); int (*process_frames)(struct xfer_context *xfer, unsigned int *frame_count, struct mapper_context *mapper,

As of 2017, two userspace library implementations are known; alsa-lib and tinyalsa. The latter is simple I/O library to use ALSA PCM interface. On the other hand, alsa-lib is more complicated than it. This is because it's designed to add features to transmission of data frames; e.g. sample resampling. To achieve this, alsa-lib has its configuration space and plugin system.

In aplay, some options are implemented as a flag for the plugins in alsa-lib. The flag is given to snd_pcm_open(). This commit adds support for the flags.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/options.c | 17 +++++++++++++++++ axfer/options.h | 6 ++++++ axfer/xfer-libasound.c | 8 ++++++++ 3 files changed, 31 insertions(+)

diff --git a/axfer/options.c b/axfer/options.c index a22223a0..bca87d14 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -19,6 +19,10 @@ enum no_short_opts { OPT_TEST_NOWAIT, OPT_PERIOD_SIZE, OPT_BUFFER_SIZE, + OPT_DISABLE_RESAMPLE, + OPT_DISABLE_CHANNELS, + OPT_DISABLE_FORMAT, + OPT_DISABLE_SOFTVOL, /* Obsoleted. */ OPT_MAX_FILE_TIME, }; @@ -348,6 +352,11 @@ int context_options_init(struct context_options *opts, int argc, {"avail-min", 1, 0, 'A'}, {"start-delay", 1, 0, 'R'}, {"stop-delay", 1, 0, 'T'}, + /* For plugins in alsa-lib. */ + {"disable-resample", 0, 0, OPT_DISABLE_RESAMPLE}, + {"disable-channels", 0, 0, OPT_DISABLE_CHANNELS}, + {"disable-format", 0, 0, OPT_DISABLE_FORMAT}, + {"disable-softvol", 0, 0, OPT_DISABLE_SOFTVOL}, /* For debugging. */ {"dump-hw-params", 0, 0, OPT_DUMP_HW_PARAMS}, {"fatal-errors", 0, 0, OPT_FATAL_ERRORS}, @@ -409,6 +418,14 @@ int context_options_init(struct context_options *opts, int argc, opts->msec_for_start_threshold = parse_l(optarg, &err); else if (c == 'T') opts->msec_for_stop_threshold = parse_l(optarg, &err); + else if (c == OPT_DISABLE_RESAMPLE) + opts->no_auto_resample = true; + else if (c == OPT_DISABLE_CHANNELS) + opts->no_auto_channels = true; + else if (c == OPT_DISABLE_FORMAT) + opts->no_auto_format = true; + else if (c == OPT_DISABLE_SOFTVOL) + opts->no_softvol = true; else if (c == OPT_DUMP_HW_PARAMS) opts->dump_hw_params = true; else if (c == OPT_FATAL_ERRORS) diff --git a/axfer/options.h b/axfer/options.h index 63b36364..95012ad3 100644 --- a/axfer/options.h +++ b/axfer/options.h @@ -45,6 +45,12 @@ struct context_options { unsigned int msec_for_start_threshold; unsigned int msec_for_stop_threshold;

+ /* For plugins in alsa-lib. */ + bool no_auto_resample; + bool no_auto_channels; + bool no_auto_format; + bool no_softvol; + /* For debugging. */ bool dump_hw_params; bool finish_at_xrun; diff --git a/axfer/xfer-libasound.c b/axfer/xfer-libasound.c index 533c9492..e01327e2 100644 --- a/axfer/xfer-libasound.c +++ b/axfer/xfer-libasound.c @@ -15,6 +15,14 @@ static int get_mode(struct context_options *options)

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; }

This commit is an integration to add an option for users to select waiter type. Currently, 'poll' and 'epoll' types are supported. Users give the type for '--waiter-type' ('-w') option to select it.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/options.c | 36 +++++++++++++++++++++++++++++++++--- axfer/options.h | 3 +++ axfer/waiter.c | 17 +++++++++++++++++ axfer/waiter.h | 2 ++ axfer/xfer-libasound.c | 2 +- 5 files changed, 56 insertions(+), 4 deletions(-)

diff --git a/axfer/options.c b/axfer/options.c index bca87d14..c4423b6c 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -176,7 +176,8 @@ static int apply_policies(struct context_options *opts, snd_pcm_stream_t direction, const char *cntr_format_literal, const char *node_literal, - const char *sample_format_literal) + const char *sample_format_literal, + const char *waiter_type_literal) { int err;

@@ -302,6 +303,30 @@ static int apply_policies(struct context_options *opts, } }

+ if (waiter_type_literal != NULL) { + if (opts->test_nowait) { + fprintf(stderr, + "An option for waiter type should not be used " + "with nowait test option.\n"); + return -EINVAL; + } + if (!opts->nonblock && !opts->mmap) { + fprintf(stderr, + "An option for waiter type should be used with " + "nonblock or mmap options.\n"); + return -EINVAL; + } + opts->waiter_type = waiter_type_from_label(waiter_type_literal); + if (opts->waiter_type == WAITER_TYPE_UNKNOWN) { + fprintf(stderr, + "An option for waiter type is invalid: %s\n", + waiter_type_literal); + return -EINVAL; + } + } else { + opts->waiter_type = WAITER_TYPE_POLL; + } + return 0; }

@@ -326,7 +351,7 @@ void context_options_calculate_duration(struct context_options *opts, int context_options_init(struct context_options *opts, int argc, char *const *argv, snd_pcm_stream_t direction) { - static const char *s_opts = "hvqd:s:t:ID:f:c:r:NMF:B:A:R:T:"; + static const char *s_opts = "hvqd:s:t:ID:f:c:r:NMw:F:B:A:R:T:"; static const struct option l_opts[] = { /* For generic purposes. */ {"help", 0, 0, 'h'}, @@ -345,6 +370,7 @@ int context_options_init(struct context_options *opts, int argc, {"rate", 1, 0, 'r'}, {"nonblock", 0, 0, 'N'}, {"mmap", 0, 0, 'M'}, + {"waiter-type", 1, 0, 'w'}, {"period-time", 1, 0, 'F'}, {"buffer-time", 1, 0, 'B'}, {"period-size", 1, 0, OPT_PERIOD_SIZE}, @@ -368,6 +394,7 @@ int context_options_init(struct context_options *opts, int argc, const char *cntr_format_literal = NULL; const char *node_literal = NULL; const char *sample_format_literal = NULL; + const char *waiter_type_literal = NULL; int l_index = 0; int c; int err = 0; @@ -404,6 +431,8 @@ int context_options_init(struct context_options *opts, int argc, opts->nonblock = true; else if (c == 'M') opts->mmap = true; + else if (c == 'w') + waiter_type_literal = optarg; else if (c == 'F') opts->msec_per_period = parse_l(optarg, &err); else if (c == 'B') @@ -450,7 +479,8 @@ int context_options_init(struct context_options *opts, int argc, return err;

return apply_policies(opts, direction, cntr_format_literal, - node_literal, sample_format_literal); + node_literal, sample_format_literal, + waiter_type_literal); }

static int generate_path_with_suffix(struct context_options *opts, diff --git a/axfer/options.h b/axfer/options.h index 95012ad3..f105ff2e 100644 --- a/axfer/options.h +++ b/axfer/options.h @@ -10,6 +10,7 @@ #define __ALSA_UTILS_AXFER_OPTIONS__H_

#include "container.h" +#include "waiter.h"

struct context_options { bool help; @@ -36,6 +37,8 @@ struct context_options { bool nonblock; bool mmap;

+ enum waiter_type waiter_type; + unsigned int msec_per_period; unsigned int msec_per_buffer; unsigned int frames_per_period; diff --git a/axfer/waiter.c b/axfer/waiter.c index f4e21a16..8e3789b9 100644 --- a/axfer/waiter.c +++ b/axfer/waiter.c @@ -14,6 +14,23 @@

#include "misc.h"

+const char *const waiter_type_labels[] = { + [WAITER_TYPE_POLL] = "poll", + [WAITER_TYPE_EPOLL] = "epoll", +}; + +enum waiter_type waiter_type_from_label(const char *label) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(waiter_type_labels); ++i) { + if (!strcmp(waiter_type_labels[i], label)) + return i; + } + + return WAITER_TYPE_UNKNOWN; +} + int waiter_context_init(struct waiter_context *waiter, enum waiter_type type) { struct { diff --git a/axfer/waiter.h b/axfer/waiter.h index 3f0dd744..aedc42f8 100644 --- a/axfer/waiter.h +++ b/axfer/waiter.h @@ -10,6 +10,7 @@ #define __ALSA_UTILS_AXFER_WAITER__H_

enum waiter_type { + WAITER_TYPE_UNKNOWN = -1, WAITER_TYPE_POLL = 0, WAITER_TYPE_EPOLL, WAITER_TYPE_COUNT, @@ -23,6 +24,7 @@ struct waiter_context { void *private_data; };

+enum waiter_type waiter_type_from_label(const char *label); int waiter_context_init(struct waiter_context *waiter, enum waiter_type type); int waiter_context_prepare(struct waiter_context *waiter, int *fds, unsigned int fd_count); diff --git a/axfer/xfer-libasound.c b/axfer/xfer-libasound.c index e01327e2..96e0cb7c 100644 --- a/axfer/xfer-libasound.c +++ b/axfer/xfer-libasound.c @@ -88,7 +88,7 @@ static int xfer_libasound_init(struct xfer_context *xfer, if (state->waiter == NULL) return -ENOMEM;

- err = waiter_context_init(state->waiter, WAITER_TYPE_POLL); + err = waiter_context_init(state->waiter, opts->waiter_type); if (err < 0) return err; }

In aplay, volume unit (vu) meter is implemented, by an option '--vumeter' (-V). When 'm' or 's' is given for the option, terminal displays monaural or stereo meter via stderr.

This commit adds support for this feature. Original implementation just supports meters up to 2 channel and this commit follows it. However, actual calculation is done all of channels with a consideration about future extension to display all of channels.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/Makefile.am | 7 +- axfer/options.c | 43 ++- axfer/options.h | 4 + axfer/subcmd-transfer.c | 1 - axfer/vumeter.c | 546 ++++++++++++++++++++++++++++++++++++++ axfer/vumeter.h | 55 ++++ axfer/xfer-libasound-irq-mmap.c | 16 +- axfer/xfer-libasound-irq-rw.c | 40 ++- axfer/xfer-libasound-timer-mmap.c | 16 +- axfer/xfer-libasound.c | 5 +- axfer/xfer-libasound.h | 3 +- axfer/xfer.c | 39 ++- axfer/xfer.h | 5 +- 13 files changed, 746 insertions(+), 34 deletions(-) create mode 100644 axfer/vumeter.c create mode 100644 axfer/vumeter.h

diff --git a/axfer/Makefile.am b/axfer/Makefile.am index 3a0b1d26..7a079e62 100644 --- a/axfer/Makefile.am +++ b/axfer/Makefile.am @@ -22,7 +22,8 @@ noinst_HEADERS = \ options.h \ xfer.h \ xfer-alsa.h \ - waiter.h + waiter.h \ + vumeter.h

axfer_SOURCES = \ misc.h \ @@ -52,4 +53,6 @@ axfer_SOURCES = \ waiter-poll.c \ xfer-libasound-irq-mmap.c \ waiter-epoll.c \ - xfer-libasound-timer-mmap.c + xfer-libasound-timer-mmap.c \ + vumeter.h \ + vumeter.c diff --git a/axfer/options.c b/axfer/options.c index b1a3184a..d595d857 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -114,6 +114,30 @@ static int verify_cntr_format(struct context_options *opts, const char *literal) return -EINVAL; }

+static int verify_vu_mode(struct context_options *opts, const char *literal) +{ + static const struct { + const char *const literal; + enum vumeter_mode mode; + } *entry, entries[] = { + {"m", VUMETER_MODE_MONO}, + {"s", VUMETER_MODE_STEREO}, + }; + int i; + + for (i = 0; i < ARRAY_SIZE(entries); ++i) { + entry = &entries[i]; + if (!strcmp(entry->literal, literal)) { + opts->vu_mode = entry->mode; + return 0; + } + } + + fprintf(stderr, "Invalid argument for vumeter mode: %s\n", literal); + + return -EINVAL; +} + /* This should be called after 'verify_cntr_format()'. */ static int verify_sample_format(struct context_options *opts, const char *literal) @@ -179,7 +203,8 @@ static int apply_policies(struct context_options *opts, const char *node_literal, const char *sample_format_literal, const char *waiter_type_literal, - const char *sched_type_literal) + const char *sched_type_literal, + const char *vu_mode_literal) { int err;

@@ -255,6 +280,12 @@ static int apply_policies(struct context_options *opts, } }

+ if (vu_mode_literal) { + err = verify_vu_mode(opts, vu_mode_literal); + if (err < 0) + return err; + } + if (opts->frames_per_second > 0) { unsigned int orig = opts->frames_per_second;

@@ -362,7 +393,7 @@ void context_options_calculate_duration(struct context_options *opts, int context_options_init(struct context_options *opts, int argc, char *const *argv, snd_pcm_stream_t direction) { - static const char *s_opts = "hvqd:s:t:ID:f:c:r:NMw:F:B:A:R:T:"; + static const char *s_opts = "hvqd:s:t:ID:f:c:r:NMw:F:B:A:R:T:V:"; static const struct option l_opts[] = { /* For generic purposes. */ {"help", 0, 0, 'h'}, @@ -400,6 +431,8 @@ int context_options_init(struct context_options *opts, int argc, {"dump-hw-params", 0, 0, OPT_DUMP_HW_PARAMS}, {"fatal-errors", 0, 0, OPT_FATAL_ERRORS}, {"test-nowait", 0, 0, OPT_TEST_NOWAIT}, + /* Misc features. */ + {"vumeter", 1, 0, 'V'}, /* Obsoleted. */ {"max-file-time", 1, 0, OPT_MAX_FILE_TIME}, {NULL, 0, 0, 0}, @@ -409,6 +442,7 @@ int context_options_init(struct context_options *opts, int argc, const char *sample_format_literal = NULL; const char *waiter_type_literal = NULL; const char *sched_type_literal = NULL; + const char *vu_mode_literal = NULL; int l_index = 0; int c; int err = 0; @@ -477,6 +511,8 @@ int context_options_init(struct context_options *opts, int argc, opts->finish_at_xrun = true; else if (c == OPT_TEST_NOWAIT) opts->test_nowait = true; + else if (c == 'V') + vu_mode_literal = optarg; else if (c == OPT_MAX_FILE_TIME) { fprintf(stderr, "An option '--%s' is obsoleted and has no " @@ -496,7 +532,8 @@ int context_options_init(struct context_options *opts, int argc,

return apply_policies(opts, direction, cntr_format_literal, node_literal, sample_format_literal, - waiter_type_literal, sched_type_literal); + waiter_type_literal, sched_type_literal, + vu_mode_literal); }

static int generate_path_with_suffix(struct context_options *opts, diff --git a/axfer/options.h b/axfer/options.h index 769757a8..188668b0 100644 --- a/axfer/options.h +++ b/axfer/options.h @@ -11,6 +11,7 @@

#include "container.h" #include "waiter.h" +#include "vumeter.h"

enum sched_type { SCHED_TYPE_IRQ = 0, @@ -67,6 +68,9 @@ struct context_options { bool dump_hw_params; bool finish_at_xrun; bool test_nowait; + + /* Misc features. */ + enum vumeter_mode vu_mode; };

int context_options_init(struct context_options *opts, int argc, diff --git a/axfer/subcmd-transfer.c b/axfer/subcmd-transfer.c index e9a8c181..480b4eb5 100644 --- a/axfer/subcmd-transfer.c +++ b/axfer/subcmd-transfer.c @@ -128,7 +128,6 @@ static int prepare_signal_handler(struct context *ctx)

static int context_init(struct context *ctx, snd_pcm_stream_t direction) { - /* Initialize transfer. */ return xfer_context_init(&ctx->xfer, XFER_TYPE_LIBASOUND, direction, &ctx->opts); } diff --git a/axfer/vumeter.c b/axfer/vumeter.c new file mode 100644 index 00000000..4d842866 --- /dev/null +++ b/axfer/vumeter.c @@ -0,0 +1,546 @@ +/* + * vumeter.c - Volume Unit meter. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#include "vumeter.h" +#include "misc.h" + +#include <endian.h> + +/* + * MEMO: Casting to 'intXX_t' is important to calculate absolute value from + * 'uintXX_t' representation of PCM frame. + */ + +static void calculate_8bit_sample_buf(struct vumeter_context *vu, + void *frame_buffer, + unsigned int frame_count) +{ + int8_t *buf = frame_buffer; + unsigned int samples_per_frame = vu->samples_per_frame; + int8_t zero_point = (int8_t)vu->zero_point; + int c, i; + + for (c = 0; c < samples_per_frame; ++c) { + int8_t peak = 0; + + for (i = 0; i < frame_count; ++i) { + int8_t val; + unsigned int offset; + + offset = i * samples_per_frame + c; + + val = abs(buf[offset] ^ zero_point); + if (val > peak) + peak = val; + } + + vu->peaks[c] = (uint32_t)peak; + } +} + +static void calculate_8bit_sample_vector(struct vumeter_context *vu, + void *frame_buffer, + unsigned int frame_count) +{ + int8_t **bufs = frame_buffer; + unsigned int samples_per_frame = vu->samples_per_frame; + int8_t zero_point = (int8_t)vu->zero_point; + int c, i; + + for (c = 0; c < samples_per_frame; ++c) { + int8_t *buf = bufs[c]; + int8_t peak = 0; + for (i = 0; i < frame_count; ++i) { + int8_t val; + + val = abs(buf[i] ^ zero_point); + if (val > peak) + peak = val; + } + + vu->peaks[c] = (uint32_t)peak; + } +} + +static void calculate_16bit_sample_buf(struct vumeter_context *vu, + void *frame_buffer, + unsigned int frame_count) +{ + int16_t *buf = frame_buffer; + unsigned int samples_per_frame = vu->samples_per_frame; + bool le = vu->le; + int16_t zero_point = (int16_t)vu->zero_point; + int c, i; + + for (c = 0; c < samples_per_frame; ++c) { + int16_t peak = 0; + + for (i = 0; i < frame_count; ++i) { + int16_t val; + unsigned int offset; + + offset = i * samples_per_frame + c; + + if (le) + val = (int32_t)le16toh(buf[offset]); + else + val = (int32_t)be16toh(buf[offset]); + + val = abs(val ^ zero_point); + if (val > peak) + peak = val; + } + + vu->peaks[c] = (uint32_t)peak; + } +} + +static void calculate_16bit_sample_vector(struct vumeter_context *vu, + void *frame_buffer, + unsigned int frame_count) +{ + int16_t **bufs = frame_buffer; + unsigned int samples_per_frame = vu->samples_per_frame; + bool le = vu->le; + int16_t zero_point = vu->zero_point; + int c, i; + + for (c = 0; c < samples_per_frame; ++c) { + int16_t *buf = bufs[c]; + int16_t peak = 0; + + for (i = 0; i < frame_count; ++i) { + int16_t val; + + if (le) + val = (int16_t)le16toh(buf[i]); + else + val = (int16_t)be16toh(buf[i]); + + val = abs(val ^ zero_point); + if (val > peak) + peak = val; + } + + vu->peaks[c] = peak; + } +} + +static void calculate_24bit_sample_buf(struct vumeter_context *vu, + void *frame_buffer, + unsigned int frame_count) +{ + int8_t *buf = frame_buffer; + unsigned int samples_per_frame = vu->samples_per_frame; + unsigned int bytes_per_sample = vu->bytes_per_sample; + bool le = vu->le; + int32_t zero_point = vu->zero_point; + int c, i; + + for (c = 0; c < samples_per_frame; ++c) { + int32_t peak = 0; + + for (i = 0; i < frame_count; ++i) { + int32_t val; + unsigned int offset; + + offset = i * bytes_per_sample * samples_per_frame + c; + + if (le) { + val = (int32_t)(((buf[offset] << 8) | + (buf[offset + 1] << 16) | + (buf[offset + 2] << 24))); + } else { + val = (int32_t)(((buf[offset] << 24) | + (buf[offset + 1] << 16) | + (buf[offset + 2] << 8))); + } + + val = abs(val ^ zero_point); + if (vu->significant_bits_per_sample == 18) + val >>= 14; + else if (vu->significant_bits_per_sample == 20) + val >>= 12; + else + val >>= 8; + if (val > peak) + peak = val; + } + + vu->peaks[c] = peak; + } +} + +static void calculate_24bit_sample_vector(struct vumeter_context *vu, + void *frame_buffer, + unsigned int frame_count) +{ + int8_t **bufs = frame_buffer; + unsigned int samples_per_frame = vu->samples_per_frame; + unsigned int bytes_per_sample = vu->bytes_per_sample; + bool le = vu->le; + int32_t zero_point = vu->zero_point; + int c, i; + + for (c = 0; c < samples_per_frame; ++c) { + int8_t *buf = bufs[c]; + int32_t peak = 0; + + for (i = 0; i < frame_count; ++i) { + int32_t val; + unsigned int offset; + + offset = bytes_per_sample * i; + + if (le) { + val = (int32_t)((buf[offset] << 8) | + (buf[offset + 1] << 16) | + (buf[offset + 2] << 24)); + } else { + val = (int32_t)((buf[offset] << 24) | + (buf[offset + 1] << 16) | + (buf[offset + 2] << 8)); + } + + val = abs(val ^ zero_point); + if (vu->significant_bits_per_sample == 18) + val >>= 14; + else if (vu->significant_bits_per_sample == 20) + val >>= 12; + else + val >>= 8; + if (val > peak) + peak = val; + } + + vu->peaks[c] = peak; + } +} + +static void calculate_32bit_sample_buf(struct vumeter_context *vu, + void *frame_buffer, + unsigned int frame_count) +{ + int32_t *buf = frame_buffer; + unsigned int samples_per_frame = vu->samples_per_frame; + bool le = vu->le; + int32_t zero_point = vu->zero_point; + int c, i; + + for (c = 0; c < samples_per_frame; ++c) { + int32_t peak = 0; + + for (i = 0; i < frame_count; ++i) { + int32_t val; + unsigned int offset; + + offset = i * samples_per_frame + c; + + if (le) + val = (int32_t)le32toh(buf[offset]); + else + val = (int32_t)be32toh(buf[offset]); + + val = abs(val ^ zero_point); + /* For [S/U]24_[B|L]E. */ + if (vu->significant_bits_per_sample == 24) + val >>= 8; + if (val > peak) + peak = val; + } + + vu->peaks[c] = peak; + } +} + +static void calculate_32bit_sample_vector(struct vumeter_context *vu, + void *frame_buffer, + unsigned int frame_count) +{ + int32_t **bufs = frame_buffer; + unsigned int samples_per_frame = vu->samples_per_frame; + bool le = vu->le; + int32_t zero_point = vu->zero_point; + int c, i; + + for (c = 0; c < samples_per_frame; ++c) { + int32_t *buf = bufs[c]; + int32_t peak = 0; + + for (i = 0; i < frame_count; ++i) { + int32_t val; + + if (le) + val = (int32_t)le32toh(buf[i]); + else + val = (int32_t)be32toh(buf[i]); + + val = abs(val ^ zero_point); + /* For [S/U]24_[B|L]E. */ + if (vu->significant_bits_per_sample == 24) + val >>= 8; + if (val > peak) + peak = val; + } + + vu->peaks[c] = peak; + } +} + +static void print_monaural(struct vumeter_context *vu, char line[80]) +{ + const int bar_len = 50; + unsigned int pos; + + /* NOTE: 74 + '| 00%' + '\0' = 80 characters. */ + + /* Print peaks on current buffer. */ + pos = vu->ratios[0] * bar_len / 100; + memset(line, '#', pos); + + /* Print maximum peaks within a second. */ + pos = vu->max_ratios_in_second[0] * bar_len / 100; + line[pos] = '+'; + + if (vu->max_ratios_in_second[0] > 99) { + snprintf(line + bar_len + 1, 80 - bar_len, + "| MAX"); + } else { + snprintf(line + bar_len + 1, 80 - bar_len, + "| %02u%%", vu->max_ratios_in_second[0]); + } +} + +static void print_stereo(struct vumeter_context *vu, char line[80]) +{ + const int bar_length = 35; + bool even; + int width; + char *substr; + int c; + + /* NOTE: 35 + ' 00%|00% ' + 35 + '\0' = 80 characters. */ + + for (c = 0; c < 2; c++) { + even = (c % 2 > 0); + + /* Print peaks on current buffer. */ + width = vu->ratios[c] * bar_length / 100; + if (width > bar_length) + width = bar_length; + if (even) + memset(line + bar_length + 9, '#', width); + else + memset(line + bar_length - width, '#', width); + + /* Print maximum peaks within a second. */ + width = vu->max_ratios_in_second[c] * bar_length / 100; + if (width > bar_length) + width = bar_length; + if (even) + line[bar_length + 8 + width] = '+'; + else + line[bar_length - width] = '+'; + + /* Print numerical value of maximum peaks within a second. */ + if (even) + substr = line + bar_length + 5; + else + substr = line + bar_length + 1; + if (vu->max_ratios_in_second[c] > 99) { + snprintf(substr, 4, "MAX"); + } else { + snprintf(substr, 4, + "%02u%%", vu->max_ratios_in_second[c]); + } + substr[3] = ' '; + } + + line[bar_length + 4] = '|'; +} + +int vumeter_context_init(struct vumeter_context *vu, enum vumeter_mode mode, + snd_pcm_access_t access, snd_pcm_format_t format, + unsigned int samples_per_frame, + unsigned int frames_per_second) +{ + int bits_per_sample; + + /* Just for sample formats of PCM. */ + if (format != SND_PCM_FORMAT_S8 && + format != SND_PCM_FORMAT_U8 && + format != SND_PCM_FORMAT_S16_LE && + format != SND_PCM_FORMAT_S16_BE && + format != SND_PCM_FORMAT_U16_LE && + format != SND_PCM_FORMAT_U16_BE && + format != SND_PCM_FORMAT_S24_LE && + format != SND_PCM_FORMAT_S24_BE && + format != SND_PCM_FORMAT_U24_LE && + format != SND_PCM_FORMAT_U24_BE && + format != SND_PCM_FORMAT_S32_LE && + format != SND_PCM_FORMAT_S32_BE && + format != SND_PCM_FORMAT_U32_LE && + format != SND_PCM_FORMAT_U32_BE && + format != SND_PCM_FORMAT_S24_3LE && + format != SND_PCM_FORMAT_S24_3BE && + format != SND_PCM_FORMAT_U24_3LE && + format != SND_PCM_FORMAT_U24_3BE && + format != SND_PCM_FORMAT_S24_3LE && + format != SND_PCM_FORMAT_S24_3BE && + format != SND_PCM_FORMAT_U24_3LE && + format != SND_PCM_FORMAT_U24_3BE && + format != SND_PCM_FORMAT_S20_3LE && + format != SND_PCM_FORMAT_S20_3BE && + format != SND_PCM_FORMAT_U20_3LE && + format != SND_PCM_FORMAT_U20_3BE && + format != SND_PCM_FORMAT_S18_3LE && + format != SND_PCM_FORMAT_S18_3BE && + format != SND_PCM_FORMAT_U18_3LE && + format != SND_PCM_FORMAT_U18_3BE) + return -EINVAL; + + bits_per_sample = snd_pcm_format_physical_width(format); + if (access == SND_PCM_ACCESS_RW_INTERLEAVED || + access == SND_PCM_ACCESS_MMAP_INTERLEAVED) { + if (bits_per_sample == 8) + vu->calculator = calculate_8bit_sample_buf; + else if (bits_per_sample == 16) + vu->calculator = calculate_16bit_sample_buf; + else if (bits_per_sample == 24) + vu->calculator = calculate_24bit_sample_buf; + else if (bits_per_sample == 32) + vu->calculator = calculate_32bit_sample_buf; + else + return -EINVAL; + } else if (access == SND_PCM_ACCESS_RW_NONINTERLEAVED || + access == SND_PCM_ACCESS_MMAP_NONINTERLEAVED) { + if (bits_per_sample == 8) + vu->calculator = calculate_8bit_sample_vector; + else if (bits_per_sample == 16) + vu->calculator = calculate_16bit_sample_vector; + else if (bits_per_sample == 24) + vu->calculator = calculate_24bit_sample_vector; + else if (bits_per_sample == 32) + vu->calculator = calculate_32bit_sample_vector; + else + return -EINVAL; + } else { + return -EINVAL; + } + vu->bytes_per_sample = bits_per_sample / 8; + + vu->peaks = calloc(samples_per_frame, sizeof(*vu->peaks)); + if (vu->peaks == NULL) + return -ENOMEM; + vu->samples_per_frame = samples_per_frame; + vu->frames_per_second = frames_per_second; + + if (mode == VUMETER_MODE_MONO || samples_per_frame == 1) + vu->printer = print_monaural; + else if (mode == VUMETER_MODE_STEREO) + vu->printer = print_stereo; + else + return -EINVAL; + vu->mode = mode; + + vu->ratios = calloc(samples_per_frame, sizeof(*vu->ratios)); + if (vu->ratios == NULL) + return -ENOMEM; + vu->max_ratios_in_second = calloc(samples_per_frame, + sizeof(*vu->max_ratios_in_second)); + if (vu->max_ratios_in_second == NULL) + return -ENOMEM; + + vu->significant_bits_per_sample = snd_pcm_format_width(format); + vu->max = (1 << (vu->significant_bits_per_sample - 1)) - 1; + + vu->le = !!snd_pcm_format_little_endian(format); + vu->zero_point = snd_pcm_format_silence_64(format); + /* For these sample formats, use 32bit width storage temporarily. */ + if (vu->significant_bits_per_sample == 18) + vu->zero_point <<= 14; + if (vu->significant_bits_per_sample == 20) + vu->zero_point <<= 12; + if (vu->significant_bits_per_sample == 24) + vu->zero_point <<= 8; + + return 0; +} + +void vumeter_context_prepare(struct vumeter_context *vu) +{ + int c; + + for (c = 0; c < vu->samples_per_frame; ++c) { + vu->ratios[c] = 0; + vu->max_ratios_in_second[c] = 0; + } + vu->total_frame_count = 0; +} + +void vumeter_context_calculate(struct vumeter_context *vu, void *frame_buffer, + unsigned int frame_count) +{ + int64_t val; + unsigned int ratio; + int c; + + vu->calculator(vu, frame_buffer, frame_count); + + vu->total_frame_count += frame_count; + + for (c = 0; c < vu->samples_per_frame; ++c) { + val = (int64_t)vu->peaks[c]; + ratio = val * 100 / vu->max; + + /* Reset ratios every second. */ + if (vu->total_frame_count >= vu->frames_per_second) + vu->max_ratios_in_second[c] = 0; + if (ratio > vu->max_ratios_in_second[c]) + vu->max_ratios_in_second[c] = ratio; + + vu->ratios[c] = ratio; + } + + vu->total_frame_count %= vu->frames_per_second; +} + +void vumeter_context_print(struct vumeter_context *vu) +{ + char line[80]; + + memset(line, ' ', 79); + + putc('\r', stderr); + + vu->printer(vu, line); + + line[79] = '\0'; + fputs(line, stderr); + fflush(stderr); +} + +void vumeter_context_break(struct vumeter_context *vu) +{ + fprintf(stderr, "\r"); +} + +void vumeter_context_destroy(struct vumeter_context *vu) +{ + if (vu->ratios) + free(vu->ratios); + vu->ratios = NULL; + + if (vu->max_ratios_in_second) + free(vu->max_ratios_in_second); + vu->max_ratios_in_second = NULL; + + if (vu->peaks) + free(vu->peaks); + vu->peaks = NULL; +} diff --git a/axfer/vumeter.h b/axfer/vumeter.h new file mode 100644 index 00000000..dcaa8b4f --- /dev/null +++ b/axfer/vumeter.h @@ -0,0 +1,55 @@ +/* + * vumeter.h - Volume Unit meter. + * + * Copyright (c) 2017 Takashi Sakamoto o-takashi@sakamocchi.jp + * + * Licensed under the terms of the GNU General Public License, version 2. + */ + +#ifndef __ALSA_UTILS_AXFER_VUMETER__H_ +#define __ALSA_UTILS_AXFER_VUMETER__H_ + +#include <stdbool.h> +#include <stdint.h> +#include <alsa/asoundlib.h> + +enum vumeter_mode { + VUMETER_MODE_NONE = 0, + VUMETER_MODE_MONO, + VUMETER_MODE_STEREO +}; + +struct vumeter_context { + enum vumeter_mode mode; + + bool le; + unsigned int significant_bits_per_sample; + unsigned int bytes_per_sample; + unsigned int samples_per_frame; + unsigned int frames_per_second; + + int64_t zero_point; + uint32_t max; + int32_t *peaks; + + unsigned int *ratios; + unsigned int *max_ratios_in_second; + uint64_t total_frame_count; + + void (*printer)(struct vumeter_context *vu, char line[80]); + void (*calculator)(struct vumeter_context *vu, void *frame_buffer, + unsigned int frame_count); +}; + +int vumeter_context_init(struct vumeter_context *vu, enum vumeter_mode mode, + snd_pcm_access_t access, snd_pcm_format_t format, + unsigned int samples_per_frame, + unsigned int frames_per_second); +void vumeter_context_prepare(struct vumeter_context *vu); +void vumeter_context_calculate(struct vumeter_context *vu, void *frame_buffer, + unsigned int frame_count); +void vumeter_context_print(struct vumeter_context *vu); +void vumeter_context_break(struct vumeter_context *vu); +void vumeter_context_destroy(struct vumeter_context *vu); + +#endif diff --git a/axfer/xfer-libasound-irq-mmap.c b/axfer/xfer-libasound-irq-mmap.c index fb70bbc5..dcb8480e 100644 --- a/axfer/xfer-libasound-irq-mmap.c +++ b/axfer/xfer-libasound-irq-mmap.c @@ -70,7 +70,8 @@ static int irq_mmap_pre_process(struct libasound_state *state) static int irq_mmap_process_frames(struct libasound_state *state, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct map_layout *layout = state->private_data; const snd_pcm_channel_area_t *areas; @@ -139,6 +140,9 @@ static int irq_mmap_process_frames(struct libasound_state *state, if (consumed_count != avail_count) logging(state, "A bug of access plugin for this PCM node.\n");

+ if (vu) + vumeter_context_calculate(vu, frame_buf, consumed_count); + *frame_count = consumed_count;

return 0; @@ -150,7 +154,8 @@ error: static int irq_mmap_r_process_frames(struct libasound_state *state, unsigned *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct map_layout *layout = state->private_data; snd_pcm_state_t s; @@ -188,7 +193,7 @@ static int irq_mmap_r_process_frames(struct libasound_state *state, goto error; }

- err = irq_mmap_process_frames(state, frame_count, mapper, cntrs); + err = irq_mmap_process_frames(state, frame_count, mapper, cntrs, vu); if (err < 0) goto error;

@@ -201,7 +206,8 @@ error: static int irq_mmap_w_process_frames(struct libasound_state *state, unsigned *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct map_layout *layout = state->private_data; snd_pcm_state_t s; @@ -215,7 +221,7 @@ static int irq_mmap_w_process_frames(struct libasound_state *state,

/* TODO: if reporting something, do here with the status data. */

- err = irq_mmap_process_frames(state, frame_count, mapper, cntrs); + err = irq_mmap_process_frames(state, frame_count, mapper, cntrs, vu); if (err < 0) goto error;

diff --git a/axfer/xfer-libasound-irq-rw.c b/axfer/xfer-libasound-irq-rw.c index ad320f6f..ee5ce801 100644 --- a/axfer/xfer-libasound-irq-rw.c +++ b/axfer/xfer-libasound-irq-rw.c @@ -20,7 +20,8 @@ struct frame_cache {

int (*handle)(struct libasound_state *state, snd_pcm_state_t status, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs); + struct container_context *cntrs, + struct vumeter_context *vu); void (*align_frames)(struct frame_cache *cache, unsigned int consumed_count, unsigned int bytes_per_sample, @@ -73,7 +74,8 @@ static void align_frames_in_n(struct frame_cache *cache,

static int read_frames(struct libasound_state *state, unsigned int *frame_count, unsigned int avail_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct frame_cache *cache = state->private_data; unsigned int consumed_count; @@ -111,6 +113,9 @@ static int read_frames(struct libasound_state *state, unsigned int *frame_count, if (err < 0) return err;

+ if (vu) + vumeter_context_calculate(vu, cache->buf, consumed_count); + cache->align_frames(cache, consumed_count, cache->bytes_per_sample, cache->samples_per_frame);

@@ -123,7 +128,8 @@ static int r_process_frames_blocking(struct libasound_state *state, snd_pcm_state_t status, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { snd_pcm_sframes_t avail; snd_pcm_uframes_t avail_count; @@ -159,7 +165,7 @@ static int r_process_frames_blocking(struct libasound_state *state, avail_count = (unsigned int)frame_count; }

- err = read_frames(state, frame_count, avail_count, mapper, cntrs); + err = read_frames(state, frame_count, avail_count, mapper, cntrs, vu); if (err < 0) goto error;

@@ -173,7 +179,8 @@ static int r_process_frames_nonblocking(struct libasound_state *state, snd_pcm_state_t status, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { snd_pcm_sframes_t avail; snd_pcm_uframes_t avail_count; @@ -206,7 +213,7 @@ static int r_process_frames_nonblocking(struct libasound_state *state, goto error; }

- err = read_frames(state, frame_count, avail_count, mapper, cntrs); + err = read_frames(state, frame_count, avail_count, mapper, cntrs, vu); if (err < 0) goto error;

@@ -219,7 +226,8 @@ error: static int write_frames(struct libasound_state *state, unsigned int *frame_count, unsigned int avail_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct frame_cache *cache = state->private_data; snd_pcm_uframes_t consumed_count; @@ -254,6 +262,9 @@ static int write_frames(struct libasound_state *state, if (err < 0) return err;

+ if (vu) + vumeter_context_calculate(vu, cache->buf, consumed_count); + consumed_count = (unsigned int)err; cache->align_frames(cache, consumed_count, cache->bytes_per_sample, cache->samples_per_frame); @@ -267,7 +278,8 @@ static int w_process_frames_blocking(struct libasound_state *state, snd_pcm_state_t status, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { snd_pcm_sframes_t avail; unsigned int avail_count; @@ -323,7 +335,7 @@ static int w_process_frames_blocking(struct libasound_state *state, avail_count = (unsigned int)frames_per_period; }

- err = write_frames(state, frame_count, avail_count, mapper, cntrs); + err = write_frames(state, frame_count, avail_count, mapper, cntrs, vu); if (err < 0) goto error;

@@ -337,7 +349,8 @@ static int w_process_frames_nonblocking(struct libasound_state *state, snd_pcm_state_t status, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { snd_pcm_sframes_t avail; unsigned int avail_count; @@ -364,7 +377,7 @@ static int w_process_frames_nonblocking(struct libasound_state *state, goto error; }

- err = write_frames(state, frame_count, avail_count, mapper, cntrs); + err = write_frames(state, frame_count, avail_count, mapper, cntrs, vu); if (err < 0) goto error;

@@ -461,7 +474,8 @@ static int irq_rw_pre_process(struct libasound_state *state) static int irq_rw_process_frames(struct libasound_state *state, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct frame_cache *cache = state->private_data; snd_pcm_state_t status; @@ -472,7 +486,7 @@ static int irq_rw_process_frames(struct libasound_state *state, return -EPIPE;

/* NOTE: Actually, status can be shift always. */ - return cache->handle(state, status, frame_count, mapper, cntrs); + return cache->handle(state, status, frame_count, mapper, cntrs, vu); }

static void irq_rw_post_process(struct libasound_state *state) diff --git a/axfer/xfer-libasound-timer-mmap.c b/axfer/xfer-libasound-timer-mmap.c index 413b7958..90439414 100644 --- a/axfer/xfer-libasound-timer-mmap.c +++ b/axfer/xfer-libasound-timer-mmap.c @@ -121,7 +121,8 @@ static void *get_buffer(struct libasound_state *state, static int timer_mmap_process_frames(struct libasound_state *state, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct map_layout *layout = state->private_data; snd_pcm_uframes_t planned_count; @@ -215,6 +216,9 @@ static int timer_mmap_process_frames(struct libasound_state *state, } *frame_count = consumed_count;

+ if (vu) + vumeter_context_calculate(vu, frame_buf, *frame_count); + return 0; }

@@ -246,7 +250,8 @@ static int forward_appl_ptr(struct libasound_state *state) static int timer_mmap_r_process_frames(struct libasound_state *state, unsigned *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct map_layout *layout = state->private_data; snd_pcm_state_t s; @@ -280,7 +285,7 @@ static int timer_mmap_r_process_frames(struct libasound_state *state, }

err = timer_mmap_process_frames(state, frame_count, mapper, - cntrs); + cntrs, vu); if (err < 0) goto error; } else { @@ -384,7 +389,8 @@ static int fill_buffer_with_zero_samples(struct libasound_state *state) static int timer_mmap_w_process_frames(struct libasound_state *state, unsigned *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct map_layout *layout = state->private_data; snd_pcm_state_t s; @@ -411,7 +417,7 @@ static int timer_mmap_w_process_frames(struct libasound_state *state, }

err = timer_mmap_process_frames(state, frame_count, mapper, - cntrs); + cntrs, vu); if (err < 0) goto error; } else { diff --git a/axfer/xfer-libasound.c b/axfer/xfer-libasound.c index 12c90936..92aba3c4 100644 --- a/axfer/xfer-libasound.c +++ b/axfer/xfer-libasound.c @@ -562,7 +562,8 @@ static int xfer_libasound_pre_process(struct xfer_context *xfer, static int xfer_libasound_process_frames(struct xfer_context *xfer, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs) + struct container_context *cntrs, + struct vumeter_context *vu) { struct libasound_state *state = xfer->private_data; int err; @@ -570,7 +571,7 @@ static int xfer_libasound_process_frames(struct xfer_context *xfer, if (state->handle == NULL) return -ENXIO;

- err = state->ops->process_frames(state, frame_count, mapper, cntrs); + err = state->ops->process_frames(state, frame_count, mapper, cntrs, vu); if (err < 0) { if (err == -EPIPE && !state->finish_at_xrun) { /* diff --git a/axfer/xfer-libasound.h b/axfer/xfer-libasound.h index 5d399571..004613fa 100644 --- a/axfer/xfer-libasound.h +++ b/axfer/xfer-libasound.h @@ -41,7 +41,8 @@ struct xfer_libasound_ops { int (*process_frames)(struct libasound_state *state, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs); + struct container_context *cntrs, + struct vumeter_context *vu); void (*post_process)(struct libasound_state *state); unsigned int private_size; }; diff --git a/axfer/xfer.c b/axfer/xfer.c index 2f9f9422..211d9aa5 100644 --- a/axfer/xfer.c +++ b/axfer/xfer.c @@ -47,6 +47,14 @@ int xfer_context_init(struct xfer_context *xfer, enum xfer_type type, return -ENOMEM; memset(xfer->private_data, 0, entries[i].data->private_size);

+ if (opts->vu_mode != VUMETER_MODE_NONE) { + xfer->vu = malloc(sizeof(*xfer->vu)); + if (xfer->vu == NULL) + return -ENOMEM; + memset(xfer->vu, 0, sizeof(*xfer->vu)); + xfer->vu->mode = opts->vu_mode; + } + return xfer->ops->init(xfer, direction, opts); }

@@ -61,6 +69,10 @@ void xfer_context_destroy(struct xfer_context *xfer) xfer->ops->destroy(xfer); if (xfer->private_data) free(xfer->private_data); + + if (xfer->vu) + free(xfer->vu); + xfer->vu = NULL; }

int xfer_context_pre_process(struct xfer_context *xfer, @@ -97,6 +109,16 @@ int xfer_context_pre_process(struct xfer_context *xfer, assert(*access <= SND_PCM_ACCESS_LAST); assert(*frames_per_buffer > 0);

+ if (xfer->vu) { + err = vumeter_context_init(xfer->vu, xfer->vu->mode, *access, + *format, *samples_per_frame, + *frames_per_second); + if (err < 0) + return err; + + vumeter_context_prepare(xfer->vu); + } + if (xfer->verbose > 1) { fprintf(stderr, "Transfer: %s\n", xfer_type_labels[xfer->type]); @@ -122,6 +144,8 @@ int xfer_context_process_frames(struct xfer_context *xfer, struct container_context *cntrs, unsigned int *frame_count) { + int err; + assert(xfer); assert(mapper); assert(cntrs); @@ -130,7 +154,15 @@ int xfer_context_process_frames(struct xfer_context *xfer, if (!xfer->ops) return -ENXIO;

- return xfer->ops->process_frames(xfer, frame_count, mapper, cntrs); + err = xfer->ops->process_frames(xfer, frame_count, mapper, cntrs, + xfer->vu); + if (err < 0) + return err; + + if (xfer->vu) + vumeter_context_print(xfer->vu); + + return 0; }

void xfer_context_pause(struct xfer_context *xfer, bool enable) @@ -151,4 +183,9 @@ void xfer_context_post_process(struct xfer_context *xfer) return;

xfer->ops->post_process(xfer); + + if (xfer->vu) { + vumeter_context_break(xfer->vu); + vumeter_context_destroy(xfer->vu); + } } diff --git a/axfer/xfer.h b/axfer/xfer.h index 167c9903..eccf042c 100644 --- a/axfer/xfer.h +++ b/axfer/xfer.h @@ -23,6 +23,8 @@ struct xfer_context { const struct xfer_ops *ops; void *private_data;

+ struct vumeter_context *vu; + unsigned int verbose; };

@@ -57,7 +59,8 @@ struct xfer_ops { int (*process_frames)(struct xfer_context *xfer, unsigned int *frame_count, struct mapper_context *mapper, - struct container_context *cntrs); + struct container_context *cntrs, + struct vumeter_context *vu); void (*post_process)(struct xfer_context *xfer); void (*destroy)(struct xfer_context *xfer); void (*pause)(struct xfer_context *xfer, bool enable);

In aplay, an option for formatted file name is supported. The format text is mainly processed by strftime(3) function, however '%v' is available as an additional format for file number.

This commit adds support for the option. However, this feature has issue that strftime(3) generates string with characters out of portable filename characters such as '/' (). This feature is unsafe for users, for instance:

$ strace ./axfer transfer -C -D hw:0,0 --use-strftime /tmp/test-%D.wav ... open("/tmp/test-09/18/17.wav", O_RDWR|O_CREAT|O_TRUNC|O_NONBLOCK, 0644) = -1 ENOENT (No such file or directory) ...

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/options.c | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++--- axfer/options.h | 1 + 2 files changed, 94 insertions(+), 5 deletions(-)

diff --git a/axfer/options.c b/axfer/options.c index d595d857..6665f893 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -24,6 +24,7 @@ enum no_short_opts { OPT_DISABLE_FORMAT, OPT_DISABLE_SOFTVOL, OPT_SCHED_TYPE, + OPT_USE_STRFTIME, /* Obsoleted. */ OPT_MAX_FILE_TIME, }; @@ -403,6 +404,7 @@ int context_options_init(struct context_options *opts, int argc, {"samples", 1, 0, 's'}, /* For containers. */ {"file-type", 1, 0, 't'}, + {"use-strftime", 0, 0, OPT_USE_STRFTIME}, /* For mapper. */ {"separate-channels", 0, 0, 'I'}, /* For transfer backend. */ @@ -465,6 +467,8 @@ int context_options_init(struct context_options *opts, int argc, opts->duration_frames = parse_l(optarg, &err); else if (c == 't') cntr_format_literal = optarg; + else if (c == OPT_USE_STRFTIME) + opts->use_strftime = true; else if (c == 'I') opts->multiple_cntrs = true; else if (c == 'D') @@ -536,9 +540,81 @@ int context_options_init(struct context_options *opts, int argc, vu_mode_literal); }

+/* + * A variant of strftime(3) that supports additional format specifiers in the + * format string: + * '%v': file number. + * + * TODO: some format string gets unportable characters such as '/'. + */ +static int generate_path_with_strftime(struct context_options *opts, + const char *template, + unsigned int index, const char *suffix, + const struct tm *now) +{ + char *format; + unsigned int len; + char *pos; + char *name; + unsigned int width; + unsigned int i; + int err = 0; + + /* This might be enough to process formatted strings. */ + format = malloc(4096); + if (format == NULL) + return -ENOMEM; + + len = strftime(format, 4096, template, now); + if (len == 0) { + fprintf(stderr, "Invalid format string for strftime(3): %s\n", + template); + err = -EINVAL; + goto end; + } + format[len] = '\0'; + + width = (unsigned int)log10(index) + 1; + + /* Estimate required length for formatted result. */ + len = 0; + for (pos = format; *pos != '\0'; ++pos) { + ++len; + /* '%v' is unique format for numbering. */ + if (*pos == '%' && *(pos + 1) == 'v') + len += width; + } + len += strlen(suffix); + + name = malloc(len + 1); + if (name == NULL) { + err = -ENOMEM; + goto end; + } + + i = 0; + for (pos = format; *pos != '\0' && i < len; ++pos) { + if (*pos == '%' && *(pos + 1) == 'v') { + i += snprintf(name + i, len - i, "%u", index); + /* Consume 2 characters in the format string. */ + ++pos; + } else { + name[i] = *pos; + ++i; + } + } + strcpy(name + i, suffix); + name[len] = '\0'; + + opts->paths[index] = name; +end: + free(format); + return err; +} + static int generate_path_with_suffix(struct context_options *opts, const char *template, unsigned int index, - const char *suffix) + const char *suffix, const struct tm *now) { static const char *const single_format = "%s%s"; static const char *const multiple_format = "%s-%i%s"; @@ -565,7 +641,8 @@ static int generate_path_with_suffix(struct context_options *opts,

static int generate_path_without_suffix(struct context_options *opts, const char *template, - unsigned int index, const char *suffix) + unsigned int index, const char *suffix, + const struct tm *now) { static const char *const single_format = "%s"; static const char *const multiple_format = "%s-%i"; @@ -593,8 +670,17 @@ static int generate_path(struct context_options *opts, char *template, unsigned int index, const char *suffix) { int (*generator)(struct context_options *opts, const char *template, - unsigned int index, const char *suffix); + unsigned int index, const char *suffix, + const struct tm *now); char *pos; + time_t now_time; + struct tm now_tm; + + now_time = time(NULL); + if ((int)now_time < 0) + return -errno; + if (localtime_r(&now_time, &now_tm) == NULL) + return -errno;

if (strlen(suffix) > 0) { pos = template + strlen(template) - strlen(suffix); @@ -604,12 +690,14 @@ static int generate_path(struct context_options *opts, char *template, }

/* Select handlers. */ - if (strlen(suffix) > 0) + if (opts->use_strftime) + generator = generate_path_with_strftime; + else if (strlen(suffix) > 0) generator = generate_path_with_suffix; else generator = generate_path_without_suffix;

- return generator(opts, template, index, suffix); + return generator(opts, template, index, suffix, &now_tm); }

static int create_paths(struct context_options *opts, unsigned int path_count) diff --git a/axfer/options.h b/axfer/options.h index 188668b0..2092796e 100644 --- a/axfer/options.h +++ b/axfer/options.h @@ -32,6 +32,7 @@ struct context_options { char **paths; unsigned int path_count; enum container_format cntr_format; + bool use_strftime;

/* For mapper. */ bool multiple_cntrs;

Current aplay has an option to use channel map API of alsa-lib. This API allows applications to get/set channel position by a position array; e.g. 'FR,FL' and 'LFE,FL,FR'.

This commit adds support for the feature. However, neither alsa-lib implementation nor ALSA PCM interface, configuring the channel map is not supported. Therefore, this feature makes no sense except for displaying current channel map.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/options.c | 29 ++++++++++++++++++++++++++--- axfer/options.h | 1 + axfer/xfer-libasound.c | 32 ++++++++++++++++++++++++++++++++ axfer/xfer-libasound.h | 2 ++ 4 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/axfer/options.c b/axfer/options.c index d4e7876b..7e112c42 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -205,7 +205,8 @@ static int apply_policies(struct context_options *opts, const char *sample_format_literal, const char *waiter_type_literal, const char *sched_type_literal, - const char *vu_mode_literal) + const char *vu_mode_literal, + const char *chmap_literal) { int err;

@@ -238,6 +239,21 @@ static int apply_policies(struct context_options *opts, return err; }

+ if (chmap_literal) { + snd_pcm_chmap_t *chmap; + chmap = snd_pcm_chmap_parse_string(chmap_literal); + if (chmap == NULL) { + fprintf(stderr, + "Unable to parse channel map string: '%s'\n", + chmap_literal); + return -EINVAL; + } + free(chmap); + opts->chmap_literal = strdup(chmap_literal); + if (opts->chmap_literal == NULL) + return -ENOMEM; + } + if (opts->samples_per_frame > 0) { if (opts->samples_per_frame < 1 || opts->samples_per_frame > 256) { @@ -409,7 +425,7 @@ void context_options_calculate_duration(struct context_options *opts, int context_options_init(struct context_options *opts, int argc, char *const *argv, snd_pcm_stream_t direction) { - static const char *s_opts = "hvqd:s:t:ID:f:c:r:NMw:F:B:A:R:T:V:i"; + static const char *s_opts = "hvqd:s:t:ID:f:c:r:NMw:F:B:A:R:T:V:im:"; static const struct option l_opts[] = { /* For generic purposes. */ {"help", 0, 0, 'h'}, @@ -451,6 +467,7 @@ int context_options_init(struct context_options *opts, int argc, /* Misc features. */ {"vumeter", 1, 0, 'V'}, {"interactive", 0, 0, 'i'}, + {"chmap", 1, 0, 'm'}, /* Obsoleted. */ {"max-file-time", 1, 0, OPT_MAX_FILE_TIME}, {NULL, 0, 0, 0}, @@ -461,6 +478,7 @@ int context_options_init(struct context_options *opts, int argc, const char *waiter_type_literal = NULL; const char *sched_type_literal = NULL; const char *vu_mode_literal = NULL; + const char *chmap_literal = NULL; int l_index = 0; int c; int err = 0; @@ -535,6 +553,8 @@ int context_options_init(struct context_options *opts, int argc, vu_mode_literal = optarg; else if (c == 'i') opts->interactive = true; + else if (c == 'm') + chmap_literal = optarg; else if (c == OPT_MAX_FILE_TIME) { fprintf(stderr, "An option '--%s' is obsoleted and has no " @@ -555,7 +575,7 @@ int context_options_init(struct context_options *opts, int argc, return apply_policies(opts, direction, cntr_format_literal, node_literal, sample_format_literal, waiter_type_literal, sched_type_literal, - vu_mode_literal); + vu_mode_literal, chmap_literal); }

/* @@ -909,6 +929,9 @@ void context_options_destroy(struct context_options *opts) } if (opts->node) free(opts->node); + if (opts->chmap_literal) + free(opts->chmap_literal); opts->paths = NULL; opts->node = NULL; + opts->chmap_literal = NULL; } diff --git a/axfer/options.h b/axfer/options.h index fed9a40e..b8aba167 100644 --- a/axfer/options.h +++ b/axfer/options.h @@ -73,6 +73,7 @@ struct context_options { /* Misc features. */ enum vumeter_mode vu_mode; bool interactive; + char *chmap_literal; };

int context_options_init(struct context_options *opts, int argc, diff --git a/axfer/xfer-libasound.c b/axfer/xfer-libasound.c index 92aba3c4..4e8c6e2e 100644 --- a/axfer/xfer-libasound.c +++ b/axfer/xfer-libasound.c @@ -84,6 +84,17 @@ static int disable_period_wakeup(struct libasound_state *state) return err; }

+static void dump_chmap(struct libasound_state *state, + const snd_pcm_chmap_t *chmap) +{ + int i; + + logging(state, " channels: %u\n", chmap->channels); + for (i = 0; i < chmap->channels; ++i) + logging(state, " ch%u: %s\n", + i, snd_pcm_chmap_name(chmap->pos[i])); +} + static int xfer_libasound_init(struct xfer_context *xfer, snd_pcm_stream_t direction, struct context_options *opts) @@ -152,6 +163,17 @@ static int xfer_libasound_init(struct xfer_context *xfer, return 0; }

+ if (opts->chmap_literal != NULL) { + state->chmap = snd_pcm_chmap_parse_string(opts->chmap_literal); + if (state->chmap == NULL) + return -ENOMEM; + + if (xfer->verbose) { + logging(state, "Chmap argument:\n"); + dump_chmap(state, state->chmap); + } + } + return set_access_hw_param(state->handle, state->hw_params, opts); }

@@ -238,6 +260,12 @@ static int configure_hw_params(struct libasound_state *state, return err; } } + if (state->chmap && samples_per_frame != state->chmap->channels) { + logging(state, + _("Mismatch between channel number and given map: %u " + "%u\n"), + samples_per_frame, state->chmap->channels); + } err = snd_pcm_hw_params_set_channels(state->handle, state->hw_params, samples_per_frame); if (err < 0) { @@ -690,6 +718,10 @@ static void xfer_libasound_destroy(struct xfer_context *xfer) if (state->log) snd_output_close(state->log); state->log = NULL; + + if (state->chmap) + free(state->chmap); + state->chmap = NULL; }

const struct xfer_data xfer_libasound = { diff --git a/axfer/xfer-libasound.h b/axfer/xfer-libasound.h index 004613fa..11e610d8 100644 --- a/axfer/xfer-libasound.h +++ b/axfer/xfer-libasound.h @@ -34,6 +34,8 @@ struct libasound_state {

bool verbose; bool finish_at_xrun; + + snd_pcm_chmap_t *chmap; };

struct xfer_libasound_ops {

In aplay, some test options are available, however their test strategy is not enough good to check runtime of PCM substream.

This commit obsoletes these options.

Signed-off-by: Takashi Sakamoto o-takashi@sakamocchi.jp --- axfer/options.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/axfer/options.c b/axfer/options.c index 6e935cd1..baddfb27 100644 --- a/axfer/options.c +++ b/axfer/options.c @@ -30,6 +30,8 @@ enum no_short_opts { OPT_PROCESS_ID_FILE, /* Obsoleted. */ OPT_MAX_FILE_TIME, + OPT_TEST_POSITION, + OPT_TEST_COEF, };

static const char *const allowed_duplication[] = { @@ -499,6 +501,8 @@ int context_options_init(struct context_options *opts, int argc, {"process-id-file", 1, 0, OPT_PROCESS_ID_FILE}, /* Obsoleted. */ {"max-file-time", 1, 0, OPT_MAX_FILE_TIME}, + {"test-position", 0, 0, OPT_TEST_POSITION}, + {"test-coef", 1, 0, OPT_TEST_COEF}, {NULL, 0, 0, 0}, }; const char *cntr_format_literal = NULL; @@ -587,7 +591,9 @@ int context_options_init(struct context_options *opts, int argc, chmap_literal = optarg; else if (c == OPT_PROCESS_ID_FILE) pidfile_name_literal = optarg; - else if (c == OPT_MAX_FILE_TIME) { + else if (c == OPT_MAX_FILE_TIME || + c == OPT_TEST_POSITION || + c == OPT_TEST_COEF) { fprintf(stderr, "An option '--%s' is obsoleted and has no " "effect.\n",