/* SPDX-License-Identifier: GPL-2.0 */

/** \file alsa_write.c paraslash's alsa output plugin */

/*
 * Based in parts on aplay.c from the alsa-utils-1.0.8 package,
 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>, which is
 * based on the vplay program by Michael Beck.
 */

#include <sys/types.h>
#include <alsa/asoundlib.h>
#include <lopsub.h>

#include "write_cmd.lsg.h"
#include "para.h"
#include "fd.h"
#include "string.h"
#include "list.h"
#include "sched.h"
#include "buffer_tree.h"
#include "write.h"
#include "error.h"

/** Data specific to the alsa writer. */
struct private_alsa_write_data {
	/** The alsa handle */
	snd_pcm_t *handle;
	/** Determined and set by alsa_init(). */
	int bytes_per_frame;
	/*
	 * If the sample rate is not given at the command line and no wav
	 * header was detected, the btr exec mechanism is employed to query the
	 * ancestor buffer tree nodes for this information. In a typical setup
	 * the decoder passes the sample rate back to the alsa writer.
	 *
	 *  \sa \ref btr_exec_up().
	 */
	unsigned sample_rate;
	/*
	 * The sample format (8/16 bit, signed/unsigned, little/big endian) is
	 * determined in the same way as the \a sample_rate.
	 */
	snd_pcm_format_t sample_format;
	/* The number of channels, again determined like \a sample_rate. */
	unsigned channels;
	/* time until buffer underrun occurs, in milliseconds */
	unsigned buffer_time;
	struct timeval drain_barrier;
	/* File descriptor to monitor for reading. */
	int poll_fd;
};

static snd_pcm_format_t get_alsa_pcm_format(enum sample_format sf)
{
	switch (sf) {
	case SF_S8: return SND_PCM_FORMAT_S8;
	case SF_U8: return SND_PCM_FORMAT_U8;
	case SF_S16_LE: return SND_PCM_FORMAT_S16_LE;
	case SF_S16_BE: return SND_PCM_FORMAT_S16_BE;
	case SF_U16_LE: return SND_PCM_FORMAT_U16_LE;
	case SF_U16_BE: return SND_PCM_FORMAT_U16_BE;
	case SF_FLOAT_LE: return SND_PCM_FORMAT_FLOAT_LE;
	case SF_FLOAT_BE: return SND_PCM_FORMAT_FLOAT_BE;
	default: return SND_PCM_FORMAT_S16_LE;
	}
}

