feat: CC 87 stores preset based on channel's current parameters

Also to RAM & SRAM

Author: rhargreaves

src/midi.c

@@ -1043,6 +1043,17 @@ static void rpn_data_entry(MidiChannel* chan, u8 value, bool is_msb)
     }
 }
 
+static void store_program_from_channel(u8 ch, u8 program)
+{
+    FOREACH_DEV_CHAN_WITH_MIDI(ch, devChan) {
+        if (devChan->ops == &FM_VTable) {
+            midi_fm_store_preset_from_channel(devChan->num, program);
+            log_info("Prg %d: FM preset stored", program + 1);
+            break; // first chan we find only
+        }
+    }
+}
+
 void midi_cc(u8 ch, u8 controller, u8 value)
 {
     MidiChannel* chan = &midiChannels[ch];
@@ -1104,6 +1115,9 @@ void midi_cc(u8 ch, u8 controller, u8 value)
     case CC_NRPN_LSB:
     case CC_NRPN_MSB:
         break;
+    case CC_STORE_PROGRAM:
+        store_program_from_channel(ch, value);
+        break;
     default:
         fm_parameter_cc(ch, controller, value);
         break;

src/midi.h

@@ -93,6 +93,7 @@
 #define CC_GENMDM_POLYPHONIC_MODE 84
 #define CC_FINE_TUNE 85
 #define CC_DEVICE_SELECT 86
+#define CC_STORE_PROGRAM 87
 #define CC_SHOW_PARAMETERS_ON_UI 83
 #define CC_GENMDM_SSG_EG_OP1 90
 #define CC_GENMDM_SSG_EG_OP2 91

src/midi_fm.c

@@ -186,14 +186,19 @@ void midi_fm_store_preset(u8 program, const FmPreset* preset)
 {
     memcpy(&userPresets[program], preset, sizeof(FmPreset));
     activeUserPresets[program] = &userPresets[program];
-
     midi_fm_sram_save_preset(program, preset);
 }
 
 void midi_fm_clear_preset(u8 program)
 {
     memset(&userPresets[program], 0, sizeof(FmPreset));
     activeUserPresets[program] = NULL;
-
     midi_fm_sram_clear_preset(program);
 }
+
+void midi_fm_store_preset_from_channel(u8 chan, u8 program)
+{
+    FmPreset fmPreset;
+    synth_extract_preset(chan, &fmPreset);
+    midi_fm_store_preset(program, &fmPreset);
+}

src/midi_fm.h

@@ -24,4 +24,5 @@ u8 midi_fm_pitch_to_octave(u8 pitch);
 void midi_fm_pitch(u8 chan, u8 pitch, s8 cents);
 u16 midi_fm_pitch_cents_to_freq_num(u8 pitch, s8 cents);
 void midi_fm_store_preset(u8 program, const FmPreset* preset);
-void midi_fm_clear_preset(u8 program);
+void midi_fm_clear_preset(u8 program);
+void midi_fm_store_preset_from_channel(u8 chan, u8 program);

src/synth.c

@@ -501,3 +501,15 @@ static void release_z80_bus(void)
     YM2612_write(0, YM_DAC_DATA); // Latch reg address for PCM driver
     Z80_releaseBus();
 }
+
+void synth_extract_preset(u8 ch, FmPreset* preset)
+{
+    const FmChannel* chan = synth_channel_parameters(ch);
+    preset->algorithm = chan->algorithm;
+    preset->feedback = chan->feedback;
+    preset->ams = chan->ams;
+    preset->fms = chan->fms;
+    for (u8 op = 0; op < MAX_FM_OPERATORS; op++) {
+        preset->operators[op] = chan->operators[op];
+    }
+}

src/synth.h

@@ -81,6 +81,7 @@ void synth_fms(u8 channel, u8 fms);
 u8 synth_busy(void);
 void synth_preset(u8 channel, const FmPreset* preset);
 const FmChannel* synth_channel_parameters(u8 channel);
+void synth_extract_preset(u8 channel, FmPreset* preset);
 const Global* synth_global_parameters();
 void synth_set_parameter_update_callback(ParameterUpdatedCallback* cb);
 void synth_set_special_mode(bool enable);

tests/Makefile

@@ -82,6 +82,7 @@ MOCKS=midi_process \
 	synth_special_mode_volume \
 	synth_direct_write_ym2612 \
 	synth_enable_dac \
+	synth_extract_preset \
 	midi_note_off \
 	midi_note_on \
 	midi_pitch_bend \

tests/mocks/mock_synth.c

@@ -188,6 +188,14 @@ void __wrap_synth_volume(u8 channel, u8 volume)
     check_expected(volume);
 }
 
