From cf08a1d6be157698385d8ac35bf3e9bd30562a71 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 14 Nov 2023 12:23:14 +1100
Subject: [PATCH 01/50] codal_port/modaudio: Extend AudioFrame constructor to
 take opt size.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 41 +++++++++++++++++++++++++--------------
 src/codal_port/modaudio.h |  7 ++-----
 2 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 5962c22..3415e3d 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -32,6 +32,8 @@
 
 #define audio_source_iter MP_STATE_PORT(audio_source)
 
+#define LOG_AUDIO_CHUNK_SIZE (5)
+#define AUDIO_CHUNK_SIZE (1 << LOG_AUDIO_CHUNK_SIZE)
 #define DEFAULT_SAMPLE_RATE (7812)
 #define BUFFER_EXPANSION (4) // smooth out the samples via linear interpolation
 #define OUT_CHUNK_SIZE (BUFFER_EXPANSION * AUDIO_CHUNK_SIZE)
@@ -46,7 +48,7 @@ static uint8_t audio_output_buffer[OUT_CHUNK_SIZE];
 static volatile audio_output_state_t audio_output_state;
 static volatile bool audio_fetcher_scheduled;
 
-microbit_audio_frame_obj_t *microbit_audio_frame_make_new(void);
+microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size);
 
 static inline bool audio_is_running(void) {
     return audio_source_iter != NULL;
@@ -261,14 +263,21 @@ MP_REGISTER_MODULE(MP_QSTR_audio, audio_module);
 static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
     (void)type_in;
     (void)args;
-    mp_arg_check_num(n_args, n_kw, 0, 0, false);
-    return microbit_audio_frame_make_new();
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
+    size_t size = AUDIO_CHUNK_SIZE;
+    if (n_args == 1) {
+        size = mp_obj_get_int(args[0]);
+        if (size <= 0) {
+            mp_raise_ValueError(MP_ERROR_TEXT("size out of bounds"));
+        }
+    }
+    return microbit_audio_frame_make_new(size);
 }
 
 static mp_obj_t audio_frame_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value_in) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     mp_int_t index = mp_obj_get_int(index_in);