/* Install PCM software and hardware configuration. */
static int alsa_init(struct writer_node *wn)
{
	struct private_alsa_write_data *pad = wn->private_data;
	snd_pcm_hw_params_t *hwparams = NULL;
	snd_pcm_sw_params_t *swparams = NULL;
	snd_pcm_uframes_t start_threshold, stop_threshold;
	snd_pcm_uframes_t buffer_size, period_size;
	snd_output_t *output_log;
	int ret;
	const char *msg, *dev = WRITE_CMD_OPT_STRING_VAL(ALSA, DEVICE, wn->lpr);
	unsigned period_time;

	PARA_INFO_LOG("opening %s\n", dev);
	msg = "unable to open pcm";
	ret = snd_pcm_open(&pad->handle, dev, SND_PCM_STREAM_PLAYBACK,
		SND_PCM_NONBLOCK);
	if (ret < 0)
		goto fail;
	ret = snd_pcm_hw_params_malloc(&hwparams);
	assert(ret >= 0);
	msg = "Broken alsa configuration";
	ret = snd_pcm_hw_params_any(pad->handle, hwparams);
	if (ret < 0)
		goto fail;
	msg = "access type not available";
	ret = snd_pcm_hw_params_set_access(pad->handle, hwparams,
		SND_PCM_ACCESS_RW_INTERLEAVED);
	if (ret < 0)
		goto fail;
	msg = "sample format not available";
	ret = snd_pcm_hw_params_set_format(pad->handle, hwparams,
		pad->sample_format);
	if (ret < 0)
		goto fail;
	msg = "channels count not available";
	ret = snd_pcm_hw_params_set_channels(pad->handle, hwparams,
		pad->channels);
	if (ret < 0)
		goto fail;
	msg = "could not set sample rate";
	ret = snd_pcm_hw_params_set_rate_near(pad->handle, hwparams,
		&pad->sample_rate, NULL);
	if (ret < 0)
		goto fail;
	/* alsa wants microseconds */
	pad->buffer_time = 1000U * WRITE_CMD_OPT_UINT32_VAL(ALSA, BUFFER_TIME,
		wn->lpr);
	msg = "could not set buffer time";
	ret = snd_pcm_hw_params_set_buffer_time_near(pad->handle, hwparams,
		&pad->buffer_time, NULL);
	if (ret < 0)
		goto fail;
	pad->buffer_time /= 1000; /* we prefer milliseconds */
	period_time = pad->buffer_time * 250; /* buffer time / 4 */
	msg = "could not set period time";
	ret = snd_pcm_hw_params_set_period_time_near(pad->handle, hwparams,
		&period_time, NULL);
	if (ret < 0)
		goto fail;

	msg = "unable to install hw params";
	ret = snd_pcm_hw_params(pad->handle, hwparams);
	if (ret < 0)
		goto fail;
	snd_pcm_hw_params_get_period_size(hwparams, &period_size, NULL);
	snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size);
	msg = "period size equals buffer size";
	if (period_size == buffer_size)
		goto fail;

	/* software parameter setup */
	ret = snd_pcm_sw_params_malloc(&swparams);
	assert(ret >= 0);
	snd_pcm_sw_params_current(pad->handle, swparams);
	snd_pcm_sw_params_set_avail_min(pad->handle, swparams, period_size);
	if (buffer_size < 1)
		start_threshold = 1;
	else
		start_threshold = PARA_MIN(buffer_size,
			(snd_pcm_uframes_t)pad->sample_rate);
	msg = "could not set start threshold";
	ret = snd_pcm_sw_params_set_start_threshold(pad->handle, swparams,
		start_threshold);
	if (ret < 0)
		goto fail;
	stop_threshold = buffer_size;
	msg = "could not set stop threshold";
	ret = snd_pcm_sw_params_set_stop_threshold(pad->handle, swparams,
		stop_threshold);
	if (ret < 0)
		goto fail;
	msg = "unable to install sw params";
	ret = snd_pcm_sw_params(pad->handle, swparams);
	if (ret < 0)
		goto fail;
	msg = "unable to determine bytes per frame";
	ret = snd_pcm_format_physical_width(pad->sample_format);
	if (ret <= 0)
		goto fail;
	pad->bytes_per_frame = ret * pad->channels / 8;
	msg = "failed to set alsa handle to nonblock mode";
	ret = snd_pcm_nonblock(pad->handle, 1);
	if (ret < 0)
		goto fail;
	ret = snd_output_buffer_open(&output_log);
	if (ret == 0) {
		char *buf, *p;
		size_t sz;
		PARA_DEBUG_LOG("dumping alsa configuration\n");
		snd_pcm_dump(pad->handle, output_log);
		snd_pcm_hw_params_dump(hwparams, output_log);
		sz = snd_output_buffer_string(output_log, &buf);
		for (p = buf; p < buf + sz;) {
			char *q = memchr(p, '\n', buf + sz - p);
			if (!q)
				break;
			*q = '\0';
			PARA_DEBUG_LOG("%s\n", p);
			p = q + 1;
		}
		snd_output_close(output_log);
	}
	ret = 1;
	goto out;
fail:
	if (ret < 0)
		PARA_ERROR_LOG("%s: %s\n", msg, snd_strerror(-ret));
	else
		PARA_ERROR_LOG("%s\n", msg);
	ret = -E_ALSA;
out:
	snd_pcm_hw_params_free(hwparams);
	snd_pcm_sw_params_free(swparams);
	return ret;
}

static void alsa_write_pre_monitor(struct sched *s, void *context)
{
	struct pollfd pfd;
	struct writer_node *wn = context;
	struct private_alsa_write_data *pad = wn->private_data;
	int ret = btr_node_status(wn->btrn, wn->min_iqs, BTR_NT_LEAF);

	if (pad)
		pad->poll_fd = -1;
	if (ret == 0)
		return;
	if (!pad) {
		sched_min_delay(s);
		return;
	}
	if (ret < 0) {
		sched_request_barrier_or_min_delay(&pad->drain_barrier, s);
		return;
	}
	/* wait at most 50% of the buffer time */
	sched_request_timeout_ms(pad->buffer_time / 2, s);
	ret = snd_pcm_poll_descriptors(pad->handle, &pfd, 1);
	if (ret < 0) {
		PARA_ERROR_LOG("could not get alsa poll fd: %s\n",
			snd_strerror(-ret));
		return;
	}
	pad->poll_fd = pfd.fd;
	sched_monitor_readfd(pfd.fd, s);
}

