diff --git a/src/audio/mixer/mixer.c b/src/audio/mixer/mixer.c index 26023bb6a570..8ac25956a9a5 100644 --- a/src/audio/mixer/mixer.c +++ b/src/audio/mixer/mixer.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -71,39 +72,36 @@ static int mixer_free(struct processing_module *mod) * Mix N source PCM streams to one sink PCM stream. Frames copied is constant. */ static int mixer_process(struct processing_module *mod, - struct input_stream_buffer *input_buffers, int num_input_buffers, - struct output_stream_buffer *output_buffers, int num_output_buffers) + struct sof_source **sources, int num_of_sources, + struct sof_sink **sinks, int num_of_sinks) { struct mixer_data *md = module_get_private_data(mod); struct comp_dev *dev = mod->dev; - const struct audio_stream *sources_stream[PLATFORM_MAX_STREAMS]; - int sources_indices[PLATFORM_MAX_STREAMS]; - int32_t i = 0, j = 0; - uint32_t frames = INT32_MAX; - /* Redundant, but helps the compiler */ - uint32_t source_bytes = 0; - uint32_t sink_bytes; + struct sof_source *active_sources[PLATFORM_MAX_STREAMS]; + struct cir_buf_source source_bufs[PLATFORM_MAX_STREAMS]; + struct cir_buf_sink sink_buf; + size_t bytes, samples, source_bytes, sink_bytes; + size_t frames = SIZE_MAX; int active_input_buffers = 0; + int i, j, ret; - comp_dbg(dev, "%d", num_input_buffers); + comp_dbg(dev, "%d", num_of_sources); /* too many sources ? */ - if (num_input_buffers >= PLATFORM_MAX_STREAMS) + if (num_of_sources >= PLATFORM_MAX_STREAMS) return -EINVAL; - /* check for underruns */ - for (i = 0; i < num_input_buffers; i++) { - uint32_t avail_frames; - - avail_frames = audio_stream_avail_frames_aligned(mod->input_buffers[i].data, - mod->output_buffers[0].data); + /* find active sources and compute frame count */ + for (i = 0; i < num_of_sources; i++) { + size_t avail_frames = source_sink_avail_frames_aligned(sources[i], sinks[0]); /* if one source is inactive, skip it */ if (avail_frames == 0) continue; - active_input_buffers++; frames = MIN(frames, avail_frames); + active_sources[active_input_buffers] = sources[i]; + active_input_buffers++; } if (!active_input_buffers) { @@ -113,43 +111,43 @@ static int mixer_process(struct processing_module *mod, * generating silence until at least one of the * sources start to have data available (frames!=0). */ - sink_bytes = dev->frames * audio_stream_frame_bytes(mod->output_buffers[0].data); - if (!audio_stream_set_zero(mod->output_buffers[0].data, sink_bytes)) - mod->output_buffers[0].size = sink_bytes; - - return 0; + return sink_fill_with_silence(sinks[0], + dev->frames * sink_get_frame_bytes(sinks[0])); } - /* Every source has the same format, so calculate bytes based on the first one */ - source_bytes = frames * audio_stream_frame_bytes(mod->input_buffers[0].data); + comp_dbg(dev, "frames = %zu", frames); - sink_bytes = frames * audio_stream_frame_bytes(mod->output_buffers[0].data); + sink_bytes = frames * sink_get_frame_bytes(sinks[0]); + samples = frames * sink_get_channels(sinks[0]); - comp_dbg(dev, "source_bytes = 0x%x, sink_bytes = 0x%x", - source_bytes, sink_bytes); - - /* mix streams */ - for (i = 0; i < num_input_buffers; i++) { - uint32_t avail_frames; - - avail_frames = audio_stream_avail_frames_aligned(mod->input_buffers[i].data, - mod->output_buffers[0].data); - - /* if one source is inactive, skip it */ - if (avail_frames == 0) - continue; + /* acquire the sink buffer */ + ret = sink_get_buffer(sinks[0], sink_bytes, &sink_buf.ptr, &sink_buf.buf_start, &bytes); + if (ret < 0) + return ret; + sink_buf.buf_end = (char *)sink_buf.buf_start + bytes; - sources_indices[j] = i; - sources_stream[j++] = mod->input_buffers[i].data; + /* Every source has the same format, so calculate bytes based on the first one */ + source_bytes = frames * source_get_frame_bytes(active_sources[0]); + + /* acquire all active source buffers */ + for (i = 0; i < active_input_buffers; i++) { + ret = source_get_data(active_sources[i], source_bytes, &source_bufs[i].ptr, + &source_bufs[i].buf_start, &bytes); + if (ret < 0) { + for (j = 0; j < i; j++) + source_release_data(active_sources[j], 0); + sink_commit_buffer(sinks[0], 0); + return ret; + } + source_bufs[i].buf_end = (const char *)source_bufs[i].buf_start + bytes; } - if (j) - md->mix_func(dev, mod->output_buffers[0].data, sources_stream, j, frames); - mod->output_buffers[0].size = sink_bytes; + md->mix_func(&sink_buf, source_bufs, active_input_buffers, samples); - /* update source buffer consumed bytes */ - for (i = 0; i < j; i++) - mod->input_buffers[sources_indices[i]].consumed = source_bytes; + /* commit the consumed and produced data */ + for (i = 0; i < active_input_buffers; i++) + source_release_data(active_sources[i], source_bytes); + sink_commit_buffer(sinks[0], sink_bytes); return 0; } @@ -163,13 +161,13 @@ static int mixer_reset(struct processing_module *mod) comp_dbg(dev, "entry"); if (dir == SOF_IPC_STREAM_PLAYBACK) { - struct comp_buffer *source; + int i; - comp_dev_for_each_producer(dev, source) { + for (i = 0; i < mod->num_of_sources; i++) { /* FIXME: this is racy and implicitly protected by serialised IPCs */ bool stop = false; - if (comp_buffer_get_source_state(source) > COMP_STATE_READY) + if (source_get_comp_state(mod->sources[i]) > COMP_STATE_READY) stop = true; /* only mix the sources with the same state with mixer */ @@ -185,46 +183,60 @@ static int mixer_reset(struct processing_module *mod) } /* init and calculate the aligned setting for available frames and free frames retrieve*/ -static inline void mixer_set_frame_alignment(struct audio_stream *source) +#if XCHAL_HAVE_HIFI3 || XCHAL_HAVE_HIFI4 +static inline uint32_t mixer_get_byte_align(uint32_t channels) { - /* Xtensa intrinsics ask for 8-byte aligned. 5.1 format SSE audio - * requires 16-byte aligned. Note: The SOF_FRAME_BYTE_ALIGN is the - * same value 16 with HiFi5. + * requires 16-byte aligned. */ - const uint32_t byte_align = audio_stream_get_channels(source) == 6 ? - MIXER_HIFI_FRAME_BYTE_ALIGN_6CH : SOF_FRAME_BYTE_ALIGN; + return channels == 6 ? 16 : 8; +} - /* There is no limit for frame number, so set it as default (1). */ - const uint32_t frame_align_req = SOF_FRAME_COUNT_ALIGN; +static void mixer_set_source_frame_alignment(struct sof_source *src) +{ + const uint32_t byte_align = mixer_get_byte_align(source_get_channels(src)); + + /*There is no limit for frame number, so set it as 1*/ + const uint32_t frame_align_req = 1; - audio_stream_set_align(byte_align, frame_align_req, source); + source_set_alignment_constants(src, byte_align, frame_align_req); } +static void mixer_set_sink_frame_alignment(struct sof_sink *snk) +{ + const uint32_t byte_align = mixer_get_byte_align(source_get_channels(snk)); + + /*There is no limit for frame number, so set it as 1*/ + const uint32_t frame_align_req = 1; + + sink_set_alignment_constants(snk, byte_align, frame_align_req); +} +#endif + static int mixer_prepare(struct processing_module *mod, struct sof_source **sources, int num_of_sources, struct sof_sink **sinks, int num_of_sinks) { struct mixer_data *md = module_get_private_data(mod); struct comp_dev *dev = mod->dev; - struct comp_buffer *sink; + int i; - sink = comp_dev_get_first_data_consumer(dev); - if (!sink) { + if (!num_of_sinks) { comp_err(dev, "no sink"); return -ENOTCONN; } - md->mix_func = mixer_get_processing_function(dev, sink); +#if XCHAL_HAVE_HIFI3 || XCHAL_HAVE_HIFI4 + mixer_set_sink_frame_alignment(sinks[0]); + for (i = 0; i < num_of_sources; i++) + mixer_set_source_frame_alignment(sources[i]); +#endif - /* No need to set sink align constraints, set constraints for each - * source next. The sink align will follow to common source alignment. - */ + md->mix_func = mixer_get_processing_function(dev, sink_get_frm_fmt(sinks[0])); /* check each mixer source state */ - struct comp_buffer *source; - - comp_dev_for_each_producer(dev, source) { + for (i = 0; i < num_of_sources; i++) { + int state = source_get_comp_state(sources[i]); bool stop; /* @@ -235,9 +247,7 @@ static int mixer_prepare(struct processing_module *mod, * preparing the mixer, so they shouldn't touch it until we're * done. */ - mixer_set_frame_alignment(&source->stream); - stop = comp_buffer_get_source_state(source) == COMP_STATE_PAUSED || - comp_buffer_get_source_state(source) == COMP_STATE_ACTIVE; + stop = state == COMP_STATE_PAUSED || state == COMP_STATE_ACTIVE; /* only prepare downstream if we have no active sources */ if (stop) @@ -251,7 +261,7 @@ static int mixer_prepare(struct processing_module *mod, static const struct module_interface mixer_interface = { .init = mixer_init, .prepare = mixer_prepare, - .process_audio_stream = mixer_process, + .process = mixer_process, .reset = mixer_reset, .free = mixer_free, }; diff --git a/src/audio/mixer/mixer.h b/src/audio/mixer/mixer.h index 875ddcbb26fe..6503da4787f4 100644 --- a/src/audio/mixer/mixer.h +++ b/src/audio/mixer/mixer.h @@ -32,23 +32,26 @@ void sys_comp_module_mixer_interface_init(void); #define MIXER_MAX_SOURCES 2 -/* Xtensa HiFi optimized version needs this for 5.1ch */ -#define MIXER_HIFI_FRAME_BYTE_ALIGN_6CH 16 +/** + * \brief mixer processing function interface + * + * The buffers are acquired and committed by the module's process callback. Each + * processing function receives ready-to-use circular buffer descriptors and only + * performs the mixing. + * + * \param[in,out] sink Sink circular buffer descriptor to write mixed data to. + * \param[in] sources Array of source circular buffer descriptors to mix. + * \param[in] num_sources Number of valid entries in \p sources. + * \param[in] samples Total number of samples (frames * channels) to mix. + */ +typedef void (*mixer_func)(struct cir_buf_sink *sink, struct cir_buf_source *sources, + int num_sources, size_t samples); /* mixer component private data */ struct mixer_data { - void (*mix_func)(struct comp_dev *dev, struct audio_stream *sink, - const struct audio_stream **sources, uint32_t count, - uint32_t frames); + mixer_func mix_func; }; -/** - * \brief mixer processing function interface - */ -typedef void (*mixer_func)(struct comp_dev *dev, struct audio_stream *sink, - const struct audio_stream **sources, uint32_t num_sources, - uint32_t frames); - /** \brief Volume processing functions map. */ struct mixer_func_map { enum sof_ipc_frame frame_fmt; /**< frame format */ @@ -64,16 +67,16 @@ extern const size_t mixer_func_count; /** * \brief Retrievies mixer processing function. * \param[in,out] dev Mixer base component device. - * \param[in] sinkb Sink buffer to match against + * \param[in] fmt Frame format to match against. */ static inline mixer_func mixer_get_processing_function(struct comp_dev *dev, - struct comp_buffer *sinkb) + enum sof_ipc_frame fmt) { int i; /* map the volume function for source and sink buffers */ for (i = 0; i < mixer_func_count; i++) { - if (audio_stream_get_frm_fmt(&sinkb->stream) != mixer_func_map[i].frame_fmt) + if (fmt != mixer_func_map[i].frame_fmt) continue; return mixer_func_map[i].func; diff --git a/src/audio/mixer/mixer_generic.c b/src/audio/mixer/mixer_generic.c index 2b1b50501187..bed337fe7a3f 100644 --- a/src/audio/mixer/mixer_generic.c +++ b/src/audio/mixer/mixer_generic.c @@ -12,29 +12,25 @@ #if CONFIG_FORMAT_S16LE /* Mix n 16 bit PCM source streams to one sink stream */ -static void mix_n_s16(struct comp_dev *dev, struct audio_stream *sink, - const struct audio_stream **sources, uint32_t num_sources, - uint32_t frames) +static void mix_n_s16(struct cir_buf_sink *sink, struct cir_buf_source *sources, + int num_sources, size_t samples) { - int16_t *src[PLATFORM_MAX_CHANNELS]; - int16_t *dest; + const int16_t *src[PLATFORM_MAX_CHANNELS]; + int16_t *dest = sink->ptr; int32_t val; - int nmax; - int i, j, n, ns; - int processed = 0; - int nch = audio_stream_get_channels(sink); - int samples = frames * nch; + size_t nmax, ns, n; + int i, j; + size_t processed = 0; - dest = audio_stream_get_wptr(sink); for (j = 0; j < num_sources; j++) - src[j] = audio_stream_get_rptr(sources[j]); + src[j] = sources[j].ptr; while (processed < samples) { nmax = samples - processed; - n = audio_stream_samples_without_wrap_s16(sink, dest); + n = cir_buf_samples_without_wrap_s16(dest, sink->buf_end); n = MIN(n, nmax); for (i = 0; i < num_sources; i++) { - ns = audio_stream_samples_without_wrap_s16(sources[i], src[i]); + ns = cir_buf_samples_without_wrap_s16(src[i], sources[i].buf_end); n = MIN(n, ns); } for (i = 0; i < n; i++) { @@ -49,39 +45,36 @@ static void mix_n_s16(struct comp_dev *dev, struct audio_stream *sink, dest++; } processed += n; - dest = audio_stream_wrap(sink, dest); + dest = cir_buf_wrap(dest, sink->buf_start, sink->buf_end); for (i = 0; i < num_sources; i++) - src[i] = audio_stream_wrap(sources[i], src[i]); + src[i] = source_cir_buf_wrap(src[i], sources[i].buf_start, + sources[i].buf_end); } } #endif /* CONFIG_FORMAT_S16LE */ #if CONFIG_FORMAT_S24LE /* Mix n 24 bit PCM source streams to one sink stream */ -static void mix_n_s24(struct comp_dev *dev, struct audio_stream *sink, - const struct audio_stream **sources, uint32_t num_sources, - uint32_t frames) +static void mix_n_s24(struct cir_buf_sink *sink, struct cir_buf_source *sources, + int num_sources, size_t samples) { - int32_t *src[PLATFORM_MAX_CHANNELS]; - int32_t *dest; + const int32_t *src[PLATFORM_MAX_CHANNELS]; + int32_t *dest = sink->ptr; int32_t val; int32_t x; - int nmax; - int i, j, n, ns; - int processed = 0; - int nch = audio_stream_get_channels(sink); - int samples = frames * nch; + size_t nmax, ns, n; + int i, j; + size_t processed = 0; - dest = audio_stream_get_wptr(sink); for (j = 0; j < num_sources; j++) - src[j] = audio_stream_get_rptr(sources[j]); + src[j] = sources[j].ptr; while (processed < samples) { nmax = samples - processed; - n = audio_stream_samples_without_wrap_s24(sink, dest); + n = cir_buf_samples_without_wrap_s32(dest, sink->buf_end); n = MIN(n, nmax); for (i = 0; i < num_sources; i++) { - ns = audio_stream_samples_without_wrap_s24(sources[i], src[i]); + ns = cir_buf_samples_without_wrap_s32(src[i], sources[i].buf_end); n = MIN(n, ns); } for (i = 0; i < n; i++) { @@ -97,38 +90,35 @@ static void mix_n_s24(struct comp_dev *dev, struct audio_stream *sink, dest++; } processed += n; - dest = audio_stream_wrap(sink, dest); + dest = cir_buf_wrap(dest, sink->buf_start, sink->buf_end); for (i = 0; i < num_sources; i++) - src[i] = audio_stream_wrap(sources[i], src[i]); + src[i] = source_cir_buf_wrap(src[i], sources[i].buf_start, + sources[i].buf_end); } } #endif /* CONFIG_FORMAT_S24LE */ #if CONFIG_FORMAT_S32LE /* Mix n 32 bit PCM source streams to one sink stream */ -static void mix_n_s32(struct comp_dev *dev, struct audio_stream *sink, - const struct audio_stream **sources, uint32_t num_sources, - uint32_t frames) +static void mix_n_s32(struct cir_buf_sink *sink, struct cir_buf_source *sources, + int num_sources, size_t samples) { - int32_t *src[PLATFORM_MAX_CHANNELS]; - int32_t *dest; + const int32_t *src[PLATFORM_MAX_CHANNELS]; + int32_t *dest = sink->ptr; int64_t val; - int nmax; - int i, j, n, ns; - int processed = 0; - int nch = audio_stream_get_channels(sink); - int samples = frames * nch; + size_t nmax, ns, n; + int i, j; + size_t processed = 0; - dest = audio_stream_get_wptr(sink); for (j = 0; j < num_sources; j++) - src[j] = audio_stream_get_rptr(sources[j]); + src[j] = sources[j].ptr; while (processed < samples) { nmax = samples - processed; - n = audio_stream_samples_without_wrap_s32(sink, dest); + n = cir_buf_samples_without_wrap_s32(dest, sink->buf_end); n = MIN(n, nmax); for (i = 0; i < num_sources; i++) { - ns = audio_stream_samples_without_wrap_s32(sources[i], src[i]); + ns = cir_buf_samples_without_wrap_s32(src[i], sources[i].buf_end); n = MIN(n, ns); } for (i = 0; i < n; i++) { @@ -143,9 +133,10 @@ static void mix_n_s32(struct comp_dev *dev, struct audio_stream *sink, dest++; } processed += n; - dest = audio_stream_wrap(sink, dest); + dest = cir_buf_wrap(dest, sink->buf_start, sink->buf_end); for (i = 0; i < num_sources; i++) - src[i] = audio_stream_wrap(sources[i], src[i]); + src[i] = source_cir_buf_wrap(src[i], sources[i].buf_start, + sources[i].buf_end); } } #endif /* CONFIG_FORMAT_S32LE */ diff --git a/src/audio/mixer/mixer_hifi3.c b/src/audio/mixer/mixer_hifi3.c index 0d774208655e..ff09047dddd2 100644 --- a/src/audio/mixer/mixer_hifi3.c +++ b/src/audio/mixer/mixer_hifi3.c @@ -14,31 +14,30 @@ #if CONFIG_FORMAT_S16LE /* Mix n 16 bit PCM source streams to one sink stream */ -static void mix_n_s16(struct comp_dev *dev, struct audio_stream *sink, - const struct audio_stream **sources, uint32_t num_sources, - uint32_t frames) +static void mix_n_s16(struct cir_buf_sink *sink, struct cir_buf_source *sources, + int num_sources, size_t samples) { - ae_int16x4 * in[PLATFORM_MAX_CHANNELS]; - ae_int16x4 *out = audio_stream_get_wptr(sink); + const ae_int16x4 *in[PLATFORM_MAX_CHANNELS]; + ae_int16x4 *out = (ae_int16x4 *)sink->ptr; ae_int16x4 sample = AE_ZERO16(); ae_int16x4 res = AE_ZERO16(); ae_int32x2 val1; ae_int32x2 val2; ae_int32x2 sample_1; ae_int32x2 sample_2; - unsigned int n, m, nmax, i, j, left_samples; - unsigned int samples = frames * audio_stream_get_channels(sink); + size_t n, m, nmax; + size_t i; + int j; + size_t left_samples; for (j = 0; j < num_sources; j++) - in[j] = audio_stream_get_rptr(sources[j]); + in[j] = (const ae_int16x4 *)sources[j].ptr; for (left_samples = samples; left_samples; left_samples -= n) { - out = audio_stream_wrap(sink, out); - nmax = audio_stream_samples_without_wrap_s16(sink, out); + nmax = cir_buf_samples_without_wrap_s16(out, sink->buf_end); n = MIN(left_samples, nmax); for (j = 0; j < num_sources; j++) { - in[j] = audio_stream_wrap(sources[j], in[j]); - nmax = audio_stream_samples_without_wrap_s16(sources[j], in[j]); + nmax = cir_buf_samples_without_wrap_s16(in[j], sources[j].buf_end); n = MIN(n, nmax); } m = n >> 2; @@ -64,33 +63,37 @@ static void mix_n_s16(struct comp_dev *dev, struct audio_stream *sink, /* store four 16 bit samples, 8 is sizeof(ae_int16x4) */ AE_S16X4_IP(res, out, 8); } + out = (ae_int16x4 *)cir_buf_wrap(out, sink->buf_start, sink->buf_end); + for (j = 0; j < num_sources; j++) + in[j] = (const ae_int16x4 *)source_cir_buf_wrap(in[j], + sources[j].buf_start, + sources[j].buf_end); } } #endif /* CONFIG_FORMAT_S16LE */ #if CONFIG_FORMAT_S24LE /* Mix n 24 bit PCM source streams to one sink stream */ -static void mix_n_s24(struct comp_dev *dev, struct audio_stream *sink, - const struct audio_stream **sources, uint32_t num_sources, - uint32_t frames) +static void mix_n_s24(struct cir_buf_sink *sink, struct cir_buf_source *sources, + int num_sources, size_t samples) { - ae_int32x2 *in[PLATFORM_MAX_CHANNELS]; - ae_int32x2 *out = audio_stream_get_wptr(sink); + const ae_int32x2 *in[PLATFORM_MAX_CHANNELS]; + ae_int32x2 *out = (ae_int32x2 *)sink->ptr; ae_int32x2 val; ae_int32x2 sample = AE_ZERO32(); - unsigned int n, m, nmax, i, j, left_samples; - unsigned int samples = frames * audio_stream_get_channels(sink); + size_t n, m, nmax; + size_t i; + int j; + size_t left_samples; for (j = 0; j < num_sources; j++) - in[j] = audio_stream_get_rptr(sources[j]); + in[j] = (const ae_int32x2 *)sources[j].ptr; for (left_samples = samples; left_samples; left_samples -= n) { - out = audio_stream_wrap(sink, out); - nmax = audio_stream_samples_without_wrap_s32(sink, out); + nmax = cir_buf_samples_without_wrap_s32(out, sink->buf_end); n = MIN(left_samples, nmax); for (j = 0; j < num_sources; j++) { - in[j] = audio_stream_wrap(sources[j], in[j]); - nmax = audio_stream_samples_without_wrap_s32(sources[j], in[j]); + nmax = cir_buf_samples_without_wrap_s32(in[j], sources[j].buf_end); n = MIN(n, nmax); } m = n >> 1; @@ -109,48 +112,56 @@ static void mix_n_s24(struct comp_dev *dev, struct audio_stream *sink, /* store two 32 bit samples, 8 is sizeof(ae_int32x2) */ AE_S32X2_IP(val, out, 8); } + out = (ae_int32x2 *)cir_buf_wrap(out, sink->buf_start, sink->buf_end); + for (j = 0; j < num_sources; j++) + in[j] = (const ae_int32x2 *)source_cir_buf_wrap(in[j], + sources[j].buf_start, + sources[j].buf_end); } } #endif /* CONFIG_FORMAT_S24LE */ #if CONFIG_FORMAT_S32LE /* Mix n 32 bit PCM source streams to one sink stream */ -static void mix_n_s32(struct comp_dev *dev, struct audio_stream *sink, - const struct audio_stream **sources, uint32_t num_sources, - uint32_t frames) +static void mix_n_s32(struct cir_buf_sink *sink, struct cir_buf_source *sources, + int num_sources, size_t samples) { - ae_q32s * in[PLATFORM_MAX_CHANNELS]; - ae_int32 *out = audio_stream_get_wptr(sink); + const ae_q32s *in[PLATFORM_MAX_CHANNELS]; + ae_int32 *out = (ae_int32 *)sink->ptr; ae_int64 sample; ae_int64 val; ae_int32x2 res; - unsigned int n, nmax, i, j, left_samples; - unsigned int m = 0; - unsigned int samples = frames * audio_stream_get_channels(sink); + size_t n, nmax; + size_t i; + int j; + size_t m = 0; + size_t left_samples; for (j = 0; j < num_sources; j++) - in[j] = audio_stream_get_rptr(sources[j]); + in[j] = (const ae_q32s *)sources[j].ptr; for (left_samples = samples; left_samples; left_samples -= n) { - out = audio_stream_wrap(sink, out); - nmax = audio_stream_samples_without_wrap_s32(sink, out); + out = (ae_int32 *)cir_buf_wrap(out, sink->buf_start, sink->buf_end); + nmax = cir_buf_samples_without_wrap_s32(out, sink->buf_end); n = MIN(left_samples, nmax); for (j = 0; j < num_sources; j++) { - in[j] = audio_stream_wrap(sources[j], in[j] + m); - nmax = audio_stream_samples_without_wrap_s32(sources[j], in[j]); + in[j] = (const ae_q32s *)source_cir_buf_wrap((const int32_t *)in[j] + m, + sources[j].buf_start, + sources[j].buf_end); + nmax = cir_buf_samples_without_wrap_s32(in[j], sources[j].buf_end); n = MIN(n, nmax); } /*record the processed samples for next address iteration */ m = n; for (i = 0; i < m; i++) { - val = AE_ZERO64(); + val = AE_ZERO64(); for (j = 0; j < num_sources; j++) { /* load one 32 bit sample */ sample = AE_L32M_X(in[j], i * sizeof(ae_q32s)); val = AE_ADD64S(val, sample); } /*Saturate to 32 bits */ - res = AE_ROUND32X2F48SSYM(val, val); + res = AE_ROUND32X2F48SSYM(val, val); /* store one 32 bit samples */ AE_S32_L_IP(res, out, sizeof(ae_int32)); diff --git a/test/cmocka/src/audio/mixer/mixer_test.c b/test/cmocka/src/audio/mixer/mixer_test.c index bf6a7ad6b48d..064997946bab 100644 --- a/test/cmocka/src/audio/mixer/mixer_test.c +++ b/test/cmocka/src/audio/mixer/mixer_test.c @@ -83,7 +83,8 @@ static int test_setup(void **state) md = test_malloc(sizeof(*md)); mod_data->private = md; - md->mix_func = mixer_get_processing_function(test_data->mod->dev, test_data->sinks[0]); + md->mix_func = mixer_get_processing_function(test_data->mod->dev, + audio_stream_get_frm_fmt(&test_data->sinks[0]->stream)); *state = test_data; @@ -109,7 +110,8 @@ static void test_audio_mixer_copy(void **state) struct processing_module_test_data *tc = *state; struct processing_module *mod = tc->mod; struct mixer_data *md = module_get_private_data(tc->mod); - const struct audio_stream *sources_stream[PLATFORM_MAX_STREAMS]; + struct cir_buf_source sources_buf[PLATFORM_MAX_STREAMS]; + struct cir_buf_sink sink_buf; for (src_idx = 0; src_idx < tc->num_sources; ++src_idx) { uint32_t *samples = tc->sources[src_idx]->stream.addr; @@ -123,11 +125,20 @@ static void test_audio_mixer_copy(void **state) audio_stream_produce(&tc->sources[src_idx]->stream, tc->sources[src_idx]->stream.size / sizeof(int32_t)); - sources_stream[src_idx] = &tc->sources[src_idx]->stream; + sources_buf[src_idx].buf_start = + audio_stream_get_addr(&tc->sources[src_idx]->stream); + sources_buf[src_idx].buf_end = + audio_stream_get_end_addr(&tc->sources[src_idx]->stream); + sources_buf[src_idx].ptr = + audio_stream_get_rptr(&tc->sources[src_idx]->stream); } - md->mix_func(mod->dev, &tc->sinks[0]->stream, sources_stream, tc->num_sources, - mod->dev->frames); + sink_buf.buf_start = audio_stream_get_addr(&tc->sinks[0]->stream); + sink_buf.buf_end = audio_stream_get_end_addr(&tc->sinks[0]->stream); + sink_buf.ptr = audio_stream_get_wptr(&tc->sinks[0]->stream); + + md->mix_func(&sink_buf, sources_buf, tc->num_sources, + mod->dev->frames * tc->parameters.channels); for (smp = 0; smp < tc->sinks[0]->stream.size / sizeof(int32_t); ++smp) { uint64_t sum = 0;