audio: pcm_converter: change pcm conversion function interface

Rework the pcm conversion and dma copy paths to operate on circular buffer
source and sink descriptors instead of the legacy audio stream buffers.

Signed-off-by: Adrian Warecki <adrian.warecki@intel.com>

Author: softwarecki

posix/include/sof/lib/dma.h

@@ -265,10 +265,11 @@ struct dma_info {
 	size_t num_dmas;
 };
 
-struct audio_stream;
-typedef int (*dma_process_func)(const struct audio_stream __sparse_cache *source,
-				uint32_t ioffset, struct audio_stream __sparse_cache *sink,
-				uint32_t ooffset, uint32_t source_samples, uint32_t chmap);
+struct cir_buf_source;
+struct cir_buf_sink;
+typedef int (*dma_process_func)(const struct cir_buf_source *source,
+				uint32_t src_channels, struct cir_buf_sink *sink,
+				uint32_t sink_channels, uint32_t source_samples, uint32_t chmap);
 
 /**
  * \brief API to initialize a platform DMA controllers.

src/audio/copier/copier.c

@@ -619,8 +619,22 @@ static int copier_module_copy(struct processing_module *mod,
 		sink_dev = comp_buffer_get_sink_component(sink_c);
 		processed_data.sink_bytes = 0;
 		if (sink_dev->state == COMP_STATE_ACTIVE) {
+			/* Bridge the legacy audio_stream buffers into cir_buf descriptors for
+			 * the new pcm_converter interface (read/write pointers = offset 0).
+			 */
+			struct cir_buf_source src_cir = {
+				.buf_start = audio_stream_get_addr(input_buffers[0].data),
+				.buf_end = audio_stream_get_end_addr(input_buffers[0].data),
+				.ptr = audio_stream_get_rptr(input_buffers[0].data),
+			};
+			struct cir_buf_sink snk_cir = {
+				.buf_start = audio_stream_get_addr(output_buffers[i].data),
+				.buf_end = audio_stream_get_end_addr(output_buffers[i].data),
+				.ptr = audio_stream_get_wptr(output_buffers[i].data),
+			};
 			uint32_t source_samples;
 			int sink_queue_id;
