Changes to properly handle samples

Author: gamblor21

locale/circuitpython.pot

@@ -1956,18 +1956,34 @@ msgstr ""
 msgid "The length of rgb_pins must be 6, 12, 18, 24, or 30"
 msgstr ""
 
+#: shared-module/audioeffects/Echo.c
+msgid "The sample's bits_per_sample does not match the effect's"
+msgstr ""
+
 #: shared-module/audiomixer/MixerVoice.c
 msgid "The sample's bits_per_sample does not match the mixer's"
 msgstr ""
 
+#: shared-module/audioeffects/Echo.c
+msgid "The sample's channel count does not match the effect's"
+msgstr ""
+
 #: shared-module/audiomixer/MixerVoice.c
 msgid "The sample's channel count does not match the mixer's"
 msgstr ""
 
+#: shared-module/audioeffects/Echo.c
+msgid "The sample's sample rate does not match the effect's"
+msgstr ""
+
 #: shared-module/audiomixer/MixerVoice.c
 msgid "The sample's sample rate does not match the mixer's"
 msgstr ""
 
+#: shared-module/audioeffects/Echo.c
+msgid "The sample's signedness does not match the effect's"
+msgstr ""
+
 #: shared-module/audiomixer/MixerVoice.c
 msgid "The sample's signedness does not match the mixer's"
 msgstr ""

ports/raspberrypi/boards/raspberry_pi_pico2/mpconfigboard.mk

@@ -10,4 +10,5 @@ CHIP_FAMILY = rp2
 EXTERNAL_FLASH_DEVICES = "W25Q32JVxQ"
 
 CIRCUITPY__EVE = 1
+CIRCUITPY_AUDIOEFFECTS = 1
 CIRCUITPY_ALARM = 0

shared-module/audioeffects/Echo.c

