Fix GitHub Issue #39: Save patch changes in midi export

- Optionally exports and imports program change and bank settings

Author: juzzlin

CHANGELOG

@@ -12,6 +12,9 @@ New features:
 
 * Make velocity interpolation dialog remember the previous values
 
+* Fix GitHub Issue #39: Save patch changes in midi export
+  - Optionally exports and imports program change and bank settings
+
 Bug fixes:
 
 * Fix crash when resizing after track deletion

src/application/application.cpp

@@ -312,14 +312,14 @@ void Application::connectApplicationService()
     connect(m_applicationService.get(), &ApplicationService::liveNoteOffRequested, m_midiService.get(), &MidiService::stopNote);
     connect(m_applicationService.get(), &ApplicationService::allNotesOffRequested, this, &Application::stopAllNotes);
 
-    connect(m_applicationService.get(), &ApplicationService::midiExportRequested, this, qOverload<QString, quint64, quint64>(&Application::exportToMidi));
+    connect(m_applicationService.get(), &ApplicationService::midiExportRequested, this, &Application::exportToMidi);
     connect(m_applicationService.get(), &ApplicationService::midiImportRequested, this, &Application::importFromMidi);
 }
 
-void Application::exportToMidi(QString fileName, quint64 startPosition, quint64 endPosition)
+void Application::exportToMidi(QString fileName, quint64 startPosition, quint64 endPosition, MidiExportOptions options)
 {
     try {
-        m_midiExporter->exportTo(fileName.toStdString(), m_editorService->song(), startPosition, endPosition);
+        m_midiExporter->exportTo(fileName.toStdString(), m_editorService->song(), startPosition, endPosition, options);
         const auto message = QString { "Exported the project to '%1' " }.arg(fileName);
         m_applicationService->requestStatusText(message);
     } catch (std::exception & e) {
@@ -328,12 +328,11 @@ void Application::exportToMidi(QString fileName, quint64 startPosition, quint64
         m_applicationService->requestStatusText(message);
     }
 }
-
-void Application::importFromMidi(QString fileName, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff)
+void Application::importFromMidi(QString fileName, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts)
 {
     try {
         const auto midiData = m_midiImporter->parseMidiFile(fileName.toStdString());
-        m_midiImporter->importTo(midiData, m_editorService->song(), importMode, patternLength, quantizeNoteOn, quantizeNoteOff);
+        m_midiImporter->importTo(midiData, m_editorService->song(), importMode, patternLength, quantizeNoteOn, quantizeNoteOff, connectMidiPorts ? m_midiService : nullptr);
         const auto message = QString { "Imported MIDI file '%1' " }.arg(fileName);
         m_applicationService->requestStatusText(message);
         m_editorService->setSong(m_editorService->song());

src/application/application.hpp

@@ -115,8 +115,8 @@ class Application : public QObject
     void requestInstruments(QStringList midiPorts);
     void stopAllNotes() const;
 
-    void exportToMidi(QString fileName, quint64 startPosition, quint64 endPosition);
-    void importFromMidi(QString fileName, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff);
+    void exportToMidi(QString fileName, quint64 startPosition, quint64 endPosition, MidiExportOptions options);
+    void importFromMidi(QString fileName, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts);
 
     std::unique_ptr<UiLogger> m_uiLogger;
 

src/application/service/application_service.cpp

@@ -145,14 +145,17 @@ void ApplicationService::requestMidiExportDialog()
     emit midiExportDialogRequested();
 }
 
-void ApplicationService::exportMidiFile(QUrl url, quint64 startPosition, quint64 endPosition)
+void ApplicationService::exportMidiFile(QUrl url, quint64 startPosition, quint64 endPosition, bool exportBank, bool exportProgramChange)
 {
     auto fileName = url.toLocalFile();
     juzzlin::L(TAG).info() << "MIDI export requested for " << fileName.toStdString() << " from " << startPosition << " to " << endPosition;
     if (!fileName.endsWith(Constants::midiFileExtension())) {
         fileName += Constants::midiFileExtension();
     }
-    emit midiExportRequested(fileName, startPosition, endPosition);
+    MidiExportOptions options;
+    options.exportBank = exportBank;
+    options.exportProgramChange = exportProgramChange;
+    emit midiExportRequested(fileName, startPosition, endPosition, options);
 }
 
 void ApplicationService::requestMidiImportDialog()
@@ -161,11 +164,11 @@ void ApplicationService::requestMidiImportDialog()
     emit midiImportDialogRequested();
 }
 
-void ApplicationService::importMidiFile(QUrl url, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff)
+void ApplicationService::importMidiFile(QUrl url, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts)
 {
     const auto fileName = url.toLocalFile();
-    juzzlin::L(TAG).info() << "MIDI import requested for " << fileName.toStdString() << " mode: " << importMode << " length: " << patternLength << " quantizeNoteOn: " << quantizeNoteOn << " quantizeNoteOff: " << quantizeNoteOff;
-    emit midiImportRequested(fileName, importMode, patternLength, quantizeNoteOn, quantizeNoteOff);
+    juzzlin::L(TAG).info() << "MIDI import requested for " << fileName.toStdString() << " mode: " << importMode << " length: " << patternLength << " quantizeNoteOn: " << quantizeNoteOn << " quantizeNoteOff: " << quantizeNoteOff << " connectMidiPorts: " << connectMidiPorts;
+    emit midiImportRequested(fileName, importMode, patternLength, quantizeNoteOn, quantizeNoteOff, connectMidiPorts);
 }
 
 void ApplicationService::requestLiveNoteOn(quint8 key, quint8 octave, quint8 velocity)

src/application/service/application_service.hpp

@@ -23,6 +23,8 @@
 
 #include <memory>
 
+#include "../../infra/midi/export/midi_exporter.hpp"
+
 namespace noteahead {
 
 class EditorService;
@@ -89,10 +91,10 @@ class ApplicationService : public QObject
     Q_INVOKABLE void saveProjectAsTemplate(QUrl url);
 
     Q_INVOKABLE void requestMidiExportDialog();
-    Q_INVOKABLE void exportMidiFile(QUrl url, quint64 startPosition, quint64 endPosition);
+    Q_INVOKABLE void exportMidiFile(QUrl url, quint64 startPosition, quint64 endPosition, bool exportBank, bool exportProgramChange);
 
     Q_INVOKABLE void requestMidiImportDialog();
-    Q_INVOKABLE void importMidiFile(QUrl url, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff);
+    Q_INVOKABLE void importMidiFile(QUrl url, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts);
 
     Q_INVOKABLE virtual bool editMode() const;
     Q_INVOKABLE virtual void setEditMode(bool editMode);
@@ -142,10 +144,10 @@ class ApplicationService : public QObject
     void saveAsDialogRequested();
     void saveAsTemplateDialogRequested();
     void midiExportDialogRequested();
-    void midiExportRequested(QString fileName, quint64 startPosition, quint64 endPosition);
+    void midiExportRequested(QString fileName, quint64 startPosition, quint64 endPosition, MidiExportOptions options);
 
     void midiImportDialogRequested();
-    void midiImportRequested(QString fileName, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff);
+    void midiImportRequested(QString fileName, int importMode, int patternLength, bool quantizeNoteOn, bool quantizeNoteOff, bool connectMidiPorts);
 
     void alertDialogRequested(QString message);
     void statusTextRequested(QString message);

src/application/service/midi_service.hpp

@@ -43,7 +43,7 @@ class MidiService : public QObject
 
     ~MidiService() override;
 
-    Q_INVOKABLE QStringList outputPorts() const;
+    virtual Q_INVOKABLE QStringList outputPorts() const;
 
     // QML API
     Q_INVOKABLE void setIsPlaying(bool isPlaying);

src/infra/midi/export/midi_exporter.cpp

@@ -42,13 +42,18 @@ namespace {
     constexpr uint8_t MIDI_PORT_EVENT = 0x21;
     constexpr uint8_t TRACK_NAME_EVENT = 0x03;
     constexpr uint8_t END_OF_TRACK_EVENT = 0x2f;
+    constexpr uint8_t DEVICE_NAME_EVENT = 0x09;
     constexpr uint8_t SET_TEMPO_EVENT = 0x51;
 
     constexpr uint8_t NOTE_ON_STATUS = 0x90;
     constexpr uint8_t NOTE_OFF_STATUS = 0x80;
     constexpr uint8_t CONTROL_CHANGE_STATUS = 0xb0;
+    constexpr uint8_t PROGRAM_CHANGE_STATUS = 0xc0;
     constexpr uint8_t PITCH_BEND_STATUS = 0xe0;
 
+    constexpr uint8_t BANK_SELECT_MSB = 0x00;
+    constexpr uint8_t BANK_SELECT_LSB = 0x20;
+
     void writeBeU32(std::ostream & out, uint32_t value)
     {
         out.put(static_cast<uint8_t>(value >> 24) & 0xff);
@@ -95,7 +100,7 @@ void MidiExporter::sortEvents(std::vector<EventS> & events)
     });
 }
 
-void MidiExporter::exportTo(std::string fileName, SongW songW, size_t startPosition, size_t endPosition) const
+void MidiExporter::exportTo(std::string fileName, SongW songW, size_t startPosition, size_t endPosition, MidiExportOptions options) const
 {
     auto song = songW.lock();
     if (!song) {
@@ -127,8 +132,8 @@ void MidiExporter::exportTo(std::string fileName, SongW songW, size_t startPosit
 
     auto filteredEvents = filterEvents(renderedEvents, m_mixerService);
 
-    const auto activeTracks = discoverActiveTracks(song, filteredEvents);
-    const auto trackData = buildTrackData(song, filteredEvents, activeTracks);
+    const auto activeTracks = discoverActiveTracks(song, filteredEvents, options);
+    const auto trackData = buildTrackData(song, filteredEvents, activeTracks, options);
 
     writeMidiHeader(out, song, activeTracks.trackToInstrument.size());
     writeTempoTrack(out, song);
@@ -169,7 +174,7 @@ void MidiExporter::writeMidiHeader(std::ostream & out, const SongS & song, size_
     writeBeU16(out, ticksPerQuarterNote);
 }
 
-MidiExporter::ActiveTracks MidiExporter::discoverActiveTracks(const SongS & song, const std::vector<EventS> & events) const
+MidiExporter::ActiveTracks MidiExporter::discoverActiveTracks(const SongS & song, const std::vector<EventS> & events, MidiExportOptions options) const
 {
     ActiveTracks activeTracks;
     std::set<std::string> portNames;
@@ -185,6 +190,18 @@ MidiExporter::ActiveTracks MidiExporter::discoverActiveTracks(const SongS & song
         }
     }
 
+    // Also add tracks that have Bank or Program settings if enabled
+    for (size_t i = 0; i < song->trackCount(); ++i) {
+        if (auto instrument = song->instrument(i)) {
+            const auto & settings = instrument->settings();
+            const bool hasBank = options.exportBank && settings.bank.has_value();
+            const bool hasPatch = options.exportProgramChange && settings.patch.has_value();
+            if (hasBank || hasPatch) {
+                activeTrackIndices.insert(i);
+            }
+        }
+    }
+
     for (const auto & trackIndex : activeTrackIndices) {
         auto instrument = song->instrument(trackIndex);
         if (!instrument) {
@@ -208,7 +225,7 @@ MidiExporter::ActiveTracks MidiExporter::discoverActiveTracks(const SongS & song
     return activeTracks;
 }
 
-MidiExporter::ByteVector MidiExporter::initializeTrack(const SongS & song, size_t trackIndex, const ActiveTracks & activeTracks) const
+MidiExporter::ByteVector MidiExporter::initializeTrack(const SongS & song, size_t trackIndex, uint8_t channel, const ActiveTracks & activeTracks, MidiExportOptions options) const
 {
     ByteVector data;
 
@@ -223,6 +240,13 @@ MidiExporter::ByteVector MidiExporter::initializeTrack(const SongS & song, size_
     data.push_back(static_cast<char>(portIndex));
     juzzlin::L(TAG).info() << "Writing MIDI Port Meta-Event for track " << trackIndex << ", portIndex: " << static_cast<int>(portIndex);
 
+    // Add Device Name Meta-Event (Port Name)
+    data.push_back(static_cast<char>(0x00)); // Delta time
+    data.push_back(static_cast<char>(META_EVENT));
+    data.push_back(static_cast<char>(DEVICE_NAME_EVENT));
+    writeVlq(data, static_cast<uint32_t>(portName.length()));
+    data.insert(data.end(), portName.begin(), portName.end());
+
     // Add Track Name Meta-Event
     data.push_back(static_cast<char>(0x00)); // Delta time
     data.push_back(static_cast<char>(META_EVENT));
@@ -231,6 +255,27 @@ MidiExporter::ByteVector MidiExporter::initializeTrack(const SongS & song, size_
     writeVlq(data, static_cast<uint32_t>(trackName.length()));
     data.insert(data.end(), trackName.begin(), trackName.end());
 
+    const auto instrument = activeTracks.trackToInstrument.at(trackIndex);
+    const auto & settings = instrument->settings();
+
+    if (options.exportBank && settings.bank.has_value()) {
+        data.push_back(static_cast<char>(0x00)); // Delta time
+        data.push_back(static_cast<char>(CONTROL_CHANGE_STATUS | channel));
+        data.push_back(static_cast<char>(BANK_SELECT_MSB));
+        data.push_back(static_cast<char>(settings.bank->msb));
+
+        data.push_back(static_cast<char>(0x00)); // Delta time
+        data.push_back(static_cast<char>(CONTROL_CHANGE_STATUS | channel));
+        data.push_back(static_cast<char>(BANK_SELECT_LSB));
+        data.push_back(static_cast<char>(settings.bank->lsb));
+    }
+
+    if (options.exportProgramChange && settings.patch.has_value()) {
+        data.push_back(static_cast<char>(0x00)); // Delta time
+        data.push_back(static_cast<char>(PROGRAM_CHANGE_STATUS | channel));
+        data.push_back(static_cast<char>(*settings.patch));
+    }
+
     return data;
 }
 
@@ -266,14 +311,14 @@ void MidiExporter::writePitchBendEvent(ByteVector & dataOut, uint8_t channel, co
     dataOut.push_back(static_cast<char>(pitchBendData.msb()));
 }
 
-std::map<size_t, MidiExporter::ByteVector> MidiExporter::buildTrackData(const SongS & song, const std::vector<EventS> & events, const ActiveTracks & activeTracks) const
+std::map<size_t, MidiExporter::ByteVector> MidiExporter::buildTrackData(const SongS & song, const std::vector<EventS> & events, const ActiveTracks & activeTracks, MidiExportOptions options) const
 {
-    auto initialState = initializeTracks(song, activeTracks);
+    auto initialState = initializeTracks(song, activeTracks, options);
     auto processedState = processEvents(std::move(initialState), events);
     return finalizeTracks(std::move(processedState));
 }
 
-MidiExporter::TrackProcessingState MidiExporter::initializeTracks(const SongS & song, const ActiveTracks & activeTracks) const
+MidiExporter::TrackProcessingState MidiExporter::initializeTracks(const SongS & song, const ActiveTracks & activeTracks, MidiExportOptions options) const
 {
     TrackProcessingState state;
     std::map<std::string, uint8_t> portChannelCounters;
@@ -286,9 +331,10 @@ MidiExporter::TrackProcessingState MidiExporter::initializeTracks(const SongS &
         if (channel == 9) { // Skip drum channel 10
             channel++;
         }
-        state.trackToChannelMap[trackIndex] = channel++;
+        const uint8_t trackChannel = channel++;
+        state.trackToChannelMap[trackIndex] = trackChannel;
 
-        state.allTracksData[trackIndex] = initializeTrack(song, trackIndex, activeTracks);
+        state.allTracksData[trackIndex] = initializeTrack(song, trackIndex, trackChannel, activeTracks, options);
     }
     return state;
 }

src/infra/midi/export/midi_exporter.hpp

@@ -36,6 +36,11 @@ class PitchBendData;
 class SideChainService;
 class Song;
 
+struct MidiExportOptions {
+    bool exportBank = true;
+    bool exportProgramChange = true;
+};
+
 class MidiExporter {
 public:
     using AutomationServiceS = std::shared_ptr<AutomationService>;
@@ -55,7 +60,7 @@ class MidiExporter {
 
     MidiExporter(AutomationServiceS automationService, MixerServiceS mixerService, SideChainServiceS sidechainService);
 
-    void exportTo(std::string fileName, SongW songW, size_t startPosition = 0, size_t endPosition = std::numeric_limits<size_t>::max()) const;
+    void exportTo(std::string fileName, SongW songW, size_t startPosition = 0, size_t endPosition = std::numeric_limits<size_t>::max(), MidiExportOptions options = MidiExportOptions()) const;
 
 private:
     struct TrackProcessingState {
@@ -65,16 +70,15 @@ class MidiExporter {
     };
 
     void writeMidiHeader(std::ostream & out, const SongS & song, size_t numNoteTracks) const;
-    ActiveTracks discoverActiveTracks(const SongS& song, const std::vector<EventS> & events) const;
-    
+    ActiveTracks discoverActiveTracks(const SongS & song, const std::vector<EventS> & events, MidiExportOptions options) const;
     std::vector<EventS> filterEvents(const std::vector<EventS> & events, MixerServiceS mixerService) const;
 
-    std::map<size_t, ByteVector> buildTrackData(const SongS& song, const std::vector<EventS> & events, const ActiveTracks & activeTracks) const;
-    TrackProcessingState initializeTracks(const SongS& song, const ActiveTracks & activeTracks) const;
+    std::map<size_t, ByteVector> buildTrackData(const SongS& song, const std::vector<EventS> & events, const ActiveTracks & activeTracks, MidiExportOptions options) const;
+    TrackProcessingState initializeTracks(const SongS& song, const ActiveTracks & activeTracks, MidiExportOptions options) const;
     TrackProcessingState processEvents(TrackProcessingState state, const std::vector<EventS> & events) const;
     std::map<size_t, ByteVector> finalizeTracks(TrackProcessingState state) const;
 
-    ByteVector initializeTrack(const SongS& song, size_t trackIndex, const ActiveTracks & activeTracks) const;
+    ByteVector initializeTrack(const SongS& song, size_t trackIndex, uint8_t channel, const ActiveTracks & activeTracks, MidiExportOptions options) const;
     void writeNoteOnEvent(ByteVector & data, uint8_t channel, const NoteData & noteData) const;
     void writeNoteOffEvent(ByteVector & data, uint8_t channel, const NoteData & noteData) const;
     void writeControlChangeEvent(ByteVector & data, uint8_t channel, const MidiCcData & ccData) const;