third_party_alsa-utils/axfer/xfer-libasound-timer-mmap.c

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