Add in mix

Author: gamblor21

shared-bindings/audiodelays/Chorus.c

@@ -41,6 +41,7 @@
 //|         :param int max_delay_ms: The maximum time the chorus can be in milliseconds
 //|         :param synthio.BlockInput delay_ms: The current time of the chorus delay in milliseconds. Must be less the max_delay_ms.
 //|         :param synthio.BlockInput voices: The number of voices playing split evenly over the delay buffer.
+//|         :param synthio.BlockInput mix: How much of the wet audio to include along with the original signal.
 //|         :param int buffer_size: The total size in bytes of each of the two playback buffers to use
 //|         :param int sample_rate: The sample rate to be used
 //|         :param int channel_count: The number of channels the source samples contain. 1 = mono; 2 = stereo.
@@ -70,11 +71,12 @@
 //|         ...
 //|
 static mp_obj_t audiodelays_chorus_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
-    enum { ARG_max_delay_ms, ARG_delay_ms, ARG_voices, 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_voices, 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_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_voices, 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 = 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} },
@@ -95,7 +97,7 @@ static mp_obj_t audiodelays_chorus_make_new(const mp_obj_type_t *type, size_t n_
     }
 
     audiodelays_chorus_obj_t *self = mp_obj_malloc(audiodelays_chorus_obj_t, &audiodelays_chorus_type);
-    common_hal_audiodelays_chorus_construct(self, max_delay_ms, args[ARG_delay_ms].u_obj, args[ARG_voices].u_obj, args[ARG_buffer_size].u_int, bits_per_sample, args[ARG_samples_signed].u_bool, channel_count, sample_rate);
+    common_hal_audiodelays_chorus_construct(self, max_delay_ms, args[ARG_delay_ms].u_obj, args[ARG_voices].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);
 }
@@ -173,6 +175,24 @@ MP_PROPERTY_GETSET(audiodelays_chorus_voices_obj,
     (mp_obj_t)&audiodelays_chorus_get_voices_obj,
     (mp_obj_t)&audiodelays_chorus_set_voices_obj);
 
+//|     mix: synthio.BlockInput
+//|     """The rate the echo mix between 0 and 1 where 0 is only sample and 1 is all effect."""
+static mp_obj_t audiodelays_chorus_obj_get_mix(mp_obj_t self_in) {
+    return common_hal_audiodelays_chorus_get_mix(self_in);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(audiodelays_chorus_get_mix_obj, audiodelays_chorus_obj_get_mix);
+
+static mp_obj_t audiodelays_chorus_obj_set_mix(mp_obj_t self_in, mp_obj_t mix_in) {
+    audiodelays_chorus_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_audiodelays_chorus_set_mix(self, mix_in);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(audiodelays_chorus_set_mix_obj, audiodelays_chorus_obj_set_mix);
+
+MP_PROPERTY_GETSET(audiodelays_chorus_mix_obj,
+    (mp_obj_t)&audiodelays_chorus_get_mix_obj,
+    (mp_obj_t)&audiodelays_chorus_set_mix_obj);
+
 //|     playing: bool
 //|     """True when the effect is playing a sample. (read-only)"""
 //|
@@ -237,6 +257,7 @@ static const mp_rom_map_elem_t audiodelays_chorus_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_playing), MP_ROM_PTR(&audiodelays_chorus_playing_obj) },
     { MP_ROM_QSTR(MP_QSTR_delay_ms), MP_ROM_PTR(&audiodelays_chorus_delay_ms_obj) },
     { MP_ROM_QSTR(MP_QSTR_voices), MP_ROM_PTR(&audiodelays_chorus_voices_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mix), MP_ROM_PTR(&audiodelays_chorus_mix_obj) },
     AUDIOSAMPLE_FIELDS,
 };
 static MP_DEFINE_CONST_DICT(audiodelays_chorus_locals_dict, audiodelays_chorus_locals_dict_table);

shared-bindings/audiodelays/Chorus.h

@@ -11,7 +11,7 @@
 extern const mp_obj_type_t audiodelays_chorus_type;
 
 void common_hal_audiodelays_chorus_construct(audiodelays_chorus_obj_t *self, uint32_t max_delay_ms,
-    mp_obj_t delay_ms, mp_obj_t voices,
+    mp_obj_t delay_ms, mp_obj_t voices, mp_obj_t mix,
     uint32_t buffer_size, uint8_t bits_per_sample,
     bool samples_signed, uint8_t channel_count, uint32_t sample_rate);
 
