sof/tools/testbench/file.c

// SPDX-License-Identifier: BSD-3-Clause
//
// Copyright(c) 2018 Intel Corporation. All rights reserved.

/* file component for reading/writing pcm samples to/from a file */

#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <stdlib.h>
#include <errno.h>
#include <inttypes.h>
#include <rtos/sof.h>
#include <sof/list.h>
#include <sof/audio/stream.h>
#include <sof/audio/ipc-config.h>
#include <rtos/clk.h>
#include <sof/ipc/driver.h>
#include <sof/audio/component.h>
#include <sof/audio/format.h>
#include <sof/audio/pipeline.h>
#include <ipc/stream.h>
#include "testbench/common_test.h"
#include "testbench/file.h"

/* bfc7488c-75aa-4ce8-9bde-d8da08a698c2 */
DECLARE_SOF_RT_UUID("file", file_uuid, 0xbfc7488c, 0x75aa, 0x4ce8,
		    0x9d, 0xbe, 0xd8, 0xda, 0x08, 0xa6, 0x98, 0xc2);
DECLARE_TR_CTX(file_tr, SOF_UUID(file_uuid), LOG_LEVEL_INFO);

static const struct comp_driver comp_file_dai;
static const struct comp_driver comp_file_host;

/*
 * Helpers for s24_4le data. To avoid an overflown 24 bit to be taken as valid 32 bit
 * sample mask in file read the 8 most signing bits to zeros. In file write similarly
 * shift the 24 bit word to MSB and possibly overflow it, then shift it back to LSB
 * side to create sign extension.
 */

static void mask_sink_s24(const struct audio_stream *sink, int samples)
{
	int32_t *snk = (int32_t *)sink->w_ptr;
	size_t bytes = samples * sizeof(int32_t);
	size_t bytes_snk;
	int samples_avail;
	int i;

	while (bytes) {
		bytes_snk = audio_stream_bytes_without_wrap(sink, snk);
		samples_avail = FILE_BYTES_TO_S32_SAMPLES(MIN(bytes, bytes_snk));
		for (i = 0; i < samples_avail; i++)
			*snk++ &= 0x00ffffff;

		bytes -= samples * sizeof(int32_t);
		snk = audio_stream_wrap(sink, snk);
	}
}

static void sign_extend_source_s24(const struct audio_stream *source, int samples)
{
	int32_t tmp;
	int32_t *src = (int32_t *)source->r_ptr;
	size_t bytes = samples * sizeof(int32_t);
	size_t bytes_src;
	int samples_avail;
	int i;

	while (bytes) {
		bytes_src = audio_stream_bytes_without_wrap(source, src);
		samples_avail = FILE_BYTES_TO_S32_SAMPLES(MIN(bytes, bytes_src));
		for (i = 0; i < samples_avail; i++) {
			tmp = *src << 8;
			*src++ = tmp >> 8;
		}

		bytes -= samples * sizeof(int32_t);
		src = audio_stream_wrap(source, src);
	}
}

/*
 * Read 32-bit samples from binary file
 */
static int read_binary_s32(struct file_comp_data *cd, const struct audio_stream *sink, int samples)
{
	int32_t *snk = (int32_t *)sink->w_ptr;
	size_t samples_avail;
	size_t bytes_snk;
	size_t bytes = samples * sizeof(int32_t);
	int ret;
	int samples_copied = 0;

	while (bytes) {
		bytes_snk = audio_stream_bytes_without_wrap(sink, snk);
		samples_avail = FILE_BYTES_TO_S32_SAMPLES(MIN(bytes, bytes_snk));
		ret = fread(snk, sizeof(int32_t), samples_avail, cd->fs.rfh);
		if (!ret) {
			cd->fs.reached_eof = 1;
			return samples_copied;
		}

		samples_copied += ret;
		bytes -= ret * sizeof(int32_t);
		snk = audio_stream_wrap(sink, snk + ret);
	}

	return samples_copied;
}

/*
 * Write 32-bit samples to binary file
 */