static void alsa_close(struct writer_node *wn)
{
	struct private_alsa_write_data *pad = wn->private_data;
	PARA_INFO_LOG("closing writer node %p\n", wn);

	if (!pad)
		return;
	if (!pad->handle)
		goto free_pad;
	/*
	 * It's OK to have a blocking operation here because we already made
	 * sure that the PCM output buffer is (nearly) empty.
	 */
	snd_pcm_nonblock(pad->handle, 0);
	snd_pcm_drain(pad->handle);
	snd_pcm_close(pad->handle);
	snd_config_update_free_global();
free_pad:
	free(pad);
}

static int alsa_write_post_monitor(__a_unused struct sched *s, void *context)
{
	struct writer_node *wn = context;
	struct private_alsa_write_data *pad = wn->private_data;
	struct btr_node *btrn = wn->btrn;
	char *data;
	size_t bytes;
	snd_pcm_sframes_t frames;
	int ret;

	ret = task_get_notification(wn->task);
	if (ret < 0)
		goto err;
again:
	ret = btr_node_status(btrn, wn->min_iqs, BTR_NT_LEAF);
	if (ret < 0)
		goto err;
	if (ret == 0)
		return 0;
	btr_merge(btrn, wn->min_iqs);
	bytes = btr_next_buffer(btrn, &data);
	if (ret < 0 || bytes < wn->min_iqs) { /* eof */
		assert(btr_no_parent(btrn));
		ret = -E_EOF;
		if (!pad)
			goto err;
		/* wait until pending frames are played */
		if (pad->drain_barrier.tv_sec == 0) {
			PARA_DEBUG_LOG("waiting for device to drain\n");
			tv_add(now, &(struct timeval)EMBRACE(0, 200 * 1000),
				&pad->drain_barrier);
			return 0;
		}
		if (tv_diff(now, &pad->drain_barrier, NULL) > 0)
			goto err;
		return 0;
	}
	if (!pad) {
		int32_t val;

		if (bytes == 0) /* no data available */
			return 0;
		pad = wn->private_data = zalloc(sizeof(*pad));
		ret = get_btr_sample_rate(btrn, &val);
		if (ret < 0)
			goto err;
		pad->sample_rate = val;
		ret = get_btr_channels(btrn, &val);
		if (ret < 0)
			goto err;
		pad->channels = val;
		ret = get_btr_sample_format(btrn, &val);
		if (ret < 0)
			goto err;
		pad->sample_format = get_alsa_pcm_format(val);
		PARA_INFO_LOG("%u channel(s), %uHz\n", pad->channels,
			pad->sample_rate);
		ret = alsa_init(wn);
		if (ret < 0)
			goto err;
		wn->min_iqs = pad->bytes_per_frame;
		goto again;
	}
	frames = bytes / pad->bytes_per_frame;
	frames = snd_pcm_writei(pad->handle, data, frames);
	if (frames == 0 || frames == -EAGAIN) {
		char buf[100];
		if (pad->poll_fd >= 0 && sched_read_ok(pad->poll_fd, s))
			if (read(pad->poll_fd, buf, 100))
				do_nothing;
		return 0;
	}
	if (frames > 0) {
		btr_consume(btrn, frames * pad->bytes_per_frame);
		goto again;
	}
	if (frames == -EPIPE) {
		snd_pcm_status_t *status;
		snd_pcm_status_malloc(&status);
		if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN)
			PARA_WARNING_LOG("underrun\n");
		snd_pcm_status_free(status);
		snd_pcm_prepare(pad->handle);
		return 0;
	}
	PARA_ERROR_LOG("alsa write error: %s\n", snd_strerror(-frames));
	ret = -E_ALSA;
err:
	assert(ret < 0);
	btr_remove_node(&wn->btrn);
	return ret;
}

/** \cond doxygen_ignore */
struct writer lsg_write_cmd_com_alsa_user_data = {
	.pre_monitor = alsa_write_pre_monitor,
	.post_monitor = alsa_write_post_monitor,
	.close = alsa_close,
};
/** \endcond */