Add MIDI clock synchronization for external hardware or other software (elieserdejesus#1354)

* Add clock start/pulse to midi driver

* Add MIDI clock methods to main controller

* Proof of concept MIDI clock sync

* Hacky latency offset

* Stable MIDI sync

* Fix settings persistence for sync outputs

* Bump version to beta

* Commit changes to translations files

* Properly start/stop the sync and cleanup track graph

* Only send start message one time

* Add sync control in interval GUI

* Avoid too many pulses and add continue message

* Stop and continue each interval reset

* Bump beta version num

* Fix unusual auto generated file references

* Changes for Windows and plugin builds

* Revert version bump for PR

* Code style: clean up control flow spacing

* Refactor message sending (DRY output loop)

* Remove stop/continue messages on new interval

Co-authored-by: Michael Dewberry <michael.dewberry@gmail>

Author: ndonald2

PROJECTS/Jamtaba-common.pri

@@ -68,6 +68,7 @@ HEADERS += audio/vorbis/VorbisEncoder.h
 HEADERS += audio/RoomStreamerNode.h
 HEADERS += audio/NinjamTrackNode.h
 HEADERS += audio/MetronomeTrackNode.h
+HEADERS += audio/MidiSyncTrackNode.h
 HEADERS += audio/SamplesBufferResampler.h
 HEADERS += audio/SamplesBufferRecorder.h
 HEADERS += audio/Mp3Decoder.h
@@ -190,6 +191,7 @@ SOURCES += audio/core/Plugins.cpp
 SOURCES += audio/Mp3Decoder.cpp
 SOURCES += audio/NinjamTrackNode.cpp
 SOURCES += audio/MetronomeTrackNode.cpp
+SOURCES += audio/MidiSyncTrackNode.cpp
 SOURCES += audio/core/SamplesBuffer.cpp
 SOURCES += audio/core/PluginDescriptor.cpp
 SOURCES += audio/SamplesBufferResampler.cpp

src/Common/MainController.cpp

@@ -641,10 +641,11 @@ void MainController::storeWindowSettings(bool maximized, const QPointF &location
 }
 
 void MainController::storeIOSettings(int firstIn, int lastIn, int firstOut, int lastOut, QString audioInputDevice, QString audioOutputDevice,
-                                     const QList<bool> &midiInputsStatus)
+                                     const QList<bool> &midiInputsStatus, const QList<bool> &syncOutputsStatus)
 {
     settings.setAudioSettings(firstIn, lastIn, firstOut, lastOut, audioInputDevice, audioOutputDevice);
     settings.setMidiSettings(midiInputsStatus);
+    settings.setSyncSettings(syncOutputsStatus);
 }
 
 void MainController::storeIOSettings(int firstIn, int lastIn, int firstOut, int lastOut, QString audioInputDevice, QString audioOutputDevice)
@@ -653,7 +654,8 @@ void MainController::storeIOSettings(int firstIn, int lastIn, int firstOut, int
                 firstIn, lastIn,
                 firstOut, lastOut,
                 audioInputDevice, audioOutputDevice,
-                settings.getMidiInputDevicesStatus()
+                settings.getMidiInputDevicesStatus(),
+                settings.getSyncOutputDevicesStatus()
     );
 
 }

src/Common/MainController.h

@@ -210,7 +210,7 @@ class MainController : public QObject
     void storeWindowSettings(bool maximized, const QPointF &location, const QSize &size);
     void storeIOSettings(int firstIn, int lastIn, int firstOut, int lastOut,
                          QString audioInputDevice, QString audioOutputDevice,
-                         const QList<bool> &midiInputStatus);
+                         const QList<bool> &midiInputStatus, const QList<bool> &syncOutputsStatus);
 
     void storeIOSettings(int firstIn, int lastIn, int firstOut, int lastOut,
                          QString audioInputDevice, QString audioOutputDevice);
@@ -289,6 +289,12 @@ class MainController : public QObject
 
     void setAllLoopersStatus(bool activated);
 
+    // sync methods
+    virtual void startMidiClock() const = 0;
+    virtual void stopMidiClock() const = 0;
+    virtual void continueMidiClock() const = 0;
+    virtual void sendMidiClockPulse() const = 0;
+
     // collapse settings
     void setLocalChannelsCollapsed(bool collapsed);
     void setBottomSectionCollapsed(bool collapsed);

src/Common/NinjamController.cpp

@@ -13,6 +13,7 @@
 #include "file/FileReader.h"
 #include "audio/NinjamTrackNode.h"
 #include "audio/MetronomeTrackNode.h"
+#include "audio/MidiSyncTrackNode.h"
 #include "audio/Resampler.h"
 #include "audio/SamplesBufferRecorder.h"
 #include "audio/vorbis/VorbisEncoder.h"
