This patch adds a new file component that testbench can use to read in samples and write out processed samples. Both text and raw pcm input formats are supported.
Signed-off-by: Ranjani Sridharan ranjani.sridharan@linux.intel.com --- tune/src/include/test/file.h | 77 ++++ tune/test/file.c | 723 +++++++++++++++++++++++++++++++++++ 2 files changed, 800 insertions(+) create mode 100644 tune/src/include/test/file.h create mode 100644 tune/test/file.c
diff --git a/tune/src/include/test/file.h b/tune/src/include/test/file.h new file mode 100644 index 0000000..777b26d --- /dev/null +++ b/tune/src/include/test/file.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2018, Intel Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the Intel Corporation nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * Author: Seppo Ingalsuo seppo.ingalsuo@linux.intel.com + * Liam Girdwood liam.r.girdwood@linux.intel.com + * Keyon Jie yang.jie@linux.intel.com + * Ranjani Sridharan ranjani.sridharan@linux.intel.com + */ +#ifndef _FILE_H +#define _FILE_H + +/* file component modes */ +enum file_mode { + FILE_READ = 0, + FILE_WRITE, + FILE_DUPLEX, +}; + +enum file_format { + FILE_TEXT = 0, + FILE_RAW, +}; + +/* file component state */ +struct file_state { + char *fn; + FILE *rfh, *wfh; /* read/write file handle */ + int reached_eof; + int n; + enum file_mode mode; + enum file_format f_format; +}; + +/* file comp data */ +struct file_comp_data { + uint32_t period_bytes; + uint32_t channels; + uint32_t frame_bytes; + uint32_t rate; + struct file_state fs; + int (*file_func)(struct comp_dev *dev, struct comp_buffer *sink, + struct comp_buffer *source, uint32_t frames); + +}; + +/* file IO ipc comp */ +struct sof_ipc_comp_file { + struct sof_ipc_comp comp; + struct sof_ipc_comp_config config; + char *fn; + enum file_mode mode; +}; +#endif diff --git a/tune/test/file.c b/tune/test/file.c new file mode 100644 index 0000000..6800a4c --- /dev/null +++ b/tune/test/file.c @@ -0,0 +1,723 @@ +/* + * Copyright (c) 2018, Intel Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the Intel Corporation nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * Author(s): Seppo Ingalsuo seppo.ingalsuo@linux.intel.com + * Ranjani Sridharan ranjani.sridharan@linux.intel.com + */ + +/* file component for reading/writing pcm samples to/from a file */ + +#include <stdio.h> +#include <stdint.h> +#include <stddef.h> +#include <errno.h> +#include <inttypes.h> +#include <sof/sof.h> +#include <sof/lock.h> +#include <sof/list.h> +#include <sof/stream.h> +#include <sof/work.h> +#include <sof/clock.h> +#include <sof/audio/component.h> +#include <sof/audio/format.h> +#include <sof/audio/pipeline.h> +#include <uapi/ipc.h> +#include "common_test.h" +#include "file.h" + +static inline void buffer_check_wrap_32(int32_t **ptr, int32_t *end, + size_t size) +{ + if (*ptr >= end) + *ptr = (int32_t *)((size_t)*ptr - size); +} + +static inline void buffer_check_wrap_16(int16_t **ptr, int16_t *end, + size_t size) +{ + if (*ptr >= end) + *ptr = (int16_t *)((size_t)*ptr - size); +} + +/* + * Read 32-bit samples from file + * currently only supports txt files + */ +static int read_samples_32(struct comp_dev *dev, struct comp_buffer *sink, + int n, int fmt, int nch) +{ + struct file_comp_data *cd = comp_get_drvdata(dev); + int32_t *dest = (int32_t *)sink->w_ptr; + int32_t sample; + int n_samples = 0; + int i, n_wrap, n_min, ret; + + while (n > 0) { + n_wrap = (int32_t *)sink->end_addr - dest; + + /* check for buffer wrap and copy to the end of the buffer */ + n_min = (n < n_wrap) ? n : n_wrap; + while (n_min > 0) { + n -= nch; + n_min -= nch; + + /* copy sample per channel */ + for (i = 0; i < nch; i++) { + /* read sample from file */ + switch (cd->fs.f_format) { + /* text input file */ + case FILE_TEXT: + if (fmt == SOF_IPC_FRAME_S32_LE) + ret = fscanf(cd->fs.rfh, "%d", + dest); + + /* mask bits if 24-bit samples */ + if (fmt == SOF_IPC_FRAME_S24_4LE) { + ret = fscanf(cd->fs.rfh, "%d", + &sample); + *dest = sample & 0x00ffffff; + } + /* quit if eof is reached */ + if (ret == EOF) { + cd->fs.reached_eof = 1; + goto quit; + } + break; + + /* raw input file */ + default: + if (fmt == SOF_IPC_FRAME_S32_LE) + ret = fread(dest, + sizeof(int32_t), + 1, cd->fs.rfh); + + /* mask bits if 24-bit samples */ + if (fmt == SOF_IPC_FRAME_S24_4LE) { + ret = fread(&sample, + sizeof(int32_t), + 1, cd->fs.rfh); + *dest = sample & 0x00ffffff; + } + /* quit if eof is reached */ + if (ret != 1) { + cd->fs.reached_eof = 1; + goto quit; + } + break; + } + dest++; + n_samples++; + } + } + /* check for buffer wrap and update pointer */ + buffer_check_wrap_32(&dest, sink->end_addr, + sink->size); + } +quit: + return n_samples; +} + +/* + * Read 16-bit samples from file + * currently only supports txt files + */ +static int read_samples_16(struct comp_dev *dev, struct comp_buffer *sink, + int n, int nch) +{ + struct file_comp_data *cd = comp_get_drvdata(dev); + int16_t *dest = (int16_t *)sink->w_ptr; + int i, n_wrap, n_min, ret; + int n_samples = 0; + + /* copy samples */ + while (n > 0) { + n_wrap = (int16_t *)sink->end_addr - dest; + + /* check for buffer wrap and copy to the end of the buffer */ + n_min = (n < n_wrap) ? n : n_wrap; + while (n_min > 0) { + n -= nch; + n_min -= nch; + + /* copy sample per channel */ + for (i = 0; i < nch; i++) { + /* read sample from file */ + ret = fscanf(cd->fs.rfh, "%hd", dest); + switch (cd->fs.f_format) { + /* text input file */ + case FILE_TEXT: + ret = fscanf(cd->fs.rfh, "%hd", dest); + if (ret == EOF) { + cd->fs.reached_eof = 1; + goto quit; + } + break; + + /* rw pcm input file */ + default: + ret = fread(dest, sizeof(int16_t), 1, + cd->fs.rfh); + if (ret != 1) { + cd->fs.reached_eof = 1; + goto quit; + } + break; + } + + dest++; + n_samples++; + } + } + /* check for buffer wrap and update pointer */ + buffer_check_wrap_16(&dest, sink->end_addr, + sink->size); + } + +quit: + return n_samples; +} + +/* + * Write 16-bit samples from file + * currently only supports txt files + */ +static int write_samples_16(struct comp_dev *dev, struct comp_buffer *source, + int n, int nch) +{ + struct file_comp_data *cd = comp_get_drvdata(dev); + int16_t *src = (int16_t *)source->r_ptr; + int i, n_wrap, n_min, ret; + int n_samples = 0; + + /* copy samples */ + while (n > 0) { + n_wrap = (int16_t *)source->end_addr - src; + + /* check for buffer wrap and copy to the end of the buffer */ + n_min = (n < n_wrap) ? n : n_wrap; + while (n_min > 0) { + n -= nch; + n_min -= nch; + + /* copy sample per channel */ + for (i = 0; i < nch; i++) { + switch (cd->fs.f_format) { + /* text output file */ + case FILE_TEXT: + ret = fprintf(cd->fs.wfh, + "%d\n", *src); + if (ret < 0) + goto quit; + break; + + /* raw pcm output file */ + default: + ret = fwrite(src, + sizeof(int16_t), + 1, cd->fs.wfh); + if (ret != 1) + goto quit; + break; + } + + src++; + n_samples++; + } + } + /* check for buffer wrap and update pointer */ + buffer_check_wrap_16(&src, source->end_addr, + source->size); + } +quit: + return n_samples; +} + +/* + * Write 32-bit samples from file + * currently only supports txt files + */ +static int write_samples_32(struct comp_dev *dev, struct comp_buffer *source, + int n, int fmt, int nch) +{ + struct file_comp_data *cd = comp_get_drvdata(dev); + int32_t *src = (int32_t *)source->r_ptr; + int i, n_wrap, n_min, ret; + int n_samples = 0; + int32_t sample; + + /* copy samples */ + while (n > 0) { + n_wrap = (int32_t *)source->end_addr - src; + + /* check for buffer wrap and copy to the end of the buffer */ + n_min = (n < n_wrap) ? n : n_wrap; + while (n_min > 0) { + n -= nch; + n_min -= nch; + + /* copy sample per channel */ + for (i = 0; i < nch; i++) { + switch (cd->fs.f_format) { + /* text output file */ + case FILE_TEXT: + if (fmt == SOF_IPC_FRAME_S32_LE) + ret = fprintf(cd->fs.wfh, + "%d\n", *src); + if (fmt == SOF_IPC_FRAME_S24_4LE) { + sample = *src << 8; + ret = fprintf(cd->fs.wfh, + "%d\n", + sample >> 8); + } + if (ret < 0) + goto quit; + break; + + /* raw pcm output file */ + default: + if (fmt == SOF_IPC_FRAME_S32_LE) + ret = fwrite(src, + sizeof(int32_t), + 1, cd->fs.wfh); + if (fmt == SOF_IPC_FRAME_S24_4LE) { + sample = *src << 8; + sample >>= 8; + ret = fwrite(&sample, + sizeof(int32_t), + 1, cd->fs.wfh); + } + if (ret != 1) + goto quit; + break; + } + + /* increment read pointer */ + src++; + + /* increment number of samples written */ + n_samples++; + } + } + /* check for buffer wrap and update pointer */ + buffer_check_wrap_32(&src, source->end_addr, + source->size); + } +quit: + return n_samples; +} + +/* function for processing 32-bit samples */ +static int file_s32_default(struct comp_dev *dev, struct comp_buffer *sink, + struct comp_buffer *source, uint32_t frames) +{ + struct file_comp_data *cd = comp_get_drvdata(dev); + int nch = dev->params.channels; + int n_samples = 0; + + switch (cd->fs.mode) { + case FILE_READ: + /* read samples */ + n_samples = read_samples_32(dev, sink, frames * nch, + SOF_IPC_FRAME_S32_LE, nch); + break; + case FILE_WRITE: + /* write samples */ + n_samples = write_samples_32(dev, source, frames * nch, + SOF_IPC_FRAME_S32_LE, nch); + break; + default: + /* TODO: duplex mode */ + break; + } + + cd->fs.n += n_samples; + return n_samples; +} + +/* function for processing 16-bit samples */ +static int file_s16(struct comp_dev *dev, struct comp_buffer *sink, + struct comp_buffer *source, uint32_t frames) +{ + struct file_comp_data *cd = comp_get_drvdata(dev); + int nch = dev->params.channels; + int n_samples = 0; + + switch (cd->fs.mode) { + case FILE_READ: + /* read samples */ + n_samples = read_samples_16(dev, sink, frames * nch, nch); + break; + case FILE_WRITE: + /* write samples */ + n_samples = write_samples_16(dev, source, frames * nch, nch); + break; + default: + /* TODO: duplex mode */ + break; + } + + cd->fs.n += n_samples; + return n_samples; +} + +/* function for processing 24-bit samples */ +static int file_s24(struct comp_dev *dev, struct comp_buffer *sink, + struct comp_buffer *source, uint32_t frames) +{ + struct file_comp_data *cd = comp_get_drvdata(dev); + int nch = dev->params.channels; + int n_samples = 0; + + switch (cd->fs.mode) { + case FILE_READ: + /* read samples */ + n_samples = read_samples_32(dev, sink, frames * nch, + SOF_IPC_FRAME_S24_4LE, nch); + break; + case FILE_WRITE: + /* write samples */ + n_samples = write_samples_32(dev, source, frames * nch, + SOF_IPC_FRAME_S24_4LE, nch); + break; + default: + /* TODO: duplex mode */ + break; + } + + cd->fs.n += n_samples; + return n_samples; +} + +static enum file_format get_file_format(char *filename) +{ + char *ext = strrchr(filename, '.'); + + if (!strcmp(ext, ".txt")) + return FILE_TEXT; + + return FILE_RAW; +} + +static struct comp_dev *file_new(struct sof_ipc_comp *comp) +{ + struct comp_dev *dev; + struct sof_ipc_comp_file *file; + struct sof_ipc_comp_file *ipc_file = + (struct sof_ipc_comp_file *)comp; + struct file_comp_data *cd; + + /* allocate memory for file comp */ + dev = malloc(COMP_SIZE(struct sof_ipc_comp_file)); + if (!dev) + return NULL; + + /* copy file comp config */ + file = (struct sof_ipc_comp_file *)&dev->comp; + memcpy(file, ipc_file, sizeof(struct sof_ipc_comp_file)); + + /* allocate memory for file comp data */ + cd = rzalloc(RZONE_RUNTIME, SOF_MEM_CAPS_RAM, sizeof(*cd)); + if (!cd) { + free(dev); + return NULL; + } + + comp_set_drvdata(dev, cd); + + /* default function for processing samples */ + cd->file_func = file_s32_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; + + /* 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\n", cd->fs.fn); + free(cd); + free(dev); + return NULL; + } + break; + case FILE_WRITE: + cd->fs.wfh = fopen(cd->fs.fn, "w"); + if (!cd->fs.wfh) { + fprintf(stderr, "error: opening file %s\n", cd->fs.fn); + free(cd); + free(dev); + return NULL; + } + break; + default: + /* TODO: duplex mode */ + break; + } + + cd->fs.reached_eof = 0; + cd->fs.n = 0; + + dev->state = COMP_STATE_READY; + + return dev; +} + +static void file_free(struct comp_dev *dev) +{ + struct file_comp_data *cd = comp_get_drvdata(dev); + + if (cd->fs.mode == FILE_READ) + fclose(cd->fs.rfh); + else + fclose(cd->fs.wfh); + + free(cd->fs.fn); + free(cd); + free(dev); + + debug_print("free file component\n"); +} + +/* set component audio stream parameters */ +static int file_params(struct comp_dev *dev) +{ + struct file_comp_data *cd = comp_get_drvdata(dev); + struct sof_ipc_comp_config *config = COMP_GET_CONFIG(dev); + + /* for file endpoint set the following from topology config */ + if (cd->fs.mode == FILE_WRITE) { + dev->params.frame_fmt = config->frame_fmt; + if (dev->params.frame_fmt == SOF_IPC_FRAME_S16_LE) + dev->params.sample_container_bytes = 2; + else + dev->params.sample_container_bytes = 4; + } + + /* Need to compute this in non-host endpoint */ + dev->frame_bytes = + dev->params.sample_container_bytes * dev->params.channels; + + /* calculate period size based on config */ + cd->period_bytes = dev->frames * dev->frame_bytes; + + /* File to sink supports only S32_LE/S16_LE/S24_4LE PCM formats */ + if (config->frame_fmt != SOF_IPC_FRAME_S32_LE && + config->frame_fmt != SOF_IPC_FRAME_S24_4LE && + config->frame_fmt != SOF_IPC_FRAME_S16_LE) + return -EINVAL; + + return 0; +} + +static int fr_cmd(struct comp_dev *dev, struct sof_ipc_ctrl_data *cdata) +{ + return -EINVAL; +} + +static int file_trigger(struct comp_dev *dev, int cmd) +{ + 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) +{ + struct sof_ipc_ctrl_data *cdata = data; + int ret = 0; + + switch (cmd) { + case COMP_CMD_SET_DATA: + ret = fr_cmd(dev, cdata); + break; + default: + break; + } + + 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 file_comp_data *cd = comp_get_drvdata(dev); + int ret = 0, bytes; + + 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 */ + if (buffer->free >= cd->period_bytes && !cd->fs.reached_eof) { + + /* read PCM samples from file */ + ret = cd->file_func(dev, buffer, NULL, dev->frames); + + /* update sink buffer pointers */ + bytes = dev->params.sample_container_bytes; + 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 */ + if (buffer->avail >= cd->period_bytes) { + + /* write PCM samples into file */ + ret = cd->file_func(dev, NULL, buffer, dev->frames); + + /* update source buffer pointers */ + bytes = dev->params.sample_container_bytes; + if (ret > 0) + comp_update_buffer_consume(buffer, + ret * bytes); + + } + break; + default: + /* TODO: duplex mode */ + break; + } + + return ret; +} + +static int file_prepare(struct comp_dev *dev) +{ + struct sof_ipc_comp_config *config = COMP_GET_CONFIG(dev); + struct comp_buffer *buffer = NULL; + struct file_comp_data *cd = comp_get_drvdata(dev); + int ret = 0, periods; + + /* 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 = config->periods_sink; + break; + case FILE_WRITE: + buffer = list_first_item(&dev->bsource_list, + struct comp_buffer, sink_list); + periods = config->periods_source; + break; + default: + /* TODO: duplex mode */ + break; + } + + if (!buffer) { + printf("error: no sink/source buffer\n"); + return -EINVAL; + } + + /* set downstream buffer size */ + switch (config->frame_fmt) { + case(SOF_IPC_FRAME_S16_LE): + ret = buffer_set_size(buffer, dev->frames * 2 * + periods * dev->params.channels); + if (ret < 0) { + printf("error: file buffer size set\n"); + return ret; + } + buffer_reset_pos(buffer); + + /* set file function */ + cd->file_func = file_s16; + break; + case(SOF_IPC_FRAME_S24_4LE): + ret = buffer_set_size(buffer, dev->frames * 4 * + periods * dev->params.channels); + if (ret < 0) { + fprintf(stderr, "error: file buffer size set\n"); + return ret; + } + buffer_reset_pos(buffer); + + /* set file function */ + cd->file_func = file_s24; + break; + case(SOF_IPC_FRAME_S32_LE): + ret = buffer_set_size(buffer, dev->frames * 4 * + periods * dev->params.channels); + if (ret < 0) { + fprintf(stderr, "error: file buffer size set\n"); + return ret; + } + buffer_reset_pos(buffer); + break; + default: + return -EINVAL; + } + + dev->state = COMP_STATE_PREPARE; + + return ret; +} + +static int file_reset(struct comp_dev *dev) +{ + dev->state = COMP_STATE_INIT; + + return 0; +} + +struct comp_driver comp_file = { + .type = SOF_COMP_FILEREAD, + .ops = { + .new = file_new, + .free = file_free, + .params = file_params, + .cmd = file_cmd, + .trigger = file_trigger, + .copy = file_copy, + .prepare = file_prepare, + .reset = file_reset, + }, +}; + +void sys_comp_file_init(void) +{ + comp_register(&comp_file); +}