+			pcm_converter_func converter;
 
 			/*
 			 * Buffer ID is constructed as IPC4_COMP_ID(src_queue, dst_queue).
@@ -630,14 +644,15 @@ static int copier_module_copy(struct processing_module *mod,
 			sink_queue_id = IPC4_SRC_QUEUE_ID(buf_get_id(sink_c));
 			if (sink_queue_id >= IPC4_COPIER_MODULE_OUTPUT_PINS_COUNT)
 				return -EINVAL;
+			converter = cd->converter[sink_queue_id];
 
 			comp_get_copy_limits(src_c, sink_c, &processed_data);
 
 			source_samples = processed_data.frames *
 					audio_stream_get_channels(input_buffers[0].data);
-			cd->converter[sink_queue_id](input_buffers[0].data, 0,
-						     output_buffers[i].data, 0,
-						     source_samples, DUMMY_CHMAP);
+			converter(&src_cir,audio_stream_get_channels(input_buffers[0].data),
+				  &snk_cir, audio_stream_get_channels(output_buffers[i].data),
+				  source_samples, DUMMY_CHMAP);
 
 			output_buffers[i].size = processed_data.sink_bytes;
 			cd->output_total_data_processed += processed_data.sink_bytes;

src/audio/pcm_converter/pcm_converter.c

@@ -15,52 +15,76 @@
 #include <sof/audio/pcm_converter.h>
 #include <rtos/panic.h>
 
-int pcm_convert_as_linear(const struct audio_stream *source, uint32_t ioffset,
-			  struct audio_stream *sink, uint32_t ooffset,
+int pcm_convert_as_linear(const struct cir_buf_source *source, size_t s_size_in,
+			  struct cir_buf_sink *sink, size_t s_size_out,
 			  uint32_t samples, pcm_converter_lin_func converter)
 {
-	const int s_size_in = audio_stream_sample_bytes(source);
-	const int s_size_out = audio_stream_sample_bytes(sink);
 	const int log2_s_size_in = ffs(s_size_in) - 1;
 	const int log2_s_size_out = ffs(s_size_out) - 1;
-	char *r_ptr = audio_stream_get_frag(source, audio_stream_get_rptr(source), ioffset,
-					    s_size_in);
-	char *w_ptr = audio_stream_get_frag(sink, audio_stream_get_wptr(sink), ooffset,
-					    s_size_out);
+	const char *r_ptr = source->ptr;
+	char *w_ptr = sink->ptr;
 	int i = 0;
 	int chunk;
 	int N1, N2;
 
-	/* assert enough avail/free samples in source and sink buffer */
-	if (audio_stream_get_avail_samples(source) < samples + ioffset)
-		return -EINVAL;
-	if (audio_stream_get_free_samples(sink) < samples + ooffset)
-		return -EINVAL;
 
 	while (i < samples) {
-		/* calculate chunk size */
-		/* "">> log2_s_size" is equal "/ s_size" here */
-		N1 = audio_stream_bytes_without_wrap(source, r_ptr) >>
-			log2_s_size_in;
-		N2 = audio_stream_bytes_without_wrap(sink, w_ptr) >>
-			log2_s_size_out;
+		/* calculate chunk size; shifting by log2_s_size is dividing by s_size */
+		N1 = ((const char *)source->buf_end - r_ptr) >> log2_s_size_in;
+		N2 = ((char *)sink->buf_end - w_ptr) >> log2_s_size_out;
 		chunk = MIN(N1, N2);
 		chunk = MIN(chunk, samples - i);
 
 		/* run conversion on linear memory region */
 		converter(r_ptr, w_ptr, chunk);
 
 		/* move pointers */
-		r_ptr = audio_stream_wrap(source, r_ptr + chunk * s_size_in);
-		w_ptr = audio_stream_wrap(sink, w_ptr + chunk * s_size_out);
+		r_ptr = cir_buf_wrap(r_ptr + chunk * s_size_in,
+				     source->buf_start, source->buf_end);
+		w_ptr = cir_buf_wrap(w_ptr + chunk * s_size_out,
+				     sink->buf_start, sink->buf_end);
 		i += chunk;
 	}
 
 	return samples;
 }
 
-int just_copy(const struct audio_stream *source, uint32_t ioffset,
-	      struct audio_stream *sink, uint32_t ooffset, uint32_t samples, uint32_t chmap)
+/* Copy "bytes" of raw data from a source to a sink circular buffer. */
+static void just_copy_bytes(const struct cir_buf_source *source, struct cir_buf_sink *sink,
+			    uint32_t bytes)
 {
-	return audio_stream_copy(source, ioffset, sink, ooffset, samples);
+	cir_buf_copy(source->ptr, source->buf_start, source->buf_end,
+		     sink->ptr, sink->buf_start, sink->buf_end, bytes);
+}
+
+int just_copy_1b(const struct cir_buf_source *source, uint32_t src_channels,
+		 struct cir_buf_sink *sink, uint32_t sink_channels,
+		 uint32_t samples, uint32_t chmap)
+{
+	just_copy_bytes(source, sink, samples);
+	return samples;
+}
+
+int just_copy_2b(const struct cir_buf_source *source, uint32_t src_channels,
+		 struct cir_buf_sink *sink, uint32_t sink_channels,
+		 uint32_t samples, uint32_t chmap)
+{
+	just_copy_bytes(source, sink, samples * sizeof(int16_t));
+	return samples;
+}
+
+int just_copy_3b(const struct cir_buf_source *source, uint32_t src_channels,
+		 struct cir_buf_sink *sink, uint32_t sink_channels,
+		 uint32_t samples, uint32_t chmap)
+{
+	just_copy_bytes(source, sink, samples * 3);
+	return samples;
+}
+
+int just_copy_4b(const struct cir_buf_source *source, uint32_t src_channels,
+		 struct cir_buf_sink *sink, uint32_t sink_channels,
+		 uint32_t samples, uint32_t chmap)
+{
+	just_copy_bytes(source, sink, samples * sizeof(int32_t));
+	return samples;
 }