Implement random modulation for MIDI CC automations

juzzlin · juzzlin · commit 15af83b9cca2 · 2026-03-19T23:47:15.000+02:00
diff --git a/CHANGELOG b/CHANGELOG
@@ -7,6 +7,8 @@ New features:
 
 * Apply track cut/copy/paste also for MIDI CC and PB automations
 
+* Implement Random modulation for MIDI CC automations
+
 Bug fixes:
 
 Other:
diff --git a/src/application/models/midi_cc_automations_model.cpp b/src/application/models/midi_cc_automations_model.cpp
@@ -146,6 +146,8 @@ QVariant MidiCcAutomationsModel::data(const QModelIndex & index, int role) const
             return midiCcAutomation.modulation().offset;
         case DataRole::Modulation_Sine_Inverted:
             return midiCcAutomation.modulation().inverted;
+        case DataRole::Modulation_Type:
+            return static_cast<int>(midiCcAutomation.modulation().type);
         case DataRole::EventsPerBeat:
             return static_cast<quint64>(midiCcAutomation.eventsPerBeat() > 0 ? midiCcAutomation.eventsPerBeat() : m_linesPerBeat);
         case DataRole::LineOffset:
@@ -244,6 +246,14 @@ bool MidiCcAutomationsModel::setData(const QModelIndex & index, const QVariant &
                 changed = true;
             }
         } break;
+        case DataRole::Modulation_Type: {
+            auto modulation = midiCcAutomation.modulation();
+            if (const auto newType = static_cast<MidiCcAutomation::ModulationParameters::ModulationType>(value.toInt()); modulation.type != newType) {
+                modulation.type = newType;
+                midiCcAutomation.setModulation(modulation);
+                changed = true;
+            }
+        } break;
         case DataRole::EventsPerBeat: {
             const auto newEventsPerBeat = static_cast<uint8_t>(value.toUInt());
             const auto targetValue = newEventsPerBeat == m_linesPerBeat ? 0 : newEventsPerBeat;
@@ -313,6 +323,7 @@ QHash<int, QByteArray> MidiCcAutomationsModel::roleNames() const
         { static_cast<int>(DataRole::Modulation_Sine_Amplitude), "modulationSineAmplitude" },
         { static_cast<int>(DataRole::Modulation_Sine_Offset), "modulationSineOffset" },
         { static_cast<int>(DataRole::Modulation_Sine_Inverted), "modulationSineInverted" },
+        { static_cast<int>(DataRole::Modulation_Type), "modulationType" },
         { static_cast<int>(DataRole::EventsPerBeat), "eventsPerBeat" },
         { static_cast<int>(DataRole::LineOffset), "lineOffset" }
     };
@@ -348,7 +359,7 @@ void MidiCcAutomationsModel::applyAll()
 void MidiCcAutomationsModel::changeController(int index, quint8 controller)
 {
     if (index >= 0 && static_cast<size_t>(index) < m_midiCcAutomations.size()) {
-        auto& midiCcAutomation = m_midiCcAutomations[static_cast<size_t>(index)];
+        auto && midiCcAutomation = m_midiCcAutomations[static_cast<size_t>(index)];
         if (midiCcAutomation.controller() != controller) {
             midiCcAutomation.setController(controller);
             m_midiCcAutomationsChanged.erase(midiCcAutomation);
@@ -359,4 +370,20 @@ void MidiCcAutomationsModel::changeController(int index, quint8 controller)
     }
 }
 
+void MidiCcAutomationsModel::changeModulationType(int index, int type)
+{
+    if (index >= 0 && static_cast<size_t>(index) < m_midiCcAutomations.size()) {
+        auto && midiCcAutomation = m_midiCcAutomations[static_cast<size_t>(index)];
+        auto modulation = midiCcAutomation.modulation();
+        if (static_cast<int>(modulation.type) != type) {
+            modulation.type = static_cast<MidiCcAutomation::ModulationParameters::ModulationType>(type);
+            midiCcAutomation.setModulation(modulation);
+            m_midiCcAutomationsChanged.erase(midiCcAutomation);
+            m_midiCcAutomationsChanged.insert(midiCcAutomation);
+            emit dataChanged(this->index(index), this->index(index), { static_cast<int>(DataRole::Modulation_Type) });
+            juzzlin::L(TAG).info() << "MIDI CC automation modulation type changed via invokable: " << midiCcAutomation.toString().toStdString();
+        }
+    }
+}
+
 } // namespace noteahead
