28 const uint8 noLSBValueReceived = 0xff;
29 const Range<int> allChannels { 1, 17 };
35 std::fill_n (lastPressureLowerBitReceivedOnChannel, 16, noLSBValueReceived);
36 std::fill_n (lastTimbreLowerBitReceivedOnChannel, 16, noLSBValueReceived);
37 std::fill_n (isMemberChannelSustained, 16,
false);
46 legacyMode.isEnabled =
false;
47 legacyMode.pitchbendRange = 2;
48 legacyMode.channelRange = allChannels;
66 legacyMode.isEnabled =
false;
67 zoneLayout = newLayout;
76 legacyMode.isEnabled =
true;
77 legacyMode.pitchbendRange = pitchbendRange;
78 legacyMode.channelRange = channelRange;
84 return legacyMode.isEnabled;
89 return legacyMode.channelRange;
94 jassert (allChannels.contains (channelRange));
98 legacyMode.channelRange = channelRange;
103 return legacyMode.pitchbendRange;
108 jassert (pitchbendRange >= 0 && pitchbendRange <= 96);
112 legacyMode.pitchbendRange = pitchbendRange;
118 pressureDimension.trackingMode = modeToUse;
123 pitchbendDimension.trackingMode = modeToUse;
128 timbreDimension.trackingMode = modeToUse;
134 listeners.add (listenerToAdd);
139 listeners.remove (listenerToRemove);
147 if (message.
isNoteOn (
true)) processMidiNoteOnMessage (message);
148 else if (message.
isNoteOff (
false)) processMidiNoteOffMessage (message);
150 || message.
isAllNotesOff()) processMidiResetAllControllersMessage (message);
151 else if (message.
isPitchWheel()) processMidiPitchWheelMessage (message);
152 else if (message.
isChannelPressure()) processMidiChannelPressureMessage (message);
153 else if (message.
isController()) processMidiControllerMessage (message);
154 else if (message.
isAftertouch()) processMidiAfterTouchMessage (message);
158void MPEInstrument::processMidiNoteOnMessage (
const MidiMessage& message)
179void MPEInstrument::processMidiNoteOffMessage (
const MidiMessage& message)
182 message.getNoteNumber(),
187void MPEInstrument::processMidiPitchWheelMessage (
const MidiMessage& message)
194void MPEInstrument::processMidiChannelPressureMessage (
const MidiMessage& message)
201void MPEInstrument::processMidiControllerMessage (
const MidiMessage& message)
203 switch (message.getControllerNumber())
205 case 64:
sustainPedal (message.getChannel(), message.isSustainPedalOn());
break;
206 case 66:
sostenutoPedal (message.getChannel(), message.isSostenutoPedalOn());
break;
207 case 70: handlePressureMSB (message.getChannel(), message.getControllerValue());
break;
208 case 74: handleTimbreMSB (message.getChannel(), message.getControllerValue());
break;
209 case 102: handlePressureLSB (message.getChannel(), message.getControllerValue());
break;
210 case 106: handleTimbreLSB (message.getChannel(), message.getControllerValue());
break;
216void MPEInstrument::processMidiResetAllControllersMessage (
const MidiMessage& message)
221 if (legacyMode.isEnabled && legacyMode.channelRange.contains (message.getChannel()))
223 for (
auto i = notes.size(); --i >= 0;)
225 auto& note = notes.getReference (i);
227 if (note.midiChannel == message.getChannel())
231 listeners.call ([&] (Listener& l) { l.noteReleased (note); });
238 auto zone = (message.getChannel() == 1 ? zoneLayout.
getLowerZone()
241 for (
auto i = notes.size(); --i >= 0;)
243 auto& note = notes.getReference (i);
245 if (zone.isUsing (note.midiChannel))
249 listeners.call ([&] (Listener& l) { l.noteReleased (note); });
256void MPEInstrument::processMidiAfterTouchMessage (
const MidiMessage& message)
266void MPEInstrument::handlePressureMSB (
int midiChannel,
int value)
noexcept
268 auto lsb = lastPressureLowerBitReceivedOnChannel[midiChannel - 1];
274void MPEInstrument::handlePressureLSB (
int midiChannel,
int value)
noexcept
276 lastPressureLowerBitReceivedOnChannel[midiChannel - 1] = uint8 (value);
279void MPEInstrument::handleTimbreMSB (
int midiChannel,
int value)
noexcept
281 auto lsb = lastTimbreLowerBitReceivedOnChannel[midiChannel - 1];
287void MPEInstrument::handleTimbreLSB (
int midiChannel,
int value)
noexcept
289 lastTimbreLowerBitReceivedOnChannel[midiChannel - 1] = uint8 (value);
303 getInitialValueForNewNote (midiChannel, pitchbendDimension),
304 getInitialValueForNewNote (midiChannel, pressureDimension),
305 getInitialValueForNewNote (midiChannel, timbreDimension),
309 updateNoteTotalPitchbend (newNote);
311 if (
auto* alreadyPlayingNote = getNotePtr (midiChannel, midiNoteNumber))
317 notes.remove (alreadyPlayingNote);
334 if (
auto* note = getNotePtr (midiChannel, midiNoteNumber))
337 note->noteOffVelocity = midiNoteOffVelocity;
340 if (getLastNotePlayedPtr (midiChannel) ==
nullptr)
363 updateDimension (midiChannel, pitchbendDimension, value);
369 updateDimension (midiChannel, pressureDimension, value);
375 updateDimension (midiChannel, timbreDimension, value);
382 for (
auto i = notes.size(); --i >= 0;)
384 auto& note = notes.getReference (i);
386 if (note.midiChannel == midiChannel
387 && note.initialNote == midiNoteNumber
388 && pressureDimension.getValue (note) != value)
390 pressureDimension.getValue (note) = value;
391 callListenersDimensionChanged (note, pressureDimension);
396MPEValue MPEInstrument::getInitialValueForNewNote (
int midiChannel, MPEDimension& dimension)
const
398 if (getLastNotePlayedPtr (midiChannel) !=
nullptr)
401 return dimension.lastValueReceivedOnChannel[midiChannel - 1];
405void MPEInstrument::updateDimension (
int midiChannel, MPEDimension& dimension, MPEValue value)
407 dimension.lastValueReceivedOnChannel[midiChannel - 1] = value;
416 for (
auto i = notes.size(); --i >= 0;)
418 auto& note = notes.getReference (i);
420 if (note.midiChannel == midiChannel)
421 updateDimensionForNote (note, dimension, value);
426 if (
auto* note = getNotePtr (midiChannel, dimension.trackingMode))
427 updateDimensionForNote (*note, dimension, value);
432 updateDimensionMaster (midiChannel == 1, dimension, value);
437void MPEInstrument::updateDimensionMaster (
bool isLowerZone, MPEDimension& dimension, MPEValue value)
442 if (! zone.isActive())
445 for (
auto i = notes.size(); --i >= 0;)
447 auto& note = notes.getReference (i);
449 if (! zone.isUsing (note.midiChannel))
452 if (&dimension == &pitchbendDimension)
456 updateNoteTotalPitchbend (note);
457 listeners.call ([&] (Listener& l) { l.notePitchbendChanged (note); });
459 else if (dimension.getValue (note) != value)
461 dimension.getValue (note) = value;
462 callListenersDimensionChanged (note, dimension);
468void MPEInstrument::updateDimensionForNote (MPENote& note, MPEDimension& dimension, MPEValue value)
470 if (dimension.getValue (note) != value)
472 dimension.getValue (note) = value;
474 if (&dimension == &pitchbendDimension)
475 updateNoteTotalPitchbend (note);
477 callListenersDimensionChanged (note, dimension);
482void MPEInstrument::callListenersDimensionChanged (
const MPENote& note,
const MPEDimension& dimension)
484 if (&dimension == &pressureDimension) { listeners.call ([&] (Listener& l) { l.notePressureChanged (note); });
return; }
485 if (&dimension == &timbreDimension) { listeners.call ([&] (Listener& l) { l.noteTimbreChanged (note); });
return; }
486 if (&dimension == &pitchbendDimension) { listeners.call ([&] (Listener& l) { l.notePitchbendChanged (note); });
return; }
490void MPEInstrument::updateNoteTotalPitchbend (MPENote& note)
492 if (legacyMode.isEnabled)
494 note.totalPitchbendInSemitones = note.pitchbend.asSignedFloat() * legacyMode.pitchbendRange;
500 if (! zone.isUsing (note.midiChannel))
502 if (zoneLayout.
getUpperZone().isUsing (note.midiChannel))
514 auto notePitchbendInSemitones = 0.0f;
516 if (zone.isUsingChannelAsMemberChannel (note.midiChannel))
517 notePitchbendInSemitones = note.pitchbend.asSignedFloat() * zone.perNotePitchbendRange;
519 auto masterPitchbendInSemitones = pitchbendDimension.lastValueReceivedOnChannel[zone.getMasterChannel() - 1]
521 * zone.masterPitchbendRange;
523 note.totalPitchbendInSemitones = notePitchbendInSemitones + masterPitchbendInSemitones;
531 handleSustainOrSostenuto (midiChannel, isDown,
false);
537 handleSustainOrSostenuto (midiChannel, isDown,
true);
541void MPEInstrument::handleSustainOrSostenuto (
int midiChannel,
bool isDown,
bool isSostenuto)
546 if (legacyMode.isEnabled ? (! legacyMode.channelRange.contains (midiChannel)) : (!
isMasterChannel (midiChannel)))
549 auto zone = (midiChannel == 1 ? zoneLayout.
getLowerZone()
552 for (
auto i = notes.size(); --i >= 0;)
554 auto& note = notes.getReference (i);
556 if (legacyMode.isEnabled ? (note.midiChannel == midiChannel) : zone.isUsing (note.midiChannel))
567 listeners.call ([&] (Listener& l) { l.noteReleased (note); });
572 listeners.call ([&] (Listener& l) { l.noteKeyStateChanged (note); });
579 if (legacyMode.isEnabled)
581 isMemberChannelSustained[midiChannel - 1] = isDown;
585 if (zone.isLowerZone())
586 for (
auto i = zone.getFirstMemberChannel(); i <= zone.getLastMemberChannel(); ++i)
587 isMemberChannelSustained[i - 1] = isDown;
589 for (
auto i = zone.getFirstMemberChannel(); i >= zone.getLastMemberChannel(); --i)
590 isMemberChannelSustained[i - 1] = isDown;
598 if (legacyMode.isEnabled)
599 return legacyMode.channelRange.contains (midiChannel);
601 return zoneLayout.getLowerZone().isUsingChannelAsMemberChannel (midiChannel)
602 || zoneLayout.getUpperZone().isUsingChannelAsMemberChannel (midiChannel);
607 if (legacyMode.isEnabled)
610 const auto lowerZone = zoneLayout.getLowerZone();
611 const auto upperZone = zoneLayout.getUpperZone();
613 return (lowerZone.isActive() && midiChannel == lowerZone.getMasterChannel())
614 || (upperZone.isActive() && midiChannel == upperZone.getMasterChannel());
619 if (legacyMode.isEnabled)
620 return legacyMode.channelRange.contains (midiChannel);
622 return zoneLayout.getLowerZone().isUsing (midiChannel)
623 || zoneLayout.getUpperZone().isUsing (midiChannel);
634 if (
auto* note = getNotePtr (midiChannel, midiNoteNumber))
648 if (
auto* note = getLastNotePlayedPtr (midiChannel))
656 for (
auto i = notes.size(); --i >= 0;)
658 auto& note = notes.getReference (i);
660 if (note != otherThanThisNote)
668const MPENote* MPEInstrument::getNotePtr (
int midiChannel,
int midiNoteNumber)
const noexcept
670 for (
int i = 0; i < notes.size(); ++i)
672 auto& note = notes.getReference (i);
674 if (note.midiChannel == midiChannel && note.initialNote == midiNoteNumber)
681MPENote* MPEInstrument::getNotePtr (
int midiChannel,
int midiNoteNumber)
noexcept
683 return const_cast<MPENote*
> (
static_cast<const MPEInstrument&
> (*this).getNotePtr (midiChannel, midiNoteNumber));
687const MPENote* MPEInstrument::getNotePtr (
int midiChannel, TrackingMode mode)
const noexcept
691 jassert (mode != allNotesOnChannel);
693 if (mode == lastNotePlayedOnChannel)
return getLastNotePlayedPtr (midiChannel);
694 if (mode == lowestNoteOnChannel)
return getLowestNotePtr (midiChannel);
695 if (mode == highestNoteOnChannel)
return getHighestNotePtr (midiChannel);
700MPENote* MPEInstrument::getNotePtr (
int midiChannel, TrackingMode mode)
noexcept
702 return const_cast<MPENote*
> (
static_cast<const MPEInstrument&
> (*this).getNotePtr (midiChannel, mode));
706const MPENote* MPEInstrument::getLastNotePlayedPtr (
int midiChannel)
const noexcept
708 for (
auto i = notes.size(); --i >= 0;)
710 auto& note = notes.getReference (i);
712 if (note.midiChannel == midiChannel
720MPENote* MPEInstrument::getLastNotePlayedPtr (
int midiChannel)
noexcept
722 return const_cast<MPENote*
> (
static_cast<const MPEInstrument&
> (*this).getLastNotePlayedPtr (midiChannel));
726const MPENote* MPEInstrument::getHighestNotePtr (
int midiChannel)
const noexcept
728 int initialNoteMax = -1;
729 const MPENote* result =
nullptr;
731 for (
auto i = notes.size(); --i >= 0;)
733 auto& note = notes.getReference (i);
735 if (note.midiChannel == midiChannel
737 && note.initialNote > initialNoteMax)
740 initialNoteMax = note.initialNote;
747MPENote* MPEInstrument::getHighestNotePtr (
int midiChannel)
noexcept
749 return const_cast<MPENote*
> (
static_cast<const MPEInstrument&
> (*this).getHighestNotePtr (midiChannel));
752const MPENote* MPEInstrument::getLowestNotePtr (
int midiChannel)
const noexcept
754 int initialNoteMin = 128;
755 const MPENote* result =
nullptr;
757 for (
auto i = notes.size(); --i >= 0;)
759 auto& note = notes.getReference (i);
761 if (note.midiChannel == midiChannel
763 && note.initialNote < initialNoteMin)
766 initialNoteMin = note.initialNote;
773MPENote* MPEInstrument::getLowestNotePtr (
int midiChannel)
noexcept
775 return const_cast<MPENote*
> (
static_cast<const MPEInstrument&
> (*this).getLowestNotePtr (midiChannel));
783 for (
auto i = notes.size(); --i >= 0;)
785 auto& note = notes.getReference (i);
799class MPEInstrumentTests :
public UnitTest
803 :
UnitTest (
"MPEInstrument class", UnitTestCategories::midi)
810 testLayout.setLowerZone (5);
811 testLayout.setUpperZone (6);
814 void runTest()
override
816 beginTest (
"initial zone layout");
819 expect (! test.getZoneLayout().getLowerZone().isActive());
820 expect (! test.getZoneLayout().getUpperZone().isActive());
823 beginTest (
"get/setZoneLayout");
826 test.setZoneLayout (testLayout);
828 auto newLayout = test.getZoneLayout();
830 expect (test.getZoneLayout().getLowerZone().isActive());
831 expect (test.getZoneLayout().getUpperZone().isActive());
832 expectEquals (newLayout.getLowerZone().getMasterChannel(), 1);
833 expectEquals (newLayout.getLowerZone().numMemberChannels, 5);
834 expectEquals (newLayout.getUpperZone().getMasterChannel(), 16);
835 expectEquals (newLayout.getUpperZone().numMemberChannels, 6);
838 beginTest (
"noteOn / noteOff");
842 test.setZoneLayout (testLayout);
843 expectEquals (test.getNumPlayingNotes(), 0);
846 UnitTestInstrument test;
847 test.setZoneLayout (testLayout);
850 test.noteOn (7, 60, MPEValue::from7BitInt (100));
851 expectEquals (test.getNumPlayingNotes(), 0);
852 expectEquals (test.noteAddedCallCounter, 0);
855 test.noteOn (3, 60, MPEValue::from7BitInt (100));
856 expectEquals (test.getNumPlayingNotes(), 1);
857 expectEquals (test.noteAddedCallCounter, 1);
858 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
861 test.noteOff (3, 60, MPEValue::from7BitInt (33));
862 expectEquals (test.getNumPlayingNotes(), 0);
863 expectEquals (test.noteReleasedCallCounter, 1);
864 expectHasFinishedNote (test, 3, 60, 33);
868 test.noteOn (1, 62, MPEValue::from7BitInt (100));
869 expectEquals (test.getNumPlayingNotes(), 1);
870 expectEquals (test.noteAddedCallCounter, 2);
871 expectNote (test.getNote (1, 62), 100, 0, 8192, 64, MPENote::keyDown);
874 test.noteOff (1, 62, MPEValue::from7BitInt (33));
875 expectEquals (test.getNumPlayingNotes(), 0);
876 expectEquals (test.noteReleasedCallCounter, 2);
877 expectHasFinishedNote (test, 1, 62, 33);
881 UnitTestInstrument test;
882 test.setZoneLayout (testLayout);
883 test.noteOn (3, 60, MPEValue::from7BitInt (100));
886 test.noteOff (3, 61, MPEValue::from7BitInt (33));
887 expectEquals (test.getNumPlayingNotes(), 1);
888 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
889 expectEquals (test.noteReleasedCallCounter, 0);
892 test.noteOff (2, 60, MPEValue::from7BitInt (33));
893 expectEquals (test.getNumPlayingNotes(), 1);
894 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
895 expectEquals (test.noteReleasedCallCounter, 0);
900 UnitTestInstrument test;
901 test.setZoneLayout (testLayout);
902 test.noteOn (3, 0, MPEValue::from7BitInt (100));
903 test.noteOn (3, 1, MPEValue::from7BitInt (100));
904 test.noteOn (3, 2, MPEValue::from7BitInt (100));
905 expectEquals (test.getNumPlayingNotes(), 3);
906 expectNote (test.getNote (3, 0), 100, 0, 8192, 64, MPENote::keyDown);
907 expectNote (test.getNote (3, 1), 100, 0, 8192, 64, MPENote::keyDown);
908 expectNote (test.getNote (3, 2), 100, 0, 8192, 64, MPENote::keyDown);
912 UnitTestInstrument test;
913 test.setZoneLayout (testLayout);
914 test.noteOn (3, 0, MPEValue::from7BitInt (100));
915 test.noteOn (3, 0, MPEValue::from7BitInt (60));
916 expectEquals (test.getNumPlayingNotes(), 1);
917 expectNote (test.getNote (3, 0), 60, 0, 8192, 64, MPENote::keyDown);
921 beginTest (
"noteReleased after setZoneLayout");
923 UnitTestInstrument test;
924 test.setZoneLayout (testLayout);
926 test.noteOn (3, 60, MPEValue::from7BitInt (100));
927 test.noteOn (3, 61, MPEValue::from7BitInt (100));
928 test.noteOn (4, 61, MPEValue::from7BitInt (100));
929 expectEquals (test.getNumPlayingNotes(), 3);
930 expectEquals (test.noteReleasedCallCounter, 0);
932 test.setZoneLayout (testLayout);
933 expectEquals (test.getNumPlayingNotes(), 0);
934 expectEquals (test.noteReleasedCallCounter, 3);
937 beginTest (
"releaseAllNotes");
939 UnitTestInstrument test;
940 test.setZoneLayout (testLayout);
941 test.noteOn (3, 60, MPEValue::from7BitInt (100));
942 test.noteOn (4, 61, MPEValue::from7BitInt (100));
943 test.noteOn (15, 62, MPEValue::from7BitInt (100));
944 expectEquals (test.getNumPlayingNotes(), 3);
946 test.releaseAllNotes();
947 expectEquals (test.getNumPlayingNotes(), 0);
950 beginTest (
"sustainPedal");
952 UnitTestInstrument test;
953 test.setZoneLayout (testLayout);
954 test.noteOn (3, 60, MPEValue::from7BitInt (100));
955 test.noteOn (10, 60, MPEValue::from7BitInt (100));
958 test.sustainPedal (3,
true);
959 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
961 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
962 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
963 expectEquals (test.noteKeyStateChangedCallCounter, 0);
966 test.sustainPedal (7,
true);
967 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
968 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
969 expectEquals (test.noteKeyStateChangedCallCounter, 0);
972 test.sustainPedal (1,
true);
973 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDownAndSustained);
974 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
975 expectEquals (test.noteKeyStateChangedCallCounter, 1);
978 test.sustainPedal (1,
false);
979 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
980 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
981 expectEquals (test.noteKeyStateChangedCallCounter, 2);
984 test.sustainPedal (1,
true);
985 expectEquals (test.noteKeyStateChangedCallCounter, 3);
986 test.noteOn (4, 51, MPEValue::from7BitInt (100));
987 expectNote (test.getNote (4, 51), 100, 0, 8192, 64, MPENote::keyDownAndSustained);
988 expectEquals (test.noteKeyStateChangedCallCounter, 3);
991 test.sustainPedal (11,
true);
992 test.noteOn (11, 52, MPEValue::from7BitInt (100));
993 expectNote (test.getNote (11, 52), 100, 0, 8192, 64, MPENote::keyDown);
994 test.noteOff (11, 52, MPEValue::from7BitInt (100));
995 expectEquals (test.noteReleasedCallCounter, 1);
998 test.noteOff (3, 60, MPEValue::from7BitInt (100));
999 test.noteOff (4, 51, MPEValue::from7BitInt (100));
1000 test.noteOff (10, 60, MPEValue::from7BitInt (100));
1001 expectEquals (test.getNumPlayingNotes(), 2);
1002 expectEquals (test.noteReleasedCallCounter, 2);
1003 expectEquals (test.noteKeyStateChangedCallCounter, 5);
1004 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::sustained);
1005 expectNote (test.getNote (4, 51), 100, 0, 8192, 64, MPENote::sustained);
1008 test.sustainPedal (1,
false);
1009 expectEquals (test.getNumPlayingNotes(), 0);
1010 expectEquals (test.noteReleasedCallCounter, 4);
1013 beginTest (
"sostenutoPedal");
1015 UnitTestInstrument test;
1016 test.setZoneLayout (testLayout);
1017 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1018 test.noteOn (10, 60, MPEValue::from7BitInt (100));
1021 test.sostenutoPedal (3,
true);
1022 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1023 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1024 expectEquals (test.noteKeyStateChangedCallCounter, 0);
1027 test.sostenutoPedal (9,
true);
1028 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1029 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1030 expectEquals (test.noteKeyStateChangedCallCounter, 0);
1033 test.sostenutoPedal (1,
true);
1034 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDownAndSustained);
1035 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1036 expectEquals (test.noteKeyStateChangedCallCounter, 1);
1039 test.sostenutoPedal (1,
false);
1040 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1041 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1042 expectEquals (test.noteKeyStateChangedCallCounter, 2);
1045 test.sostenutoPedal (1,
true);
1046 expectEquals (test.noteKeyStateChangedCallCounter, 3);
1047 test.noteOn (4, 51, MPEValue::from7BitInt (100));
1048 expectEquals (test.getNumPlayingNotes(), 3);
1049 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDownAndSustained);
1050 expectNote (test.getNote (4, 51), 100, 0, 8192, 64, MPENote::keyDown);
1051 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1052 expectEquals (test.noteKeyStateChangedCallCounter, 3);
1056 test.noteOff (3, 60, MPEValue::from7BitInt (100));
1057 test.noteOff (4, 51, MPEValue::from7BitInt (100));
1058 test.noteOff (10, 60, MPEValue::from7BitInt (100));
1059 expectEquals (test.getNumPlayingNotes(), 1);
1060 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::sustained);
1061 expectEquals (test.noteReleasedCallCounter, 2);
1062 expectEquals (test.noteKeyStateChangedCallCounter, 4);
1065 test.sustainPedal (1,
false);
1066 expectEquals (test.getNumPlayingNotes(), 0);
1067 expectEquals (test.noteReleasedCallCounter, 3);
1070 beginTest (
"getMostRecentNote");
1073 test.setZoneLayout (testLayout);
1075 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1076 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1079 auto note = test.getMostRecentNote (2);
1080 expect (! note.isValid());
1083 auto note = test.getMostRecentNote (3);
1084 expect (note.isValid());
1085 expectEquals (
int (note.midiChannel), 3);
1086 expectEquals (
int (note.initialNote), 61);
1089 test.sustainPedal (1,
true);
1090 test.noteOff (3, 61, MPEValue::from7BitInt (100));
1093 auto note = test.getMostRecentNote (3);
1094 expect (note.isValid());
1095 expectEquals (
int (note.midiChannel), 3);
1096 expectEquals (
int (note.initialNote), 60);
1099 test.sustainPedal (1,
false);
1100 test.noteOff (3, 60, MPEValue::from7BitInt (100));
1103 auto note = test.getMostRecentNote (3);
1104 expect (! note.isValid());
1108 beginTest (
"getMostRecentNoteOtherThan");
1110 MPENote testNote (3, 60,
1111 MPEValue::centreValue(), MPEValue::centreValue(),
1112 MPEValue::centreValue(), MPEValue::centreValue());
1118 test.setZoneLayout (testLayout);
1119 expect (! test.getMostRecentNoteOtherThan (testNote).isValid());
1121 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1122 expect (! test.getMostRecentNoteOtherThan (testNote).isValid());
1124 test.noteOn (4, 61, MPEValue::from7BitInt (100));
1125 expect (test.getMostRecentNoteOtherThan (testNote).isValid());
1126 expect (test.getMostRecentNoteOtherThan (testNote).midiChannel == 4);
1127 expect (test.getMostRecentNoteOtherThan (testNote).initialNote == 61);
1133 test.setZoneLayout (testLayout);
1134 expect (! test.getMostRecentNoteOtherThan (testNote).isValid());
1136 test.noteOn (4, 61, MPEValue::from7BitInt (100));
1137 expect (test.getMostRecentNoteOtherThan (testNote).isValid());
1138 expect (test.getMostRecentNoteOtherThan (testNote).midiChannel == 4);
1139 expect (test.getMostRecentNoteOtherThan (testNote).initialNote == 61);
1141 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1142 expect (test.getMostRecentNoteOtherThan (testNote).isValid());
1143 expect (test.getMostRecentNoteOtherThan (testNote).midiChannel == 4);
1144 expect (test.getMostRecentNoteOtherThan (testNote).initialNote == 61);
1148 beginTest (
"pressure");
1151 UnitTestInstrument test;
1152 test.setZoneLayout (testLayout);
1154 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1155 test.noteOn (4, 60, MPEValue::from7BitInt (100));
1156 test.noteOn (10, 60, MPEValue::from7BitInt (100));
1159 test.pressure (3, MPEValue::from7BitInt (33));
1160 expectNote (test.getNote (3, 60), 100, 33, 8192, 64, MPENote::keyDown);
1161 expectNote (test.getNote (4, 60), 100, 0, 8192, 64, MPENote::keyDown);
1162 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1163 expectEquals (test.notePressureChangedCallCounter, 1);
1166 test.pressure (1, MPEValue::from7BitInt (44));
1167 expectNote (test.getNote (3, 60), 100, 44, 8192, 64, MPENote::keyDown);
1168 expectNote (test.getNote (4, 60), 100, 44, 8192, 64, MPENote::keyDown);
1169 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1170 expectEquals (test.notePressureChangedCallCounter, 3);
1173 test.pressure (8, MPEValue::from7BitInt (55));
1174 expectNote (test.getNote (3, 60), 100, 44, 8192, 64, MPENote::keyDown);
1175 expectNote (test.getNote (4, 60), 100, 44, 8192, 64, MPENote::keyDown);
1176 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1177 expectEquals (test.notePressureChangedCallCounter, 3);
1180 UnitTestInstrument test;
1181 test.setZoneLayout (testLayout);
1184 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1185 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1186 test.pressure (3, MPEValue::from7BitInt (66));
1187 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1188 expectNote (test.getNote (3, 61), 100, 66, 8192, 64, MPENote::keyDown);
1189 expectEquals (test.notePressureChangedCallCounter, 1);
1192 UnitTestInstrument test;
1193 test.setZoneLayout (testLayout);
1197 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1198 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1199 test.noteOff (3, 61, MPEValue::from7BitInt (100));
1200 test.pressure (3, MPEValue::from7BitInt (77));
1201 expectEquals (test.getNumPlayingNotes(), 1);
1202 expectNote (test.getNote (3, 60), 100, 77, 8192, 64, MPENote::keyDown);
1203 expectEquals (test.notePressureChangedCallCounter, 1);
1206 UnitTestInstrument test;
1207 test.setZoneLayout (testLayout);
1210 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1211 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1214 UnitTestInstrument test;
1215 test.setZoneLayout (testLayout);
1218 test.pressure (3, MPEValue::from7BitInt (77));
1219 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1220 expectNote (test.getNote (3, 60), 100, 77, 8192, 64, MPENote::keyDown);
1223 UnitTestInstrument test;
1224 test.setZoneLayout (testLayout);
1228 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1229 test.pressure (3, MPEValue::from7BitInt (77));
1230 test.noteOff (3, 61, MPEValue::from7BitInt (100));
1231 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1232 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1235 UnitTestInstrument test;
1236 test.setZoneLayout (testLayout);
1240 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1241 test.pressure (3, MPEValue::from7BitInt (77));
1242 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1243 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1244 test.pressure (3, MPEValue::from7BitInt (78));
1245 expectNote (test.getNote (3, 60), 100, 78, 8192, 64, MPENote::keyDown);
1246 expectNote (test.getNote (3, 61), 100, 77, 8192, 64, MPENote::keyDown);
1250 UnitTestInstrument test;
1251 test.setZoneLayout (testLayout);
1254 test.noteOn (16, 60, MPEValue::from7BitInt (100));
1255 expectNote (test.getNote (16, 60), 100, 0, 8192, 64, MPENote::keyDown);
1256 test.aftertouch (16, 60, MPEValue::from7BitInt (27));
1257 expectNote (test.getNote (16, 60), 100, 27, 8192, 64, MPENote::keyDown);
1260 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1261 test.aftertouch (3, 60, MPEValue::from7BitInt (50));
1262 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1266 beginTest (
"pitchbend");
1269 UnitTestInstrument test;
1270 test.setZoneLayout (testLayout);
1272 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1273 test.noteOn (4, 60, MPEValue::from7BitInt (100));
1274 test.noteOn (10, 60, MPEValue::from7BitInt (100));
1277 test.pitchbend (3, MPEValue::from14BitInt (1111));
1278 expectNote (test.getNote (3, 60), 100, 0, 1111, 64, MPENote::keyDown);
1279 expectNote (test.getNote (4, 60), 100, 0, 8192, 64, MPENote::keyDown);
1280 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1281 expectEquals (test.notePitchbendChangedCallCounter, 1);
1287 test.pitchbend (1, MPEValue::from14BitInt (2222));
1288 expectNote (test.getNote (3, 60), 100, 0, 1111, 64, MPENote::keyDown);
1289 expectNote (test.getNote (4, 60), 100, 0, 8192, 64, MPENote::keyDown);
1290 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1291 expectEquals (test.notePitchbendChangedCallCounter, 3);
1294 test.pitchbend (8, MPEValue::from14BitInt (3333));
1295 expectNote (test.getNote (3, 60), 100, 0, 1111, 64, MPENote::keyDown);
1296 expectNote (test.getNote (4, 60), 100, 0, 8192, 64, MPENote::keyDown);
1297 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1298 expectEquals (test.notePitchbendChangedCallCounter, 3);
1301 UnitTestInstrument test;
1302 test.setZoneLayout (testLayout);
1305 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1306 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1307 test.pitchbend (3, MPEValue::from14BitInt (4444));
1308 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1309 expectNote (test.getNote (3, 61), 100, 0, 4444, 64, MPENote::keyDown);
1310 expectEquals (test.notePitchbendChangedCallCounter, 1);
1313 UnitTestInstrument test;
1314 test.setZoneLayout (testLayout);
1318 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1319 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1320 test.noteOff (3, 61, MPEValue::from7BitInt (100));
1321 test.pitchbend (3, MPEValue::from14BitInt (5555));
1322 expectEquals (test.getNumPlayingNotes(), 1);
1323 expectNote (test.getNote (3, 60), 100, 0, 5555, 64, MPENote::keyDown);
1324 expectEquals (test.notePitchbendChangedCallCounter, 1);
1327 UnitTestInstrument test;
1328 test.setZoneLayout (testLayout);
1338 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1339 test.sustainPedal (1,
true);
1340 test.noteOff (3, 60, MPEValue::from7BitInt (64));
1341 expectEquals (test.getNumPlayingNotes(), 1);
1342 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::sustained);
1343 expectEquals (test.noteKeyStateChangedCallCounter, 2);
1345 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1346 test.pitchbend (3, MPEValue::from14BitInt (6666));
1347 expectEquals (test.getNumPlayingNotes(), 2);
1348 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::sustained);
1349 expectNote (test.getNote (3, 61), 100, 0, 6666, 64, MPENote::keyDownAndSustained);
1350 expectEquals (test.notePitchbendChangedCallCounter, 1);
1353 UnitTestInstrument test;
1354 test.setZoneLayout (testLayout);
1364 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1365 test.pitchbend (3, MPEValue::from14BitInt (5555));
1366 expectNote (test.getNote (3, 60), 100, 0, 5555, 64, MPENote::keyDown);
1368 test.noteOff (3, 60, MPEValue::from7BitInt (100));
1369 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1370 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1375 UnitTestInstrument test;
1377 MPEZoneLayout layout = testLayout;
1378 test.setZoneLayout (layout);
1379 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1380 test.pitchbend (3, MPEValue::from14BitInt (4096));
1381 expectDoubleWithinRelativeError (test.getMostRecentNote (3).totalPitchbendInSemitones, -24.0, 0.01);
1383 layout.setLowerZone (5, 96);
1384 test.setZoneLayout (layout);
1385 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1386 test.pitchbend (3, MPEValue::from14BitInt (0));
1387 expectDoubleWithinRelativeError (test.getMostRecentNote (3).totalPitchbendInSemitones, -96.0, 0.01);
1389 layout.setLowerZone (5, 1);
1390 test.setZoneLayout (layout);
1391 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1392 test.pitchbend (3, MPEValue::from14BitInt (16383));
1393 expectDoubleWithinRelativeError (test.getMostRecentNote (3).totalPitchbendInSemitones, 1.0, 0.01);
1395 layout.setLowerZone (5, 0);
1396 test.setZoneLayout (layout);
1397 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1398 test.pitchbend (3, MPEValue::from14BitInt (12345));
1399 expectDoubleWithinRelativeError (test.getMostRecentNote (3).totalPitchbendInSemitones, 0.0, 0.01);
1404 UnitTestInstrument test;
1406 MPEZoneLayout layout = testLayout;
1407 test.setZoneLayout (layout);
1408 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1409 test.pitchbend (1, MPEValue::from14BitInt (4096));
1410 expectDoubleWithinRelativeError (test.getMostRecentNote (3).totalPitchbendInSemitones, -1.0, 0.01);
1412 layout.setLowerZone (5, 48, 96);
1413 test.setZoneLayout (layout);
1414 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1415 test.pitchbend (1, MPEValue::from14BitInt (0));
1416 expectDoubleWithinRelativeError (test.getMostRecentNote (3).totalPitchbendInSemitones, -96.0, 0.01);
1418 layout.setLowerZone (5, 48, 1);
1419 test.setZoneLayout (layout);
1420 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1421 test.pitchbend (1, MPEValue::from14BitInt (16383));
1422 expectDoubleWithinRelativeError (test.getMostRecentNote (3).totalPitchbendInSemitones, 1.0, 0.01);
1424 layout.setLowerZone (5, 48, 0);
1425 test.setZoneLayout (layout);
1426 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1427 test.pitchbend (1, MPEValue::from14BitInt (12345));
1428 expectDoubleWithinRelativeError (test.getMostRecentNote (3).totalPitchbendInSemitones, 0.0, 0.01);
1434 UnitTestInstrument test;
1436 MPEZoneLayout layout = testLayout;
1437 layout.setLowerZone (5, 12, 1);
1438 test.setZoneLayout (layout);
1440 test.pitchbend (1, MPEValue::from14BitInt (4096));
1441 test.pitchbend (3, MPEValue::from14BitInt (0));
1444 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1445 expectDoubleWithinRelativeError (test.getMostRecentNote (3).totalPitchbendInSemitones, -12.5, 0.01);
1449 beginTest (
"timbre");
1452 UnitTestInstrument test;
1453 test.setZoneLayout (testLayout);
1455 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1456 test.noteOn (4, 60, MPEValue::from7BitInt (100));
1457 test.noteOn (10, 60, MPEValue::from7BitInt (100));
1460 test.timbre (3, MPEValue::from7BitInt (33));
1461 expectNote (test.getNote (3, 60), 100, 0, 8192, 33, MPENote::keyDown);
1462 expectNote (test.getNote (4, 60), 100, 0, 8192, 64, MPENote::keyDown);
1463 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1464 expectEquals (test.noteTimbreChangedCallCounter, 1);
1467 test.timbre (1, MPEValue::from7BitInt (44));
1468 expectNote (test.getNote (3, 60), 100, 0, 8192, 44, MPENote::keyDown);
1469 expectNote (test.getNote (4, 60), 100, 0, 8192, 44, MPENote::keyDown);
1470 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1471 expectEquals (test.noteTimbreChangedCallCounter, 3);
1474 test.timbre (9, MPEValue::from7BitInt (55));
1475 expectNote (test.getNote (3, 60), 100, 0, 8192, 44, MPENote::keyDown);
1476 expectNote (test.getNote (4, 60), 100, 0, 8192, 44, MPENote::keyDown);
1477 expectNote (test.getNote (10, 60), 100, 0, 8192, 64, MPENote::keyDown);
1478 expectEquals (test.noteTimbreChangedCallCounter, 3);
1481 UnitTestInstrument test;
1482 test.setZoneLayout (testLayout);
1485 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1486 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1487 test.timbre (3, MPEValue::from7BitInt (66));
1488 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1489 expectNote (test.getNote (3, 61), 100, 0, 8192, 66, MPENote::keyDown);
1490 expectEquals (test.noteTimbreChangedCallCounter, 1);
1493 UnitTestInstrument test;
1494 test.setZoneLayout (testLayout);
1498 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1499 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1500 test.noteOff (3, 61, MPEValue::from7BitInt (100));
1501 test.timbre (3, MPEValue::from7BitInt (77));
1502 expectEquals (test.getNumPlayingNotes(), 1);
1503 expectNote (test.getNote (3, 60), 100, 0, 8192, 77, MPENote::keyDown);
1504 expectEquals (test.noteTimbreChangedCallCounter, 1);
1507 UnitTestInstrument test;
1508 test.setZoneLayout (testLayout);
1511 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1512 test.timbre (3, MPEValue::from7BitInt (42));
1513 expectNote (test.getNote (3, 60), 100, 0, 8192, 42, MPENote::keyDown);
1515 test.noteOff (3, 60, MPEValue::from7BitInt (100));
1516 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1517 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1521 beginTest (
"setPressureTrackingMode");
1525 UnitTestInstrument test;
1526 test.setZoneLayout (testLayout);
1528 test.setPressureTrackingMode (MPEInstrument::lastNotePlayedOnChannel);
1529 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1530 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1531 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1532 test.pressure (3, MPEValue::from7BitInt (99));
1533 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1534 expectNote (test.getNote (3, 62), 100, 0, 8192, 64, MPENote::keyDown);
1535 expectNote (test.getNote (3, 61), 100, 99, 8192, 64, MPENote::keyDown);
1536 expectEquals (test.notePressureChangedCallCounter, 1);
1540 UnitTestInstrument test;
1541 test.setZoneLayout (testLayout);
1543 test.setPressureTrackingMode (MPEInstrument::lowestNoteOnChannel);
1544 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1545 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1546 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1547 test.pressure (3, MPEValue::from7BitInt (99));
1548 expectNote (test.getNote (3, 60), 100, 99, 8192, 64, MPENote::keyDown);
1549 expectNote (test.getNote (3, 62), 100, 0, 8192, 64, MPENote::keyDown);
1550 expectNote (test.getNote (3, 61), 100, 0, 8192, 64, MPENote::keyDown);
1551 expectEquals (test.notePressureChangedCallCounter, 1);
1555 UnitTestInstrument test;
1556 test.setZoneLayout (testLayout);
1558 test.setPressureTrackingMode (MPEInstrument::highestNoteOnChannel);
1559 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1560 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1561 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1562 test.pressure (3, MPEValue::from7BitInt (99));
1563 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1564 expectNote (test.getNote (3, 62), 100, 99, 8192, 64, MPENote::keyDown);
1565 expectNote (test.getNote (3, 61), 100, 0, 8192, 64, MPENote::keyDown);
1566 expectEquals (test.notePressureChangedCallCounter, 1);
1570 UnitTestInstrument test;
1571 test.setZoneLayout (testLayout);
1573 test.setPressureTrackingMode (MPEInstrument::allNotesOnChannel);
1574 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1575 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1576 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1577 test.pressure (3, MPEValue::from7BitInt (99));
1578 expectNote (test.getNote (3, 60), 100, 99, 8192, 64, MPENote::keyDown);
1579 expectNote (test.getNote (3, 62), 100, 99, 8192, 64, MPENote::keyDown);
1580 expectNote (test.getNote (3, 61), 100, 99, 8192, 64, MPENote::keyDown);
1581 expectEquals (test.notePressureChangedCallCounter, 3);
1585 beginTest (
"setPitchbendTrackingMode");
1589 UnitTestInstrument test;
1590 test.setZoneLayout (testLayout);
1592 test.setPitchbendTrackingMode (MPEInstrument::lastNotePlayedOnChannel);
1593 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1594 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1595 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1596 test.pitchbend (3, MPEValue::from14BitInt (9999));
1597 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1598 expectNote (test.getNote (3, 62), 100, 0, 8192, 64, MPENote::keyDown);
1599 expectNote (test.getNote (3, 61), 100, 0, 9999, 64, MPENote::keyDown);
1600 expectEquals (test.notePitchbendChangedCallCounter, 1);
1604 UnitTestInstrument test;
1605 test.setZoneLayout (testLayout);
1607 test.setPitchbendTrackingMode (MPEInstrument::lowestNoteOnChannel);
1608 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1609 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1610 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1611 test.pitchbend (3, MPEValue::from14BitInt (9999));
1612 expectNote (test.getNote (3, 60), 100, 0, 9999, 64, MPENote::keyDown);
1613 expectNote (test.getNote (3, 62), 100, 0, 8192, 64, MPENote::keyDown);
1614 expectNote (test.getNote (3, 61), 100, 0, 8192, 64, MPENote::keyDown);
1615 expectEquals (test.notePitchbendChangedCallCounter, 1);
1619 UnitTestInstrument test;
1620 test.setZoneLayout (testLayout);
1622 test.setPitchbendTrackingMode (MPEInstrument::highestNoteOnChannel);
1623 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1624 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1625 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1626 test.pitchbend (3, MPEValue::from14BitInt (9999));
1627 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1628 expectNote (test.getNote (3, 62), 100, 0, 9999, 64, MPENote::keyDown);
1629 expectNote (test.getNote (3, 61), 100, 0, 8192, 64, MPENote::keyDown);
1630 expectEquals (test.notePitchbendChangedCallCounter, 1);
1634 UnitTestInstrument test;
1635 test.setZoneLayout (testLayout);
1637 test.setPitchbendTrackingMode (MPEInstrument::allNotesOnChannel);
1638 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1639 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1640 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1641 test.pitchbend (3, MPEValue::from14BitInt (9999));
1642 expectNote (test.getNote (3, 60), 100, 0, 9999, 64, MPENote::keyDown);
1643 expectNote (test.getNote (3, 62), 100, 0, 9999, 64, MPENote::keyDown);
1644 expectNote (test.getNote (3, 61), 100, 0, 9999, 64, MPENote::keyDown);
1645 expectEquals (test.notePitchbendChangedCallCounter, 3);
1649 beginTest (
"setTimbreTrackingMode");
1653 UnitTestInstrument test;
1654 test.setZoneLayout (testLayout);
1656 test.setTimbreTrackingMode (MPEInstrument::lastNotePlayedOnChannel);
1657 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1658 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1659 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1660 test.timbre (3, MPEValue::from7BitInt (99));
1661 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1662 expectNote (test.getNote (3, 62), 100, 0, 8192, 64, MPENote::keyDown);
1663 expectNote (test.getNote (3, 61), 100, 0, 8192, 99, MPENote::keyDown);
1664 expectEquals (test.noteTimbreChangedCallCounter, 1);
1668 UnitTestInstrument test;
1669 test.setZoneLayout (testLayout);
1671 test.setTimbreTrackingMode (MPEInstrument::lowestNoteOnChannel);
1672 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1673 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1674 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1675 test.timbre (3, MPEValue::from7BitInt (99));
1676 expectNote (test.getNote (3, 60), 100, 0, 8192, 99, MPENote::keyDown);
1677 expectNote (test.getNote (3, 62), 100, 0, 8192, 64, MPENote::keyDown);
1678 expectNote (test.getNote (3, 61), 100, 0, 8192, 64, MPENote::keyDown);
1679 expectEquals (test.noteTimbreChangedCallCounter, 1);
1683 UnitTestInstrument test;
1684 test.setZoneLayout (testLayout);
1686 test.setTimbreTrackingMode (MPEInstrument::highestNoteOnChannel);
1687 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1688 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1689 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1690 test.timbre (3, MPEValue::from7BitInt (99));
1691 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
1692 expectNote (test.getNote (3, 62), 100, 0, 8192, 99, MPENote::keyDown);
1693 expectNote (test.getNote (3, 61), 100, 0, 8192, 64, MPENote::keyDown);
1694 expectEquals (test.noteTimbreChangedCallCounter, 1);
1698 UnitTestInstrument test;
1699 test.setZoneLayout (testLayout);
1701 test.setTimbreTrackingMode (MPEInstrument::allNotesOnChannel);
1702 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1703 test.noteOn (3, 62, MPEValue::from7BitInt (100));
1704 test.noteOn (3, 61, MPEValue::from7BitInt (100));
1705 test.timbre (3, MPEValue::from7BitInt (99));
1706 expectNote (test.getNote (3, 60), 100, 0, 8192, 99, MPENote::keyDown);
1707 expectNote (test.getNote (3, 62), 100, 0, 8192, 99, MPENote::keyDown);
1708 expectNote (test.getNote (3, 61), 100, 0, 8192, 99, MPENote::keyDown);
1709 expectEquals (test.noteTimbreChangedCallCounter, 3);
1713 beginTest (
"processNextMidiEvent");
1715 UnitTestInstrument test;
1719 test.processNextMidiEvent (MidiMessage::noteOn (3, 42, uint8 (92)));
1720 expectEquals (test.noteOnCallCounter, 1);
1721 expectEquals (test.lastMidiChannelReceived, 3);
1722 expectEquals (test.lastMidiNoteNumberReceived, 42);
1723 expectEquals (test.lastMPEValueReceived.as7BitInt(), 92);
1727 test.processNextMidiEvent (MidiMessage::noteOff (4, 12, uint8 (33)));
1728 expectEquals (test.noteOffCallCounter, 1);
1729 expectEquals (test.lastMidiChannelReceived, 4);
1730 expectEquals (test.lastMidiNoteNumberReceived, 12);
1731 expectEquals (test.lastMPEValueReceived.as7BitInt(), 33);
1736 test.processNextMidiEvent (MidiMessage::noteOn (5, 11, uint8 (0)));
1737 expectEquals (test.noteOffCallCounter, 2);
1738 expectEquals (test.lastMidiChannelReceived, 5);
1739 expectEquals (test.lastMidiNoteNumberReceived, 11);
1740 expectEquals (test.lastMPEValueReceived.as7BitInt(), 64);
1744 test.processNextMidiEvent (MidiMessage::pitchWheel (1, 3333));
1745 expectEquals (test.pitchbendCallCounter, 1);
1746 expectEquals (test.lastMidiChannelReceived, 1);
1747 expectEquals (test.lastMPEValueReceived.as14BitInt(), 3333);
1752 test.processNextMidiEvent (MidiMessage::channelPressureChange (10, 35));
1753 expectEquals (test.pressureCallCounter, 1);
1754 expectEquals (test.lastMidiChannelReceived, 10);
1755 expectEquals (test.lastMPEValueReceived.as7BitInt(), 35);
1761 test.processNextMidiEvent (MidiMessage::controllerEvent (3, 70, 120));
1762 expectEquals (test.pressureCallCounter, 2);
1763 expectEquals (test.lastMidiChannelReceived, 3);
1764 expectEquals (test.lastMPEValueReceived.as7BitInt(), 120);
1767 test.processNextMidiEvent (MidiMessage::controllerEvent (4, 102, 121));
1768 expectEquals (test.pressureCallCounter, 2);
1769 test.processNextMidiEvent (MidiMessage::controllerEvent (5, 102, 122));
1770 expectEquals (test.pressureCallCounter, 2);
1771 test.processNextMidiEvent (MidiMessage::controllerEvent (4, 70, 123));
1772 expectEquals (test.pressureCallCounter, 3);
1773 expectEquals (test.lastMidiChannelReceived, 4);
1774 expectEquals (test.lastMPEValueReceived.as14BitInt(), 121 + (123 << 7));
1775 test.processNextMidiEvent (MidiMessage::controllerEvent (5, 70, 124));
1776 expectEquals (test.pressureCallCounter, 4);
1777 expectEquals (test.lastMidiChannelReceived, 5);
1778 expectEquals (test.lastMPEValueReceived.as14BitInt(), 122 + (124 << 7));
1779 test.processNextMidiEvent (MidiMessage::controllerEvent (5, 70, 64));
1780 expectEquals (test.pressureCallCounter, 5);
1781 expectEquals (test.lastMidiChannelReceived, 5);
1782 expectEquals (test.lastMPEValueReceived.as7BitInt(), 64);
1785 test.processNextMidiEvent (MidiMessage::controllerEvent (3, 74, 120));
1786 expectEquals (test.timbreCallCounter, 1);
1787 expectEquals (test.lastMidiChannelReceived, 3);
1788 expectEquals (test.lastMPEValueReceived.as7BitInt(), 120);
1789 test.processNextMidiEvent (MidiMessage::controllerEvent (4, 106, 121));
1790 expectEquals (test.timbreCallCounter, 1);
1791 test.processNextMidiEvent (MidiMessage::controllerEvent (5, 106, 122));
1792 expectEquals (test.timbreCallCounter, 1);
1793 test.processNextMidiEvent (MidiMessage::controllerEvent (4, 74, 123));
1794 expectEquals (test.timbreCallCounter, 2);
1795 expectEquals (test.lastMidiChannelReceived, 4);
1796 expectEquals (test.lastMPEValueReceived.as14BitInt(), 121 + (123 << 7));
1797 test.processNextMidiEvent (MidiMessage::controllerEvent (5, 74, 124));
1798 expectEquals (test.timbreCallCounter, 3);
1799 expectEquals (test.lastMidiChannelReceived, 5);
1800 expectEquals (test.lastMPEValueReceived.as14BitInt(), 122 + (124 << 7));
1801 test.processNextMidiEvent (MidiMessage::controllerEvent (5, 74, 64));
1802 expectEquals (test.timbreCallCounter, 4);
1803 expectEquals (test.lastMidiChannelReceived, 5);
1804 expectEquals (test.lastMPEValueReceived.as7BitInt(), 64);
1807 test.processNextMidiEvent (MidiMessage::controllerEvent (1, 64, 127));
1808 expectEquals (test.sustainPedalCallCounter, 1);
1809 expectEquals (test.lastMidiChannelReceived, 1);
1810 expect (test.lastSustainPedalValueReceived);
1811 test.processNextMidiEvent (MidiMessage::controllerEvent (16, 64, 0));
1812 expectEquals (test.sustainPedalCallCounter, 2);
1813 expectEquals (test.lastMidiChannelReceived, 16);
1814 expect (! test.lastSustainPedalValueReceived);
1817 test.processNextMidiEvent (MidiMessage::controllerEvent (1, 66, 127));
1818 expectEquals (test.sostenutoPedalCallCounter, 1);
1819 expectEquals (test.lastMidiChannelReceived, 1);
1820 expect (test.lastSostenutoPedalValueReceived);
1821 test.processNextMidiEvent (MidiMessage::controllerEvent (16, 66, 0));
1822 expectEquals (test.sostenutoPedalCallCounter, 2);
1823 expectEquals (test.lastMidiChannelReceived, 16);
1824 expect (! test.lastSostenutoPedalValueReceived);
1834 buffer.addEvents (MPEMessages::setLowerZone (5), 0, -1, 0);
1835 buffer.addEvents (MPEMessages::setUpperZone (6), 0, -1, 0);
1837 MidiBuffer::Iterator iter (buffer);
1838 MidiMessage message;
1841 while (iter.getNextEvent (message, samplePosition))
1842 test.processNextMidiEvent (message);
1844 expect (test.getZoneLayout().getLowerZone().isActive());
1845 expect (test.getZoneLayout().getUpperZone().isActive());
1846 expectEquals (test.getZoneLayout().getLowerZone().getMasterChannel(), 1);
1847 expectEquals (test.getZoneLayout().getLowerZone().numMemberChannels, 5);
1848 expectEquals (test.getZoneLayout().getUpperZone().getMasterChannel(), 16);
1849 expectEquals (test.getZoneLayout().getUpperZone().numMemberChannels, 6);
1852 beginTest (
"MIDI all notes off");
1854 UnitTestInstrument test;
1855 test.setZoneLayout (testLayout);
1856 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1857 test.noteOn (4, 61, MPEValue::from7BitInt (100));
1858 test.noteOn (15, 62, MPEValue::from7BitInt (100));
1859 test.noteOn (15, 63, MPEValue::from7BitInt (100));
1860 expectEquals (test.getNumPlayingNotes(), 4);
1863 test.processNextMidiEvent (MidiMessage::allControllersOff (3));
1864 expectEquals (test.getNumPlayingNotes(), 4);
1867 test.processNextMidiEvent (MidiMessage::allControllersOff (9));
1868 expectEquals (test.getNumPlayingNotes(), 4);
1871 test.processNextMidiEvent (MidiMessage::allControllersOff (1));
1872 expectEquals (test.getNumPlayingNotes(), 2);
1873 test.processNextMidiEvent (MidiMessage::allControllersOff (16));
1874 expectEquals (test.getNumPlayingNotes(), 0);
1877 beginTest (
"MIDI all notes off (legacy mode)");
1879 UnitTestInstrument test;
1880 test.enableLegacyMode();
1881 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1882 test.noteOn (4, 61, MPEValue::from7BitInt (100));
1883 test.noteOn (15, 62, MPEValue::from7BitInt (100));
1884 test.noteOn (15, 63, MPEValue::from7BitInt (100));
1885 expectEquals (test.getNumPlayingNotes(), 4);
1887 test.processNextMidiEvent (MidiMessage::allControllersOff (3));
1888 expectEquals (test.getNumPlayingNotes(), 3);
1890 test.processNextMidiEvent (MidiMessage::allControllersOff (15));
1891 expectEquals (test.getNumPlayingNotes(), 1);
1893 test.processNextMidiEvent (MidiMessage::allControllersOff (4));
1894 expectEquals (test.getNumPlayingNotes(), 0);
1897 beginTest (
"default initial values for pitchbend and timbre");
1900 test.setZoneLayout (testLayout);
1902 test.pitchbend (3, MPEValue::from14BitInt (3333));
1903 test.pitchbend (2, MPEValue::from14BitInt (4444));
1904 test.pitchbend (2, MPEValue::from14BitInt (5555));
1906 test.timbre (3, MPEValue::from7BitInt (66));
1907 test.timbre (2, MPEValue::from7BitInt (77));
1908 test.timbre (2, MPEValue::from7BitInt (88));
1910 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1912 expectNote (test.getMostRecentNote (3), 100, 0, 3333, 66, MPENote::keyDown);
1915 beginTest (
"Legacy mode");
1920 expect (! test.isLegacyModeEnabled());
1922 test.setZoneLayout (testLayout);
1923 expect (! test.isLegacyModeEnabled());
1925 test.enableLegacyMode();
1926 expect (test.isLegacyModeEnabled());
1928 test.setZoneLayout (testLayout);
1929 expect (! test.isLegacyModeEnabled());
1934 test.enableLegacyMode (0, Range<int> (1, 11));
1935 expectEquals (test.getLegacyModePitchbendRange(), 0);
1936 expect (test.getLegacyModeChannelRange() == Range<int> (1, 11));
1941 test.enableLegacyMode();
1943 expectEquals (test.getLegacyModePitchbendRange(), 2);
1944 expect (test.getLegacyModeChannelRange() == Range<int> (1, 17));
1946 test.setLegacyModePitchbendRange (96);
1947 expectEquals (test.getLegacyModePitchbendRange(), 96);
1949 test.setLegacyModeChannelRange (Range<int> (10, 12));
1950 expect (test.getLegacyModeChannelRange() == Range<int> (10, 12));
1955 UnitTestInstrument test;
1956 test.enableLegacyMode();
1958 test.noteOn (1, 60, MPEValue::from7BitInt (100));
1959 test.noteOn (2, 60, MPEValue::from7BitInt (100));
1960 test.noteOn (15, 60, MPEValue::from7BitInt (100));
1961 test.noteOn (16, 60, MPEValue::from7BitInt (100));
1962 expectEquals (test.getNumPlayingNotes(), 4);
1966 test.pitchbend (1, MPEValue::from14BitInt (9999));
1967 test.pressure (2, MPEValue::from7BitInt (88));
1968 test.timbre (15, MPEValue::from7BitInt (77));
1970 expectNote (test.getNote (1, 60), 100, 0, 9999, 64, MPENote::keyDown);
1971 expectNote (test.getNote (2, 60), 100, 88, 8192, 64, MPENote::keyDown);
1972 expectNote (test.getNote (15, 60), 100, 0, 8192, 77, MPENote::keyDown);
1973 expectNote (test.getNote (16, 60), 100, 0, 8192, 64, MPENote::keyDown);
1977 test.noteOff (15, 60, MPEValue::from7BitInt (0));
1978 test.noteOff (1, 60, MPEValue::from7BitInt (0));
1979 test.noteOff (2, 60, MPEValue::from7BitInt (0));
1980 test.noteOff (16, 60, MPEValue::from7BitInt (0));
1981 expectEquals (test.getNumPlayingNotes(), 0);
1986 UnitTestInstrument test;
1987 test.enableLegacyMode (2, Range<int> (3, 8));
1989 test.noteOn (1, 60, MPEValue::from7BitInt (100));
1990 test.noteOn (2, 60, MPEValue::from7BitInt (100));
1991 test.noteOn (3, 60, MPEValue::from7BitInt (100));
1992 test.noteOn (4, 60, MPEValue::from7BitInt (100));
1993 test.noteOn (6, 60, MPEValue::from7BitInt (100));
1994 test.noteOn (7, 60, MPEValue::from7BitInt (100));
1995 test.noteOn (8, 60, MPEValue::from7BitInt (100));
1996 test.noteOn (16, 60, MPEValue::from7BitInt (100));
1998 expectEquals (test.getNumPlayingNotes(), 4);
1999 expectNote (test.getNote (3, 60), 100, 0, 8192, 64, MPENote::keyDown);
2000 expectNote (test.getNote (4, 60), 100, 0, 8192, 64, MPENote::keyDown);
2001 expectNote (test.getNote (6, 60), 100, 0, 8192, 64, MPENote::keyDown);
2002 expectNote (test.getNote (7, 60), 100, 0, 8192, 64, MPENote::keyDown);
2007 UnitTestInstrument test;
2008 test.enableLegacyMode();
2010 test.setPitchbendTrackingMode (MPEInstrument::lastNotePlayedOnChannel);
2011 test.noteOn (1, 60, MPEValue::from7BitInt (100));
2012 test.noteOn (1, 62, MPEValue::from7BitInt (100));
2013 test.noteOn (1, 61, MPEValue::from7BitInt (100));
2014 test.pitchbend (1, MPEValue::from14BitInt (9999));
2015 expectNote (test.getNote (1, 60), 100, 0, 8192, 64, MPENote::keyDown);
2016 expectNote (test.getNote (1, 61), 100, 0, 9999, 64, MPENote::keyDown);
2017 expectNote (test.getNote (1, 62), 100, 0, 8192, 64, MPENote::keyDown);
2020 UnitTestInstrument test;
2021 test.enableLegacyMode();
2023 test.setPitchbendTrackingMode (MPEInstrument::lowestNoteOnChannel);
2024 test.noteOn (1, 60, MPEValue::from7BitInt (100));
2025 test.noteOn (1, 62, MPEValue::from7BitInt (100));
2026 test.noteOn (1, 61, MPEValue::from7BitInt (100));
2027 test.pitchbend (1, MPEValue::from14BitInt (9999));
2028 expectNote (test.getNote (1, 60), 100, 0, 9999, 64, MPENote::keyDown);
2029 expectNote (test.getNote (1, 61), 100, 0, 8192, 64, MPENote::keyDown);
2030 expectNote (test.getNote (1, 62), 100, 0, 8192, 64, MPENote::keyDown);
2033 UnitTestInstrument test;
2034 test.enableLegacyMode();
2036 test.setPitchbendTrackingMode (MPEInstrument::highestNoteOnChannel);
2037 test.noteOn (1, 60, MPEValue::from7BitInt (100));
2038 test.noteOn (1, 62, MPEValue::from7BitInt (100));
2039 test.noteOn (1, 61, MPEValue::from7BitInt (100));
2040 test.pitchbend (1, MPEValue::from14BitInt (9999));
2041 expectNote (test.getNote (1, 60), 100, 0, 8192, 64, MPENote::keyDown);
2042 expectNote (test.getNote (1, 61), 100, 0, 8192, 64, MPENote::keyDown);
2043 expectNote (test.getNote (1, 62), 100, 0, 9999, 64, MPENote::keyDown);
2046 UnitTestInstrument test;
2047 test.enableLegacyMode();
2049 test.setPitchbendTrackingMode (MPEInstrument::allNotesOnChannel);
2050 test.noteOn (1, 60, MPEValue::from7BitInt (100));
2051 test.noteOn (1, 62, MPEValue::from7BitInt (100));
2052 test.noteOn (1, 61, MPEValue::from7BitInt (100));
2053 test.pitchbend (1, MPEValue::from14BitInt (9999));
2054 expectNote (test.getNote (1, 60), 100, 0, 9999, 64, MPENote::keyDown);
2055 expectNote (test.getNote (1, 61), 100, 0, 9999, 64, MPENote::keyDown);
2056 expectNote (test.getNote (1, 62), 100, 0, 9999, 64, MPENote::keyDown);
2061 UnitTestInstrument test;
2062 test.enableLegacyMode (11);
2064 test.pitchbend (1, MPEValue::from14BitInt (4096));
2065 test.noteOn (1, 60, MPEValue::from7BitInt (100));
2066 expectDoubleWithinRelativeError (test.getMostRecentNote (1).totalPitchbendInSemitones, -5.5, 0.01);
2070 UnitTestInstrument test;
2071 test.enableLegacyMode();
2073 test.sustainPedal (1,
true);
2074 test.noteOn (2, 61, MPEValue::from7BitInt (100));
2075 test.noteOff (2, 61, MPEValue::from7BitInt (100));
2076 test.noteOn (1, 60, MPEValue::from7BitInt (100));
2077 test.noteOff (1, 60, MPEValue::from7BitInt (100));
2079 expectEquals (test.getNumPlayingNotes(), 1);
2080 expectNote (test.getNote (1, 60), 100, 0, 8192, 64, MPENote::sustained);
2082 test.sustainPedal (1,
false);
2083 expectEquals (test.getNumPlayingNotes(), 0);
2085 test.noteOn (2, 61, MPEValue::from7BitInt (100));
2086 test.sustainPedal (1,
true);
2087 test.noteOff (2, 61, MPEValue::from7BitInt (100));
2088 expectEquals (test.getNumPlayingNotes(), 0);
2093 UnitTestInstrument test;
2094 test.enableLegacyMode();
2096 test.noteOn (1, 60, MPEValue::from7BitInt (100));
2097 test.sostenutoPedal (1,
true);
2098 test.noteOff (1, 60, MPEValue::from7BitInt (100));
2099 test.noteOn (2, 61, MPEValue::from7BitInt (100));
2100 test.noteOff (2, 61, MPEValue::from7BitInt (100));
2102 expectEquals (test.getNumPlayingNotes(), 1);
2103 expectNote (test.getNote (1, 60), 100, 0, 8192, 64, MPENote::sustained);
2105 test.sostenutoPedal (1,
false);
2106 expectEquals (test.getNumPlayingNotes(), 0);
2108 test.noteOn (2, 61, MPEValue::from7BitInt (100));
2109 test.sostenutoPedal (1,
true);
2110 test.noteOff (2, 61, MPEValue::from7BitInt (100));
2111 expectEquals (test.getNumPlayingNotes(), 0);
2115 UnitTestInstrument test;
2116 test.setZoneLayout (testLayout);
2117 test.noteOn (3, 60, MPEValue::from7BitInt (100));
2118 expectEquals (test.getNumPlayingNotes(), 1);
2120 test.enableLegacyMode();
2121 expectEquals (test.getNumPlayingNotes(), 0);
2122 test.noteOn (3, 60, MPEValue::from7BitInt (100));
2123 expectEquals (test.getNumPlayingNotes(), 1);
2125 test.setZoneLayout (testLayout);
2126 expectEquals (test.getNumPlayingNotes(), 0);
2136 class UnitTestInstrument :
public MPEInstrument,
2137 private MPEInstrument::Listener
2139 using Base = MPEInstrument;
2142 UnitTestInstrument()
2143 : noteOnCallCounter (0), noteOffCallCounter (0), pitchbendCallCounter (0),
2144 pressureCallCounter (0), timbreCallCounter (0), sustainPedalCallCounter (0),
2145 sostenutoPedalCallCounter (0), noteAddedCallCounter (0), notePressureChangedCallCounter (0),
2146 notePitchbendChangedCallCounter (0), noteTimbreChangedCallCounter (0),
2147 noteKeyStateChangedCallCounter (0), noteReleasedCallCounter (0),
2148 lastMidiChannelReceived (-1), lastMidiNoteNumberReceived (-1),
2149 lastSustainPedalValueReceived (false), lastSostenutoPedalValueReceived (false)
2154 void noteOn (
int midiChannel,
int midiNoteNumber, MPEValue midiNoteOnVelocity)
override
2156 Base::noteOn (midiChannel, midiNoteNumber, midiNoteOnVelocity);
2158 noteOnCallCounter++;
2159 lastMidiChannelReceived = midiChannel;
2160 lastMidiNoteNumberReceived = midiNoteNumber;
2161 lastMPEValueReceived = midiNoteOnVelocity;
2164 void noteOff (
int midiChannel,
int midiNoteNumber, MPEValue midiNoteOffVelocity)
override
2166 Base::noteOff (midiChannel, midiNoteNumber, midiNoteOffVelocity);
2168 noteOffCallCounter++;
2169 lastMidiChannelReceived = midiChannel;
2170 lastMidiNoteNumberReceived = midiNoteNumber;
2171 lastMPEValueReceived = midiNoteOffVelocity;
2174 void pitchbend (
int midiChannel, MPEValue value)
override
2176 Base::pitchbend (midiChannel, value);
2178 pitchbendCallCounter++;
2179 lastMidiChannelReceived = midiChannel;
2180 lastMPEValueReceived = value;
2183 void pressure (
int midiChannel, MPEValue value)
override
2185 Base::pressure (midiChannel, value);
2187 pressureCallCounter++;
2188 lastMidiChannelReceived = midiChannel;
2189 lastMPEValueReceived = value;
2192 void timbre (
int midiChannel, MPEValue value)
override
2194 Base::timbre (midiChannel, value);
2196 timbreCallCounter++;
2197 lastMidiChannelReceived = midiChannel;
2198 lastMPEValueReceived = value;
2201 void sustainPedal (
int midiChannel,
bool value)
override
2203 Base::sustainPedal (midiChannel, value);
2205 sustainPedalCallCounter++;
2206 lastMidiChannelReceived = midiChannel;
2207 lastSustainPedalValueReceived = value;
2210 void sostenutoPedal (
int midiChannel,
bool value)
override
2212 Base::sostenutoPedal (midiChannel, value);
2214 sostenutoPedalCallCounter++;
2215 lastMidiChannelReceived = midiChannel;
2216 lastSostenutoPedalValueReceived = value;
2219 void aftertouch (
int midiChannel,
int midiNoteNumber, MPEValue value)
2222 processNextMidiEvent (message);
2225 int noteOnCallCounter, noteOffCallCounter, pitchbendCallCounter,
2226 pressureCallCounter, timbreCallCounter, sustainPedalCallCounter,
2227 sostenutoPedalCallCounter, noteAddedCallCounter,
2228 notePressureChangedCallCounter, notePitchbendChangedCallCounter,
2229 noteTimbreChangedCallCounter, noteKeyStateChangedCallCounter,
2230 noteReleasedCallCounter, lastMidiChannelReceived, lastMidiNoteNumberReceived;
2232 bool lastSustainPedalValueReceived, lastSostenutoPedalValueReceived;
2233 MPEValue lastMPEValueReceived;
2234 std::unique_ptr<MPENote> lastNoteFinished;
2238 void noteAdded (MPENote)
override { noteAddedCallCounter++; }
2240 void notePressureChanged (MPENote)
override { notePressureChangedCallCounter++; }
2241 void notePitchbendChanged (MPENote)
override { notePitchbendChangedCallCounter++; }
2242 void noteTimbreChanged (MPENote)
override { noteTimbreChangedCallCounter++; }
2243 void noteKeyStateChanged (MPENote)
override { noteKeyStateChangedCallCounter++; }
2245 void noteReleased (MPENote finishedNote)
override
2247 noteReleasedCallCounter++;
2248 lastNoteFinished.reset (
new MPENote (finishedNote));
2253 void expectNote (MPENote noteToTest,
2254 int noteOnVelocity7Bit,
2258 MPENote::KeyState keyState)
2260 expect (noteToTest.isValid());
2261 expectEquals (noteToTest.noteOnVelocity.as7BitInt(), noteOnVelocity7Bit);
2262 expectEquals (noteToTest.pressure.as7BitInt(), pressure7Bit);
2263 expectEquals (noteToTest.pitchbend.as14BitInt(), pitchbend14Bit);
2264 expectEquals (noteToTest.timbre.as7BitInt(),timbre7Bit);
2265 expect (noteToTest.keyState == keyState);
2268 void expectHasFinishedNote (
const UnitTestInstrument& test,
2269 int channel,
int noteNumber,
int noteOffVelocity7Bit)
2271 expect (test.lastNoteFinished !=
nullptr);
2272 expectEquals (
int (test.lastNoteFinished->midiChannel), channel);
2273 expectEquals (
int (test.lastNoteFinished->initialNote), noteNumber);
2274 expectEquals (test.lastNoteFinished->noteOffVelocity.as7BitInt(), noteOffVelocity7Bit);
2275 expect (test.lastNoteFinished->keyState == MPENote::off);
2278 void expectDoubleWithinRelativeError (
double actual,
double expected,
double maxRelativeError)
2280 const double maxAbsoluteError = jmax (1.0, std::abs (expected)) * maxRelativeError;
2281 expect (std::abs (expected - actual) < maxAbsoluteError);
2285 MPEZoneLayout testLayout;
2288static MPEInstrumentTests MPEInstrumentUnitTests;
virtual void noteAdded(MPENote newNote)
virtual void noteReleased(MPENote finishedNote)
virtual void noteKeyStateChanged(MPENote changedNote)
void setPitchbendTrackingMode(TrackingMode modeToUse)
void setLegacyModeChannelRange(Range< int > channelRange)
MPENote getMostRecentNoteOtherThan(MPENote otherThanThisNote) const noexcept
MPEZoneLayout getZoneLayout() const noexcept
virtual void sostenutoPedal(int midiChannel, bool isDown)
virtual void pitchbend(int midiChannel, MPEValue pitchbend)
bool isMemberChannel(int midiChannel) const noexcept
void enableLegacyMode(int pitchbendRange=2, Range< int > channelRange=Range< int >(1, 17))
MPENote getNote(int index) const noexcept
void setZoneLayout(MPEZoneLayout newLayout)
virtual void polyAftertouch(int midiChannel, int midiNoteNumber, MPEValue value)
virtual void processNextMidiEvent(const MidiMessage &message)
void setLegacyModePitchbendRange(int pitchbendRange)
bool isLegacyModeEnabled() const noexcept
void setPressureTrackingMode(TrackingMode modeToUse)
void addListener(Listener *listenerToAdd)
void removeListener(Listener *listenerToRemove)
virtual void sustainPedal(int midiChannel, bool isDown)
void setTimbreTrackingMode(TrackingMode modeToUse)
int getNumPlayingNotes() const noexcept
virtual void timbre(int midiChannel, MPEValue value)
MPENote getMostRecentNote(int midiChannel) const noexcept
Range< int > getLegacyModeChannelRange() const noexcept
virtual void noteOn(int midiChannel, int midiNoteNumber, MPEValue midiNoteOnVelocity)
int getLegacyModePitchbendRange() const noexcept
virtual void noteOff(int midiChannel, int midiNoteNumber, MPEValue midiNoteOffVelocity)
virtual void pressure(int midiChannel, MPEValue value)
bool isMasterChannel(int midiChannel) const noexcept
bool isUsingChannel(int midiChannel) const noexcept
static MPEValue centreValue() noexcept
static MPEValue from14BitInt(int value) noexcept
static MPEValue minValue() noexcept
static MPEValue from7BitInt(int value) noexcept
const Zone getUpperZone() const noexcept
const Zone getLowerZone() const noexcept
void processNextMidiEvent(const MidiMessage &message)
bool isAftertouch() const noexcept
bool isNoteOn(bool returnTrueForVelocity0=false) const noexcept
int getChannel() const noexcept
static MidiMessage aftertouchChange(int channel, int noteNumber, int aftertouchAmount) noexcept
bool isController() const noexcept
bool isNoteOff(bool returnTrueForNoteOnVelocity0=true) const noexcept
bool isPitchWheel() const noexcept
int getNoteNumber() const noexcept
bool isResetAllControllers() const noexcept
bool isAllNotesOff() const noexcept
uint8 getVelocity() const noexcept
bool isChannelPressure() const noexcept