static int write_binary_s32(struct file_comp_data *cd, const struct audio_stream *source,
			    int samples)
{
	int32_t *src = (int32_t *)source->r_ptr;
	size_t samples_avail;
	size_t bytes_src;
	size_t bytes = samples * sizeof(int32_t);
	int ret;
	int samples_copied = 0;

	while (bytes) {
		bytes_src = audio_stream_bytes_without_wrap(source, src);
		samples_avail = FILE_BYTES_TO_S32_SAMPLES(MIN(bytes, bytes_src));
		ret = fwrite(src, sizeof(int32_t), samples_avail, cd->fs.wfh);
		if (ret == 0) {
			cd->fs.write_failed = true;
			return samples_copied;
		}
		samples_copied += ret;
		bytes -= ret * sizeof(int32_t);
		src = audio_stream_wrap(source, src + ret);
	}

	return samples_copied;
}

/*
 * Read 32-bit samples from text file
 */
static int read_text_s32(struct file_comp_data *cd, const struct audio_stream *sink, int samples)
{
	int32_t *snk = (int32_t *)sink->w_ptr;
	size_t bytes = samples * sizeof(int32_t);
	size_t bytes_snk;
	int ret;
	int i;
	int samples_copied = 0;

	while (bytes) {
		bytes_snk = audio_stream_bytes_without_wrap(sink, snk);
		samples = FILE_BYTES_TO_S32_SAMPLES(MIN(bytes, bytes_snk));
		for (i = 0; i < samples; i++) {
			ret = fscanf(cd->fs.rfh, "%d", snk++);
			if (ret == EOF) {
				cd->fs.reached_eof = 1;
				return samples_copied;
			}
			samples_copied++;
			bytes -= sizeof(int32_t);
		}
		snk = audio_stream_wrap(sink, snk);
	}

	return samples_copied;
}

/*
 * Write 32-bit samples to text file
 */
static int write_text_s32(struct file_comp_data *cd, const struct audio_stream *source, int samples)
{
	int32_t *src = (int32_t *)source->r_ptr;
	size_t bytes = samples * sizeof(int32_t);
	size_t bytes_src;
	int ret;
	int i;
	int samples_copied = 0;

	while (bytes) {
		bytes_src = audio_stream_bytes_without_wrap(source, src);
		samples = FILE_BYTES_TO_S32_SAMPLES(MIN(bytes, bytes_src));
		for (i = 0; i < samples; i++) {
			ret = fprintf(cd->fs.wfh, "%d\n", *src++);
			if (ret < 1) {
				cd->fs.write_failed = true;
				return samples_copied;
			}
			samples_copied++;
			bytes -= sizeof(int32_t);
		}
		src = audio_stream_wrap(source, src);
	}

	return samples_copied;
}

static int read_samples_s32(struct file_comp_data *cd, const struct audio_stream *sink,
			    int samples, int fmt)
{
	int n_samples = 0;

	switch (cd->fs.f_format) {
	case FILE_RAW:
		/* raw input file */
		n_samples = read_binary_s32(cd, sink, samples);
		break;
	case FILE_TEXT:
		/* text input file */
		n_samples = read_text_s32(cd, sink, samples);
		break;
	default:
		return -EINVAL;
	}

	if (fmt == SOF_IPC_FRAME_S24_4LE)
		mask_sink_s24(sink, samples);

	return n_samples;
}

/*
 * Write 32-bit samples to file
 */
static int write_samples_s32(struct file_comp_data *cd, struct audio_stream *source, int samples,
			     int fmt)
{
	int samples_written;

	if (fmt == SOF_IPC_FRAME_S24_4LE)
		sign_extend_source_s24(source, samples);

	switch (cd->fs.f_format) {
	case FILE_RAW:
		/* raw input file */
		samples_written = write_binary_s32(cd, source, samples);
		break;
	case FILE_TEXT:
		/* text input file */
		samples_written = write_text_s32(cd, source, samples);
		break;
	default:
		return -EINVAL;
	}

	return samples_written;
}

/*
 * Read 16-bit samples from binary file
 */
