// SPDX-License-Identifier: GPL-2.0

//

// xfer-libffado.c - receive/transmit frames by libffado.

//

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

//

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

#include "xfer.h"

#include "misc.h"

#include "frame-cache.h"

#include <stdio.h>

#include <sched.h>

#include <libffado/ffado.h>

struct libffado_state {

	ffado_device_t *handle;

	enum ffado_direction direction;

	char *port_literal;

	char *node_literal;

	char *guid_literal;

	unsigned int frames_per_period;

	unsigned int periods_per_buffer;

	unsigned int sched_priority;

	bool slave_mode:1;

	bool snoop_mode:1;

	unsigned int data_ch_count;

	ffado_streaming_stream_type *data_ch_map;

	int (*process_frames)(struct xfer_context *xfer,

			      unsigned int *frame_count,

			      struct mapper_context *mapper,

			      struct container_context *cntrs);

	struct frame_cache cache;

};

enum no_short_opts {

	OPT_FRAMES_PER_PERIOD = 200,

	OPT_PERIODS_PER_BUFFER,

	OPT_SLAVE_MODE,

	OPT_SNOOP_MODE,

	OPT_SCHED_PRIORITY,

};

#define S_OPTS	"p:n:g:"

static const struct option l_opts[] = {

	{"port",		1, 0, 'p'},

	{"node",		1, 0, 'n'},

	{"guid",		1, 0, 'g'},

	{"frames-per-period",	1, 0, OPT_FRAMES_PER_PERIOD},

	{"periods-per-buffer",	1, 0, OPT_PERIODS_PER_BUFFER},

	{"slave",		0, 0, OPT_SLAVE_MODE},

	{"snoop",		0, 0, OPT_SNOOP_MODE},

	{"sched-priority",	1, 0, OPT_SCHED_PRIORITY}, // to SCHED_FIFO

};

static int xfer_libffado_init(struct xfer_context *xfer,

			       snd_pcm_stream_t direction)

{

	struct libffado_state *state = xfer->private_data;

	if (direction == SND_PCM_STREAM_CAPTURE)

		state->direction = FFADO_CAPTURE;

	else if (direction == SND_PCM_STREAM_PLAYBACK)

		state->direction = FFADO_PLAYBACK;

	else

		return -EINVAL;

	return 0;

}

static int xfer_libffado_parse_opt(struct xfer_context *xfer, int key,

				    const char *optarg)

