// SPDX-License-Identifier: GPL-2.0

//

// mapper-io.c - a unit test for muxer/demuxer for PCM frames on buffer.

//

// 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"

#include "generator.h"

#include <stdlib.h>

#include <unistd.h>

#include <stdbool.h>

#include <assert.h>

struct mapper_trial {

	enum container_format cntr_format;

	struct container_context *cntrs;

	char **paths;

	struct mapper_context mapper;

	bool verbose;

};

static void test_demuxer(struct mapper_context *mapper, snd_pcm_access_t access,

			 unsigned int bytes_per_sample,

			 unsigned int samples_per_frame,

			 unsigned int frames_per_buffer,

			 void *frame_buffer, unsigned int frame_count,

			 struct container_context *cntrs,

			 unsigned int cntr_count, bool verbose)

{

	unsigned int total_frame_count;

	int err;

	err = mapper_context_init(mapper, MAPPER_TYPE_DEMUXER, cntr_count,

				  verbose);

	assert(err == 0);

	err = mapper_context_pre_process(mapper, access, bytes_per_sample,

					 samples_per_frame, frames_per_buffer,

					 cntrs);

	assert(err == 0);

	total_frame_count = frame_count;

	err = mapper_context_process_frames(mapper, frame_buffer,

					    &total_frame_count, cntrs);

	assert(err == 0);

	assert(total_frame_count == frame_count);

	mapper_context_post_process(mapper);

	mapper_context_destroy(mapper);

}

static int test_demux(struct mapper_trial *trial, snd_pcm_access_t access,

		      snd_pcm_format_t sample_format,

		      unsigned int samples_per_frame,

		      unsigned int frames_per_second,

		      unsigned int frames_per_buffer,

		      void *frame_buffer, unsigned int frame_count,

		      unsigned int cntr_count)

{

	struct container_context *cntrs = trial->cntrs;

	char **paths = trial->paths;

	enum container_format cntr_format = trial->cntr_format;

	unsigned int bytes_per_sample;

	uint64_t total_frame_count;

	int i;

	int err = 0;

	for (i = 0; i < cntr_count; ++i) {

		snd_pcm_format_t format;

		unsigned int channels;

		unsigned int rate;

		err = container_builder_init(cntrs + i, paths[i], cntr_format,

					     0);

		if (err < 0)

			goto end;

		format = sample_format;

		rate = frames_per_second;

		total_frame_count = frame_count;

		if (cntr_count > 1)

			channels = 1;

		else

			channels = samples_per_frame;

		err = container_context_pre_process(cntrs + i, &format,

						    &channels, &rate,

						    &total_frame_count);

		if (err < 0)

			goto end;

		assert(format == sample_format);

		assert(rate == frames_per_second);

		assert(total_frame_count >= 0);

		if (cntr_count > 1)

			assert(channels == 1);

		else

			assert(channels == samples_per_frame);

	}

	bytes_per_sample = snd_pcm_format_physical_width(sample_format) / 8;

	test_demuxer(&trial->mapper, access, bytes_per_sample,

		     samples_per_frame, frames_per_buffer, frame_buffer,

		     frame_count, cntrs, cntr_count, trial->verbose);

	for (i = 0; i < cntr_count; ++i) {

		container_context_post_process(cntrs + i, &total_frame_count);

		assert(total_frame_count == frame_count);

	}

end:

	for (i = 0; i < cntr_count; ++i)

		container_context_destroy(cntrs + i);

	return err;

}

static void test_muxer(struct mapper_context *mapper, snd_pcm_access_t access,

		       unsigned int bytes_per_sample,

		       unsigned int samples_per_frame,

		       unsigned int frames_per_buffer,

		       void *frame_buffer, unsigned int frame_count,

		       struct container_context *cntrs,

		       unsigned int cntr_count, bool verbose)

