// SPDX-License-Identifier: GPL-2.0

//

// xfer-libasound-irq-rw.c - IRQ-based scheduling model for read/write operation.

//

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

//

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

#include "xfer-libasound.h"

#include "misc.h"

#include "frame-cache.h"

struct rw_closure {

	snd_pcm_access_t access;

	int (*process_frames)(struct libasound_state *state,

			      snd_pcm_state_t status, unsigned int *frame_count,

			      struct mapper_context *mapper,

		      struct container_context *cntrs);

	struct frame_cache cache;

};

static int wait_for_avail(struct libasound_state *state)

{

	unsigned int msec_per_buffer;

	unsigned short revents;

	unsigned short event;

	int err;

	// Wait during msec equivalent to all audio data frames in buffer

	// instead of period, for safe.

	err = snd_pcm_hw_params_get_buffer_time(state->hw_params,

						&msec_per_buffer, NULL);

	if (err < 0)

		return err;

	msec_per_buffer /= 1000;

	// Wait for hardware IRQ when no available space.

	err = xfer_libasound_wait_event(state, msec_per_buffer, &revents);

	if (err < 0)

		return err;

	// TODO: error reporting.

	if (revents & POLLERR)

		return -EIO;

	if (snd_pcm_stream(state->handle) == SND_PCM_STREAM_CAPTURE)

		event = POLLIN;

	else

		event = POLLOUT;

	if (!(revents & event))

		return -EAGAIN;

	return 0;

}

static int read_frames(struct libasound_state *state, unsigned int *frame_count,

		       unsigned int avail_count, struct mapper_context *mapper,

		       struct container_context *cntrs)

{

	struct rw_closure *closure = state->private_data;

	snd_pcm_sframes_t handled_frame_count;

	unsigned int consumed_count;

	int err;

	// Trim according up to expected frame count.

	if (*frame_count < avail_count)

		avail_count = *frame_count;

	// Cache required amount of frames.

	if (avail_count > frame_cache_get_count(&closure->cache)) {

		avail_count -= frame_cache_get_count(&closure->cache);

		// Execute write operation according to the shape of buffer.

		// These operations automatically start the substream.

		if (closure->access == SND_PCM_ACCESS_RW_INTERLEAVED) {

			handled_frame_count = snd_pcm_readi(state->handle,

							closure->cache.buf_ptr,

							avail_count);

		} else {

			handled_frame_count = snd_pcm_readn(state->handle,

							closure->cache.buf_ptr,

							avail_count);

		}

		if (handled_frame_count < 0) {

			err = handled_frame_count;

			return err;

		}

		frame_cache_increase_count(&closure->cache, handled_frame_count);

		avail_count = frame_cache_get_count(&closure->cache);

	}

	// Write out to file descriptors.

	consumed_count = avail_count;

	err = mapper_context_process_frames(mapper, closure->cache.buf,

					    &consumed_count, cntrs);

	if (err < 0)

		return err;

	frame_cache_reduce(&closure->cache, consumed_count);

	*frame_count = consumed_count;

	return 0;

}

static int r_process_frames_blocking(struct libasound_state *state,

				     snd_pcm_state_t status,

				     unsigned int *frame_count,

				     struct mapper_context *mapper,

				     struct container_context *cntrs)

{

	snd_pcm_sframes_t avail;

	snd_pcm_uframes_t avail_count;

	int err = 0;

	if (status == SND_PCM_STATE_RUNNING) {

		// Check available space on the buffer.

		avail = snd_pcm_avail(state->handle);

		if (avail < 0) {

			err = avail;

			goto error;

		}

		avail_count = (snd_pcm_uframes_t)avail;

		if (avail_count == 0) {

			// Request data frames so that blocking is just

			// released.

			err = snd_pcm_sw_params_get_avail_min(state->sw_params,

							      &avail_count);

			if (err < 0)

				goto error;

		}

	} else {

		// Request data frames so that the PCM substream starts.

		snd_pcm_uframes_t frame_count;

		err = snd_pcm_sw_params_get_start_threshold(state->sw_params,

							    &frame_count);

		if (err < 0)

			goto error;

		avail_count = (unsigned int)frame_count;

	}

