Extend chord automation with an arpeggiator

Author: juzzlin

CHANGELOG

@@ -8,6 +8,8 @@ New features:
 * Implement the concept of a 'drum track'
   - Drum tracks are not transposed by pattern => transpose
 
+* Extend chord automation with an arpeggiator
+
 Bug fixes:
 
 Other:

README.md

@@ -88,6 +88,10 @@ All Arctic Music Project songs:
   - Linear, Sine wave, and Random modulation (since 1.8.0+)
 - Chord automation (since 1.2.0)
   - In Column Settings the user can set offsets for three notes that are relative to the root note
+- Arpeggiator (since 1.9.0)
+  - Extend chord automation with an arpeggiator
+  - Patterns: Up, Down, Up-Down, Down-Up, Random
+  - Adjustable events per beat (1-32)
 - Step record / play notes via a MIDI controller (since 0.10.0)
   - The MIDI controller is routed to the instrument of the selected track
 - Highly adjustable note-off's (global default in ms, per-instrument in ms, manual)

src/CMakeLists.txt

@@ -54,6 +54,7 @@ set(HEADER_FILES
   common/utils.hpp
   domain/automation.hpp
   domain/automation_location.hpp
+  domain/arpeggiator.hpp
   domain/column.hpp
   domain/column_settings.hpp
   domain/event.hpp
@@ -147,6 +148,7 @@ set(SOURCE_FILES
   common/utils.cpp
   domain/automation.cpp
   domain/automation_location.cpp
+  domain/arpeggiator.cpp
   domain/column.cpp
   domain/column_settings.cpp
   domain/event.cpp

src/application/models/column_settings_model.cpp

@@ -43,6 +43,10 @@ void ColumnSettingsModel::reset()
     emit chordNote3OffsetChanged();
     emit chordNote3VelocityChanged();
     emit chordNote3DelayChanged();
+
+    emit arpeggiatorEnabledChanged();
+    emit arpeggiatorPatternChanged();
+    emit arpeggiatorEventsPerBeatChanged();
 }
 
 void ColumnSettingsModel::requestData()
@@ -63,6 +67,10 @@ void ColumnSettingsModel::setColumnSettings(const ColumnSettings & settings)
     const bool note3VelocityChanged = m_settings.chordAutomationSettings.note3.velocity != settings.chordAutomationSettings.note3.velocity;
     const bool note3DelayChanged = m_settings.chordAutomationSettings.note3.delay != settings.chordAutomationSettings.note3.delay;
 
+    const bool arpeggiatorEnabledChanged = m_settings.chordAutomationSettings.arpeggiator.enabled != settings.chordAutomationSettings.arpeggiator.enabled;
+    const bool arpeggiatorPatternChanged = m_settings.chordAutomationSettings.arpeggiator.pattern != settings.chordAutomationSettings.arpeggiator.pattern;
+    const bool arpeggiatorEventsPerBeatChanged = m_settings.chordAutomationSettings.arpeggiator.eventsPerBeat != settings.chordAutomationSettings.arpeggiator.eventsPerBeat;
+
     m_settings = settings;
 
     if (delayChanged) {
@@ -96,6 +104,16 @@ void ColumnSettingsModel::setColumnSettings(const ColumnSettings & settings)
         emit chordNote3DelayChanged();
     }
 
+    if (arpeggiatorEnabledChanged) {
+        emit this->arpeggiatorEnabledChanged();
+    }
+    if (arpeggiatorPatternChanged) {
+        emit this->arpeggiatorPatternChanged();
+    }
+    if (arpeggiatorEventsPerBeatChanged) {
+        emit this->arpeggiatorEventsPerBeatChanged();
+    }
+
     emit dataReceived();
 }
 
@@ -255,4 +273,43 @@ void ColumnSettingsModel::setChordNote3Delay(qint16 delay)
     }
 }
 
+bool ColumnSettingsModel::arpeggiatorEnabled() const
+{
+    return m_settings.chordAutomationSettings.arpeggiator.enabled;
+}
+
+void ColumnSettingsModel::setArpeggiatorEnabled(bool enabled)
+{
+    if (m_settings.chordAutomationSettings.arpeggiator.enabled != enabled) {
+        m_settings.chordAutomationSettings.arpeggiator.enabled = enabled;
+        emit arpeggiatorEnabledChanged();
+    }
+}
+
+int ColumnSettingsModel::arpeggiatorPattern() const
+{
+    return static_cast<int>(m_settings.chordAutomationSettings.arpeggiator.pattern);
+}
+
+void ColumnSettingsModel::setArpeggiatorPattern(int pattern)
+{
+    if (static_cast<int>(m_settings.chordAutomationSettings.arpeggiator.pattern) != pattern) {
+        m_settings.chordAutomationSettings.arpeggiator.pattern = static_cast<Arpeggiator::Pattern>(pattern);
+        emit arpeggiatorPatternChanged();
+    }
+}
+
+uint8_t ColumnSettingsModel::arpeggiatorEventsPerBeat() const
+{
+    return m_settings.chordAutomationSettings.arpeggiator.eventsPerBeat;
+}
+
+void ColumnSettingsModel::setArpeggiatorEventsPerBeat(uint8_t eventsPerBeat)
+{
+    if (m_settings.chordAutomationSettings.arpeggiator.eventsPerBeat != eventsPerBeat) {
+        m_settings.chordAutomationSettings.arpeggiator.eventsPerBeat = eventsPerBeat;
+        emit arpeggiatorEventsPerBeatChanged();
+    }
+}
+
 } // namespace noteahead

