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

/** \file oggdec_filter.c Paraslash's ogg vorbis decoder. */


/**
 * Avoid warnings on NetBSD.
 *
 * The static ogg-vorbis callback structures are only needed on Windows. At
 * least with vorbistools-1.3.7, they cause warnings on NetBSD-10.0. The define
 * below instructs the preprocessor to not define these structures, avoiding
 * the warnings. See the comment in vorbisfile.h for details.
 */
#define OV_EXCLUDE_STATIC_CALLBACKS

#include <vorbis/vorbisfile.h>

#include "para.h"
#include "list.h"
#include "sched.h"
#include "buffer_tree.h"
#include "filter.h"
#include "error.h"
#include "string.h"

/** Determine byte sex. */
#ifdef WORDS_BIGENDIAN
#define ENDIAN 1
#else
#define ENDIAN 0
#endif

/** Data specific to the oggdec filter. */
struct private_oggdec_data {
	/** Describes an ogg vorbis file. */
	OggVorbis_File *vf;
	/** The number of bytes consumed from the input buffer. */
	size_t converted;
	/** The number of channels of the current stream. */
	unsigned int channels;
	/** Current sample rate in Hz. */
	unsigned int sample_rate;
	/** Whether everything was decoded during the previous iteration. */
	bool have_more;
};

static size_t cb_read(void *buf, size_t size, size_t nmemb, void *datasource)
{
	struct filter_node *fn = datasource;
	struct private_oggdec_data *pod = fn->private_data;
	struct btr_node *btrn = fn->btrn;
	char *btr_buf;
	size_t nbytes = btr_next_buffer(btrn, &btr_buf), tmp;

	/**
	 * oggvorbis always uses size == 1. Other sizes would complicate the code
	 * for no real gain. So we simply don't support size != 1.
	 */
	assert(size == 1);
	assert(pod->converted <= nbytes);
	tmp = nbytes - pod->converted;
	PARA_DEBUG_LOG("vorbis requests %zu bytes have %zu\n", nmemb, tmp);
	tmp = PARA_MIN(tmp, nmemb);
	if (tmp == 0)
		return 0;
	memcpy(buf, btr_buf + pod->converted, tmp);
	pod->converted += tmp;
	return tmp;
}

/*
 * Custom data seeking function.
 *
 * Since we want the data source to be treated as unseekable at all
 * times, the provided seek callback always returns -1 (failure).
 */
static int cb_seek(__a_unused void *datasource, __a_unused ogg_int64_t offset,
		__a_unused int whence)
{
	return -1;
}

static int cb_close(__a_unused void *datasource)
{
	return 0;
}

static const ov_callbacks ovc = {
	.read_func = cb_read,
	.seek_func = cb_seek,
	.close_func = cb_close,
	/*
	 * The tell function need not be provided if the data IO abstraction is
	 * not seekable
	 */
	.tell_func = NULL
};

static void ogg_open(struct filter_node *fn)
{
	fn->private_data = zalloc(sizeof(struct private_oggdec_data));
	fn->min_iqs = 8000;
}

static void ogg_close(struct filter_node *fn)
{
	struct private_oggdec_data *pod = fn->private_data;

	if (pod && pod->vf) {
		PARA_DEBUG_LOG("ov_clearing %p, pod = %p\n", pod->vf, pod);
		ov_clear(pod->vf);
		free(pod->vf);
		pod->vf = NULL;
	} else
		PARA_DEBUG_LOG("nothing to close\n");
	free(pod);
	fn->private_data = NULL;
}

static int oggdec_execute(const struct btr_node *btrn, const char *cmd,
		char **result)
{
	struct filter_node *fn = btr_context(btrn);
	struct private_oggdec_data *pod = fn->private_data;

	return decoder_execute(cmd, pod->sample_rate, pod->channels, result);
}

