codal_port/microbit_soundeffect: Update SoundEffect class.

Signed-off-by: Damien George <[email protected]>

Author: dpgeorge

src/codal_port/microbit_soundeffect.c

@@ -52,32 +52,52 @@
 #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_ENCODE_VOLUME(v) (((v) * 1023 + 127) / 255)
+#define SOUND_EXPR_DECODE_VOLUME(v) (((v) * 255 + 511) / 1023)
 
-#define SOUND_EXPR_DEFAULT "3""1023""0500""0500""18""000""2500""0000""0000""0128""00""0001""0024""0000000000000000000000000000"
+// #define SOUND_EXPR_DEFAULT "3""1023""0500""0500""18""000""2500""0000""0000""0128""00""0001""0024""0000000000000000000000000000"
+// 310230500050018000250000000000012800000100240000000000000000000000000000
+// 310230500050018000250000000000000000000000000000000000000000000000000000
+//                               30=steps
+//                                     36=fx-param
+//                                         40=fx-steps
 
 #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_SHAPE_LINEAR (1)
+#define SOUND_EFFECT_SHAPE_CURVE (2)
+#define SOUND_EFFECT_SHAPE_LOG (18)
 
-#define SOUND_EFFECT_FX_NONE (0) // Python "None" object
+#define SOUND_EFFECT_FX_NONE (0)
 #define SOUND_EFFECT_FX_TREMOLO (2)
 #define SOUND_EFFECT_FX_VIBRATO (1)
 #define SOUND_EFFECT_FX_WARBLE (3)
 
+#define SOUND_EFFECT_DEFAULT_FREQ_START         (500)
+#define SOUND_EFFECT_DEFAULT_FREQ_END           (2500)
+#define SOUND_EFFECT_DEFAULT_DURATION           (500)
+#define SOUND_EFFECT_DEFAULT_VOL_START          (255)
+#define SOUND_EFFECT_DEFAULT_VOL_END            (0)
+#define SOUND_EFFECT_DEFAULT_WAVE               (SOUND_EFFECT_WAVE_SQUARE)
+#define SOUND_EFFECT_DEFAULT_FX                 (SOUND_EFFECT_FX_NONE)
+#define SOUND_EFFECT_DEFAULT_SHAPE              (SOUND_EFFECT_SHAPE_LOG)
+
 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;
 
+typedef struct _soundeffect_attr_t {
+    uint16_t qst;
+    uint8_t offset;
+    uint8_t length;
+} soundeffect_attr_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,
@@ -87,12 +107,23 @@ STATIC const uint16_t wave_to_qstr_table[5] = {
 };
 
 STATIC const uint16_t fx_to_qstr_table[4] = {
-    [0] = MP_QSTR_None,
+    [SOUND_EFFECT_FX_NONE] = MP_QSTR_FX_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,
 };
 
+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_shape, SOUND_EXPR_SHAPE_OFFSET, SOUND_EXPR_SHAPE_LENGTH },
+};
+
 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];
@@ -131,54 +162,59 @@ STATIC void microbit_soundeffect_print(const mp_print_t *print, mp_obj_t self_in
     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;
+    if (kind == PRINT_STR) {
+        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_SHAPE_LINEAR:
+                mp_printf(print, "shape=SHAPE_LINEAR)");
+                break;
+            case SOUND_EFFECT_SHAPE_CURVE:
+                mp_printf(print, "shape=SHAPE_CURVE)");
+                break;
+            case SOUND_EFFECT_SHAPE_LOG:
+                mp_printf(print, "shape=SHAPE_LOG)");
+                break;
+            default:
+                mp_printf(print, "shape=%d)", shape);
+                break;
+        }
+    } else {
+        // PRINT_REPR
+        mp_printf(print, "SoundEffect(%d, %d, %d, %d, %d, %d, %d, %d)",
+            freq_start, freq_end, duration, vol_start, vol_end, wave, fx, shape);
     }
 }
 
 // Constructor:
-// SoundEffect(preset=None, *, freq_start, freq_end, duration, vol_start, vol_end, wave, fx, interpolation)
+// SoundEffect(freq_start, freq_end, duration, vol_start, vol_end, wave, fx, shape)
 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 };
+    enum { ARG_freq_start, ARG_freq_end, ARG_duration, ARG_vol_start, ARG_vol_end, ARG_wave, ARG_fx, ARG_shape };
     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} },
+        { MP_QSTR_freq_start,       MP_ARG_INT, {.u_int = SOUND_EFFECT_DEFAULT_FREQ_START} },
+        { MP_QSTR_freq_end,         MP_ARG_INT, {.u_int = SOUND_EFFECT_DEFAULT_FREQ_END} },
+        { MP_QSTR_duration,         MP_ARG_INT, {.u_int = SOUND_EFFECT_DEFAULT_DURATION} },
+        { MP_QSTR_vol_start,        MP_ARG_INT, {.u_int = SOUND_EFFECT_DEFAULT_VOL_START} },
+        { MP_QSTR_vol_end,          MP_ARG_INT, {.u_int = SOUND_EFFECT_DEFAULT_VOL_END} },
+        { MP_QSTR_wave,             MP_ARG_INT, {.u_int = SOUND_EFFECT_DEFAULT_WAVE} },
+        { MP_QSTR_fx,               MP_ARG_INT, {.u_int = SOUND_EFFECT_DEFAULT_FX} },
+        { MP_QSTR_shape,            MP_ARG_INT, {.u_int = SOUND_EFFECT_DEFAULT_SHAPE} },
     };
 
     // Parse arguments.
