--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+//
+// mapper-single.c - a muxer/demuxer for single containers.
+//
+// Copyright (c) 2018 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 single_state {
+ void (*align_frames)(void *frame_buf, unsigned int frame_count,
+ char *buf, unsigned int bytes_per_sample,
+ unsigned int samples_per_frame);
+ char *buf;
+};
+
+static void align_to_vector(void *frame_buf, unsigned int frame_count,
+ char *src, unsigned int bytes_per_sample,
+ unsigned samples_per_frame)
+{
+ char **dst_bufs = frame_buf;
+ char *dst;
+ unsigned int src_pos;
+ unsigned int dst_pos;
+ int i, j;
+
+ // src: interleaved => dst: a set of interleaved buffers.
+ for (i = 0; i < samples_per_frame; ++i) {
+ dst = dst_bufs[i];
+ for (j = 0; j < frame_count; ++j) {
+ src_pos = bytes_per_sample * (samples_per_frame * j + i);
+ dst_pos = bytes_per_sample * j;
+
+ memcpy(dst + dst_pos, src + src_pos, bytes_per_sample);
+ }
+ }
+}
+
+static void align_from_vector(void *frame_buf, unsigned int frame_count,
+ char *dst, unsigned int bytes_per_sample,
+ unsigned int samples_per_frame)
+{
+ char **src_bufs = frame_buf;
+ char *src;
+ unsigned int dst_pos;
+ unsigned int src_pos;
+ int i, j;
+
+ // src: a set of interleaved buffers => dst:interleaved.
+ for (i = 0; i < samples_per_frame; ++i) {
+ src = src_bufs[i];
+ for (j = 0; j < frame_count; ++j) {
+ src_pos = bytes_per_sample * j;
+ dst_pos = bytes_per_sample * (samples_per_frame * j + i);
+
+ memcpy(dst + dst_pos, src + src_pos, bytes_per_sample);
+ }
+ }
+}
+
+static int single_pre_process(struct mapper_context *mapper,
+ struct container_context *cntrs,
+ unsigned int cntr_count)
+{
+ struct single_state *state = mapper->private_data;
+ unsigned int bytes_per_buffer;
+
+ if (cntrs->bytes_per_sample != mapper->bytes_per_sample ||
+ cntrs->samples_per_frame != mapper->samples_per_frame)
+ return -EINVAL;
+
+ // Decide method to align frames.
+ if (mapper->type == MAPPER_TYPE_DEMUXER) {
+ if (mapper->access == SND_PCM_ACCESS_RW_NONINTERLEAVED ||
+ mapper->access == SND_PCM_ACCESS_MMAP_NONINTERLEAVED)
+ state->align_frames = align_from_vector;
+ else if (mapper->access == SND_PCM_ACCESS_RW_INTERLEAVED ||
+ mapper->access == SND_PCM_ACCESS_MMAP_INTERLEAVED)
+ state->align_frames = NULL;
+ else
+ return -EINVAL;
+ } else {
+ if (mapper->access == SND_PCM_ACCESS_RW_NONINTERLEAVED ||
+ mapper->access == SND_PCM_ACCESS_MMAP_NONINTERLEAVED)
+ state->align_frames = align_to_vector;
+ else if (mapper->access == SND_PCM_ACCESS_RW_INTERLEAVED ||
+ mapper->access == SND_PCM_ACCESS_MMAP_INTERLEAVED)
+ state->align_frames = NULL;
+ else
+ return -EINVAL;
+ }
+
+ if (state->align_frames) {
+ // Allocate intermediate buffer as the same size as a period.
+ bytes_per_buffer = mapper->bytes_per_sample *
+ mapper->samples_per_frame *
+ mapper->frames_per_buffer;
+ state->buf = malloc(bytes_per_buffer);
+ if (state->buf == NULL)
+ return -ENOMEM;
+ memset(state->buf, 0, bytes_per_buffer);
+ }
+
+ return 0;
+}
+
+static int single_muxer_process_frames(struct mapper_context *mapper,
+ void *frame_buf,
+ unsigned int *frame_count,
+ struct container_context *cntrs,
+ unsigned int cntr_count)
+{
+ struct single_state *state = mapper->private_data;
+ void *src;
+ int err;
+
+ // If need to align PCM frames, process PCM frames to the intermediate
+ // buffer once.
+ if (!state->align_frames) {
+ // The most likely.
+ src = frame_buf;
+ } else {
+ src = state->buf;
+ }
+ err = container_context_process_frames(cntrs, src, frame_count);
+ if (err < 0)
+ return err;
+
+ // Unlikely.
+ if (src != frame_buf && *frame_count > 0)
+ state->align_frames(frame_buf, *frame_count, src,
+ mapper->bytes_per_sample,
+ mapper->samples_per_frame);
+
+ return 0;
+}
+
+static int single_demuxer_process_frames(struct mapper_context *mapper,
+ void *frame_buf,
+ unsigned int *frame_count,
+ struct container_context *cntrs,
+ unsigned int cntr_count)
+{
+ struct single_state *state = mapper->private_data;
+ void *dst;
+
+ // If need to align PCM frames, process PCM frames to the intermediate
+ // buffer once.
+ if (!state->align_frames) {
+ // The most likely.
+ dst = frame_buf;
+ } else {
+ state->align_frames(frame_buf, *frame_count, state->buf,
+ mapper->bytes_per_sample,
+ mapper->samples_per_frame);
+ dst = state->buf;
+ }
+
+ return container_context_process_frames(cntrs, dst, frame_count);
+}
+
+static void single_post_process(struct mapper_context *mapper)
+{
+ struct single_state *state = mapper->private_data;
+
+ if (state->buf)
+ free(state->buf);
+
+ state->buf = NULL;
+ state->align_frames = NULL;
+}
+
+const struct mapper_data mapper_muxer_single = {
+ .ops = {
+ .pre_process = single_pre_process,
+ .process_frames = single_muxer_process_frames,
+ .post_process = single_post_process,
+ },
+ .private_size = sizeof(struct single_state),
+};
+
+const struct mapper_data mapper_demuxer_single = {
+ .ops = {
+ .pre_process = single_pre_process,
+ .process_frames = single_demuxer_process_frames,
+ .post_process = single_post_process,
+ },
+ .private_size = sizeof(struct single_state),
+};