midi.hpp

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <dsp/common.hpp>
#include <dsp/filter.hpp>
#include <dsp/digital.hpp>
#include <midi.hpp>
#include <jansson.h>
 
 
namespace rack {
namespace dsp {
 

template <int CHANNELS>
struct MidiGenerator {
    uint8_t channels;
    int8_t vels[CHANNELS];
    int8_t notes[CHANNELS];
    bool gates[CHANNELS];
    int8_t keyPressures[CHANNELS];
    int8_t channelPressure;
    int8_t ccs[128];
    int16_t pw;
    bool clk;
    bool start;
    bool stop;
    bool cont;
    int64_t frame = -1;
 
    MidiGenerator() {
        reset();
    }
 
    void reset() {
        channels = CHANNELS;
        for (int c = 0; c < CHANNELS; c++) {
            vels[c] = 100;
            notes[c] = 60;
            gates[c] = false;
            keyPressures[c] = -1;
        }
        channelPressure = -1;
        for (int i = 0; i < 128; i++) {
            ccs[i] = -1;
        }
        pw = 0x2000;
        clk = false;
        start = false;
        stop = false;
        cont = false;
    }
 
    void panic() {
        reset();
        // Send all note off commands
        for (int note = 0; note <= 127; note++) {
            // Note off
            midi::Message m;
            m.setStatus(0x8);
            m.setNote(note);
            m.setValue(0);
            m.setFrame(frame);
            onMessage(m);
        }
    }
 
    void setChannels(uint8_t channels) {
        if (this->channels == channels)
            return;
        // Disable notes when channels decreases
        for (uint8_t c = channels; c < this->channels; c++) {
            setNoteGate(notes[c], false, c);
        }
        this->channels = channels;
    }

    void setVelocity(int8_t vel, int c) {
        vels[c] = vel;
    }
 
    void setNoteGate(int8_t note, bool gate, int c) {
        bool changedNote = gate && gates[c] && (note != notes[c]);
        bool enabledGate = gate && !gates[c];
        bool disabledGate = !gate && gates[c];
        if (changedNote || disabledGate) {
            // Note off
            midi::Message m;
            m.setStatus(0x8);
            m.setNote(notes[c]);
            m.setValue(vels[c]);
            m.setFrame(frame);
            onMessage(m);
        }
        if (changedNote || enabledGate) {
            // Note on
            midi::Message m;
            m.setStatus(0x9);
            m.setNote(note);
            m.setValue(vels[c]);
            m.setFrame(frame);
            onMessage(m);
        }
        notes[c] = note;
        gates[c] = gate;
    }
 
    void setKeyPressure(int8_t val, int c) {
        if (keyPressures[c] == val)
            return;
        keyPressures[c] = val;
        // Polyphonic key pressure
        midi::Message m;
        m.setStatus(0xa);
        m.setNote(notes[c]);
        m.setValue(val);
        m.setFrame(frame);
        onMessage(m);
    }
 
    void setChannelPressure(int8_t val) {
        if (channelPressure == val)
            return;
        channelPressure = val;
        // Channel pressure
        midi::Message m;
        m.setSize(2);
        m.setStatus(0xd);
        m.setNote(val);
        m.setFrame(frame);
        onMessage(m);
    }
 
    void setCc(int8_t cc, int id) {
        if (ccs[id] == cc)
            return;
        ccs[id] = cc;
        // Continuous controller
        midi::Message m;
        m.setStatus(0xb);
        m.setNote(id);
        m.setValue(cc);
        m.setFrame(frame);
        onMessage(m);
    }
 
    void setModWheel(int8_t cc) {
        setCc(cc, 0x01);
    }
 
    void setVolume(int8_t cc) {
        setCc(cc, 0x07);
    }
 
    void setBalance(int8_t cc) {
        setCc(cc, 0x08);
    }
 
    void setPan(int8_t cc) {
        setCc(cc, 0x0a);
    }
 
    void setSustainPedal(int8_t cc) {
        setCc(cc, 0x40);
    }
 
    void setPitchWheel(int16_t pw) {
        if (this->pw == pw)
            return;
        this->pw = pw;
        // Pitch wheel
        midi::Message m;
        m.setStatus(0xe);
        m.setNote(pw & 0x7f);
        m.setValue((pw >> 7) & 0x7f);
        m.setFrame(frame);
        onMessage(m);
    }
 