{

	unsigned int total_frame_count;

	int err;

	err = mapper_context_init(mapper, MAPPER_TYPE_MUXER, cntr_count,

				  verbose);

	assert(err == 0);

	err = mapper_context_pre_process(mapper, access, bytes_per_sample,

					 samples_per_frame, frames_per_buffer,

					 cntrs);

	assert(err == 0);

	total_frame_count = frame_count;

	err = mapper_context_process_frames(mapper, frame_buffer,

					    &total_frame_count, cntrs);

	assert(err == 0);

	assert(total_frame_count == frame_count);

	mapper_context_post_process(mapper);

	mapper_context_destroy(mapper);

}

static int test_mux(struct mapper_trial *trial, snd_pcm_access_t access,

		    snd_pcm_format_t sample_format,

		    unsigned int samples_per_frame,

		    unsigned int frames_per_second,

		    unsigned int frames_per_buffer,

		    void *frame_buffer, unsigned int frame_count,

		    unsigned int cntr_count)

{

	struct container_context *cntrs = trial->cntrs;

	char **paths = trial->paths;

	unsigned int bytes_per_sample;

	uint64_t total_frame_count;

	int i;

	int err = 0;

	for (i = 0; i < cntr_count; ++i) {

		snd_pcm_format_t format;

		unsigned int channels;

		unsigned int rate;

		err = container_parser_init(cntrs + i, paths[i], 0);

		if (err < 0)

			goto end;

		format = sample_format;

		rate = frames_per_second;

		if (cntr_count > 1)

			channels = 1;

		else

			channels = samples_per_frame;

		err = container_context_pre_process(cntrs + i, &format,

						    &channels, &rate,

						    &total_frame_count);

		if (err < 0)

			goto end;

		assert(format == sample_format);

		assert(rate == frames_per_second);

		assert(total_frame_count == frame_count);

		if (cntr_count > 1)

			assert(channels == 1);

		else

			assert(channels == samples_per_frame);

	}

	bytes_per_sample = snd_pcm_format_physical_width(sample_format) / 8;

	test_muxer(&trial->mapper, access, bytes_per_sample, samples_per_frame,

		   frames_per_buffer, frame_buffer, frame_count, cntrs,

		   cntr_count, trial->verbose);

	for (i = 0; i < cntr_count; ++i) {

		container_context_post_process(cntrs + i, &total_frame_count);

		assert(total_frame_count == frame_count);

	}

end:

	for (i = 0; i < cntr_count; ++i)

		container_context_destroy(cntrs + i);

	return err;

}

static int test_mapper(struct mapper_trial *trial, snd_pcm_access_t access,

		    snd_pcm_format_t sample_format,

		    unsigned int samples_per_frame,

		    unsigned int frames_per_second, void *frame_buffer,

		    void *check_buffer, unsigned int frame_count,

		    unsigned int cntr_count)

{

	unsigned int frames_per_buffer;

	int i;

	int err;

	// Use a buffer aligned by typical size of page frame.

	frames_per_buffer = ((frame_count + 4096) / 4096) * 4096;

	err = test_demux(trial, access, sample_format, samples_per_frame,

			 frames_per_second, frames_per_buffer, frame_buffer,

			 frame_count, cntr_count);

	if (err < 0)

		goto end;

	err = test_mux(trial, access, sample_format, samples_per_frame,

		       frames_per_second, frames_per_buffer, check_buffer,

		       frame_count, cntr_count);

end:

	for (i = 0; i < cntr_count; ++i)

		unlink(trial->paths[i]);

	return err;

}

static int test_i_buf(struct mapper_trial *trial, snd_pcm_access_t access,

		      snd_pcm_format_t sample_format,

		      unsigned int samples_per_frame,

		      unsigned int frames_per_second, void *frame_buffer,

		      unsigned int frame_count, unsigned int cntr_count)

