MIDI 14-bit CCs

[danngreen]

Some snippets taken from here:
https://forum.4ms.info/t/highly-desirable-stateful-midi/1007/4

combining a CC 0-31 as MSB with the value from the CC number +32 as LSB, right? So it would need a user setting to enable this, and then the patch would ignore maps on CCs 32-63 and update the mapped controls for CCs 0-31 with a 14-bit value whenever it receives either MSB or LSB (resetting LSB to 0 when it receives an MSB)

there is a ‘minor’ optimisation that means small turns only require you to send the LSB.
this means, you always need to send MSB first, then LSB (and receivers, should only act on the MSB after they get the next LSB!)

The idea is that the user can enable/disable this mode in the Preferences.

Some edge-cases and unanswered issues:

• What to do if a user is in 14-bit MIDI mode and loads a patch that uses an LSB CC number (e.g. CC33)?

An alternative approach would be to add 14-bit MIDI support to a module (a separate plugin, or the built-in RackCore MIDIToCVInterface module).

[danngreen]

One way to do this is to calculate the 14-bit CC on the M4 core when the MIDI stream is parsed. Here is where that happens:
https://github.com/4ms/metamodule/blob/main/firmware/src/core_m4/midi_controls.hh

The event.val is an int16_t (see here: https://github.com/4ms/metamodule/blob/main/firmware/src/params/midi_params.hh#L31), so the 14-bit value will fit nicely in there.

The audio thread on the A7 core is what sees the MIDI messages. Here: https://github.com/4ms/metamodule/blob/main/firmware/src/audio/midi.hh . It passes the message to the patch player, which then sets any mapped knobs and jacks.

I think it might be easiest if we always treat CC messages as 14-bit, that is, when 14-bit mode is disabled the M4 core would shift all CC messages up by 7 bits. So CC01 value of 10 would be sent to the A7 core as CC01 value of 1280. Then the A7 core can just always divide by a fixed amount to get the right value regardless of what mode is enabled. That also solves any kind of sync issue if the user changes MIDI bit mode while there's MIDI messages in the pipeline.

The M4 core would need to know if it's supposed to do 14 bit or 7 bit, and the A7 core would be handling setting this flag since the A7 handles the GUI. The two cores share data via the MetaParams structure, so we would need to add a bool midi_14bit_mode flag to this. It would work very similarly to how the midi_poly_chans field of metaparams works. Pretty much anywhere midi_poly_chans appears in the code, there will need to be something similar happening for midi_14bit_mode -- except that instead of getting the value from the patch player, we would get the value from the settings file. The settings and preferences tab is a separate topic, basically could be copy/pasted from other user preferences (audio sample rate, block size, etc)

---

Another way to do it is to not change the M4's MIDI processing at all. Rather, it would all happen in https://github.com/4ms/metamodule/blob/main/firmware/src/audio/midi.hh. The A7 core would combine the two CC messages in that function, and pass it on to the patch player. In some ways this is more simple, but it does place a bit more code in the "hot loop".