diff --git a/src/application/models/midi_cc_automations_model.hpp b/src/application/models/midi_cc_automations_model.hpp
@@ -49,6 +49,7 @@ class MidiCcAutomationsModel : public QAbstractListModel
         Modulation_Sine_Amplitude,
         Modulation_Sine_Offset,
         Modulation_Sine_Inverted,
+        Modulation_Type,
         EventsPerBeat,
         LineOffset
     };
@@ -75,6 +76,7 @@ class MidiCcAutomationsModel : public QAbstractListModel
 
     Q_INVOKABLE void applyAll();
     Q_INVOKABLE void changeController(int index, quint8 controller);
+    Q_INVOKABLE void changeModulationType(int index, int type);
 
 signals:
     void midiCcAutomationChanged(const MidiCcAutomation & midiCcAutomation);
diff --git a/src/application/service/automation_service.cpp b/src/application/service/automation_service.cpp
@@ -24,6 +24,7 @@
 
 #include <algorithm>
 #include <cmath> // For std::sin and M_PI
+#include <random>
 #include <ranges>
 
 #include <QXmlStreamReader>
@@ -76,13 +77,13 @@ void AutomationService::addMidiCcAutomationWithId(const MidiCcAutomation & autom
     juzzlin::L(TAG).info() << "MIDI CC Automation added (with ID): " << automation.toString().toStdString();
 }
 