{

	unsigned int size;

	char *buf;

	int err;

	size = frame_count * samples_per_frame *

			snd_pcm_format_physical_width(sample_format) / 8;

	buf = malloc(size);

	if (buf == 0)

		return -ENOMEM;

	memset(buf, 0, size);

	// Test multiple target.

	err = test_mapper(trial, access, sample_format, samples_per_frame,

			  frames_per_second, frame_buffer, buf,

			  frame_count, cntr_count);

	if (err < 0)

		goto end;

	err = memcmp(frame_buffer, buf, size);

	assert(err == 0);

	// Test single target.

	err = test_mapper(trial, access, sample_format, samples_per_frame,

			  frames_per_second, frame_buffer, buf,

			  frame_count, 1);

	if (err < 0)

		goto end;

	err = memcmp(frame_buffer, buf, size);

	assert(err == 0);

end:

	free(buf);

	return err;

}

static int test_vector(struct mapper_trial *trial, snd_pcm_access_t access,

		       snd_pcm_format_t sample_format,

		       unsigned int samples_per_frame,

		       unsigned int frames_per_second, void *frame_buffer,

		       unsigned int frame_count, unsigned int cntr_count)

{

	unsigned int size;

	char **bufs;

	int i;

	int err;

	bufs = calloc(cntr_count, sizeof(*bufs));

	if (bufs == NULL)

		return -ENOMEM;

	size = frame_count * snd_pcm_format_physical_width(sample_format) / 8;

	for (i = 0; i < cntr_count; ++i) {

		bufs[i] = malloc(size);

		if (bufs[i] == NULL) {

			err = -ENOMEM;

			goto end;

		}

		memset(bufs[i], 0, size);

	}

	// Test multiple target.

	err = test_mapper(trial, access, sample_format, samples_per_frame,

			  frames_per_second, frame_buffer, bufs,

			  frame_count, cntr_count);

	if (err < 0)

		goto end;

	for (i = 0; i < cntr_count; ++i) {

		char **target = frame_buffer;

		err = memcmp(target[i], bufs[i], size);

		assert(err == 0);

	}

	// Test single target.

	err = test_mapper(trial, access, sample_format, samples_per_frame,

			  frames_per_second, frame_buffer, bufs,

			  frame_count, 1);

	if (err < 0)

		goto end;

	for (i = 0; i < cntr_count; ++i) {

		char **target = frame_buffer;

		err = memcmp(target[i], bufs[i], size);

		assert(err == 0);

	}

end:

	for (i = 0; i < cntr_count; ++i) {

		if (bufs[i])

			free(bufs[i]);

	}

	free(bufs);

	return err;

}

static int test_n_buf(struct mapper_trial *trial, snd_pcm_access_t access,

		      snd_pcm_format_t sample_format,

		      unsigned int samples_per_frame,

		      unsigned int frames_per_second, void *frame_buffer,

		      unsigned int frame_count, unsigned int cntr_count)

{

	char *test_buf = frame_buffer;

	unsigned int size;

	char **test_vec;

	int i;

	int err;

	size = frame_count * snd_pcm_format_physical_width(sample_format) / 8;

	test_vec = calloc(cntr_count * 2, sizeof(*test_vec));

	if (test_vec == NULL)

		return -ENOMEM;

	for (i = 0; i < cntr_count; ++i)

		test_vec[i] = test_buf + size * i;

	err = test_vector(trial, access, sample_format, samples_per_frame,

			  frames_per_second, test_vec, frame_count, cntr_count);

	free(test_vec);

	return err;

}

static int callback(struct test_generator *gen, snd_pcm_access_t access,

		    snd_pcm_format_t sample_format,

		    unsigned int samples_per_frame, void *frame_buffer,

		    unsigned int frame_count)

