tracktion_MidiList.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
namespace tracktion { inline namespace engine
{
 
class MidiList
{
public:
    MidiList();
    MidiList (const juce::ValueTree&, juce::UndoManager*);
    ~MidiList();
 
    static juce::ValueTree createMidiList();
 
    void copyFrom (const MidiList&, juce::UndoManager*);
 
    void addFrom (const MidiList&, juce::UndoManager*);
 
    //==============================================================================
    enum class NoteAutomationType
    {
        none,       
        expression  
    };
 
    //==============================================================================
    const juce::Array<MidiNote*>& getNotes() const;
    const juce::Array<MidiControllerEvent*>& getControllerEvents() const;
    const juce::Array<MidiSysexEvent*>& getSysexEvents() const;
 
    //==============================================================================
    bool isAttachedToClip() const noexcept                          { return ! state.getParent().hasType (IDs::NA); }
 
    void setCompList (bool shouldBeComp) noexcept                   { isComp = shouldBeComp; }
    bool isCompList() const noexcept                                { return isComp; }
 
    //==============================================================================
    MidiChannel getMidiChannel() const                              { return midiChannel; }
 
    void setMidiChannel (MidiChannel chanNum);
 
    juce::String getImportedMidiTrackName() const noexcept          { return importedName; }
 
    juce::String getImportedFileName() const noexcept               { return importedFileName; }
    void setImportedFileName (const juce::String& n)                { importedFileName = n; }
 
    //==============================================================================
    bool isEmpty() const noexcept                                   { return state.getNumChildren() == 0; }
 
    void clear (juce::UndoManager*);
    void trimOutside (BeatPosition firstBeat, BeatPosition lastBeat, juce::UndoManager*);
    void moveAllBeatPositions (BeatDuration deltaBeats, juce::UndoManager*);
    void rescale (double factor, juce::UndoManager*);
 
    //==============================================================================
    int getNumNotes() const                                         { return getNotes().size(); }
    MidiNote* getNote (int index) const                             { return getNotes()[index]; }
    MidiNote* getNoteFor (const juce::ValueTree&);
 
    juce::Range<int> getNoteNumberRange() const;
 
    BeatPosition getFirstBeatNumber() const;
 
    BeatPosition getLastBeatNumber() const;
 
    MidiNote* addNote (const MidiNote&, juce::UndoManager*);
    MidiNote* addNote (int pitch, BeatPosition startBeat, BeatDuration lengthInBeats, int velocity, int colourIndex, juce::UndoManager*);
    void removeNote (MidiNote&, juce::UndoManager*);
    void removeAllNotes (juce::UndoManager*);
 
    //==============================================================================
    int getNumControllerEvents() const                              { return getControllerEvents().size(); }
 
    MidiControllerEvent* getControllerEvent (int index) const       { return getControllerEvents()[index]; }
    MidiControllerEvent* getControllerEventAt (BeatPosition, int controllerType) const;
 
    MidiControllerEvent* addControllerEvent (const MidiControllerEvent&, juce::UndoManager*);
    MidiControllerEvent* addControllerEvent (BeatPosition, int controllerType, int controllerValue, juce::UndoManager*);
    MidiControllerEvent* addControllerEvent (BeatPosition, int controllerType, int controllerValue, int metadata, juce::UndoManager*);
 
    void removeControllerEvent (MidiControllerEvent&, juce::UndoManager*);
    void removeAllControllers (juce::UndoManager*);
 
    bool containsController (int controllerType) const;
 
    void setControllerValueAt (int controllerType, BeatPosition beatNumber, int newValue, juce::UndoManager*);
    void removeControllersBetween (int controllerType, BeatPosition beatNumberStart, BeatPosition beatNumberEnd, juce::UndoManager*);
 
    void insertRepeatedControllerValue (int type, int startVal, int endVal,
                                        BeatRange rangeBeats,
                                        BeatDuration intervalBeats, juce::UndoManager*);
 
    //==============================================================================
    int getNumSysExEvents() const                                   { return getSysexEvents().size(); }
 
    MidiSysexEvent* getSysexEvent (int index) const                 { return getSysexEvents()[index]; }
    MidiSysexEvent* getSysexEventUnchecked (int index) const        { return getSysexEvents().getUnchecked (index); }
    MidiSysexEvent* getSysexEventFor (const juce::ValueTree&) const;
 
    MidiSysexEvent& addSysExEvent (const juce::MidiMessage&, BeatPosition, juce::UndoManager*);
 
    void removeSysExEvent (const MidiSysexEvent&, juce::UndoManager*);
    void removeAllSysexes (juce::UndoManager*);
 
    //==============================================================================
    void importMidiSequence (const juce::MidiMessageSequence&, Edit*,
                             TimePosition editTimeOfListTimeZero, juce::UndoManager*);
 