    void setClock(bool clk) {
        if (this->clk == clk)
            return;
        this->clk = clk;
        if (clk) {
            // Timing clock
            midi::Message m;
            m.setSize(1);
            m.setStatus(0xf);
            m.setChannel(0x8);
            m.setFrame(frame);
            onMessage(m);
        }
    }
 
    void setStart(bool start) {
        if (this->start == start)
            return;
        this->start = start;
        if (start) {
            // Start
            midi::Message m;
            m.setSize(1);
            m.setStatus(0xf);
            m.setChannel(0xa);
            m.setFrame(frame);
            onMessage(m);
        }
    }
 
    void setContinue(bool cont) {
        if (this->cont == cont)
            return;
        this->cont = cont;
        if (cont) {
            // Continue
            midi::Message m;
            m.setSize(1);
            m.setStatus(0xf);
            m.setChannel(0xb);
            m.setFrame(frame);
            onMessage(m);
        }
    }
 
    void setStop(bool stop) {
        if (this->stop == stop)
            return;
        this->stop = stop;
        if (stop) {
            // Stop
            midi::Message m;
            m.setSize(1);
            m.setStatus(0xf);
            m.setChannel(0xc);
            m.setFrame(frame);
            onMessage(m);
        }
    }
 
    void setFrame(int64_t frame) {
        this->frame = frame;
    }
 
    virtual void onMessage(const midi::Message& message) {}
};
 

template <uint8_t MAX_CHANNELS>
struct MidiParser {
    // Settings

    uint8_t channels;
 
    enum MonoMode {
        LAST_PRIORITY_MODE,
        FIRST_PRIORITY_MODE,
        LOWEST_PRIORITY_MODE,
        HIGHEST_PRIORITY_MODE,
        NUM_MONO_MODES
    };
    MonoMode monoMode;

    bool retriggerOnResume;

    enum PolyMode {
        ROTATE_MODE,
        REUSE_MODE,
        RESET_MODE,
        MPE_MODE,
        NUM_POLY_MODES
    };
    PolyMode polyMode;

    bool releaseVelocityEnabled;

    float pwRange;

    bool smooth;

    uint32_t clockDivision;
 
    // States

    int64_t clock;

    bool pedal;
 
    uint8_t notes[MAX_CHANNELS];
    bool gates[MAX_CHANNELS];
    uint8_t velocities[MAX_CHANNELS];
    uint8_t aftertouches[MAX_CHANNELS];
    std::vector<uint8_t> heldNotes;
    int8_t rotateIndex;

    int16_t pws[MAX_CHANNELS];
    uint8_t mods[MAX_CHANNELS];
    dsp::ExponentialFilter pwFilters[MAX_CHANNELS];
    dsp::ExponentialFilter modFilters[MAX_CHANNELS];
 
    dsp::PulseGenerator clockPulse;
    dsp::PulseGenerator clockDividerPulse;
    dsp::PulseGenerator retriggerPulses[MAX_CHANNELS];
    dsp::PulseGenerator startPulse;
    dsp::PulseGenerator stopPulse;
    dsp::PulseGenerator continuePulse;
 
    MidiParser() {
        heldNotes.reserve(128);
        reset();
    }

    void reset() {
        channels = 1;
        monoMode = LAST_PRIORITY_MODE;
        retriggerOnResume = false;
        polyMode = ROTATE_MODE;
        releaseVelocityEnabled = false;
        pwRange = 2.f;
        smooth = true;
        clockDivision = 24;
        setFilterLambda(30.f);
        panic();
    }

    void panic() {
        clock = 0;
        pedal = false;
        for (uint8_t c = 0; c < MAX_CHANNELS; c++) {
            // Middle C
            notes[c] = 60;
            gates[c] = false;
            velocities[c] = 0;
            aftertouches[c] = 0;
            pws[c] = 0;
            mods[c] = 0;
            pwFilters[c].reset();
            modFilters[c].reset();
        }
        rotateIndex = -1;
        heldNotes.clear();
    }
 
    void processFilters(float deltaTime) {
        uint8_t wheelChannels = getWheelChannels();
        for (uint8_t c = 0; c < wheelChannels; c++) {
            float pw = pws[c] / 8191.f;
            pw = math::clamp(pw, -1.f, 1.f);
            if (smooth)
                pw = pwFilters[c].process(deltaTime, pw);
            else
                pwFilters[c].out = pw;
 
            float mod = mods[c] / 127.f;
            mod = math::clamp(mod, 0.f, 1.f);
            if (smooth)
                mod = modFilters[c].process(deltaTime, mod);
            else
                modFilters[c].out = mod;
        }
    }
 