static int read_binary_s16(struct file_comp_data *cd, const struct audio_stream *sink, int samples)
{
	int16_t *snk = (int16_t *)sink->w_ptr;
	size_t samples_avail;
	size_t bytes_snk;
	size_t bytes = samples * sizeof(int16_t);
	int ret;
	int samples_copied = 0;

	while (bytes) {
		bytes_snk = audio_stream_bytes_without_wrap(sink, snk);
		samples_avail = FILE_BYTES_TO_S16_SAMPLES(MIN(bytes, bytes_snk));
		ret = fread(snk, sizeof(int16_t), samples_avail, cd->fs.rfh);
		if (!ret) {
			cd->fs.reached_eof = 1;
			return samples_copied;
		}

		samples_copied += ret;
		bytes -= ret * sizeof(int16_t);
		snk = audio_stream_wrap(sink, snk + ret);
	}

	return samples_copied;
}

/*
 * Write 16-bit samples to binary file
 */
static int write_binary_s16(struct file_comp_data *cd, const struct audio_stream *source,
			    int samples)
{
	int16_t *src = (int16_t *)source->r_ptr;
	size_t samples_avail;
	size_t bytes_src;
	size_t bytes = samples * sizeof(int16_t);
	int ret;
	int samples_copied = 0;

	while (bytes) {
		bytes_src = audio_stream_bytes_without_wrap(source, src);
		samples_avail = FILE_BYTES_TO_S16_SAMPLES(MIN(bytes, bytes_src));
		ret = fwrite(src, sizeof(int16_t), samples_avail, cd->fs.wfh);
		if (!ret) {
			cd->fs.write_failed = true;
			return samples_copied;
		}

		samples_copied += ret;
		bytes -= ret * sizeof(int16_t);
		src = audio_stream_wrap(source, src + ret);
	}

	return samples_copied;
}

/*
 * Read 16-bit samples from text file
 */
static int read_text_s16(struct file_comp_data *cd, const struct audio_stream *sink, int samples)
{
	int16_t *snk = (int16_t *)sink->w_ptr;
	size_t bytes = samples * sizeof(int16_t);
	size_t bytes_snk;
	int ret;
	int i;
	int samples_copied = 0;

	while (bytes) {
		bytes_snk = audio_stream_bytes_without_wrap(sink, snk);
		samples = FILE_BYTES_TO_S16_SAMPLES(MIN(bytes, bytes_snk));
		for (i = 0; i < samples; i++) {
			ret = fscanf(cd->fs.rfh, "%hd", snk++);
			if (ret == EOF) {
				cd->fs.reached_eof = true;
				return samples_copied;
			}
			samples_copied++;
			bytes -= sizeof(int16_t);
		}
		snk = audio_stream_wrap(sink, snk);
	}

	return samples_copied;
}

/*
 * Write 16-bit samples to text file
 */
static int write_text_s16(struct file_comp_data *cd, const struct audio_stream *source, int samples)
{
	int16_t *src = (int16_t *)source->r_ptr;
	size_t bytes = samples * sizeof(int16_t);
	size_t bytes_src;
	int ret;
	int i;
	int samples_copied = 0;

	while (bytes) {
		bytes_src = audio_stream_bytes_without_wrap(source, src);
		samples = FILE_BYTES_TO_S16_SAMPLES(MIN(bytes, bytes_src));
		for (i = 0; i < samples; i++) {
			ret = fprintf(cd->fs.wfh, "%hd\n", *src++);
			if (ret < 1) {
				cd->fs.write_failed = true;
				return samples_copied;
			}
			samples_copied++;
			bytes -= sizeof(int16_t);
		}
		src = audio_stream_wrap(source, src);
	}

	return samples_copied;
}

static int read_samples_s16(struct file_comp_data *cd, const struct audio_stream *sink, int samples)
{
	int n_samples = 0;

	switch (cd->fs.f_format) {
	case FILE_RAW:
		/* raw input file */
		n_samples = read_binary_s16(cd, sink, samples);
		break;
	case FILE_TEXT:
		/* text input file */
		n_samples = read_text_s16(cd, sink, samples);
		break;
	default:
		return -EINVAL;
	}

	return n_samples;
}

/*
 * Write 16-bit samples to file
 */
static int write_samples_s16(struct file_comp_data *cd, struct audio_stream *source, int samples)
{
	int samples_written;

	switch (cd->fs.f_format) {
	case FILE_RAW:
		/* raw input file */
		samples_written = write_binary_s16(cd, source, samples);
		break;
	case FILE_TEXT:
		/* text input file */
		samples_written = write_text_s16(cd, source, samples);
		break;
	default:
		return -EINVAL;
	}

	return samples_written;
}