{

	struct libffado_state *state = xfer->private_data;

	int err;

	if (key == 'p')

		state->port_literal = arg_duplicate_string(optarg, &err;;

	else if (key == 'n')

		state->node_literal = arg_duplicate_string(optarg, &err;;

	else if (key == 'g')

		state->guid_literal = arg_duplicate_string(optarg, &err;;

	else if (key == OPT_FRAMES_PER_PERIOD)

		state->frames_per_period = arg_parse_decimal_num(optarg, &err;;

	else if (key == OPT_PERIODS_PER_BUFFER)

		state->periods_per_buffer = arg_parse_decimal_num(optarg, &err;;

	else if (key == OPT_SLAVE_MODE)

		state->slave_mode = true;

	else if (key == OPT_SNOOP_MODE)

		state->snoop_mode = true;

	else if (key == OPT_SCHED_PRIORITY)

		state->sched_priority = arg_parse_decimal_num(optarg, &err;;

	else

		err = -ENXIO;

	return err;

}

static int validate_sched_priority(struct libffado_state *state)

{

	int val;

	val = sched_get_priority_max(SCHED_FIFO);

	if (val < 0)

		return -errno;

	if (state->sched_priority > val)

		return -EINVAL;

	val = sched_get_priority_min(SCHED_FIFO);

	if (val < 0)

		return -errno;

	if (state->sched_priority < val)

		return -EINVAL;

	return 0;

}

static int xfer_libffado_validate_opts(struct xfer_context *xfer)

{

	struct libffado_state *state = xfer->private_data;

	int err;

	if (state->node_literal != NULL) {

		if (state->port_literal == NULL) {

			fprintf(stderr,

				"'n' option should correspond 'p' option.\n");

			return -EINVAL;

		}

	}

	if (state->port_literal != NULL && state->guid_literal != NULL) {

		fprintf(stderr,

			"Neither 'p' option nor 'g' option is available at the "

			"same time.\n");

		return -EINVAL;

	}

	if (state->guid_literal != NULL) {

		if (strstr(state->guid_literal, "0x") != state->guid_literal) {

			fprintf(stderr,

				"A value of 'g' option should have '0x' as its "

				"prefix for hexadecimal number.\n");

			return -EINVAL;

		}

	}

	if (state->slave_mode && state->snoop_mode) {

		fprintf(stderr, "Neither slave mode nor snoop mode is available"

				"at the same time.\n");

		return -EINVAL;

	}

	if (state->sched_priority > 0) {

		err = validate_sched_priority(state);

		if (err < 0)

			return err;

	}

	if (state->frames_per_period == 0)

		state->frames_per_period = 512;

	if (state->periods_per_buffer == 0)

		state->periods_per_buffer = 2;

	return 0;

}

static int r_process_frames(struct xfer_context *xfer,

			    unsigned int *frame_count,

			    struct mapper_context *mapper,

			    struct container_context *cntrs)

{

	struct libffado_state *state = xfer->private_data;

	unsigned int avail_count;

	unsigned int bytes_per_frame;

	unsigned int consumed_count;

	int err;

	// Trim up to expected frame count.

	avail_count = state->frames_per_period;

	if (*frame_count < avail_count)

		avail_count = *frame_count;

	// Cache required amount of frames.

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

		int ch;

		int pos;

		// Register buffers.

		pos = 0;

		bytes_per_frame = state->cache.bytes_per_sample *

				  state->cache.samples_per_frame;

		for (ch = 0; ch < state->data_ch_count; ++ch) {

			char *buf;

			if (state->data_ch_map[ch] != ffado_stream_type_audio)

				continue;

			buf = state->cache.buf_ptr;

			buf += ch * bytes_per_frame;

			if (ffado_streaming_set_capture_stream_buffer(state->handle,

								      ch, buf))

				return -EIO;

			++pos;

		}

		assert(pos == xfer->samples_per_frame);

		// Move data to the buffer from intermediate buffer.

		if (!ffado_streaming_transfer_buffers(state->handle))

			return -EIO;

		frame_cache_increase_count(&state->cache,

					   state->frames_per_period);

	}

	// Write out to file descriptors.

	consumed_count = frame_cache_get_count(&state->cache);

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

					    &consumed_count, cntrs);

	if (err < 0)

		return err;

	frame_cache_reduce(&state->cache, consumed_count);

	*frame_count = consumed_count;

	return 0;

}

static int w_process_frames(struct xfer_context *xfer,

			    unsigned int *frame_count,

			    struct mapper_context *mapper,

			    struct container_context *cntrs)

{

	struct libffado_state *state = xfer->private_data;

	unsigned int avail_count;

	int pos;

	int ch;

	unsigned int bytes_per_frame;

	unsigned int consumed_count;

	int err;

	// Trim up to expected frame_count.

	avail_count = state->frames_per_period;

	if (*frame_count < avail_count)

		avail_count = *frame_count;

	// Cache required amount of frames.

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

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

		err = mapper_context_process_frames(mapper, state->cache.buf_ptr,

						    &avail_count, cntrs);

		if (err < 0)

			return err;

		frame_cache_increase_count(&state->cache, avail_count);

		avail_count = state->cache.remained_count;

	}

	// Register buffers.

	pos = 0;

	bytes_per_frame = state->cache.bytes_per_sample *

			  state->cache.samples_per_frame;

	for (ch = 0; ch < state->data_ch_count; ++ch) {

		char *buf;

		if (state->data_ch_map[ch] != ffado_stream_type_audio)

			continue;

		buf = state->cache.buf;

		buf += bytes_per_frame;

		if (ffado_streaming_set_playback_stream_buffer(state->handle,

								ch, buf))

			return -EIO;

		++pos;

	}

	assert(pos == xfer->samples_per_frame);

	// Move data on the buffer for transmission.

	if (!ffado_streaming_transfer_buffers(state->handle))

		return -EIO;

	consumed_count = state->frames_per_period;

	frame_cache_reduce(&state->cache, consumed_count);

	*frame_count = consumed_count;

	return 0;

}

static int open_handle(struct xfer_context *xfer,

		       unsigned int frames_per_second)

{

	struct libffado_state *state = xfer->private_data;

	ffado_options_t options = {0};

	ffado_device_info_t info = {0};

	char str[32] = {0};

	char *strings[1];

	// Set target unit if given.

	if (state->port_literal != NULL) {

		if (state->node_literal != NULL) {

			snprintf(str, sizeof(str), "hw:%s,%s",

				 state->port_literal, state->node_literal);

		} else {

			snprintf(str, sizeof(str), "hw:%s",

				 state->port_literal);

		}

	} else if (state->guid_literal != NULL) {

		snprintf(str, sizeof(str), "guid:%s", state->guid_literal);

	}

	if (str[0] != '\0') {

		info.nb_device_spec_strings = 1;

		strings[0] = str;

		info.device_spec_strings = strings;

	}

	// Set common options.

	options.sample_rate = frames_per_second;

	options.period_size = state->frames_per_period;

	options.nb_buffers = state->periods_per_buffer;

	options.realtime = !!(state->sched_priority > 0);

	options.packetizer_priority = state->sched_priority;

	options.slave_mode = state->slave_mode;

	options.snoop_mode = state->snoop_mode;

	options.verbose = xfer->verbose;

	state->handle = ffado_streaming_init(info, options);

	if (state->handle == NULL)

		return -EINVAL;

	return 0;

}

static int enable_mbla_data_ch(struct libffado_state *state,

			       unsigned int *samples_per_frame)

{

	int (*func_type)(ffado_device_t *handle, int pos);

	int (*func_onoff)(ffado_device_t *handle, int pos, int on);

	int count;

	int ch;

	if (state->direction == FFADO_CAPTURE) {

		func_type = ffado_streaming_get_capture_stream_type;

		func_onoff = ffado_streaming_capture_stream_onoff;

		count = ffado_streaming_get_nb_capture_streams(state->handle);

	} else {

		func_type = ffado_streaming_get_playback_stream_type;

		func_onoff = ffado_streaming_playback_stream_onoff;

		count = ffado_streaming_get_nb_playback_streams(state->handle);

	}

	if (count <= 0)

		return -EIO;

	state->data_ch_map = calloc(count, sizeof(*state->data_ch_map));

	if (state->data_ch_map == NULL)

		return -ENOMEM;

	state->data_ch_count = count;

	// When a data ch is off, data in the ch is truncated. This helps to

	// align PCM frames in interleaved order.

	*samples_per_frame = 0;

	for (ch = 0; ch < count; ++ch) {

		int on;

		state->data_ch_map[ch] = func_type(state->handle, ch);

		on = !!(state->data_ch_map[ch] == ffado_stream_type_audio);

		if (func_onoff(state->handle, ch, on))

			return -EIO;

		if (on)

			++(*samples_per_frame);

	}

	return 0;

}

static int xfer_libffado_pre_process(struct xfer_context *xfer,

				     snd_pcm_format_t *format,

				     unsigned int *samples_per_frame,

				     unsigned int *frames_per_second,

				     snd_pcm_access_t *access,

				     snd_pcm_uframes_t *frames_per_buffer)

{

	struct libffado_state *state = xfer->private_data;

	unsigned int channels;

	int err;

	// Supported format of sample is 24 bit multi bit linear audio in

	// AM824 format or the others.

	if (state->direction == FFADO_CAPTURE) {

		if (*format == SND_PCM_FORMAT_UNKNOWN)

			*format = SND_PCM_FORMAT_S24;

	}

	if (*format != SND_PCM_FORMAT_S24) {

		fprintf(stderr,

			"A libffado backend supports S24 only.\n");

		return -EINVAL;

	}

	// The backend requires the number of frames per second for its

	// initialization.

	if (state->direction == FFADO_CAPTURE) {

		if (*frames_per_second == 0)

			*frames_per_second = 48000;

	}

	if (*frames_per_second < 32000 || *frames_per_second > 192000) {

		fprintf(stderr,

			"A libffado backend supports sampling rate between "

			"32000 and 192000, discretely.\n");

		return -EINVAL;

	}

	err = open_handle(xfer, *frames_per_second);

	if (err < 0)

		return err;

	if (ffado_streaming_set_audio_datatype(state->handle,

					       ffado_audio_datatype_int24))

		return -EINVAL;

	// Decide buffer layout.

	err = enable_mbla_data_ch(state, &channels);

	if (err < 0)

		return err;

	// This backend doesn't support resampling.

	if (state->direction == FFADO_CAPTURE) {

		if (*samples_per_frame == 0)

			*samples_per_frame = channels;

	}

	if (*samples_per_frame != channels) {

		fprintf(stderr,

			"The number of samples per frame should be %u.\n",

			channels);

		return -EINVAL;

	}

	// A buffer has interleaved-aligned PCM frames.

	*access = SND_PCM_ACCESS_RW_INTERLEAVED;

	*frames_per_buffer =

			state->frames_per_period * state->periods_per_buffer;

	// Use cache for double number of frames per period.

	err = frame_cache_init(&state->cache, *access,

			       snd_pcm_format_physical_width(*format) / 8,

			       *samples_per_frame, state->frames_per_period * 2);

	if (err < 0)

		return err;

	if (state->direction == FFADO_CAPTURE)

		state->process_frames = r_process_frames;

	else

		state->process_frames = w_process_frames;

	if (ffado_streaming_prepare(state->handle))

		return -EIO;

	if (ffado_streaming_start(state->handle))

		return -EIO;

	return 0;

}

static int xfer_libffado_process_frames(struct xfer_context *xfer,

					unsigned int *frame_count,

					struct mapper_context *mapper,

					struct container_context *cntrs)

{

	struct libffado_state *state = xfer->private_data;

	ffado_wait_response res;

	int err;

	res = ffado_streaming_wait(state->handle);

	if (res == ffado_wait_shutdown || res == ffado_wait_error) {

		err = -EIO;

	} else if (res == ffado_wait_xrun) {

		// No way to recover in this backend.

		err = -EPIPE;

	} else if (res == ffado_wait_ok) {

		err = state->process_frames(xfer, frame_count, mapper, cntrs);

	} else {

		err = -ENXIO;

	}

	if (err < 0)

		*frame_count = 0;

	return err;

}

static void xfer_libffado_pause(struct xfer_context *xfer, bool enable)

{

	struct libffado_state *state = xfer->private_data;

	// This is an emergency avoidance because this backend doesn't support

	// suspend/aresume operation.

	if (enable) {

		ffado_streaming_stop(state->handle);

		ffado_streaming_finish(state->handle);

		exit(EXIT_FAILURE);

	}

}

static void xfer_libffado_post_process(struct xfer_context *xfer)

{

	struct libffado_state *state = xfer->private_data;

	if (state->handle != NULL) {

		ffado_streaming_stop(state->handle);

		ffado_streaming_finish(state->handle);

	}

	frame_cache_destroy(&state->cache);

	free(state->data_ch_map);

	state->data_ch_map = NULL;

}

static void xfer_libffado_destroy(struct xfer_context *xfer)

{

	struct libffado_state *state = xfer->private_data;

	free(state->port_literal);

	free(state->node_literal);

	free(state->guid_literal);

	state->port_literal = NULL;

	state->node_literal = NULL;

	state->guid_literal = NULL;

}

static void xfer_libffado_help(struct xfer_context *xfer)

{

	printf(

"      -p, --port           decimal ID of port to decide 1394 OHCI controller for communication on IEEE 1394 bus\n"

"      -n, --node           decimal ID of node to decide unit on IEEE 1394 bus for transmission of audio data frame\n"

"      -g, --guid           hexadecimal ID for node on IEEE 1394 bus for transmission of audio data frame\n"

"      --frames-per-period  the number of audio data frame to handle one operation (frame unit)\n"

"      --periods-per-bufer  the number of periods in intermediate buffer between libffado (frame unit)\n"

"      --slave              receive frames from the other Linux system on IEEE 1394 bus running with libffado.\n"

"      --snoop              receive frames on packets of all isochronous channels.\n"

"      --sched-priority     set SCHED_FIFO with given priority. see RLIMIT_RTPRIO in getrlimit(2).\n"

	);

}

const struct xfer_data xfer_libffado = {

	.s_opts = S_OPTS,

	.l_opts = l_opts,

	.l_opts_count = ARRAY_SIZE(l_opts),

	.ops = {

		.init		= xfer_libffado_init,

		.parse_opt	= xfer_libffado_parse_opt,

		.validate_opts	= xfer_libffado_validate_opts,

		.pre_process	= xfer_libffado_pre_process,

		.process_frames	= xfer_libffado_process_frames,

		.pause		= xfer_libffado_pause,

		.post_process	= xfer_libffado_post_process,

		.destroy	= xfer_libffado_destroy,

		.help		= xfer_libffado_help,

	},

	.private_size = sizeof(struct libffado_state),

};