@@ -235,6 +236,7 @@ NinjamController::NinjamController(controller::MainController *mainController) :
     samplesInInterval(0),
     mainController(mainController),
     metronomeTrackNode(createMetronomeTrackNode(mainController->getSampleRate())),
+    midiSyncTrackNode(new audio::MidiSyncTrackNode(mainController)),
     lastBeat(0),
     currentBpi(0),
     currentBpm(0),
@@ -264,6 +266,7 @@ void NinjamController::setBpm(int newBpm)
     currentBpm = newBpm;
     samplesInInterval = computeTotalSamplesInInterval();
     metronomeTrackNode->setSamplesPerBeat(getSamplesPerBeat());
+    midiSyncTrackNode->setPulseTiming(currentBpi * 24, getSamplesPerBeat()/24.0);
 
     emit currentBpmChanged(currentBpm);
 }
@@ -274,11 +277,21 @@ void NinjamController::setBpmBpi(int initialBpm, int initialBpi)
     currentBpm = initialBpm;
     samplesInInterval = computeTotalSamplesInInterval();
     metronomeTrackNode->setSamplesPerBeat(getSamplesPerBeat());
+    midiSyncTrackNode->setPulseTiming(currentBpi * 24, getSamplesPerBeat()/24.0);
 
     emit currentBpmChanged(currentBpm);
     emit currentBpiChanged(currentBpi);
 }
 