/* Default file copy function, just return error if called */
static int file_default(struct comp_dev *dev, struct audio_stream *sink,
			struct audio_stream *source, uint32_t frames)
{
	return -EINVAL;
}

/* function for processing 32-bit samples */
static int file_s32(struct comp_dev *dev, struct audio_stream *sink,
		    struct audio_stream *source, uint32_t frames)
{
	struct dai_data *dd = comp_get_drvdata(dev);
	struct file_comp_data *cd = comp_get_drvdata(dd->dai);
	int nch;
	int n_samples = 0;

	switch (cd->fs.mode) {
	case FILE_READ:
		/* read samples */
		nch = audio_stream_get_channels(sink);
		n_samples = read_samples_s32(cd, sink, frames * nch, SOF_IPC_FRAME_S32_LE);
		break;
	case FILE_WRITE:
		/* write samples */
		nch = audio_stream_get_channels(source);
		n_samples = write_samples_s32(cd, source, frames * nch, SOF_IPC_FRAME_S32_LE);
		break;
	default:
		/* TODO: duplex mode */
		fprintf(stderr, "Error: Unknown file mode %d\n", cd->fs.mode);
		return -EINVAL;
	}

	/* update sample counter and check if we have a sample limit */
	cd->fs.n += n_samples;
	if (cd->max_samples && cd->fs.n >= cd->max_samples)
		cd->fs.reached_eof = 1;

	return n_samples;
}

/* function for processing 16-bit samples */
static int file_s16(struct comp_dev *dev, struct audio_stream *sink,
		    struct audio_stream *source, uint32_t frames)
{
	struct dai_data *dd = comp_get_drvdata(dev);
	struct file_comp_data *cd = comp_get_drvdata(dd->dai);
	int nch;
	int n_samples;

	switch (cd->fs.mode) {
	case FILE_READ:
		/* read samples */
		nch = audio_stream_get_channels(sink);
		n_samples = read_samples_s16(cd, sink, frames * nch);
		break;
	case FILE_WRITE:
		/* write samples */
		nch = audio_stream_get_channels(source);
		n_samples = write_samples_s16(cd, source, frames * nch);
		break;
	default:
		/* TODO: duplex mode */
		fprintf(stderr, "Error: Unknown file mode %d\n", cd->fs.mode);
		return -EINVAL;
	}

	/* update sample counter and check if we have a sample limit */
	cd->fs.n += n_samples;
	if (cd->max_samples && cd->fs.n >= cd->max_samples)
		cd->fs.reached_eof = 1;

	return n_samples;
}

/* function for processing 24-bit samples */
static int file_s24(struct comp_dev *dev, struct audio_stream *sink,
		    struct audio_stream *source, uint32_t frames)
{
	struct dai_data *dd = comp_get_drvdata(dev);
	struct file_comp_data *cd = comp_get_drvdata(dd->dai);
	int nch;
	int n_samples = 0;

	switch (cd->fs.mode) {
	case FILE_READ:
		/* read samples */
		nch = audio_stream_get_channels(sink);
		n_samples = read_samples_s32(cd, sink, frames * nch, SOF_IPC_FRAME_S24_4LE);
		break;
	case FILE_WRITE:
		/* write samples */
		nch = audio_stream_get_channels(source);
		n_samples = write_samples_s32(cd, source, frames * nch, SOF_IPC_FRAME_S24_4LE);
		break;
	default:
		/* TODO: duplex mode */
		fprintf(stderr, "Error: Unknown file mode %d\n", cd->fs.mode);
		return -EINVAL;
	}

	/* update sample counter and check if we have a sample limit */
	cd->fs.n += n_samples;
	if (cd->max_samples && cd->fs.n >= cd->max_samples)
		cd->fs.reached_eof = 1;

	return n_samples;
}

static enum file_format get_file_format(char *filename)
{
	char *ext = strrchr(filename, '.');

	if (!ext)
		return FILE_RAW;

	if (!strcmp(ext, ".txt"))
		return FILE_TEXT;

	return FILE_RAW;
}

