// SPDX-License-Identifier: GPL-2.0

//

// allocator.h - a header of a generator for test with buffers of PCM frames.

//

// Copyright (c) 2018 Takashi Sakamoto <o-takashi@sakamocchi.jp>

//

// Licensed under the terms of the GNU General Public License, version 2.

#include "generator.h"

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

int generator_context_init(struct test_generator *gen,

			   uint64_t access_mask, uint64_t sample_format_mask,

			   unsigned int min_samples_per_frame,

			   unsigned int max_samples_per_frame,

			   unsigned int min_frame_count,

			   unsigned int max_frame_count,

			   unsigned int step_frame_count,

			   unsigned int private_size)

{

	gen->fd = open("/dev/urandom", O_RDONLY);

	if (gen->fd < 0)

		return -errno;

	gen->private_data = malloc(private_size);

	if (gen->private_data == NULL)

		return -ENOMEM;

	memset(gen->private_data, 0, private_size);

	gen->access_mask = access_mask;

	gen->sample_format_mask = sample_format_mask;

	gen->min_samples_per_frame = min_samples_per_frame;

	gen->max_samples_per_frame = max_samples_per_frame;

	gen->min_frame_count = min_frame_count;

	gen->max_frame_count = max_frame_count;

	gen->step_frame_count = step_frame_count;

	return 0;

}

static void *allocate_buf(snd_pcm_access_t access,

			  snd_pcm_format_t sample_format,

			  unsigned int samples_per_frame,

			  unsigned int frame_count)

{

	unsigned int bytes_per_sample;

	bytes_per_sample = snd_pcm_format_physical_width(sample_format) / 8;

	return calloc(samples_per_frame * frame_count, bytes_per_sample);

}

static void *allocate_vector(snd_pcm_access_t access,

			     snd_pcm_format_t sample_format,

			     unsigned int samples_per_frame,

			     unsigned int frame_count)

{

	unsigned int bytes_per_sample;

	char **bufs;

	int i;

	bytes_per_sample = snd_pcm_format_physical_width(sample_format) / 8;

	bufs = calloc(samples_per_frame, sizeof(char *));

	if (bufs == NULL)

		return NULL;

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

		bufs[i] = calloc(frame_count, bytes_per_sample);

		if (bufs[i] == NULL) {

			for (; i >= 0; --i)

				free(bufs[i]);

			free(bufs);

			return NULL;

		}

	}

	return bufs;

}

static int fill_buf(int fd, void *frame_buffer, snd_pcm_access_t access,

		    snd_pcm_format_t sample_format,

		    unsigned int samples_per_frame, unsigned int frame_count)

{

	unsigned int size;

	int len;

	size = snd_pcm_format_physical_width(sample_format) / 8 *

						samples_per_frame * frame_count;

	while (size > 0) {

		len = read(fd, frame_buffer, size);

		if (len < 0)

			return len;

		size -= len;

	}

	return 0;

}

static int fill_vector(int fd, void *frame_buffer, snd_pcm_access_t access,

		       snd_pcm_format_t sample_format,

		       unsigned int samples_per_frame, unsigned int frame_count)

{

	char **bufs = frame_buffer;

	unsigned int size;

	int len;

	int i;

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

		size = frame_count *

			snd_pcm_format_physical_width(sample_format) / 8;

		while (size > 0) {

			len = read(fd, bufs[i], size);

			if (len < 0)

				return len;

			size -= len;

		}

	}

	return 0;

}

static void deallocate_buf(void *frame_buffer, unsigned int samples_per_frame)

{

	free(frame_buffer);

}

static void deallocate_vector(void *frame_buffer,

			      unsigned int samples_per_frame)

{

	char **bufs = frame_buffer;

	int i;

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

		free(bufs[i]);

	free(bufs);

}

static int test_frame_count(struct test_generator *gen,

			    snd_pcm_access_t access,

			    snd_pcm_format_t sample_format,

			    unsigned int samples_per_frame)

{

	void *(*allocator)(snd_pcm_access_t access,

			   snd_pcm_format_t sample_format,

			   unsigned int samples_per_frame,

			   unsigned int frame_count);

	int (*fill)(int fd, void *frame_buffer, snd_pcm_access_t access,

		    snd_pcm_format_t sample_format,

		    unsigned int samples_per_frame, unsigned int frame_count);

	void (*deallocator)(void *frame_buffer, unsigned int samples_per_frame);

	void *frame_buffer;

	int i;

	int err = 0;

	if (access != SND_PCM_ACCESS_RW_NONINTERLEAVED) {

		allocator = allocate_buf;

		fill = fill_buf;

		deallocator = deallocate_buf;

	} else {

		allocator = allocate_vector;

		fill = fill_vector;

		deallocator = deallocate_vector;

	}

	frame_buffer = allocator(access, sample_format, samples_per_frame,

				 gen->max_frame_count);

	if (frame_buffer == NULL)

		return -ENOMEM;

	err = fill(gen->fd, frame_buffer, access, sample_format,

		   samples_per_frame, gen->max_frame_count);

	if (err < 0)

		goto end;

	for (i = gen->min_frame_count;

	     i <= gen->max_frame_count; i += gen->step_frame_count) {

		err = gen->cb(gen, access ,sample_format, samples_per_frame,

			      frame_buffer, i);

		if (err < 0)

			break;

	}

end:

	deallocator(frame_buffer, samples_per_frame);

	return err;

}

static int test_samples_per_frame(struct test_generator *gen,

				  snd_pcm_access_t access,

				  snd_pcm_format_t sample_format)

{

	int i;

	int err = 0;

	for (i = gen->min_samples_per_frame;

	     i <= gen->max_samples_per_frame; ++i) {

		err = test_frame_count(gen, access, sample_format, i);

		if (err < 0)

			break;

	}

	return err;

}

static int test_sample_format(struct test_generator *gen,

			      snd_pcm_access_t access)

{

	int i;

	int err = 0;

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

		if (!((1ull << i) & gen->sample_format_mask))

			continue;

		err = test_samples_per_frame(gen, access, i);

		if (err < 0)

			break;

	}

	return err;

}

static int test_access(struct test_generator *gen)

{

	int i;

	int err = 0;

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

		if (!((1ull << i) & gen->access_mask))

			continue;

		err = test_sample_format(gen, i);

		if (err < 0)

			break;

	}

	return err;

}

int generator_context_run(struct test_generator *gen, generator_cb_t cb)

{

	gen->cb = cb;

	return test_access(gen);

}

void generator_context_destroy(struct test_generator *gen)

{

	free(gen->private_data);

	close(gen->fd);

}