-    if (index < 0 || index >= AUDIO_CHUNK_SIZE) {
+    if (index < 0 || index >= self->size) {
          mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds"));
     }
     if (value_in == MP_OBJ_NULL) {
@@ -288,10 +297,10 @@ static mp_obj_t audio_frame_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t
 }
 
 static mp_obj_t audio_frame_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
-    (void)self_in;
+    microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     switch (op) {
         case MP_UNARY_OP_LEN:
-            return MP_OBJ_NEW_SMALL_INT(32);
+            return MP_OBJ_NEW_SMALL_INT(self->size);
         default:
             return MP_OBJ_NULL; // op not supported
     }
@@ -301,14 +310,15 @@ static mp_int_t audio_frame_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufin
     (void)flags;
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     bufinfo->buf = self->data;
-    bufinfo->len = AUDIO_CHUNK_SIZE;
+    bufinfo->len = self->size;
     bufinfo->typecode = 'b';
     return 0;
 }
 
 static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_t *other, bool add) {
     int mult = add ? 1 : -1;
-    for (int i = 0; i < AUDIO_CHUNK_SIZE; i++) {
+    size_t size = MIN(self->size, other->size);
+    for (int i = 0; i < size; i++) {
         unsigned val = (int)self->data[i] + mult*(other->data[i]-128);
         // Clamp to 0-255
         if (val > 255) {
@@ -319,8 +329,8 @@ static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_
 }
 
 static microbit_audio_frame_obj_t *copy(microbit_audio_frame_obj_t *self) {
-    microbit_audio_frame_obj_t *result = microbit_audio_frame_make_new();
-    for (int i = 0; i < AUDIO_CHUNK_SIZE; i++) {
+    microbit_audio_frame_obj_t *result = microbit_audio_frame_make_new(self->size);
+    for (int i = 0; i < self->size; i++) {
         result->data[i] = self->data[i];
     }
     return result;
@@ -330,7 +340,7 @@ mp_obj_t copyfrom(mp_obj_t self_in, mp_obj_t other) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(other, &bufinfo, MP_BUFFER_READ);
-    uint32_t len = bufinfo.len > AUDIO_CHUNK_SIZE ? AUDIO_CHUNK_SIZE : bufinfo.len;
+    uint32_t len = MIN(bufinfo.len, self->size);
     for (uint32_t i = 0; i < len; i++) {
         self->data[i] = ((uint8_t *)bufinfo.buf)[i];
     }
@@ -367,7 +377,7 @@ int32_t float_to_fixed(float f, uint32_t scale) {
 
 static void mult(microbit_audio_frame_obj_t *self, float f) {
     int scaled = float_to_fixed(f, 15);
-    for (int i = 0; i < AUDIO_CHUNK_SIZE; i++) {
+    for (int i = 0; i < self->size; i++) {
         unsigned val = ((((int)self->data[i]-128) * scaled) >> 15)+128;
         if (val > 255) {
             val = (1-(val>>31))*255;
@@ -419,10 +429,11 @@ MP_DEFINE_CONST_OBJ_TYPE(
     locals_dict, &microbit_audio_frame_locals_dict
     );
 
-microbit_audio_frame_obj_t *microbit_audio_frame_make_new(void) {
-    microbit_audio_frame_obj_t *res = m_new_obj(microbit_audio_frame_obj_t);
+microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size) {
+    microbit_audio_frame_obj_t *res = m_new_obj_var(microbit_audio_frame_obj_t, uint8_t, size);
     res->base.type = &microbit_audio_frame_type;
-    memset(res->data, 128, AUDIO_CHUNK_SIZE);
+    res->size = size;
+    memset(res->data, 128, size);
     return res;
 }
 
diff --git a/src/codal_port/modaudio.h b/src/codal_port/modaudio.h
index 7111715..c454b18 100644
--- a/src/codal_port/modaudio.h
+++ b/src/codal_port/modaudio.h
@@ -29,14 +29,12 @@
 
 #include "py/runtime.h"
 
-#define LOG_AUDIO_CHUNK_SIZE (5)
-#define AUDIO_CHUNK_SIZE (1 << LOG_AUDIO_CHUNK_SIZE)
-
 #define SOUND_EXPR_TOTAL_LENGTH (72)
 
 typedef struct _microbit_audio_frame_obj_t {
     mp_obj_base_t base;
-    uint8_t data[AUDIO_CHUNK_SIZE];
+    size_t size;
+    uint8_t data[];
 } microbit_audio_frame_obj_t;
 
 extern const mp_obj_type_t microbit_audio_frame_type;
@@ -45,7 +43,6 @@ extern const mp_obj_module_t audio_module;
 void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, uint32_t sample_rate);
 void microbit_audio_stop(void);
 bool microbit_audio_is_playing(void);
-microbit_audio_frame_obj_t *microbit_audio_frame_make_new(void);
 
 const char *microbit_soundeffect_get_sound_expr_data(mp_obj_t self_in);
 

From 2119cd92203dc522106794dfaee61d15f307dc87 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 14 Nov 2023 12:25:29 +1100
Subject: [PATCH 02/50] codal_port/modaudio: Rework audio playing to play a
 long AudioFrame.

- Audio playback now supports AudioFrames with arbitrary size.
- Allows passing a single AudioFrame to audio.play.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_app/microbithal.h         |   7 +-
 src/codal_app/microbithal_audio.cpp |  28 ++++---
 src/codal_port/modaudio.c           | 125 ++++++++++++++++++----------
 3 files changed, 103 insertions(+), 57 deletions(-)

diff --git a/src/codal_app/microbithal.h b/src/codal_app/microbithal.h
index 78d455f..28e77c8 100644
--- a/src/codal_app/microbithal.h
+++ b/src/codal_app/microbithal.h
@@ -185,9 +185,10 @@ bool microbit_hal_audio_is_expression_active(void);
 void microbit_hal_audio_play_expression(const char *expr);
 void microbit_hal_audio_stop_expression(void);
 
-void microbit_hal_audio_init(uint32_t sample_rate);
-void microbit_hal_audio_write_data(const uint8_t *buf, size_t num_samples);
-void microbit_hal_audio_ready_callback(void);
+void microbit_hal_audio_raw_init(uint32_t sample_rate);
+void microbit_hal_audio_raw_set_rate(uint32_t sample_rate);
+void microbit_hal_audio_raw_write_data(const uint8_t *buf, size_t num_samples);
+void microbit_hal_audio_raw_ready_callback(void);
 
 void microbit_hal_audio_speech_init(uint32_t sample_rate);
 void microbit_hal_audio_speech_write_data(const uint8_t *buf, size_t num_samples);
diff --git a/src/codal_app/microbithal_audio.cpp b/src/codal_app/microbithal_audio.cpp
index d27b429..0810434 100644
--- a/src/codal_app/microbithal_audio.cpp
+++ b/src/codal_app/microbithal_audio.cpp
@@ -53,7 +53,7 @@ class AudioSource : public DataSource {
     }
 };
 
-static AudioSource data_source;
+static AudioSource raw_source;
 static AudioSource speech_source;
 
 extern "C" {
@@ -105,23 +105,27 @@ void microbit_hal_audio_stop_expression(void) {
     uBit.audio.soundExpressions.stop();
 }
 
-void microbit_hal_audio_init(uint32_t sample_rate) {
-    if (!data_source.started) {
+void microbit_hal_audio_raw_init(uint32_t sample_rate) {
+    if (!raw_source.started) {
         MicroBitAudio::requestActivation();
-        data_source.started = true;
-        data_source.callback = microbit_hal_audio_ready_callback;
-        data_source.channel = uBit.audio.mixer.addChannel(data_source, sample_rate, 255);
+        raw_source.started = true;
+        raw_source.callback = microbit_hal_audio_raw_ready_callback;
+        raw_source.channel = uBit.audio.mixer.addChannel(raw_source, sample_rate, 255);
     } else {
-        data_source.channel->setSampleRate(sample_rate);
+        raw_source.channel->setSampleRate(sample_rate);
     }
 }
 
-void microbit_hal_audio_write_data(const uint8_t *buf, size_t num_samples) {
-    if ((size_t)data_source.buf.length() != num_samples) {
-        data_source.buf = ManagedBuffer(num_samples);
+void microbit_hal_audio_raw_set_rate(uint32_t sample_rate) {
+    raw_source.channel->setSampleRate(sample_rate);
+}
+
+void microbit_hal_audio_raw_write_data(const uint8_t *buf, size_t num_samples) {
+    if ((size_t)raw_source.buf.length() != num_samples) {
+        raw_source.buf = ManagedBuffer(num_samples);
     }
-    memcpy(data_source.buf.getBytes(), buf, num_samples);
-    data_source.sink->pullRequest();
+    memcpy(raw_source.buf.getBytes(), buf, num_samples);
+    raw_source.sink->pullRequest();
 }
 
 void microbit_hal_audio_speech_init(uint32_t sample_rate) {
diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 3415e3d..9a03a43 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -30,7 +30,9 @@
 #include "modaudio.h"
 #include "modmicrobit.h"
 
-#define audio_source_iter MP_STATE_PORT(audio_source)
+// Convenience macros to access the root-pointer state.
+#define audio_source_frame MP_STATE_PORT(audio_source_frame_state)
+#define audio_source_iter MP_STATE_PORT(audio_source_iter_state)
 
 #define LOG_AUDIO_CHUNK_SIZE (5)
 #define AUDIO_CHUNK_SIZE (1 << LOG_AUDIO_CHUNK_SIZE)
@@ -47,15 +49,18 @@ typedef enum {
 static uint8_t audio_output_buffer[OUT_CHUNK_SIZE];
 static volatile audio_output_state_t audio_output_state;
 static volatile bool audio_fetcher_scheduled;
+static size_t audio_raw_offset;
 
 microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size);
 
 static inline bool audio_is_running(void) {
-    return audio_source_iter != NULL;
+    return audio_source_frame != NULL || audio_source_iter != MP_OBJ_NULL;
 }
 
 void microbit_audio_stop(void) {
+    audio_source_frame = NULL;
     audio_source_iter = NULL;
+    audio_raw_offset = 0;
     microbit_hal_audio_stop_expression();
 }
 
@@ -65,50 +70,77 @@ static void audio_buffer_ready(void) {
     audio_output_state = AUDIO_OUTPUT_STATE_DATA_READY;
     MICROPY_END_ATOMIC_SECTION(atomic_state);
     if (old_state == AUDIO_OUTPUT_STATE_IDLE) {
-        microbit_hal_audio_ready_callback();
+        microbit_hal_audio_raw_ready_callback();
     }
 }
 
 static void audio_data_fetcher(void) {
     audio_fetcher_scheduled = false;
-    if (audio_source_iter == NULL) {
-        return;
-    }
-    mp_obj_t buffer_obj;
-    nlr_buf_t nlr;
-    if (nlr_push(&nlr) == 0) {
-        buffer_obj = mp_iternext_allow_raise(audio_source_iter);
-        nlr_pop();
-    } else {
-        if (!mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type),
-            MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
-            mp_sched_exception(MP_OBJ_FROM_PTR(nlr.ret_val));
+
+    if (audio_source_frame != NULL) {
+        // An existing AudioFrame is being played, see if there's any data left.
+        if (audio_raw_offset >= audio_source_frame->size) {
+            // AudioFrame is exhausted.
+            audio_source_frame = NULL;
         }
-        buffer_obj = MP_OBJ_STOP_ITERATION;
     }
-    if (buffer_obj == MP_OBJ_STOP_ITERATION) {
-        // End of audio iterator
-        microbit_audio_stop();
-    } else if (mp_obj_get_type(buffer_obj) != &microbit_audio_frame_type) {
-        // Audio iterator did not return an AudioFrame
-        microbit_audio_stop();
-        mp_sched_exception(mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("not an AudioFrame")));
-    } else {
-        microbit_audio_frame_obj_t *buffer = (microbit_audio_frame_obj_t *)buffer_obj;
-        uint8_t *dest = &audio_output_buffer[0];
-        uint32_t last = dest[BUFFER_EXPANSION * AUDIO_CHUNK_SIZE - 1];
-        for (int i = 0; i < AUDIO_CHUNK_SIZE; ++i) {
-            uint32_t cur = buffer->data[i];
-            for (int j = 0; j < BUFFER_EXPANSION; ++j) {
-                // Get next sample with linear interpolation.
-                uint32_t sample = ((BUFFER_EXPANSION - 1 - j) * last + (j + 1) * cur) / BUFFER_EXPANSION;
-                // Write sample to the buffer.
-                *dest++ = sample;
+
+    if (audio_source_frame == NULL) {
+        // There is no AudioFrame, so try to get one from the audio iterator.
+
+        if (audio_source_iter == MP_OBJ_NULL) {
+            // Audio iterator is already exhausted.
+            microbit_audio_stop();
+            return;
+        }
+
+        // Get the next item from the audio iterator.
+        nlr_buf_t nlr;
+        mp_obj_t frame_obj;
+        if (nlr_push(&nlr) == 0) {
+            frame_obj = mp_iternext_allow_raise(audio_source_iter);
+            nlr_pop();
+        } else {
+            if (!mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type),
+                MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
+                mp_sched_exception(MP_OBJ_FROM_PTR(nlr.ret_val));
             }
-            last = cur;
+            frame_obj = MP_OBJ_STOP_ITERATION;
+        }
+        if (frame_obj == MP_OBJ_STOP_ITERATION) {
+            // End of audio iterator.
+            microbit_audio_stop();
+            return;
+        }
+        if (!mp_obj_is_type(frame_obj, &microbit_audio_frame_type)) {
+            // Audio iterator did not return an AudioFrame.
+            microbit_audio_stop();
+            mp_sched_exception(mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("not an AudioFrame")));
+            return;
         }
-        audio_buffer_ready();
+
+        // We have the next AudioFrame.
+        audio_source_frame = MP_OBJ_TO_PTR(frame_obj);
+        audio_raw_offset = 0;
     }
+
+    const uint8_t *src = &audio_source_frame->data[audio_raw_offset];
+    audio_raw_offset += AUDIO_CHUNK_SIZE;
+
+    uint8_t *dest = &audio_output_buffer[0];
+    uint32_t last = dest[OUT_CHUNK_SIZE - 1];
+    for (int i = 0; i < AUDIO_CHUNK_SIZE; ++i) {
+        uint32_t cur = src[i];
+        for (int j = 0; j < BUFFER_EXPANSION; ++j) {
+            // Get next sample with linear interpolation.
+            uint32_t sample = ((BUFFER_EXPANSION - 1 - j) * last + (j + 1) * cur) / BUFFER_EXPANSION;
+            // Write sample to the buffer.
+            *dest++ = sample;
+        }
+        last = cur;
+    }
+
+    audio_buffer_ready();
 }
 
 static mp_obj_t audio_data_fetcher_wrapper(mp_obj_t arg) {
@@ -117,10 +149,10 @@ static mp_obj_t audio_data_fetcher_wrapper(mp_obj_t arg) {
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(audio_data_fetcher_wrapper_obj, audio_data_fetcher_wrapper);
 
-void microbit_hal_audio_ready_callback(void) {
+void microbit_hal_audio_raw_ready_callback(void) {
     if (audio_output_state == AUDIO_OUTPUT_STATE_DATA_READY) {
         // there is data ready to send out to the audio pipeline, so send it
-        microbit_hal_audio_write_data(&audio_output_buffer[0], OUT_CHUNK_SIZE);
+        microbit_hal_audio_raw_write_data(&audio_output_buffer[0], OUT_CHUNK_SIZE);
         audio_output_state = AUDIO_OUTPUT_STATE_DATA_WRITTEN;
     } else {
         // no data ready, need to call this function later when data is ready
@@ -135,7 +167,7 @@ void microbit_hal_audio_ready_callback(void) {
 static void audio_init(uint32_t sample_rate) {
     audio_fetcher_scheduled = false;
     audio_output_state = AUDIO_OUTPUT_STATE_IDLE;
-    microbit_hal_audio_init(BUFFER_EXPANSION * sample_rate);
+    microbit_hal_audio_raw_init(BUFFER_EXPANSION * sample_rate);
 }
 
 void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, uint32_t sample_rate) {
@@ -151,6 +183,9 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
         sound_expr_data = sound->name;
     } else if (mp_obj_is_type(src, &microbit_soundeffect_type)) {
         sound_expr_data = microbit_soundeffect_get_sound_expr_data(src);
+    } else if (mp_obj_is_type(src, &microbit_audio_frame_type)) {
+        audio_source_frame = MP_OBJ_TO_PTR(src);
+        audio_raw_offset = 0;
     } else if (mp_obj_is_type(src, &mp_type_tuple) || mp_obj_is_type(src, &mp_type_list)) {
         // A tuple/list passed in.  Need to check if it contains SoundEffect instances.
         size_t len;
@@ -168,7 +203,13 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
             }
             // Replace last "," with a string null terminator.
             data[-1] = '\0';
+        } else {
+            // A tuple/list of AudioFrame instances.
+            audio_source_iter = mp_getiter(src, NULL);
         }
+    } else {
+        // An iterator of AudioFrame instances.
+        audio_source_iter = mp_getiter(src, NULL);
     }
 
     if (sound_expr_data != NULL) {
@@ -191,9 +232,8 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
         return;
     }
 
-    // Get the iterator and start the audio running.
+    // Start the audio running.
     // The scheduler must be locked because audio_data_fetcher() can also be called from the scheduler.
-    audio_source_iter = mp_getiter(src, NULL);
     mp_sched_lock();
     audio_data_fetcher();
     mp_sched_unlock();
@@ -437,4 +477,5 @@ microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size) {
     return res;
 }
 
-MP_REGISTER_ROOT_POINTER(void *audio_source);
+MP_REGISTER_ROOT_POINTER(struct _microbit_audio_frame_obj_t *audio_source_frame_state);
+MP_REGISTER_ROOT_POINTER(mp_obj_t audio_source_iter_state);

From 1dc4c1243674ff3d4539ceed320c54a13d618023 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 14 Nov 2023 12:28:09 +1100
Subject: [PATCH 03/50] codal_port/modaudio: Remove buffer expansion.

Playing generated samples (eg from v1 code) now sounds better without
buffer expansion.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 9a03a43..a4570aa 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -37,8 +37,6 @@
 #define LOG_AUDIO_CHUNK_SIZE (5)
 #define AUDIO_CHUNK_SIZE (1 << LOG_AUDIO_CHUNK_SIZE)
 #define DEFAULT_SAMPLE_RATE (7812)
-#define BUFFER_EXPANSION (4) // smooth out the samples via linear interpolation
-#define OUT_CHUNK_SIZE (BUFFER_EXPANSION * AUDIO_CHUNK_SIZE)
 
 typedef enum {
     AUDIO_OUTPUT_STATE_IDLE,
@@ -46,7 +44,7 @@ typedef enum {
     AUDIO_OUTPUT_STATE_DATA_WRITTEN,
 } audio_output_state_t;
 
-static uint8_t audio_output_buffer[OUT_CHUNK_SIZE];
+static uint8_t audio_output_buffer[AUDIO_CHUNK_SIZE];
 static volatile audio_output_state_t audio_output_state;
 static volatile bool audio_fetcher_scheduled;
 static size_t audio_raw_offset;
@@ -128,16 +126,9 @@ static void audio_data_fetcher(void) {
     audio_raw_offset += AUDIO_CHUNK_SIZE;
 
     uint8_t *dest = &audio_output_buffer[0];
-    uint32_t last = dest[OUT_CHUNK_SIZE - 1];
     for (int i = 0; i < AUDIO_CHUNK_SIZE; ++i) {
-        uint32_t cur = src[i];
-        for (int j = 0; j < BUFFER_EXPANSION; ++j) {
-            // Get next sample with linear interpolation.
-            uint32_t sample = ((BUFFER_EXPANSION - 1 - j) * last + (j + 1) * cur) / BUFFER_EXPANSION;
-            // Write sample to the buffer.
-            *dest++ = sample;
-        }
-        last = cur;
+        // Copy sample to the buffer.
+        *dest++ = src[i];
     }
 
     audio_buffer_ready();
@@ -152,7 +143,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(audio_data_fetcher_wrapper_obj, audio_data_fetc
 void microbit_hal_audio_raw_ready_callback(void) {
     if (audio_output_state == AUDIO_OUTPUT_STATE_DATA_READY) {
         // there is data ready to send out to the audio pipeline, so send it
-        microbit_hal_audio_raw_write_data(&audio_output_buffer[0], OUT_CHUNK_SIZE);
+        microbit_hal_audio_raw_write_data(&audio_output_buffer[0], AUDIO_CHUNK_SIZE);
         audio_output_state = AUDIO_OUTPUT_STATE_DATA_WRITTEN;
     } else {
         // no data ready, need to call this function later when data is ready
@@ -167,7 +158,7 @@ void microbit_hal_audio_raw_ready_callback(void) {
 static void audio_init(uint32_t sample_rate) {
     audio_fetcher_scheduled = false;
     audio_output_state = AUDIO_OUTPUT_STATE_IDLE;
-    microbit_hal_audio_raw_init(BUFFER_EXPANSION * sample_rate);
+    microbit_hal_audio_raw_init(sample_rate);
 }
 
 void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, uint32_t sample_rate) {

From 07190d511a3d575de18d8a6d72df83982e696884 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 14 Nov 2023 12:28:44 +1100
Subject: [PATCH 04/50] codal_app: Add microphone recording interface.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_app/microbithal.h              |  3 +
 src/codal_app/microbithal_microphone.cpp | 89 ++++++++++++++++++++++++
 2 files changed, 92 insertions(+)

diff --git a/src/codal_app/microbithal.h b/src/codal_app/microbithal.h
index 28e77c8..1ad7c2a 100644
--- a/src/codal_app/microbithal.h
+++ b/src/codal_app/microbithal.h
@@ -168,6 +168,9 @@ void microbit_hal_microphone_init(void);
 void microbit_hal_microphone_set_threshold(int kind, int value);
 int microbit_hal_microphone_get_level(void);
 float microbit_hal_microphone_get_level_db(void);
+void microbit_hal_microphone_start_recording(uint8_t *buf, size_t len, int rate);
+bool microbit_hal_microphone_is_recording(void);
+void microbit_hal_microphone_stop_recording(void);
 
 const uint8_t *microbit_hal_get_font_data(char c);
 
diff --git a/src/codal_app/microbithal_microphone.cpp b/src/codal_app/microbithal_microphone.cpp
index e530432..ce2eece 100644
--- a/src/codal_app/microbithal_microphone.cpp
+++ b/src/codal_app/microbithal_microphone.cpp
@@ -28,12 +28,63 @@
 #include "microbithal.h"
 #include "MicroBitDevice.h"
 
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
 extern "C" void microbit_hal_level_detector_callback(int);
 
 static void level_detector_event_handler(Event evt) {
     microbit_hal_level_detector_callback(evt.value);
 }
 
+class MyStreamRecording : public DataSink
+{
+    public:
+    DataSource &upStream;
+
+    public:
+    uint8_t *dest;
+    size_t dest_pos;
+    size_t dest_max;
+    bool request_stop;
+
+    MyStreamRecording(DataSource &source);
+    virtual ~MyStreamRecording();
+
+    virtual int pullRequest();
+};
+
+MyStreamRecording::MyStreamRecording( DataSource &source ) : upStream( source )
+{
+}
+
+MyStreamRecording::~MyStreamRecording()
+{
+}
+
+int MyStreamRecording::pullRequest()
+{
+    ManagedBuffer data = this->upStream.pull();
+
+    size_t n = MIN((size_t)data.length(), this->dest_max - this->dest_pos);
+    if (n == 0 || this->request_stop) {
+        this->upStream.disconnect();
+        this->request_stop = false;
+    } else {
+        // Copy and convert signed 8-bit to unsigned 8-bit data.
+        const uint8_t *src = data.getBytes();
+        uint8_t *dest = this->dest + this->dest_pos;
+        for (size_t i = 0; i < n; ++i) {
+            *dest++ = *src++ + 128;
+        }
+        this->dest_pos += n;
+    }
+
+    return DEVICE_OK;
+}
+
+static MyStreamRecording *recording = NULL;
+static SplitterChannel *splitterChannel = NULL;
+
 extern "C" {
 
 static bool microphone_init_done = false;
@@ -66,4 +117,42 @@ float microbit_hal_microphone_get_level_db(void) {
     return value;
 }
 
+void microbit_hal_microphone_start_recording(uint8_t *buf, size_t len, int rate) {
+    if (splitterChannel == NULL) {
+        splitterChannel = uBit.audio.splitter->createChannel();
+        splitterChannel->setFormat(DATASTREAM_FORMAT_8BIT_UNSIGNED);
+        // Increase sample period to 64us, so we can get our desired rate.
+        splitterChannel->requestSampleRate(1000000 / 64);
+    }
+    splitterChannel->requestSampleRate(rate);
+
+    if (recording == NULL) {
+        recording = new MyStreamRecording(*splitterChannel);
+    } else {
+        if (microbit_hal_microphone_is_recording()) {
+            microbit_hal_microphone_stop_recording();
+            while (microbit_hal_microphone_is_recording()) {
+                microbit_hal_idle();
+            }
+        }
+    }
+
+    recording->dest = buf;
+    recording->dest_pos = 0;
+    recording->dest_max = len;
+    recording->request_stop = false;
+
+    splitterChannel->connect(*recording);
+}
+
+bool microbit_hal_microphone_is_recording(void) {
+    return recording != NULL && splitterChannel->isConnected();
+}
+
+void microbit_hal_microphone_stop_recording(void) {
+    if (recording != NULL) {
+        recording->request_stop = true;
+    }
+}
+
 }

From edfa023cd2f498b4576ed36b633b05fc461cc8f4 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 14 Nov 2023 12:28:55 +1100
Subject: [PATCH 05/50] codal_port/microbit_microphone: Add methods to record.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_microphone.c | 74 ++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/src/codal_port/microbit_microphone.c b/src/codal_port/microbit_microphone.c
index cf37069..26c137f 100644
--- a/src/codal_port/microbit_microphone.c
+++ b/src/codal_port/microbit_microphone.c
@@ -26,6 +26,7 @@
 
 #include "py/runtime.h"
 #include "py/mphal.h"
+#include "modaudio.h"
 #include "modmicrobit.h"
 
 #define EVENT_HISTORY_SIZE (8)
@@ -158,6 +159,75 @@ static mp_obj_t microbit_microphone_get_events(mp_obj_t self_in) {
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(microbit_microphone_get_events_obj, microbit_microphone_get_events);
 
+static void microbit_microphone_record_helper(microbit_audio_frame_obj_t *audio_frame, int rate, bool wait) {
+    // Start the recording.
+    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, rate);
+
+    if (wait) {
+        // Wait for the recording to finish.
+        while (microbit_hal_microphone_is_recording()) {
+            mp_handle_pending(true);
+            microbit_hal_idle();
+        }
+    }
+}
+
+static mp_obj_t microbit_microphone_record(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_duration, ARG_rate, };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_duration, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_rate, MP_ARG_INT, {.u_int = 7812} },
+    };
+
+    // Parse the args.
+    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);
+
+    // Create the AudioFrame to record into.
+    size_t size = args[ARG_duration].u_int * args[ARG_rate].u_int / 1000;
+    microbit_audio_frame_obj_t *audio_frame = microbit_audio_frame_make_new(size);
+
+    microbit_microphone_record_helper(audio_frame, args[ARG_rate].u_int, true);
+
+    // Return the new AudioFrame.
+    return MP_OBJ_FROM_PTR(audio_frame);
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(microbit_microphone_record_obj, 1, microbit_microphone_record);
+
+static mp_obj_t microbit_microphone_record_into(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_buffer, ARG_rate, ARG_wait, };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_rate, MP_ARG_INT, {.u_int = 7812} },
+        { MP_QSTR_wait, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
+    };
+
+    // Parse the args.
+    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_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[ARG_buffer].u_obj, &bufinfo, MP_BUFFER_READ);
+
+    microbit_hal_microphone_start_recording(bufinfo.buf, bufinfo.len, args[ARG_rate].u_int);
+
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(microbit_microphone_record_into_obj, 1, microbit_microphone_record_into);
+
+static mp_obj_t microbit_microphone_is_recording(mp_obj_t self_in) {
+    (void)self_in;
+    return mp_obj_new_bool(microbit_hal_microphone_is_recording());
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(microbit_microphone_is_recording_obj, microbit_microphone_is_recording);
+
+static mp_obj_t microbit_microphone_stop_recording(mp_obj_t self_in) {
+    (void)self_in;
+    microbit_hal_microphone_stop_recording();
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(microbit_microphone_stop_recording_obj, microbit_microphone_stop_recording);
+
 static const mp_rom_map_elem_t microbit_microphone_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_set_threshold), MP_ROM_PTR(&microbit_microphone_set_threshold_obj) },
     { MP_ROM_QSTR(MP_QSTR_sound_level), MP_ROM_PTR(&microbit_microphone_sound_level_obj) },
@@ -166,6 +236,10 @@ static const mp_rom_map_elem_t microbit_microphone_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_is_event), MP_ROM_PTR(&microbit_microphone_is_event_obj) },
     { MP_ROM_QSTR(MP_QSTR_was_event), MP_ROM_PTR(&microbit_microphone_was_event_obj) },
     { MP_ROM_QSTR(MP_QSTR_get_events), MP_ROM_PTR(&microbit_microphone_get_events_obj) },
+    { MP_ROM_QSTR(MP_QSTR_record), MP_ROM_PTR(&microbit_microphone_record_obj) },
+    { MP_ROM_QSTR(MP_QSTR_record_into), MP_ROM_PTR(&microbit_microphone_record_into_obj) },
+    { MP_ROM_QSTR(MP_QSTR_is_recording), MP_ROM_PTR(&microbit_microphone_is_recording_obj) },
+    { MP_ROM_QSTR(MP_QSTR_stop_recording), MP_ROM_PTR(&microbit_microphone_stop_recording_obj) },
 };
 static MP_DEFINE_CONST_DICT(microbit_microphone_locals_dict, microbit_microphone_locals_dict_table);
 

From 7e3b1027fb53ffa087664a675b91a1ade6070acd Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 14 Nov 2023 12:14:42 +1100
Subject: [PATCH 06/50] codal_port/modaudio: Add audio.sound_level() method.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index a4570aa..0eff183 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -48,6 +48,7 @@ static uint8_t audio_output_buffer[AUDIO_CHUNK_SIZE];
 static volatile audio_output_state_t audio_output_state;
 static volatile bool audio_fetcher_scheduled;
 static size_t audio_raw_offset;
+static uint32_t audio_current_sound_level;
 
 microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size);
 
@@ -59,6 +60,7 @@ void microbit_audio_stop(void) {
     audio_source_frame = NULL;
     audio_source_iter = NULL;
     audio_raw_offset = 0;
+    audio_current_sound_level = 0;
     microbit_hal_audio_stop_expression();
 }
 
@@ -126,10 +128,14 @@ static void audio_data_fetcher(void) {
     audio_raw_offset += AUDIO_CHUNK_SIZE;
 
     uint8_t *dest = &audio_output_buffer[0];
+    uint32_t sound_level = 0;
     for (int i = 0; i < AUDIO_CHUNK_SIZE; ++i) {
         // Copy sample to the buffer.
         *dest++ = src[i];
+        // Compute the sound level.
+        sound_level += (src[i] - 128) * (src[i] - 128);
     }
+    audio_current_sound_level = sound_level / AUDIO_CHUNK_SIZE / AUDIO_CHUNK_SIZE;
 
     audio_buffer_ready();
 }
@@ -271,11 +277,17 @@ mp_obj_t is_playing(void) {
 }
 MP_DEFINE_CONST_FUN_OBJ_0(microbit_audio_is_playing_obj, is_playing);
 
+static mp_obj_t microbit_audio_sound_level(void) {
+    return MP_OBJ_NEW_SMALL_INT(audio_current_sound_level);
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(microbit_audio_sound_level_obj, microbit_audio_sound_level);
+
 static const mp_rom_map_elem_t audio_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_audio) },
     { MP_ROM_QSTR(MP_QSTR_stop), MP_ROM_PTR(&microbit_audio_stop_obj) },
     { MP_ROM_QSTR(MP_QSTR_play), MP_ROM_PTR(&microbit_audio_play_obj) },
     { MP_ROM_QSTR(MP_QSTR_is_playing), MP_ROM_PTR(&microbit_audio_is_playing_obj) },
+    { MP_ROM_QSTR(MP_QSTR_sound_level), MP_ROM_PTR(&microbit_audio_sound_level_obj) },
     { MP_ROM_QSTR(MP_QSTR_AudioFrame), MP_ROM_PTR(&microbit_audio_frame_type) },
     { MP_ROM_QSTR(MP_QSTR_SoundEffect), MP_ROM_PTR(&microbit_soundeffect_type) },
 };

From c487a388f84e74d87c896bf79f8623e51f3e5690 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 14 Nov 2023 12:40:26 +1100
Subject: [PATCH 07/50] src: Add test recording program.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/test_record.py | 57 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 src/test_record.py

diff --git a/src/test_record.py b/src/test_record.py
new file mode 100644
index 0000000..656ef28
--- /dev/null
+++ b/src/test_record.py
@@ -0,0 +1,57 @@
+from microbit import *
+
+mouth_open = Image(
+    "09090:"
+    "00000:"
+    "09990:"
+    "90009:"
+    "09990"
+)
+mouth_closed = Image(
+    "09090:"
+    "00000:"
+    "00000:"
+    "99999:"
+    "00000"
+)
+play = Image(
+    "00000:"
+    "04740:"
+    "07970:"
+    "04740:"
+    "00000"
+)
+
+RECORDING_RATE = 7812
+RECORDING_SECONDS = 5
+RECORDING_SIZE = RECORDING_RATE * RECORDING_SECONDS
+
+my_recording = audio.AudioFrame(RECORDING_SIZE)
+
+while True:
+    if button_a.is_pressed():
+        microphone.record_into(my_recording, rate=RECORDING_RATE, wait=False)
+        display.show([mouth_open, mouth_closed], loop=True, wait=False, delay=150)
+        while button_a.is_pressed() and microphone.is_recording():
+            sleep(50)
+        microphone.stop_recording()
+        display.show(mouth_closed)
+        while button_a.is_pressed():
+            sleep(50)
+        display.clear()
+        my_recording *= 5
+    if button_b.is_pressed():
+        audio.play(my_recording, wait=False)
+        level = 0
+        while audio.is_playing():
+            l = audio.sound_level()
+            if l > level:
+                level = l
+            else:
+                level *= 0.95
+            display.show(play * min(1, level / 100))
+            x = accelerometer.get_x()
+            audio.set_rate(max(2250, scale(x, (-1000, 1000), (2250, 13374))))
+            sleep(5)
+        display.clear()
+    sleep(100)

From 30ef534a0de96a941db5bf979e6de11c7c2d1cce Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 15 Jan 2024 16:49:32 +1100
Subject: [PATCH 08/50] codal_port/modaudio: Rename "size" field to
 "alloc_size".

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 20 ++++++++++----------
 src/codal_port/modaudio.h |  2 +-
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 0eff183..1a3ed6e 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -79,7 +79,7 @@ static void audio_data_fetcher(void) {
 
     if (audio_source_frame != NULL) {
         // An existing AudioFrame is being played, see if there's any data left.
-        if (audio_raw_offset >= audio_source_frame->size) {
+        if (audio_raw_offset >= audio_source_frame->alloc_size) {
             // AudioFrame is exhausted.
             audio_source_frame = NULL;
         }
@@ -320,7 +320,7 @@ static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, mp_uint_t
 static mp_obj_t audio_frame_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value_in) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     mp_int_t index = mp_obj_get_int(index_in);
-    if (index < 0 || index >= self->size) {
+    if (index < 0 || index >= self->alloc_size) {
          mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds"));
     }
     if (value_in == MP_OBJ_NULL) {
@@ -343,7 +343,7 @@ static mp_obj_t audio_frame_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     switch (op) {
         case MP_UNARY_OP_LEN:
-            return MP_OBJ_NEW_SMALL_INT(self->size);
+            return MP_OBJ_NEW_SMALL_INT(self->alloc_size);
         default:
             return MP_OBJ_NULL; // op not supported
     }
@@ -353,14 +353,14 @@ static mp_int_t audio_frame_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufin
     (void)flags;
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     bufinfo->buf = self->data;
-    bufinfo->len = self->size;
+    bufinfo->len = self->alloc_size;
     bufinfo->typecode = 'b';
     return 0;
 }
 
 static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_t *other, bool add) {
     int mult = add ? 1 : -1;
-    size_t size = MIN(self->size, other->size);
+    size_t size = MIN(self->alloc_size, other->alloc_size);
     for (int i = 0; i < size; i++) {
         unsigned val = (int)self->data[i] + mult*(other->data[i]-128);
         // Clamp to 0-255
@@ -372,8 +372,8 @@ static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_
 }
 
 static microbit_audio_frame_obj_t *copy(microbit_audio_frame_obj_t *self) {
-    microbit_audio_frame_obj_t *result = microbit_audio_frame_make_new(self->size);
-    for (int i = 0; i < self->size; i++) {
+    microbit_audio_frame_obj_t *result = microbit_audio_frame_make_new(self->alloc_size);
+    for (int i = 0; i < self->alloc_size; i++) {
         result->data[i] = self->data[i];
     }
     return result;
@@ -383,7 +383,7 @@ mp_obj_t copyfrom(mp_obj_t self_in, mp_obj_t other) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(other, &bufinfo, MP_BUFFER_READ);
-    uint32_t len = MIN(bufinfo.len, self->size);
+    uint32_t len = MIN(bufinfo.len, self->alloc_size);
     for (uint32_t i = 0; i < len; i++) {
         self->data[i] = ((uint8_t *)bufinfo.buf)[i];
     }
@@ -420,7 +420,7 @@ int32_t float_to_fixed(float f, uint32_t scale) {
 
 static void mult(microbit_audio_frame_obj_t *self, float f) {
     int scaled = float_to_fixed(f, 15);
-    for (int i = 0; i < self->size; i++) {
+    for (int i = 0; i < self->alloc_size; i++) {
         unsigned val = ((((int)self->data[i]-128) * scaled) >> 15)+128;
         if (val > 255) {
             val = (1-(val>>31))*255;
@@ -475,7 +475,7 @@ MP_DEFINE_CONST_OBJ_TYPE(
 microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size) {
     microbit_audio_frame_obj_t *res = m_new_obj_var(microbit_audio_frame_obj_t, uint8_t, size);
     res->base.type = &microbit_audio_frame_type;
-    res->size = size;
+    res->alloc_size = size;
     memset(res->data, 128, size);
     return res;
 }
diff --git a/src/codal_port/modaudio.h b/src/codal_port/modaudio.h
index c454b18..b0145c4 100644
--- a/src/codal_port/modaudio.h
+++ b/src/codal_port/modaudio.h
@@ -33,7 +33,7 @@
 
 typedef struct _microbit_audio_frame_obj_t {
     mp_obj_base_t base;
-    size_t size;
+    size_t alloc_size;
     uint8_t data[];
 } microbit_audio_frame_obj_t;
 

From affdb0ac470eb36f34c7451d7283c358404b251f Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 15 Jan 2024 16:45:30 +1100
Subject: [PATCH 09/50] codal_port/modaudio: Make AudioFrame constructor
 public.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 2 --
 src/codal_port/modaudio.h | 2 ++
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 1a3ed6e..71c717f 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -50,8 +50,6 @@ static volatile bool audio_fetcher_scheduled;
 static size_t audio_raw_offset;
 static uint32_t audio_current_sound_level;
 
-microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size);
-
 static inline bool audio_is_running(void) {
     return audio_source_frame != NULL || audio_source_iter != MP_OBJ_NULL;
 }
diff --git a/src/codal_port/modaudio.h b/src/codal_port/modaudio.h
index b0145c4..f40c61d 100644
--- a/src/codal_port/modaudio.h
+++ b/src/codal_port/modaudio.h
@@ -44,6 +44,8 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
 void microbit_audio_stop(void);
 bool microbit_audio_is_playing(void);
 
+microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size);
+
 const char *microbit_soundeffect_get_sound_expr_data(mp_obj_t self_in);
 
 #endif // MICROPY_INCLUDED_MICROBIT_MODAUDIO_H

From 8ae75da6b18ee086d0cde1a63b4f2edb9819d459 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 15 Jan 2024 17:14:44 +1100
Subject: [PATCH 10/50] codal_app/microbithal_microphone: Store the current
 recording length.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_app/microbithal.h              |  2 +-
 src/codal_app/microbithal_microphone.cpp | 15 ++++++++-------
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/codal_app/microbithal.h b/src/codal_app/microbithal.h
index 1ad7c2a..d91e6b8 100644
--- a/src/codal_app/microbithal.h
+++ b/src/codal_app/microbithal.h
@@ -168,7 +168,7 @@ void microbit_hal_microphone_init(void);
 void microbit_hal_microphone_set_threshold(int kind, int value);
 int microbit_hal_microphone_get_level(void);
 float microbit_hal_microphone_get_level_db(void);
-void microbit_hal_microphone_start_recording(uint8_t *buf, size_t len, int rate);
+void microbit_hal_microphone_start_recording(uint8_t *buf, size_t max_len, size_t *cur_len, int rate);
 bool microbit_hal_microphone_is_recording(void);
 void microbit_hal_microphone_stop_recording(void);
 
diff --git a/src/codal_app/microbithal_microphone.cpp b/src/codal_app/microbithal_microphone.cpp
index ce2eece..7aac576 100644
--- a/src/codal_app/microbithal_microphone.cpp
+++ b/src/codal_app/microbithal_microphone.cpp
@@ -43,7 +43,7 @@ class MyStreamRecording : public DataSink
 
     public:
     uint8_t *dest;
-    size_t dest_pos;
+    size_t *dest_pos_ptr;
     size_t dest_max;
     bool request_stop;
 
@@ -65,18 +65,18 @@ int MyStreamRecording::pullRequest()
 {
     ManagedBuffer data = this->upStream.pull();
 
-    size_t n = MIN((size_t)data.length(), this->dest_max - this->dest_pos);
+    size_t n = MIN((size_t)data.length(), this->dest_max - *this->dest_pos_ptr);
     if (n == 0 || this->request_stop) {
         this->upStream.disconnect();
         this->request_stop = false;
     } else {
         // Copy and convert signed 8-bit to unsigned 8-bit data.
         const uint8_t *src = data.getBytes();
-        uint8_t *dest = this->dest + this->dest_pos;
+        uint8_t *dest = this->dest + *this->dest_pos_ptr;
         for (size_t i = 0; i < n; ++i) {
             *dest++ = *src++ + 128;
         }
-        this->dest_pos += n;
+        *this->dest_pos_ptr += n;
     }
 
     return DEVICE_OK;
@@ -117,7 +117,7 @@ float microbit_hal_microphone_get_level_db(void) {
     return value;
 }
 
-void microbit_hal_microphone_start_recording(uint8_t *buf, size_t len, int rate) {
+void microbit_hal_microphone_start_recording(uint8_t *buf, size_t max_len, size_t *cur_len, int rate) {
     if (splitterChannel == NULL) {
         splitterChannel = uBit.audio.splitter->createChannel();
         splitterChannel->setFormat(DATASTREAM_FORMAT_8BIT_UNSIGNED);
@@ -138,8 +138,9 @@ void microbit_hal_microphone_start_recording(uint8_t *buf, size_t len, int rate)
     }
 
     recording->dest = buf;
-    recording->dest_pos = 0;
-    recording->dest_max = len;
+    recording->dest_pos_ptr = cur_len;
+    *recording->dest_pos_ptr = 0;
+    recording->dest_max = max_len;
     recording->request_stop = false;
 
     splitterChannel->connect(*recording);

From 1e4ae5be56120c1b5e96ecd07157db5f5bee6473 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 15 Jan 2024 17:15:14 +1100
Subject: [PATCH 11/50] codal_port/modaudio: Add a "used_size" field to
 AudioFrame.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_microphone.c | 12 ++++++++----
 src/codal_port/modaudio.c            | 16 +++++++++-------
 src/codal_port/modaudio.h            |  1 +
 3 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/src/codal_port/microbit_microphone.c b/src/codal_port/microbit_microphone.c
index 26c137f..8bdf0a8 100644
--- a/src/codal_port/microbit_microphone.c
+++ b/src/codal_port/microbit_microphone.c
@@ -161,7 +161,7 @@ static MP_DEFINE_CONST_FUN_OBJ_1(microbit_microphone_get_events_obj, microbit_mi
 
 static void microbit_microphone_record_helper(microbit_audio_frame_obj_t *audio_frame, int rate, bool wait) {
     // Start the recording.
-    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, rate);
+    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, &audio_frame->used_size, rate);
 
     if (wait) {
         // Wait for the recording to finish.
@@ -206,10 +206,14 @@ static mp_obj_t microbit_microphone_record_into(mp_uint_t n_args, const mp_obj_t
     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_buffer_info_t bufinfo;
-    mp_get_buffer_raise(args[ARG_buffer].u_obj, &bufinfo, MP_BUFFER_READ);
+    // Check that the buffer is an AudioFrame instance.
+    if (!mp_obj_is_type(args[ARG_buffer].u_obj, &microbit_audio_frame_type)) {
+        mp_raise_TypeError(MP_ERROR_TEXT("expecting an AudioFrame"));
+    }
+    microbit_audio_frame_obj_t *audio_frame = MP_OBJ_TO_PTR(args[ARG_buffer].u_obj);
 
-    microbit_hal_microphone_start_recording(bufinfo.buf, bufinfo.len, args[ARG_rate].u_int);
+    // Start the recording.
+    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, &audio_frame->used_size, args[ARG_rate].u_int);
 
     return mp_const_none;
 }
diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 71c717f..8363fce 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -77,7 +77,7 @@ static void audio_data_fetcher(void) {
 
     if (audio_source_frame != NULL) {
         // An existing AudioFrame is being played, see if there's any data left.
-        if (audio_raw_offset >= audio_source_frame->alloc_size) {
+        if (audio_raw_offset >= audio_source_frame->used_size) {
             // AudioFrame is exhausted.
             audio_source_frame = NULL;
         }
@@ -318,7 +318,7 @@ static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, mp_uint_t
 static mp_obj_t audio_frame_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value_in) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     mp_int_t index = mp_obj_get_int(index_in);
-    if (index < 0 || index >= self->alloc_size) {
+    if (index < 0 || index >= self->used_size) {
          mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds"));
     }
     if (value_in == MP_OBJ_NULL) {
@@ -341,7 +341,7 @@ static mp_obj_t audio_frame_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     switch (op) {
         case MP_UNARY_OP_LEN:
-            return MP_OBJ_NEW_SMALL_INT(self->alloc_size);
+            return MP_OBJ_NEW_SMALL_INT(self->used_size);
         default:
             return MP_OBJ_NULL; // op not supported
     }
@@ -351,14 +351,14 @@ static mp_int_t audio_frame_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufin
     (void)flags;
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     bufinfo->buf = self->data;
-    bufinfo->len = self->alloc_size;
+    bufinfo->len = self->used_size;
     bufinfo->typecode = 'b';
     return 0;
 }
 
 static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_t *other, bool add) {
     int mult = add ? 1 : -1;
-    size_t size = MIN(self->alloc_size, other->alloc_size);
+    size_t size = MIN(self->used_size, other->used_size);
     for (int i = 0; i < size; i++) {
         unsigned val = (int)self->data[i] + mult*(other->data[i]-128);
         // Clamp to 0-255
@@ -371,6 +371,7 @@ static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_
 
 static microbit_audio_frame_obj_t *copy(microbit_audio_frame_obj_t *self) {
     microbit_audio_frame_obj_t *result = microbit_audio_frame_make_new(self->alloc_size);
+    result->used_size = self->used_size;
     for (int i = 0; i < self->alloc_size; i++) {
         result->data[i] = self->data[i];
     }
@@ -381,7 +382,7 @@ mp_obj_t copyfrom(mp_obj_t self_in, mp_obj_t other) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(other, &bufinfo, MP_BUFFER_READ);
-    uint32_t len = MIN(bufinfo.len, self->alloc_size);
+    uint32_t len = MIN(bufinfo.len, self->used_size);
     for (uint32_t i = 0; i < len; i++) {
         self->data[i] = ((uint8_t *)bufinfo.buf)[i];
     }
@@ -418,7 +419,7 @@ int32_t float_to_fixed(float f, uint32_t scale) {
 
 static void mult(microbit_audio_frame_obj_t *self, float f) {
     int scaled = float_to_fixed(f, 15);
-    for (int i = 0; i < self->alloc_size; i++) {
+    for (int i = 0; i < self->used_size; i++) {
         unsigned val = ((((int)self->data[i]-128) * scaled) >> 15)+128;
         if (val > 255) {
             val = (1-(val>>31))*255;
@@ -474,6 +475,7 @@ microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size) {
     microbit_audio_frame_obj_t *res = m_new_obj_var(microbit_audio_frame_obj_t, uint8_t, size);
     res->base.type = &microbit_audio_frame_type;
     res->alloc_size = size;
+    res->used_size = 0;
     memset(res->data, 128, size);
     return res;
 }
diff --git a/src/codal_port/modaudio.h b/src/codal_port/modaudio.h
index f40c61d..5a76311 100644
--- a/src/codal_port/modaudio.h
+++ b/src/codal_port/modaudio.h
@@ -34,6 +34,7 @@
 typedef struct _microbit_audio_frame_obj_t {
     mp_obj_base_t base;
     size_t alloc_size;
+    size_t used_size;
     uint8_t data[];
 } microbit_audio_frame_obj_t;
 

From 0cf7f04bcca116d1f702100f14e999231ba27936 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 15 Jan 2024 17:42:39 +1100
Subject: [PATCH 12/50] codal_port/modaudio: Add rate to AudioFrame.

Make the constructor take duration and rate arguments, and add get_rate() /
set_rate() methods.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_microphone.c |  2 +-
 src/codal_port/modaudio.c            | 58 ++++++++++++++++++++++------
 src/codal_port/modaudio.h            |  3 +-
 3 files changed, 49 insertions(+), 14 deletions(-)

diff --git a/src/codal_port/microbit_microphone.c b/src/codal_port/microbit_microphone.c
index 8bdf0a8..dd9c155 100644
--- a/src/codal_port/microbit_microphone.c
+++ b/src/codal_port/microbit_microphone.c
@@ -185,7 +185,7 @@ static mp_obj_t microbit_microphone_record(mp_uint_t n_args, const mp_obj_t *pos
 
     // Create the AudioFrame to record into.
     size_t size = args[ARG_duration].u_int * args[ARG_rate].u_int / 1000;
-    microbit_audio_frame_obj_t *audio_frame = microbit_audio_frame_make_new(size);
+    microbit_audio_frame_obj_t *audio_frame = microbit_audio_frame_make_new(size, args[ARG_rate].u_int);
 
     microbit_microphone_record_helper(audio_frame, args[ARG_rate].u_int, true);
 
diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 8363fce..c0f74ba 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -301,18 +301,32 @@ MP_REGISTER_MODULE(MP_QSTR_audio, audio_module);
 /******************************************************************************/
 // AudioFrame class
 
-static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
     (void)type_in;
-    (void)args;
-    mp_arg_check_num(n_args, n_kw, 0, 1, false);
-    size_t size = AUDIO_CHUNK_SIZE;
-    if (n_args == 1) {
-        size = mp_obj_get_int(args[0]);
-        if (size <= 0) {
-            mp_raise_ValueError(MP_ERROR_TEXT("size out of bounds"));
-        }
+
+    enum { ARG_duration, ARG_rate };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_duration, MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_rate, MP_ARG_INT, {.u_int = DEFAULT_SAMPLE_RATE} },
+    };
+    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 rate = args[ARG_rate].u_int;
+    if (rate <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
+    }
+
+    size_t size;
+    if (args[ARG_duration].u_int < 0) {
+        size = AUDIO_CHUNK_SIZE;
+    } else if (args[ARG_duration].u_int == 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("size out of bounds"));
+    } else {
+        size = args[ARG_duration].u_int * rate / 1000;
     }
-    return microbit_audio_frame_make_new(size);
+
+    return microbit_audio_frame_make_new(size, rate);
 }
 
 static mp_obj_t audio_frame_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value_in) {
@@ -370,7 +384,7 @@ static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_
 }
 
 static microbit_audio_frame_obj_t *copy(microbit_audio_frame_obj_t *self) {
-    microbit_audio_frame_obj_t *result = microbit_audio_frame_make_new(self->alloc_size);
+    microbit_audio_frame_obj_t *result = microbit_audio_frame_make_new(self->alloc_size, self->rate);
     result->used_size = self->used_size;
     for (int i = 0; i < self->alloc_size; i++) {
         result->data[i] = self->data[i];
@@ -454,7 +468,26 @@ static mp_obj_t audio_frame_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj
     }
 }
 
+static mp_obj_t audio_frame_get_rate(mp_obj_t self_in) {
+    microbit_audio_frame_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    return MP_OBJ_NEW_SMALL_INT(self->rate);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(audio_frame_get_rate_obj, audio_frame_get_rate);
+
+static mp_obj_t audio_frame_set_rate(mp_obj_t self_in, mp_obj_t rate_in) {
+    microbit_audio_frame_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_int_t rate = mp_obj_get_int(rate_in);
+    if (rate <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
+    }
+    self->rate = rate;
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(audio_frame_set_rate_obj, audio_frame_set_rate);
+
 static const mp_map_elem_t microbit_audio_frame_locals_dict_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR_get_rate), (mp_obj_t)&audio_frame_get_rate_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_set_rate), (mp_obj_t)&audio_frame_set_rate_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_copyfrom), (mp_obj_t)&copyfrom_obj },
 };
 static MP_DEFINE_CONST_DICT(microbit_audio_frame_locals_dict, microbit_audio_frame_locals_dict_table);
@@ -471,11 +504,12 @@ MP_DEFINE_CONST_OBJ_TYPE(
     locals_dict, &microbit_audio_frame_locals_dict
     );
 
-microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size) {
+microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size, uint32_t rate) {
     microbit_audio_frame_obj_t *res = m_new_obj_var(microbit_audio_frame_obj_t, uint8_t, size);
     res->base.type = &microbit_audio_frame_type;
     res->alloc_size = size;
     res->used_size = 0;
+    res->rate = rate;
     memset(res->data, 128, size);
     return res;
 }
diff --git a/src/codal_port/modaudio.h b/src/codal_port/modaudio.h
index 5a76311..ec54fcc 100644
--- a/src/codal_port/modaudio.h
+++ b/src/codal_port/modaudio.h
@@ -35,6 +35,7 @@ typedef struct _microbit_audio_frame_obj_t {
     mp_obj_base_t base;
     size_t alloc_size;
     size_t used_size;
+    uint32_t rate;
     uint8_t data[];
 } microbit_audio_frame_obj_t;
 
@@ -45,7 +46,7 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
 void microbit_audio_stop(void);
 bool microbit_audio_is_playing(void);
 
-microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size);
+microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size, uint32_t rate);
 
 const char *microbit_soundeffect_get_sound_expr_data(mp_obj_t self_in);
 

From ab6ea697e12ce6be023a7c19785160aba816f9c8 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 15 Jan 2024 17:49:57 +1100
Subject: [PATCH 13/50] codal_port/microbit_microphone: Use rate from
 AudioFrame, or update it.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_microphone.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/codal_port/microbit_microphone.c b/src/codal_port/microbit_microphone.c
index dd9c155..0656e2d 100644
--- a/src/codal_port/microbit_microphone.c
+++ b/src/codal_port/microbit_microphone.c
@@ -198,7 +198,7 @@ static mp_obj_t microbit_microphone_record_into(mp_uint_t n_args, const mp_obj_t
     enum { ARG_buffer, ARG_rate, ARG_wait, };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_rate, MP_ARG_INT, {.u_int = 7812} },
+        { MP_QSTR_rate, MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_wait, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
     };
 
@@ -212,8 +212,13 @@ static mp_obj_t microbit_microphone_record_into(mp_uint_t n_args, const mp_obj_t
     }
     microbit_audio_frame_obj_t *audio_frame = MP_OBJ_TO_PTR(args[ARG_buffer].u_obj);
 
+    // Set the rate of the AudioFrame, if specified.
+    if (args[ARG_rate].u_int > 0) {
+        audio_frame->rate = args[ARG_rate].u_int;
+    }
+
     // Start the recording.
-    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, &audio_frame->used_size, args[ARG_rate].u_int);
+    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, &audio_frame->used_size, audio_frame->rate);
 
     return mp_const_none;
 }

From bd7905d5eb310b2d00414c815e18a56921957555 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 15 Jan 2024 17:59:18 +1100
Subject: [PATCH 14/50] codal_port/modaudio: Use AudioFrame rate as rate when
 playing it.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index c0f74ba..39dbe3e 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -120,6 +120,7 @@ static void audio_data_fetcher(void) {
         // We have the next AudioFrame.
         audio_source_frame = MP_OBJ_TO_PTR(frame_obj);
         audio_raw_offset = 0;
+        microbit_hal_audio_raw_set_rate(audio_source_frame->rate);
     }
 
     const uint8_t *src = &audio_source_frame->data[audio_raw_offset];
@@ -181,6 +182,7 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
     } else if (mp_obj_is_type(src, &microbit_audio_frame_type)) {
         audio_source_frame = MP_OBJ_TO_PTR(src);
         audio_raw_offset = 0;
+        microbit_hal_audio_raw_set_rate(audio_source_frame->rate);
     } else if (mp_obj_is_type(src, &mp_type_tuple) || mp_obj_is_type(src, &mp_type_list)) {
         // A tuple/list passed in.  Need to check if it contains SoundEffect instances.
         size_t len;
@@ -481,6 +483,8 @@ static mp_obj_t audio_frame_set_rate(mp_obj_t self_in, mp_obj_t rate_in) {
         mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
     }
     self->rate = rate;
+    // TODO: only set if this frame is currently being played
+    microbit_hal_audio_raw_set_rate(rate);
     return mp_const_none;
 }
 static MP_DEFINE_CONST_FUN_OBJ_2(audio_frame_set_rate_obj, audio_frame_set_rate);

From 2756929affe474a75af73d493341f5b020d15feb Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 15 Jan 2024 17:59:45 +1100
Subject: [PATCH 15/50] src: Update test_record.py.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/test_record.py | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/test_record.py b/src/test_record.py
index 656ef28..76a3ba6 100644
--- a/src/test_record.py
+++ b/src/test_record.py
@@ -22,15 +22,11 @@
     "00000"
 )
 
-RECORDING_RATE = 7812
-RECORDING_SECONDS = 5
-RECORDING_SIZE = RECORDING_RATE * RECORDING_SECONDS
-
-my_recording = audio.AudioFrame(RECORDING_SIZE)
+my_recording = audio.AudioFrame(5000)
 
 while True:
     if button_a.is_pressed():
-        microphone.record_into(my_recording, rate=RECORDING_RATE, wait=False)
+        microphone.record_into(my_recording, wait=False)
         display.show([mouth_open, mouth_closed], loop=True, wait=False, delay=150)
         while button_a.is_pressed() and microphone.is_recording():
             sleep(50)
@@ -51,7 +47,7 @@
                 level *= 0.95
             display.show(play * min(1, level / 100))
             x = accelerometer.get_x()
-            audio.set_rate(max(2250, scale(x, (-1000, 1000), (2250, 13374))))
+            my_recording.set_rate(max(2250, scale(x, (-1000, 1000), (2250, 13374))))
             sleep(5)
         display.clear()
     sleep(100)

From 19dbe4b242b9265ecd2f0e2db1546b0125086079 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 18 Jan 2024 15:33:00 +1100
Subject: [PATCH 16/50] codal_app/main: Set microphone gain to 0.2.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_app/main.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/codal_app/main.cpp b/src/codal_app/main.cpp
index 00e91a9..c5f82e0 100644
--- a/src/codal_app/main.cpp
+++ b/src/codal_app/main.cpp
@@ -75,6 +75,9 @@ int main() {
     uBit.audio.setSpeakerEnabled(true);
     uBit.audio.setPinEnabled(false);
 
+    // Set the microphone gain to a reasonable value.
+    uBit.audio.processor->setGain(0.2);
+
     mp_main();
     return 0;
 }

From f1b03ee63c7be26eafe26c22b0442f5647f73c98 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 18 Jan 2024 15:33:29 +1100
Subject: [PATCH 17/50] codal_port/modaudio: Take the sqrt of sound_level.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 39dbe3e..df31ea5 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -25,6 +25,7 @@
  * THE SOFTWARE.
  */
 
+#include <math.h>
 #include "py/mphal.h"
 #include "drv_system.h"
 #include "modaudio.h"
@@ -134,7 +135,7 @@ static void audio_data_fetcher(void) {
         // Compute the sound level.
         sound_level += (src[i] - 128) * (src[i] - 128);
     }
-    audio_current_sound_level = sound_level / AUDIO_CHUNK_SIZE / AUDIO_CHUNK_SIZE;
+    audio_current_sound_level = sound_level / AUDIO_CHUNK_SIZE;
 
     audio_buffer_ready();
 }
@@ -277,8 +278,10 @@ mp_obj_t is_playing(void) {
 }
 MP_DEFINE_CONST_FUN_OBJ_0(microbit_audio_is_playing_obj, is_playing);
 
+// Returns a number between 0 and 254, being the average intensity of the sound played
+// from the most recent chunk of data.
 static mp_obj_t microbit_audio_sound_level(void) {
-    return MP_OBJ_NEW_SMALL_INT(audio_current_sound_level);
+    return MP_OBJ_NEW_SMALL_INT(2 * sqrt(audio_current_sound_level));
 }
 static MP_DEFINE_CONST_FUN_OBJ_0(microbit_audio_sound_level_obj, microbit_audio_sound_level);
 

From 4e3ac1da8cb960827e13c26614137ac6d68bb68f Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 18 Jan 2024 15:34:08 +1100
Subject: [PATCH 18/50] codal_port/modaudio: Mostly use "alloc_size" instead of
 "used_size".

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index df31ea5..73d3723 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -337,7 +337,7 @@ static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, size_t n_
 static mp_obj_t audio_frame_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value_in) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     mp_int_t index = mp_obj_get_int(index_in);
-    if (index < 0 || index >= self->used_size) {
+    if (index < 0 || index >= self->alloc_size) {
          mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds"));
     }
     if (value_in == MP_OBJ_NULL) {
@@ -360,7 +360,7 @@ static mp_obj_t audio_frame_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     switch (op) {
         case MP_UNARY_OP_LEN:
-            return MP_OBJ_NEW_SMALL_INT(self->used_size);
+            return MP_OBJ_NEW_SMALL_INT(self->alloc_size);
         default:
             return MP_OBJ_NULL; // op not supported
     }
@@ -370,14 +370,14 @@ static mp_int_t audio_frame_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufin
     (void)flags;
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     bufinfo->buf = self->data;
-    bufinfo->len = self->used_size;
+    bufinfo->len = self->alloc_size;
     bufinfo->typecode = 'b';
     return 0;
 }
 
 static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_t *other, bool add) {
     int mult = add ? 1 : -1;
-    size_t size = MIN(self->used_size, other->used_size);
+    size_t size = MIN(self->alloc_size, other->alloc_size);
     for (int i = 0; i < size; i++) {
         unsigned val = (int)self->data[i] + mult*(other->data[i]-128);
         // Clamp to 0-255
@@ -401,7 +401,7 @@ mp_obj_t copyfrom(mp_obj_t self_in, mp_obj_t other) {
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(other, &bufinfo, MP_BUFFER_READ);
-    uint32_t len = MIN(bufinfo.len, self->used_size);
+    uint32_t len = MIN(bufinfo.len, self->alloc_size);
     for (uint32_t i = 0; i < len; i++) {
         self->data[i] = ((uint8_t *)bufinfo.buf)[i];
     }
@@ -438,7 +438,7 @@ int32_t float_to_fixed(float f, uint32_t scale) {
 
 static void mult(microbit_audio_frame_obj_t *self, float f) {
     int scaled = float_to_fixed(f, 15);
-    for (int i = 0; i < self->used_size; i++) {
+    for (int i = 0; i < self->alloc_size; i++) {
         unsigned val = ((((int)self->data[i]-128) * scaled) >> 15)+128;
         if (val > 255) {
             val = (1-(val>>31))*255;

From 40979ac344d9e128802d7082950cb7f5a23bf94b Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 18 Jan 2024 15:34:38 +1100
Subject: [PATCH 19/50] codal_port/modaudio: Round up AudioFrame size to
 nearest 32.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 73d3723..562fc20 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -329,6 +329,8 @@ static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, size_t n_
         mp_raise_ValueError(MP_ERROR_TEXT("size out of bounds"));
     } else {
         size = args[ARG_duration].u_int * rate / 1000;
+        // Round up the size to the nearest AUDIO_CHUNK_SIZE.
+        size = (size + AUDIO_CHUNK_SIZE - 1) & ~(AUDIO_CHUNK_SIZE - 1);
     }
 
     return microbit_audio_frame_make_new(size, rate);

From 48781579387ef6fa408a5857df6895d8cbd25b5a Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 18 Jan 2024 16:00:03 +1100
Subject: [PATCH 20/50] codal_port/modaudio: Increas "used_size" when data is
 written.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 562fc20..f56058f 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -354,6 +354,7 @@ static mp_obj_t audio_frame_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t
             mp_raise_ValueError(MP_ERROR_TEXT("value out of range"));
         }
         self->data[index] = value;
+        self->used_size = MAX(self->used_size, index + 1);
         return mp_const_none;
     }
 }
@@ -374,6 +375,10 @@ static mp_int_t audio_frame_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufin
     bufinfo->buf = self->data;
     bufinfo->len = self->alloc_size;
     bufinfo->typecode = 'b';
+    if (flags == MP_BUFFER_WRITE) {
+        // Assume that writing to the buffer will make all data valid for playback.
+        self->used_size = self->alloc_size;
+    }
     return 0;
 }
 

From 5fe630799f66374c6e73b0946cb52cdce778f632 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 18 Jan 2024 16:00:22 +1100
Subject: [PATCH 21/50] src: Update test_record.py.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/test_record.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test_record.py b/src/test_record.py
index 76a3ba6..3bd8b0a 100644
--- a/src/test_record.py
+++ b/src/test_record.py
@@ -35,7 +35,7 @@
         while button_a.is_pressed():
             sleep(50)
         display.clear()
-        my_recording *= 5
+        my_recording *= 2  # amplify volume
     if button_b.is_pressed():
         audio.play(my_recording, wait=False)
         level = 0

From a528b1efa30f2cd5125d456723be28cc23ea14eb Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 18 Jan 2024 16:10:46 +1100
Subject: [PATCH 22/50] codal_port/modaudio: Update to build with latest
 micropython.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index f56058f..1736ee7 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -519,7 +519,7 @@ MP_DEFINE_CONST_OBJ_TYPE(
     );
 
 microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size, uint32_t rate) {
-    microbit_audio_frame_obj_t *res = m_new_obj_var(microbit_audio_frame_obj_t, uint8_t, size);
+    microbit_audio_frame_obj_t *res = m_new_obj_var(microbit_audio_frame_obj_t, data, uint8_t, size);
     res->base.type = &microbit_audio_frame_type;
     res->alloc_size = size;
     res->used_size = 0;

From 71d94304bc7e12c9fb5fe0421864abb798b8b81f Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 27 Feb 2024 10:20:13 +1100
Subject: [PATCH 23/50] codal_app/microbithal_microphone: Make input streaming
 use pullInto.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_app/microbithal_microphone.cpp | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/codal_app/microbithal_microphone.cpp b/src/codal_app/microbithal_microphone.cpp
index 7aac576..588158d 100644
--- a/src/codal_app/microbithal_microphone.cpp
+++ b/src/codal_app/microbithal_microphone.cpp
@@ -39,7 +39,7 @@ static void level_detector_event_handler(Event evt) {
 class MyStreamRecording : public DataSink
 {
     public:
-    DataSource &upStream;
+    SplitterChannel *upStream;
 
     public:
     uint8_t *dest;
@@ -47,13 +47,13 @@ class MyStreamRecording : public DataSink
     size_t dest_max;
     bool request_stop;
 
-    MyStreamRecording(DataSource &source);
+    MyStreamRecording(SplitterChannel *source);
     virtual ~MyStreamRecording();
 
     virtual int pullRequest();
 };
 
-MyStreamRecording::MyStreamRecording( DataSource &source ) : upStream( source )
+MyStreamRecording::MyStreamRecording(SplitterChannel *source) : upStream(source)
 {
 }
 
@@ -63,18 +63,20 @@ MyStreamRecording::~MyStreamRecording()
 
 int MyStreamRecording::pullRequest()
 {
-    ManagedBuffer data = this->upStream.pull();
+    uint8_t *pull_buf = this->dest + *this->dest_pos_ptr;
+    size_t n = this->dest_max - *this->dest_pos_ptr;
+
+    if (n > 0) {
+        n = this->upStream->pullInto(pull_buf, n) - pull_buf;
+    }
 
-    size_t n = MIN((size_t)data.length(), this->dest_max - *this->dest_pos_ptr);
     if (n == 0 || this->request_stop) {
-        this->upStream.disconnect();
+        this->upStream->disconnect();
         this->request_stop = false;
     } else {
-        // Copy and convert signed 8-bit to unsigned 8-bit data.
-        const uint8_t *src = data.getBytes();
-        uint8_t *dest = this->dest + *this->dest_pos_ptr;
+        // Convert signed 8-bit to unsigned 8-bit data.
         for (size_t i = 0; i < n; ++i) {
-            *dest++ = *src++ + 128;
+            pull_buf[i] += 128;
         }
         *this->dest_pos_ptr += n;
     }
@@ -127,7 +129,7 @@ void microbit_hal_microphone_start_recording(uint8_t *buf, size_t max_len, size_
     splitterChannel->requestSampleRate(rate);
 
     if (recording == NULL) {
-        recording = new MyStreamRecording(*splitterChannel);
+        recording = new MyStreamRecording(splitterChannel);
     } else {
         if (microbit_hal_microphone_is_recording()) {
             microbit_hal_microphone_stop_recording();

From 8528e890072ee10bc6c38f43599ab641f6ba14cb Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 25 Mar 2024 16:11:44 +1100
Subject: [PATCH 24/50] codal_port/microbit_microphone: Implement wait argument
 to record_into.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_microphone.c | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/codal_port/microbit_microphone.c b/src/codal_port/microbit_microphone.c
index 0656e2d..459301f 100644
--- a/src/codal_port/microbit_microphone.c
+++ b/src/codal_port/microbit_microphone.c
@@ -160,8 +160,13 @@ static mp_obj_t microbit_microphone_get_events(mp_obj_t self_in) {
 static MP_DEFINE_CONST_FUN_OBJ_1(microbit_microphone_get_events_obj, microbit_microphone_get_events);
 
 static void microbit_microphone_record_helper(microbit_audio_frame_obj_t *audio_frame, int rate, bool wait) {
+    // Set the rate of the AudioFrame, if specified.
+    if (rate > 0) {
+        audio_frame->rate = rate;
+    }
+
     // Start the recording.
-    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, &audio_frame->used_size, rate);
+    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, &audio_frame->used_size, audio_frame->rate);
 
     if (wait) {
         // Wait for the recording to finish.
@@ -187,6 +192,7 @@ static mp_obj_t microbit_microphone_record(mp_uint_t n_args, const mp_obj_t *pos
     size_t size = args[ARG_duration].u_int * args[ARG_rate].u_int / 1000;
     microbit_audio_frame_obj_t *audio_frame = microbit_audio_frame_make_new(size, args[ARG_rate].u_int);
 
+    // Start recording and wait.
     microbit_microphone_record_helper(audio_frame, args[ARG_rate].u_int, true);
 
     // Return the new AudioFrame.
@@ -212,13 +218,8 @@ static mp_obj_t microbit_microphone_record_into(mp_uint_t n_args, const mp_obj_t
     }
     microbit_audio_frame_obj_t *audio_frame = MP_OBJ_TO_PTR(args[ARG_buffer].u_obj);
 
-    // Set the rate of the AudioFrame, if specified.
-    if (args[ARG_rate].u_int > 0) {
-        audio_frame->rate = args[ARG_rate].u_int;
-    }
-
-    // Start the recording.
-    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, &audio_frame->used_size, audio_frame->rate);
+    // Start recording and wait if requested.
+    microbit_microphone_record_helper(audio_frame, args[ARG_rate].u_int, args[ARG_wait].u_bool);
 
     return mp_const_none;
 }

From 5d1b3b588317ca72d49433faea687684e4c4cce8 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 25 Mar 2024 16:23:26 +1100
Subject: [PATCH 25/50] codal_app/microbithal_microphone: Remove CODAL
 workaround.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_app/microbithal_microphone.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/codal_app/microbithal_microphone.cpp b/src/codal_app/microbithal_microphone.cpp
index 588158d..9c41845 100644
--- a/src/codal_app/microbithal_microphone.cpp
+++ b/src/codal_app/microbithal_microphone.cpp
@@ -123,8 +123,6 @@ void microbit_hal_microphone_start_recording(uint8_t *buf, size_t max_len, size_
     if (splitterChannel == NULL) {
         splitterChannel = uBit.audio.splitter->createChannel();
         splitterChannel->setFormat(DATASTREAM_FORMAT_8BIT_UNSIGNED);
-        // Increase sample period to 64us, so we can get our desired rate.
-        splitterChannel->requestSampleRate(1000000 / 64);
     }
     splitterChannel->requestSampleRate(rate);
 

From 7ba6c034bfb19cc6e7f38fd805e1d8fd723c4a8c Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 22 Apr 2024 15:02:01 +1000
Subject: [PATCH 26/50] codal_app/microbithal_microphone: Add func to set the
 sensitivity.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_app/microbithal.h              | 1 +
 src/codal_app/microbithal_microphone.cpp | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/src/codal_app/microbithal.h b/src/codal_app/microbithal.h
index d91e6b8..d9bafc6 100644
--- a/src/codal_app/microbithal.h
+++ b/src/codal_app/microbithal.h
@@ -165,6 +165,7 @@ int microbit_hal_compass_get_field_strength(void);
 int microbit_hal_compass_get_heading(void);
 
 void microbit_hal_microphone_init(void);
+void microbit_hal_microphone_set_sensitivity(float value);
 void microbit_hal_microphone_set_threshold(int kind, int value);
 int microbit_hal_microphone_get_level(void);
 float microbit_hal_microphone_get_level_db(void);
diff --git a/src/codal_app/microbithal_microphone.cpp b/src/codal_app/microbithal_microphone.cpp
index 9c41845..9455b0e 100644
--- a/src/codal_app/microbithal_microphone.cpp
+++ b/src/codal_app/microbithal_microphone.cpp
@@ -99,6 +99,10 @@ void microbit_hal_microphone_init(void) {
     }
 }
 
+void microbit_hal_microphone_set_sensitivity(float value) {
+    uBit.audio.processor->setGain(value);
+}
+
 void microbit_hal_microphone_set_threshold(int kind, int value) {
     if (kind == MICROBIT_HAL_MICROPHONE_SET_THRESHOLD_LOW) {
         uBit.audio.levelSPL->setLowThreshold(value);

From b19fbde76f0948ed886b2f80a4b6aa3682f564ab Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 22 Apr 2024 15:02:31 +1000
Subject: [PATCH 27/50] codal_port/microbit_microphone: Add set_sensitivity
 method and consts.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_microphone.c | 31 ++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/src/codal_port/microbit_microphone.c b/src/codal_port/microbit_microphone.c
index 459301f..4e003b0 100644
--- a/src/codal_port/microbit_microphone.c
+++ b/src/codal_port/microbit_microphone.c
@@ -85,6 +85,13 @@ static uint8_t sound_event_from_obj(mp_obj_t sound) {
     mp_raise_ValueError(MP_ERROR_TEXT("invalid sound"));
 }
 
+static mp_obj_t microbit_microphone_set_sensitivity(mp_obj_t self_in, mp_obj_t value_in) {
+    (void)self_in;
+    microbit_hal_microphone_set_sensitivity(mp_obj_get_float(value_in));
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(microbit_microphone_set_sensitivity_obj, microbit_microphone_set_sensitivity);
+
 static mp_obj_t microbit_microphone_set_threshold(mp_obj_t self_in, mp_obj_t sound_in, mp_obj_t value_in) {
     (void)self_in;
     uint8_t sound = sound_event_from_obj(sound_in);
@@ -238,7 +245,26 @@ static mp_obj_t microbit_microphone_stop_recording(mp_obj_t self_in) {
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(microbit_microphone_stop_recording_obj, microbit_microphone_stop_recording);
 
+#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
+
+// The way float objects are defined depends on the object representation.  Here we only
+// support representation A and B which use the following struct for float objects.
+// This is defined in py/objfloat.c and not exposed publicly, so must be defined here.
+
+typedef struct _mp_obj_float_t {
+    mp_obj_base_t base;
+    mp_float_t value;
+} mp_obj_float_t;
+
+static const mp_obj_float_t microbit_microphone_sensitivity_low_obj = {{&mp_type_float}, (mp_float_t)0.079};
+static const mp_obj_float_t microbit_microphone_sensitivity_medium_obj = {{&mp_type_float}, (mp_float_t)0.2};
+static const mp_obj_float_t microbit_microphone_sensitivity_high_obj = {{&mp_type_float}, (mp_float_t)1.0};
+
+#endif
+
 static const mp_rom_map_elem_t microbit_microphone_locals_dict_table[] = {
+    // Methods.
+    { MP_ROM_QSTR(MP_QSTR_set_sensitivity), MP_ROM_PTR(&microbit_microphone_set_sensitivity_obj) },
     { MP_ROM_QSTR(MP_QSTR_set_threshold), MP_ROM_PTR(&microbit_microphone_set_threshold_obj) },
     { MP_ROM_QSTR(MP_QSTR_sound_level), MP_ROM_PTR(&microbit_microphone_sound_level_obj) },
     { MP_ROM_QSTR(MP_QSTR_sound_level_db), MP_ROM_PTR(&microbit_microphone_sound_level_db_obj) },
@@ -250,6 +276,11 @@ static const mp_rom_map_elem_t microbit_microphone_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_record_into), MP_ROM_PTR(&microbit_microphone_record_into_obj) },
     { MP_ROM_QSTR(MP_QSTR_is_recording), MP_ROM_PTR(&microbit_microphone_is_recording_obj) },
     { MP_ROM_QSTR(MP_QSTR_stop_recording), MP_ROM_PTR(&microbit_microphone_stop_recording_obj) },
+
+    // Constants.
+    { MP_ROM_QSTR(MP_QSTR_SENSITIVITY_LOW), MP_ROM_PTR(&microbit_microphone_sensitivity_low_obj) },
+    { MP_ROM_QSTR(MP_QSTR_SENSITIVITY_MEDIUM), MP_ROM_PTR(&microbit_microphone_sensitivity_medium_obj) },
+    { MP_ROM_QSTR(MP_QSTR_SENSITIVITY_HIGH), MP_ROM_PTR(&microbit_microphone_sensitivity_high_obj) },
 };
 static MP_DEFINE_CONST_DICT(microbit_microphone_locals_dict, microbit_microphone_locals_dict_table);
 

From 8041d868f1743c98e489c2780d7e923c5b764529 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 22 Apr 2024 15:14:56 +1000
Subject: [PATCH 28/50] codal_port/modaudio: Ensure AudioFrame size is
 non-zero.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 1736ee7..df2bd40 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -519,6 +519,11 @@ MP_DEFINE_CONST_OBJ_TYPE(
     );
 
 microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size, uint32_t rate) {
+    // Make sure size is non-zero.
+    if (size == 0) {
+        size = 1;
+    }
+
     microbit_audio_frame_obj_t *res = m_new_obj_var(microbit_audio_frame_obj_t, data, uint8_t, size);
     res->base.type = &microbit_audio_frame_type;
     res->alloc_size = size;

From 80cfac7d9e5108472d25a07ccd608b5795450cf2 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 22 Apr 2024 15:21:57 +1000
Subject: [PATCH 29/50] codal_port/microbit_microphone: Validate duration and
 rate args.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_microphone.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/codal_port/microbit_microphone.c b/src/codal_port/microbit_microphone.c
index 4e003b0..5ab563d 100644
--- a/src/codal_port/microbit_microphone.c
+++ b/src/codal_port/microbit_microphone.c
@@ -195,6 +195,14 @@ static mp_obj_t microbit_microphone_record(mp_uint_t n_args, const mp_obj_t *pos
     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);
 
+    // Validate arguments.
+    if (args[ARG_duration].u_int <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("duration out of bounds"));
+    }
+    if (args[ARG_rate].u_int <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
+    }
+
     // Create the AudioFrame to record into.
     size_t size = args[ARG_duration].u_int * args[ARG_rate].u_int / 1000;
     microbit_audio_frame_obj_t *audio_frame = microbit_audio_frame_make_new(size, args[ARG_rate].u_int);

From 61aaf2ae89649549ba1dcfd1565c0304de3c6734 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 29 Apr 2024 14:01:05 +1000
Subject: [PATCH 30/50] codal_port/modaudio: Allow AudioFrame to be arbitrary
 length.

No longer needs to be a multiple of 32.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index df2bd40..6f98261 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -125,16 +125,22 @@ static void audio_data_fetcher(void) {
     }
 
     const uint8_t *src = &audio_source_frame->data[audio_raw_offset];
-    audio_raw_offset += AUDIO_CHUNK_SIZE;
+    size_t src_len = MIN(audio_source_frame->used_size - audio_raw_offset, AUDIO_CHUNK_SIZE);
+    audio_raw_offset += src_len;
 
     uint8_t *dest = &audio_output_buffer[0];
     uint32_t sound_level = 0;
-    for (int i = 0; i < AUDIO_CHUNK_SIZE; ++i) {
+
+    for (int i = 0; i < src_len; ++i) {
         // Copy sample to the buffer.
         *dest++ = src[i];
         // Compute the sound level.
         sound_level += (src[i] - 128) * (src[i] - 128);
     }
+
+    // Fill any remaining audio_output_buffer bytes with silence.
+    memset(dest, 128, AUDIO_CHUNK_SIZE - src_len);
+
     audio_current_sound_level = sound_level / AUDIO_CHUNK_SIZE;
 
     audio_buffer_ready();
@@ -329,8 +335,6 @@ static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, size_t n_
         mp_raise_ValueError(MP_ERROR_TEXT("size out of bounds"));
     } else {
         size = args[ARG_duration].u_int * rate / 1000;
-        // Round up the size to the nearest AUDIO_CHUNK_SIZE.
-        size = (size + AUDIO_CHUNK_SIZE - 1) & ~(AUDIO_CHUNK_SIZE - 1);
     }
 
     return microbit_audio_frame_make_new(size, rate);

From e8a5d616e3fcd35fd1ca8c0ff3e3ea7f3ab4bcdd Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 29 Apr 2024 13:39:55 +1000
Subject: [PATCH 31/50] codal_port/modaudio: Make None the default to
 AudioFrame().

And allow duration to be a float, for more accurate sizing.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 6f98261..9080086 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -317,7 +317,7 @@ static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, size_t n_
 
     enum { ARG_duration, ARG_rate };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_duration, MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_duration, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_rate, MP_ARG_INT, {.u_int = DEFAULT_SAMPLE_RATE} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
@@ -329,12 +329,14 @@ static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, size_t n_
     }
 
     size_t size;
-    if (args[ARG_duration].u_int < 0) {
+    if (args[ARG_duration].u_obj == mp_const_none) {
         size = AUDIO_CHUNK_SIZE;
-    } else if (args[ARG_duration].u_int == 0) {
-        mp_raise_ValueError(MP_ERROR_TEXT("size out of bounds"));
     } else {
-        size = args[ARG_duration].u_int * rate / 1000;
+        mp_float_t duration = mp_obj_get_float(args[ARG_duration].u_obj);
+        if (duration <= 0) {
+            mp_raise_ValueError(MP_ERROR_TEXT("size out of bounds"));
+        }
+        size = duration * rate / 1000;
     }
 
     return microbit_audio_frame_make_new(size, rate);

From 0441aa2886b7b6e65465b53c368a5fcdada9cdb6 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 29 Apr 2024 14:17:34 +1000
Subject: [PATCH 32/50] codal_port/microbit_microphone: Require rate to be
 positive.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_microphone.c | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/codal_port/microbit_microphone.c b/src/codal_port/microbit_microphone.c
index 5ab563d..d967b6b 100644
--- a/src/codal_port/microbit_microphone.c
+++ b/src/codal_port/microbit_microphone.c
@@ -166,12 +166,7 @@ static mp_obj_t microbit_microphone_get_events(mp_obj_t self_in) {
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(microbit_microphone_get_events_obj, microbit_microphone_get_events);
 
-static void microbit_microphone_record_helper(microbit_audio_frame_obj_t *audio_frame, int rate, bool wait) {
-    // Set the rate of the AudioFrame, if specified.
-    if (rate > 0) {
-        audio_frame->rate = rate;
-    }
-
+static void microbit_microphone_record_helper(microbit_audio_frame_obj_t *audio_frame, bool wait) {
     // Start the recording.
     microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, &audio_frame->used_size, audio_frame->rate);
 
@@ -208,7 +203,7 @@ static mp_obj_t microbit_microphone_record(mp_uint_t n_args, const mp_obj_t *pos
     microbit_audio_frame_obj_t *audio_frame = microbit_audio_frame_make_new(size, args[ARG_rate].u_int);
 
     // Start recording and wait.
-    microbit_microphone_record_helper(audio_frame, args[ARG_rate].u_int, true);
+    microbit_microphone_record_helper(audio_frame, true);
 
     // Return the new AudioFrame.
     return MP_OBJ_FROM_PTR(audio_frame);
@@ -219,7 +214,7 @@ static mp_obj_t microbit_microphone_record_into(mp_uint_t n_args, const mp_obj_t
     enum { ARG_buffer, ARG_rate, ARG_wait, };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_rate, MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_rate, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_wait, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
     };
 
@@ -233,8 +228,18 @@ static mp_obj_t microbit_microphone_record_into(mp_uint_t n_args, const mp_obj_t
     }
     microbit_audio_frame_obj_t *audio_frame = MP_OBJ_TO_PTR(args[ARG_buffer].u_obj);
 
+    // Check if the rate is specified.
+    if (args[ARG_rate].u_obj != mp_const_none) {
+        // Update the AudioFrame to use the specified rate.
+        mp_int_t rate = mp_obj_get_int(args[ARG_rate].u_obj);
+        if (rate <= 0) {
+            mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
+        }
+        audio_frame->rate = rate;
+    }
+
     // Start recording and wait if requested.
-    microbit_microphone_record_helper(audio_frame, args[ARG_rate].u_int, args[ARG_wait].u_bool);
+    microbit_microphone_record_helper(audio_frame, args[ARG_wait].u_bool);
 
     return mp_const_none;
 }

From c7f64c173f6af960d118748d3e1fba2b50d94ccd Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 30 Apr 2024 17:22:58 +1000
Subject: [PATCH 33/50] codal_port/modaudio: Fix typecode of AudioFrame buffer
 to be unsigned.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 9080086..dab1075 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -380,7 +380,7 @@ static mp_int_t audio_frame_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufin
     microbit_audio_frame_obj_t *self = (microbit_audio_frame_obj_t *)self_in;
     bufinfo->buf = self->data;
     bufinfo->len = self->alloc_size;
-    bufinfo->typecode = 'b';
+    bufinfo->typecode = 'B';
     if (flags == MP_BUFFER_WRITE) {
         // Assume that writing to the buffer will make all data valid for playback.
         self->used_size = self->alloc_size;

From c741736ef6742a694575a67d8479422f6931c9c9 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 20 May 2024 15:58:06 +1000
Subject: [PATCH 34/50] codal_port/modaudio: Use mp_sched_schedule_node for
 audio fetcher.

This is more efficient than mp_sched_schedule(), and can never fail.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c     | 22 ++++++----------------
 src/codal_port/mpconfigport.h |  1 +
 2 files changed, 7 insertions(+), 16 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index dab1075..e4ac9d5 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -47,9 +47,9 @@ typedef enum {
 
 static uint8_t audio_output_buffer[AUDIO_CHUNK_SIZE];
 static volatile audio_output_state_t audio_output_state;
-static volatile bool audio_fetcher_scheduled;
 static size_t audio_raw_offset;
 static uint32_t audio_current_sound_level;
+static mp_sched_node_t audio_data_fetcher_sched_node;
 
 static inline bool audio_is_running(void) {
     return audio_source_frame != NULL || audio_source_iter != MP_OBJ_NULL;
@@ -73,9 +73,7 @@ static void audio_buffer_ready(void) {
     }
 }
 
-static void audio_data_fetcher(void) {
-    audio_fetcher_scheduled = false;
-
+static void audio_data_fetcher(mp_sched_node_t *node) {
     if (audio_source_frame != NULL) {
         // An existing AudioFrame is being played, see if there's any data left.
         if (audio_raw_offset >= audio_source_frame->used_size) {
@@ -146,12 +144,6 @@ static void audio_data_fetcher(void) {
     audio_buffer_ready();
 }
 
-static mp_obj_t audio_data_fetcher_wrapper(mp_obj_t arg) {
-    audio_data_fetcher();
-    return mp_const_none;
-}
-static MP_DEFINE_CONST_FUN_OBJ_1(audio_data_fetcher_wrapper_obj, audio_data_fetcher_wrapper);
-
 void microbit_hal_audio_raw_ready_callback(void) {
     if (audio_output_state == AUDIO_OUTPUT_STATE_DATA_READY) {
         // there is data ready to send out to the audio pipeline, so send it
@@ -161,14 +153,12 @@ void microbit_hal_audio_raw_ready_callback(void) {
         // no data ready, need to call this function later when data is ready
         audio_output_state = AUDIO_OUTPUT_STATE_IDLE;
     }
-    if (!audio_fetcher_scheduled) {
-        // schedule audio_data_fetcher to be executed to prepare the next buffer
-        audio_fetcher_scheduled = mp_sched_schedule(MP_OBJ_FROM_PTR(&audio_data_fetcher_wrapper_obj), mp_const_none);
-    }
+
+    // schedule audio_data_fetcher to be executed to prepare the next buffer
+    mp_sched_schedule_node(&audio_data_fetcher_sched_node, audio_data_fetcher);
 }
 
 static void audio_init(uint32_t sample_rate) {
-    audio_fetcher_scheduled = false;
     audio_output_state = AUDIO_OUTPUT_STATE_IDLE;
     microbit_hal_audio_raw_init(sample_rate);
 }
@@ -239,7 +229,7 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
     // Start the audio running.
     // The scheduler must be locked because audio_data_fetcher() can also be called from the scheduler.
     mp_sched_lock();
-    audio_data_fetcher();
+    audio_data_fetcher(&audio_data_fetcher_sched_node);
     mp_sched_unlock();
 
     if (wait) {
diff --git a/src/codal_port/mpconfigport.h b/src/codal_port/mpconfigport.h
index cca2378..8a4a3a7 100644
--- a/src/codal_port/mpconfigport.h
+++ b/src/codal_port/mpconfigport.h
@@ -61,6 +61,7 @@
 #define MICROPY_MODULE_BUILTIN_INIT             (1)
 #define MICROPY_USE_INTERNAL_ERRNO              (1)
 #define MICROPY_ENABLE_SCHEDULER                (1)
+#define MICROPY_SCHEDULER_STATIC_NODES          (1)
 
 // Fine control over Python builtins, classes, modules, etc
 #define MICROPY_PY_BUILTINS_STR_UNICODE         (1)

From 26d077a9118e9c21e70b0b8ca9d1aff00f49b7c6 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 20 May 2024 15:59:04 +1000
Subject: [PATCH 35/50] codal_port/modaudio: Separate default AudioFrame and
 output buffer size.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index e4ac9d5..15594c0 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -35,8 +35,8 @@
 #define audio_source_frame MP_STATE_PORT(audio_source_frame_state)
 #define audio_source_iter MP_STATE_PORT(audio_source_iter_state)
 
-#define LOG_AUDIO_CHUNK_SIZE (5)
-#define AUDIO_CHUNK_SIZE (1 << LOG_AUDIO_CHUNK_SIZE)
+#define AUDIO_OUTPUT_BUFFER_SIZE (32)
+#define DEFAULT_AUDIO_FRAME_SIZE (32)
 #define DEFAULT_SAMPLE_RATE (7812)
 
 typedef enum {
@@ -45,7 +45,7 @@ typedef enum {
     AUDIO_OUTPUT_STATE_DATA_WRITTEN,
 } audio_output_state_t;
 
-static uint8_t audio_output_buffer[AUDIO_CHUNK_SIZE];
+static uint8_t audio_output_buffer[AUDIO_OUTPUT_BUFFER_SIZE];
 static volatile audio_output_state_t audio_output_state;
 static size_t audio_raw_offset;
 static uint32_t audio_current_sound_level;
@@ -123,7 +123,7 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
     }
 
     const uint8_t *src = &audio_source_frame->data[audio_raw_offset];
-    size_t src_len = MIN(audio_source_frame->used_size - audio_raw_offset, AUDIO_CHUNK_SIZE);
+    size_t src_len = MIN(audio_source_frame->used_size - audio_raw_offset, AUDIO_OUTPUT_BUFFER_SIZE);
     audio_raw_offset += src_len;
 
     uint8_t *dest = &audio_output_buffer[0];
@@ -137,9 +137,9 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
     }
 
     // Fill any remaining audio_output_buffer bytes with silence.
-    memset(dest, 128, AUDIO_CHUNK_SIZE - src_len);
+    memset(dest, 128, AUDIO_OUTPUT_BUFFER_SIZE - src_len);
 
-    audio_current_sound_level = sound_level / AUDIO_CHUNK_SIZE;
+    audio_current_sound_level = sound_level / AUDIO_OUTPUT_BUFFER_SIZE;
 
     audio_buffer_ready();
 }
@@ -147,7 +147,7 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
 void microbit_hal_audio_raw_ready_callback(void) {
     if (audio_output_state == AUDIO_OUTPUT_STATE_DATA_READY) {
         // there is data ready to send out to the audio pipeline, so send it
-        microbit_hal_audio_raw_write_data(&audio_output_buffer[0], AUDIO_CHUNK_SIZE);
+        microbit_hal_audio_raw_write_data(&audio_output_buffer[0], AUDIO_OUTPUT_BUFFER_SIZE);
         audio_output_state = AUDIO_OUTPUT_STATE_DATA_WRITTEN;
     } else {
         // no data ready, need to call this function later when data is ready
@@ -320,7 +320,7 @@ static mp_obj_t microbit_audio_frame_new(const mp_obj_type_t *type_in, size_t n_
 
     size_t size;
     if (args[ARG_duration].u_obj == mp_const_none) {
-        size = AUDIO_CHUNK_SIZE;
+        size = DEFAULT_AUDIO_FRAME_SIZE;
     } else {
         mp_float_t duration = mp_obj_get_float(args[ARG_duration].u_obj);
         if (duration <= 0) {

From a4fb09be8bcd771b45f5a9d363b2f4016f821492 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 20 May 2024 16:38:02 +1000
Subject: [PATCH 36/50] codal_port/modaudio: Allow output buffer to be larger
 than 32 bytes.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 83 ++++++++++++++++++++++++---------------
 1 file changed, 51 insertions(+), 32 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 15594c0..33b4516 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -35,7 +35,10 @@
 #define audio_source_frame MP_STATE_PORT(audio_source_frame_state)
 #define audio_source_iter MP_STATE_PORT(audio_source_iter_state)
 
+#ifndef AUDIO_OUTPUT_BUFFER_SIZE
 #define AUDIO_OUTPUT_BUFFER_SIZE (32)
+#endif
+
 #define DEFAULT_AUDIO_FRAME_SIZE (32)
 #define DEFAULT_SAMPLE_RATE (7812)
 
@@ -46,8 +49,9 @@ typedef enum {
 } audio_output_state_t;
 
 static uint8_t audio_output_buffer[AUDIO_OUTPUT_BUFFER_SIZE];
+static size_t audio_output_buffer_offset;
 static volatile audio_output_state_t audio_output_state;
-static size_t audio_raw_offset;
+static size_t audio_source_frame_offset;
 static uint32_t audio_current_sound_level;
 static mp_sched_node_t audio_data_fetcher_sched_node;
 
@@ -56,27 +60,18 @@ static inline bool audio_is_running(void) {
 }
 
 void microbit_audio_stop(void) {
+    audio_output_buffer_offset = 0;
     audio_source_frame = NULL;
     audio_source_iter = NULL;
-    audio_raw_offset = 0;
+    audio_source_frame_offset = 0;
     audio_current_sound_level = 0;
     microbit_hal_audio_stop_expression();
 }
 
-static void audio_buffer_ready(void) {
-    uint32_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
-    audio_output_state_t old_state = audio_output_state;
-    audio_output_state = AUDIO_OUTPUT_STATE_DATA_READY;
-    MICROPY_END_ATOMIC_SECTION(atomic_state);
-    if (old_state == AUDIO_OUTPUT_STATE_IDLE) {
-        microbit_hal_audio_raw_ready_callback();
-    }
-}
-
-static void audio_data_fetcher(mp_sched_node_t *node) {
+static void audio_data_pull_from_source(void) {
     if (audio_source_frame != NULL) {
         // An existing AudioFrame is being played, see if there's any data left.
-        if (audio_raw_offset >= audio_source_frame->used_size) {
+        if (audio_source_frame_offset >= audio_source_frame->used_size) {
             // AudioFrame is exhausted.
             audio_source_frame = NULL;
         }
@@ -118,30 +113,54 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
 
         // We have the next AudioFrame.
         audio_source_frame = MP_OBJ_TO_PTR(frame_obj);
-        audio_raw_offset = 0;
+        audio_source_frame_offset = 0;
         microbit_hal_audio_raw_set_rate(audio_source_frame->rate);
     }
+}
 
-    const uint8_t *src = &audio_source_frame->data[audio_raw_offset];
-    size_t src_len = MIN(audio_source_frame->used_size - audio_raw_offset, AUDIO_OUTPUT_BUFFER_SIZE);
-    audio_raw_offset += src_len;
-
-    uint8_t *dest = &audio_output_buffer[0];
-    uint32_t sound_level = 0;
+static void audio_data_fetcher(mp_sched_node_t *node) {
+    audio_data_pull_from_source();
+    uint8_t *dest = &audio_output_buffer[audio_output_buffer_offset];
 
-    for (int i = 0; i < src_len; ++i) {
-        // Copy sample to the buffer.
-        *dest++ = src[i];
-        // Compute the sound level.
-        sound_level += (src[i] - 128) * (src[i] - 128);
+    if (audio_source_frame == NULL) {
+        // Audio source is exhausted.
+        // Fill any remaining audio_output_buffer bytes with silence.
+        memset(dest, 128, AUDIO_OUTPUT_BUFFER_SIZE - audio_output_buffer_offset);
+        audio_output_buffer_offset = AUDIO_OUTPUT_BUFFER_SIZE;
+    } else {
+        // Copy samples to the buffer.
+        const uint8_t *src = &audio_source_frame->data[audio_source_frame_offset];
+        size_t src_len = MIN(audio_source_frame->used_size - audio_source_frame_offset, AUDIO_OUTPUT_BUFFER_SIZE - audio_output_buffer_offset);
+        memcpy(dest, src, src_len);
+
+        // Update output and source offsets.
+        audio_output_buffer_offset += src_len;
+        audio_source_frame_offset += src_len;
     }
 
-    // Fill any remaining audio_output_buffer bytes with silence.
-    memset(dest, 128, AUDIO_OUTPUT_BUFFER_SIZE - src_len);
-
-    audio_current_sound_level = sound_level / AUDIO_OUTPUT_BUFFER_SIZE;
+    if (audio_output_buffer_offset < AUDIO_OUTPUT_BUFFER_SIZE) {
+        // Output buffer not full yet, so attempt to pull more data from the source.
+        mp_sched_schedule_node(&audio_data_fetcher_sched_node, audio_data_fetcher);
+    } else {
+        // Output buffer is full, process it and prepare for next buffer fill.
+        audio_output_buffer_offset = 0;
 
-    audio_buffer_ready();
+        // Compute the sound level.
+        uint32_t sound_level = 0;
+        for (int i = 0; i < AUDIO_OUTPUT_BUFFER_SIZE; ++i) {
+            sound_level += (audio_output_buffer[i] - 128) * (audio_output_buffer[i] - 128);
+        }
+        audio_current_sound_level = sound_level / AUDIO_OUTPUT_BUFFER_SIZE;
+
+        // Send the data to the lower levels of the audio pipeline.
+        uint32_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+        audio_output_state_t old_state = audio_output_state;
+        audio_output_state = AUDIO_OUTPUT_STATE_DATA_READY;
+        MICROPY_END_ATOMIC_SECTION(atomic_state);
+        if (old_state == AUDIO_OUTPUT_STATE_IDLE) {
+            microbit_hal_audio_raw_ready_callback();
+        }
+    }
 }
 
 void microbit_hal_audio_raw_ready_callback(void) {
@@ -178,7 +197,7 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
         sound_expr_data = microbit_soundeffect_get_sound_expr_data(src);
     } else if (mp_obj_is_type(src, &microbit_audio_frame_type)) {
         audio_source_frame = MP_OBJ_TO_PTR(src);
-        audio_raw_offset = 0;
+        audio_source_frame_offset = 0;
         microbit_hal_audio_raw_set_rate(audio_source_frame->rate);
     } else if (mp_obj_is_type(src, &mp_type_tuple) || mp_obj_is_type(src, &mp_type_list)) {
         // A tuple/list passed in.  Need to check if it contains SoundEffect instances.

From a280e252e48ed1cf1843dda62803dc5c175cf97d Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 27 May 2024 16:21:26 +1000
Subject: [PATCH 37/50] codal_port/modaudio: Stop streaming audio when data is
 exhausted.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 33b4516..6b099e4 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -124,7 +124,13 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
 
     if (audio_source_frame == NULL) {
         // Audio source is exhausted.
-        // Fill any remaining audio_output_buffer bytes with silence.
+
+        if (audio_output_buffer_offset == 0) {
+            // No output data left, finish output streaming.
+            return;
+        }
+
+        // Fill remaining audio_output_buffer bytes with silence, for the final output frame.
         memset(dest, 128, AUDIO_OUTPUT_BUFFER_SIZE - audio_output_buffer_offset);
         audio_output_buffer_offset = AUDIO_OUTPUT_BUFFER_SIZE;
     } else {

From 9819ff8da0af524daef8ce9bd9667008ad1eb2bd Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 1 Aug 2024 22:26:40 +1000
Subject: [PATCH 38/50] codal_port: Implement AudioTrack and AudioRecording.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/Makefile                  |   3 +
 src/codal_port/microbit_audiorecording.c | 128 +++++++++++++++++
 src/codal_port/microbit_audiotrack.c     | 167 +++++++++++++++++++++++
 src/codal_port/microbit_microphone.c     |  50 ++++---
 src/codal_port/modaudio.c                |  57 ++++++--
 src/codal_port/modaudio.h                |  17 +++
 src/codal_port/utils.c                   |  35 +++++
 src/codal_port/utils.h                   |  33 +++++
 8 files changed, 450 insertions(+), 40 deletions(-)
 create mode 100644 src/codal_port/microbit_audiorecording.c
 create mode 100644 src/codal_port/microbit_audiotrack.c
 create mode 100644 src/codal_port/utils.c
 create mode 100644 src/codal_port/utils.h

diff --git a/src/codal_port/Makefile b/src/codal_port/Makefile
index c6b4643..64bd213 100644
--- a/src/codal_port/Makefile
+++ b/src/codal_port/Makefile
@@ -69,6 +69,8 @@ SRC_C += \
 	iters.c \
 	main.c \
 	microbit_accelerometer.c \
+	microbit_audiorecording.c \
+	microbit_audiotrack.c \
 	microbit_button.c \
 	microbit_compass.c \
 	microbit_display.c \
@@ -100,6 +102,7 @@ SRC_C += \
 	modspeech.c \
 	modthis.c \
 	mphalport.c \
+	utils.c \
 
 SRC_C += \
 	shared/readline/readline.c \
diff --git a/src/codal_port/microbit_audiorecording.c b/src/codal_port/microbit_audiorecording.c
new file mode 100644
index 0000000..2b3422d
--- /dev/null
+++ b/src/codal_port/microbit_audiorecording.c
@@ -0,0 +1,128 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mphal.h"
+#include "drv_system.h"
+#include "modmicrobit.h"
+#include "modaudio.h"
+#include "utils.h"
+
+mp_obj_t microbit_audio_recording_new(size_t num_bytes, uint32_t rate) {
+    // Make sure size is non-zero.
+    if (num_bytes == 0) {
+        num_bytes = 1;
+    }
+
+    // Create and return the AudioRecording object.
+    uint8_t *data = m_new(uint8_t, num_bytes);
+    memset(data, 128, num_bytes);
+    return microbit_audio_track_new(MP_OBJ_NULL, num_bytes, data, rate);
+}
+
+static mp_obj_t microbit_audio_recording_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    (void)type_in;
+
+    enum { ARG_duration, ARG_rate };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_duration, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = MP_OBJ_NULL} },
+        { MP_QSTR_rate, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_INT(AUDIO_TRACK_DEFAULT_SAMPLE_RATE)} },
+    };
+    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 rate = mp_obj_get_int_allow_float(args[ARG_rate].u_obj);
+    if (rate <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
+    }
+
+    mp_float_t duration_ms = mp_obj_get_float(args[ARG_duration].u_obj);
+    if (duration_ms <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("duration out of bounds"));
+    }
+    size_t num_bytes = duration_ms * rate / 1000;
+
+    return microbit_audio_recording_new(num_bytes, rate);
+}
+
+static mp_obj_t microbit_audio_recording_copy(mp_obj_t self_in) {
+    microbit_audio_track_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    uint8_t *data = m_new(uint8_t, self->size);
+    memcpy(data, self->data, self->size);
+    return microbit_audio_track_new(MP_OBJ_NULL, self->size, data, self->rate);
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(microbit_audio_recording_copy_obj, microbit_audio_recording_copy);
+
+static mp_obj_t microbit_audio_recording_track(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_start_ms, ARG_end_ms };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_start_ms, MP_ARG_KW_ONLY, {.u_rom_obj = MP_ROM_INT(0)} },
+        { MP_QSTR_end_ms, MP_ARG_KW_ONLY, {.u_rom_obj = MP_ROM_INT(-1)} },
+    };
+    // parse args
+    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);
+
+    microbit_audio_track_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    mp_int_t start_byte = mp_obj_get_float(args[ARG_start_ms].u_obj) * self->rate / 1000;
+    mp_int_t end_byte;
+    if (args[ARG_end_ms].u_obj == MP_OBJ_NEW_SMALL_INT(-1)) {
+        end_byte = self->size;
+    } else {
+        end_byte = mp_obj_get_float(args[ARG_end_ms].u_obj) * self->rate / 1000;
+    }
+
+    // Truncate start_byte to fit in valid range.
+    start_byte = MAX(0, start_byte);
+    start_byte = MIN(start_byte, self->size);
+
+    // Truncate end_byte to fit in valid range.
+    end_byte = MAX(0, end_byte);
+    end_byte = MIN(end_byte, self->size);
+
+    // Calculate length of track, truncating negative lengths to 0.
+    size_t len = MAX(0, end_byte - start_byte);
+
+    // Create and return new track.
+    return microbit_audio_track_new(pos_args[0], len, self->data + start_byte, self->rate);
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(microbit_audio_recording_track_obj, 1, microbit_audio_recording_track);
+
+static const mp_rom_map_elem_t microbit_audio_recording_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_get_rate), MP_ROM_PTR(&microbit_audio_track_get_rate_obj) },
+    { MP_ROM_QSTR(MP_QSTR_set_rate), MP_ROM_PTR(&microbit_audio_track_set_rate_obj) },
+    { MP_ROM_QSTR(MP_QSTR_copy), MP_ROM_PTR(&microbit_audio_recording_copy_obj) },
+    { MP_ROM_QSTR(MP_QSTR_track), MP_ROM_PTR(&microbit_audio_recording_track_obj) },
+};
+static MP_DEFINE_CONST_DICT(microbit_audio_recording_locals_dict, microbit_audio_recording_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+    microbit_audio_recording_type,
+    MP_QSTR_AudioRecording,
+    MP_TYPE_FLAG_NONE,
+    make_new, microbit_audio_recording_make_new,
+    buffer, microbit_audio_track_get_buffer,
+    locals_dict, &microbit_audio_recording_locals_dict
+    );
diff --git a/src/codal_port/microbit_audiotrack.c b/src/codal_port/microbit_audiotrack.c
new file mode 100644
index 0000000..049c062
--- /dev/null
+++ b/src/codal_port/microbit_audiotrack.c
@@ -0,0 +1,167 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mphal.h"
+#include "drv_system.h"
+#include "modmicrobit.h"
+#include "modaudio.h"
+#include "utils.h"
+
+mp_obj_t microbit_audio_track_new(mp_obj_t buffer_obj, size_t len, uint8_t *data, uint32_t rate) {
+    microbit_audio_track_obj_t *self = m_new_obj(microbit_audio_track_obj_t);
+    if (buffer_obj == MP_OBJ_NULL) {
+        self->base.type = &microbit_audio_recording_type;
+    } else {
+        self->base.type = &microbit_audio_track_type;
+        if (mp_obj_is_type(buffer_obj, &microbit_audio_track_type)) {
+            buffer_obj = ((microbit_audio_track_obj_t *)MP_OBJ_TO_PTR(buffer_obj))->buffer_obj;
+        }
+    }
+    self->buffer_obj = buffer_obj;
+    self->size = len;
+    self->rate = rate;
+    self->data = data;
+    return MP_OBJ_FROM_PTR(self);
+}
+
+static mp_obj_t microbit_audio_track_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    (void)type_in;
+
+    enum { ARG_buffer, ARG_rate };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = MP_OBJ_NULL} },
+        { MP_QSTR_rate, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_INT(AUDIO_TRACK_DEFAULT_SAMPLE_RATE)} },
+    };
+    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 rate = mp_obj_get_int_allow_float(args[ARG_rate].u_obj);
+    if (rate <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
+    }
+
+    // Get buffer.
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[ARG_buffer].u_obj, &bufinfo, MP_BUFFER_RW);
+
+    // Create and return the AudioTrack object.
+    return microbit_audio_track_new(args[ARG_buffer].u_obj, bufinfo.len, bufinfo.buf, rate);
+}
+
+static mp_obj_t microbit_audio_track_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
+    microbit_audio_track_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    switch (op) {
+        case MP_UNARY_OP_LEN:
+            return MP_OBJ_NEW_SMALL_INT(self->size);
+        default:
+            return MP_OBJ_NULL; // op not supported
+    }
+}
+
+static mp_obj_t microbit_audio_track_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value_in) {
+    microbit_audio_track_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (value_in == MP_OBJ_NULL) {
+        // delete
+        mp_raise_TypeError(MP_ERROR_TEXT("cannot delete elements of AudioTrack"));
+    } else if (value_in == MP_OBJ_SENTINEL) {
+        // load
+        if (mp_obj_is_type(index, &mp_type_slice)) {
+            mp_bound_slice_t slice;
+            if (!mp_seq_get_fast_slice_indexes(self->size, index, &slice)) {
+                mp_raise_NotImplementedError(MP_ERROR_TEXT("slices must have step=1"));
+            }
+            return microbit_audio_track_new(self->buffer_obj, slice.stop - slice.start, self->data + slice.start, self->rate);
+        } else {
+            size_t index_val = mp_get_index(self->base.type, self->size, index, false);
+            return MP_OBJ_NEW_SMALL_INT(self->data[index_val]);
+        }
+    } else {
+        // store
+        size_t index_val = mp_get_index(self->base.type, self->size, index, false);
+        mp_int_t value = mp_obj_get_int(value_in);
+        if (value < 0 || value > 255) {
+            mp_raise_ValueError(MP_ERROR_TEXT("value out of range"));
+        }
+        self->data[index_val] = value;
+        return mp_const_none;
+    }
+}
+
+mp_int_t microbit_audio_track_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
+    (void)flags;
+    microbit_audio_track_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    bufinfo->buf = self->data;
+    bufinfo->len = self->size;
+    bufinfo->typecode = 'B';
+    return 0;
+}
+
+static mp_obj_t microbit_audio_track_get_rate(mp_obj_t self_in) {
+    microbit_audio_track_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    return MP_OBJ_NEW_SMALL_INT(self->rate);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(microbit_audio_track_get_rate_obj, microbit_audio_track_get_rate);
+
+static mp_obj_t microbit_audio_track_set_rate(mp_obj_t self_in, mp_obj_t rate_in) {
+    microbit_audio_track_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_int_t rate = mp_obj_get_int_allow_float(rate_in);
+    if (rate <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
+    }
+    self->rate = rate;
+    // TODO: only set if this frame is currently being played
+    microbit_hal_audio_raw_set_rate(rate);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(microbit_audio_track_set_rate_obj, microbit_audio_track_set_rate);
+
+static mp_obj_t microbit_audio_track_copyfrom(mp_obj_t self_in, mp_obj_t other) {
+    microbit_audio_track_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(other, &bufinfo, MP_BUFFER_READ);
+    uint32_t len = MIN(bufinfo.len, self->size);
+    memcpy(self->data, bufinfo.buf, len);
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_2(microbit_audio_track_copyfrom_obj, microbit_audio_track_copyfrom);
+
+static const mp_rom_map_elem_t microbit_audio_track_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_get_rate), MP_ROM_PTR(&microbit_audio_track_get_rate_obj) },
+    { MP_ROM_QSTR(MP_QSTR_set_rate), MP_ROM_PTR(&microbit_audio_track_set_rate_obj) },
+    { MP_ROM_QSTR(MP_QSTR_copyfrom), MP_ROM_PTR(&microbit_audio_track_copyfrom_obj) },
+};
+static MP_DEFINE_CONST_DICT(microbit_audio_track_locals_dict, microbit_audio_track_locals_dict_table);
+
+MP_DEFINE_CONST_OBJ_TYPE(
+    microbit_audio_track_type,
+    MP_QSTR_AudioTrack,
+    MP_TYPE_FLAG_NONE,
+    make_new, microbit_audio_track_make_new,
+    unary_op, microbit_audio_track_unary_op,
+    subscr, microbit_audio_track_subscr,
+    buffer, microbit_audio_track_get_buffer,
+    locals_dict, &microbit_audio_track_locals_dict
+    );
diff --git a/src/codal_port/microbit_microphone.c b/src/codal_port/microbit_microphone.c
index d967b6b..b3ccc79 100644
--- a/src/codal_port/microbit_microphone.c
+++ b/src/codal_port/microbit_microphone.c
@@ -166,9 +166,9 @@ static mp_obj_t microbit_microphone_get_events(mp_obj_t self_in) {
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(microbit_microphone_get_events_obj, microbit_microphone_get_events);
 
-static void microbit_microphone_record_helper(microbit_audio_frame_obj_t *audio_frame, bool wait) {
+static void microbit_microphone_record_helper(microbit_audio_track_obj_t *audio_track, bool wait) {
     // Start the recording.
-    microbit_hal_microphone_start_recording(audio_frame->data, audio_frame->alloc_size, &audio_frame->used_size, audio_frame->rate);
+    microbit_hal_microphone_start_recording(audio_track->data, audio_track->size, &audio_track->size, audio_track->rate);
 
     if (wait) {
         // Wait for the recording to finish.
@@ -182,8 +182,8 @@ static void microbit_microphone_record_helper(microbit_audio_frame_obj_t *audio_
 static mp_obj_t microbit_microphone_record(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_duration, ARG_rate, };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_duration, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
-        { MP_QSTR_rate, MP_ARG_INT, {.u_int = 7812} },
+        { MP_QSTR_duration, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_rate, MP_ARG_INT, {.u_int = AUDIO_TRACK_DEFAULT_SAMPLE_RATE} },
     };
 
     // Parse the args.
@@ -191,30 +191,30 @@ static mp_obj_t microbit_microphone_record(mp_uint_t n_args, const mp_obj_t *pos
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     // Validate arguments.
-    if (args[ARG_duration].u_int <= 0) {
+    mp_float_t duration = mp_obj_get_float(args[ARG_duration].u_obj);
+    if (duration <= 0) {
         mp_raise_ValueError(MP_ERROR_TEXT("duration out of bounds"));
     }
     if (args[ARG_rate].u_int <= 0) {
         mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
     }
 
-    // Create the AudioFrame to record into.
-    size_t size = args[ARG_duration].u_int * args[ARG_rate].u_int / 1000;
-    microbit_audio_frame_obj_t *audio_frame = microbit_audio_frame_make_new(size, args[ARG_rate].u_int);
+    // Create the AudioRecording to record into.
+    size_t size = duration * args[ARG_rate].u_int / 1000;
+    microbit_audio_track_obj_t *audio_track = MP_OBJ_TO_PTR(microbit_audio_recording_new(size, args[ARG_rate].u_int));
 
     // Start recording and wait.
-    microbit_microphone_record_helper(audio_frame, true);
+    microbit_microphone_record_helper(audio_track, true);
 
     // Return the new AudioFrame.
-    return MP_OBJ_FROM_PTR(audio_frame);
+    return MP_OBJ_FROM_PTR(audio_track);
 }
 static MP_DEFINE_CONST_FUN_OBJ_KW(microbit_microphone_record_obj, 1, microbit_microphone_record);
 
 static mp_obj_t microbit_microphone_record_into(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_buffer, ARG_rate, ARG_wait, };
+    enum { ARG_buffer, ARG_wait };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_rate, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_wait, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
     };
 
@@ -223,25 +223,21 @@ static mp_obj_t microbit_microphone_record_into(mp_uint_t n_args, const mp_obj_t
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     // Check that the buffer is an AudioFrame instance.
-    if (!mp_obj_is_type(args[ARG_buffer].u_obj, &microbit_audio_frame_type)) {
-        mp_raise_TypeError(MP_ERROR_TEXT("expecting an AudioFrame"));
-    }
-    microbit_audio_frame_obj_t *audio_frame = MP_OBJ_TO_PTR(args[ARG_buffer].u_obj);
-
-    // Check if the rate is specified.
-    if (args[ARG_rate].u_obj != mp_const_none) {
-        // Update the AudioFrame to use the specified rate.
-        mp_int_t rate = mp_obj_get_int(args[ARG_rate].u_obj);
-        if (rate <= 0) {
-            mp_raise_ValueError(MP_ERROR_TEXT("rate out of bounds"));
-        }
-        audio_frame->rate = rate;
+    // TODO allow both AudioRecording and AudioTrack? yes
+    if (!mp_obj_is_type(args[ARG_buffer].u_obj, &microbit_audio_track_type)
+        && !mp_obj_is_type(args[ARG_buffer].u_obj, &microbit_audio_recording_type)) {
+        mp_raise_TypeError(MP_ERROR_TEXT("expecting an AudioTrack or AudioRecording"));
     }
+    microbit_audio_track_obj_t *audio_track = MP_OBJ_TO_PTR(args[ARG_buffer].u_obj);
+
+    // Create the AudioTrack to record into.
+    microbit_audio_track_obj_t *audio_track_new = MP_OBJ_TO_PTR(microbit_audio_track_new(args[ARG_buffer].u_obj, audio_track->size, audio_track->data, audio_track->rate));
 
     // Start recording and wait if requested.
-    microbit_microphone_record_helper(audio_frame, args[ARG_wait].u_bool);
+    microbit_microphone_record_helper(audio_track_new, args[ARG_wait].u_bool);
 
-    return mp_const_none;
+    // Return the new AudioTrack.
+    return MP_OBJ_FROM_PTR(audio_track_new);
 }
 static MP_DEFINE_CONST_FUN_OBJ_KW(microbit_microphone_record_into_obj, 1, microbit_microphone_record_into);
 
diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 6b099e4..db861f7 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -33,6 +33,7 @@
 
 // Convenience macros to access the root-pointer state.
 #define audio_source_frame MP_STATE_PORT(audio_source_frame_state)
+#define audio_source_track MP_STATE_PORT(audio_source_track_state)
 #define audio_source_iter MP_STATE_PORT(audio_source_iter_state)
 
 #ifndef AUDIO_OUTPUT_BUFFER_SIZE
@@ -56,12 +57,13 @@ static uint32_t audio_current_sound_level;
 static mp_sched_node_t audio_data_fetcher_sched_node;
 
 static inline bool audio_is_running(void) {
-    return audio_source_frame != NULL || audio_source_iter != MP_OBJ_NULL;
+    return audio_source_frame != NULL || audio_source_track != NULL || audio_source_iter != MP_OBJ_NULL;
 }
 
 void microbit_audio_stop(void) {
     audio_output_buffer_offset = 0;
     audio_source_frame = NULL;
+    audio_source_track = NULL;
     audio_source_iter = NULL;
     audio_source_frame_offset = 0;
     audio_current_sound_level = 0;
@@ -75,10 +77,16 @@ static void audio_data_pull_from_source(void) {
             // AudioFrame is exhausted.
             audio_source_frame = NULL;
         }
+    } else if (audio_source_track != NULL) {
+        // An existing AudioTrack is being played, see if there's any data left.
+        if (audio_source_frame_offset >= audio_source_track->size) {
+            // AudioTrack is exhausted.
+            audio_source_track = NULL;
+        }
     }
 
-    if (audio_source_frame == NULL) {
-        // There is no AudioFrame, so try to get one from the audio iterator.
+    if (audio_source_frame == NULL && audio_source_track == NULL) {
+        // There is no AudioFrame/AudioTrack, so try to get one from the audio iterator.
 
         if (audio_source_iter == MP_OBJ_NULL) {
             // Audio iterator is already exhausted.
@@ -104,17 +112,24 @@ static void audio_data_pull_from_source(void) {
             microbit_audio_stop();
             return;
         }
-        if (!mp_obj_is_type(frame_obj, &microbit_audio_frame_type)) {
-            // Audio iterator did not return an AudioFrame.
+
+        if (mp_obj_is_type(frame_obj, &microbit_audio_frame_type)) {
+            // We have the next AudioFrame.
+            audio_source_frame = MP_OBJ_TO_PTR(frame_obj);
+            audio_source_frame_offset = 0;
+            microbit_hal_audio_raw_set_rate(audio_source_frame->rate);
+        } else if (mp_obj_is_type(frame_obj, &microbit_audio_track_type)
+            || mp_obj_is_type(frame_obj, &microbit_audio_recording_type)) {
+            // We have the next AudioTrack/AudioRecording.
+            audio_source_track = MP_OBJ_TO_PTR(frame_obj);
+            audio_source_frame_offset = 0;
+            microbit_hal_audio_raw_set_rate(audio_source_track->rate);
+        } else {
+            // Audio iterator did not return an AudioFrame/AudioTrack/AudioRecording.
             microbit_audio_stop();
             mp_sched_exception(mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("not an AudioFrame")));
             return;
         }
-
-        // We have the next AudioFrame.
-        audio_source_frame = MP_OBJ_TO_PTR(frame_obj);
-        audio_source_frame_offset = 0;
-        microbit_hal_audio_raw_set_rate(audio_source_frame->rate);
     }
 }
 
@@ -122,7 +137,7 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
     audio_data_pull_from_source();
     uint8_t *dest = &audio_output_buffer[audio_output_buffer_offset];
 
-    if (audio_source_frame == NULL) {
+    if (audio_source_frame == NULL && audio_source_track == NULL) {
         // Audio source is exhausted.
 
         if (audio_output_buffer_offset == 0) {
@@ -135,8 +150,16 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
         audio_output_buffer_offset = AUDIO_OUTPUT_BUFFER_SIZE;
     } else {
         // Copy samples to the buffer.
-        const uint8_t *src = &audio_source_frame->data[audio_source_frame_offset];
-        size_t src_len = MIN(audio_source_frame->used_size - audio_source_frame_offset, AUDIO_OUTPUT_BUFFER_SIZE - audio_output_buffer_offset);
+        const uint8_t *src;
+        size_t size;
+        if (audio_source_frame != NULL) {
+            src = &audio_source_frame->data[audio_source_frame_offset];
+            size = audio_source_frame->used_size;
+        } else {
+            src = &audio_source_track->data[audio_source_frame_offset];
+            size = audio_source_track->size;
+        }
+        size_t src_len = MIN(size - audio_source_frame_offset, AUDIO_OUTPUT_BUFFER_SIZE - audio_output_buffer_offset);
         memcpy(dest, src, src_len);
 
         // Update output and source offsets.
@@ -205,6 +228,11 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
         audio_source_frame = MP_OBJ_TO_PTR(src);
         audio_source_frame_offset = 0;
         microbit_hal_audio_raw_set_rate(audio_source_frame->rate);
+    } else if (mp_obj_is_type(src, &microbit_audio_track_type)
+        || mp_obj_is_type(src, &microbit_audio_recording_type)) {
+        audio_source_track = MP_OBJ_TO_PTR(src);
+        audio_source_frame_offset = 0;
+        microbit_hal_audio_raw_set_rate(audio_source_track->rate);
     } else if (mp_obj_is_type(src, &mp_type_tuple) || mp_obj_is_type(src, &mp_type_list)) {
         // A tuple/list passed in.  Need to check if it contains SoundEffect instances.
         size_t len;
@@ -313,6 +341,8 @@ static const mp_rom_map_elem_t audio_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_is_playing), MP_ROM_PTR(&microbit_audio_is_playing_obj) },
     { MP_ROM_QSTR(MP_QSTR_sound_level), MP_ROM_PTR(&microbit_audio_sound_level_obj) },
     { MP_ROM_QSTR(MP_QSTR_AudioFrame), MP_ROM_PTR(&microbit_audio_frame_type) },
+    { MP_ROM_QSTR(MP_QSTR_AudioRecording), MP_ROM_PTR(&microbit_audio_recording_type) },
+    { MP_ROM_QSTR(MP_QSTR_AudioTrack), MP_ROM_PTR(&microbit_audio_track_type) },
     { MP_ROM_QSTR(MP_QSTR_SoundEffect), MP_ROM_PTR(&microbit_soundeffect_type) },
 };
 static MP_DEFINE_CONST_DICT(audio_module_globals, audio_globals_table);
@@ -555,4 +585,5 @@ microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size, uint32_t
 }
 
 MP_REGISTER_ROOT_POINTER(struct _microbit_audio_frame_obj_t *audio_source_frame_state);
+MP_REGISTER_ROOT_POINTER(struct _microbit_audio_track_obj_t *audio_source_track_state);
 MP_REGISTER_ROOT_POINTER(mp_obj_t audio_source_iter_state);
diff --git a/src/codal_port/modaudio.h b/src/codal_port/modaudio.h
index ec54fcc..f3747d8 100644
--- a/src/codal_port/modaudio.h
+++ b/src/codal_port/modaudio.h
@@ -30,6 +30,7 @@
 #include "py/runtime.h"
 
 #define SOUND_EXPR_TOTAL_LENGTH (72)
+#define AUDIO_TRACK_DEFAULT_SAMPLE_RATE (7812)
 
 typedef struct _microbit_audio_frame_obj_t {
     mp_obj_base_t base;
@@ -39,7 +40,17 @@ typedef struct _microbit_audio_frame_obj_t {
     uint8_t data[];
 } microbit_audio_frame_obj_t;
 
+typedef struct _microbit_audio_track_obj_t {
+    mp_obj_base_t base;
+    mp_obj_t buffer_obj; // so GC can't reclaim the underlying buffer
+    size_t size;
+    uint32_t rate;
+    uint8_t *data;
+} microbit_audio_track_obj_t;
+
 extern const mp_obj_type_t microbit_audio_frame_type;
+extern const mp_obj_type_t microbit_audio_recording_type;
+extern const mp_obj_type_t microbit_audio_track_type;
 extern const mp_obj_module_t audio_module;
 
 void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, uint32_t sample_rate);
@@ -47,7 +58,13 @@ void microbit_audio_stop(void);
 bool microbit_audio_is_playing(void);
 
 microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size, uint32_t rate);
+mp_obj_t microbit_audio_track_new(mp_obj_t buffer_obj, size_t len, uint8_t *data, uint32_t rate);
+mp_obj_t microbit_audio_recording_new(size_t num_bytes, uint32_t rate);
 
 const char *microbit_soundeffect_get_sound_expr_data(mp_obj_t self_in);
 
+mp_int_t microbit_audio_track_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags);
+MP_DECLARE_CONST_FUN_OBJ_1(microbit_audio_track_get_rate_obj);
+MP_DECLARE_CONST_FUN_OBJ_2(microbit_audio_track_set_rate_obj);
+
 #endif // MICROPY_INCLUDED_MICROBIT_MODAUDIO_H
diff --git a/src/codal_port/utils.c b/src/codal_port/utils.c
new file mode 100644
index 0000000..d070417
--- /dev/null
+++ b/src/codal_port/utils.c
@@ -0,0 +1,35 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "utils.h"
+
+mp_int_t mp_obj_get_int_allow_float(mp_obj_t obj) {
+    if (mp_obj_is_integer(obj)) {
+        return mp_obj_get_int(obj);
+    } else {
+        return (mp_int_t)mp_obj_get_float(obj);
+    }
+}
diff --git a/src/codal_port/utils.h b/src/codal_port/utils.h
new file mode 100644
index 0000000..a398e81
--- /dev/null
+++ b/src/codal_port/utils.h
@@ -0,0 +1,33 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_CODAL_PORT_UTILS_H
+#define MICROPY_INCLUDED_CODAL_PORT_UTILS_H
+
+#include "py/runtime.h"
+
+mp_int_t mp_obj_get_int_allow_float(mp_obj_t obj);
+
+#endif // MICROPY_INCLUDED_CODAL_PORT_UTILS_H

From 3fba8c968951c1f84bbff62e81a178176a2bdc72 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Fri, 2 Aug 2024 16:04:11 +1000
Subject: [PATCH 39/50] src: Update test_record.py.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/test_record.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/test_record.py b/src/test_record.py
index 3bd8b0a..20d2306 100644
--- a/src/test_record.py
+++ b/src/test_record.py
@@ -22,11 +22,11 @@
     "00000"
 )
 
-my_recording = audio.AudioFrame(5000)
+my_recording = audio.AudioRecording(duration=5000)
 
 while True:
     if button_a.is_pressed():
-        microphone.record_into(my_recording, wait=False)
+        my_track = microphone.record_into(my_recording, wait=False)
         display.show([mouth_open, mouth_closed], loop=True, wait=False, delay=150)
         while button_a.is_pressed() and microphone.is_recording():
             sleep(50)
@@ -35,9 +35,13 @@
         while button_a.is_pressed():
             sleep(50)
         display.clear()
-        my_recording *= 2  # amplify volume
+        # amplify volume
+        GAIN = 2
+        #my_recording *= GAIN
+        for i in range(len(my_track)):
+            my_track[i] = max(0, min(128 + GAIN * (my_track[i] - 128), 255))
     if button_b.is_pressed():
-        audio.play(my_recording, wait=False)
+        audio.play(my_track, wait=False)
         level = 0
         while audio.is_playing():
             l = audio.sound_level()
@@ -47,7 +51,7 @@
                 level *= 0.95
             display.show(play * min(1, level / 100))
             x = accelerometer.get_x()
-            my_recording.set_rate(max(2250, scale(x, (-1000, 1000), (2250, 13374))))
+            my_track.set_rate(max(2250, scale(x, (-1000, 1000), (2250, 13374))))
             sleep(5)
         display.clear()
     sleep(100)

From 96a24ff82d39b7310903327476e6add0c06c6ed3 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 5 Aug 2024 11:45:00 +1000
Subject: [PATCH 40/50] codal_port/modaudio: Remove used_size entry from
 AudioFrame type.

It's no longer needed now that there is AudioTrack.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 11 ++---------
 src/codal_port/modaudio.h |  1 -
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index db861f7..36d1e7e 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -73,7 +73,7 @@ void microbit_audio_stop(void) {
 static void audio_data_pull_from_source(void) {
     if (audio_source_frame != NULL) {
         // An existing AudioFrame is being played, see if there's any data left.
-        if (audio_source_frame_offset >= audio_source_frame->used_size) {
+        if (audio_source_frame_offset >= audio_source_frame->alloc_size) {
             // AudioFrame is exhausted.
             audio_source_frame = NULL;
         }
@@ -154,7 +154,7 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
         size_t size;
         if (audio_source_frame != NULL) {
             src = &audio_source_frame->data[audio_source_frame_offset];
-            size = audio_source_frame->used_size;
+            size = audio_source_frame->alloc_size;
         } else {
             src = &audio_source_track->data[audio_source_frame_offset];
             size = audio_source_track->size;
@@ -405,7 +405,6 @@ static mp_obj_t audio_frame_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t
             mp_raise_ValueError(MP_ERROR_TEXT("value out of range"));
         }
         self->data[index] = value;
-        self->used_size = MAX(self->used_size, index + 1);
         return mp_const_none;
     }
 }
@@ -426,10 +425,6 @@ static mp_int_t audio_frame_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufin
     bufinfo->buf = self->data;
     bufinfo->len = self->alloc_size;
     bufinfo->typecode = 'B';
-    if (flags == MP_BUFFER_WRITE) {
-        // Assume that writing to the buffer will make all data valid for playback.
-        self->used_size = self->alloc_size;
-    }
     return 0;
 }
 
@@ -448,7 +443,6 @@ static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_
 
 static microbit_audio_frame_obj_t *copy(microbit_audio_frame_obj_t *self) {
     microbit_audio_frame_obj_t *result = microbit_audio_frame_make_new(self->alloc_size, self->rate);
-    result->used_size = self->used_size;
     for (int i = 0; i < self->alloc_size; i++) {
         result->data[i] = self->data[i];
     }
@@ -578,7 +572,6 @@ microbit_audio_frame_obj_t *microbit_audio_frame_make_new(size_t size, uint32_t
     microbit_audio_frame_obj_t *res = m_new_obj_var(microbit_audio_frame_obj_t, data, uint8_t, size);
     res->base.type = &microbit_audio_frame_type;
     res->alloc_size = size;
-    res->used_size = 0;
     res->rate = rate;
     memset(res->data, 128, size);
     return res;
diff --git a/src/codal_port/modaudio.h b/src/codal_port/modaudio.h
index f3747d8..ddf32a1 100644
--- a/src/codal_port/modaudio.h
+++ b/src/codal_port/modaudio.h
@@ -35,7 +35,6 @@
 typedef struct _microbit_audio_frame_obj_t {
     mp_obj_base_t base;
     size_t alloc_size;
-    size_t used_size;
     uint32_t rate;
     uint8_t data[];
 } microbit_audio_frame_obj_t;

From 02e5289a862b1bbcfc033adf11e54d19cdf1d997 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 21 Aug 2024 12:31:40 +1000
Subject: [PATCH 41/50] codal_port/modaudio: Make AudioFrame add and mult
 helpers public.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 21 +++++++++++----------
 src/codal_port/modaudio.h |  3 +++
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 36d1e7e..b4b7c70 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -428,16 +428,15 @@ static mp_int_t audio_frame_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufin
     return 0;
 }
 
-static void add_into(microbit_audio_frame_obj_t *self, microbit_audio_frame_obj_t *other, bool add) {
+void microbit_audio_data_add_inplace(uint8_t *lhs_data, const uint8_t *rhs_data, size_t size, bool add) {
     int mult = add ? 1 : -1;
-    size_t size = MIN(self->alloc_size, other->alloc_size);
     for (int i = 0; i < size; i++) {
-        unsigned val = (int)self->data[i] + mult*(other->data[i]-128);
+        unsigned val = (int)lhs_data[i] + mult*(rhs_data[i]-128);
         // Clamp to 0-255
         if (val > 255) {
             val = (1-(val>>31))*255;
         }
-        self->data[i] = val;
+        lhs_data[i] = val;
     }
 }
 
@@ -488,14 +487,14 @@ int32_t float_to_fixed(float f, uint32_t scale) {
     return result;
 }
 
-static void mult(microbit_audio_frame_obj_t *self, float f) {
+void microbit_audio_data_mult_inplace(uint8_t *data, size_t size, float f) {
     int scaled = float_to_fixed(f, 15);
-    for (int i = 0; i < self->alloc_size; i++) {
-        unsigned val = ((((int)self->data[i]-128) * scaled) >> 15)+128;
+    for (int i = 0; i < size; i++) {
+        unsigned val = ((((int)data[i]-128) * scaled) >> 15)+128;
         if (val > 255) {
             val = (1-(val>>31))*255;
         }
-        self->data[i] = val;
+        data[i] = val;
     }
 }
 
@@ -513,12 +512,14 @@ static mp_obj_t audio_frame_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj
             if (mp_obj_get_type(rhs_in) != &microbit_audio_frame_type) {
                 return MP_OBJ_NULL; // op not supported
             }
-            add_into(lhs, (microbit_audio_frame_obj_t *)rhs_in, op==MP_BINARY_OP_ADD||op==MP_BINARY_OP_INPLACE_ADD);
+            microbit_audio_frame_obj_t *rhs = MP_OBJ_TO_PTR(rhs_in);
+            size_t size = MIN(lhs->alloc_size, rhs->alloc_size);
+            microbit_audio_data_add_inplace(lhs->data, rhs->data, size, op == MP_BINARY_OP_ADD || op == MP_BINARY_OP_INPLACE_ADD);
             return lhs;
         case MP_BINARY_OP_MULTIPLY:
             lhs = copy(lhs);
         case MP_BINARY_OP_INPLACE_MULTIPLY:
-            mult(lhs, mp_obj_get_float(rhs_in));
+            microbit_audio_data_mult_inplace(lhs->data, lhs->alloc_size, mp_obj_get_float(rhs_in));
             return lhs;
         default:
             return MP_OBJ_NULL; // op not supported
diff --git a/src/codal_port/modaudio.h b/src/codal_port/modaudio.h
index ddf32a1..b3440e4 100644
--- a/src/codal_port/modaudio.h
+++ b/src/codal_port/modaudio.h
@@ -52,6 +52,9 @@ extern const mp_obj_type_t microbit_audio_recording_type;
 extern const mp_obj_type_t microbit_audio_track_type;
 extern const mp_obj_module_t audio_module;
 
+void microbit_audio_data_add_inplace(uint8_t *lhs_data, const uint8_t *rhs_data, size_t size, bool add);
+void microbit_audio_data_mult_inplace(uint8_t *data, size_t size, float f);
+
 void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, uint32_t sample_rate);
 void microbit_audio_stop(void);
 bool microbit_audio_is_playing(void);

From 30251c7fc6bf7c3728ad996a1c2fb4447673e05b Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 21 Aug 2024 12:32:02 +1000
Subject: [PATCH 42/50] codal_port/microbit_audiotrack: Implement
 +,+=,-,-=,*,*= on AudioTrack.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_audiotrack.c | 32 ++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/src/codal_port/microbit_audiotrack.c b/src/codal_port/microbit_audiotrack.c
index 049c062..a645197 100644
--- a/src/codal_port/microbit_audiotrack.c
+++ b/src/codal_port/microbit_audiotrack.c
@@ -81,6 +81,37 @@ static mp_obj_t microbit_audio_track_unary_op(mp_unary_op_t op, mp_obj_t self_in
     }
 }
 
+static mp_obj_t microbit_audio_track_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
+    microbit_audio_track_obj_t *lhs = MP_OBJ_TO_PTR(lhs_in);
+
+    // Make a copy of LHS if the operation is not inplace.
+    if (op == MP_BINARY_OP_ADD || op == MP_BINARY_OP_SUBTRACT || op == MP_BINARY_OP_MULTIPLY) {
+        microbit_audio_track_obj_t *lhs_copy = microbit_audio_track_new(lhs->buffer_obj, lhs->size, lhs->data, lhs->rate);
+        memcpy(lhs_copy->data, lhs->data, lhs->size);
+        lhs = lhs_copy;
+    }
+
+    switch(op) {
+        case MP_BINARY_OP_ADD:
+        case MP_BINARY_OP_SUBTRACT:
+        case MP_BINARY_OP_INPLACE_ADD:
+        case MP_BINARY_OP_INPLACE_SUBTRACT:
+            if (mp_obj_get_type(rhs_in) != &microbit_audio_track_type) {
+                return MP_OBJ_NULL; // op not supported
+            }
+            microbit_audio_track_obj_t *rhs = MP_OBJ_TO_PTR(rhs_in);
+            size_t size = MIN(lhs->size, rhs->size);
+            microbit_audio_data_add_inplace(lhs->data, rhs->data, size, op == MP_BINARY_OP_ADD || op == MP_BINARY_OP_INPLACE_ADD);
+            return lhs;
+        case MP_BINARY_OP_MULTIPLY:
+        case MP_BINARY_OP_INPLACE_MULTIPLY:
+            microbit_audio_data_mult_inplace(lhs->data, lhs->size, mp_obj_get_float(rhs_in));
+            return lhs;
+        default:
+            return MP_OBJ_NULL; // op not supported
+    }
+}
+
 static mp_obj_t microbit_audio_track_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value_in) {
     microbit_audio_track_obj_t *self = MP_OBJ_TO_PTR(self_in);
     if (value_in == MP_OBJ_NULL) {
@@ -161,6 +192,7 @@ MP_DEFINE_CONST_OBJ_TYPE(
     MP_TYPE_FLAG_NONE,
     make_new, microbit_audio_track_make_new,
     unary_op, microbit_audio_track_unary_op,
+    binary_op, microbit_audio_track_binary_op,
     subscr, microbit_audio_track_subscr,
     buffer, microbit_audio_track_get_buffer,
     locals_dict, &microbit_audio_track_locals_dict

From ceb13c83a1a4311f6eace5b7648041e32e5cf764 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 21 Aug 2024 12:37:49 +1000
Subject: [PATCH 43/50] src: Update test_record.py to use mult for volume.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/test_record.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/test_record.py b/src/test_record.py
index 20d2306..1f83c5e 100644
--- a/src/test_record.py
+++ b/src/test_record.py
@@ -35,11 +35,7 @@
         while button_a.is_pressed():
             sleep(50)
         display.clear()
-        # amplify volume
-        GAIN = 2
-        #my_recording *= GAIN
-        for i in range(len(my_track)):
-            my_track[i] = max(0, min(128 + GAIN * (my_track[i] - 128), 255))
+        my_track *= 2  # amplify volume
     if button_b.is_pressed():
         audio.play(my_track, wait=False)
         level = 0

From e337b9431df53f593d1b77f2fe3580f7285901a7 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 22 Aug 2024 10:58:14 +1000
Subject: [PATCH 44/50] src: In test_record.py, make sure my_track is defined.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/test_record.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/test_record.py b/src/test_record.py
index 1f83c5e..a99696f 100644
--- a/src/test_record.py
+++ b/src/test_record.py
@@ -23,6 +23,7 @@
 )
 
 my_recording = audio.AudioRecording(duration=5000)
+my_track = None
 
 while True:
     if button_a.is_pressed():
@@ -36,7 +37,7 @@
             sleep(50)
         display.clear()
         my_track *= 2  # amplify volume
-    if button_b.is_pressed():
+    if button_b.is_pressed() and my_track:
         audio.play(my_track, wait=False)
         level = 0
         while audio.is_playing():

From d4c7b67dc8e9cf84bc66eedb4c9e0e496e6b3c81 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 26 Aug 2024 11:11:36 +1000
Subject: [PATCH 45/50] codal_port/microbit_audiorecording: Make track() args
 positional.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/microbit_audiorecording.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/codal_port/microbit_audiorecording.c b/src/codal_port/microbit_audiorecording.c
index 2b3422d..6de7974 100644
--- a/src/codal_port/microbit_audiorecording.c
+++ b/src/codal_port/microbit_audiorecording.c
@@ -78,8 +78,8 @@ static MP_DEFINE_CONST_FUN_OBJ_1(microbit_audio_recording_copy_obj, microbit_aud
 static mp_obj_t microbit_audio_recording_track(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_start_ms, ARG_end_ms };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_start_ms, MP_ARG_KW_ONLY, {.u_rom_obj = MP_ROM_INT(0)} },
-        { MP_QSTR_end_ms, MP_ARG_KW_ONLY, {.u_rom_obj = MP_ROM_INT(-1)} },
+        { MP_QSTR_start_ms, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_INT(0)} },
+        { MP_QSTR_end_ms, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_INT(-1)} },
     };
     // parse args
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];

From 5cc0cb0b283af52f3f9a2ddb8d57400af930c47b Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 9 Sep 2024 11:09:53 +1000
Subject: [PATCH 46/50] src: Use was_pressed in test_record.py.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/test_record.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test_record.py b/src/test_record.py
index a99696f..ef81f9e 100644
--- a/src/test_record.py
+++ b/src/test_record.py
@@ -26,7 +26,7 @@
 my_track = None
 
 while True:
-    if button_a.is_pressed():
+    if button_a.was_pressed():
         my_track = microphone.record_into(my_recording, wait=False)
         display.show([mouth_open, mouth_closed], loop=True, wait=False, delay=150)
         while button_a.is_pressed() and microphone.is_recording():
@@ -37,7 +37,7 @@
             sleep(50)
         display.clear()
         my_track *= 2  # amplify volume
-    if button_b.is_pressed() and my_track:
+    if button_b.was_pressed() and my_track:
         audio.play(my_track, wait=False)
         level = 0
         while audio.is_playing():

From 5b36b01034fe99329e2e11133084a64fa7b577ba Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 9 Sep 2024 13:14:32 +1000
Subject: [PATCH 47/50] codal_port/modaudio: Improve feeding of audio pipeline.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index b4b7c70..e22cf37 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -37,7 +37,7 @@
 #define audio_source_iter MP_STATE_PORT(audio_source_iter_state)
 
 #ifndef AUDIO_OUTPUT_BUFFER_SIZE
-#define AUDIO_OUTPUT_BUFFER_SIZE (32)
+#define AUDIO_OUTPUT_BUFFER_SIZE (64)
 #endif
 
 #define DEFAULT_AUDIO_FRAME_SIZE (32)
@@ -56,6 +56,8 @@ static size_t audio_source_frame_offset;
 static uint32_t audio_current_sound_level;
 static mp_sched_node_t audio_data_fetcher_sched_node;
 
+static void audio_data_schedule_fetch(void);
+
 static inline bool audio_is_running(void) {
     return audio_source_frame != NULL || audio_source_track != NULL || audio_source_iter != MP_OBJ_NULL;
 }
@@ -169,7 +171,7 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
 
     if (audio_output_buffer_offset < AUDIO_OUTPUT_BUFFER_SIZE) {
         // Output buffer not full yet, so attempt to pull more data from the source.
-        mp_sched_schedule_node(&audio_data_fetcher_sched_node, audio_data_fetcher);
+        audio_data_schedule_fetch();
     } else {
         // Output buffer is full, process it and prepare for next buffer fill.
         audio_output_buffer_offset = 0;
@@ -192,6 +194,18 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
     }
 }
 
+static void audio_data_schedule_fetch(void) {
+    if (audio_source_track != NULL && audio_source_frame_offset < audio_source_track->size) {
+        // An existing AudioTrack is being played, and still has some data remaining,
+        // so fetch that immediately.  This helps to keep audio playback smooth when the
+        // playback rate is large.
+        audio_data_fetcher(&audio_data_fetcher_sched_node);
+    } else {
+        // Schedule audio_data_fetcher to be executed ASAP to try and fetch more data.
+        mp_sched_schedule_node(&audio_data_fetcher_sched_node, audio_data_fetcher);
+    }
+}
+
 void microbit_hal_audio_raw_ready_callback(void) {
     if (audio_output_state == AUDIO_OUTPUT_STATE_DATA_READY) {
         // there is data ready to send out to the audio pipeline, so send it
@@ -202,8 +216,8 @@ void microbit_hal_audio_raw_ready_callback(void) {
         audio_output_state = AUDIO_OUTPUT_STATE_IDLE;
     }
 
-    // schedule audio_data_fetcher to be executed to prepare the next buffer
-    mp_sched_schedule_node(&audio_data_fetcher_sched_node, audio_data_fetcher);
+    // Schedule the next fetch of audio data.
+    audio_data_schedule_fetch();
 }
 
 static void audio_init(uint32_t sample_rate) {

From 311dece8786baa7d2d58b7136166d4250d0fffb0 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 9 Sep 2024 13:26:36 +1000
Subject: [PATCH 48/50] codal_app/microbithal_audio: Add
 microbit_hal_audio_is_playing() func.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_app/microbithal.h         | 1 +
 src/codal_app/microbithal_audio.cpp | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/src/codal_app/microbithal.h b/src/codal_app/microbithal.h
index d9bafc6..78c75e9 100644
--- a/src/codal_app/microbithal.h
+++ b/src/codal_app/microbithal.h
@@ -185,6 +185,7 @@ int microbit_hal_log_data(const char *key, const char *value);
 void microbit_hal_audio_select_pin(int pin);
 void microbit_hal_audio_select_speaker(bool enable);
 void microbit_hal_audio_set_volume(int value);
+bool microbit_hal_audio_is_playing(void);
 bool microbit_hal_audio_is_expression_active(void);
 void microbit_hal_audio_play_expression(const char *expr);
 void microbit_hal_audio_stop_expression(void);
diff --git a/src/codal_app/microbithal_audio.cpp b/src/codal_app/microbithal_audio.cpp
index 0810434..b60c172 100644
--- a/src/codal_app/microbithal_audio.cpp
+++ b/src/codal_app/microbithal_audio.cpp
@@ -86,6 +86,10 @@ void microbit_hal_sound_synth_callback(int event) {
     }
 }
 
+bool microbit_hal_audio_is_playing(void) {
+    return uBit.audio.isPlaying();
+}
+
 bool microbit_hal_audio_is_expression_active(void) {
     return sound_synth_active_count > 0;
 }

From 4c957c4caa7115e99bb84454b3b660f0019e0d30 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 9 Sep 2024 13:26:53 +1000
Subject: [PATCH 49/50] codal_port/modaudio: Make audio waiting wait for audio
 to be silent.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index e22cf37..99af69f 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -301,7 +301,7 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
 
     if (wait) {
         // Wait the audio to exhaust the iterator.
-        while (audio_is_running()) {
+        while (microbit_audio_is_playing()) {
             mp_handle_pending(true);
             microbit_hal_idle();
         }
@@ -333,7 +333,9 @@ static mp_obj_t play(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
 MP_DEFINE_CONST_FUN_OBJ_KW(microbit_audio_play_obj, 0, play);
 
 bool microbit_audio_is_playing(void) {
-    return audio_is_running() || microbit_hal_audio_is_expression_active();
+    return audio_is_running()
+        || microbit_hal_audio_is_playing()
+        || microbit_hal_audio_is_expression_active();
 }
 
 mp_obj_t is_playing(void) {

From df4cb051ec75b06572fe3743757af6c0d578ce16 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 18 Sep 2024 12:01:14 +1000
Subject: [PATCH 50/50] codal_port/modaudio: Make sure final partial audio data
 is sent out.

Signed-off-by: Damien George <damien@micropython.org>
---
 src/codal_port/modaudio.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
index 99af69f..f31ff88 100644
--- a/src/codal_port/modaudio.c
+++ b/src/codal_port/modaudio.c
@@ -66,7 +66,7 @@ void microbit_audio_stop(void) {
     audio_output_buffer_offset = 0;
     audio_source_frame = NULL;
     audio_source_track = NULL;
-    audio_source_iter = NULL;
+    audio_source_iter = MP_OBJ_NULL;
     audio_source_frame_offset = 0;
     audio_current_sound_level = 0;
     microbit_hal_audio_stop_expression();
@@ -92,7 +92,6 @@ static void audio_data_pull_from_source(void) {
 
         if (audio_source_iter == MP_OBJ_NULL) {
             // Audio iterator is already exhausted.
-            microbit_audio_stop();
             return;
         }
 
@@ -111,7 +110,7 @@ static void audio_data_pull_from_source(void) {
         }
         if (frame_obj == MP_OBJ_STOP_ITERATION) {
             // End of audio iterator.
-            microbit_audio_stop();
+            audio_source_iter = MP_OBJ_NULL;
             return;
         }
 
@@ -128,7 +127,7 @@ static void audio_data_pull_from_source(void) {
             microbit_hal_audio_raw_set_rate(audio_source_track->rate);
         } else {
             // Audio iterator did not return an AudioFrame/AudioTrack/AudioRecording.
-            microbit_audio_stop();
+            audio_source_iter = MP_OBJ_NULL;
             mp_sched_exception(mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("not an AudioFrame")));
             return;
         }
@@ -144,6 +143,7 @@ static void audio_data_fetcher(mp_sched_node_t *node) {
 
         if (audio_output_buffer_offset == 0) {
             // No output data left, finish output streaming.
+            microbit_audio_stop();
             return;
         }