/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2017 Intel Corporation. All rights reserved.
 *
 * Author: Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>
 */

#ifndef __SOF_AUDIO_SRC_SRC_H__
#define __SOF_AUDIO_SRC_SRC_H__

#include <stddef.h>
#include <stdint.h>
#include <ipc4/base-config.h>
#include <sof/audio/ipc-config.h>
#include <sof/audio/audio_stream.h>
#include <sof/audio/component.h>
#include <sof/audio/module_adapter/module/generic.h>

struct src_param {
	int fir_s1;
	int fir_s2;
	int out_s1;
	int out_s2;
	int sbuf_length;
	int src_multich;
	int total;
	int blk_in;
	int blk_out;
	int stage1_times;
	int stage2_times;
	int idx_in;
	int idx_out;
	int nch;
};

struct src_stage {
	const int idm;
	const int odm;
	const int num_of_subfilters;
	const int subfilter_length;
	const int filter_length;
	const int blk_in;
	const int blk_out;
	const int halfband;
	const int shift;
	const void *coefs; /* Can be int16_t or int32_t depending on config */
};

struct src_state {
	int fir_delay_size;	/* samples */
	int out_delay_size;	/* samples */
	int32_t *fir_delay;
	int32_t *out_delay;
	int32_t *fir_wp;
	int32_t *out_rp;
};

struct polyphase_src {
	int number_of_stages;
	struct src_stage *stage1;
	struct src_stage *stage2;
	struct src_state state1;
	struct src_state state2;
};

struct src_stage_prm {
	int nch;
	int times;
	void const *x_rptr;
	void const *x_end_addr;
	size_t x_size;
	void *y_wptr;
	void *y_addr;
	void *y_end_addr;
	size_t y_size;
	int shift;
	struct src_state *state;
	struct src_stage *stage;
};

static inline void src_inc_wrap(int32_t **ptr, int32_t *end, size_t size)
{
	if (*ptr >= end)
		*ptr = (int32_t *)((uint8_t *)*ptr - size);
}

static inline void src_dec_wrap(int32_t **ptr, int32_t *addr, size_t size)
{
	if (*ptr < addr)
		*ptr = (int32_t *)((uint8_t *)*ptr + size);
}

#if CONFIG_FORMAT_S16LE
static inline void src_inc_wrap_s16(int16_t **ptr, int16_t *end, size_t size)
{
	if (*ptr >= end)
		*ptr = (int16_t *)((uint8_t *)*ptr - size);
}

static inline void src_dec_wrap_s16(int16_t **ptr, int16_t *addr, size_t size)
{
	if (*ptr < addr)
		*ptr = (int16_t *)((uint8_t *)*ptr + size);
}
#endif /* CONFIG_FORMAT_S16LE */

static inline void src_state_reset(struct src_state *state)
{
	state->fir_delay_size = 0;
	state->out_delay_size = 0;
}

static inline void src_polyphase_reset(struct polyphase_src *src)
{
	src->number_of_stages = 0;
	src->stage1 = NULL;
	src->stage2 = NULL;
	src_state_reset(&src->state1);
	src_state_reset(&src->state2);
}

int src_polyphase_init(struct polyphase_src *src, struct src_param *p,
		       int32_t *delay_lines_start);

int src_polyphase(struct polyphase_src *src, int32_t x[], int32_t y[],
		  int n_in);

#if CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE
void src_polyphase_stage_cir(struct src_stage_prm *s);
#endif /* CONFIG_FORMAT_S24LE || CONFIG_FORMAT_S32LE */

#if CONFIG_FORMAT_S16LE
void src_polyphase_stage_cir_s16(struct src_stage_prm *s);
#endif /* CONFIG_FORMAT_S16LE */

int32_t src_input_rates(void);

int32_t src_output_rates(void);

void src_set_alignment(struct sof_source *source, struct sof_sink *sink);

#if CONFIG_IPC_MAJOR_4
/* src component private data */
struct ipc4_config_src {
	struct ipc4_base_module_cfg base;
	uint32_t sink_rate;
};
#endif

