LCOV - code coverage report
Current view: top level - src/MIDI_Inputs - NoteCCRange.hpp (source / functions) Hit Total Coverage
Test: 19d2efc7037c2e176feca44750a12594c76f466f Lines: 71 72 98.6 %
Date: 2019-11-24 14:50:27 Functions: 65 83 78.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #pragma once
       2             : 
       3             : #include <Banks/BankableMIDIInput.hpp>
       4             : #include <MIDI_Inputs/MIDIInputElementCC.hpp>
       5             : #include <MIDI_Inputs/MIDIInputElementNote.hpp>
       6             : 
       7             : BEGIN_CS_NAMESPACE
       8             : 
       9             : class INoteCCValue {
      10             :   protected:
      11          10 :     INoteCCValue(uint8_t rangeLength) : rangeLength{rangeLength} {}
      12             : 
      13             :   public:
      14           4 :     uint8_t length() const { return rangeLength; }
      15             :     virtual uint8_t getValue(uint8_t index) const = 0;
      16          12 :     uint8_t getValue() const { return getValue(0); }
      17             : 
      18             :   private:
      19             :     uint8_t rangeLength;
      20             : };
      21             : 
      22             : class NoteCCRangeEmptyCallback {
      23             :   public:
      24           9 :     void begin(const INoteCCValue &) {}
      25          13 :     void update(const INoteCCValue &, uint8_t) {}
      26          30 :     void updateAll(const INoteCCValue &) {}
      27             : };
      28             : 
      29           1 : struct SimpleNoteCCValueCallback {
      30             :   protected:
      31           1 :     SimpleNoteCCValueCallback() = default;
      32             : 
      33             :   public:
      34           0 :     virtual void begin(const INoteCCValue &) {}
      35             :     virtual void update(const INoteCCValue &, uint8_t) = 0;
      36           2 :     virtual void updateAll(const INoteCCValue &noteccval) {
      37           4 :         for (uint8_t i = 0; i < noteccval.length(); ++i)
      38           2 :             update(noteccval, i);
      39           2 :     }
      40             : };
      41             : 
      42             : // -------------------------------------------------------------------------- //
      43             : 
      44             : template <class MIDIInput_t, uint8_t RangeLen, uint8_t NumBanks, class Callback>
      45          10 : class NoteCCRange : public MIDIInput_t, public INoteCCValue {
      46             :   public:
      47          10 :     NoteCCRange(MIDICNChannelAddress address, const Callback &callback)
      48          20 :         : MIDIInput_t{address}, INoteCCValue{RangeLen}, callback{callback} {}
      49             : 
      50             :     /// @todo   check index bounds
      51         132 :     uint8_t getValue(uint8_t index) const override {
      52         132 :         return values[getSelection()][index];
      53             :     }
      54             :     using INoteCCValue::getValue;
      55             : 
      56             :     /// Initialize
      57          11 :     void begin() override { callback.begin(*this); }
      58             :     /// Reset all values to zero
      59           2 :     void reset() override {
      60           2 :         values = {};
      61           2 :         callback.updateAll(*this);
      62           2 :     }
      63             : 
      64             :   private:
      65          19 :     bool updateImpl(const ChannelMessageMatcher &midimsg,
      66             :                     const MIDICNChannelAddress &target) override {
      67          19 :         uint8_t bankIndex = this->getBankIndex(target);
      68          19 :         uint8_t rangeIndex = this->getRangeIndex(target);
      69          19 :         uint8_t value = getValueFromMIDIMessage(midimsg);
      70          19 :         values[bankIndex][rangeIndex] = value;
      71          19 :         if (bankIndex == this->getSelection())
      72          15 :             callback.update(*this, rangeIndex);
      73          19 :         return true;
      74             :     }
      75             : 
      76             :     static uint8_t
      77          19 :     getValueFromMIDIMessage(const ChannelMessageMatcher &midimsg) {
      78          19 :         return midimsg.type == NOTE_OFF ? 0 : midimsg.data2;
      79             :     }
      80             : 
      81             :     /// Get the active bank selection
      82          35 :     virtual uint8_t getSelection() const { return 0; }
      83             : 
      84             :     /// Get the bank index from a MIDI address
      85          11 :     virtual setting_t getBankIndex(MIDICNChannelAddress target) const {
      86             :         (void)target;
      87          11 :         return 0;
      88             :     }
      89             : 
      90          11 :     virtual uint8_t getRangeIndex(MIDICNChannelAddress target) const {
      91          11 :         return target.getAddress() - this->address.getAddress();
      92             :     }
      93             : 
      94          14 :     Array<Array<uint8_t, RangeLen>, NumBanks> values = {};
      95             : 
      96             :   public:
      97             :     Callback callback;
      98             :     constexpr static uint8_t length() { return RangeLen; }
      99             : };
     100             : 
     101             : // -------------------------------------------------------------------------- //
     102             : 
     103             : template <class MIDIInput_t, uint8_t RangeLen,
     104             :           class Callback = NoteCCRangeEmptyCallback>
     105           6 : class GenericNoteCCRange
     106             :     : public NoteCCRange<MIDIInput_t, RangeLen, 1, Callback> {
     107             :   public:
     108           6 :     GenericNoteCCRange(MIDICNChannelAddress address, const Callback &callback)
     109           6 :         : NoteCCRange<MIDIInput_t, RangeLen, 1, Callback>{address, callback} {}
     110             : 
     111             :   private:
     112             :     /// Check if the address of the incoming MIDI message is within the range
     113             :     /// of addresses of this element.
     114          11 :     bool match(const MIDICNChannelAddress &target) const override {
     115          11 :         return MIDICNChannelAddress::matchAddressInRange( //
     116          11 :             target, this->address, RangeLen);
     117             :     }
     118             : };
     119             : 
     120             : /**
     121             :  * @brief   MIDI Input Element that listens to a range of notes.
     122             :  * 
     123             :  * @ingroup MIDIInputElements
     124             :  * @tparam  RangeLen 
     125             :  *          The length of the range of notes to listen to.
     126             :  */
     127             : template <uint8_t RangeLen>
     128           1 : class NoteRange : public GenericNoteCCRange<MIDIInputElementNote, RangeLen> {
     129             :   public:
     130           1 :     NoteRange(MIDICNChannelAddress address)
     131           1 :         : GenericNoteCCRange<MIDIInputElementNote, RangeLen>{address, {}} {}
     132             : };
     133             : 
     134           4 : class NoteValue : public GenericNoteCCRange<MIDIInputElementNote, 1> {
     135             :   public:
     136           4 :     NoteValue(MIDICNChannelAddress address)
     137           4 :         : GenericNoteCCRange<MIDIInputElementNote, 1>{address, {}} {}
     138             : };
     139             : using MIDINote[[deprecated("Use NoteValue instead")]] = NoteValue;
     140             : 
     141             : template <uint8_t RangeLen>
     142             : class CCRange : public GenericNoteCCRange<MIDIInputElementCC, RangeLen> {
     143             :   public:
     144             :     CCRange(MIDICNChannelAddress address)
     145             :         : GenericNoteCCRange<MIDIInputElementCC, RangeLen>{address, {}} {}
     146             : };
     147             : 
     148             : class CCValue : public GenericNoteCCRange<MIDIInputElementCC, 1> {
     149             :   public:
     150             :     CCValue(MIDICNChannelAddress address)
     151             :         : GenericNoteCCRange<MIDIInputElementCC, 1>{address, {}} {}
     152             : };
     153             : 
     154             : // -------------------------------------------------------------------------- //
     155             : 
     156             : namespace Bankable {
     157             : 
     158             : /// @tparam RangeLen
     159             : ///         The length of the range.
     160             : /// @tparam NumBanks
     161             : ///         The size of the bank.
     162             : template <class MIDIInput_t, uint8_t RangeLen, uint8_t NumBanks,
     163             :           class Callback = NoteCCRangeEmptyCallback>
     164           4 : class GenericNoteCCRange
     165             :     : public NoteCCRange<MIDIInput_t, RangeLen, NumBanks, Callback>,
     166             :       public BankableMIDIInput<NumBanks> {
     167             :   public:
     168           4 :     GenericNoteCCRange(BankConfig<NumBanks> config,
     169             :                        MIDICNChannelAddress address,
     170             :                        const Callback &callback)
     171           4 :         : NoteCCRange<MIDIInput_t, RangeLen, NumBanks, Callback>{
     172           4 :             address,
     173           4 :             callback,
     174           8 :         }, BankableMIDIInput<NumBanks>{config} {}
     175             : 
     176             :   private:
     177             :     /// Check if the address of the incoming MIDI message is within the range
     178             :     /// of addresses and in one of the banks of this element.
     179          20 :     bool match(const MIDICNChannelAddress &target) const override {
     180          40 :         return BankableMIDIInput<NumBanks>::matchBankableAddressInRange(
     181          20 :             target, this->address, RangeLen);
     182             :     }
     183             : 
     184         116 :     setting_t getSelection() const override {
     185         116 :         return BankableMIDIInput<NumBanks>::getSelection();
     186             :     };
     187             : 
     188           8 :     uint8_t getBankIndex(MIDICNChannelAddress target) const override {
     189           8 :         return BankableMIDIInput<NumBanks>::getBankIndex(target, this->address);
     190             :     }
     191             : 
     192           8 :     uint8_t getRangeIndex(MIDICNChannelAddress target) const override {
     193          16 :         return BankableMIDIInput<NumBanks>::getRangeIndex(target,
     194           8 :                                                           this->address);
     195             :     }
     196             : 
     197          28 :     void onBankSettingChange() override { this->callback.updateAll(*this); }
     198             : };
     199             : 
     200             : template <uint8_t RangeLen, uint8_t NumBanks>
     201           4 : class NoteRange
     202             :     : public GenericNoteCCRange<MIDIInputElementNote, RangeLen, NumBanks> {
     203             :   public:
     204           4 :     NoteRange(BankConfig<NumBanks> config, MIDICNChannelAddress address)
     205           4 :         : GenericNoteCCRange<MIDIInputElementNote, RangeLen, NumBanks>{
     206           8 :               config, address, {}} {}
     207             : };
     208             : 
     209             : template <uint8_t NumBanks>
     210             : class NoteValue : public GenericNoteCCRange<MIDIInputElementNote, 1, NumBanks> {
     211             :   public:
     212             :     NoteValue(BankConfig<NumBanks> config, MIDICNChannelAddress address)
     213             :         : GenericNoteCCRange<MIDIInputElementNote, 1, NumBanks>{
     214             :               config, address, {}} {}
     215             : };
     216             : template <uint8_t NumBanks>
     217             : using MIDINote[[deprecated("Use NoteValue instead")]] = NoteValue<NumBanks>;
     218             : 
     219             : template <uint8_t RangeLen, uint8_t NumBanks>
     220             : class CCRange
     221             :     : public GenericNoteCCRange<MIDIInputElementCC, RangeLen, NumBanks> {
     222             :   public:
     223             :     CCRange(BankConfig<NumBanks> config, MIDICNChannelAddress address)
     224             :         : GenericNoteCCRange<MIDIInputElementCC, RangeLen, NumBanks>{
     225             :               config, address, {}} {}
     226             : };
     227             : 
     228             : template <uint8_t NumBanks>
     229             : class CCValue : public GenericNoteCCRange<MIDIInputElementCC, 1, NumBanks> {
     230             :   public:
     231             :     CCValue(BankConfig<NumBanks> config, MIDICNChannelAddress address)
     232             :         : GenericNoteCCRange<MIDIInputElementCC, 1, NumBanks>{
     233             :               config, address, {}} {}
     234             : };
     235             : 
     236             : } // namespace Bankable
     237             : 
     238             : END_CS_NAMESPACE

Generated by: LCOV version 1.14-5-g4ff2ed6