// SPDX-License-Identifier: GPL-2.0

//

// xfer-libasound-irq-mmap.c - Timer-based scheduling model for mmap 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"

struct map_layout {

	snd_pcm_status_t *status;

	bool need_forward_or_rewind;

	char **vector;

	unsigned int frames_per_second;

	unsigned int samples_per_frame;

	unsigned int frames_per_buffer;

};

static int timer_mmap_pre_process(struct libasound_state *state)

{

	struct map_layout *layout = state->private_data;

	snd_pcm_access_t access;

	snd_pcm_uframes_t frame_offset;

	snd_pcm_uframes_t avail = 0;

	snd_pcm_uframes_t frames_per_buffer;

	int i;

	int err;

	// This parameter, 'period event', is a software feature in alsa-lib.

	// This switch a handler in 'hw' PCM plugin from irq-based one to

	// timer-based one. This handler has two file descriptors for

	// ALSA PCM character device and ALSA timer device. The latter is used

	// to catch suspend/resume events as wakeup event.

	err = snd_pcm_sw_params_set_period_event(state->handle,

						 state->sw_params, 1);

	if (err < 0)

		return err;

	err = snd_pcm_status_malloc(&layout->status);

	if (err < 0)

		return err;

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

	if (err < 0)

		return err;

	err = snd_pcm_hw_params_get_channels(state->hw_params,

					     &layout->samples_per_frame);

	if (err < 0)

		return err;

	err = snd_pcm_hw_params_get_rate(state->hw_params,

					 &layout->frames_per_second, NULL);

	if (err < 0)

		return err;

	err = snd_pcm_hw_params_get_buffer_size(state->hw_params,

						&frames_per_buffer);

	if (err < 0)

		return err;

	layout->frames_per_buffer = (unsigned int)frames_per_buffer;

	if (access == SND_PCM_ACCESS_MMAP_NONINTERLEAVED) {

		layout->vector = calloc(layout->samples_per_frame,

					sizeof(*layout->vector));

		if (layout->vector == NULL)

			return err;

	}

	if (state->verbose) {

		const snd_pcm_channel_area_t *areas;

		err = snd_pcm_mmap_begin(state->handle, &areas, &frame_offset,

					 &avail);

		if (err < 0)

			return err;

		logging(state, "attributes for mapped page frame:\n");

		for (i = 0; i < layout->samples_per_frame; ++i) {

			const snd_pcm_channel_area_t *area = areas + i;

			logging(state, "  sample number: %d\n", i);

			logging(state, "    address: %p\n", area->addr);

			logging(state, "    bits for offset: %u\n", area->first);

			logging(state, "    bits/frame: %u\n", area->step);

		}

	}

	return 0;

}

static void *get_buffer(struct libasound_state *state,

			const snd_pcm_channel_area_t *areas,

			snd_pcm_uframes_t frame_offset)

{

	struct map_layout *layout = state->private_data;

	void *frame_buf;

	if (layout->vector == NULL) {

		char *buf;

		buf = areas[0].addr;

		buf += snd_pcm_frames_to_bytes(state->handle, frame_offset);

		frame_buf = buf;

	} else {

		int i;

		for (i = 0; i < layout->samples_per_frame; ++i) {

			layout->vector[i] = areas[i].addr;

			layout->vector[i] += snd_pcm_samples_to_bytes(

						state->handle, frame_offset);

		}

		frame_buf = layout->vector;

	}

	return frame_buf;

}

static int timer_mmap_process_frames(struct libasound_state *state,

				     unsigned int *frame_count,

				     struct mapper_context *mapper,

				     struct container_context *cntrs)

{

	struct map_layout *layout = state->private_data;

	snd_pcm_uframes_t planned_count;

	snd_pcm_sframes_t avail;

	snd_pcm_uframes_t avail_count;

	const snd_pcm_channel_area_t *areas;

	snd_pcm_uframes_t frame_offset;

	void *frame_buf;

	snd_pcm_sframes_t consumed_count;

	int err;

	// Retrieve avail space on PCM buffer between kernel/user spaces.

	// On cache incoherent architectures, still care of data

	// synchronization.

	avail = snd_pcm_avail_update(state->handle);

	if (avail < 0)

		return (int)avail;

	// Retrieve pointers of the buffer and left space up to the boundary.

	avail_count = (snd_pcm_uframes_t)avail;

	err = snd_pcm_mmap_begin(state->handle, &areas, &frame_offset,

				 &avail_count);

	if (err < 0)

		return err;

	// MEMO: Use the amount of data frames as you like.

