VU.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Timing/MillisMicrosTimer.hpp>
#include <MIDI_Inputs/InterfaceMIDIInputElements.hpp>
#include <MIDI_Inputs/MIDIInputElementMatchers.hpp>
 
BEGIN_CS_NAMESPACE
 
namespace MCU {
 
struct VUState {
    VUState(uint8_t value = 0, bool overload = false)
        : value(value), overload(overload) {}
 
    uint8_t value : 4; 
    bool overload : 1; 
 
    enum Changed {
        NothingChanged = 0,
        ValueChanged = 1,
        OverloadChanged = 2,
    };
 
    Changed update(uint8_t data) {
        switch (data) {
            case 0xF: { // clear overload
                Changed changed = overload ? OverloadChanged : NothingChanged;
                overload = false;
                return changed;
            }
            case 0xE: { // set overload
                Changed changed = !overload ? OverloadChanged : NothingChanged;
                overload = true;
                return changed;
            }
            case 0xD: { // no meaning
                return NothingChanged;
            }
            default: { // set value
                Changed changed = value != data ? ValueChanged : NothingChanged;
                value = data;
                return changed;
            }
        }
    }
 
    bool decay() {
        if (value == 0)
            return false;
        value--;
        return true;
    }
};
 
// -------------------------------------------------------------------------- //
 
struct VUMatcher {
    VUMatcher(MIDIAddress address) : address(address) {}
 
    struct Result {
        bool match; 
        uint8_t data; 
    };
 
    Result operator()(ChannelMessage m) {
        uint8_t track = m.data1 >> 4;
        if (!MIDIAddress::matchSingle({track, m.getChannelCable()}, address))
            return {false, 0};
        uint8_t data = m.data1 & 0x0F;
        return {true, data};
    }
 
    MIDIAddress address; 
};
 
template <uint8_t BankSize>
struct BankableVUMatcher {
    BankableVUMatcher(BankConfig<BankSize> config, MIDIAddress address)
        : config(config), address(address) {}
 
    struct Result {
        bool match; 
        uint8_t data;      
        uint8_t bankIndex; 
    };
 
    Result operator()(ChannelMessage m) {
        using BankableMIDIMatcherHelpers::getBankIndex;
        using BankableMIDIMatcherHelpers::matchBankable;
        uint8_t track = m.data1 >> 4;
        MIDIAddress midiaddr = {track, m.getChannelCable()};
        if (!matchBankable(midiaddr, address, config))
            return {false, 0, 0};
        uint8_t data = m.data1 & 0x0F;
        uint8_t bankIndex = getBankIndex(midiaddr, address, config);
        return {true, data, bankIndex};
    }
 
    Bank<BankSize> &getBank() { return config.bank; }
    const Bank<BankSize> &getBank() const { return config.bank; }
    BankType getBankType() const { return config.type; }
    static constexpr setting_t getBankSize() { return BankSize; }
 
    setting_t getSelection() const { return getBank().getSelection(); }
 
    BaseBankConfig<BankSize> config; 
    MIDIAddress address; 
};
 
// -------------------------------------------------------------------------- //
 
namespace VUDecay {
constexpr unsigned int Hold = 0;
constexpr unsigned int Default = 150;
} // namespace VUDecay
 
class VU : public MatchingMIDIInputElement<MIDIMessageType::CHANNEL_PRESSURE,
                                           VUMatcher>,
           public Interfaces::MCU::IVU {
  public:
    using Matcher = VUMatcher;
    using Parent = MatchingMIDIInputElement<MIDIMessageType::CHANNEL_PRESSURE,
                                            Matcher>;
    VU(uint8_t track, MIDIChannelCable channelCN,
       unsigned int decayTime = VUDecay::Default)
        : Parent({{track - 1, channelCN}}),
          IVU(12), decayTimer(decayTime) {}
 
    VU(uint8_t track, unsigned int decayTime = VUDecay::Default)
        : VU(track, CHANNEL_1, decayTime) {}
 
  protected:
    bool handleUpdateImpl(typename Matcher::Result match) {
        auto changed = state.update(match.data);
        if (changed == VUState::ValueChanged)
            // reset the timer and fire after one interval
            decayTimer.beginNextPeriod();
        return changed;
    }
 
    void handleUpdate(typename Matcher::Result match) override {
        dirty |= handleUpdateImpl(match);
    }
 
    bool decay() {
        return decayTimer.getInterval() != VUDecay::Hold && 
               decayTimer &&
               state.decay();
    }
 
  public:
    void reset() override { state = {}; }
 
    void update() override {
        dirty |= decay();
    }
 
  public:
 
    uint8_t getValue() override { return state.value; }
    bool getOverload() override { return state.overload; }
 
 
  private:
    VUState state = {};
    AH::Timer<millis> decayTimer;
};
 
// -------------------------------------------------------------------------- //
 
namespace Bankable {
 
template <uint8_t BankSize>
class VU
    : public BankableMatchingMIDIInputElement<MIDIMessageType::CHANNEL_PRESSURE,
                                              BankableVUMatcher<BankSize>>,
      public Interfaces::MCU::IVU {
  public:
    using Matcher = BankableVUMatcher<BankSize>;
    using Parent
        = BankableMatchingMIDIInputElement<MIDIMessageType::CHANNEL_PRESSURE,
                                           Matcher>;
 
    VU(BankConfig<BankSize> config, uint8_t track, MIDIChannelCable channelCN,
       unsigned int decayTime = VUDecay::Default)
        : Parent({config, {track - 1, channelCN}}),
          IVU(12), decayTimer(decayTime) {}
 
    VU(BankConfig<BankSize> config, uint8_t track,
       unsigned int decayTime = VUDecay::Default)
        : VU(config, track, CHANNEL_1, decayTime) {}
 
  protected:
    bool handleUpdateImpl(typename Matcher::Result match) {
        auto changed = states[match.bankIndex].update(match.data);
        if (changed == VUState::ValueChanged &&
            match.bankIndex == this->getActiveBank())
            // Only care about active bank's decay.
            // Other banks will decay as well, but not as precisely.
            // They aren't visible anyway, so it's a good compromise.
            decayTimer.beginNextPeriod();
        return changed && match.bankIndex == this->getActiveBank();
        // Only mark dirty if the value of the active bank changed
    }
 
    void handleUpdate(typename Matcher::Result match) override {
        dirty |= handleUpdateImpl(match);
    }
 
    bool decay() {
        bool newdirty = false;
        if (decayTimer.getInterval() != VUDecay::Hold && decayTimer)
            for (uint8_t i = 0; i < BankSize; ++i)
                newdirty |= states[i].decay() && i == this->getActiveBank();
        // Only mark dirty if the value of the active bank decayed
        return newdirty;
    }
 
  public:
    void reset() override {
        states = {{}};
        dirty = true;
    }
 
    void update() override {
        dirty |= decay();
    }
 
  protected:
    void onBankSettingChange() override { dirty = true; }
 
  public:
 
    uint8_t getValue(uint8_t bank) const { return states[bank].value; }
    bool getOverload(uint8_t bank) const { return states[bank].overload; }
    float getFloatValue(uint8_t bank) const { return getValue(bank) / 12.f; }
 
    uint8_t getValue() override { return getValue(this->getActiveBank()); }
    bool getOverload() override { return getOverload(this->getActiveBank()); }
    float getFloatValue() override { return getValue() / 12.f; }
 
 
  private:
    AH::Array<VUState, BankSize> states = {{}};
    AH::Timer<millis> decayTimer;
};
 
} // namespace Bankable
 
} // namespace MCU
 
END_CS_NAMESPACE