+void __wrap_synth_extract_preset(u8 channel, FmPreset* preset)
+{
+    if (disableChecks)
+        return;
+    check_expected(channel);
+    memcpy(preset, mock_type(FmPreset*), sizeof(FmPreset));
+}
+
 const FmChannel* __wrap_synth_channel_parameters(u8 channel)
 {
     return NULL;
@@ -273,17 +281,54 @@ int fmpreset_equality_check(
 {
     FmPreset* expected = (FmPreset*)value;
     FmPreset* actual = (FmPreset*)check_value_data;
+    bool mismatch = false;
+
+    if (actual->algorithm != expected->algorithm) {
+        print_error("algorithm mismatch: %d != %d\n", actual->algorithm, expected->algorithm);
+        mismatch = true;
+    }
+
+    if (actual->ams != expected->ams) {
+        print_error("ams mismatch: %d != %d\n", actual->ams, expected->ams);
+        mismatch = true;
+    }
+
+    if (actual->fms != expected->fms) {
+        print_error("fms mismatch: %d != %d\n", actual->fms, expected->fms);
+        mismatch = true;
+    }
 
-    if ((actual->algorithm == expected->algorithm) && (actual->ams == expected->ams)
-        && (actual->feedback == expected->feedback) && (actual->fms == expected->fms)
-        && operator_equality_check(&actual->operators[0], &expected->operators[0])
-        && operator_equality_check(&actual->operators[1], &expected->operators[1])
-        && operator_equality_check(&actual->operators[2], &expected->operators[2])
-        && operator_equality_check(&actual->operators[3], &expected->operators[3])) {
-        return 1;
+    if (actual->feedback != expected->feedback) {
+        print_error("feedback mismatch: %d != %d\n", actual->feedback, expected->feedback);
+        mismatch = true;
     }
 
-    return 0;
+    if (actual->fms != expected->fms) {
+        print_error("fms mismatch: %d != %d\n", actual->fms, expected->fms);
+        mismatch = true;
+    }
+
+    if (!operator_equality_check(&actual->operators[0], &expected->operators[0])) {
+        print_error("operator 0 mismatch\n");
+        mismatch = true;
+    }
+
+    if (!operator_equality_check(&actual->operators[1], &expected->operators[1])) {
+        print_error("operator 1 mismatch\n");
+        mismatch = true;
+    }
+
+    if (!operator_equality_check(&actual->operators[2], &expected->operators[2])) {
+        print_error("operator 2 mismatch\n");
+        mismatch = true;
+    }
+
+    if (!operator_equality_check(&actual->operators[3], &expected->operators[3])) {
+        print_error("operator 3 mismatch\n");
+        mismatch = true;
+    }
+
+    return mismatch ? 0 : 1;
 }
 
 void _expect_synth_algorithm(u8 channel, u8 algorithm, const char* const file, const int line)
@@ -448,3 +493,10 @@ void _expect_synth_preset(
     expect_value_with_pos(__wrap_synth_preset, channel, channel, file, line);
     expect_check_with_pos(__wrap_synth_preset, preset, fmpreset_equality_check, preset, file, line);
 }
+
+void _expect_synth_extract_preset(
+    u8 channel, FmPreset* preset, const char* const file, const int line)
+{
+    expect_value_with_pos(__wrap_synth_extract_preset, channel, channel, file, line);
+    will_return(__wrap_synth_extract_preset, preset);
+}

tests/mocks/mock_synth.h

@@ -38,6 +38,8 @@ void __wrap_synth_special_mode_pitch(u8 op, u8 octave, u16 freqNumber);
 void __wrap_synth_special_mode_volume(u8 op, u8 volume);
 void __wrap_synth_direct_write_ym2612(u8 part, u8 reg, u8 data);
 void __wrap_synth_enable_dac(bool enable);
+void __wrap_synth_extract_preset(u8 channel, FmPreset* preset);
+
 extern void __real_synth_init(const FmPreset* defaultPreset);
 extern void __real_synth_note_on(u8 channel);
 extern void __real_synth_note_off(u8 channel);
@@ -70,7 +72,7 @@ extern void __real_synth_special_mode_pitch(u8 op, u8 octave, u16 freqNumber);
 extern void __real_synth_special_mode_volume(u8 op, u8 volume);
 extern void __real_synth_enable_dac(bool enable);
 extern void __real_synth_direct_write_ym2612(u8 part, u8 reg, u8 data);
-
+extern void __real_synth_extract_preset(u8 channel, FmPreset* preset);
 int fmpreset_equality_check(
     const LargestIntegralType value, const LargestIntegralType check_value_data);
 void _expect_synth_algorithm(u8 channel, u8 algorithm, const char* const file, const int line);
@@ -115,6 +117,8 @@ void _expect_synth_direct_write_ym2612(
     u8 part, u8 reg, u8 data, const char* const file, const int line);
 void _expect_synth_preset(
     u8 channel, const FmPreset* preset, const char* const file, const int line);
+void _expect_synth_extract_preset(
+    u8 channel, FmPreset* preset, const char* const file, const int line);
 
 #define expect_synth_preset(channel, preset)                                                       \
     _expect_synth_preset(channel, preset, __FILE__, __LINE__)
@@ -168,3 +172,5 @@ void _expect_synth_preset(
     _expect_synth_set_special_mode(enable, __FILE__, __LINE__)
 #define expect_synth_direct_write_ym2612(part, reg, data)                                          \
     _expect_synth_direct_write_ym2612(part, reg, data, __FILE__, __LINE__)
+#define expect_synth_extract_preset(channel, preset)                                               \
+    _expect_synth_extract_preset(channel, preset, __FILE__, __LINE__)

tests/unit/main.c

@@ -177,6 +177,7 @@ int main(void)
         midi_test(test_midi_sysex_logs_warning_if_clear_all_programs_type_is_incorrect),
         midi_test(test_midi_loads_presets_from_sram),
         midi_test(test_midi_sysex_does_not_display_loaded_msg_if_no_presets_are_loaded),
+        midi_test(test_midi_cc_stores_program),
 
         midi_test(
             test_midi_fm_note_on_percussion_channel_sets_percussion_preset),

tests/unit/test_midi_sysex.c

@@ -471,4 +471,37 @@ void test_midi_sysex_does_not_display_loaded_msg_if_no_presets_are_loaded(UNUSED
     mock_log_enable_checks();
     mock_synth_disable_checks();
     __real_midi_reset();
+}
+
+void test_midi_cc_stores_program(UNUSED void** state)
+{
+    const u8 program = 0x01;
+
+    expect_synth_algorithm(FM_CH1, 0x06);
+    __real_midi_cc(MIDI_CHANNEL_1, CC_GENMDM_FM_ALGORITHM, 111);
+
+    FmPreset fmPreset;
+    memcpy(&fmPreset, &TEST_M_BANK_0_INST_0_GRANDPIANO, sizeof(FmPreset));
+    fmPreset.algorithm = 0x06;
+
+    mock_log_enable_checks();
+    expect_synth_extract_preset(FM_CH1, &fmPreset);
+    expect_log_info("Prg %d: FM preset stored");
+    __real_midi_cc(MIDI_CHANNEL_1, CC_STORE_PROGRAM, program);
+
+    expect_synth_algorithm(FM_CH1, 0x00);
+    __real_midi_cc(MIDI_CHANNEL_1, CC_GENMDM_FM_ALGORITHM, 0);
+
+    expect_synth_preset(FM_CH1, &fmPreset);
+    __real_midi_program(MIDI_CHANNEL_1, program);
+
+    // check that the preset was stored to SRAM
+    const u8 EXPECTED_SRAM_DATA[SRAM_PRESET_LENGTH]
+        = { /* magic number */ 0x9E, 0x1D, /* version */ 0x01,
+              /* preset */ 0xC0, 0x00, 0x11, 0xA4, 0xE7, 0x20, 0xA7, 0x00, 0x4D, 0x85, 0x26, 0x4B,
+              0xA4, 0x00, 0x2F, 0xFE, 0xE9, 0x78, 0x84, 0x00, 0x17, 0xB8, 0x8A, 0x23, 0x02, 0x00,
+              /* reserved */ 0x00, 0x00, 0x00, 0x00, 0x00, /* checksum */ 0x87, 0x77 };
+
+    u16 offset = SRAM_PRESET_START + (program * SRAM_PRESET_LENGTH);
+    assert_memory_equal(mock_sram_data(offset), EXPECTED_SRAM_DATA, SRAM_PRESET_LENGTH);
 }

tests/unit/test_midi_sysex.h

@@ -26,4 +26,5 @@ void test_midi_sysex_logs_warning_if_program_clear_type_is_incorrect(UNUSED void
 void test_midi_sysex_clears_all_programs(UNUSED void** state);
 void test_midi_sysex_logs_warning_if_clear_all_programs_type_is_incorrect(UNUSED void** state);
 void test_midi_loads_presets_from_sram(UNUSED void** state);
-void test_midi_sysex_does_not_display_loaded_msg_if_no_presets_are_loaded(UNUSED void** state);
+void test_midi_sysex_does_not_display_loaded_msg_if_no_presets_are_loaded(UNUSED void** state);
+void test_midi_cc_stores_program(UNUSED void** state);