	planned_count = layout->frames_per_buffer * random() / RAND_MAX;

	if (frame_offset + planned_count > layout->frames_per_buffer)

		planned_count = layout->frames_per_buffer - frame_offset;

	// Trim up to expected frame count.

	if (*frame_count < planned_count)

		planned_count = *frame_count;

	// Yield this CPU till planned amount of frames become available.

	if (avail_count < planned_count) {

		unsigned short revents;

		int timeout_msec;

		// TODO; precise granularity of timeout; e.g. ppoll(2).

		// Furthermore, wrap up according to granularity of reported

		// value for hw_ptr.

		timeout_msec = ((planned_count - avail_count) * 1000 +

				layout->frames_per_second - 1) /

			       layout->frames_per_second;

		// TODO: However, experimentally, the above is not enough to

		// keep planned amount of frames when waking up. I don't know

		// exactly the mechanism yet.

		err = xfer_libasound_wait_event(state, timeout_msec,

						&revents);

		if (err < 0)

			return err;

		if (revents & POLLERR) {

			// TODO: error reporting.

			return -EIO;

		}

		if (!(revents & (POLLIN | POLLOUT)))

			return -EAGAIN;

		// MEMO: Need to perform hwsync explicitly because hwptr is not

		// synchronized to actual position of data frame transmission

		// on hardware because IRQ handlers are not used in this

		// scheduling strategy.

		avail = snd_pcm_avail(state->handle);

		if (avail < 0)

			return (int)avail;

		if (avail < planned_count) {

			logging(state,

				"Wake up but not enough space: %lu %lu %u\n",

				planned_count, avail, timeout_msec);

			planned_count = avail;

		}

	}

	// Let's process data frames.

	*frame_count = planned_count;

	frame_buf = get_buffer(state, areas, frame_offset);

	err = mapper_context_process_frames(mapper, frame_buf, frame_count,

					    cntrs);

	if (err < 0)

		return err;

	consumed_count = snd_pcm_mmap_commit(state->handle, frame_offset,

					     *frame_count);

	if (consumed_count != *frame_count) {

		logging(state,

			"A bug of 'hw' PCM plugin or driver for this PCM "

			"node.\n");

	}

	*frame_count = consumed_count;

	return 0;

}

static int forward_appl_ptr(struct libasound_state *state)

{

	struct map_layout *layout = state->private_data;

	snd_pcm_uframes_t forwardable_count;

	snd_pcm_sframes_t forward_count;

	forward_count = snd_pcm_forwardable(state->handle);

	if (forward_count < 0)

		return (int)forward_count;

	forwardable_count = forward_count;

	// No need to add safe-gurard because hwptr goes ahead.

	forward_count = snd_pcm_forward(state->handle, forwardable_count);

	if (forward_count < 0)

		return (int)forward_count;

	if (state->verbose) {

		logging(state,

			"  forwarded: %lu/%u\n",

			forward_count, layout->frames_per_buffer);

	}

	return 0;

}

static int timer_mmap_r_process_frames(struct libasound_state *state,

				       unsigned *frame_count,

				       struct mapper_context *mapper,

				       struct container_context *cntrs)

{

	struct map_layout *layout = state->private_data;

	snd_pcm_state_t s;

	int err;

	// SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP suppresses any IRQ to notify

	// period elapse for data transmission, therefore no need to care of

	// concurrent access by IRQ context and process context, unlike

	// IRQ-based operations.

	// Here, this is just to query current status to hardware, for later

	// processing.

	err = snd_pcm_status(state->handle, layout->status);

	if (err < 0)

		goto error;

	s = snd_pcm_status_get_state(layout->status);

	// TODO: if reporting something, do here with the status data.

	if (s == SND_PCM_STATE_RUNNING) {

		// Reduce delay between sampling on hardware and handling by

		// this program.

		if (layout->need_forward_or_rewind) {

			err = forward_appl_ptr(state);

			if (err < 0)

				goto error;

			layout->need_forward_or_rewind = false;

		}

		err = timer_mmap_process_frames(state, frame_count, mapper,

						cntrs);

		if (err < 0)

			goto error;

	} else {

		if (s == SND_PCM_STATE_PREPARED) {

			// For capture direction, need to start stream

			// explicitly.

			err = snd_pcm_start(state->handle);

			if (err < 0)

				goto error;

			layout->need_forward_or_rewind = true;

			// Not yet.

			*frame_count = 0;

		} else {

			err = -EPIPE;

			goto error;

		}

	}

	return 0;

error:

	*frame_count = 0;

	return err;

}

