Delay and Decay to BlockInput

gamblor21 · gamblor21 · commit 477480705a6d · 2024-09-22T13:12:17.000-05:00
diff --git a/shared-bindings/audiodelays/Echo.c b/shared-bindings/audiodelays/Echo.c
@@ -22,12 +22,13 @@
 //|     """An Echo effect"""
 //|
 static mp_obj_t audiodelays_echo_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
-    enum { ARG_delay_ms, ARG_decay, ARG_mix, ARG_buffer_size, ARG_sample_rate, ARG_bits_per_sample, ARG_samples_signed, ARG_channel_count, };
+    enum { ARG_max_delay_ms, ARG_delay_ms, ARG_decay, ARG_mix, ARG_buffer_size, ARG_sample_rate, ARG_bits_per_sample, ARG_samples_signed, ARG_channel_count, };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_delay_ms, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 50 } },
+        { MP_QSTR_max_delay_ms, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 50 } },
+        { MP_QSTR_delay_ms, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_decay, MP_ARG_OBJ | MP_ARG_KW_ONLY,  {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_mix, MP_ARG_OBJ | MP_ARG_KW_ONLY,  {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_buffer_size, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 1024} },
+        { MP_QSTR_buffer_size, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 512} },
         { MP_QSTR_sample_rate, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 8000} },
         { MP_QSTR_bits_per_sample, MP_ARG_INT | MP_ARG_KW_ONLY, {.u_int = 16} },
         { MP_QSTR_samples_signed, MP_ARG_BOOL | MP_ARG_KW_ONLY, {.u_bool = true} },
@@ -37,12 +38,7 @@ static mp_obj_t audiodelays_echo_make_new(const mp_obj_type_t *type, size_t n_ar
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_int_t delay_ms = mp_arg_validate_int_range(args[ARG_delay_ms].u_int, 1, 4000, MP_QSTR_delay_ms);
-
-    mp_float_t decay = (args[ARG_decay].u_obj == MP_OBJ_NULL)
-        ? (mp_float_t)DECAY_DEFAULT
-        : mp_obj_get_float(args[ARG_decay].u_obj);
-    mp_arg_validate_float_range(decay, 0.0f, 1.0f, MP_QSTR_decay);
+    mp_int_t max_delay_ms = mp_arg_validate_int_range(args[ARG_max_delay_ms].u_int, 1, 4000, MP_QSTR_max_delay_ms);
 
     mp_int_t channel_count = mp_arg_validate_int_range(args[ARG_channel_count].u_int, 1, 2, MP_QSTR_channel_count);
     mp_int_t sample_rate = mp_arg_validate_int_min(args[ARG_sample_rate].u_int, 1, MP_QSTR_sample_rate);
@@ -52,7 +48,7 @@ static mp_obj_t audiodelays_echo_make_new(const mp_obj_type_t *type, size_t n_ar
     }
 
     audiodelays_echo_obj_t *self = mp_obj_malloc(audiodelays_echo_obj_t, &audiodelays_echo_type);
-    common_hal_audiodelays_echo_construct(self, delay_ms, decay, args[ARG_mix].u_obj, args[ARG_buffer_size].u_int, bits_per_sample, args[ARG_samples_signed].u_bool, channel_count, sample_rate);
+    common_hal_audiodelays_echo_construct(self, max_delay_ms, args[ARG_delay_ms].u_obj, args[ARG_decay].u_obj, args[ARG_mix].u_obj, args[ARG_buffer_size].u_int, bits_per_sample, args[ARG_samples_signed].u_bool, channel_count, sample_rate);
 
     return MP_OBJ_FROM_PTR(self);
 }