    void processPulses(float deltaTime) {
        clockPulse.process(deltaTime);
        clockDividerPulse.process(deltaTime);
        startPulse.process(deltaTime);
        stopPulse.process(deltaTime);
        continuePulse.process(deltaTime);
        for (uint8_t c = 0; c < channels; c++) {
            retriggerPulses[c].process(deltaTime);
        }
    }
 
    void processMessage(const midi::Message& msg) {
        // DEBUG("MIDI: %ld %s", msg.getFrame(), msg.toString().c_str());
 
        switch (msg.getStatus()) {
            // note off
            case 0x8: {
                releaseNote(msg.getNote(), msg.getChannel(), msg.getValue());
            } break;
            // note on
            case 0x9: {
                uint8_t velocity = msg.getValue();
                if (velocity > 0) {
                    pressNote(msg.getNote(), msg.getChannel(), velocity);
                }
                else {
                    // Note-on event with velocity 0 is an alternative for note-off event.
                    releaseNote(msg.getNote(), msg.getChannel(), -1);
                }
            } break;
            // key pressure
            case 0xa: {
                // Set the aftertouches with the same note
                // TODO Should we handle the MPE case differently?
                for (uint8_t c = 0; c < MAX_CHANNELS; c++) {
                    if (notes[c] == msg.getNote())
                        aftertouches[c] = msg.getValue();
                }
            } break;
            // cc
            case 0xb: {
                processCC(msg);
            } break;
            // channel pressure
            case 0xd: {
                if (channels > 1 && polyMode == MPE_MODE) {
                    // Set the channel aftertouch
                    aftertouches[msg.getChannel()] = msg.getNote();
                }
                else {
                    // Set all aftertouches
                    for (uint8_t c = 0; c < MAX_CHANNELS; c++) {
                        aftertouches[c] = msg.getNote();
                    }
                }
            } break;
            // pitch wheel
            case 0xe: {
                uint8_t c = (channels > 1 && polyMode == MPE_MODE) ? msg.getChannel() : 0;
                int16_t pw = msg.getValue();
                pw <<= 7;
                pw |= msg.getNote();
                pw -= 8192;
                pws[c] = pw;
            } break;
            case 0xf: {
                processSystem(msg);
            } break;
            default: break;
        }
    }
 
    void processCC(const midi::Message& msg) {
        switch (msg.getNote()) {
            // mod
            case 0x01: {
                uint8_t c = (channels > 1 && polyMode == MPE_MODE) ? msg.getChannel() : 0;
                mods[c] = msg.getValue();
            } break;
            // sustain
            case 0x40: {
                if (msg.getValue() >= 64)
                    pressPedal();
                else
                    releasePedal();
            } break;
            // all notes off (panic)
            case 0x7b: {
                if (msg.getValue() == 0) {
                    panic();
                }
            } break;
            default: break;
        }
    }
 
    void processSystem(const midi::Message& msg) {
        switch (msg.getChannel()) {
            // Song Position Pointer
            case 0x2: {
                int64_t pos = int64_t(msg.getNote()) | (int64_t(msg.getValue()) << 7);
                clock = pos * 6;
            } break;
            // Timing
            case 0x8: {
                clockPulse.trigger(1e-3);
                if (clock % clockDivision == 0) {
                    clockDividerPulse.trigger(1e-3);
                }
                clock++;
            } break;
            // Start
            case 0xa: {
                startPulse.trigger(1e-3);
                clock = 0;
            } break;
            // Continue
            case 0xb: {
                continuePulse.trigger(1e-3);
            } break;
            // Stop
            case 0xc: {
                stopPulse.trigger(1e-3);
            } break;
            default: break;
        }
    }
 
    uint8_t assignChannel(uint8_t note) {
        if (channels <= 1)
            return 0;
 
        if (polyMode == REUSE_MODE) {
            // Try to find channel with the same note
            for (uint8_t c = 0; c < channels; c++) {
                if (notes[c] == note)
                    return c;
            }
        }
        if (polyMode == REUSE_MODE || polyMode == ROTATE_MODE) {
            // Find next available channel
            for (uint8_t i = 0; i < channels; i++) {
                rotateIndex++;
                if (rotateIndex >= channels)
                    rotateIndex = 0;
                if (!gates[rotateIndex])
                    return rotateIndex;
            }
            // No notes are available. Advance rotateIndex once more.
            rotateIndex++;
            if (rotateIndex >= channels)
                rotateIndex = 0;
            return rotateIndex;
        }
        if (polyMode == RESET_MODE) {
            for (uint8_t c = 0; c < channels; c++) {
                if (!gates[c])
                    return c;
            }
            return channels - 1;
        }
        if (polyMode == MPE_MODE) {
            // This case is handled by querying the MIDI message channel.
            return 0;
        }
        return 0;
    }
 