	err = read_frames(state, frame_count, avail_count, mapper, cntrs);

	if (err < 0)

		goto error;

	return 0;

error:

	*frame_count = 0;

	return err;

}

static int r_process_frames_nonblocking(struct libasound_state *state,

					snd_pcm_state_t status,

					unsigned int *frame_count,

					struct mapper_context *mapper,

					struct container_context *cntrs)

{

	snd_pcm_sframes_t avail;

	snd_pcm_uframes_t avail_count;

	int err = 0;

	if (status != SND_PCM_STATE_RUNNING) {

		err = snd_pcm_start(state->handle);

		if (err < 0)

			goto error;

	}

	if (state->use_waiter) {

		err = wait_for_avail(state);

		if (err < 0)

			goto error;

	}

	// Check available space on the buffer.

	avail = snd_pcm_avail(state->handle);

	if (avail < 0) {

		err = avail;

		goto error;

	}

	avail_count = (snd_pcm_uframes_t)avail;

	if (avail_count == 0) {

		// Let's go to a next iteration.

		err = 0;

		goto error;

	}

	err = read_frames(state, frame_count, avail_count, mapper, cntrs);

	if (err < 0)

		goto error;

	return 0;

error:

	*frame_count = 0;

	return err;

}

static int write_frames(struct libasound_state *state,

			unsigned int *frame_count, unsigned int avail_count,

			struct mapper_context *mapper,

			struct container_context *cntrs)

{

	struct rw_closure *closure = state->private_data;

	snd_pcm_uframes_t consumed_count;

	snd_pcm_sframes_t handled_frame_count;

	int err;

	// Trim according up to expected frame count.

	if (*frame_count < avail_count)

		avail_count = *frame_count;

	// Cache required amount of frames.

	if (avail_count > frame_cache_get_count(&closure->cache)) {

		avail_count -= frame_cache_get_count(&closure->cache);

		// Read frames to transfer.

		err = mapper_context_process_frames(mapper,

				closure->cache.buf_ptr, &avail_count, cntrs);

		if (err < 0)

			return err;

		frame_cache_increase_count(&closure->cache, avail_count);

		avail_count = frame_cache_get_count(&closure->cache);

	}

	// Execute write operation according to the shape of buffer. These

	// operations automatically start the stream.

	consumed_count = avail_count;

	if (closure->access == SND_PCM_ACCESS_RW_INTERLEAVED) {

		handled_frame_count = snd_pcm_writei(state->handle,

					closure->cache.buf, consumed_count);

	} else {

		handled_frame_count = snd_pcm_writen(state->handle,

					closure->cache.buf, consumed_count);

	}

	if (handled_frame_count < 0) {

		err = handled_frame_count;

		return err;

	}

	consumed_count = handled_frame_count;

	frame_cache_reduce(&closure->cache, consumed_count);

	*frame_count = consumed_count;

	return 0;

}

static int w_process_frames_blocking(struct libasound_state *state,

				     snd_pcm_state_t status,

				     unsigned int *frame_count,

				     struct mapper_context *mapper,

				     struct container_context *cntrs)

{

	snd_pcm_sframes_t avail;

	unsigned int avail_count;

	int err;

	if (status == SND_PCM_STATE_RUNNING) {

		// Check available space on the buffer.

		avail = snd_pcm_avail(state->handle);

		if (avail < 0) {

			err = avail;

			goto error;

		}

		avail_count = (unsigned int)avail;

		if (avail_count == 0) {

			// Fill with data frames so that blocking is just

			// released.

			snd_pcm_uframes_t avail_min;

			err = snd_pcm_sw_params_get_avail_min(state->sw_params,

							      &avail_min);

			if (err < 0)

				goto error;

			avail_count = (unsigned int)avail_min;

		}

	} else {

		snd_pcm_uframes_t frames_for_start_threshold;

		snd_pcm_uframes_t frames_per_period;

		// Fill with data frames so that the PCM substream starts.

		err = snd_pcm_sw_params_get_start_threshold(state->sw_params,

						&frames_for_start_threshold);

		if (err < 0)

			goto error;

		// But the above number can be too small and cause XRUN because

		// I/O operation is done per period.

		err = snd_pcm_hw_params_get_period_size(state->hw_params,

						&frames_per_period, NULL);

		if (err < 0)

			goto error;

		// Use larger one to prevent from both of XRUN and successive

		// blocking.

		if (frames_for_start_threshold > frames_per_period)

			avail_count = (unsigned int)frames_for_start_threshold;

		else

			avail_count = (unsigned int)frames_per_period;

	}