static int ogg_init(struct filter_node *fn)
{
	struct private_oggdec_data *pod = fn->private_data;
	struct btr_node *btrn = fn->btrn;
	int ret, oret;
	size_t iqs;
	struct OggVorbis_File *vf = alloc(sizeof(*vf));

	PARA_NOTICE_LOG("iqs: %zu, min_iqs: %zu, opening ov callbacks\n",
		btr_get_input_queue_size(btrn), fn->min_iqs);
open:
	oret = ov_open_callbacks(fn, vf,
		NULL, /* no initial buffer */
		0, /* no initial bytes */
		ovc); /* the ov_open_callbacks */
	if (oret == OV_ENOTVORBIS || oret == OV_EBADHEADER) {
		/* maybe the input buffer is too small */
		if (!btr_no_parent(btrn)) {
			fn->min_iqs += 1000;
			iqs = btr_get_input_queue_size(btrn);
			ret = 0;
			if (iqs < fn->min_iqs)
				goto out;
			btr_merge(btrn, fn->min_iqs);
			pod->converted = 0;
			goto open;
		}
		ret = (oret == OV_ENOTVORBIS)?
			-E_OGGDEC_NOTVORBIS : -E_OGGDEC_BADHEADER;
		goto out;
	}
	ret = -E_OGGDEC_READ;
	if (oret == OV_EREAD)
		goto out;
	ret = -E_OGGDEC_VERSION;
	if (oret == OV_EVERSION)
		goto out;
	ret = -E_OGGDEC_FAULT;
	if (oret < 0)
		goto out;
	pod->channels = ov_info(vf, 0)->channels;
	pod->sample_rate = ov_info(vf, 0)->rate;
	PARA_NOTICE_LOG("%u channels, %u Hz\n", pod->channels,
		pod->sample_rate);
	ret = 1;
out:
	if (ret <= 0)
		free(vf);
	else {
		btr_consume(btrn, pod->converted);
		pod->converted = 0;
		fn->min_iqs = 0;
		pod->vf = vf;
		pod->have_more = true;
	}
	return ret;
}

/** Suspend decoding if output queue size is larger than that. */
#define OGGDEC_MAX_OUTPUT_SIZE (96 * 1024)

/**
  * Allocate chunks of this size and produce at most one chunk of output per
  * ->post_monitor() invocation. If the buffer could only be filled partially
  * due to insufficient input being available, it is shrunk to the real output
  * size and the resized buffer is fed into the output queue.
  */
#define OGGDEC_OUTPUT_CHUNK_SIZE (32 * 1024)

static void ogg_pre_monitor(struct sched *s, void *context)
{
	struct filter_node *fn = context;
	struct private_oggdec_data *pod = fn->private_data;
	struct btr_node *btrn = fn->btrn;
	int ret;

	ret = btr_node_status(btrn, fn->min_iqs, BTR_NT_INTERNAL);
	if (ret != 0)
		return sched_min_delay(s);
	if (!pod->have_more)
		return;
	if (btr_get_output_queue_size(btrn) > OGGDEC_MAX_OUTPUT_SIZE)
		return;
	sched_min_delay(s);
}

static int ogg_post_monitor(__a_unused struct sched *s, void *context)
{
	struct filter_node *fn = context;
	struct private_oggdec_data *pod = fn->private_data;
	struct btr_node *btrn = fn->btrn;
	int ret, have;
	char *buf;

	ret = btr_node_status(btrn, fn->min_iqs, BTR_NT_INTERNAL);
	if (ret < 0) {
		if (ret != -E_EOF) /* fatal error */
			goto out;
		if (fn->min_iqs == 0 && !pod->have_more) /* EOF */
			goto out;
		/* last ov_read() returned OV_HOLE */
	} else if (ret == 0 && !pod->have_more) /* nothing to do */
		goto out;
	if (btr_get_output_queue_size(btrn) > OGGDEC_MAX_OUTPUT_SIZE)
		return 0;
	if (!pod->vf) {
		if (ret <= 0)
			goto out;
		btr_merge(btrn, fn->min_iqs);
		ret = ogg_init(fn);
		goto out;
	}
	have = 0;
	buf = alloc(OGGDEC_OUTPUT_CHUNK_SIZE);
	for (;;) {
		ret = ov_read(pod->vf, buf + have, OGGDEC_OUTPUT_CHUNK_SIZE - have,
			ENDIAN, 2 /* 16 bit */, 1 /* signed */, NULL);
		btr_consume(btrn, pod->converted);
		pod->converted = 0;
		if (ret <= 0)
			break;
		fn->min_iqs = 0;
		have += ret;
		if (have >= OGGDEC_OUTPUT_CHUNK_SIZE)
			break;
	}
	pod->have_more = (ret > 0);
	if (have > 0) {
		if (have < OGGDEC_OUTPUT_CHUNK_SIZE)
			buf = para_realloc(buf, have);
		btr_add_output(buf, have, btrn);
	} else
		free(buf);
	if (ret == OV_HOLE) /* avoid buffer underruns */
		fn->min_iqs = 9000;
	if (ret >= 0 || ret == OV_HOLE)
		return 0;
	ret = -E_OGGDEC_BADLINK;
out:
	if (ret < 0)
		btr_remove_node(&fn->btrn);
	return ret;
}

/** \cond doxygen_ignore */
const struct filter lsg_filter_cmd_com_oggdec_user_data = {
	.open = ogg_open,
	.close = ogg_close,
	.pre_monitor = ogg_pre_monitor,
	.post_monitor = ogg_post_monitor,
	.execute = oggdec_execute
};
/** \endcond */