juce_MPEInstrument.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   The code included in this file is provided under the terms of the ISC license
   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
   To use, copy, modify, and/or distribute this software for any purpose with or
   without fee is hereby granted provided that the above copyright notice and
   this permission notice appear in all copies.
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
//==============================================================================
class JUCE_API  MPEInstrument
{
public:
    MPEInstrument() noexcept;

    MPEInstrument (MPEZoneLayout layout);

    virtual ~MPEInstrument();
 
    //==============================================================================
    MPEZoneLayout getZoneLayout() const noexcept;

    void setZoneLayout (MPEZoneLayout newLayout);

    bool isMemberChannel (int midiChannel) const noexcept;

    bool isMasterChannel (int midiChannel) const noexcept;

    bool isUsingChannel (int midiChannel) const noexcept;
 
    //==============================================================================
    enum TrackingMode
    {
        lastNotePlayedOnChannel, 
        lowestNoteOnChannel,     
        highestNoteOnChannel,    
        allNotesOnChannel        
    };

    void setPressureTrackingMode (TrackingMode modeToUse);

    void setPitchbendTrackingMode (TrackingMode modeToUse);

    void setTimbreTrackingMode (TrackingMode modeToUse);
 
    //==============================================================================
    virtual void processNextMidiEvent (const MidiMessage& message);
 
    //==============================================================================
    virtual void noteOn (int midiChannel, int midiNoteNumber, MPEValue midiNoteOnVelocity);

    virtual void noteOff (int midiChannel, int midiNoteNumber, MPEValue midiNoteOffVelocity);

    virtual void pitchbend (int midiChannel, MPEValue pitchbend);

    virtual void pressure (int midiChannel, MPEValue value);

    virtual void timbre (int midiChannel, MPEValue value);

    virtual void polyAftertouch (int midiChannel, int midiNoteNumber, MPEValue value);

    virtual void sustainPedal (int midiChannel, bool isDown);

    virtual void sostenutoPedal (int midiChannel, bool isDown);

    void releaseAllNotes();
 
    //==============================================================================
    int getNumPlayingNotes() const noexcept;

    MPENote getNote (int index) const noexcept;

    MPENote getNote (int midiChannel, int midiNoteNumber) const noexcept;

    MPENote getNoteWithID (uint16 noteID) const noexcept;

    MPENote getMostRecentNote (int midiChannel) const noexcept;

    MPENote getMostRecentNoteOtherThan (MPENote otherThanThisNote) const noexcept;
 
    //==============================================================================
    class JUCE_API  Listener
    {
    public:
        virtual ~Listener() = default;

        virtual void noteAdded (MPENote newNote)                 { ignoreUnused (newNote); }

        virtual void notePressureChanged (MPENote changedNote)   { ignoreUnused (changedNote); }

        virtual void notePitchbendChanged (MPENote changedNote)  { ignoreUnused (changedNote); }

        virtual void noteTimbreChanged (MPENote changedNote)     { ignoreUnused (changedNote); }

        virtual void noteKeyStateChanged (MPENote changedNote)   { ignoreUnused (changedNote); }

        virtual void noteReleased (MPENote finishedNote)         { ignoreUnused (finishedNote); }

        virtual void zoneLayoutChanged()                         {}
    };
 
    //==============================================================================
    void addListener (Listener* listenerToAdd);

    void removeListener (Listener* listenerToRemove);
 
    //==============================================================================
    void enableLegacyMode (int pitchbendRange = 2,
                           Range<int> channelRange = Range<int> (1, 17));

    bool isLegacyModeEnabled() const noexcept;

    Range<int> getLegacyModeChannelRange() const noexcept;

    void setLegacyModeChannelRange (Range<int> channelRange);

    int getLegacyModePitchbendRange() const noexcept;

    void setLegacyModePitchbendRange (int pitchbendRange);
 
protected:
    //==============================================================================
    CriticalSection lock;
 
private:
    //==============================================================================
    Array<MPENote> notes;
    MPEZoneLayout zoneLayout;
    ListenerList<Listener> listeners;
 
    uint8 lastPressureLowerBitReceivedOnChannel[16];
    uint8 lastTimbreLowerBitReceivedOnChannel[16];
    bool isMemberChannelSustained[16];
 
    struct LegacyMode
    {
        bool isEnabled = false;
        Range<int> channelRange;
        int pitchbendRange = 2;
    };
 
    struct MPEDimension
    {
        TrackingMode trackingMode = lastNotePlayedOnChannel;
        MPEValue lastValueReceivedOnChannel[16];
        MPEValue MPENote::* value;
        MPEValue& getValue (MPENote& note) noexcept   { return note.*(value); }
    };
 
    LegacyMode legacyMode;
    MPEDimension pitchbendDimension, pressureDimension, timbreDimension;
 
    void resetLastReceivedValues();
 
    void updateDimension (int midiChannel, MPEDimension&, MPEValue);
    void updateDimensionMaster (bool, MPEDimension&, MPEValue);
    void updateDimensionForNote (MPENote&, MPEDimension&, MPEValue);
    void callListenersDimensionChanged (const MPENote&, const MPEDimension&);
    MPEValue getInitialValueForNewNote (int midiChannel, MPEDimension&) const;
 
    void processMidiNoteOnMessage (const MidiMessage&);
    void processMidiNoteOffMessage (const MidiMessage&);
    void processMidiPitchWheelMessage (const MidiMessage&);
    void processMidiChannelPressureMessage (const MidiMessage&);
    void processMidiControllerMessage (const MidiMessage&);
    void processMidiResetAllControllersMessage (const MidiMessage&);
    void processMidiAfterTouchMessage (const MidiMessage&);
    void handlePressureMSB (int midiChannel, int value) noexcept;
    void handlePressureLSB (int midiChannel, int value) noexcept;
    void handleTimbreMSB (int midiChannel, int value) noexcept;
    void handleTimbreLSB (int midiChannel, int value) noexcept;
    void handleSustainOrSostenuto (int midiChannel, bool isDown, bool isSostenuto);
 
    const MPENote* getNotePtr (int midiChannel, int midiNoteNumber) const noexcept;
    MPENote* getNotePtr (int midiChannel, int midiNoteNumber) noexcept;
    const MPENote* getNotePtr (int midiChannel, TrackingMode) const noexcept;
    MPENote* getNotePtr (int midiChannel, TrackingMode) noexcept;
    const MPENote* getLastNotePlayedPtr (int midiChannel) const noexcept;
    MPENote* getLastNotePlayedPtr (int midiChannel) noexcept;
    const MPENote* getHighestNotePtr (int midiChannel) const noexcept;
    MPENote* getHighestNotePtr (int midiChannel) noexcept;
    const MPENote* getLowestNotePtr (int midiChannel) const noexcept;
    MPENote* getLowestNotePtr (int midiChannel) noexcept;
    void updateNoteTotalPitchbend (MPENote&);
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MPEInstrument)
};
 
} // namespace juce