Audio: aec: optimize acoustic echo cancellation processing

This check-in introduces performance optimization modifications to
the audio Echo Cancellation (AEC) implementation. The enhancements
primarily focus on refining loop structures and memory copy
operations to ensure more efficient use of cycles.

Signed-off-by: shastry <malladi.sastry@intel.com>

Author: ShriramShastry

src/audio/google/google_rtc_audio_processing.c

@@ -822,23 +822,46 @@ static int google_rtc_audio_processing_process(struct processing_module *mod,
 	/* 32float: de-interlace ref buffer, convert it to float, skip channels if > Max
 	 * 16int: linearize buffer, skip channels if > Max
 	 */
+	// Optimization:Reduce cycle waste by streamlining the inner loop,
+	// converting from array indexing to pointer arithmetic,
+	// and putting data copy verification outside the loop.
 	buffer_offset = 0;
-	for (int i = 0; i < cd->num_frames; i++) {
-		for (channel = 0; channel < cd->num_aec_reference_channels; ++channel) {
+	int16_t *ref_end = ref + cd->num_frames * cd->num_aec_reference_channels;
+
+	if ((void *)ref_end >= (void *)ref_buf_end)
+		ref_end = (void *)ref_buf_start;
+
 #if CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API
-			cd->aec_reference_buffer_ptrs[channel][i] =
-					convert_int16_to_float(ref[channel]);
+	float **ref_ptr = cd->aec_reference_buffer_ptrs;
+
+	for (int i = 0; i < cd->num_frames; ++i) {
+		for (int channel = 0; channel < cd->num_aec_reference_channels; ++channel) {
+			if (ref && (void *)ref >= (void *)ref_buf_start &&
+			    (void *)ref < (void *)ref_buf_end) {
+				(*ref_ptr)[channel] = convert_int16_to_float(*ref++);
+			} else {
+				//ref does not point to valid int16_t data
+				return -1;
+			}
+		}
+		ref_ptr++;
+	}
+
 #else /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
-			cd->aec_reference_buffer[buffer_offset++] = ref[channel];
-#endif /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
+	int16_t *ref_buf = cd->aec_reference_buffer;
 
+	while (ref != ref_end) {
+		if (ref && (void *)ref >= (void *)ref_buf_start &&
+		    (void *)ref < (void *)ref_buf_end) {
+			*ref_buf++ = *ref++;
+		} else {
+			// ref does not point to valid int16_t data
+			return -2;
 		}
-
-		ref += cd->num_aec_reference_channels;
-		if ((void *)ref >= (void *)ref_buf_end)
-			ref = (void *)ref_buf_start;
 	}
 
+#endif /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
+
 #if CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API
 	GoogleRtcAudioProcessingAnalyzeRender_float32(cd->state,
 						      (const float **)
@@ -855,24 +878,47 @@ static int google_rtc_audio_processing_process(struct processing_module *mod,
 			      (const void **)&src_buf_start,  &src_buf_size);
 	assert(!ret);
 	src_buf_end = src_buf_start + src_buf_size;
-
+	// The second optimization eliminates the inner loop
+	// and replaces it with pointer arithmetic for speedier access.
+	// To reduce cycle waste, the data copy check is moved outside of the loop.
 	buffer_offset = 0;
-	for (int i = 0; i < cd->num_frames; i++) {
-		for (channel = 0; channel < cd->num_capture_channels; channel++)
+	int16_t *src_end = src + cd->num_frames * cd->config.output_fmt.channels_count;
+
+	if ((void *)src_end >= (void *)src_buf_end)
+		src_end = (void *)src_buf_start;
+
 #if CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API
-		cd->process_buffer_ptrs[channel][i] = convert_int16_to_float(src[channel]);
-#else /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
-		cd->process_buffer[buffer_offset++] = src[channel];
-#endif /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
+	float **proc_ptr = cd->process_buffer_ptrs;
+
+	// Process the data until the source pointer reaches the end
+	// This assumes that the source buffer is continuous in memory
+	// If the source buffer is not continuous (i.e., if it wraps around
+	// like in a circular buffer), this code will not work correctly
+	while (src != src_end) {
+		// Check if src has exceeded the buffer end
+		if ((void *)src >= (void *)src_buf_end)
+			src = (void *)src_buf_start;
 
-		/* move pointer to next frame
-		 * number of incoming channels may be < cd->num_capture_channels
-		 */
-		src += cd->config.output_fmt.channels_count;
+		*proc_ptr++ = convert_int16_to_float(src++);
+	}
+
+#else /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
+	int16_t *proc_buf = cd->process_buffer;
+
+	// Process the data until the source pointer reaches the end
+	// This assumes that the source buffer is continuous in memory
+	// If the source buffer is not continuous (i.e., if it wraps
+	// around like in a circular buffer), this code will not work correctly
+	while (src != src_end) {
+		// Check if src has exceeded the buffer end
 		if ((void *)src >= (void *)src_buf_end)
 			src = (void *)src_buf_start;
+
+		*proc_buf++ = *src++;
 	}
 
+#endif /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
+
 	source_release_data(src_stream, num_of_bytes_to_process);
 
 	/* call the library, use same in/out buffers */
@@ -894,24 +940,24 @@ static int google_rtc_audio_processing_process(struct processing_module *mod,
 
 	/* process all channels in output stream */
 	buffer_offset = 0;
-	for (int i = 0; i < cd->num_frames; i++) {
-		for (channel = 0; channel < cd->config.output_fmt.channels_count; channel++) {
-			/* set data in processed channels, zeroize not processed */
-			if (channel < cd->num_capture_channels)
+	int16_t *dst_end = dst + cd->num_frames * cd->config.output_fmt.channels_count;
+
+	if ((void *)dst_end >= (void *)dst_buf_end)
+		dst_end = (void *)dst_buf_start;
+
 #if CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API
-				dst[channel] = convert_float_to_int16(
-						   cd->process_buffer_ptrs[channel][i]);
+	float **proc_ptr = cd->process_buffer_ptrs;
+
+	while (dst != dst_end && *proc_ptr)
+		*dst++ = convert_float_to_int16(*proc_ptr++);
+
 #else /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
-				dst[channel] = cd->process_buffer[buffer_offset++];
-#endif /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
-			else
-				dst[channel] = 0;
-		}
+	int16_t *process_buffer = cd->process_buffer;
 
-		dst += cd->config.output_fmt.channels_count;
-		if ((void *)dst >= (void *)dst_buf_end)
-			dst = (void *)dst_buf_start;
-	}
+	while (dst != dst_end && *process_buffer)
+		*dst++ = *process_buffer++;
+
+#endif /* CONFIG_COMP_GOOGLE_RTC_USE_32_BIT_FLOAT_API */
 
 	sink_commit_buffer(dst_stream, num_of_bytes_to_process);
 
@@ -928,6 +974,8 @@ static int google_rtc_audio_processing_process(struct processing_module *mod,
 	int16_t *src, *dst, *ref;
 	uint32_t num_aec_reference_frames;
 	uint32_t num_aec_reference_bytes;
+	int ref_channels;
+	int aec_ref_product;
 	int num_samples_remaining;
 	int num_frames_remaining;
 	int channel;
@@ -950,25 +998,32 @@ static int google_rtc_audio_processing_process(struct processing_module *mod,
 	ref_stream = ref_streamb->data;
 	ref = audio_stream_get_rptr(ref_stream);
 
+	// Pre-calculate the number of channels in the reference stream for efficiency
+	ref_channels = audio_stream_get_channels(ref_stream);
+
+	// Pre-calculate the product of the number of AEC reference channels and the AEC
+	// reference frame index
+	aec_ref_product = cd->num_aec_reference_channels * cd->aec_reference_frame_index;
+
 	num_aec_reference_frames = input_buffers[cd->aec_reference_source].size;
 	num_aec_reference_bytes = audio_stream_frame_bytes(ref_stream) * num_aec_reference_frames;
 
-	num_samples_remaining = num_aec_reference_frames * audio_stream_get_channels(ref_stream);
+	num_samples_remaining = num_aec_reference_frames * ref_channels;
 	while (num_samples_remaining) {
 		nmax = audio_stream_samples_without_wrap_s16(ref_stream, ref);
 		n = MIN(num_samples_remaining, nmax);
 		for (i = 0; i < n; i += cd->num_aec_reference_channels) {
-			j = cd->num_aec_reference_channels * cd->aec_reference_frame_index;
+			j = aec_ref_product;
 			for (channel = 0; channel < cd->num_aec_reference_channels; ++channel)
 				cd->aec_reference_buffer[j++] = ref[channel];
-
-			ref += audio_stream_get_channels(ref_stream);
+			ref += ref_channels;
 			++cd->aec_reference_frame_index;
-
 			if (cd->aec_reference_frame_index == cd->num_frames) {
 				GoogleRtcAudioProcessingAnalyzeRender_int16(cd->state,
-									    cd->aec_reference_buffer);
+									 cd->aec_reference_buffer);
 				cd->aec_reference_frame_index = 0;
+				// Reset the product as the frame index is reset
+				aec_ref_product = 0;
 			}
 		}
 		num_samples_remaining -= n;
@@ -984,6 +1039,8 @@ static int google_rtc_audio_processing_process(struct processing_module *mod,
 	src = audio_stream_get_rptr(mic_stream);
 	dst = audio_stream_get_wptr(out_stream);
 
+	//Move out of loop
+	int mic_stream_channels = audio_stream_get_channels(mic_stream);
 	frames = input_buffers[cd->raw_microphone_source].size;
 	num_frames_remaining = frames;
 
@@ -993,34 +1050,40 @@ static int google_rtc_audio_processing_process(struct processing_module *mod,
 		nmax = audio_stream_frames_without_wrap(out_stream, dst);
 		n = MIN(n, nmax);
 		for (i = 0; i < n; i++) {
-			memcpy_s(&(cd->raw_mic_buffer[cd->raw_mic_buffer_frame_index *
-						      cd->num_capture_channels]),
-				 cd->num_frames * cd->num_capture_channels *
-				 sizeof(cd->raw_mic_buffer[0]), src,
-				 sizeof(int16_t) * cd->num_capture_channels);
-			++cd->raw_mic_buffer_frame_index;
-
-			memcpy_s(dst, cd->num_frames * cd->num_capture_channels *
-				 sizeof(cd->output_buffer[0]),
-				 &(cd->output_buffer[cd->output_buffer_frame_index *
-						     cd->num_capture_channels]),
-				 sizeof(int16_t) * cd->num_capture_channels);
-			++cd->output_buffer_frame_index;
-
-			if (cd->raw_mic_buffer_frame_index == cd->num_frames) {
-				GoogleRtcAudioProcessingProcessCapture_int16(cd->state,
-									     cd->raw_mic_buffer,
-									     cd->output_buffer);
-				cd->output_buffer_frame_index = 0;
-				cd->raw_mic_buffer_frame_index = 0;
+			// If we haven't filled the buffer yet, copy the data
+			if (cd->raw_mic_buffer_frame_index < cd->num_frames) {
+				memcpy_s(&(cd->raw_mic_buffer[cd->raw_mic_buffer_frame_index *
+							      cd->num_capture_channels]),
+					 cd->num_frames * cd->num_capture_channels *
+					 sizeof(cd->raw_mic_buffer[0]), src,
+					 sizeof(int16_t) * cd->num_capture_channels);
+				++cd->raw_mic_buffer_frame_index;
+			}
+
+			if (cd->output_buffer_frame_index < cd->num_frames) {
+				memcpy_s(dst, cd->num_frames * cd->num_capture_channels *
+					 sizeof(cd->output_buffer[0]),
+					 &(cd->output_buffer[cd->output_buffer_frame_index *
+							     cd->num_capture_channels]),
+					 sizeof(int16_t) * cd->num_capture_channels);
+				++cd->output_buffer_frame_index;
 			}
 
-			src += audio_stream_get_channels(mic_stream);
-			dst += audio_stream_get_channels(out_stream);
+			src += mic_stream_channels;
+			dst += mic_stream_channels;
 		}
 		num_frames_remaining -= n;
 		src = audio_stream_wrap(mic_stream, src);
 		dst = audio_stream_wrap(out_stream, dst);
+
+		// If we've filled the buffer, process the data
+		if (cd->raw_mic_buffer_frame_index == cd->num_frames) {
+			GoogleRtcAudioProcessingProcessCapture_int16(cd->state,
+								     cd->raw_mic_buffer,
+								     cd->output_buffer);
+			cd->output_buffer_frame_index = 0;
+			cd->raw_mic_buffer_frame_index = 0;
+		}
 	}
 
 	module_update_buffer_position(&input_buffers[cd->raw_microphone_source],