    void pressNote(uint8_t note, uint8_t channel, uint8_t velocity) {
        // Remove existing similar note
        heldNotes.erase(std::remove(heldNotes.begin(), heldNotes.end(), note), heldNotes.end());
        // Push note to end
        heldNotes.push_back(note);
        // Handle polyphony modes
        if (channels > 1) {
            if (polyMode == MPE_MODE) {
                // Output channel equals MIDI channel
            }
            else {
                channel = assignChannel(note);
            }
        }
        // Handle monophonic modes
        else {
            channel = 0;
            if (monoMode == LAST_PRIORITY_MODE) {
                // Always play note
            }
            if (monoMode == FIRST_PRIORITY_MODE) {
                if (heldNotes.size() > 1)
                    return;
            }
            if (monoMode == LOWEST_PRIORITY_MODE) {
                uint8_t minNote = *std::min_element(heldNotes.begin(), heldNotes.end());
                if (note != minNote)
                    return;
            }
            if (monoMode == HIGHEST_PRIORITY_MODE) {
                uint8_t maxNote = *std::max_element(heldNotes.begin(), heldNotes.end());
                if (note != maxNote)
                    return;
            }
        }
        // Set note
        notes[channel] = note;
        gates[channel] = true;
        velocities[channel] = velocity;
        retriggerPulses[channel].trigger(1e-3);
    }

    void releaseNote(uint8_t note, int8_t channel, int8_t velocity) {
        // Remove the note
        heldNotes.erase(std::remove(heldNotes.begin(), heldNotes.end(), note), heldNotes.end());
        // Hold note if pedal is pressed
        if (pedal)
            return;
        // Find output channel of released note, if any
        if (channels > 1 && polyMode == MPE_MODE) {
            // Each MPE channel must be monophonic so the output channel must be the released note channel
        }
        else {
            // Find channel of active note
            channel = -1;
            for (uint8_t c = 0; c < channels; c++) {
                if (gates[c] && notes[c] == note) {
                    channel = c;
                    break;
                }
            }
        }
        if (channel < 0) {
            // Released note is not active on any channel
            return;
        }
        // Deactivate note
        gates[channel] = false;
        refreshHeld();
        // Set velocity
        if (releaseVelocityEnabled && velocity >= 0) {
            velocities[channel] = velocity;
        }
    }

    void refreshHeld() {
        // Monophonic
        if (channels <= 1) {
            // Reactivate note if at least one is held
            if (!heldNotes.empty()) {
                if (monoMode == LAST_PRIORITY_MODE) {
                    notes[0] = heldNotes.back();
                }
                if (monoMode == FIRST_PRIORITY_MODE) {
                    notes[0] = heldNotes.front();
                }
                if (monoMode == LOWEST_PRIORITY_MODE) {
                    notes[0] = *std::min_element(heldNotes.begin(), heldNotes.end());
                }
                if (monoMode == HIGHEST_PRIORITY_MODE) {
                    notes[0] = *std::max_element(heldNotes.begin(), heldNotes.end());
                }
                gates[0] = true;
                if (retriggerOnResume) {
                    retriggerPulses[0].trigger(1e-3);
                }
            }
            else {
                gates[0] = false;
            }
        }
        // Polyphonic
        else {
            // Deactivate notes that are not held
            for (uint8_t c = 0; c < channels; c++) {
                if (!gates[c])
                    continue;
                // Check if note is still held
                bool held = std::find(heldNotes.begin(), heldNotes.end(), notes[c]) != heldNotes.end();
                if (!held)
                    gates[c] = false;
            }
        }
    }
 
    void pressPedal() {
        if (pedal)
            return;
        pedal = true;
    }
 
    void releasePedal() {
        if (!pedal)
            return;
        pedal = false;
        refreshHeld();
    }
 
    uint8_t getChannels() {
        return channels;
    }
 
    void setChannels(uint8_t channels) {
        if (channels == this->channels)
            return;
        this->channels = channels;
        panic();
    }
 
    void setMonoMode(MonoMode monoMode) {
        if (monoMode == this->monoMode)
            return;
        this->monoMode = monoMode;
        panic();
    }
 
    void setPolyMode(PolyMode polyMode) {
        if (polyMode == this->polyMode)
            return;
        this->polyMode = polyMode;
        panic();
    }
 
