Add record method.

Author: relic-se

ports/raspberrypi/audio_dma.c

@@ -677,13 +677,7 @@ uint8_t *audio_dma_get_buffer(audio_dma_t *dma) {
     if (!dma->input_register_address || dma->input_index >= 2) {
         return NULL;
     }
-    uint8_t *buffer = dma->input_buffer[dma->input_index];
-    dma->input_index = -1;
-    return buffer;
-}
-
-bool audio_dma_has_buffer(audio_dma_t *dma) {
-    return dma->input_register_address && dma->input_index < 2;
+    return dma->input_buffer[dma->input_index];
 }
 
 // WARN(tannewt): DO NOT print from here, or anything it calls. Printing calls

ports/raspberrypi/audio_dma.h

@@ -100,7 +100,6 @@ void audio_dma_stop_input(audio_dma_t *dma);
 bool audio_dma_get_playing(audio_dma_t *dma);
 bool audio_dma_get_recording(audio_dma_t *dma);
 uint8_t *audio_dma_get_buffer(audio_dma_t *dma);
-bool audio_dma_has_buffer(audio_dma_t *dma);
 void audio_dma_pause(audio_dma_t *dma);
 void audio_dma_resume(audio_dma_t *dma);
 bool audio_dma_get_paused(audio_dma_t *dma);

ports/raspberrypi/common-hal/audiobusio/I2S.c

@@ -164,6 +164,43 @@ void common_hal_audiobusio_i2s_deinit(audiobusio_i2s_obj_t *self) {
     audio_dma_deinit(&self->dma);
 }
 