    void importFromEditTimeSequenceWithNoteExpression (const juce::MidiMessageSequence&, Edit*,
                                                       TimePosition editTimeOfListTimeZero, juce::UndoManager*);
 
    enum class TimeBase
    {
        seconds,    
        beats,      
        beatsRaw    
    };
 
    juce::MidiMessageSequence exportToPlaybackMidiSequence (MidiClip&, TimeBase, bool generateMPE) const;
 
    static juce::MidiMessageSequence createDefaultPlaybackMidiSequence (const MidiList&, MidiClip&, TimeBase, bool generateMPE);
 
    //==============================================================================
    static bool looksLikeMPEData (const juce::File&);
 
    static constexpr const double defaultInitialTimbreValue = 0.5;
    static constexpr const double defaultInitialPitchBendValue = 0;
    static constexpr const double defaultInitialPressureValue = 0;
 
    static bool fileHasTempoChanges (const juce::File&);
 
    static bool readSeparateTracksFromFile (const juce::File&,
                                            juce::OwnedArray<MidiList>& lists,
                                            juce::Array<BeatPosition>& tempoChangeBeatNumbers,
                                            juce::Array<double>& bpms,
                                            juce::Array<int>& numerators,
                                            juce::Array<int>& denominators,
                                            BeatDuration& songLength,
                                            bool importAsNoteExpression);
 
    //==============================================================================
    template <typename Type>
    static void sortMidiEventsByTime (juce::Array<Type>& notes)
    {
        std::sort (notes.begin(), notes.end(),
                   [] (const Type& a, const Type& b) { return a->getBeatPosition() < b->getBeatPosition(); });
    }
 
    template <typename Type>
    static void sortMidiEventsByNoteNumber (juce::Array<Type>& notes)
    {
        std::sort (notes.begin(), notes.end(),
                   [] (const Type& a, const Type& b) { return a->getNoteNumber() < b->getNoteNumber(); });
    }
 
    //==============================================================================
    juce::ValueTree state;
 
private:
    //==============================================================================
    juce::CachedValue<MidiChannel> midiChannel;
    juce::CachedValue<bool> isComp;
 
    juce::String importedFileName;
    juce::String importedName;
 
    void initialise (juce::UndoManager*);
 
    template<typename EventType>
    struct EventDelegate
    {
        static bool isSuitableType (const juce::ValueTree&);
        static bool updateObject (EventType&, const juce::Identifier&);
        static void removeFromSelection (EventType*);
    };
 
    template<typename EventType>
    struct EventList : public ValueTreeObjectList<EventType>
    {
        EventList (const juce::ValueTree& v)
            : ValueTreeObjectList<EventType> (v)
        {
            ValueTreeObjectList<EventType>::rebuildObjects();
        }
 
        ~EventList() override
        {
            ValueTreeObjectList<EventType>::freeObjects();
        }
 
        EventType* getEventFor (const juce::ValueTree& v)
        {
            for (auto m : ValueTreeObjectList<EventType>::objects)
                if (m->state == v)
                    return m;
 
            return {};
        }
 
        bool isSuitableType (const juce::ValueTree& v) const override   { return EventDelegate<EventType>::isSuitableType (v); }
        EventType* createNewObject (const juce::ValueTree& v) override  { return new EventType (v); }
        void deleteObject (EventType* m) override                       { delete m; }
        void newObjectAdded (EventType*) override                       { triggerSort(); }
        void objectRemoved (EventType* m) override                      { EventDelegate<EventType>::removeFromSelection (m); triggerSort(); }
        void objectOrderChanged() override                              { triggerSort(); }
 
        void valueTreePropertyChanged (juce::ValueTree& v, const juce::Identifier& i) override
        {
            if (auto e = getEventFor (v))
                if (EventDelegate<EventType>::updateObject (*e, i))
                    triggerSort();
        }
 
        void triggerSort()
        {
            const juce::ScopedLock sl (lock);
            needsSorting = true;
        }
 
        const juce::Array<EventType*>& getSortedList()
        {
            TRACKTION_ASSERT_MESSAGE_THREAD
 
            const juce::ScopedLock sl (lock);
 
            if (needsSorting)
            {
                needsSorting = false;
                sortedEvents = ValueTreeObjectList<EventType>::objects;
                sortMidiEventsByTime (sortedEvents);
            }
 
            return sortedEvents;
        }
 
        bool needsSorting = true;
        juce::Array<EventType*> sortedEvents;
        juce::CriticalSection lock;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (EventList)
    };
 
    std::unique_ptr<EventList<MidiNote>> noteList;
    std::unique_ptr<EventList<MidiControllerEvent>> controllerList;
    std::unique_ptr<EventList<MidiSysexEvent>> sysexList;
 
    //==============================================================================
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MidiList)
};
 
}} // namespace tracktion { inline namespace engine