    float getPitchVoltage(uint8_t channel) {
        uint8_t wheelChannel = (channels > 1 && polyMode == MPE_MODE) ? channel : 0;
        return (notes[channel] - 60.f + pwFilters[wheelChannel].out * pwRange) / 12.f;
    }

    void setFilterLambda(float lambda) {
        for (uint8_t c = 0; c < MAX_CHANNELS; c++) {
            pwFilters[c].setLambda(lambda);
            modFilters[c].setLambda(lambda);
        }
    }

    float getPw(uint8_t channel) {
        return pwFilters[channel].out;
    }

    float getMod(uint8_t channel) {
        return modFilters[channel].out;
    }

    uint8_t getWheelChannels() {
        return (channels > 1 && polyMode == MPE_MODE) ? MAX_CHANNELS : 1;
    }
 
    json_t* toJson() {
        json_t* rootJ = json_object();
        json_object_set_new(rootJ, "channels", json_integer(channels));
        json_object_set_new(rootJ, "monoMode", json_integer(monoMode));
        json_object_set_new(rootJ, "retriggerOnResume", json_boolean(retriggerOnResume));
        json_object_set_new(rootJ, "polyMode", json_integer(polyMode));
        json_object_set_new(rootJ, "releaseVelocityEnabled", json_boolean(releaseVelocityEnabled));
        json_object_set_new(rootJ, "pwRange", json_real(pwRange));
        json_object_set_new(rootJ, "smooth", json_boolean(smooth));
        json_object_set_new(rootJ, "clockDivision", json_integer(clockDivision));
        if (channels > 1 && polyMode == MPE_MODE) {
            // Saving/restoring pitch and mod doesn't make much sense for MPE.
        }
        else {
            json_object_set_new(rootJ, "lastPw", json_integer(pws[0]));
            json_object_set_new(rootJ, "lastMod", json_integer(mods[0]));
        }
        // Assume all filter lambdas are the same
        json_object_set_new(rootJ, "filterLambda", json_real(pwFilters[0].lambda));
        return rootJ;
    }
 
    void fromJson(json_t* rootJ) {
        json_t* channelsJ = json_object_get(rootJ, "channels");
        if (channelsJ)
            setChannels(json_integer_value(channelsJ));
 
        json_t* monoModeJ = json_object_get(rootJ, "monoMode");
        if (monoModeJ)
            monoMode = (MonoMode) json_integer_value(monoModeJ);
 
        json_t* retriggerOnResumeJ = json_object_get(rootJ, "retriggerOnResume");
        if (retriggerOnResumeJ)
            retriggerOnResume = json_boolean_value(retriggerOnResumeJ);
 
        json_t* polyModeJ = json_object_get(rootJ, "polyMode");
        if (polyModeJ)
            polyMode = (PolyMode) json_integer_value(polyModeJ);
 
        json_t* releaseVelocityEnabledJ = json_object_get(rootJ, "releaseVelocityEnabled");
        if (releaseVelocityEnabledJ)
            releaseVelocityEnabled = json_boolean_value(releaseVelocityEnabledJ);
 
        json_t* pwRangeJ = json_object_get(rootJ, "pwRange");
        if (pwRangeJ)
            pwRange = json_number_value(pwRangeJ);
 
        json_t* smoothJ = json_object_get(rootJ, "smooth");
        if (smoothJ)
            smooth = json_boolean_value(smoothJ);
 
        json_t* clockDivisionJ = json_object_get(rootJ, "clockDivision");
        if (clockDivisionJ)
            clockDivision = json_integer_value(clockDivisionJ);
 
        json_t* lastPwJ = json_object_get(rootJ, "lastPw");
        if (lastPwJ)
            pws[0] = json_integer_value(lastPwJ);
 
        // In Rack <2.5.3, `lastPitch` was used from 0 to 16383.
        json_t* lastPitchJ = json_object_get(rootJ, "lastPitch");
        if (lastPitchJ)
            pws[0] = json_integer_value(lastPitchJ) - 8192;
 
        json_t* lastModJ = json_object_get(rootJ, "lastMod");
        if (lastModJ)
            mods[0] = json_integer_value(lastModJ);
 
        // Added in Rack 2.5.3
        json_t* filterLambdaJ = json_object_get(rootJ, "filterLambda");
        if (filterLambdaJ)
            setFilterLambda(json_number_value(filterLambdaJ));
    }
};
 
 
} // namespace dsp
} // namespace rack