MIDI_Sender.ipp

Go to the documentation of this file.

#include "MIDI_Sender.hpp"
#include <AH/Containers/CRTP.hpp>
 
BEGIN_CS_NAMESPACE
 
template <class Derived>
void MIDI_Sender<Derived>::sendChannelMessage(MIDIMessageType m, Channel c,
                                              uint8_t d1, uint8_t d2,
                                              Cable cable) {
    send(ChannelMessage(m, c, d1, d2, cable));
}
 
template <class Derived>
void MIDI_Sender<Derived>::sendChannelMessage(MIDIMessageType m, Channel c,
                                              uint8_t d1, Cable cable) {
    send(ChannelMessage(m, c, d1, 0, cable));
}
 
template <class Derived>
void MIDI_Sender<Derived>::sendNoteOn(MIDIAddress address, uint8_t velocity) {
    if (address)
        CRTP(Derived).sendChannelMessageImpl({
            MIDIMessageType::NOTE_ON,
            address.getChannel(),
            address.getAddress(),
            uint8_t(velocity & 0x7F),
            address.getCableNumber(),
        });
}
template <class Derived>
void MIDI_Sender<Derived>::sendNoteOff(MIDIAddress address, uint8_t velocity) {
    if (address)
        CRTP(Derived).sendChannelMessageImpl({
            MIDIMessageType::NOTE_OFF,
            address.getChannel(),
            address.getAddress(),
            uint8_t(velocity & 0x7F),
            address.getCableNumber(),
        });
}
template <class Derived>
void MIDI_Sender<Derived>::sendKeyPressure(MIDIAddress address,
                                           uint8_t pressure) {
    if (address)
        CRTP(Derived).sendChannelMessageImpl({
            MIDIMessageType::KEY_PRESSURE,
            address.getChannel(),
            address.getAddress(),
            uint8_t(pressure & 0x7F),
            address.getCableNumber(),
        });
}
template <class Derived>
void MIDI_Sender<Derived>::sendControlChange(MIDIAddress address,
                                             uint8_t value) {
    if (address)
        CRTP(Derived).sendChannelMessageImpl({
            MIDIMessageType::CONTROL_CHANGE,
            address.getChannel(),
            address.getAddress(),
            uint8_t(value & 0x7F),
            address.getCableNumber(),
        });
}
template <class Derived>
void MIDI_Sender<Derived>::sendProgramChange(MIDIChannelCable address,
                                             uint8_t value) {
    if (address)
        CRTP(Derived).sendChannelMessageImpl({
            MIDIMessageType::PROGRAM_CHANGE,
            address.getChannel(),
            uint8_t(value & 0x7F),
            uint8_t(0x00),
            address.getCableNumber(),
        });
}
template <class Derived>
void MIDI_Sender<Derived>::sendProgramChange(MIDIAddress address) {
    if (address)
        CRTP(Derived).sendChannelMessageImpl({
            MIDIMessageType::PROGRAM_CHANGE,
            address.getChannel(),
            address.getAddress(),
            uint8_t(0x00),
            address.getCableNumber(),
        });
}
template <class Derived>
void MIDI_Sender<Derived>::sendChannelPressure(MIDIChannelCable address,
                                               uint8_t pressure) {
    if (address)
        CRTP(Derived).sendChannelMessageImpl({
            MIDIMessageType::CHANNEL_PRESSURE,
            address.getChannel(),
            uint8_t(pressure & 0x7F),
            uint8_t(0x00),
            address.getCableNumber(),
        });
}
template <class Derived>
void MIDI_Sender<Derived>::sendPitchBend(MIDIChannelCable address,
                                         uint16_t value) {
    if (address)
        CRTP(Derived).sendChannelMessageImpl({
            MIDIMessageType::PITCH_BEND,
            address.getChannel(),
            uint8_t((value >> 0) & 0x7F),
            uint8_t((value >> 7) & 0x7F),
            address.getCableNumber(),
        });
}
template <class Derived>
void MIDI_Sender<Derived>::send(SysExMessage message) {
    if (message.length > 0)
        CRTP(Derived).sendSysExImpl(message);
}
 
template <class Derived>
void MIDI_Sender<Derived>::send(RealTimeMessage message) {
    if (message.isValid())
        CRTP(Derived).sendRealTimeImpl(message);
}
 
template <class Derived>
void MIDI_Sender<Derived>::send(ChannelMessage message) {
    if (message.hasValidChannelMessageHeader()) {
        message.sanitize();
        CRTP(Derived).sendChannelMessageImpl(message);
    }
}
 
template <class Derived>
void MIDI_Sender<Derived>::send(SysCommonMessage message) {
    if (message.hasValidSystemCommonHeader()) {
        message.sanitize();
        CRTP(Derived).sendSysCommonImpl(message);
    }
}
 