src/application/models/column_settings_model.hpp

@@ -41,6 +41,10 @@ class ColumnSettingsModel : public QObject
     Q_PROPERTY(quint8 chordNote3Velocity READ chordNote3Velocity WRITE setChordNote3Velocity NOTIFY chordNote3VelocityChanged)
     Q_PROPERTY(qint16 chordNote3Delay READ chordNote3Delay WRITE setChordNote3Delay NOTIFY chordNote3DelayChanged)
 
+    Q_PROPERTY(bool arpeggiatorEnabled READ arpeggiatorEnabled WRITE setArpeggiatorEnabled NOTIFY arpeggiatorEnabledChanged)
+    Q_PROPERTY(int arpeggiatorPattern READ arpeggiatorPattern WRITE setArpeggiatorPattern NOTIFY arpeggiatorPatternChanged)
+    Q_PROPERTY(uint8_t arpeggiatorEventsPerBeat READ arpeggiatorEventsPerBeat WRITE setArpeggiatorEventsPerBeat NOTIFY arpeggiatorEventsPerBeatChanged)
+
 public:
     explicit ColumnSettingsModel(QObject * parent = nullptr);
     ~ColumnSettingsModel() override;
@@ -87,6 +91,15 @@ class ColumnSettingsModel : public QObject
     qint16 chordNote3Delay() const;
     void setChordNote3Delay(qint16 delay);
 
+    bool arpeggiatorEnabled() const;
+    void setArpeggiatorEnabled(bool enabled);
+
+    int arpeggiatorPattern() const;
+    void setArpeggiatorPattern(int pattern);
+
+    uint8_t arpeggiatorEventsPerBeat() const;
+    void setArpeggiatorEventsPerBeat(uint8_t eventsPerBeat);
+
 signals:
     void dataRequested();
     void dataReceived();
@@ -106,6 +119,10 @@ class ColumnSettingsModel : public QObject
     void chordNote3VelocityChanged();
     void chordNote3DelayChanged();
 
+    void arpeggiatorEnabledChanged();
+    void arpeggiatorPatternChanged();
+    void arpeggiatorEventsPerBeatChanged();
+
     void saveRequested(quint64 trackIndex, quint64 columnIndex, const ColumnSettings & settings);
 
 private:

src/common/constants.cpp

@@ -189,6 +189,21 @@ QString xmlKeyChordNote3Delay()
     return "chordNote3Delay";
 }
 
