Audio: Up_down_mixer: Process with circular wrap

The previous processing function processed entire source
and sink circular size. It avoids wrap check but is more
inefficient when buffer is larger than period.

WIP, not cleaned up.

Signed-off-by: Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>

Author: singalsu

src/audio/up_down_mixer/up_down_mixer.c

@@ -435,40 +435,72 @@ up_down_mixer_process(struct processing_module *mod,
 	struct comp_dev *dev = mod->dev;
 
 	size_t output_frames, input_frames, ret, input_cirbuf_size, output_cirbuf_size;
-	const uint8_t *input0_pos, *input0_start;
-	uint8_t *output_pos, *output_start;
+	const uint8_t *input_pos, *input_start, *input_end;
+	uint8_t *output_pos, *output_start, *output_end;
+	int input_frames_without_wrap, output_frames_without_wrap;
+	int frames_without_wrap, frames, frames_remain;
+	uint32_t input_bytes;
 
 	comp_dbg(dev, "up_down_mixer_process()");
 
 	output_frames = sink_get_free_frames(output_buffers[0]);
 	input_frames = source_get_data_frames_available(input_buffers[0]);
+	frames = MIN(input_frames, output_frames);
+	if (!frames)
+		return 0;
 
 	const size_t output_frame_bytes = sink_get_frame_bytes(output_buffers[0]);
 
-	ret = sink_get_buffer(output_buffers[0], output_frames * output_frame_bytes,
+	ret = sink_get_buffer(output_buffers[0], frames * output_frame_bytes,
 			      (void **)&output_pos, (void **)&output_start, &output_cirbuf_size);
-	if (ret)
+	if (ret) {
+		comp_err(dev, "failed sink_get_buffer");
 		return -ENODATA;
+	}
 
-	const size_t input0_frame_bytes = source_get_frame_bytes(input_buffers[0]);
+	const size_t input_frame_bytes = source_get_frame_bytes(input_buffers[0]);
 
-	ret = source_get_data(input_buffers[0], input_frames * input0_frame_bytes,
-			      (const void **)&input0_pos, (const void **)&input0_start,
+	ret = source_get_data(input_buffers[0], frames * input_frame_bytes,
+			      (const void **)&input_pos, (const void **)&input_start,
 			      &input_cirbuf_size);
 	if (ret) {
 		sink_commit_buffer(output_buffers[0], 0);
+		comp_err(dev, "failed source_get_data");
 		return -ENODATA;
 	}
 
-	cd->mix_routine(cd, (const void *)input0_start, input_cirbuf_size, (void *)output_start);
+	input_end = input_start + input_cirbuf_size;
+	output_end = output_start + output_cirbuf_size;
+	frames_remain = frames;
+	while (frames_remain) {
+		input_frames_without_wrap = (input_end - input_pos) / input_frame_bytes;
+		output_frames_without_wrap = (output_end - output_pos) / output_frame_bytes;
+		frames_without_wrap = MIN(input_frames_without_wrap, output_frames_without_wrap);
+		frames_without_wrap = MIN(frames_without_wrap, frames);
+		input_bytes = input_frame_bytes * frames_without_wrap;
+		cd->mix_routine(cd, (const void *)input_pos, input_bytes, (void *)output_pos);
+
+		input_pos += input_bytes;
+		output_pos += frames_without_wrap * output_frame_bytes;
+		input_pos = (input_pos > input_end) ?
+			input_pos - input_cirbuf_size : input_pos;
+		output_pos = (output_pos > output_end) ?
+			output_pos - output_cirbuf_size : output_pos;
+		frames_remain -= frames_without_wrap;
+	}
 
-	ret = sink_commit_buffer(output_buffers[0], output_frames * output_frame_bytes);
-	if (ret)
+	ret = sink_commit_buffer(output_buffers[0], frames * output_frame_bytes);
+	if (ret) {
+		comp_err(dev, "failed sink_commit_buffer");
 		return ret;
+	}
 
-	ret = source_release_data(input_buffers[0], input_frames * input0_frame_bytes);
-	if (ret)
+	ret = source_release_data(input_buffers[0], frames * input_frame_bytes);
+	if (ret) {
+		comp_err(dev, "failed source_release_data");
 		return ret;
+	}
+
 	return 0;
 }