static struct comp_dev *file_new(const struct comp_driver *drv,
				 const struct comp_ipc_config *config,
				 const void *spec)
{
	const struct dai_driver *fdrv;
	struct comp_dev *dev;
	const struct ipc_comp_file *ipc_file = spec;
	struct dai_data *dd;
	struct dai *fdai;
	struct file_comp_data *cd;

	debug_print("file_new()\n");

	dev = comp_alloc(drv, sizeof(*dev));
	if (!dev)
		return NULL;
	dev->ipc_config = *config;

	/* allocate  memory for file comp data */
	dd = rzalloc(SOF_MEM_ZONE_RUNTIME_SHARED, 0, SOF_MEM_CAPS_RAM, sizeof(*dd));
	if (!dd)
		goto error_skip_dd;

	fdai = rzalloc(SOF_MEM_ZONE_RUNTIME_SHARED, 0, SOF_MEM_CAPS_RAM, sizeof(*fdai));
	if (!fdai)
		goto error_skip_dai;

	fdrv = rzalloc(SOF_MEM_ZONE_RUNTIME_SHARED, 0, SOF_MEM_CAPS_RAM, sizeof(*fdrv));
	if (!fdrv)
		goto error_skip_drv;

	cd = rzalloc(SOF_MEM_ZONE_RUNTIME_SHARED, 0, SOF_MEM_CAPS_RAM, sizeof(*cd));
	if (!cd)
		goto error_skip_cd;

	fdai->drv = fdrv;
	dd->dai = fdai;
	comp_set_drvdata(dev, dd);
	comp_set_drvdata(dd->dai, cd);

	/* default function for processing samples */
	cd->file_func = file_default;

	/* get filename from IPC and open file */
	cd->fs.fn = strdup(ipc_file->fn);

	/* set file format */
	cd->fs.f_format = get_file_format(cd->fs.fn);

	/* set file comp mode */
	cd->fs.mode = ipc_file->mode;

	cd->rate = ipc_file->rate;
	cd->channels = ipc_file->channels;
	cd->frame_fmt = ipc_file->frame_fmt;
	dev->direction = ipc_file->direction;

	/* open file handle(s) depending on mode */
	switch (cd->fs.mode) {
	case FILE_READ:
		cd->fs.rfh = fopen(cd->fs.fn, "r");
		if (!cd->fs.rfh) {
			fprintf(stderr, "error: opening file %s for reading - %s\n",
				cd->fs.fn, strerror(errno));
			goto error;
		}
		break;
	case FILE_WRITE:
		cd->fs.wfh = fopen(cd->fs.fn, "w+");
		if (!cd->fs.wfh) {
			fprintf(stderr, "error: opening file %s for writing - %s\n",
				cd->fs.fn, strerror(errno));
			goto error;
		}
		break;
	default:
		/* TODO: duplex mode */
		fprintf(stderr, "Error: Unknown file mode %d\n", cd->fs.mode);
		goto error;
	}

	cd->fs.reached_eof = false;
	cd->fs.write_failed = false;
	cd->fs.n = 0;
	cd->fs.copy_count = 0;
	cd->fs.cycles_count = 0;
	dev->state = COMP_STATE_READY;
	return dev;

error:
	free(cd);

error_skip_cd:
	free((void *)fdrv);

error_skip_drv:
	free(fdai);

error_skip_dai:
	free(dd);

error_skip_dd:
	free(dev);
	return NULL;
}

static void file_free(struct comp_dev *dev)
{
	struct dai_data *dd = comp_get_drvdata(dev);
	struct file_comp_data *cd = comp_get_drvdata(dd->dai);

	comp_dbg(dev, "file_free()");

	if (cd->fs.mode == FILE_READ)
		fclose(cd->fs.rfh);
	else
		fclose(cd->fs.wfh);

	free(cd->fs.fn);
	free(cd);
	free((void *)dd->dai->drv);
	free(dd->dai);
	free(dd);
	free(dev);
}

static int file_verify_params(struct comp_dev *dev,
			      struct sof_ipc_stream_params *params)
{
	int ret;

	comp_dbg(dev, "file_verify_params()");

	ret = comp_verify_params(dev, 0, params);
	if (ret < 0) {
		comp_err(dev, "file_verify_params() error: comp_verify_params() failed.");
		return ret;
	}

	return 0;
}