@@ -191,63 +227,23 @@ STATIC mp_obj_t microbit_soundeffect_make_new(const mp_obj_type_t *type, size_t
     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);
+    memset(&self->sound_expr[0], '0', SOUND_EXPR_TOTAL_LENGTH);
+    sound_expr_encode(self, SOUND_EXPR_STEPS_OFFSET, SOUND_EXPR_STEPS_LENGTH, 128);
 
     // 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));
-    }
+    sound_expr_encode(self, SOUND_EXPR_FREQUENCY_START_OFFSET, SOUND_EXPR_FREQUENCY_START_LENGTH, args[ARG_freq_start].u_int);
+    sound_expr_encode(self, SOUND_EXPR_FREQUENCY_END_OFFSET, SOUND_EXPR_FREQUENCY_END_LENGTH, args[ARG_freq_end].u_int);
+    sound_expr_encode(self, SOUND_EXPR_DURATION_OFFSET, SOUND_EXPR_DURATION_LENGTH, args[ARG_duration].u_int);
+    sound_expr_encode(self, SOUND_EXPR_VOLUME_START_OFFSET, SOUND_EXPR_VOLUME_START_LENGTH, args[ARG_vol_start].u_int);
+    sound_expr_encode(self, SOUND_EXPR_VOLUME_END_OFFSET, SOUND_EXPR_VOLUME_END_LENGTH, args[ARG_vol_end].u_int);
+    sound_expr_encode(self, SOUND_EXPR_WAVE_OFFSET, SOUND_EXPR_WAVE_LENGTH, args[ARG_wave].u_int);
+    sound_expr_encode(self, SOUND_EXPR_FX_CHOICE_OFFSET, SOUND_EXPR_FX_CHOICE_LENGTH, args[ARG_fx].u_int);
+    sound_expr_encode(self, SOUND_EXPR_SHAPE_OFFSET, SOUND_EXPR_SHAPE_LENGTH, args[ARG_shape].u_int);
 
     // 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;
@@ -258,7 +254,8 @@ STATIC void microbit_soundeffect_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
         }
     }
     if (soundeffect_attr == NULL) {
-        // Invalid attribute.
+        // Invalid attribute, set MP_OBJ_SENTINEL to continue lookup in locals dict.
+        dest[1] = MP_OBJ_SENTINEL;
         return;
     }
     if (dest[0] == MP_OBJ_NULL) {
@@ -282,9 +279,43 @@ STATIC void microbit_soundeffect_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
     }
 }
 
-// Note: these locals are only accessible as SoundEffect.xxx, because
-// microbit_soundeffect_attr handles attribute lookups on instances.
+STATIC mp_obj_t microbit_soundeffect_from_string(mp_obj_t str_in) {
+    microbit_soundeffect_obj_t *self = m_new_obj(microbit_soundeffect_obj_t);
+    self->base.type = &microbit_soundeffect_type;
+    self->is_mutable = true;
+
+    // Initialise the sound expression data with the preset values.
+    memset(&self->sound_expr[0], '0', SOUND_EXPR_TOTAL_LENGTH);
+    size_t len;
+    const char *str = mp_obj_str_get_data(str_in, &len);
+    if (len > SOUND_EXPR_TOTAL_LENGTH) {
+        len = SOUND_EXPR_TOTAL_LENGTH;
+    }
+    memcpy(&self->sound_expr[0], str, len);
+
+    return MP_OBJ_FROM_PTR(self);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(microbit_soundeffect_from_string_obj, microbit_soundeffect_from_string);
+STATIC MP_DEFINE_CONST_STATICMETHOD_OBJ(microbit_soundeffect_from_string_staticmethod_obj, MP_ROM_PTR(&microbit_soundeffect_from_string_obj));
+
+STATIC mp_obj_t microbit_soundeffect_copy(mp_obj_t self_in) {
+    microbit_soundeffect_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    microbit_soundeffect_obj_t *copy = m_new_obj(microbit_soundeffect_obj_t);
+    copy->base.type = self->base.type;
+    copy->is_mutable = true;
+    memcpy(&copy->sound_expr[0], &self->sound_expr[0], SOUND_EXPR_TOTAL_LENGTH);
+
+    return MP_OBJ_FROM_PTR(copy);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(microbit_soundeffect_copy_obj, microbit_soundeffect_copy);
+
 STATIC const mp_rom_map_elem_t microbit_soundeffect_locals_dict_table[] = {
+    // Static methods.
+    { MP_ROM_QSTR(MP_QSTR__from_string), MP_ROM_PTR(&microbit_soundeffect_from_string_staticmethod_obj) },
+
+    // Instance methods.
+    { MP_ROM_QSTR(MP_QSTR_copy), MP_ROM_PTR(&microbit_soundeffect_copy_obj) },
+
     // Class constants.
     #define C(NAME) { MP_ROM_QSTR(MP_QSTR_ ## NAME), MP_ROM_INT(SOUND_EFFECT_ ## NAME) }
 
@@ -294,9 +325,9 @@ STATIC const mp_rom_map_elem_t microbit_soundeffect_locals_dict_table[] = {
     C(WAVE_SQUARE),
     C(WAVE_NOISE),
 
-    C(INTER_LINEAR),
-    C(INTER_CURVE),
-    C(INTER_LOG),
+    C(SHAPE_LINEAR),
+    C(SHAPE_CURVE),
+    C(SHAPE_LOG),
 
     C(FX_NONE),
     C(FX_TREMOLO),