{

	int (*handler)(struct mapper_trial *trial, snd_pcm_access_t access,

		       snd_pcm_format_t sample_format,

		       unsigned int samples_per_frame,

		       unsigned int frames_per_second, void *frame_buffer,

		       unsigned int frame_count, unsigned int cntr_count);

	struct mapper_trial *trial = gen->private_data;

	if (access == SND_PCM_ACCESS_RW_NONINTERLEAVED)

		handler = test_vector;

	else if (access == SND_PCM_ACCESS_MMAP_NONINTERLEAVED)

		handler = test_n_buf;

	else

		handler = test_i_buf;

	return handler(trial, access, sample_format, samples_per_frame, 48000,

		       frame_buffer, frame_count, samples_per_frame);

};

int main(int argc, const char *argv[])

{

	// Test 8/16/18/20/24/32/64 bytes per sample.

	static const uint64_t sample_format_mask =

			(1ull << SND_PCM_FORMAT_U8) |

			(1ull << SND_PCM_FORMAT_S16_LE) |

			(1ull << SND_PCM_FORMAT_S18_3LE) |

			(1ull << SND_PCM_FORMAT_S20_3LE) |

			(1ull << SND_PCM_FORMAT_S24_LE) |

			(1ull << SND_PCM_FORMAT_S32_LE) |

			(1ull << SND_PCM_FORMAT_FLOAT64_LE);

	uint64_t access_mask;

	struct test_generator gen = {0};

	struct mapper_trial *trial;

	struct container_context *cntrs;

	unsigned int samples_per_frame;

	char **paths = NULL;

	snd_pcm_access_t access;

	bool verbose;

	int i;

	int err;

	// Test up to 32 channels.

	samples_per_frame = 32;

	cntrs = calloc(samples_per_frame, sizeof(*cntrs));

	if (cntrs == NULL)

		return -ENOMEM;

	paths = calloc(samples_per_frame, sizeof(*paths));

	if (paths == NULL) {

		err = -ENOMEM;

		goto end;

	}

	for (i = 0; i < samples_per_frame; ++i) {

		paths[i] = malloc(8);

		if (paths[i] == NULL) {

			err = -ENOMEM;

			goto end;

		}

		snprintf(paths[i], 8, "hoge%d", i);

	}

	if (argc > 1) {

		char *term;

		access = strtol(argv[1], &term, 10);

		if (errno != 0 || *term != '\0') {

			err = -EINVAL;;

			goto end;

		}

		if (access < SND_PCM_ACCESS_MMAP_INTERLEAVED &&

		    access > SND_PCM_ACCESS_RW_NONINTERLEAVED) {

			err = -EINVAL;

			goto end;

		}

		if (access == SND_PCM_ACCESS_MMAP_COMPLEX) {

			err = -EINVAL;

			goto end;

		}

		access_mask = 1ull << access;

		verbose = true;

	} else {

		access_mask = (1ull << SND_PCM_ACCESS_MMAP_INTERLEAVED) |

			      (1ull << SND_PCM_ACCESS_MMAP_NONINTERLEAVED) |

			      (1ull << SND_PCM_ACCESS_RW_INTERLEAVED) |

			      (1ull << SND_PCM_ACCESS_RW_NONINTERLEAVED);

		verbose = false;

	}

	err = generator_context_init(&gen, access_mask, sample_format_mask,

				     1, samples_per_frame,

				     23, 4500, 1024,

				     sizeof(struct mapper_trial));

	if (err < 0)

		goto end;

	trial = gen.private_data;

	trial->cntrs = cntrs;

	trial->cntr_format = CONTAINER_FORMAT_RIFF_WAVE;

	trial->paths = paths;

	trial->verbose = verbose;

	err = generator_context_run(&gen, callback);

	generator_context_destroy(&gen;;

end:

	if (paths) {

		for (i = 0; i < samples_per_frame; ++i)

			free(paths[i]);

		free(paths);

	}

	free(cntrs);

	if (err < 0) {

		printf("%s\n", strerror(-err));

		return EXIT_FAILURE;

	}

	return EXIT_SUCCESS;

}