audio: use size_t for circular-buffer sample counts

src/audio/aria/aria_generic.c

@@ -47,19 +47,20 @@ static void aria_algo_get_data(struct processing_module *mod,
 	int32_t gain_begin = cd->gains[sof_aria_index_tab[gain_state_add_2]];
 	/* do linear approximation between points gain_begin and gain_end */
 	int32_t gain_end = cd->gains[sof_aria_index_tab[gain_state_add_3]];
-	int32_t m, n, i, ch;
-	int32_t samples = frames * audio_stream_get_channels(sink);
+	size_t m, n, i;
+	int ch;
+	size_t samples = frames * audio_stream_get_channels(sink);
 	int32_t *out = audio_stream_get_wptr(sink);
 	int32_t *in = cd->data_ptr;
 	int32_t gain;
 	const int ch_n = cd->chan_cnt;
 	const int shift = 31 - cd->att;
 
-	for (i = 1; i < ARIA_MAX_GAIN_STATES - 1; i++) {
-		if (cd->gains[sof_aria_index_tab[gain_state_add_2 + i]] < gain_begin)
-			gain_begin = cd->gains[sof_aria_index_tab[gain_state_add_2 + i]];
-		if (cd->gains[sof_aria_index_tab[gain_state_add_3 + i]] < gain_end)
-			gain_end = cd->gains[sof_aria_index_tab[gain_state_add_3 + i]];
+	for (ch = 1; ch < ARIA_MAX_GAIN_STATES - 1; ch++) {
+		if (cd->gains[sof_aria_index_tab[gain_state_add_2 + ch]] < gain_begin)
+			gain_begin = cd->gains[sof_aria_index_tab[gain_state_add_2 + ch]];
+		if (cd->gains[sof_aria_index_tab[gain_state_add_3 + ch]] < gain_end)
+			gain_end = cd->gains[sof_aria_index_tab[gain_state_add_3 + ch]];
 	}
 	step = (gain_end - gain_begin) / frames;
 	gain = gain_begin;

src/audio/asrc/asrc.c

@@ -46,8 +46,8 @@ static void src_copy_s32(struct processing_module *mod,
 	int32_t *buf;
 	const int32_t *src = source->ptr;
 	int32_t *snk = sink->ptr;
-	int n_wrap_src;
-	int n_wrap_snk;
+	size_t n_wrap_src;
+	size_t n_wrap_snk;
 	int n_copy;
 	unsigned int n;
 	int ret;
@@ -118,8 +118,8 @@ static void src_copy_s16(struct processing_module *mod,
 	const int16_t *src = source->ptr;
 	int16_t *snk = sink->ptr;
 	int16_t *buf;
-	int n_wrap_src;
-	int n_wrap_snk;
+	size_t n_wrap_src;
+	size_t n_wrap_snk;
 	int n_copy;
 	int s_copy;
 	int ret;

src/audio/crossover/crossover.c

@@ -81,8 +81,7 @@ int crossover_get_stream_index(struct processing_module *mod,
 }
 
 /*
- * \brief Aligns the sinks with their respective assignments
- *	  in the configuration.
+ * \brief Aligns the sinks with their respective assignments in the configuration.
  *
  * Refer to sof/src/include/sof/crossover.h for more information on assigning
  * sinks to an output.
@@ -94,14 +93,14 @@ int crossover_get_stream_index(struct processing_module *mod,
  * \return number of sinks assigned. This number should be equal to
  *	   config->num_sinks if no errors were found.
  */
-static int crossover_assign_sinks(struct processing_module *mod,
-				  struct sof_sink **sinks, int num_of_sinks,
-				  struct sof_sink **assigned_sinks)
+static uint32_t crossover_assign_sinks(struct processing_module *mod,
+				       struct sof_sink **sinks, int num_of_sinks,
+				       struct sof_sink **assigned_sinks)
 {
 	struct comp_data *cd = module_get_private_data(mod);
 	struct sof_crossover_config *config = cd->config;
 	struct comp_dev *dev = mod->dev;
-	int num_sinks = 0;
+	uint32_t num_sinks = 0;
 	int i;
 	int j;
 
@@ -474,14 +473,11 @@ static int crossover_process(struct processing_module *mod,
 	struct comp_data *cd = module_get_private_data(mod);
 	struct comp_dev *dev = mod->dev;
 	struct sof_source *source = sources[0];
-	uint32_t num_sinks;
+	uint32_t num_sinks, prev_num_sinks;
 	uint32_t num_assigned_sinks = 0;
-	uint32_t frames;
+	size_t frames, cfg_size;
 	struct sof_crossover_config *prev_config;
-	uint32_t prev_num_sinks;
-	size_t cfg_size;
-	int ret;
-	int i;
+	int ret, i;
 
 	comp_dbg(dev, "entry");
 

src/audio/crossover/crossover.h

@@ -57,8 +57,8 @@ struct comp_data;
 typedef int (*crossover_process_func)(struct comp_data *cd,
 				      struct sof_source *source,
 				      struct sof_sink **sinks,
-				      int32_t num_sinks,
-				      uint32_t frames);
+				      uint32_t num_sinks,
+				      size_t frames);
 
 /* Crossover component private data */
 struct comp_data {

src/audio/crossover/crossover_generic.c

@@ -105,12 +105,12 @@ static void crossover_generic_split_4way(int32_t in,
 static int crossover_default_pass(struct comp_data *cd,
 				  struct sof_source *source,
 				  struct sof_sink **sinks,
-				  int32_t num_sinks,
-				  uint32_t frames)
+				  uint32_t num_sinks,
+				  size_t frames)
 {
 	size_t bytes = frames * source_get_frame_bytes(source);
+	uint32_t i;
 	int ret;
-	int i;
 
 	for (i = 0; i < num_sinks; i++) {
 		if (!sinks[i])
@@ -127,8 +127,8 @@ static int crossover_default_pass(struct comp_data *cd,
 static int crossover_s16_default(struct comp_data *cd,
 				 struct sof_source *source,
 				 struct sof_sink **sinks,
-				 int32_t num_sinks,
-				 uint32_t frames)
+				 uint32_t num_sinks,
+				 size_t frames)
 {
 	int16_t *y[SOF_CROSSOVER_MAX_STREAMS];
 	int16_t *y_start[SOF_CROSSOVER_MAX_STREAMS];
@@ -137,12 +137,14 @@ static int crossover_s16_default(struct comp_data *cd,
 	int32_t out[SOF_CROSSOVER_MAX_STREAMS];
 	struct crossover_state *state;
 	int16_t const *x, *x_start, *x_end;
-	int x_samples, y_samples;
-	int nch = source_get_channels(source);
+	size_t x_samples, y_samples;
+	unsigned int nch = source_get_channels(source);
 	size_t bytes = frames * source_get_frame_bytes(source);
-	int active_sinks = 0;
-	int remaining_samples;
-	int ch, i, j, n;
+	uint32_t active_sinks = 0;
+	size_t remaining_samples;
+	size_t i, n;
+	unsigned int ch;
+	uint32_t j;
 	int ret;
 
 	ret = source_get_data_s16(source, bytes, &x, &x_start, &x_samples);
@@ -205,8 +207,8 @@ static int crossover_s16_default(struct comp_data *cd,
 static int crossover_s24_default(struct comp_data *cd,
 				 struct sof_source *source,
 				 struct sof_sink **sinks,
-				 int32_t num_sinks,
-				 uint32_t frames)
+				 uint32_t num_sinks,
+				 size_t frames)
 {
 	int32_t *y[SOF_CROSSOVER_MAX_STREAMS];
 	int32_t *y_start[SOF_CROSSOVER_MAX_STREAMS];
@@ -215,12 +217,14 @@ static int crossover_s24_default(struct comp_data *cd,
 	int32_t out[SOF_CROSSOVER_MAX_STREAMS];
 	struct crossover_state *state;
 	int32_t const *x, *x_start, *x_end;
-	int x_samples, y_samples;
-	int nch = source_get_channels(source);
+	size_t x_samples, y_samples;
+	unsigned int nch = source_get_channels(source);
 	size_t bytes = frames * source_get_frame_bytes(source);
-	int active_sinks = 0;
-	int remaining_samples;
-	int ch, i, j, n;
+	uint32_t active_sinks = 0;
+	size_t remaining_samples;
+	size_t i, n;
+	unsigned int ch;
+	uint32_t j;
 	int ret;
 
 	ret = source_get_data_s32(source, bytes, &x, &x_start, &x_samples);
@@ -297,8 +301,8 @@ static int crossover_s24_default(struct comp_data *cd,
 static int crossover_s32_default(struct comp_data *cd,
 				 struct sof_source *source,
 				 struct sof_sink **sinks,
-				 int32_t num_sinks,
-				 uint32_t frames)
+				 uint32_t num_sinks,
+				 size_t frames)
 {
 	int32_t *y[SOF_CROSSOVER_MAX_STREAMS];
 	int32_t *y_start[SOF_CROSSOVER_MAX_STREAMS];
@@ -307,12 +311,14 @@ static int crossover_s32_default(struct comp_data *cd,
 	int32_t out[SOF_CROSSOVER_MAX_STREAMS];
 	struct crossover_state *state;
 	int32_t const *x, *x_start, *x_end;
-	int x_samples, y_samples;
-	int nch = source_get_channels(source);
+	size_t x_samples, y_samples;
+	unsigned int nch = source_get_channels(source);
 	size_t bytes = frames * source_get_frame_bytes(source);
-	int active_sinks = 0;
-	int remaining_samples;
-	int ch, i, j, n;
+	uint32_t active_sinks = 0;
+	size_t remaining_samples;
+	size_t i, n;
+	unsigned int ch;
+	uint32_t j;
 	int ret;
 
 	ret = source_get_data_s32(source, bytes, &x, &x_start, &x_samples);

src/audio/dcblock/dcblock_generic.c

@@ -53,12 +53,12 @@ static int dcblock_s16_default(struct comp_data *cd,
 {
 	const int16_t *x = source->ptr;
 	int16_t *y = sink->ptr;
-	int samples_without_wrap;
+	size_t samples_without_wrap;
 	int nch = cd->channels;
-	int remaining_samples = frames * nch;
+	size_t remaining_samples = frames * nch;
 	int32_t tmp;
 	int ch = 0;
-	int i;
+	size_t i;
 
 	while (remaining_samples) {
 		samples_without_wrap = cir_buf_samples_without_wrap_s16(x, source->buf_end);
@@ -100,12 +100,12 @@ static int dcblock_s24_default(struct comp_data *cd,
 {
 	const int32_t *x = source->ptr;
 	int32_t *y = sink->ptr;
-	int samples_without_wrap;
+	size_t samples_without_wrap;
 	int nch = cd->channels;
-	int remaining_samples = frames * nch;
+	size_t remaining_samples = frames * nch;
 	int32_t tmp;
 	int ch = 0;
-	int i;
+	size_t i;
 
 	while (remaining_samples) {
 		samples_without_wrap = cir_buf_samples_without_wrap_s32(x, source->buf_end);
@@ -147,11 +147,11 @@ static int dcblock_s32_default(struct comp_data *cd,
 {
 	const int32_t *x = source->ptr;
 	int32_t *y = sink->ptr;
-	int samples_without_wrap;
+	size_t samples_without_wrap;
 	int nch = cd->channels;
-	int remaining_samples = frames * nch;
+	size_t remaining_samples = frames * nch;
 	int ch = 0;
-	int i;
+	size_t i;
 
 	while (remaining_samples) {
 		samples_without_wrap = cir_buf_samples_without_wrap_s32(x, source->buf_end);

src/audio/drc/drc_generic.c

@@ -508,18 +508,18 @@ static inline void drc_pre_delay_index_inc(int *idx, int increment)
 static void drc_delay_input_sample_s16(struct drc_state *state,
 				       const struct cir_buf_source *source,
 				       struct cir_buf_sink *sink,
-				       const int16_t **x, int16_t **y, int samples, int nch)
+				       const int16_t **x, int16_t **y, size_t samples, int nch)
 {
 	const int16_t *x1;
 	int16_t *y1;
 	int16_t *pd;
 	int pd_write_index, pd_read_index;
-	int nbuf, npcm, nfrm;
+	size_t nbuf, npcm, nfrm;
 	int ch;
-	int i;
+	size_t i;
 	const int16_t *x0 = *x;
 	int16_t *y0 = *y;
-	int remaining_samples = samples;
+	size_t remaining_samples = samples;
 
 	while (remaining_samples) {
 		nbuf = cir_buf_samples_without_wrap_s16(x0, source->buf_end);
@@ -562,11 +562,11 @@ static void drc_s16_default(struct processing_module *mod,
 	int nch = cd->channels;
 	const int16_t *x = (int16_t *)source->ptr;
 	int16_t *y = (int16_t *)sink->ptr;
-	int samples = frames * nch;
+	size_t samples = frames * nch;
 	struct drc_state *state = &cd->state;
 	const struct sof_drc_params *p = &cd->config->params; /* Read-only */
-	int fragment_samples;
-	int fragment;
+	size_t fragment_samples;
+	size_t fragment;
 
 	if (!cd->enabled) {
 		/* Delay the input sample only and don't do other processing. This is used when the
@@ -602,18 +602,18 @@ static void drc_s16_default(struct processing_module *mod,
 static void drc_delay_input_sample_s32(struct drc_state *state,
 				       const struct cir_buf_source *source,
 				       struct cir_buf_sink *sink,
-				       const int32_t **x, int32_t **y, int samples, int nch)
+				       const int32_t **x, int32_t **y, size_t samples, int nch)
 {
 	const int32_t *x1;
 	int32_t *y1;
 	int32_t *pd;
 	int pd_write_index, pd_read_index;
-	int nbuf, npcm, nfrm;
+	size_t nbuf, npcm, nfrm;
 	int ch;
-	int i;
+	size_t i;
 	const int32_t *x0 = *x;
 	int32_t *y0 = *y;
-	int remaining_samples = samples;
+	size_t remaining_samples = samples;
 
 	while (remaining_samples) {
 		nbuf = cir_buf_samples_without_wrap_s32(x0, source->buf_end);
@@ -652,18 +652,18 @@ static void drc_delay_input_sample_s32(struct drc_state *state,
 static void drc_delay_input_sample_s24(struct drc_state *state,
 				       const struct cir_buf_source *source,
 				       struct cir_buf_sink *sink,
-				       const int32_t **x, int32_t **y, int samples, int nch)
+				       const int32_t **x, int32_t **y, size_t samples, int nch)
 {
 	const int32_t *x1;
 	int32_t *y1;
 	int32_t *pd;
 	int pd_write_index, pd_read_index;
-	int nbuf, npcm, nfrm;
+	size_t nbuf, npcm, nfrm;
 	int ch;
-	int i;
+	size_t i;
 	const int32_t *x0 = *x;
 	int32_t *y0 = *y;
-	int remaining_samples = samples;
+	size_t remaining_samples = samples;
 
 	while (remaining_samples) {
 		nbuf = cir_buf_samples_without_wrap_s32(x0, source->buf_end);
@@ -706,11 +706,11 @@ static void drc_s24_default(struct processing_module *mod,
 	int nch = cd->channels;
 	const int32_t *x = (int32_t *)source->ptr;
 	int32_t *y = (int32_t *)sink->ptr;
-	int samples = frames * nch;
+	size_t samples = frames * nch;
 	struct drc_state *state = &cd->state;
 	const struct sof_drc_params *p = &cd->config->params; /* Read-only */
-	int fragment_samples;
-	int fragment;
+	size_t fragment_samples;
+	size_t fragment;
 
 	if (!cd->enabled) {
 		/* Delay the input sample only and don't do other processing. This is used when the
@@ -754,11 +754,11 @@ static void drc_s32_default(struct processing_module *mod,
 	int nch = cd->channels;
 	const int32_t *x = (int32_t *)source->ptr;
 	int32_t *y = (int32_t *)sink->ptr;
-	int samples = frames * nch;
+	size_t samples = frames * nch;
 	struct drc_state *state = &cd->state;
 	const struct sof_drc_params *p = &cd->config->params; /* Read-only */
-	int fragment_samples;
-	int fragment;
+	size_t fragment_samples;
+	size_t fragment;
 
 	if (!cd->enabled) {
 		/* Delay the input sample only and don't do other processing. This is used when the