@@ -31,7 +31,7 @@ void common_hal_audioeffects_echo_construct(audioeffects_echo_obj_t *self, uint3
 
     // calculate buffer size for the set delay
     self->delay_ms = delay_ms;
-    self->echo_buffer_len = self->sample_rate / 1000.0f * self->delay_ms * sizeof(uint32_t);
+    self->echo_buffer_len = self->sample_rate / 1000.0f * self->delay_ms * (self->channel_count * (self->bits_per_sample / 8));
 
     self->echo_buffer = m_malloc(self->echo_buffer_len);
     if (self->echo_buffer == NULL) {
@@ -44,6 +44,12 @@ void common_hal_audioeffects_echo_construct(audioeffects_echo_obj_t *self, uint3
     // write is what we send to the outgoing buffer
     self->echo_buffer_read_pos = self->buffer_len / sizeof(uint32_t);
     self->echo_buffer_write_pos = 0;
+
+    self->sample = NULL;
+    self->sample_remaining_buffer = NULL;
+    self->sample_buffer_length = 0;
+    self->loop = false;
+    self->more_data = false;
 }
 
 bool common_hal_audioeffects_echo_deinited(audioeffects_echo_obj_t *self) {
@@ -68,7 +74,7 @@ uint32_t common_hal_audioeffects_echo_get_delay_ms(audioeffects_echo_obj_t *self
 
 void common_hal_audioeffects_echo_set_delay_ms(audioeffects_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 * sizeof(uint32_t);
+    self->echo_buffer_len = self->sample_rate / 1000.0f * self->delay_ms * (self->channel_count * (self->bits_per_sample / 8));
 
     self->echo_buffer = m_realloc(self->echo_buffer, self->echo_buffer_len);
     if (self->echo_buffer == NULL) {
@@ -118,59 +124,138 @@ bool common_hal_audioeffects_echo_get_playing(audioeffects_echo_obj_t *self) {
 }
 
 void common_hal_audioeffects_echo_play(audioeffects_echo_obj_t *self, mp_obj_t sample, bool loop) {
-    // check buffer size vs our buffer length
+    if (audiosample_sample_rate(sample) != self->sample_rate) {
+        mp_raise_ValueError(MP_ERROR_TEXT("The sample's sample rate does not match the effect's"));
+    }
+    if (audiosample_channel_count(sample) != self->channel_count) {
+        mp_raise_ValueError(MP_ERROR_TEXT("The sample's channel count does not match the effect's"));
+    }
+    if (audiosample_bits_per_sample(sample) != self->bits_per_sample) {
+        mp_raise_ValueError(MP_ERROR_TEXT("The sample's bits_per_sample does not match the effect's"));
+    }
+    bool single_buffer;
+    bool samples_signed;
+    uint32_t max_buffer_length;
+    uint8_t spacing;
+    audiosample_get_buffer_structure(sample, false, &single_buffer, &samples_signed, &max_buffer_length, &spacing);
+    if (samples_signed != self->samples_signed) {
+        mp_raise_ValueError(MP_ERROR_TEXT("The sample's signedness does not match the effect's"));
+    }
     self->sample = sample;
+    self->loop = loop;
+
+    audiosample_reset_buffer(self->sample, false, 0);
+    audioio_get_buffer_result_t result = audiosample_get_buffer(self->sample, false, 0, (uint8_t **)&self->sample_remaining_buffer, &self->sample_buffer_length);
+    // Track length in terms of words.
+    self->sample_buffer_length /= sizeof(uint32_t);
+    self->more_data = result == GET_BUFFER_MORE_DATA;
+
     return;
 }
 
 void common_hal_audioeffects_echo_stop(audioeffects_echo_obj_t *self) {
     self->sample = NULL;
-    memset(self->echo_buffer, 0, self->echo_buffer_len); // clear echo
+    // memset(self->echo_buffer, 0, self->echo_buffer_len); // clear echo
+    // memset(self->buffer, 0, self->buffer_len);
     return;
 }
 
 audioio_get_buffer_result_t audioeffects_echo_get_buffer(audioeffects_echo_obj_t *self, bool single_channel_output, uint8_t channel,
     uint8_t **buffer, uint32_t *buffer_length) {
 
-    *buffer_length = self->buffer_len;
-    *buffer = (uint8_t *)self->buffer;
-
-    if (self->sample == NULL) {
-
-    } else {
-        // Get the sample's buffer
-        uint32_t *sample_buffer;
-        uint32_t sample_buffer_len;
-
-        // audioio_get_buffer_result_t result =
-        audiosample_get_buffer(self->sample, false, 0, (uint8_t **)&sample_buffer, &sample_buffer_len);
-
-        uint32_t n = MIN(sample_buffer_len / sizeof(uint32_t), (self->buffer_len / sizeof(uint32_t)));
-        *buffer_length = n * sizeof(uint32_t);
-
-        uint32_t echo_buf_len = self->echo_buffer_len / sizeof(uint32_t);
-
-        // pass the sample thru to our buffer adding in the echo
-        for (uint32_t i = 0; i < n; i++) {
-            if (self->echo_buffer_read_pos >= echo_buf_len) {
-                self->echo_buffer_read_pos = 0;
+    uint32_t *word_buffer = (uint32_t *)self->buffer;
+    uint32_t length = self->buffer_len / sizeof(uint32_t);
+    uint32_t echo_buf_len = self->echo_buffer_len / sizeof(uint32_t);
+
+    while (length != 0) {
+        if (self->sample_buffer_length == 0) {
+            if (!self->more_data) {
+                if (self->loop) {
+                    if (self->sample) {
+                        audiosample_reset_buffer(self->sample, false, 0);
+                    }
+                } else {
+                    self->sample = NULL;
+                }
+            }
+            if (self->sample) {
+                // Load another buffer
+                audioio_get_buffer_result_t result = audiosample_get_buffer(self->sample, false, 0, (uint8_t **)&self->sample_remaining_buffer, &self->sample_buffer_length);
+                // Track length in terms of words.
+                self->sample_buffer_length /= sizeof(uint32_t);
+                self->more_data = result == GET_BUFFER_MORE_DATA;
             }
-
-            uint32_t echo = self->echo_buffer[self->echo_buffer_read_pos++];
-            self->buffer[i] = add16signed(mult16signed(echo, self->decay), sample_buffer[i]);
         }
 
-        // copy sample buffer to echo buf to play back later
-        // This now includes our current sound + previous echos
-        for (uint32_t i = 0; i < n; i++) {
-            if (self->echo_buffer_write_pos >= echo_buf_len) {
-                self->echo_buffer_write_pos = 0;
+        // If we have no sample keep the echo echoing
+        if (self->sample == NULL) {
+            if (MP_LIKELY(self->bits_per_sample == 16)) {
+                if (MP_LIKELY(self->samples_signed)) {
+                    for (uint32_t i = 0; i < length; i++) {
+                        if (self->echo_buffer_read_pos >= echo_buf_len) {
+                            self->echo_buffer_read_pos = 0;
+                        }
+
+                        uint32_t echo = self->echo_buffer[self->echo_buffer_read_pos++];
+                        word_buffer[i] = mult16signed(echo, self->decay);
+
+                        if (self->echo_buffer_write_pos >= echo_buf_len) {
+                            self->echo_buffer_write_pos = 0;
+                        }
+
+                        self->echo_buffer[self->echo_buffer_write_pos++] = word_buffer[i];
+                    }
+                }
+            }
+            length = 0;
+        } else {
+            uint32_t n = MIN(self->sample_buffer_length, length);
+            uint32_t *sample_src = self->sample_remaining_buffer;
+
+            if (MP_LIKELY(self->bits_per_sample == 16)) {
+                if (MP_LIKELY(self->samples_signed)) {
+                    for (uint32_t i = 0; i < n; i++) {
+                        uint32_t sample_word = sample_src[i];
+                        uint32_t echo = self->echo_buffer[self->echo_buffer_read_pos++];
+                        word_buffer[i] = add16signed(mult16signed(echo, self->decay), sample_word);
+                        self->echo_buffer[self->echo_buffer_write_pos++] = add16signed(sample_word, word_buffer[i]);
+
+                        if (self->echo_buffer_read_pos >= echo_buf_len) {
+                            self->echo_buffer_read_pos = 0;
+                        }
+                        if (self->echo_buffer_write_pos >= echo_buf_len) {
+                            self->echo_buffer_write_pos = 0;
+                        }
+                    }
+                } else {
+                    // for (uint32_t i = 0; i < n; i++) {
+                    // uint32_t sample_word = sample_src[i];
+                    // sample_word = tosigned16(sample_word);
+                    // word_buffer[i] = add16signed(mult16signed(sample_word, self->decay), word_buffer[i]);
+                    // }
+                }
+            } else {
+                // uint16_t *hword_buffer = (uint16_t *)word_buffer;
+                // uint16_t *sample_hsrc = (uint16_t *)sample_src;
+                // for (uint32_t i = 0; i < n * 2; i++) {
+                // uint32_t sample_word = unpack8(sample_hsrc[i]);
+                // if (MP_LIKELY(!self->samples_signed)) {
+                // sample_word = tosigned16(sample_word);
+                // }
+                // sample_word = mult16signed(sample_word, self->decay);
+                // sample_word = add16signed(sample_word, unpack8(hword_buffer[i]));
+                // hword_buffer[i] = pack8(sample_word);
+                // }
             }
 
-            self->echo_buffer[self->echo_buffer_write_pos++] = add16signed(sample_buffer[i], self->buffer[i]);
+            length -= n;
+            word_buffer += n;
+            self->sample_remaining_buffer += n;
+            self->sample_buffer_length -= n;
         }
     }
-
+    *buffer = (uint8_t *)self->buffer;
+    *buffer_length = self->buffer_len;
     return GET_BUFFER_MORE_DATA;
 }
 
@@ -179,11 +264,16 @@ void audioeffects_echo_get_buffer_structure(audioeffects_echo_obj_t *self, bool
 
     if (self->sample != NULL) {
         audiosample_get_buffer_structure(self->sample, single_channel_output, single_buffer, samples_signed, max_buffer_length, spacing);
+        *single_buffer = false;
         *max_buffer_length = self->buffer_len;
     } else {
-        *single_buffer = false;
+        *single_buffer = true;
         *samples_signed = true;
         *max_buffer_length = self->buffer_len;
-        *spacing = 1;
+        if (single_channel_output) {
+            *spacing = self->channel_count;
+        } else {
+            *spacing = 1;
+        }
     }
 }

shared-module/audioeffects/Echo.h

@@ -23,6 +23,12 @@ typedef struct {
     uint32_t *buffer;
     uint32_t buffer_len; // buffer in bytes
 
+    uint32_t *sample_remaining_buffer;
+    uint32_t sample_buffer_length;
+
+    bool loop;
+    bool more_data;
+
     uint32_t *echo_buffer;
     uint32_t echo_buffer_len; // bytes
 

shared-module/audioeffects/effects_utils.h

@@ -56,3 +56,36 @@ static inline uint32_t mult16signed(uint32_t val, int32_t mul) {
     return result;
     #endif
 }
+
+
+static inline uint32_t tounsigned8(uint32_t val) {
+    #if (defined(__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))
+    return __UADD8(val, 0x80808080);
+    #else
+    return val ^ 0x80808080;
+    #endif
+}
+
+static inline uint32_t tounsigned16(uint32_t val) {
+    #if (defined(__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))
+    return __UADD16(val, 0x80008000);
+    #else
+    return val ^ 0x80008000;
+    #endif
+}
+
+static inline uint32_t tosigned16(uint32_t val) {
+    #if (defined(__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))
+    return __UADD16(val, 0x80008000);
+    #else
+    return val ^ 0x80008000;
+    #endif
+}
+
+static inline uint32_t unpack8(uint16_t val) {
+    return ((val & 0xff00) << 16) | ((val & 0x00ff) << 8);
+}
+
+static inline uint32_t pack8(uint32_t val) {
+    return ((val & 0xff000000) >> 16) | ((val & 0xff00) >> 8);
+}