@@ -28,6 +28,9 @@ void common_hal_audiodelays_chorus_set_delay_ms(audiodelays_chorus_obj_t *self,
 mp_obj_t common_hal_audiodelays_chorus_get_voices(audiodelays_chorus_obj_t *self);
 void common_hal_audiodelays_chorus_set_voices(audiodelays_chorus_obj_t *self, mp_obj_t voices);
 
+mp_obj_t common_hal_audiodelays_chorus_get_mix(audiodelays_chorus_obj_t *self);
+void common_hal_audiodelays_chorus_set_mix(audiodelays_chorus_obj_t *self, mp_obj_t arg);
+
 bool common_hal_audiodelays_chorus_get_playing(audiodelays_chorus_obj_t *self);
 void common_hal_audiodelays_chorus_play(audiodelays_chorus_obj_t *self, mp_obj_t sample, bool loop);
 void common_hal_audiodelays_chorus_stop(audiodelays_chorus_obj_t *self);

shared-module/audiodelays/Chorus.c

@@ -10,7 +10,7 @@
 #include "py/runtime.h"
 
 void common_hal_audiodelays_chorus_construct(audiodelays_chorus_obj_t *self, uint32_t max_delay_ms,
-    mp_obj_t delay_ms, mp_obj_t voices,
+    mp_obj_t delay_ms, mp_obj_t voices, mp_obj_t mix,
     uint32_t buffer_size, uint8_t bits_per_sample,
     bool samples_signed, uint8_t channel_count, uint32_t sample_rate) {
 
@@ -66,6 +66,11 @@ void common_hal_audiodelays_chorus_construct(audiodelays_chorus_obj_t *self, uin
     }
     synthio_block_assign_slot(delay_ms, &self->delay_ms, MP_QSTR_delay_ms);
 
+    if (mix == MP_OBJ_NULL) {
+        mix = mp_obj_new_float(MICROPY_FLOAT_CONST(0.5));
+    }
+    synthio_block_assign_slot(mix, &self->mix, MP_QSTR_mix);
+
     // Many effects may need buffers of what was played this shows how it was done for the chorus
     // A maximum length buffer was created and then the current chorus length can be dynamically changes
     // without having to reallocate a large chunk of memory.
@@ -148,6 +153,14 @@ void audiodelays_chorus_reset_buffer(audiodelays_chorus_obj_t *self,
     memset(self->chorus_buffer, 0, self->chorus_buffer_len);
 }
 
+mp_obj_t common_hal_audiodelays_chorus_get_mix(audiodelays_chorus_obj_t *self) {
+    return self->mix.obj;
+}
+
+void common_hal_audiodelays_chorus_set_mix(audiodelays_chorus_obj_t *self, mp_obj_t arg) {
+    synthio_block_assign_slot(arg, &self->mix, MP_QSTR_mix);
+}
+
 bool common_hal_audiodelays_chorus_get_playing(audiodelays_chorus_obj_t *self) {
     return self->sample != NULL;
 }
@@ -225,6 +238,7 @@ audioio_get_buffer_result_t audiodelays_chorus_get_buffer(audiodelays_chorus_obj
 
         int32_t voices = (int32_t)MAX(synthio_block_slot_get(&self->voices), 1.0);
         int32_t mix_down_scale = SYNTHIO_MIX_DOWN_SCALE(voices);
+        mp_float_t mix = synthio_block_slot_get_limited(&self->mix, MICROPY_FLOAT_CONST(0.0), MICROPY_FLOAT_CONST(1.0));
 
         mp_float_t f_delay_ms = synthio_block_slot_get(&self->delay_ms);
         if (MICROPY_FLOAT_C_FUN(fabs)(self->current_delay_ms - f_delay_ms) >= self->sample_ms) {
@@ -287,6 +301,10 @@ audioio_get_buffer_result_t audiodelays_chorus_get_buffer(audiodelays_chorus_obj
                     word = synthio_mix_down_sample(word, mix_down_scale);
                 }
 
+                // Add original sample + effect
+                word = sample_word + (word * mix);
+                word = synthio_mix_down_sample(word, 2);
+
                 if (MP_LIKELY(self->base.bits_per_sample == 16)) {
                     word_buffer[i] = word;
                     if (!self->base.samples_signed) {

shared-module/audiodelays/Chorus.h

@@ -19,6 +19,7 @@ typedef struct {
     mp_float_t current_delay_ms;
     mp_float_t sample_ms;
     synthio_block_slot_t voices;
+    synthio_block_slot_t mix;
 
     int8_t *buffer[2];
     uint8_t last_buf_idx;