midi_converter.hpp

Go to the documentation of this file.

// sbl/dsp/widgets/midi_converter.hpp — MIDI-to-CV converter widget
//
// Converts MIDI events (method calls) into normalized float signal outputs.
// The Eurorack analog: a MIDI-to-CV module (Yarns, Mutant Brain, 0-Coast).
//
// Input side — method calls matching MidiParser's event delivery:
//   note_on(note, velocity), note_off(note), cc(number, value),
//   pitch_bend(value), aftertouch(value)
//
// Output side — readable float signal values:
//   pitch()     [0,1] note mapped to configurable range (default 24–120)
//   gate()      0.0 off, velocity/127.0 on (gate strength)
//   velocity()  [0,1] last note-on velocity, held until next note-on
//   pressure()  [0,1] channel aftertouch
//   bend()      [-1,1] pitch bend, bipolar
//   cc(N)       [0,1] CC value by enum or raw index
//
// Monophonic, last-note priority. See FDP-063 for design rationale.
//
// Usage:
//   sbl::dsp::widgets::MidiConverter mc;
//   mc.note_on(60, 100);
//   float p = mc.pitch();     // note 60 mapped to [0,1]
//   float g = mc.gate();      // 100/127.0 ≈ 0.787
//   mc.cc(1, 64);
//   float mod = mc.cc(sbl::dsp::widgets::Cc::CC1_ModWheel); // 64/127.0 ≈ 0.504
 
#ifndef SBL_DSP_WIDGETS_MIDI_CONVERTER_HPP_
#define SBL_DSP_WIDGETS_MIDI_CONVERTER_HPP_
 
#include <algorithm>
#include <cstdint>
 
namespace sbl::dsp::widgets {
 
/// Common MIDI CC numbers. Values match the MIDI spec 1:1.
enum class Cc : uint8_t {
    CC1_ModWheel = 1,
    CC2_BreathController = 2,
    CC4_FootController = 4,
    CC5_Portamento = 5,
    CC7_Volume = 7,
    CC10_Pan = 10,
    CC11_Expression = 11,
    CC64_Sustain = 64,
    CC65_PortamentoOnOff = 65,
    CC71_Resonance = 71,
    CC72_Release = 72,
    CC73_Attack = 73,
    CC74_Brightness = 74,
    CC75_Decay = 75,
    CC76_VibratoRate = 76,
    CC77_VibratoDepth = 77,
    CC91_ReverbSend = 91,
    CC93_ChorusSend = 93,
};
 
class MidiConverter {
public:
    // --- Input: MIDI events ---
 
    /// Note on. Sets pitch, gate (with velocity strength), and velocity.
    void note_on(uint8_t note, uint8_t vel) {
        current_note_ = note;
        float v = static_cast<float>(vel) / 127.0f;
        gate_ = v;
        velocity_ = v;
        pitch_ = note_to_pitch(note);
    }
 
    /// Note off. Clears gate only if note matches current note (last-note priority).
    /// Pitch and velocity are held.
    void note_off(uint8_t note) {
        if (note == current_note_) {
            gate_ = 0.0f;
        }
    }
 
    /// CC value. Stores normalized value for the given CC number.
    void cc(uint8_t number, uint8_t value) {
        cc_[number] = static_cast<float>(value) / 127.0f;
    }
 
    /// Pitch bend. Raw MIDI value: -8192 to +8191.
    void pitch_bend(int16_t value) {
        if (value >= 0) {
            bend_ = static_cast<float>(value) / 8191.0f;
        } else {
            bend_ = static_cast<float>(value) / 8192.0f;
        }
    }
 
    /// Channel aftertouch.
    void aftertouch(uint8_t value) {
        pressure_ = static_cast<float>(value) / 127.0f;
    }
 
    // --- Output: normalized signal values ---
 
    /// Pitch as [0,1] mapped to the configured note range.
    float pitch() const { return pitch_; }
 
    /// Gate state. 0.0 = off, (0,1] = on with velocity strength.
    float gate() const { return gate_; }
 
    /// Last note-on velocity as [0,1]. Held until next note-on.
    float velocity() const { return velocity_; }
 
    /// Channel aftertouch as [0,1].
    float pressure() const { return pressure_; }
 
    /// Pitch bend as [-1,1].
    float bend() const { return bend_; }
 
    /// CC value by enum. Returns [0,1].
    float cc(Cc cc_num) const {
        return cc_[static_cast<uint8_t>(cc_num)];
    }
 
    /// CC value by raw index. Returns [0,1].
    float cc(uint8_t cc_num) const {
        return cc_[cc_num];
    }
 
    // --- Configuration ---
 
    /// Set the note range for pitch normalization. Default: 24–120.
    void set_pitch_range(uint8_t min_note, uint8_t max_note) {
        min_note_ = min_note;
        max_note_ = max_note;
    }
 
    /// Reset all state to initial values.
    void reset() {
        pitch_ = 0.0f;
        gate_ = 0.0f;
        velocity_ = 0.0f;
        pressure_ = 0.0f;
        bend_ = 0.0f;
        current_note_ = 0;
        for (auto& v : cc_) v = 0.0f;
    }
 
private:
    float note_to_pitch(uint8_t note) const {
        float range = static_cast<float>(max_note_ - min_note_);
        float normalized = (static_cast<float>(note) - static_cast<float>(min_note_)) / range;
        return std::clamp(normalized, 0.0f, 1.0f);
    }
 
    float pitch_ = 0.0f;
    float gate_ = 0.0f;
    float velocity_ = 0.0f;
    float pressure_ = 0.0f;
    float bend_ = 0.0f;
    uint8_t current_note_ = 0;
    uint8_t min_note_ = 24;
    uint8_t max_note_ = 120;
    float cc_[128] = {};
};
 
} // namespace sbl::dsp::widgets
 
#endif // SBL_DSP_WIDGETS_MIDI_CONVERTER_HPP_