-void AutomationService::addMidiCcModulation(quint64 automationId, quint64 cycles, float amplitude, float offset, bool inverted)
+void AutomationService::addMidiCcModulation(quint64 automationId, int type, quint64 cycles, float amplitude, float offset, bool inverted)
 {
     if (const auto iter = std::ranges::find_if(m_automations.midiCc, [&](auto && existingAutomation) {
             return automationId == existingAutomation.id();
         });
         iter != m_automations.midiCc.end()) {
-        MidiCcAutomation::ModulationParameters modulation { static_cast<float>(cycles), amplitude, offset, inverted };
+        MidiCcAutomation::ModulationParameters modulation { static_cast<MidiCcAutomation::ModulationParameters::ModulationType>(type), static_cast<float>(cycles), amplitude, offset, inverted };
         iter->setModulation(modulation);
         notifyChangedLines(*iter);
         juzzlin::L(TAG).info() << "MIDI CC Modulation added to automation id " << automationId;
@@ -388,10 +389,15 @@ AutomationService::EventList AutomationService::renderMidiCcToEventsByLine(size_
                 double interpolatedValue = interpolator.getValue(static_cast<size_t>(line));
 
                 double totalModulation = 0.0;
-                if (modulation.cycles > 0.f && modulation.amplitude > 0.f) {
+                if (modulation.cycles > 0.f || modulation.amplitude > 0.f) {
                     const double phase = interpolation.line1 > interpolation.line0 ? static_cast<double>(line - interpolation.line0) / (static_cast<double>(interpolation.line1 - interpolation.line0)) : 0;
-                    const double sineWave = (modulation.inverted ? -1 : 1) * std::sin(phase * modulation.cycles * 2 * M_PI);
-                    totalModulation = sineWave * modulation.amplitude / 100.0; // Amplitude is a percentage
+                    double modulationValue = 0.0;
+                    if (modulation.type == MidiCcAutomation::ModulationParameters::ModulationType::SineWave) {
+                        modulationValue = sineModulationValue(modulation, phase);
+                    } else if (modulation.type == MidiCcAutomation::ModulationParameters::ModulationType::Random) {
+                        modulationValue = randomModulationValue(automation.id(), modulation, phase);
+                    }
+                    totalModulation = modulationValue * modulation.amplitude / 100.0; // Amplitude is a percentage
                 }
                 totalModulation += modulation.offset / 100.0;
                 interpolatedValue += interpolatedValue * totalModulation;
@@ -405,6 +411,22 @@ AutomationService::EventList AutomationService::renderMidiCcToEventsByLine(size_
     return events;
 }
 
+double AutomationService::sineModulationValue(const MidiCcAutomation::ModulationParameters & modulation, double phase) const
+{
+    return (modulation.inverted ? -1 : 1) * std::sin(phase * modulation.cycles * 2 * M_PI);
+}
+
+double AutomationService::randomModulationValue(size_t automationId, const MidiCcAutomation::ModulationParameters & modulation, double phase) const
+{
+    const int sampleIndex = static_cast<int>(std::floor(phase * modulation.cycles));
+    if (sampleIndex < modulation.cycles) {
+        std::mt19937 gen(static_cast<uint32_t>(automationId + sampleIndex));
+        std::uniform_real_distribution<double> dist(-1.0, 1.0);
+        return (modulation.inverted ? -1 : 1) * dist(gen);
+    }
+    return 0.0; // Return to 0
+}
+
 AutomationService::EventList AutomationService::renderPitchBendToEventsByLine(size_t pattern, size_t track, size_t column, size_t line, size_t tick) const
 {
     EventList events;
@@ -484,8 +506,13 @@ AutomationService::EventList AutomationService::renderMidiCcToEventsByColumn(siz
                     double totalModulation = 0.0;
                     if (modulation.cycles > 0.f || modulation.amplitude > 0.f) {
                         const double phase = interpolation.line1 > interpolation.line0 ? static_cast<double>(line - interpolation.line0) / (static_cast<double>(interpolation.line1 - interpolation.line0)) : 0;
-                        const double sineWave = (modulation.inverted ? -1 : 1) * std::sin(phase * modulation.cycles * 2 * M_PI);
-                        totalModulation = sineWave * modulation.amplitude / 100.0;
+                        double modulationValue = 0.0;
+                        if (modulation.type == MidiCcAutomation::ModulationParameters::ModulationType::SineWave) {
+                            modulationValue = sineModulationValue(modulation, phase);
+                        } else if (modulation.type == MidiCcAutomation::ModulationParameters::ModulationType::Random) {
+                            modulationValue = randomModulationValue(automation.id(), modulation, phase);
+                        }
+                        totalModulation = modulationValue * modulation.amplitude / 100.0;
                     }
                     totalModulation += modulation.offset / 100.0;
                     interpolatedValue += interpolatedValue * totalModulation;
diff --git a/src/application/service/automation_service.hpp b/src/application/service/automation_service.hpp
@@ -53,7 +53,7 @@ class AutomationService : public QObject
     Q_INVOKABLE quint64 addMidiCcAutomation(quint64 pattern, quint64 track, quint64 column, quint8 controller, quint64 line0, quint64 line1, quint8 value0, quint8 value1, QString comment, quint8 eventsPerBeat, quint8 lineOffset);
     quint64 addMidiCcAutomation(const MidiCcAutomation & automation);
     void addMidiCcAutomationWithId(const MidiCcAutomation & automation);
-    Q_INVOKABLE void addMidiCcModulation(quint64 automationId, quint64 cycles, float amplitude, float offset, bool inverted);
+    Q_INVOKABLE void addMidiCcModulation(quint64 automationId, int type, quint64 cycles, float amplitude, float offset, bool inverted);
 
     //! Adds automation for MIDI pitch bend.
     //! \param value0 Start value from -100% to +100%.
@@ -111,6 +111,9 @@ public slots:
     EventList renderMidiCcToEventsByColumn(size_t pattern, size_t track, size_t column, size_t tick, size_t ticksPerLine, size_t linesPerBeat) const;
     EventList renderPitchBendToEventsByColumn(size_t pattern, size_t track, size_t column, size_t tick, size_t ticksPerLine) const;
 
+    double sineModulationValue(const MidiCcAutomation::ModulationParameters & modulation, double phase) const;
+    double randomModulationValue(size_t automationId, const MidiCcAutomation::ModulationParameters & modulation, double phase) const;
+
     struct Automations
     {
         MidiCcAutomationList midiCc;
diff --git a/src/common/constants.cpp b/src/common/constants.cpp
@@ -604,6 +604,16 @@ QString xmlValueTrue()
     return "true";
 }
 
+QString xmlValueSineWave()
+{
+    return "SineWave";
+}
+
+QString xmlValueRandom()
+{
+    return "Random";
+}
+
 } // namespace NahdXml
 
 } // namespace noteahead::Constants
diff --git a/src/common/constants.hpp b/src/common/constants.hpp
@@ -182,6 +182,8 @@ QString xmlKeySideChainSettings();
 
 QString xmlValueFalse();
 QString xmlValueTrue();
+QString xmlValueSineWave();
+QString xmlValueRandom();
 
 } // namespace NahdXml
 } // namespace noteahead::Constants
diff --git a/src/domain/midi_cc_automation.cpp b/src/domain/midi_cc_automation.cpp
@@ -154,6 +154,7 @@ void MidiCcAutomation::serializeToXml(QXmlStreamWriter & writer) const
 
     if (m_modulation.cycles > 0.f || m_modulation.amplitude > 0.f || m_modulation.offset != 0.f) {
         writer.writeStartElement(Constants::NahdXml::xmlKeyModulation());
+        writer.writeAttribute(Constants::NahdXml::xmlKeyType(), m_modulation.type == ModulationParameters::ModulationType::SineWave ? Constants::NahdXml::xmlValueSineWave() : Constants::NahdXml::xmlValueRandom());
         writer.writeAttribute(Constants::NahdXml::xmlKeyCycles(), QString::number(static_cast<int>(m_modulation.cycles)));
         writer.writeAttribute(Constants::NahdXml::xmlKeyAmplitude(), QString::number(static_cast<int>(m_modulation.amplitude)));
         writer.writeAttribute(Constants::NahdXml::xmlKeyOffset(), QString::number(static_cast<int>(m_modulation.offset)));
@@ -188,6 +189,16 @@ MidiCcAutomation::MidiCcAutomationU MidiCcAutomation::deserializeFromXml(QXmlStr
                 interpolationParameters.value1 = static_cast<quint8>(attributes.value(Constants::NahdXml::xmlKeyValue1()).toUInt());
             } else if (!reader.name().compare(Constants::NahdXml::xmlKeyModulation())) {
                 const auto attributes = reader.attributes();
+                if (attributes.hasAttribute(Constants::NahdXml::xmlKeyType())) {
+                    const auto type = attributes.value(Constants::NahdXml::xmlKeyType());
+                    if (!type.compare(Constants::NahdXml::xmlValueRandom())) {
+                        modulationParameters.type = ModulationParameters::ModulationType::Random;
+                    } else {
+                        modulationParameters.type = ModulationParameters::ModulationType::SineWave;
+                    }
+                } else {
+                    modulationParameters.type = ModulationParameters::ModulationType::SineWave;
+                }
                 modulationParameters.cycles = static_cast<float>(attributes.value(Constants::NahdXml::xmlKeyCycles()).toInt());
                 modulationParameters.amplitude = static_cast<float>(attributes.value(Constants::NahdXml::xmlKeyAmplitude()).toInt());
                 modulationParameters.offset = static_cast<float>(attributes.value(Constants::NahdXml::xmlKeyOffset()).toInt());
diff --git a/src/domain/midi_cc_automation.hpp b/src/domain/midi_cc_automation.hpp
@@ -49,14 +49,21 @@ class MidiCcAutomation : public Automation
 
     struct ModulationParameters
     {
+        enum class ModulationType
+        {
+            SineWave,
+            Random
+        };
+
+        ModulationType type = ModulationType::SineWave;
         float cycles = 0.f;
         float amplitude = 0.f;
         float offset = 0.f;
         bool inverted = false;
 
         bool operator==(const ModulationParameters & other) const
         {
-            return cycles == other.cycles && amplitude == other.amplitude && offset == other.offset && inverted == other.inverted;
+            return type == other.type && cycles == other.cycles && amplitude == other.amplitude && offset == other.offset && inverted == other.inverted;
         }
 
         bool operator!=(const ModulationParameters & other) const
diff --git a/src/unit_tests/automation_service_test/automation_service_test.cpp b/src/unit_tests/automation_service_test/automation_service_test.cpp
@@ -267,7 +267,7 @@ void AutomationServiceTest::test_renderMidiCcToEventsByLine_withModulation_shoul
     quint8 value0 = 64;
     quint8 value1 = 64;
     const auto automationId = automationService.addMidiCcAutomation(pattern, track, column, controller, line0, line1, value0, value1, {}, true, 8, 0);
-    automationService.addMidiCcModulation(automationId, 1, 50.0f, 0.0f, false);
+    automationService.addMidiCcModulation(automationId, 0, 1, 50.0f, 0.0f, false);
 
     const auto tick = 0;
     // Line 0: Base 64, Phase 0, Sine 0, Modulation 0
@@ -282,6 +282,39 @@ void AutomationServiceTest::test_renderMidiCcToEventsByLine_withModulation_shoul
     QCOMPARE(automationService.renderToEventsByLine(pattern, track, column, 4, tick).at(0)->midiCcData()->value(), 64);
 }
 
+void AutomationServiceTest::test_renderMidiCcToEventsByLine_withRandomModulation_shouldRenderModulatedEvents()
+{
+    AutomationService automationService;
+
+    quint64 pattern = 0;
+    quint64 track = 1;
+    quint64 column = 2;
+    quint8 controller = 64;
+    quint8 line0 = 0;
+    quint8 line1 = 4;
+    quint8 value0 = 64;
+    quint8 value1 = 64;
+    // ID will be 1
+    const auto automationId = automationService.addMidiCcAutomation(pattern, track, column, controller, line0, line1, value0, value1, {}, true, 8, 0);
+    // Type 1 = Random, 1 cycle, 100% amplitude
+    automationService.addMidiCcModulation(automationId, 1, 1, 100.0f, 0.0f, false);
+
+    const auto tick = 0;
+    // For automationId = 1 and sampleIndex = 0, std::mt19937 seeded with 1:
+    // first value from dist(-1, 1) is roughly -0.131538
+    // value = 64 + 64 * (-0.131538) = 64 - 8.4 = 55.6 -> 56
+    const auto val0 = automationService.renderToEventsByLine(pattern, track, column, 0, tick).at(0)->midiCcData()->value();
+    QVERIFY(val0 != 64);
+
+    // Should stay same for line 1, 2, 3 (within same cycle)
+    QCOMPARE(automationService.renderToEventsByLine(pattern, track, column, 1, tick).at(0)->midiCcData()->value(), val0);
+    QCOMPARE(automationService.renderToEventsByLine(pattern, track, column, 2, tick).at(0)->midiCcData()->value(), val0);
+    QCOMPARE(automationService.renderToEventsByLine(pattern, track, column, 3, tick).at(0)->midiCcData()->value(), val0);
+
+    // Return to 0 at the end (line 4, phase 1.0)
+    QCOMPARE(automationService.renderToEventsByLine(pattern, track, column, 4, tick).at(0)->midiCcData()->value(), 64);
+}
+
 void AutomationServiceTest::test_renderMidiCcToEventsByLine_withInvertedModulation_shouldRenderModulatedEvents()
 {
     AutomationService automationService;
@@ -295,7 +328,7 @@ void AutomationServiceTest::test_renderMidiCcToEventsByLine_withInvertedModulati
     quint8 value0 = 64;
     quint8 value1 = 64;
     const auto automationId = automationService.addMidiCcAutomation(pattern, track, column, controller, line0, line1, value0, value1, {}, true, 8, 0);
-    automationService.addMidiCcModulation(automationId, 1, 50.0f, 0.0f, true);
+    automationService.addMidiCcModulation(automationId, 0, 1, 50.0f, 0.0f, true);
 
     const auto tick = 0;
     // Line 0: Base 64, Phase 0, Sine 0, Modulation 0
@@ -325,13 +358,13 @@ void AutomationServiceTest::test_renderMidiCcToEventsByLine_withOffset_shouldRen
     const auto automationId = automationService.addMidiCcAutomation(pattern, track, column, controller, line0, line1, value0, value1, {}, true, 8, 0);
 
     // Test positive offset (+50%)
-    automationService.addMidiCcModulation(automationId, 0, 0.0f, 50.0f, false);
+    automationService.addMidiCcModulation(automationId, 0, 0, 0.0f, 50.0f, false);
     const auto tick = 0;
     // 64 + 64 * 0.5 = 96
     QCOMPARE(automationService.renderToEventsByLine(pattern, track, column, 0, tick).at(0)->midiCcData()->value(), 96);
 
     // Test negative offset (-50%)
-    automationService.addMidiCcModulation(automationId, 0, 0.0f, -50.0f, false);
+    automationService.addMidiCcModulation(automationId, 0, 0, 0.0f, -50.0f, false);
     // 64 + 64 * -0.5 = 32
     QCOMPARE(automationService.renderToEventsByLine(pattern, track, column, 0, tick).at(0)->midiCcData()->value(), 32);
 }
diff --git a/src/unit_tests/automation_service_test/automation_service_test.hpp b/src/unit_tests/automation_service_test/automation_service_test.hpp
@@ -40,6 +40,7 @@ private slots:
     void test_renderToEventsByLine_shouldRenderToEvents();
     void test_renderToEventsByLine_disableAutomation_shouldNotRenderEvents();
     void test_renderMidiCcToEventsByLine_withModulation_shouldRenderModulatedEvents();
+    void test_renderMidiCcToEventsByLine_withRandomModulation_shouldRenderModulatedEvents();
     void test_renderMidiCcToEventsByLine_withInvertedModulation_shouldRenderModulatedEvents();
     void test_renderMidiCcToEventsByLine_withOffset_shouldRenderOffsetEvents();
     void test_renderMidiCcToEventsByColumn_withEventsPerBeatAndLineOffset_shouldSkipEvents();
diff --git a/src/unit_tests/editor_service_test/editor_service_test.cpp b/src/unit_tests/editor_service_test/editor_service_test.cpp
@@ -1741,7 +1741,7 @@ void EditorServiceTest::test_toXmlFromXml_automationService_midiCc_withModulatio
 {
     AutomationService automationServiceOut;
     const auto automationId = automationServiceOut.addMidiCcAutomation(0, 0, 0, 0, 0, 1, 0, 1, {}, true, 8, 0);
-    automationServiceOut.addMidiCcModulation(automationId, 1, 50.0f, 0.0f, true);
+    automationServiceOut.addMidiCcModulation(automationId, 0, 1, 50.0f, 0.0f, true);
 
     AutomationService automationServiceIn;
     EditorService editorService;
diff --git a/src/unit_tests/midi_cc_automations_model_test/midi_cc_automations_model_test.cpp b/src/unit_tests/midi_cc_automations_model_test/midi_cc_automations_model_test.cpp
diff --git a/src/unit_tests/midi_cc_automations_model_test/midi_cc_automations_model_test.hpp b/src/unit_tests/midi_cc_automations_model_test/midi_cc_automations_model_test.hpp
diff --git a/src/view/qml/Dialogs/AddMidiCcAutomationDialog.qml b/src/view/qml/Dialogs/AddMidiCcAutomationDialog.qml
diff --git a/src/view/qml/Dialogs/EditMidiCcAutomationsDelegate.qml b/src/view/qml/Dialogs/EditMidiCcAutomationsDelegate.qml
diff --git a/src/view/qml/Dialogs/MidiCcAutomationModel.qml b/src/view/qml/Dialogs/MidiCcAutomationModel.qml
diff --git a/src/view/qml/Main.qml b/src/view/qml/Main.qml