/**
 * \brief Sets file component audio stream parameters.
 * \param[in,out] dev Volume base component device.
 * \param[in] params Audio (PCM) stream parameters (ignored for this component)
 * \return Error code.
 *
 * All done in prepare() since we need to know source and sink component params.
 */
static int file_params(struct comp_dev *dev,
		       struct sof_ipc_stream_params *params)
{
	struct comp_buffer *buffer;
	struct dai_data *dd = comp_get_drvdata(dev);
	struct file_comp_data *cd = comp_get_drvdata(dd->dai);
	struct audio_stream *stream;
	int periods;
	int samples;
	int ret;

	comp_info(dev, "file_params()");

	ret = file_verify_params(dev, params);
	if (ret < 0) {
		comp_err(dev, "file_params(): pcm params verification failed.");
		return ret;
	}

	/* file component sink/source buffer period count */
	switch (cd->fs.mode) {
	case FILE_READ:
		buffer = list_first_item(&dev->bsink_list, struct comp_buffer, source_list);
		periods = dev->ipc_config.periods_sink;
		break;
	case FILE_WRITE:
		buffer = list_first_item(&dev->bsource_list, struct comp_buffer, sink_list);
		periods = dev->ipc_config.periods_source;
		break;
	default:
		/* TODO: duplex mode */
		fprintf(stderr, "Error: Unknown file mode %d\n", cd->fs.mode);
		return -EINVAL;
	}

	/* set downstream buffer size */
	stream = &buffer->stream;
	samples = periods * dev->frames * audio_stream_get_channels(stream);
	switch (audio_stream_get_frm_fmt(stream)) {
	case SOF_IPC_FRAME_S16_LE:
		ret = buffer_set_size(buffer, samples * sizeof(int16_t), 0);
		if (ret < 0) {
			fprintf(stderr, "error: file buffer size set\n");
			return ret;
		}

		/* set file function */
		cd->file_func = file_s16;
		break;
	case SOF_IPC_FRAME_S24_4LE:
		ret = buffer_set_size(buffer, samples * sizeof(int32_t), 0);
		if (ret < 0) {
			fprintf(stderr, "error: file buffer size set\n");
			return ret;
		}

		/* set file function */
		cd->file_func = file_s24;
		break;
	case SOF_IPC_FRAME_S32_LE:
		ret = buffer_set_size(buffer, samples * sizeof(int32_t), 0);
		if (ret < 0) {
			fprintf(stderr, "error: file buffer size set\n");
			return ret;
		}

		/* set file function */
		cd->file_func = file_s32;
		break;
	default:
		fprintf(stderr, "Warning: Unknown file sample format %d\n",
			dev->ipc_config.frame_fmt);
		return -EINVAL;
	}

	cd->sample_container_bytes = audio_stream_sample_bytes(stream);
	buffer_reset_pos(buffer, NULL);

	return 0;
}

static int fr_cmd(struct comp_dev *dev, struct sof_ipc_ctrl_data *cdata)
{
	fprintf(stderr, "Warning: Set data is not implemented\n");
	return -EINVAL;
}

static int file_trigger(struct comp_dev *dev, int cmd)
{
	comp_info(dev, "file_trigger()");
	return comp_set_state(dev, cmd);
}

/* used to pass standard and bespoke commands (with data) to component */
static int file_cmd(struct comp_dev *dev, int cmd, void *data,
		    int max_data_size)
{
	struct sof_ipc_ctrl_data *cdata = ASSUME_ALIGNED(data, 4);
	int ret = 0;

	comp_info(dev, "file_cmd()");
	switch (cmd) {
	case COMP_CMD_SET_DATA:
		ret = fr_cmd(dev, cdata);
		break;
	default:
		fprintf(stderr, "Warning: Unknown file command %d\n", cmd);
		return -EINVAL;
	}

	return ret;
}

/*
 * copy and process stream samples
 * returns the number of bytes copied
 */