+QString xmlKeyArpeggiatorEnabled()
+{
+    return "arpeggiatorEnabled";
+}
+
+QString xmlKeyArpeggiatorPattern()
+{
+    return "arpeggiatorPattern";
+}
+
+QString xmlKeyArpeggiatorEventsPerBeat()
+{
+    return "arpeggiatorEventsPerBeat";
+}
+
 QString xmlKeyController()
 {
     return "controller";

src/common/constants.hpp

@@ -68,6 +68,9 @@ QString xmlKeyChordNote2Delay();
 QString xmlKeyChordNote3Offset();
 QString xmlKeyChordNote3Velocity();
 QString xmlKeyChordNote3Delay();
+QString xmlKeyArpeggiatorEnabled();
+QString xmlKeyArpeggiatorPattern();
+QString xmlKeyArpeggiatorEventsPerBeat();
 
 QString xmlKeyController();
 QString xmlKeyEnabled();

src/domain/arpeggiator.cpp

@@ -0,0 +1,69 @@
+// This file is part of Noteahead.
+// Copyright (C) 2026 Jussi Lind <jussi.lind@iki.fi>
+//
+// Noteahead 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 3 of the License, or
+// (at your option) any later version.
+// Noteahead 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 Noteahead. If not, see <http://www.gnu.org/licenses/>.
+
+#include "arpeggiator.hpp"
+
+#include "../application/service/random_service.hpp"
+
+#include <algorithm>
+
+namespace noteahead {
+
+Arpeggiator::NoteInfoList Arpeggiator::generate(Pattern pattern, const NoteInfoList & inputNotes)
+{
+    if (inputNotes.empty()) {
+        return {};
+    }
+
+    NoteInfoList uniqueNotes = inputNotes;
+    std::sort(uniqueNotes.begin(), uniqueNotes.end(), [](auto && a, auto && b) {
+        return a.note < b.note;
+    });
+    uniqueNotes.erase(std::unique(uniqueNotes.begin(), uniqueNotes.end(), [](auto && a, auto && b) {
+        return a.note == b.note;
+    }), uniqueNotes.end());
+
+    NoteInfoList arpeggioSequence;
+    switch (pattern) {
+    case Pattern::Up:
+        arpeggioSequence = uniqueNotes;
+        break;
+    case Pattern::Down:
+        arpeggioSequence = uniqueNotes;
+        std::reverse(arpeggioSequence.begin(), arpeggioSequence.end());
+        break;
+    case Pattern::UpDown:
+        arpeggioSequence = uniqueNotes;
+        for (int i = static_cast<int>(uniqueNotes.size()) - 2; i > 0; i--) {
+            arpeggioSequence.push_back(uniqueNotes[static_cast<size_t>(i)]);
+        }
+        break;
+    case Pattern::DownUp:
+        arpeggioSequence = uniqueNotes;
+        std::reverse(arpeggioSequence.begin(), arpeggioSequence.end());
+        for (size_t i = 1; i < uniqueNotes.size() - 1; i++) {
+            arpeggioSequence.push_back(uniqueNotes[i]);
+        }
+        break;
+    case Pattern::Random:
+        arpeggioSequence = uniqueNotes;
+        std::shuffle(arpeggioSequence.begin(), arpeggioSequence.end(), RandomService::generator());
+        break;
+    }
+
+    return arpeggioSequence;
+}
+
+} // namespace noteahead

src/domain/arpeggiator.hpp

@@ -0,0 +1,55 @@
+// This file is part of Noteahead.
+// Copyright (C) 2026 Jussi Lind <jussi.lind@iki.fi>
+//
+// Noteahead 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 3 of the License, or
+// (at your option) any later version.
+// Noteahead 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 Noteahead. If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef ARPEGGIATOR_HPP
+#define ARPEGGIATOR_HPP
+
+#include <cstdint>
+#include <vector>
+
+namespace noteahead {
+
+class Arpeggiator
+{
+public:
+    enum class Pattern
+    {
+        Up,
+        Down,
+        UpDown,
+        DownUp,
+        Random
+    };
+
+    struct Settings
+    {
+        bool enabled = false;
+        Pattern pattern = Pattern::Up;
+        uint8_t eventsPerBeat = 4;
+    };
+
+    struct NoteInfo
+    {
+        uint8_t note = 0;
+        uint8_t velocity = 0;
+    };
+
+    using NoteInfoList = std::vector<NoteInfo>;
+    static NoteInfoList generate(Pattern pattern, const NoteInfoList & inputNotes);
+};
+
+} // namespace noteahead
+
+#endif // ARPEGGIATOR_HPP

src/domain/column_settings.cpp

@@ -46,7 +46,11 @@ void ColumnSettings::serializeToXml(QXmlStreamWriter & writer) const
     writer.writeAttribute(Constants::NahdXml::xmlKeyChordNote3Velocity(), QString::number(chordAutomationSettings.note3.velocity));
     writer.writeAttribute(Constants::NahdXml::xmlKeyChordNote3Delay(), QString::number(chordAutomationSettings.note3.delay));
 
-    writer.writeEndElement();
+    writer.writeAttribute(Constants::NahdXml::xmlKeyArpeggiatorEnabled(), chordAutomationSettings.arpeggiator.enabled ? Constants::NahdXml::xmlValueTrue() : Constants::NahdXml::xmlValueFalse());
+    writer.writeAttribute(Constants::NahdXml::xmlKeyArpeggiatorPattern(), QString::number(static_cast<int>(chordAutomationSettings.arpeggiator.pattern)));
+    writer.writeAttribute(Constants::NahdXml::xmlKeyArpeggiatorEventsPerBeat(), QString::number(chordAutomationSettings.arpeggiator.eventsPerBeat));
+
+    writer.writeEndElement(); // ColumnSettings
 }
 
 ColumnSettings::ColumnSettingsU ColumnSettings::deserializeFromXml(QXmlStreamReader & reader)
@@ -67,6 +71,10 @@ ColumnSettings::ColumnSettingsU ColumnSettings::deserializeFromXml(QXmlStreamRea
     settings->chordAutomationSettings.note3.velocity = Utils::Xml::readUIntAttribute(reader, Constants::NahdXml::xmlKeyChordNote3Velocity(), false).value_or(100);
     settings->chordAutomationSettings.note3.delay = Utils::Xml::readIntAttribute(reader, Constants::NahdXml::xmlKeyChordNote3Delay(), false).value_or(0);
 
+    settings->chordAutomationSettings.arpeggiator.enabled = Utils::Xml::readBoolAttribute(reader, Constants::NahdXml::xmlKeyArpeggiatorEnabled(), false).value_or(false);
+    settings->chordAutomationSettings.arpeggiator.pattern = static_cast<Arpeggiator::Pattern>(Utils::Xml::readIntAttribute(reader, Constants::NahdXml::xmlKeyArpeggiatorPattern(), false).value_or(0));
+    settings->chordAutomationSettings.arpeggiator.eventsPerBeat = static_cast<uint8_t>(Utils::Xml::readUIntAttribute(reader, Constants::NahdXml::xmlKeyArpeggiatorEventsPerBeat(), false).value_or(4));
+
     return settings;
 }