struct comp_data {
#if CONFIG_IPC_MAJOR_4
	struct ipc4_config_src ipc_config;
#else
	struct ipc_config_src ipc_config;
#endif /* CONFIG_IPC_MAJOR_4 */
	struct polyphase_src src;
	struct src_param param;
	int32_t *delay_lines;
	uint32_t sink_rate;
	uint32_t source_rate;
	int32_t *sbuf_w_ptr;
	int32_t const *sbuf_r_ptr;
	int sbuf_avail;
	int data_shift;
	int source_frames;
	int sink_frames;
	int sample_container_bytes;
	int channels_count;
	int (*src_func)(struct comp_data *cd, struct sof_source *source,
			struct sof_sink *sink);
	void (*polyphase_func)(struct src_stage_prm *s);
};

#endif /* __SOF_AUDIO_SRC_SRC_H__ */

#if CONFIG_IPC_MAJOR_4

int src_stream_pcm_source_rate_check(struct ipc4_config_src cfg,
				     struct sof_ipc_stream_params *params);
int src_stream_pcm_sink_rate_check(struct ipc4_config_src cfg,
				   struct sof_ipc_stream_params *params);
#elif CONFIG_IPC_MAJOR_3
int src_stream_pcm_sink_rate_check(struct ipc_config_src cfg,
				   struct sof_ipc_stream_params *params);
int src_stream_pcm_source_rate_check(struct ipc_config_src cfg,
				     struct sof_ipc_stream_params *params);
#endif /* CONFIG_IPC_MAJOR_4 */

/* Calculates the needed FIR delay line length */
static inline int src_fir_delay_length(struct src_stage *s)
{
	return s->subfilter_length + (s->num_of_subfilters - 1) * s->idm
		+ s->blk_in;
}

/* Calculates the FIR output delay line length */
static inline int src_out_delay_length(struct src_stage *s)
{
	return 1 + (s->num_of_subfilters - 1) * s->odm;
}

/* Returns index of a matching sample rate */
static inline int src_find_fs(int fs_list[], int list_length, int fs)
{
	int i;

	for (i = 0; i < list_length; i++) {
		if (fs_list[i] == fs)
			return i;
	}
	return -EINVAL;
}

/* Fallback function */
static inline int src_fallback(struct comp_data *cd,
			       struct sof_source *source,
			       struct sof_sink *sink)
{
	return 0;
}

int src_rate_check(const void *spec);
int src_set_params(struct processing_module *mod, struct sof_sink *sink);

void src_get_source_sink_params(struct comp_dev *dev, struct sof_source *source,
				struct sof_sink *sink);
int src_prepare_general(struct processing_module *mod,
			struct sof_source *source,
			struct sof_sink *sink);
int src_init(struct processing_module *mod);

int src_buffer_lengths(struct comp_dev *dev, struct comp_data *cd,
		       int nch);
int init_stages(struct src_stage *stage1, struct src_stage *stage2,
		struct polyphase_src *src, struct src_param *p,
		int n, int32_t *delay_lines_start);
int src_1s(struct comp_data *cd, struct sof_source *source,
	   struct sof_sink *sink);
int src_copy_sxx(struct comp_data *cd, struct sof_source *source,
		 struct sof_sink *sink);
int src_verify_params(struct processing_module *mod);

bool src_get_copy_limits(struct comp_data *cd,
			 struct sof_source *source,
			 struct sof_sink *sink);
int src_params_general(struct processing_module *mod,
		       struct sof_source *source,
		       struct sof_sink *sink);
int src_prepare(struct processing_module *mod,
		struct sof_source **sources, int num_of_sources,
		struct sof_sink **sinks, int num_of_sinks);
int src_2s(struct comp_data *cd,
	   struct sof_source *source, struct sof_sink *sink);

bool src_is_ready_to_process(struct processing_module *mod,
			     struct sof_source **sources, int num_of_sources,
			     struct sof_sink **sinks, int num_of_sinks);
int src_process(struct processing_module *mod,
		struct sof_source **sources, int num_of_sources,
		struct sof_sink **sinks, int num_of_sinks);

int src_set_config(struct processing_module *mod, uint32_t config_id,
		   enum module_cfg_fragment_position pos, uint32_t data_offset_size,
		   const uint8_t *fragment, size_t fragment_size, uint8_t *response,
		   size_t response_size);
int src_get_config(struct processing_module *mod, uint32_t config_id,
		   uint32_t *data_offset_size, uint8_t *fragment, size_t fragment_size);
int src_free(struct processing_module *mod);
int src_reset(struct processing_module *mod);
extern const struct sof_uuid src_uuid;
extern struct tr_ctx src_tr;