static int rewind_appl_ptr(struct libasound_state *state)

{

	struct map_layout *layout = state->private_data;

	snd_pcm_uframes_t rewindable_count;

	snd_pcm_sframes_t rewind_count;

	rewind_count = snd_pcm_rewindable(state->handle);

	if (rewind_count < 0)

		return (int)rewind_count;

	rewindable_count = rewind_count;

	// If appl_ptr were rewound just to position of hw_ptr, at next time,

	// hw_ptr could catch up appl_ptr. This is overrun. We need a space

	// between these two pointers to prevent this XRUN.

	// This space is largely affected by time to process data frames later.

	//

	// TODO: a generous way to estimate a good value.

	if (rewindable_count < 32)

		return 0;

	rewindable_count -= 32;

	rewind_count = snd_pcm_rewind(state->handle, rewindable_count);

	if (rewind_count < 0)

		return (int)rewind_count;

	if (state->verbose) {

		logging(state,

			"  rewound: %lu/%u\n",

			rewind_count, layout->frames_per_buffer);

	}

	return 0;

}

static int fill_buffer_with_zero_samples(struct libasound_state *state)

{

	struct map_layout *layout = state->private_data;

	const snd_pcm_channel_area_t *areas;

	snd_pcm_uframes_t frame_offset;

	snd_pcm_uframes_t avail_count;

	snd_pcm_format_t sample_format;

	snd_pcm_uframes_t consumed_count;

	int err;

	err = snd_pcm_hw_params_get_buffer_size(state->hw_params,

						&avail_count);

	if (err < 0)

		return err;

	err = snd_pcm_mmap_begin(state->handle, &areas, &frame_offset,

				 &avail_count);

	if (err < 0)

		return err;

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

	if (err < 0)

		return err;

	err = snd_pcm_areas_silence(areas, frame_offset,

				    layout->samples_per_frame, avail_count,

				    sample_format);

	if (err < 0)

		return err;

	consumed_count = snd_pcm_mmap_commit(state->handle, frame_offset,

					     avail_count);

	if (consumed_count != avail_count)

		logging(state, "A bug of access plugin for this PCM node.\n");

	return 0;

}

static int timer_mmap_w_process_frames(struct libasound_state *state,

				       unsigned *frame_count,

				       struct mapper_context *mapper,

				       struct container_context *cntrs)

{

	struct map_layout *layout = state->private_data;

	snd_pcm_state_t s;

	int err;

	// Read my comment in 'timer_mmap_w_process_frames()'.

	err = snd_pcm_status(state->handle, layout->status);

	if (err < 0)

		goto error;

	s = snd_pcm_status_get_state(layout->status);

	// TODO: if reporting something, do here with the status data.

	if (s == SND_PCM_STATE_RUNNING) {

		// Reduce delay between queueing by this program and presenting

		// on hardware.

		if (layout->need_forward_or_rewind) {

			err = rewind_appl_ptr(state);

			if (err < 0)

				goto error;

			layout->need_forward_or_rewind = false;

		}

		err = timer_mmap_process_frames(state, frame_count, mapper,

						cntrs);

		if (err < 0)

			goto error;

	} else {

		// Need to start playback stream explicitly

		if (s == SND_PCM_STATE_PREPARED) {

			err = fill_buffer_with_zero_samples(state);

			if (err < 0)

				goto error;

			err = snd_pcm_start(state->handle);

			if (err < 0)

				goto error;

			layout->need_forward_or_rewind = true;

			// Not yet.

			*frame_count = 0;

		} else {

			err = -EPIPE;

			goto error;

		}

	}

	return 0;

error:

	*frame_count = 0;

	return err;

}

static void timer_mmap_post_process(struct libasound_state *state)

{

	struct map_layout *layout = state->private_data;

	if (layout->status)

		snd_pcm_status_free(layout->status);

	layout->status = NULL;

	if (layout->vector)

		free(layout->vector);

	layout->vector = NULL;

}

const struct xfer_libasound_ops xfer_libasound_timer_mmap_w_ops = {

	.pre_process	= timer_mmap_pre_process,

	.process_frames	= timer_mmap_w_process_frames,

	.post_process	= timer_mmap_post_process,

	.private_size	= sizeof(struct map_layout),

};

const struct xfer_libasound_ops xfer_libasound_timer_mmap_r_ops = {

	.pre_process	= timer_mmap_pre_process,

	.process_frames	= timer_mmap_r_process_frames,

	.post_process	= timer_mmap_post_process,

	.private_size	= sizeof(struct map_layout),

};