static int file_copy(struct comp_dev *dev)
{
	struct comp_buffer *buffer;
	struct dai_data *dd = comp_get_drvdata(dev);
	struct file_comp_data *cd = comp_get_drvdata(dd->dai);
	uint64_t cycles0, cycles1;
	int snk_frames;
	int src_frames;
	int bytes = cd->sample_container_bytes;
	int ret = 0;

	tb_getcycles(&cycles0);
	switch (cd->fs.mode) {
	case FILE_READ:
		/* file component sink buffer */
		buffer = list_first_item(&dev->bsink_list, struct comp_buffer,
					 source_list);

		/* test sink has enough free frames */
		snk_frames = MIN(audio_stream_get_free_frames(&buffer->stream), dev->frames);
		if (snk_frames > 0 && !cd->fs.reached_eof) {
			/* read PCM samples from file */
			ret = cd->file_func(dev, &buffer->stream, NULL,
					    snk_frames);

			/* update sink buffer pointers */
			if (ret > 0)
				comp_update_buffer_produce(buffer,
							   ret * bytes);
		}
		break;
	case FILE_WRITE:
		/* file component source buffer */
		buffer = list_first_item(&dev->bsource_list,
					 struct comp_buffer, sink_list);

		/* test source has enough free frames */
		src_frames = audio_stream_get_avail_frames(&buffer->stream);
		if (src_frames > 0) {
			/* write PCM samples into file */
			ret = cd->file_func(dev, NULL, &buffer->stream,
					    src_frames);

			/* update source buffer pointers */
			if (ret > 0)
				comp_update_buffer_consume(buffer,
							   ret * bytes);
		}
		break;
	default:
		/* TODO: duplex mode */
		ret = -EINVAL;
		break;
	}

	cd->fs.copy_count++;
	if (cd->fs.reached_eof || (cd->max_copies && cd->fs.copy_count >= cd->max_copies)) {
		cd->fs.reached_eof = 1;
		comp_info(dev, "file_copy(): copies %d max %d eof %d",
			  cd->fs.copy_count, cd->max_copies,
			  cd->fs.reached_eof);
		schedule_task_cancel(dev->pipeline->pipe_task);
	}

	tb_getcycles(&cycles1);
	cd->fs.cycles_count += cycles1 - cycles0;
	return ret;
}

static int file_prepare(struct comp_dev *dev)
{
	int ret = 0;

	comp_info(dev, "file_prepare()");

	ret = comp_set_state(dev, COMP_TRIGGER_PREPARE);
	if (ret < 0)
		return ret;

	if (ret == COMP_STATUS_STATE_ALREADY_SET)
		return PPL_STATUS_PATH_STOP;

	dev->state = COMP_STATE_PREPARE;
	return ret;
}

static int file_reset(struct comp_dev *dev)
{
	comp_info(dev, "file_reset()");
	comp_set_state(dev, COMP_TRIGGER_RESET);
	return 0;
}

static int file_get_hw_params(struct comp_dev *dev,
			      struct sof_ipc_stream_params *params, int dir)
{
	struct dai_data *dd = comp_get_drvdata(dev);
	struct file_comp_data *cd = comp_get_drvdata(dd->dai);

	comp_info(dev, "file_hw_params()");
	params->direction = dir;
	params->rate = cd->rate;
	params->channels = cd->channels;
	params->buffer_fmt = 0;
	params->frame_fmt = cd->frame_fmt;
	return 0;
}

static const struct comp_driver comp_file_host = {
	.type = SOF_COMP_HOST,
	.uid = SOF_RT_UUID(file_uuid),
	.tctx	= &file_tr,
	.ops = {
		.create = file_new,
		.free = file_free,
		.params = file_params,
		.cmd = file_cmd,
		.trigger = file_trigger,
		.copy = file_copy,
		.prepare = file_prepare,
		.reset = file_reset,
	},

};

static const struct comp_driver comp_file_dai = {
	.type = SOF_COMP_DAI,
	.uid = SOF_RT_UUID(file_uuid),
	.tctx	= &file_tr,
	.ops = {
		.create = file_new,
		.free = file_free,
		.params = file_params,
		.cmd = file_cmd,
		.trigger = file_trigger,
		.copy = file_copy,
		.prepare = file_prepare,
		.reset = file_reset,
		.dai_get_hw_params = file_get_hw_params,
	},
};

static struct comp_driver_info comp_file_host_info = {
	.drv = &comp_file_host,
};

static struct comp_driver_info comp_file_dai_info = {
	.drv = &comp_file_dai,
};

void sys_comp_file_init(void)
{
	comp_register(&comp_file_host_info);
	comp_register(&comp_file_dai_info);
}