@@ -90,29 +86,27 @@ static mp_obj_t audiodelays_echo_obj___exit__(size_t n_args, const mp_obj_t *arg
 static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(audiodelays_echo___exit___obj, 4, 4, audiodelays_echo_obj___exit__);
 
 
-//|     delay_ms: int
+//|     delay_ms: BlockInput
 //|     """Delay of the echo in microseconds. (read-only)"""
 //|
 static mp_obj_t audiodelays_echo_obj_get_delay_ms(mp_obj_t self_in) {
     audiodelays_echo_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
-    return mp_obj_new_float(common_hal_audiodelays_echo_get_delay_ms(self));
+    return common_hal_audiodelays_echo_get_delay_ms(self);
 
 }
 MP_DEFINE_CONST_FUN_OBJ_1(audiodelays_echo_get_delay_ms_obj, audiodelays_echo_obj_get_delay_ms);
 
 static mp_obj_t audiodelays_echo_obj_set_delay_ms(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_delay_ms };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_delay_ms, MP_ARG_INT | MP_ARG_REQUIRED, {} },
+        { MP_QSTR_delay_ms,     MP_ARG_OBJ | MP_ARG_REQUIRED, {} },
     };
     audiodelays_echo_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_int_t delay_ms = mp_arg_validate_int_range(args[ARG_delay_ms].u_int, 1, 4000, MP_QSTR_delay_ms);
-
-    common_hal_audiodelays_echo_set_delay_ms(self, delay_ms);
+    common_hal_audiodelays_echo_set_delay_ms(self, args[ARG_delay_ms].u_obj);
 
     return mp_const_none;
 }
@@ -122,10 +116,10 @@ MP_PROPERTY_GETSET(audiodelays_echo_delay_ms_obj,
     (mp_obj_t)&audiodelays_echo_get_delay_ms_obj,
     (mp_obj_t)&audiodelays_echo_set_delay_ms_obj);
 
-//|     decay: float
+//|     decay: BlockInput
 //|     """The rate the echo decays between 0 and 1."""
 static mp_obj_t audiodelays_echo_obj_get_decay(mp_obj_t self_in) {
-    return mp_obj_new_float(common_hal_audiodelays_echo_get_decay(self_in));
+    return common_hal_audiodelays_echo_get_decay(self_in);
 }
 MP_DEFINE_CONST_FUN_OBJ_1(audiodelays_echo_get_decay_obj, audiodelays_echo_obj_get_decay);
 
@@ -138,10 +132,7 @@ static mp_obj_t audiodelays_echo_obj_set_decay(size_t n_args, const mp_obj_t *po
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_float_t decay = mp_obj_get_float(args[ARG_decay].u_obj);
-    mp_arg_validate_float_range(decay, 0.0f, 1.0f, MP_QSTR_decay);
-
-    common_hal_audiodelays_echo_set_decay(self, decay);
+    common_hal_audiodelays_echo_set_decay(self, args[ARG_decay].u_obj);
 
     return mp_const_none;
 }
@@ -151,10 +142,7 @@ MP_PROPERTY_GETSET(audiodelays_echo_decay_obj,
     (mp_obj_t)&audiodelays_echo_get_decay_obj,
     (mp_obj_t)&audiodelays_echo_set_decay_obj);
 
