xref: /third_party/alsa-utils/axfer/mapper-multiple.c (revision c72fcc34)

// SPDX-License-Identifier: GPL-2.0
//
// mapper-multiple.c - a muxer/demuxer for multiple 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 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;
	unsigned 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;
	unsigned 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;
	unsigned 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 (cntr->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;
	unsigned 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;
	unsigned 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),
};