	err = write_frames(state, frame_count, avail_count, mapper, cntrs);

	if (err < 0)

		goto error;

	return 0;

error:

	*frame_count = 0;

	return err;

}

static int w_process_frames_nonblocking(struct libasound_state *state,

					snd_pcm_state_t status,

					unsigned int *frame_count,

					struct mapper_context *mapper,

					struct container_context *cntrs)

{

	snd_pcm_sframes_t avail;

	unsigned int avail_count;

	int err;

	if (state->use_waiter) {

		err = wait_for_avail(state);

		if (err < 0)

			goto error;

	}

	// Check available space on the buffer.

	avail = snd_pcm_avail(state->handle);

	if (avail < 0) {

		err = avail;

		goto error;

	}

	avail_count = (unsigned int)avail;

	if (avail_count == 0) {

		// Let's go to a next iteration.

		err = 0;

		goto error;

	}

	err = write_frames(state, frame_count, avail_count, mapper, cntrs);

	if (err < 0)

		goto error;

	// NOTE: The substream starts automatically when the accumulated number

	// of queued data frame exceeds start_threshold.

	return 0;

error:

	*frame_count = 0;

	return err;

}

static int irq_rw_pre_process(struct libasound_state *state)

{

	struct rw_closure *closure = state->private_data;

	snd_pcm_format_t format;

	snd_pcm_uframes_t frames_per_buffer;

	int bytes_per_sample;

	unsigned int samples_per_frame;

	int err;

	err = snd_pcm_hw_params_get_format(state->hw_params, &format);

	if (err < 0)

		return err;

	bytes_per_sample = snd_pcm_format_physical_width(format) / 8;

	if (bytes_per_sample <= 0)

		return -ENXIO;

	err = snd_pcm_hw_params_get_channels(state->hw_params,

					     &samples_per_frame);

	if (err < 0)

		return err;

	err = snd_pcm_hw_params_get_buffer_size(state->hw_params,

						&frames_per_buffer);

	if (err < 0)

		return err;

	err = snd_pcm_hw_params_get_access(state->hw_params, &closure->access);

	if (err < 0)

		return err;

	err = frame_cache_init(&closure->cache, closure->access,

			       bytes_per_sample, samples_per_frame,

			       frames_per_buffer);

	if (err < 0)

		return err;

	if (snd_pcm_stream(state->handle) == SND_PCM_STREAM_CAPTURE) {

		if (state->nonblock)

			closure->process_frames = r_process_frames_nonblocking;

		else

			closure->process_frames = r_process_frames_blocking;

	} else {

		if (state->nonblock)

			closure->process_frames = w_process_frames_nonblocking;

		else

			closure->process_frames = w_process_frames_blocking;

	}

	return 0;

}

static int irq_rw_process_frames(struct libasound_state *state,

				unsigned int *frame_count,

				struct mapper_context *mapper,

				struct container_context *cntrs)

{

	struct rw_closure *closure = state->private_data;

	snd_pcm_state_t status;

	// Need to recover the stream.

	status = snd_pcm_state(state->handle);

	if (status != SND_PCM_STATE_RUNNING && status != SND_PCM_STATE_PREPARED)

		return -EPIPE;

	// NOTE: Actually, status can be shift always.

	return closure->process_frames(state, status, frame_count, mapper, cntrs);

}

static void irq_rw_post_process(struct libasound_state *state)

{

	struct rw_closure *closure = state->private_data;

	frame_cache_destroy(&closure->cache);

}

const struct xfer_libasound_ops xfer_libasound_irq_rw_ops = {

	.pre_process	= irq_rw_pre_process,

	.process_frames	= irq_rw_process_frames,

	.post_process	= irq_rw_post_process,

	.private_size	= sizeof(struct rw_closure),

};