-
-
-
-//|     mix: float
+//|     mix: BlockInput
 //|     """The rate the echo mix between 0 and 1."""
 static mp_obj_t audiodelays_echo_obj_get_mix(mp_obj_t self_in) {
     return common_hal_audiodelays_echo_get_mix(self_in);
diff --git a/shared-bindings/audiodelays/Echo.h b/shared-bindings/audiodelays/Echo.h
@@ -10,8 +10,8 @@
 
 extern const mp_obj_type_t audiodelays_echo_type;
 
-void common_hal_audiodelays_echo_construct(audiodelays_echo_obj_t *self,
-    uint32_t delay_ms, mp_float_t decay, mp_obj_t mix,
+void common_hal_audiodelays_echo_construct(audiodelays_echo_obj_t *self, uint32_t max_delay_ms,
+    mp_obj_t delay_ms, mp_obj_t decay, mp_obj_t mix,
     uint32_t buffer_size, uint8_t bits_per_sample, bool samples_signed,
     uint8_t channel_count, uint32_t sample_rate);
 
@@ -22,11 +22,11 @@ uint32_t common_hal_audiodelays_echo_get_sample_rate(audiodelays_echo_obj_t *sel
 uint8_t common_hal_audiodelays_echo_get_channel_count(audiodelays_echo_obj_t *self);
 uint8_t common_hal_audiodelays_echo_get_bits_per_sample(audiodelays_echo_obj_t *self);
 
-uint32_t common_hal_audiodelays_echo_get_delay_ms(audiodelays_echo_obj_t *self);
-void common_hal_audiodelays_echo_set_delay_ms(audiodelays_echo_obj_t *self, uint32_t delay_ms);
+mp_obj_t common_hal_audiodelays_echo_get_delay_ms(audiodelays_echo_obj_t *self);
+void common_hal_audiodelays_echo_set_delay_ms(audiodelays_echo_obj_t *self, mp_obj_t delay_ms);
 
-mp_float_t common_hal_audiodelays_echo_get_decay(audiodelays_echo_obj_t *self);
-void common_hal_audiodelays_echo_set_decay(audiodelays_echo_obj_t *self, mp_float_t decay);
+mp_obj_t common_hal_audiodelays_echo_get_decay(audiodelays_echo_obj_t *self);
+void common_hal_audiodelays_echo_set_decay(audiodelays_echo_obj_t *self, mp_obj_t decay);
 
 mp_obj_t common_hal_audiodelays_echo_get_mix(audiodelays_echo_obj_t *self);
 void common_hal_audiodelays_echo_set_mix(audiodelays_echo_obj_t *self, mp_obj_t arg);
diff --git a/shared-module/audiodelays/Echo.c b/shared-module/audiodelays/Echo.c
@@ -10,7 +10,8 @@
 #include "shared-module/audiomixer/utils.h"
 
 
-void common_hal_audiodelays_echo_construct(audiodelays_echo_obj_t *self, uint32_t delay_ms, mp_float_t decay, mp_obj_t mix,
+void common_hal_audiodelays_echo_construct(audiodelays_echo_obj_t *self, uint32_t max_delay_ms,
+    mp_obj_t delay_ms, mp_obj_t decay, mp_obj_t mix,
     uint32_t buffer_size, uint8_t bits_per_sample,
     bool samples_signed, uint8_t channel_count, uint32_t sample_rate) {
 
@@ -19,7 +20,6 @@ void common_hal_audiodelays_echo_construct(audiodelays_echo_obj_t *self, uint32_
     self->channel_count = channel_count;
     self->sample_rate = sample_rate;
 
-    // check that buffer_size <= echo_buffer_size
     self->buffer_len = buffer_size;
     self->buffer = m_malloc(self->buffer_len);
     if (self->buffer == NULL) {
@@ -28,23 +28,34 @@ void common_hal_audiodelays_echo_construct(audiodelays_echo_obj_t *self, uint32_
     }
     memset(self->buffer, 0, self->buffer_len);
 
-    self->decay = (uint16_t)(decay * (1 << 15));
+    if (decay == MP_OBJ_NULL) {
+        decay = mp_obj_new_float(0.7);
+    }
+    synthio_block_assign_slot(decay, &self->decay, MP_QSTR_decay);
+
+    if (delay_ms == MP_OBJ_NULL) {
+        delay_ms = mp_obj_new_float(0.05);
+    }
+    synthio_block_assign_slot(delay_ms, &self->delay_ms, MP_QSTR_delay_ms);
 
     if (mix == MP_OBJ_NULL) {
         mix = mp_obj_new_float(0.5);
     }
     synthio_block_assign_slot(mix, &self->mix, MP_QSTR_mix);
 
     // calculate buffer size for the set delay
-    self->delay_ms = delay_ms;
-    self->echo_buffer_len = self->sample_rate / 1000.0f * self->delay_ms * (self->channel_count * (self->bits_per_sample / 8));
+    mp_float_t f_delay_ms = synthio_block_slot_get(&self->delay_ms);
+    self->echo_buffer_len = self->sample_rate / 1000.0f * f_delay_ms * (self->channel_count * (self->bits_per_sample / 8));
 
-    self->echo_buffer = m_malloc(self->echo_buffer_len);
+    // Set the echo buffer for the max possible delay
+    self->max_delay_ms = max_delay_ms;
+    self->max_echo_buffer_len = self->sample_rate / 1000.0f * max_delay_ms * (self->channel_count * (self->bits_per_sample / 8));
+    self->echo_buffer = m_malloc(self->max_echo_buffer_len);
     if (self->echo_buffer == NULL) {
         common_hal_audiodelays_echo_deinit(self);
-        m_malloc_fail(self->echo_buffer_len);
+        m_malloc_fail(self->max_echo_buffer_len);
     }
-    memset(self->echo_buffer, 0, self->echo_buffer_len);
+    memset(self->echo_buffer, 0, self->max_echo_buffer_len);
 
     // read is where we store the incoming sample
     // write is what we send to the outgoing buffer
@@ -74,19 +85,15 @@ void common_hal_audiodelays_echo_deinit(audiodelays_echo_obj_t *self) {
 }
 
 
-uint32_t common_hal_audiodelays_echo_get_delay_ms(audiodelays_echo_obj_t *self) {
-    return self->delay_ms;
+mp_obj_t common_hal_audiodelays_echo_get_delay_ms(audiodelays_echo_obj_t *self) {
+    return self->delay_ms.obj;
 }
 
-void common_hal_audiodelays_echo_set_delay_ms(audiodelays_echo_obj_t *self, uint32_t delay_ms) {
-    self->delay_ms = delay_ms;
-    self->echo_buffer_len = self->sample_rate / 1000.0f * self->delay_ms * (self->channel_count * (self->bits_per_sample / 8));
+void common_hal_audiodelays_echo_set_delay_ms(audiodelays_echo_obj_t *self, mp_obj_t delay_ms) {
+    synthio_block_assign_slot(delay_ms, &self->delay_ms, MP_QSTR_delay_ms);
 
-    self->echo_buffer = m_realloc(self->echo_buffer, self->echo_buffer_len);
-    if (self->echo_buffer == NULL) {
-        common_hal_audiodelays_echo_deinit(self);
-        m_malloc_fail(self->echo_buffer_len);
-    }
+    mp_float_t f_delay_ms = synthio_block_slot_get(&self->delay_ms);
+    self->echo_buffer_len = self->sample_rate / 1000.0f * f_delay_ms * (self->channel_count * (self->bits_per_sample / 8));
 
     uint32_t max_ebuf_length = self->echo_buffer_len / sizeof(uint32_t);
 
@@ -99,12 +106,12 @@ void common_hal_audiodelays_echo_set_delay_ms(audiodelays_echo_obj_t *self, uint
     }
 }
 
-mp_float_t common_hal_audiodelays_echo_get_decay(audiodelays_echo_obj_t *self) {
-    return (mp_float_t)self->decay / (1 << 15);
+mp_obj_t common_hal_audiodelays_echo_get_decay(audiodelays_echo_obj_t *self) {
+    return self->decay.obj;
 }
 
-void common_hal_audiodelays_echo_set_decay(audiodelays_echo_obj_t *self, mp_float_t decay) {
-    self->decay = (uint16_t)(decay * (1 << 15));
+void common_hal_audiodelays_echo_set_decay(audiodelays_echo_obj_t *self, mp_obj_t decay) {
+    synthio_block_assign_slot(decay, &self->decay, MP_QSTR_decay);
 }
 
 mp_obj_t common_hal_audiodelays_echo_get_mix(audiodelays_echo_obj_t *self) {
@@ -169,8 +176,6 @@ void common_hal_audiodelays_echo_play(audiodelays_echo_obj_t *self, mp_obj_t sam
 
 void common_hal_audiodelays_echo_stop(audiodelays_echo_obj_t *self) {
     self->sample = NULL;
-    // memset(self->echo_buffer, 0, self->echo_buffer_len); // clear echo
-    // memset(self->buffer, 0, self->buffer_len);
     return;
 }
 
@@ -188,6 +193,14 @@ audioio_get_buffer_result_t audiodelays_echo_get_buffer(audiodelays_echo_obj_t *
     }
     uint16_t mix = (uint16_t)(f_mix * (1 << 15));
 
+    mp_float_t f_decay = synthio_block_slot_get(&self->decay);
+    if (f_decay > 1.0) {
+        f_decay = 1.0;
+    } else if (f_decay < 0.0) {
+        f_decay = 0.0;
+    }
+    uint16_t decay = (uint16_t)(f_decay * (1 << 15));
+
     while (length != 0) {
         if (self->sample_buffer_length == 0) {
             if (!self->more_data) {
@@ -219,7 +232,7 @@ audioio_get_buffer_result_t audiodelays_echo_get_buffer(audiodelays_echo_obj_t *
                     // sample signed/unsigned won't matter as we have no sample
                     for (uint32_t i = 0; i < length; i++) {
                         uint32_t echo = self->echo_buffer[self->echo_buffer_read_pos++];
-                        word_buffer[i] = mult16signed(echo, self->decay);
+                        word_buffer[i] = mult16signed(echo, decay);
                         self->echo_buffer[self->echo_buffer_write_pos++] = word_buffer[i];
 
                         word_buffer[i] = mult16signed(word_buffer[i], mix);
@@ -238,7 +251,7 @@ audioio_get_buffer_result_t audiodelays_echo_get_buffer(audiodelays_echo_obj_t *
                 uint16_t *echo_hsrc = (uint16_t *)self->echo_buffer;
                 for (uint32_t i = 0; i < length * 2; i++) {
                     uint32_t echo_word = unpack8(echo_hsrc[i]);
-                    echo_word = mult16signed(echo_word, self->decay);
+                    echo_word = mult16signed(echo_word, decay);
                     hword_buffer[i] = pack8(echo_word);
 
                     echo_hsrc[self->echo_buffer_write_pos++] = hword_buffer[i];
@@ -267,7 +280,7 @@ audioio_get_buffer_result_t audiodelays_echo_get_buffer(audiodelays_echo_obj_t *
                             sample_word = tosigned16(sample_word);
                         }
                         uint32_t echo = self->echo_buffer[self->echo_buffer_read_pos++];
-                        word_buffer[i] = add16signed(mult16signed(echo, self->decay), sample_word);
+                        word_buffer[i] = add16signed(mult16signed(echo, decay), sample_word);
                         self->echo_buffer[self->echo_buffer_write_pos++] = word_buffer[i];
 
                         word_buffer[i] = add16signed(mult16signed(sample_word, 32768 - mix), mult16signed(word_buffer[i], mix));
@@ -290,7 +303,7 @@ audioio_get_buffer_result_t audiodelays_echo_get_buffer(audiodelays_echo_obj_t *
                     if (MP_LIKELY(!self->samples_signed)) {
                         sample_word = tosigned16(sample_word);
                     }
-                    echo_word = mult16signed(echo_word, self->decay);
+                    echo_word = mult16signed(echo_word, decay);
                     sample_word = add16signed(sample_word, echo_word);
                     hword_buffer[i] = pack8(sample_word);
 
diff --git a/shared-module/audiodelays/Echo.h b/shared-module/audiodelays/Echo.h
@@ -14,16 +14,18 @@ extern const mp_obj_type_t audiodelays_echo_type;
 
 typedef struct {
     mp_obj_base_t base;
-    uint32_t delay_ms;
-    uint16_t decay;
+    uint32_t max_delay_ms;
+    synthio_block_slot_t delay_ms;
+    synthio_block_slot_t decay;
     synthio_block_slot_t mix;
+
     uint8_t bits_per_sample;
     bool samples_signed;
     uint8_t channel_count;
     uint32_t sample_rate;
 
     uint32_t *buffer;
-    uint32_t buffer_len; // buffer in bytes
+    uint32_t buffer_len; // max buffer in bytes
 
     uint32_t *sample_remaining_buffer;
     uint32_t sample_buffer_length;
@@ -33,6 +35,7 @@ typedef struct {
 
     uint32_t *echo_buffer;
     uint32_t echo_buffer_len; // bytes
+    uint32_t max_echo_buffer_len; // bytes
 
     uint32_t echo_buffer_read_pos; // words
     uint32_t echo_buffer_write_pos; // words
