// 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),
};