MidiExport.h

Go to the documentation of this file.

/*
 * MidiExport.h - support for exporting MIDI files
 *
 * Copyright (c) 2015 Mohamed Abdel Maksoud <mohamed at amaksoud.com>
 * Copyright (c) 2017 Hyunjin Song <tteu.ingog/at/gmail.com>
 * Copyright (c) 2020 EmoonX
 * Copyright (c) 2026 Dalton Messmer <messmer.dalton/at/gmail.com>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_MIDI_EXPORT_H
#define LMMS_MIDI_EXPORT_H
 
#include "MidiFile.h"
#include "DataFile.h"
#include "ExportFilter.h"
#include "Note.h"
 
class QDomNode;
 
namespace lmms
{

class MidiExport : public ExportFilter
{
private:
    struct Note
    {
        using Type = ::lmms::Note::Type;

        std::uint8_t pitch = 0;

        std::uint8_t volume = 0;

        tick_t time = 0;

        tick_t duration = 0;
 
        Type type = Type::Regular;

        bool operator<(const Note& b) const noexcept
        {
            return time < b.time;
        }
    };

    class Clip
    {
    private:
        std::vector<Note> m_notes;
 
    public:
        void write(const QDomNode& root,
            int basePitch, double baseVolume, tick_t baseTime);

        void processPatternNotes(tick_t cutPos);

        void writeToTrack(MidiFile::Track& midiTrack) const;

        void writeToPattern(Clip& patternClip,
            tick_t len, tick_t base, tick_t start, tick_t end);
    };

    std::uint8_t m_channel = 0;

    DataFile m_dataFile = DataFile(DataFile::Type::SongProject);

    std::vector<std::vector<std::pair<tick_t, tick_t>>> m_plists;
 
public:
    MidiExport();
    ~MidiExport() override = default;
 
    // Default Beat Length in ticks for step notes
    // TODO: The beat length actually varies per note, however the method that
    // calculates it (InstrumentTrack::beatLen) requires a NotePlayHandle to do
    // so. While we don't figure out a way to hold the beat length of each note
    // on its member variables, we will use a default value as a beat length that
    // will be used as an upper limit of the midi note length. This doesn't worsen
    // the current logic used for MidiExport because right now the beat length is
    // not even considered during the generation of the MIDI.
    static constexpr int DefaultBeatLength = 1500;

    bool tryExport(const TrackContainer::TrackList& tracks,
        const TrackContainer::TrackList& patternStoreTracks,
        int tempo, int masterPitch, const std::filesystem::path& filePath) override;
 
private:
    void processTrack(Track& track, MidiFile::Track& midiTrack,
        int tempo, int masterPitch, bool isPattern = false);

    void writePatternClip(Clip& clip, const QDomElement& clipElem,
        std::uint8_t patternIdx, MidiFile::Track& midiTrack);

    void processPatternTrack(Track& track);

    gui::PluginView* instantiateView(QWidget*) override { return nullptr; }
};
 
} // namespace lmms
 
#endif // LMMS_MIDI_EXPORT_H