+void NinjamController::setSyncEnabled(bool enabled)
+{
+    if (enabled) {
+        midiSyncTrackNode->start();
+    } else {
+        midiSyncTrackNode->stop();
+    }
+}
+
 void NinjamController::removeEncoder(int groupChannelIndex)
 {
     QMutexLocker locker(&mutex);
@@ -326,6 +339,7 @@ void NinjamController::process(const audio::SamplesBuffer &in, audio::SamplesBuf
             handleNewInterval();
 
         metronomeTrackNode->setIntervalPosition(this->intervalPosition);
+        midiSyncTrackNode->setIntervalPosition(this->intervalPosition);
         int currentBeat = intervalPosition / getSamplesPerBeat();
         if (currentBeat != lastBeat)
         {
@@ -433,6 +447,10 @@ void NinjamController::stop(bool emitDisconnectedSignal)
     {
         this->running = false;
 
+        // stop midi sync track
+        this->midiSyncTrackNode->stop();
+        mainController->removeTrack(MIDI_SYNC_TRACK_ID);
+
         // store metronome settings
         auto metronomeTrack = mainController->getTrackNode(METRONOME_TRACK_ID);
         if (metronomeTrack)
@@ -553,6 +571,8 @@ void NinjamController::start(const ServerInfo &server)
         mainController->setTrackPan(METRONOME_TRACK_ID,
                                     mainController->getSettings().getMetronomePan());
 
+        mainController->addTrack(MIDI_SYNC_TRACK_ID, this->midiSyncTrackNode);
+
         this->intervalPosition = lastBeat = 0;
 
         auto ninjamService = mainController->getNinjamService();

src/Common/NinjamController.h

@@ -18,6 +18,7 @@ class UserChannel;
 
 namespace audio {
     class MetronomeTrackNode;
+    class MidiSyncTrackNode;
     class SamplesBuffer;
 }
 
@@ -30,6 +31,7 @@ using ninjam::client::User;
 using ninjam::client::UserChannel;
 using audio::SamplesBuffer;
 using audio::MetronomeTrackNode;
+using audio::MidiSyncTrackNode;
 
 class NinjamController : public QObject
 {
@@ -56,9 +58,12 @@ class NinjamController : public QObject
     void setBpm(int newBpm);
     void setBpmBpi(int initialBpm, int initalBpi);
 
+    void setSyncEnabled(bool enabled);
+
     void sendChatMessage(const QString &msg);
 
     static const long METRONOME_TRACK_ID = 123456789;     // just a number :)
+    static const long MIDI_SYNC_TRACK_ID = 1123581113;    // also just a number ;)
 
     void recreateEncoders();
 
@@ -123,6 +128,7 @@ class NinjamController : public QObject
     MainController *mainController;
 
     MetronomeTrackNode *metronomeTrackNode;
+    MidiSyncTrackNode *midiSyncTrackNode;
 
 private:
     static QString getUniqueKeyForChannel(const UserChannel &channel, const QString &userFullName);

src/Common/audio/MidiSyncTrackNode.cpp

@@ -0,0 +1,86 @@
+#include "MidiSyncTrackNode.h"
+#include "MainController.h"
+#include "MetronomeUtils.h"
+#include "audio/core/AudioDriver.h"
+#include <algorithm>
+
+using audio::MidiSyncTrackNode;
+using audio::SamplesBuffer;
+
+using namespace controller;
+
+MidiSyncTrackNode::MidiSyncTrackNode(MainController *controller) :
+    pulsesPerInterval(0),
+    samplesPerPulse(0),
+    intervalPosition(0),
+    currentPulse(0),
+    lastPlayedPulse(-1),
+    running(false),
+    hasSentStart(false),
+    mainController(controller)
+{
+    resetInterval();
+}
+
+MidiSyncTrackNode::~MidiSyncTrackNode()
+{
+}
+
+void MidiSyncTrackNode::setPulseTiming(long pulsesPerInterval, double samplesPerPulse)
+{
+    if (pulsesPerInterval <= 0 || samplesPerPulse <= 0)
+        qCritical() << "invalid sync timing params";
+
+    this->pulsesPerInterval = pulsesPerInterval;
+    this->samplesPerPulse = samplesPerPulse;
+    resetInterval();
+}
+
+void MidiSyncTrackNode::resetInterval()
+{
+    intervalPosition = 0;
+    lastPlayedPulse = -1;
+}
+
+void MidiSyncTrackNode::setIntervalPosition(long intervalPosition)
+{
+    if (samplesPerPulse <= 0)
+        return;
+
+    this->intervalPosition = intervalPosition;
+    this->currentPulse = ((double)intervalPosition / samplesPerPulse);
+}
+
+void MidiSyncTrackNode::start()
+{
+    running = true;
+}
+
+void MidiSyncTrackNode::stop()
+{
+    running = false;
+    hasSentStart = false;
+    mainController->stopMidiClock();
+}
+
+void MidiSyncTrackNode::processReplacing(const SamplesBuffer &in, SamplesBuffer &out,
+                                          int SampleRate, std::vector<midi::MidiMessage> &midiBuffer)
+{
+    if (pulsesPerInterval <= 0 || samplesPerPulse <= 0)
+        return;
+
+    if (currentPulse == 0 && currentPulse != lastPlayedPulse) {
+        if (running && !hasSentStart) {
+            mainController->startMidiClock();
+            hasSentStart = true;
+        }
+//        qDebug() << "Pulses played in interval: " << lastPlayedPulse;
+        lastPlayedPulse = -1;
+    }
+
+    while (currentPulse < pulsesPerInterval && currentPulse - lastPlayedPulse >= 1) {
+        mainController->sendMidiClockPulse();
+        lastPlayedPulse++;
+    }
+    AudioNode::processReplacing(in, out, SampleRate, midiBuffer);
+}

src/Common/audio/MidiSyncTrackNode.h

@@ -0,0 +1,43 @@
+#ifndef MIDISYNCTRACKNODE_H
+#define MIDISYNCTRACKNODE_H
+
+#include "core/AudioNode.h"
+
+namespace controller{
+    class MainController;
+}
+
+namespace audio {
+
+using controller::MainController;
+
+class MidiSyncTrackNode : public audio::AudioNode
+{
+
+public:
+    MidiSyncTrackNode(MainController *controller);
+
+    ~MidiSyncTrackNode();
+    void processReplacing(const SamplesBuffer &in, SamplesBuffer &out, int sampleRate, std::vector<midi::MidiMessage> &midiBuffer) override;
+    void setPulseTiming(long pulsesPerInterval, double samplesPerPulse);
+    void setIntervalPosition(long intervalPosition);
+    void resetInterval();
+
+    void start();
+    void stop();
+
+private:
+    long pulsesPerInterval;
+    double samplesPerPulse;
+    long intervalPosition;
+    int currentPulse;
+    int lastPlayedPulse;
+    bool running;
+    bool hasSentStart;
+
+    MainController *mainController;
+};
+
+} // namespace
+
+#endif // MIDISYNCTRACKNODE_H

src/Common/gui/NinjamPanel.cpp

@@ -141,6 +141,7 @@ void NinjamPanel::setupSignals()
     connect(ui->comboBpi, SIGNAL(activated(QString)), this, SLOT(handleBpiComboActication(QString)));
     connect(ui->comboBpm, SIGNAL(activated(QString)), this, SLOT(handleBpmComboActication(QString)));
 
+    connect(ui->checkboxSync, SIGNAL(clicked(bool)), this, SIGNAL(midiSyncChanged(bool)));
 }
 
 void NinjamPanel::handleBpiComboActication(const QString &newBpi)

src/Common/gui/NinjamPanel.h

@@ -71,6 +71,7 @@ class NinjamPanel : public QFrame
     void accentsBeatsChanged(const QList<int> &);
     void hostSyncStateChanged(bool syncWithHost);
     void intervalShapeChanged(int newShape);
+    void midiSyncChanged(bool syncOn);
 
 protected:
     void changeEvent(QEvent *) override;