+// output_buffer may be a byte buffer or a halfword buffer.
+// output_buffer_length is the number of slots, not the number of bytes.
+void common_hal_audiobusio_i2s_record_to_buffer(audiobusio_i2s_obj_t *self,
+    int16_t *output_buffer, uint32_t output_buffer_length) {
+    if (!self->state_machine.in) {
+        mp_raise_RuntimeError(MP_ERROR_TEXT("No data in"));
+    }
+
+    // Make sure that dma is running.
+    i2s_configure_audio_dma(self, self, true, self->sample_rate, self->bits_per_sample);
+
+    size_t output_count = 0;
+    int16_t *buffer;
+    size_t buffer_length;
+
+    while (output_count < output_buffer_length) {
+        // Do other things while we wait for the buffer to fill.
+        while (self->last_record_index == self->dma.input_index) {
+            if (self->state_machine.out) {
+                common_hal_mcu_delay_us(1000000 / self->sample_rate);
+            } else {
+                RUN_BACKGROUND_TASKS;
+            }
+        }
+        self->last_record_index = self->dma.input_index;
+
+        buffer = (int16_t *)audio_dma_get_buffer(&self->dma);
+        buffer_length = MIN((output_buffer_length - output_count), self->buffer_size / sizeof(int16_t));
+
+        for (size_t i = 0; i < buffer_length; i++) {
+            output_buffer[i + output_count] = buffer[i];
+        }
+
+        output_count += buffer_length;
+    }
+}
+
 void common_hal_audiobusio_i2s_play(audiobusio_i2s_obj_t *self,
     mp_obj_t sample, bool loop) {
     if (!self->state_machine.out) {
@@ -273,6 +310,8 @@ void audiobusio_i2s_reset_buffer(audiobusio_i2s_obj_t *self,
     }
 
     i2s_configure_audio_dma(self, self, true, self->sample_rate, self->bits_per_sample);
+    self->last_record_index = -1;
+    self->last_sample_index = -1;
 }
 
 audioio_get_buffer_result_t audiobusio_i2s_get_buffer(audiobusio_i2s_obj_t *self,
@@ -289,13 +328,14 @@ audioio_get_buffer_result_t audiobusio_i2s_get_buffer(audiobusio_i2s_obj_t *self
     }
 
     // Do other things while we wait for the buffer to fill.
-    while (!audio_dma_has_buffer(&self->dma)) {
+    while (self->last_sample_index == self->dma.input_index) {
         if (self->state_machine.out) {
             common_hal_mcu_delay_us(1000000 / self->sample_rate);
         } else {
             RUN_BACKGROUND_TASKS;
         }
     }
+    self->last_sample_index = self->dma.input_index;
 
     *buffer_length = self->buffer_size;
     *buffer = audio_dma_get_buffer(&self->dma);

ports/raspberrypi/common-hal/audiobusio/I2S.h

@@ -26,6 +26,8 @@ typedef struct {
     uint32_t sample_rate;
     uint8_t bits_per_sample;
     bool samples_signed;
+    uint8_t last_sample_index;
+    uint8_t last_record_index;
 } audiobusio_i2s_obj_t;
 
 // These are not available from Python because it may be called in an interrupt.

ports/raspberrypi/common-hal/audiobusio/I2SIn.c

@@ -293,6 +293,8 @@ void audiobusio_i2sin_reset_buffer(audiobusio_i2sin_obj_t *self,
         common_hal_rp2pio_statemachine_stop(&self->state_machine);
         mp_raise_RuntimeError(MP_ERROR_TEXT("Unable to allocate buffers for signed conversion"));
     }
+
+    self->last_index = -1;
 }
 
 audioio_get_buffer_result_t audiobusio_i2sin_get_buffer(audiobusio_i2sin_obj_t *self,
@@ -301,10 +303,8 @@ audioio_get_buffer_result_t audiobusio_i2sin_get_buffer(audiobusio_i2sin_obj_t *
     uint8_t **buffer,
     uint32_t *buffer_length) {
 
-    // TODO: single_channel_output
-
     // Do other things while we wait for the buffer to fill.
-    while (!audio_dma_has_buffer(&self->dma)) {
+    while (self->last_index == self->dma.input_index) {
         RUN_BACKGROUND_TASKS;
     }
 

ports/raspberrypi/common-hal/audiobusio/I2SIn.h

@@ -26,6 +26,7 @@ typedef struct {
     uint32_t sample_rate;
     uint8_t bits_per_sample;
     bool samples_signed;
+    uint8_t last_index;
 } audiobusio_i2sin_obj_t;
 
 

shared-bindings/audiobusio/I2S.c

@@ -179,6 +179,42 @@ static mp_obj_t audiobusio_i2s_obj___exit__(size_t n_args, const mp_obj_t *args)
 }
 static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(audiobusio_i2s___exit___obj, 4, 4, audiobusio_i2s_obj___exit__);
 
+//|     def record(self, destination: WriteableBuffer, destination_length: int) -> None:
+//|         """Records destination_length bytes of samples to destination. This is
+//|         blocking.
+//|
+//|         An IOError may be raised when the destination is too slow to record the
+//|         audio at the given rate. For internal flash, writing all 1s to the file
+//|         before recording is recommended to speed up writes.
+//|
+//|         :return: The number of samples recorded. If this is less than ``destination_length``,
+//|           some samples were missed due to processing time."""
+//|         ...
+static mp_obj_t audiobusio_i2s_obj_record(mp_obj_t self_obj, mp_obj_t destination, mp_obj_t destination_length) {
+    audiobusio_i2s_obj_t *self = MP_OBJ_TO_PTR(self_obj);
+    check_for_deinit(self);
+    uint32_t length = mp_arg_validate_type_int(destination_length, MP_QSTR_length);
+    mp_arg_validate_length_min(length, 0, MP_QSTR_length);
+
+    mp_buffer_info_t bufinfo;
+    if (mp_obj_is_type(destination, &mp_type_fileio)) {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("Cannot record to a file"));
+    } else if (mp_get_buffer(destination, &bufinfo, MP_BUFFER_WRITE)) {
+        if (bufinfo.len / mp_binary_get_size('@', bufinfo.typecode, NULL) < length) {
+            mp_raise_ValueError(MP_ERROR_TEXT("Destination capacity is smaller than destination_length."));
+        }
+        uint8_t bit_depth = common_hal_audiobusio_i2s_get_bits_per_sample(self);
+        if (bufinfo.typecode != 'h' && bit_depth == 16) {
+            mp_raise_ValueError(MP_ERROR_TEXT("destination buffer must be an array of type 'h' for bit_depth = 16"));
+        } else if (bufinfo.typecode != 'B' && bufinfo.typecode != BYTEARRAY_TYPECODE && bit_depth == 8) {
+            mp_raise_ValueError(MP_ERROR_TEXT("destination buffer must be a bytearray or array of type 'B' for bit_depth = 8"));
+        }
+        // length is the buffer length in slots, not bytes.
+        common_hal_audiobusio_i2s_record_to_buffer(self, bufinfo.buf, length);
+    }
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_3(audiobusio_i2s_record_obj, audiobusio_i2s_obj_record);
 
 //|     def play(self, sample: circuitpython_typing.AudioSample, *, loop: bool = False) -> None:
 //|         """Plays the sample once when loop=False and continuously when loop=True.
@@ -280,6 +316,7 @@ static const mp_rom_map_elem_t audiobusio_i2s_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&audiobusio_i2s_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&default___enter___obj) },
     { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&audiobusio_i2s___exit___obj) },
+    { MP_ROM_QSTR(MP_QSTR_record), MP_ROM_PTR(&audiobusio_i2s_record_obj) },
     { MP_ROM_QSTR(MP_QSTR_play), MP_ROM_PTR(&audiobusio_i2s_play_obj) },
     { MP_ROM_QSTR(MP_QSTR_stop), MP_ROM_PTR(&audiobusio_i2s_stop_obj) },
     { MP_ROM_QSTR(MP_QSTR_pause), MP_ROM_PTR(&audiobusio_i2s_pause_obj) },

shared-bindings/audiobusio/I2S.h

@@ -23,6 +23,9 @@ void common_hal_audiobusio_i2s_construct(audiobusio_i2s_obj_t *self,
 void common_hal_audiobusio_i2s_deinit(audiobusio_i2s_obj_t *self);
 bool common_hal_audiobusio_i2s_deinited(audiobusio_i2s_obj_t *self);
 
+void common_hal_audiobusio_i2s_record_to_buffer(audiobusio_i2s_obj_t *self,
+    int16_t *buffer, uint32_t length);
+
 void common_hal_audiobusio_i2s_play(audiobusio_i2s_obj_t *self, mp_obj_t sample, bool loop);
 void common_hal_audiobusio_i2s_stop(audiobusio_i2s_obj_t *self);
 bool common_hal_audiobusio_i2s_get_playing(audiobusio_i2s_obj_t *self);