Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include "BankableMIDIMatcherHelpers.hpp"
       4             : #include "MIDIInputElement.hpp"
       5             : 
       6             : BEGIN_CS_NAMESPACE
       7             : 
       8             : /// @addtogroup MIDIInputMatchers
       9             : /// @{
      10             : 
      11             : // -------------------------------------------------------------------------- //
      12             : 
      13             : /// Matcher for MIDI messages with 1 data byte, such as Channel Pressure
      14             : /// and Program Change.
      15             : struct OneByteMIDIMatcher {
      16           3 :     OneByteMIDIMatcher(MIDIChannelCable address) : address(address) {}
      17             : 
      18             :     struct Result {
      19             :         bool match;
      20             :         uint8_t value;
      21             :     };
      22             : 
      23           4 :     Result operator()(ChannelMessage m) {
      24           4 :         if (!MIDIChannelCable::matchSingle(m.getChannelCable(), address))
      25           2 :             return {false, 0};
      26           2 :         uint8_t value = m.data1;
      27           2 :         return {true, value};
      28             :     }
      29             : 
      30             :     MIDIChannelCable address;
      31             : };
      32             : 
      33             : // -------------------------------------------------------------------------- //
      34             : 
      35             : /// Matcher for MIDI messages with 2 data bytes, such as Note On/Off, Control
      36             : /// Change, Key Pressure (but not Pitch Bend). Matches a single address.
      37             : struct TwoByteMIDIMatcher {
      38           7 :     TwoByteMIDIMatcher(MIDIAddress address) : address(address) {}
      39             : 
      40             :     struct Result {
      41             :         bool match;
      42             :         uint8_t value;
      43             :     };
      44             : 
      45          16 :     Result operator()(ChannelMessage m) {
      46          16 :         if (!MIDIAddress::matchSingle(m.getAddress(), address))
      47           0 :             return {false, 0};
      48             :         uint8_t value =
      49          16 :             m.getMessageType() == MIDIMessageType::NoteOff ? 0 : m.getData2();
      50          16 :         return {true, value};
      51             :     }
      52             : 
      53             :     MIDIAddress address;
      54             : };
      55             : 
      56             : // -------------------------------------------------------------------------- //
      57             : 
      58             : /// Matcher for MIDI Pitch Bend messages. Matches a single address.
      59             : struct PitchBendMIDIMatcher {
      60             :     PitchBendMIDIMatcher(MIDIChannelCable address) : address(address) {}
      61             : 
      62             :     struct Result {
      63             :         bool match;
      64             :         uint16_t value;
      65             :     };
      66             : 
      67             :     Result operator()(ChannelMessage m) {
      68             :         if (!MIDIChannelCable::matchSingle(m.getChannelCable(), address))
      69             :             return {false, 0};
      70             :         uint16_t value = (m.data2 << 7) | m.data1;
      71             :         return {true, value};
      72             :     }
      73             : 
      74             :     MIDIChannelCable address;
      75             : };
      76             : 
      77             : // -------------------------------------------------------------------------- //
      78             : 
      79             : /// Matcher for MIDI messages with 2 data bytes, such as Note On/Off, Control
      80             : /// Change, Key Pressure (but not Pitch Bend). Matches ranges of addresses on a
      81             : /// single channel and cable.
      82             : struct TwoByteRangeMIDIMatcher {
      83          17 :     TwoByteRangeMIDIMatcher(MIDIAddress address, uint8_t length)
      84          17 :         : address(address), length(length) {}
      85             : 
      86             :     struct Result {
      87             :         bool match;
      88             :         uint8_t value;
      89             :         uint8_t index;
      90             :     };
      91             : 
      92          96 :     Result operator()(ChannelMessage m) {
      93          96 :         if (!MIDIAddress::matchAddressInRange(m.getAddress(), address, length))
      94           2 :             return {false, 0, 0};
      95             :         uint8_t value =
      96          94 :             m.getMessageType() == MIDIMessageType::NoteOff ? 0 : m.getData2();
      97          94 :         uint8_t index = m.getData1() - address.getAddress();
      98          94 :         return {true, value, index};
      99             :     }
     100             : 
     101             :     MIDIAddress address;
     102             :     uint8_t length;
     103             : };
     104             : 
     105             : // -------------------------------------------------------------------------- //
     106             : 
     107             : /// Matcher for MIDI messages with 1 data byte, such as Channel Pressure
     108             : /// and Program Change. Matches a single address over multiple banks.
     109             : template <uint8_t BankSize>
     110             : struct BankableOneByteMIDIMatcher {
     111             :     BankableOneByteMIDIMatcher(
     112             :         BankConfig<BankSize, BankType::ChangeChannel> config,
     113             :         MIDIChannelCable address)
     114             :         : config(config), address(address) {}
     115             : 
     116             :     struct Result {
     117             :         bool match;
     118             :         uint8_t value;
     119             :         uint8_t bankIndex;
     120             :     };
     121             : 
     122             :     Result operator()(ChannelMessage m) {
     123             :         using BankableMIDIMatcherHelpers::getBankIndex;
     124             :         using BankableMIDIMatcherHelpers::matchBankable;
     125             :         if (!matchBankable(m.getChannelCable(), address, config))
     126             :             return {false, 0, 0};
     127             :         uint8_t value = m.data1;
     128             :         uint8_t bankIndex = getBankIndex(m.getChannelCable(), address, config);
     129             :         return {true, value, bankIndex};
     130             :     }
     131             : 
     132             :     Bank<BankSize> &getBank() { return config.bank; }
     133             :     const Bank<BankSize> &getBank() const { return config.bank; }
     134             :     BankType getBankType() const { return config.type; }
     135             :     static constexpr setting_t getBankSize() { return BankSize; }
     136             : 
     137             :     /// Get the current bank setting.
     138             :     /// @see    @ref Bank<N>::getSelection()
     139             :     setting_t getSelection() const { return getBank().getSelection(); }
     140             : 
     141             :     BaseBankConfig<BankSize> config;
     142             :     MIDIChannelCable address;
     143             : };
     144             : 
     145             : // -------------------------------------------------------------------------- //
     146             : 
     147             : /// Matcher for MIDI messages with 2 data bytes, such as Note On/Off, Control
     148             : /// Change, Key Pressure. Matches a single address over multiple banks.
     149             : template <uint8_t BankSize>
     150             : struct BankableTwoByteMIDIMatcher {
     151           6 :     BankableTwoByteMIDIMatcher(BankConfig<BankSize> config, MIDIAddress address)
     152           6 :         : config(config), address(address) {}
     153             : 
     154             :     struct Result {
     155             :         bool match;
     156             :         uint8_t value;
     157             :         uint8_t bankIndex;
     158             :     };
     159             : 
     160          11 :     Result operator()(ChannelMessage m) {
     161             :         using BankableMIDIMatcherHelpers::getBankIndex;
     162             :         using BankableMIDIMatcherHelpers::matchBankable;
     163          11 :         if (!matchBankable(m.getAddress(), address, config))
     164           0 :             return {false, 0, 0};
     165          11 :         uint8_t value =
     166          20 :             m.getMessageType() == MIDIMessageType::NoteOff ? 0 : m.getData2();
     167          11 :         uint8_t bankIndex = getBankIndex(m.getAddress(), address, config);
     168          11 :         return {true, value, bankIndex};
     169             :     }
     170             : 
     171          12 :     Bank<BankSize> &getBank() { return config.bank; }
     172          55 :     const Bank<BankSize> &getBank() const { return config.bank; }
     173             :     BankType getBankType() const { return config.type; }
     174             :     static constexpr setting_t getBankSize() { return BankSize; }
     175             : 
     176             :     /// Get the current bank setting.
     177             :     /// @see    @ref Bank<N>::getSelection()
     178          55 :     setting_t getSelection() const { return getBank().getSelection(); }
     179             : 
     180             :     BaseBankConfig<BankSize> config;
     181             :     MIDIAddress address;
     182             : };
     183             : 
     184             : // -------------------------------------------------------------------------- //
     185             : 
     186             : /// Matcher for MIDI Pitch Bend messages. Matches a single address over multiple
     187             : /// banks.
     188             : template <uint8_t BankSize>
     189             : struct BankablePitchBendMIDIMatcher {
     190             :     BankablePitchBendMIDIMatcher(
     191             :         BankConfig<BankSize, BankType::ChangeChannel> config,
     192             :         MIDIChannelCable address)
     193             :         : config(config), address(address) {}
     194             : 
     195             :     struct Result {
     196             :         bool match;
     197             :         uint16_t value;
     198             :         uint8_t bankIndex;
     199             :     };
     200             : 
     201             :     Result operator()(ChannelMessage m) {
     202             :         using BankableMIDIMatcherHelpers::getBankIndex;
     203             :         using BankableMIDIMatcherHelpers::matchBankable;
     204             :         if (!matchBankable(m.getChannelCable(), address, config))
     205             :             return {false, 0, 0};
     206             :         uint16_t value = (m.data2 << 7) | m.data1;
     207             :         uint8_t bankIndex = getBankIndex(m.getChannelCable(), address, config);
     208             :         return {true, value, bankIndex};
     209             :     }
     210             : 
     211             :     Bank<BankSize> &getBank() { return config.bank; }
     212             :     const Bank<BankSize> &getBank() const { return config.bank; }
     213             :     BankType getBankType() const { return config.type; }
     214             :     static constexpr setting_t getBankSize() { return BankSize; }
     215             : 
     216             :     /// Get the current bank setting.
     217             :     /// @see    @ref Bank<N>::getSelection()
     218             :     setting_t getSelection() const { return getBank().getSelection(); }
     219             : 
     220             :     BaseBankConfig<BankSize> config;
     221             :     MIDIChannelCable address;
     222             : };
     223             : 
     224             : // -------------------------------------------------------------------------- //
     225             : 
     226             : /// Matcher for MIDI messages with 2 data bytes, such as Note On/Off, Control
     227             : /// Change, Key Pressure. Matches a range of addresses over multiple banks.
     228             : template <uint8_t BankSize>
     229             : struct BankableTwoByteRangeMIDIMatcher {
     230             :     /// Constructor.
     231           6 :     BankableTwoByteRangeMIDIMatcher(BankConfig<BankSize> config,
     232             :                                     MIDIAddress address, uint8_t length)
     233           6 :         : config(config), address(address), length(length) {}
     234             : 
     235             :     struct Result {
     236             :         bool match;
     237             :         uint8_t value;
     238             :         uint8_t bankIndex;
     239             :         uint8_t index;
     240             :     };
     241             : 
     242          30 :     Result operator()(ChannelMessage m) {
     243             :         using BankableMIDIMatcherHelpers::getBankIndex;
     244             :         using BankableMIDIMatcherHelpers::getRangeIndex;
     245             :         using BankableMIDIMatcherHelpers::matchBankableInRange;
     246          30 :         if (!matchBankableInRange(m.getAddress(), address, config, length))
     247          18 :             return {false, 0, 0, 0};
     248          12 :         uint8_t value = m.getMessageType() == m.NoteOff ? 0 : m.getData2();
     249          12 :         uint8_t bankIndex = getBankIndex(m.getAddress(), address, config);
     250          12 :         uint8_t rangeIndex = getRangeIndex(m.getAddress(), address, config);
     251          12 :         return {true, value, bankIndex, rangeIndex};
     252             :     }
     253             : 
     254          12 :     Bank<BankSize> &getBank() { return config.bank; }
     255             :     const Bank<BankSize> &getBank() const { return config.bank; }
     256             :     static constexpr setting_t getBankSize() { return BankSize; }
     257             : 
     258             :     /// Get the current bank setting.
     259             :     /// @see    @ref Bank<N>::getSelection()
     260         180 :     setting_t getSelection() const { return config.bank.getSelection(); }
     261             : 
     262             :     BaseBankConfig<BankSize> config;
     263             :     MIDIAddress address;
     264             :     uint8_t length;
     265             : };
     266             : 
     267             : // -------------------------------------------------------------------------- //
     268             : 
     269             : /// @}
     270             : 
     271             : END_CS_NAMESPACE