template <class Derived>
template <uint16_t N>
void MIDI_Sender<Derived>::sendSysEx(const uint8_t (&sysexdata)[N],
                                     Cable cable) {
    send(SysExMessage(sysexdata, N, cable));
}
template <class Derived>
void MIDI_Sender<Derived>::sendSysEx(const uint8_t *data, uint16_t length,
                                     Cable cable) {
    send(SysExMessage(data, length, cable));
}
 
template <class Derived>
void MIDI_Sender<Derived>::sendSysCommon(MIDIMessageType m, Cable cable) {
    send(SysCommonMessage(m, cable));
}
template <class Derived>
void MIDI_Sender<Derived>::sendSysCommon(MIDIMessageType m, uint8_t data1,
                                         Cable cable) {
    send(SysCommonMessage(m, data1, cable));
}
template <class Derived>
void MIDI_Sender<Derived>::sendSysCommon(MIDIMessageType m, uint8_t data1,
                                         uint8_t data2, Cable cable) {
    send(SysCommonMessage(m, data1, data2, cable));
}
 
template <class Derived>
void MIDI_Sender<Derived>::sendMTCQuarterFrame(uint8_t data, Cable cable) {
    send(SysCommonMessage(MIDIMessageType::MTC_QUARTER_FRAME, data, cable));
}
template <class Derived>
void MIDI_Sender<Derived>::sendMTCQuarterFrame(uint8_t messageType,
                                               uint8_t values, Cable cable) {
    sendMTCQuarterFrame((messageType << 4) | values, cable);
}
template <class Derived>
void MIDI_Sender<Derived>::sendSongPositionPointer(uint16_t spp, Cable cable) {
    SysCommonMessage msg(MIDIMessageType::SONG_POSITION_POINTER, cable);
    msg.setData14bit(spp);
    send(msg);
}
template <class Derived>
void MIDI_Sender<Derived>::sendSongSelect(uint8_t song, Cable cable) {
    send(SysCommonMessage(MIDIMessageType::SONG_SELECT, song, cable));
}
template <class Derived>
void MIDI_Sender<Derived>::sendTuneRequest(Cable cable) {
    send(SysCommonMessage(MIDIMessageType::TUNE_REQUEST, cable));
}
 
template <class Derived>
void MIDI_Sender<Derived>::sendRealTime(MIDIMessageType rt, Cable cable) {
    send(RealTimeMessage(rt, cable));
}
template <class Derived>
void MIDI_Sender<Derived>::sendRealTime(uint8_t rt, Cable cable) {
    send(RealTimeMessage(rt, cable));
}
 
template <class Derived>
void MIDI_Sender<Derived>::sendTimingClock(Cable cable) {
    sendRealTime(MIDIMessageType::TIMING_CLOCK, cable);
}
template <class Derived>
void MIDI_Sender<Derived>::sendStart(Cable cable) {
    sendRealTime(MIDIMessageType::START, cable);
}
template <class Derived>
void MIDI_Sender<Derived>::sendContinue(Cable cable) {
    sendRealTime(MIDIMessageType::CONTINUE, cable);
}
template <class Derived>
void MIDI_Sender<Derived>::sendStop(Cable cable) {
    sendRealTime(MIDIMessageType::STOP, cable);
}
template <class Derived>
void MIDI_Sender<Derived>::sendActiveSensing(Cable cable) {
    sendRealTime(MIDIMessageType::ACTIVE_SENSING, cable);
}
template <class Derived>
void MIDI_Sender<Derived>::sendSystemReset(Cable cable) {
    sendRealTime(MIDIMessageType::SYSTEM_RESET, cable);
}
 
template <class Derived>
void MIDI_Sender<Derived>::sendNow() {
    CRTP(Derived).sendNowImpl();
}
 
template <class Derived>
void MIDI_Sender<Derived>::sendKP(MIDIAddress address, uint8_t pressure) {
    sendKeyPressure(address, pressure);
}
template <class Derived>
void MIDI_Sender<Derived>::sendCC(MIDIAddress address, uint8_t value) {
    sendControlChange(address, value);
}
template <class Derived>
void MIDI_Sender<Derived>::sendPC(MIDIAddress address) {
    sendProgramChange(address);
}
template <class Derived>
void MIDI_Sender<Derived>::sendPC(MIDIChannelCable address, uint8_t value) {
    sendProgramChange(address, value);
}
template <class Derived>
void MIDI_Sender<Derived>::sendCP(MIDIChannelCable address, uint8_t pressure) {
    sendChannelPressure(address, pressure);
}
template <class Derived>
void MIDI_Sender<Derived>::sendPB(MIDIChannelCable address, uint16_t value) {
    sendPitchBend(address, value);
}
 
END_CS_NAMESPACE