cs-midi/Control_Surface/Control_Surface_Class.cpp

#include "Control_Surface_Class.hpp"
#include <AH/Debug/Debug.hpp>
#include <AH/Hardware/ExtendedInputOutput/ExtendedIOElement.hpp>
#include <AH/Hardware/FilteredAnalog.hpp>
#include <MIDI_Constants/Control_Change.hpp>
#include <MIDI_Inputs/MIDIInputElement.hpp>
#include <MIDI_Outputs/Abstract/MIDIOutputElement.hpp>
#include <Selectors/Selector.hpp>

BEGIN_CS_NAMESPACE

using AH::ExtendedIOElement;

Control_Surface_ &Control_Surface_::getInstance() {
    static Control_Surface_ instance;
    return instance;
}

void Control_Surface_::begin() {
    connectDefaultMIDI_Interface();

    FilteredAnalog<>::setupADC();
    ExtendedIOElement::beginAll();
    Updatable<MIDI_Interface>::beginAll();
    MIDIOutputOnly::beginAll();
    MIDIInputElementNote::beginAll();
    MIDIInputElementKP::beginAll();
    MIDIInputElementCC::beginAll();
    MIDIInputElementPC::beginAll();
    MIDIInputElementCP::beginAll();
    MIDIInputElementPB::beginAll();
    MIDIInputElementSysEx::beginAll();
    Updatable<>::beginAll();
}

bool Control_Surface_::connectDefaultMIDI_Interface() {
#if !DISABLE_PIPES
    if (hasSinkPipe() || hasSourcePipe())
        return false;
    auto def = MIDI_Interface::getDefault();
    if (def == nullptr) {
        FATAL_ERROR(F("No default MIDI Interface"), 0xF123);
        return false;
    }
    *this << inpipe << *def;
    *this >> outpipe >> *def;
    return true;
#else
    return MIDI_Interface::getDefault();
#endif
}

void Control_Surface_::disconnectMIDI_Interfaces() {
#if !DISABLE_PIPES
    disconnectSinkPipes();
    disconnectSourcePipes();
#endif
}

void Control_Surface_::loop() {
    ExtendedIOElement::updateAllBufferedInputs();
    Updatable<>::updateAll();
    updateMidiInput();
    updateInputs();
    ExtendedIOElement::updateAllBufferedOutputs();
}

void Control_Surface_::updateMidiInput() {
#if !DISABLE_PIPES
    Updatable<MIDI_Interface>::updateAll();
#else
    if (auto iface = MIDI_Interface::getDefault()) {
        MIDIReadEvent event = iface->read();
        while (event != MIDIReadEvent::NO_MESSAGE) {
            MIDI_Interface::dispatchIncoming(iface, event);
            switch (event) {
                case MIDIReadEvent::CHANNEL_MESSAGE:
                    sinkMIDIfromPipe(iface->getChannelMessage());
                    break;
                case MIDIReadEvent::SYSEX_CHUNK:
                case MIDIReadEvent::SYSEX_MESSAGE:
                    sinkMIDIfromPipe(iface->getSysExMessage());
                    break;
                case MIDIReadEvent::SYSCOMMON_MESSAGE:
                    sinkMIDIfromPipe(iface->getSysCommonMessage());
                    break;
                case MIDIReadEvent::REALTIME_MESSAGE:
                    sinkMIDIfromPipe(iface->getRealTimeMessage());
                    break;
                case MIDIReadEvent::NO_MESSAGE: break;
                default: break;
            }
            event = iface->read();
        }
    }
#endif
}

#if !DISABLE_PIPES
void Control_Surface_::sendChannelMessageImpl(ChannelMessage msg) {
    this->sourceMIDItoPipe(msg);
}
void Control_Surface_::sendSysExImpl(SysExMessage msg) {
    this->sourceMIDItoPipe(msg);
}
void Control_Surface_::sendSysCommonImpl(SysCommonMessage msg) {
    this->sourceMIDItoPipe(msg);
}
void Control_Surface_::sendRealTimeImpl(RealTimeMessage msg) {
    this->sourceMIDItoPipe(msg);
}
#else
void Control_Surface_::sendChannelMessageImpl(ChannelMessage msg) {
    if (auto def = MIDI_Interface::getDefault())
        def->send(msg);
}
void Control_Surface_::sendSysExImpl(SysExMessage msg) {
    if (auto def = MIDI_Interface::getDefault())
        def->send(msg);
}
void Control_Surface_::sendSysCommonImpl(SysCommonMessage msg) {
    if (auto def = MIDI_Interface::getDefault())
        def->send(msg);
}
void Control_Surface_::sendRealTimeImpl(RealTimeMessage msg) {
    if (auto def = MIDI_Interface::getDefault())
        def->send(msg);
}
#endif

void Control_Surface_::sinkMIDIfromPipe(ChannelMessage midimsg) {
    if (channelMessageCallback && channelMessageCallback(midimsg))
        return;

    if (midimsg.getMessageType() == MIDIMessageType::ControlChange &&
        midimsg.getData1() == MIDI_CC::Reset_All_Controllers) {
        MIDIInputElementCC::resetAll();
        MIDIInputElementCP::resetAll();
    } else if (midimsg.getMessageType() == MIDIMessageType::ControlChange &&
               midimsg.getData1() == MIDI_CC::All_Notes_Off) {
        MIDIInputElementNote::resetAll();
    } else {
        switch (midimsg.getMessageType()) {
            case MIDIMessageType::None: break;
            case MIDIMessageType::NoteOff:
            case MIDIMessageType::NoteOn:
                MIDIInputElementNote::updateAllWith(midimsg);
                break;
            case MIDIMessageType::KeyPressure:
                MIDIInputElementKP::updateAllWith(midimsg);
                break;
            case MIDIMessageType::ControlChange:
                MIDIInputElementCC::updateAllWith(midimsg);
                break;
            case MIDIMessageType::ProgramChange:
                MIDIInputElementPC::updateAllWith(midimsg);
                break;
            case MIDIMessageType::ChannelPressure:
                MIDIInputElementCP::updateAllWith(midimsg);
                break;
            case MIDIMessageType::PitchBend:
                MIDIInputElementPB::updateAllWith(midimsg);
                break;
            default: break;
        }
    }
}

void Control_Surface_::sinkMIDIfromPipe(SysExMessage msg) {
    if (sysExMessageCallback && sysExMessageCallback(msg))
        return;
    MIDIInputElementSysEx::updateAllWith(msg);
}

void Control_Surface_::sinkMIDIfromPipe(SysCommonMessage msg) {
    if (sysCommonMessageCallback && sysCommonMessageCallback(msg))
        return;
}

void Control_Surface_::sinkMIDIfromPipe(RealTimeMessage rtMessage) {
    if (realTimeMessageCallback && realTimeMessageCallback(rtMessage))
        return;
}

void Control_Surface_::updateInputs() {
    MIDIInputElementNote::updateAll();
    MIDIInputElementKP::updateAll();
    MIDIInputElementCC::updateAll();
    MIDIInputElementPC::updateAll();
    MIDIInputElementCP::updateAll();
    MIDIInputElementPB::updateAll();
    MIDIInputElementSysEx::updateAll();
}

#if CS_TRUE_CONTROL_SURFACE_INSTANCE
Control_Surface_ &Control_Surface = Control_Surface_::getInstance();
#endif

END_CS_NAMESPACE