audiodelays, audiofilters, audiofreeverb: buffer lengths and silence …

shared-module/audiodelays/Chorus.c

@@ -130,6 +130,10 @@ void chorus_recalculate_delay(audiodelays_chorus_obj_t *self, mp_float_t f_delay
     // Calculate the current chorus buffer length in bytes
     uint32_t new_chorus_buffer_len = (uint32_t)(self->base.sample_rate / MICROPY_FLOAT_CONST(1000.0) * f_delay_ms) * (self->base.channel_count * sizeof(uint16_t));
 
+    if (new_chorus_buffer_len > self->max_chorus_buffer_len) {
+        new_chorus_buffer_len = self->max_chorus_buffer_len;
+    }
+
     self->chorus_buffer_len = new_chorus_buffer_len;
 
     self->current_delay_ms = f_delay_ms;

shared-module/audiodelays/Echo.c

@@ -143,12 +143,13 @@ void recalculate_delay(audiodelays_echo_obj_t *self, mp_float_t f_delay_ms) {
         uint32_t new_echo_buffer_len = (uint32_t)(self->base.sample_rate / MICROPY_FLOAT_CONST(1000.0) * f_delay_ms) * sizeof(uint16_t);
 
         // Limit to valid range
-        if (new_echo_buffer_len > max_echo_buffer_len) {
-            new_echo_buffer_len = max_echo_buffer_len;
-        } else if (new_echo_buffer_len < self->buffer_len) {
+        if (new_echo_buffer_len < self->buffer_len) {
             // If the echo buffer is smaller than our audio buffer, weird things happen
             new_echo_buffer_len = self->buffer_len;
         }
+        if (new_echo_buffer_len > max_echo_buffer_len) {
+            new_echo_buffer_len = max_echo_buffer_len;
+        }
 
         self->echo_buffer_len = new_echo_buffer_len;
 

shared-module/audiodelays/GranularPitchShift.c

@@ -326,7 +326,9 @@ audioio_get_buffer_result_t audiodelays_granular_pitch_shift_get_buffer(audiodel
             } else {
                 // For unsigned samples set to the middle which is "quiet"
                 if (MP_LIKELY(self->base.bits_per_sample == 16)) {
-                    memset(word_buffer, 32768, length * (self->base.bits_per_sample / 8));
+                    for (uint32_t i = 0; i < length; i++) {
+                        word_buffer[i] = (int16_t)0x8000;
+                    }
                 } else {
                     memset(hword_buffer, 128, length * (self->base.bits_per_sample / 8));
                 }

shared-module/audiodelays/MultiTapDelay.c

@@ -118,12 +118,13 @@ void common_hal_audiodelays_multi_tap_delay_set_delay_ms(audiodelays_multi_tap_d
     self->delay_buffer_len = (uint32_t)(self->base.sample_rate / MICROPY_FLOAT_CONST(1000.0) * self->delay_ms) * (self->base.channel_count * sizeof(uint16_t));
 
     // Limit to valid range
-    if (self->delay_buffer_len > self->max_delay_buffer_len) {
-        self->delay_buffer_len = self->max_delay_buffer_len;
-    } else if (self->delay_buffer_len < self->buffer_len) {
+    if (self->delay_buffer_len < self->buffer_len) {
         // If the delay buffer is smaller than our audio buffer, weird things happen
         self->delay_buffer_len = self->buffer_len;
     }
+    if (self->delay_buffer_len > self->max_delay_buffer_len) {
+        self->delay_buffer_len = self->max_delay_buffer_len;
+    }
 
     // Clear the now unused part of the buffer or some weird artifacts appear
     memset(self->delay_buffer + self->delay_buffer_len, 0, self->max_delay_buffer_len - self->delay_buffer_len);

shared-module/audiodelays/PitchShift.c

@@ -61,6 +61,7 @@ void common_hal_audiodelays_pitch_shift_construct(audiodelays_pitch_shift_obj_t
     self->freeze = false;
 
     // Allocate the window buffer
+    mp_arg_validate_int_min(window, sizeof(uint16_t) * channel_count, MP_QSTR_window);
     self->window_len = window; // bytes
     self->window_buffer = m_malloc_without_collect(self->window_len);
     if (self->window_buffer == NULL) {
@@ -233,7 +234,9 @@ audioio_get_buffer_result_t audiodelays_pitch_shift_get_buffer(audiodelays_pitch
             } else {
                 // For unsigned samples set to the middle which is "quiet"
                 if (MP_LIKELY(self->base.bits_per_sample == 16)) {
-                    memset(word_buffer, 32768, length * (self->base.bits_per_sample / 8));
+                    for (uint32_t si = 0; si < length; si++) {
+                        word_buffer[si] = (int16_t)0x8000;
+                    }
                 } else {
                     memset(hword_buffer, 128, length * (self->base.bits_per_sample / 8));
                 }

shared-module/audiofilters/Distortion.c

@@ -210,7 +210,9 @@ audioio_get_buffer_result_t audiofilters_distortion_get_buffer(audiofilters_dist
             } else {
                 // For unsigned samples set to the middle which is "quiet"
                 if (MP_LIKELY(self->base.bits_per_sample == 16)) {
-                    memset(word_buffer, 32768, length * (self->base.bits_per_sample / 8));
+                    for (uint32_t si = 0; si < length; si++) {
+                        word_buffer[si] = (int16_t)0x8000;
+                    }
                 } else {
                     memset(hword_buffer, 128, length * (self->base.bits_per_sample / 8));
                 }
@@ -325,7 +327,7 @@ audioio_get_buffer_result_t audiofilters_distortion_get_buffer(audiofilters_dist
 
                     // Hard clip
                     if (!self->soft_clip) {
-                        word = MIN(MAX(word, -32767), 32768);
+                        word = MIN(MAX(word, -32767), 32767);
                     }
 
                     if (MP_LIKELY(self->base.bits_per_sample == 16)) {

shared-module/audiofilters/Filter.c

@@ -225,7 +225,7 @@ audioio_get_buffer_result_t audiofilters_filter_get_buffer(audiofilters_filter_o
                     }
 
                     // Process biquad filters
-                    for (uint8_t j = 0; j < self->filter.objs_len; j++) {
+                    for (size_t j = 0; j < self->filter.objs_len; j++) {
                         mp_obj_t filter_obj = self->filter.objs[j];
                         common_hal_synthio_biquad_tick(filter_obj);
                         for (uint8_t k = 0; k < self->base.channel_count; k++) {

shared-module/audiofilters/__init__.c

@@ -48,21 +48,21 @@ void audiofilters_assign_filter_chain(audiofilters_filter_chain_t *self, mp_obj_
 
 void audiofilters_reset_filter_chain(audiofilters_filter_chain_t *self, uint8_t channel_count) {
     if (self->states) {
-        for (uint8_t i = 0; i < self->objs_len * channel_count; i++) {
+        for (size_t i = 0; i < self->objs_len * channel_count; i++) {
             synthio_biquad_filter_reset(&self->states[i]);
         }
     }
 }
 
 void audiofilters_tick_filter_chain(audiofilters_filter_chain_t *self) {
-    for (uint8_t j = 0; j < self->objs_len; j++) {
+    for (size_t j = 0; j < self->objs_len; j++) {
         common_hal_synthio_biquad_tick(self->objs[j]);
     }
 }
 
 int32_t audiofilters_process_filter_chain(audiofilters_filter_chain_t *self, uint8_t channel_count, uint8_t channel, int32_t word) {
     // Process biquad filters
-    for (uint8_t j = 0; j < self->objs_len; j++) {
+    for (size_t j = 0; j < self->objs_len; j++) {
         word = synthio_biquad_filter_sample(self->objs[j], &self->states[j * channel_count + channel], word);
     }
     return word;

shared-module/audiofreeverb/Freeverb.c

@@ -96,7 +96,7 @@ void common_hal_audiofreeverb_freeverb_construct(audiofreeverb_freeverb_obj_t *s
             common_hal_audiofreeverb_freeverb_deinit(self);
             m_malloc_fail(self->combbuffersizes[i]);
         }
-        memset(self->combbuffers[i], 0, self->combbuffersizes[i]);
+        memset(self->combbuffers[i], 0, self->combbuffersizes[i] * sizeof(uint16_t));
 
         self->combbufferindex[i] = 0;
         self->combfitlers[i] = 0;
@@ -114,7 +114,7 @@ void common_hal_audiofreeverb_freeverb_construct(audiofreeverb_freeverb_obj_t *s
             common_hal_audiofreeverb_freeverb_deinit(self);
             m_malloc_fail(self->allpassbuffersizes[i]);
         }
-        memset(self->allpassbuffers[i], 0, self->allpassbuffersizes[i]);
+        memset(self->allpassbuffers[i], 0, self->allpassbuffersizes[i] * sizeof(uint16_t));
 
         self->allpassbufferindex[i] = 0;
     }
@@ -304,6 +304,8 @@ audioio_get_buffer_result_t audiofreeverb_freeverb_get_buffer(audiofreeverb_free
 
         int16_t *sample_src = (int16_t *)self->sample_remaining_buffer;
 
+        uint32_t channel_comb_offset = 0, channel_allpass_offset = 0;
+
         for (uint32_t i = 0; i < n; i++) {
             int32_t sample_word = 0;
             if (self->sample != NULL) {
@@ -312,7 +314,6 @@ audioio_get_buffer_result_t audiofreeverb_freeverb_get_buffer(audiofreeverb_free
 
             int32_t word, sum;
             int16_t input, bufout, output;
-            uint32_t channel_comb_offset = 0, channel_allpass_offset = 0;
 
             // Apply filters as Pre-EQ
             input = (int16_t)audiofilters_process_filter_chain(&self->pre_filter, self->base.channel_count, n % self->base.channel_count, sample_word);