codal_port: Add SoundEffect class.

dpgeorge · dpgeorge · commit 19dc67069d58 · 2022-07-10T14:22:12.000+10:00
Signed-off-by: Damien George &lt;damien@micropython.org&gt;
diff --git a/src/codal_port/Makefile b/src/codal_port/Makefile
@@ -72,6 +72,7 @@ SRC_C += \
 	microbit_pinaudio.c \
 	microbit_pinmode.c \
 	microbit_sound.c \
+	microbit_soundeffect.c \
 	microbit_soundevent.c \
 	microbit_speaker.c \
 	microbit_spi.c \
diff --git a/src/codal_port/microbit_soundeffect.c b/src/codal_port/microbit_soundeffect.c
@@ -0,0 +1,296 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 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/runtime.h"
+#include "modmicrobit.h"
+
+#define SOUND_EXPR_TOTAL_LENGTH                 (72)
+
+#define SOUND_EXPR_WAVE_OFFSET                  (0)
+#define SOUND_EXPR_WAVE_LENGTH                  (1)
+#define SOUND_EXPR_VOLUME_START_OFFSET          (1)
+#define SOUND_EXPR_VOLUME_START_LENGTH          (4)
+#define SOUND_EXPR_FREQUENCY_START_OFFSET       (5)
+#define SOUND_EXPR_FREQUENCY_START_LENGTH       (4)
+#define SOUND_EXPR_DURATION_OFFSET              (9)
+#define SOUND_EXPR_DURATION_LENGTH              (4)
+#define SOUND_EXPR_SHAPE_OFFSET                 (13)
+#define SOUND_EXPR_SHAPE_LENGTH                 (2)
+#define SOUND_EXPR_FREQUENCY_END_OFFSET         (18)
+#define SOUND_EXPR_FREQUENCY_END_LENGTH         (4)
+#define SOUND_EXPR_VOLUME_END_OFFSET            (26)
+#define SOUND_EXPR_VOLUME_END_LENGTH            (4)
+#define SOUND_EXPR_STEPS_OFFSET                 (30)
+#define SOUND_EXPR_STEPS_LENGTH                 (4)
+#define SOUND_EXPR_FX_CHOICE_OFFSET             (34)
+#define SOUND_EXPR_FX_CHOICE_LENGTH             (2)
+#define SOUND_EXPR_FX_PARAM_OFFSET              (36)
+#define SOUND_EXPR_FX_PARAM_LENGTH              (4)
+#define SOUND_EXPR_FX_STEPS_OFFSET              (40)
+#define SOUND_EXPR_FX_STEPS_LENGTH              (4)
+
+#define SOUND_EXPR_ENCODE_VOLUME(v) ((v) * 1023 / 255)
+#define SOUND_EXPR_DECODE_VOLUME(v) ((v) * 255 / 1023)
+
+#define SOUND_EXPR_DEFAULT "3""1023""0500""0500""18""000""2500""0000""0000""0128""00""0001""0024""0000000000000000000000000000"
+
+#define SOUND_EFFECT_WAVE_SINE (0)
+#define SOUND_EFFECT_WAVE_SAWTOOTH (1)
+#define SOUND_EFFECT_WAVE_TRIANGLE (2)
+#define SOUND_EFFECT_WAVE_SQUARE (3)
+#define SOUND_EFFECT_WAVE_NOISE (4)
+
+#define SOUND_EFFECT_INTER_LINEAR (1)
+#define SOUND_EFFECT_INTER_CURVE (2)
+#define SOUND_EFFECT_INTER_LOG (18)
+
+#define SOUND_EFFECT_FX_NONE (0) // Python "None" object
+#define SOUND_EFFECT_FX_TREMOLO (2)
+#define SOUND_EFFECT_FX_VIBRATO (1)
+#define SOUND_EFFECT_FX_WARBLE (3)
+
+typedef struct _microbit_soundeffect_obj_t {
+    mp_obj_base_t base;
+    bool is_mutable;
+    char sound_expr[SOUND_EXPR_TOTAL_LENGTH];
+} microbit_soundeffect_obj_t;
+
+STATIC const uint16_t wave_to_qstr_table[5] = {
+    [SOUND_EFFECT_WAVE_SINE] = MP_QSTR_WAVE_SINE,
+    [SOUND_EFFECT_WAVE_SAWTOOTH] = MP_QSTR_WAVE_SAWTOOTH,
+    [SOUND_EFFECT_WAVE_TRIANGLE] = MP_QSTR_WAVE_TRIANGLE,
+    [SOUND_EFFECT_WAVE_SQUARE] = MP_QSTR_WAVE_SQUARE,
+    [SOUND_EFFECT_WAVE_NOISE] = MP_QSTR_WAVE_NOISE,
+};
+
+STATIC const uint16_t fx_to_qstr_table[4] = {
+    [0] = MP_QSTR_None,
+    [SOUND_EFFECT_FX_TREMOLO] = MP_QSTR_FX_TREMOLO,
+    [SOUND_EFFECT_FX_VIBRATO] = MP_QSTR_FX_VIBRATO,
+    [SOUND_EFFECT_FX_WARBLE] = MP_QSTR_FX_WARBLE,
+};
+
+const char *microbit_soundeffect_get_sound_expr_data(mp_obj_t self_in) {
+    const microbit_soundeffect_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    return &self->sound_expr[0];
+}
+
+STATIC void sound_expr_encode(microbit_soundeffect_obj_t *self, size_t offset, size_t length, unsigned int value) {
+    if (offset == SOUND_EXPR_VOLUME_START_OFFSET || offset == SOUND_EXPR_VOLUME_END_OFFSET) {
+        value = SOUND_EXPR_ENCODE_VOLUME(value);
+    }
+    for (size_t i = length; i > 0; --i) {
+        self->sound_expr[offset + i - 1] = '0' + value % 10;
+        value /= 10;
+    }
+}
+
+STATIC unsigned int sound_expr_decode(const microbit_soundeffect_obj_t *self, size_t offset, size_t length) {
+    unsigned int value = 0;
+    for (size_t i = 0; i < length; ++i) {
+        value = value * 10 + self->sound_expr[offset + i] - '0';
+    }
+    if (offset == SOUND_EXPR_VOLUME_START_OFFSET || offset == SOUND_EXPR_VOLUME_END_OFFSET) {
+        value = SOUND_EXPR_DECODE_VOLUME(value);
+    }
+    return value;
+}
+
+STATIC void microbit_soundeffect_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    const microbit_soundeffect_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+    unsigned int freq_start = sound_expr_decode(self, SOUND_EXPR_FREQUENCY_START_OFFSET, SOUND_EXPR_FREQUENCY_START_LENGTH);
+    unsigned int freq_end = sound_expr_decode(self, SOUND_EXPR_FREQUENCY_END_OFFSET, SOUND_EXPR_FREQUENCY_END_LENGTH);
+    unsigned int duration = sound_expr_decode(self, SOUND_EXPR_DURATION_OFFSET, SOUND_EXPR_DURATION_LENGTH);
+    unsigned int vol_start = sound_expr_decode(self, SOUND_EXPR_VOLUME_START_OFFSET, SOUND_EXPR_VOLUME_START_LENGTH);
+    unsigned int vol_end = sound_expr_decode(self, SOUND_EXPR_VOLUME_END_OFFSET, SOUND_EXPR_VOLUME_END_LENGTH);
+    unsigned int wave = sound_expr_decode(self, SOUND_EXPR_WAVE_OFFSET, SOUND_EXPR_WAVE_LENGTH);
+    unsigned int fx = sound_expr_decode(self, SOUND_EXPR_FX_CHOICE_OFFSET, SOUND_EXPR_FX_CHOICE_LENGTH);
+    unsigned int shape = sound_expr_decode(self, SOUND_EXPR_SHAPE_OFFSET, SOUND_EXPR_SHAPE_LENGTH);
+
+    mp_printf(print, "SoundEffect("
+        "freq_start=%d, "
+        "freq_end=%d, "
+        "duration=%d, "
+        "vol_start=%d, "
+        "vol_end=%d, "
+        "wave=%q, "
+        "fx=%q, ",
+        freq_start,
+        freq_end,
+        duration,
+        vol_start,
+        vol_end,
+        wave_to_qstr_table[wave],
+        fx_to_qstr_table[fx]
+    );
+
+    // Support shape values that don't have a corresponding constant assigned.
+    switch (shape) {
+        case SOUND_EFFECT_INTER_LINEAR:
+            mp_printf(print, "interpolation=INTER_LINEAR)");
+            break;
+        case SOUND_EFFECT_INTER_CURVE:
+            mp_printf(print, "interpolation=INTER_CURVE)");
+            break;
+        case SOUND_EFFECT_INTER_LOG:
+            mp_printf(print, "interpolation=INTER_LOG)");
+            break;
+        default:
+            mp_printf(print, "interpolation=%d)", shape);
+            break;
+    }
+}
+
+// Constructor:
+// SoundEffect(preset=None, *, freq_start, freq_end, duration, vol_start, vol_end, wave, fx, interpolation)
+STATIC mp_obj_t microbit_soundeffect_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args_in) {
+    enum { ARG_preset, ARG_freq_start, ARG_freq_end, ARG_duration, ARG_vol_start, ARG_vol_end, ARG_wave, ARG_fx, ARG_interpolation };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_preset,           MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_freq_start,       MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_freq_end,         MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_duration,         MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_vol_start,        MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_vol_end,          MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_wave,             MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_fx,               MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_interpolation,    MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+    };
+
+    // Parse arguments.
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, args_in, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // Create sound effect object.
+    microbit_soundeffect_obj_t *self = m_new_obj(microbit_soundeffect_obj_t);
+    self->base.type = type;
+    self->is_mutable = true;
+
+    // Initialise the sound expression data with the preset values.
+    const char *sound_expr_preset = SOUND_EXPR_DEFAULT;
+    if (args[ARG_preset].u_obj != mp_const_none) {
+        if (mp_obj_is_type(args[ARG_preset].u_obj, &microbit_soundeffect_type)) {
+            sound_expr_preset = microbit_soundeffect_get_sound_expr_data(args[ARG_preset].u_obj);
+        } else {
+            sound_expr_preset = mp_obj_str_get_str(args[ARG_preset].u_obj);
+        }
+    }
+    memcpy(&self->sound_expr[0], sound_expr_preset, SOUND_EXPR_TOTAL_LENGTH);
+
+    // Modify any given parameters.
+    if (args[ARG_freq_start].u_obj != MP_OBJ_NULL) {
+        sound_expr_encode(self, SOUND_EXPR_FREQUENCY_START_OFFSET, SOUND_EXPR_FREQUENCY_START_LENGTH, mp_obj_get_int(args[ARG_freq_start].u_obj));
+    }
+    if (args[ARG_freq_end].u_obj != MP_OBJ_NULL) {
+        sound_expr_encode(self, SOUND_EXPR_FREQUENCY_END_OFFSET, SOUND_EXPR_FREQUENCY_END_LENGTH, mp_obj_get_int(args[ARG_freq_end].u_obj));
+    }
+    if (args[ARG_duration].u_obj != MP_OBJ_NULL) {
+        sound_expr_encode(self, SOUND_EXPR_DURATION_OFFSET, SOUND_EXPR_DURATION_LENGTH, mp_obj_get_int(args[ARG_duration].u_obj));
+    }
+    if (args[ARG_vol_start].u_obj != MP_OBJ_NULL) {
+        sound_expr_encode(self, SOUND_EXPR_VOLUME_START_OFFSET, SOUND_EXPR_VOLUME_START_LENGTH, mp_obj_get_int(args[ARG_vol_start].u_obj));
+    }
+    if (args[ARG_vol_end].u_obj != MP_OBJ_NULL) {
+        sound_expr_encode(self, SOUND_EXPR_VOLUME_END_OFFSET, SOUND_EXPR_VOLUME_END_LENGTH, mp_obj_get_int(args[ARG_vol_end].u_obj));
+    }
+    if (args[ARG_wave].u_obj != MP_OBJ_NULL) {
+        sound_expr_encode(self, SOUND_EXPR_WAVE_OFFSET, SOUND_EXPR_WAVE_LENGTH, mp_obj_get_int(args[ARG_wave].u_obj));
+    }
+    if (args[ARG_fx].u_obj != MP_OBJ_NULL) {
+        sound_expr_encode(self, SOUND_EXPR_FX_CHOICE_OFFSET, SOUND_EXPR_FX_CHOICE_LENGTH, args[ARG_fx].u_obj == mp_const_none ? 0 : mp_obj_get_int(args[ARG_fx].u_obj));
+    }
+    if (args[ARG_interpolation].u_obj != MP_OBJ_NULL) {
+        sound_expr_encode(self, SOUND_EXPR_SHAPE_OFFSET, SOUND_EXPR_SHAPE_LENGTH, mp_obj_get_int(args[ARG_interpolation].u_obj));
+    }
+
+    // Return new sound effect object
+    return MP_OBJ_FROM_PTR(self);
+}
+
+typedef struct _soundeffect_attr_t {
+    uint16_t qst;
+    uint8_t offset;
+    uint8_t length;
+} soundeffect_attr_t;
+
+STATIC const soundeffect_attr_t soundeffect_attr_table[] = {
+    { MP_QSTR_freq_start, SOUND_EXPR_FREQUENCY_START_OFFSET, SOUND_EXPR_FREQUENCY_START_LENGTH },
+    { MP_QSTR_freq_end, SOUND_EXPR_FREQUENCY_END_OFFSET, SOUND_EXPR_FREQUENCY_END_LENGTH },
+    { MP_QSTR_duration, SOUND_EXPR_DURATION_OFFSET, SOUND_EXPR_DURATION_LENGTH },
+    { MP_QSTR_vol_start, SOUND_EXPR_VOLUME_START_OFFSET, SOUND_EXPR_VOLUME_START_LENGTH },
+    { MP_QSTR_vol_end, SOUND_EXPR_VOLUME_END_OFFSET, SOUND_EXPR_VOLUME_END_LENGTH },
+    { MP_QSTR_wave, SOUND_EXPR_WAVE_OFFSET, SOUND_EXPR_WAVE_LENGTH },
+    { MP_QSTR_fx, SOUND_EXPR_FX_CHOICE_OFFSET, SOUND_EXPR_FX_CHOICE_LENGTH },
+    { MP_QSTR_interpolation, SOUND_EXPR_SHAPE_OFFSET, SOUND_EXPR_SHAPE_LENGTH },
+};
+
+STATIC void microbit_soundeffect_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
+    microbit_soundeffect_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    const soundeffect_attr_t *soundeffect_attr = NULL;
+    for (size_t i = 0; i < MP_ARRAY_SIZE(soundeffect_attr_table); ++i) {
+        if (soundeffect_attr_table[i].qst == attr) {
+            soundeffect_attr = &soundeffect_attr_table[i];
+            break;
+        }
+    }
+    if (soundeffect_attr == NULL) {
+        // Invalid attribute.
+        return;
+    }
+    if (dest[0] == MP_OBJ_NULL) {
+        // Load attribute.
+        unsigned int value = sound_expr_decode(self, soundeffect_attr->offset, soundeffect_attr->length);
+        if (attr == MP_QSTR_fx && value == 0) {
+            dest[0] = mp_const_none;
+        } else {
+            dest[0] = MP_OBJ_NEW_SMALL_INT(value);
+        }
+    } else if (dest[1] != MP_OBJ_NULL) {
+        // Store attribute.
+        if (self->is_mutable) {
+            unsigned int value = 0;
+            if (dest[1] != mp_const_none) {
+                value = mp_obj_get_int(dest[1]);
+            }
+            sound_expr_encode(self, soundeffect_attr->offset, soundeffect_attr->length, value);
+            dest[0] = MP_OBJ_NULL; // Indicate store succeeded.
+        }
+    }
+}
+
+STATIC const mp_rom_map_elem_t microbit_soundeffect_locals_dict_table[] = {
+};
+STATIC MP_DEFINE_CONST_DICT(microbit_soundeffect_locals_dict, microbit_soundeffect_locals_dict_table);
+
+const mp_obj_type_t microbit_soundeffect_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_MicroBitSoundEffect,
+    .print = microbit_soundeffect_print,
+    .make_new = microbit_soundeffect_make_new,
+    .attr = microbit_soundeffect_attr,
+    .locals_dict = (mp_obj_dict_t *)&microbit_soundeffect_locals_dict,
+};
diff --git a/src/codal_port/modaudio.c b/src/codal_port/modaudio.c
@@ -137,9 +137,17 @@ void microbit_audio_play_source(mp_obj_t src, mp_obj_t pin_select, bool wait, ui
     audio_init(sample_rate);
     microbit_pin_audio_select(pin_select);
 
+    const char *sound_expr_data = NULL;
     if (mp_obj_is_type(src, &microbit_sound_type)) {
         const microbit_sound_obj_t *sound = (const microbit_sound_obj_t *)MP_OBJ_TO_PTR(src);
-        microbit_hal_audio_play_expression_by_name(sound->name);
+        sound_expr_data = sound->name;
+    } else if (mp_obj_is_type(src, &microbit_soundeffect_type)) {
+        // TODO make sure we keep a reference to this so GC doesn't reclaim if playing in the background?
+        sound_expr_data = microbit_soundeffect_get_sound_expr_data(src);
+    }
+
+    if (sound_expr_data != NULL) {
+        microbit_hal_audio_play_expression_by_name(sound_expr_data);
         if (wait) {
             nlr_buf_t nlr;
             if (nlr_push(&nlr) == 0) {
@@ -215,6 +223,7 @@ STATIC const mp_rom_map_elem_t audio_globals_table[] = {
     { 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_AudioFrame), MP_ROM_PTR(&microbit_audio_frame_type) },
+    { MP_ROM_QSTR(MP_QSTR_SoundEffect), MP_ROM_PTR(&microbit_soundeffect_type) },
 };
 STATIC MP_DEFINE_CONST_DICT(audio_module_globals, audio_globals_table);
 
diff --git a/src/codal_port/modmicrobit.h b/src/codal_port/modmicrobit.h
@@ -85,6 +85,7 @@ extern const mp_obj_type_t microbit_dig_pin_type;
 extern const mp_obj_type_t microbit_touch_pin_type;
 extern const mp_obj_type_t microbit_touch_only_pin_type;
 extern const mp_obj_type_t microbit_sound_type;
+extern const mp_obj_type_t microbit_soundeffect_type;
 extern const mp_obj_type_t microbit_soundevent_type;
 
 extern const struct _microbit_pin_obj_t microbit_p0_obj;
@@ -214,6 +215,8 @@ void microbit_pin_audio_speaker_enable(bool enable);
 void microbit_pin_audio_select(mp_const_obj_t select);
 void microbit_pin_audio_free(void);
 
+const char *microbit_soundeffect_get_sound_expr_data(mp_obj_t self_in);
+
 MP_DECLARE_CONST_FUN_OBJ_0(microbit_reset_obj);
 
 #endif // MICROPY_INCLUDED_MICROBIT_MODMICROBIT_H
