feat: add looper effect with UI integration (#116)

* feat: add looper effect with UI integration

* feat: implement loop level smoothing for improved audio transitions

* fix(gui): constrain looper slider width

* test(looper): add pedal coverage

* fix(gui): avoid unnecessary horizontal scroll

* fix: correct cursor positioning in pedal board and remove progress bar text overlay

---------

Co-authored-by: Sudip Mondal <sudip.mondal@mando.work>

Author: ionfwsrijan

CMakeLists.txt

@@ -167,6 +167,7 @@ set(APP_SOURCES
     src/audio/effects/equalizer.cpp
     src/audio/effects/noise_gate.cpp
     src/audio/effects/compressor.cpp
+    src/audio/effects/looper.cpp
     src/audio/effects/cabinet_sim.cpp
     src/audio/effects/ir_cabinet.cpp
     src/audio/effects/amp_simulator.cpp
@@ -485,6 +486,7 @@ else() # NOT EMSCRIPTEN, ANDROID, or IOS
         tests/test_common.cpp
         tests/test_oboe_ring_buffer.cpp
         tests/test_effects.cpp
+        tests/test_looper.cpp
         tests/test_preset_manager.cpp
         tests/test_json_serialization.cpp
         tests/test_recorder.cpp
@@ -524,6 +526,7 @@ else() # NOT EMSCRIPTEN, ANDROID, or IOS
         src/audio/effects/equalizer.cpp
         src/audio/effects/noise_gate.cpp
         src/audio/effects/compressor.cpp
+        src/audio/effects/looper.cpp
         src/audio/effects/cabinet_sim.cpp
         src/audio/effects/ir_cabinet.cpp
         src/audio/effects/amp_simulator.cpp
@@ -601,4 +604,4 @@ else() # NOT EMSCRIPTEN, ANDROID, or IOS
     install(DIRECTORY presets DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/amplitron)
     install(DIRECTORY assets/fonts DESTINATION bin/assets)
 
-endif() # EMSCRIPTEN / ANDROID / IOS / desktop
+endif() # EMSCRIPTEN / ANDROID / IOS / desktop

src/audio/effects/looper.cpp

@@ -0,0 +1,241 @@
+#include "audio/effects/looper.h"
+#include "audio/effect_factory.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace Amplitron {
+
+static EffectRegistrar<Looper> reg("Looper");
+
+Looper::Looper() {
+    params_ = {
+        {"Loop Level", 0.80f, 0.0f, 1.0f, 0.80f, "", "Playback volume of the recorded loop mixed with live input."},
+        {"Crossfade",  5.0f,  0.0f, 20.0f, 5.0f,  "ms", "Crossfade length at the loop boundary to reduce clicks/pops."},
+    };
+    ensure_capacity();
+    const float sr = static_cast<float>(std::max(sample_rate_, 1));
+    loop_level_alpha_ = 1.0f - std::exp(-1.0f / (sr * kLoopLevelSmoothingSeconds));
+    reset();
+}
+
+void Looper::set_sample_rate(int sample_rate) {
+    Effect::set_sample_rate(sample_rate);
+    const float sr = static_cast<float>(std::max(sample_rate_, 1));
+    loop_level_alpha_ = 1.0f - std::exp(-1.0f / (sr * kLoopLevelSmoothingSeconds));
+    ensure_capacity();
+    reset();
+}
+
+void Looper::ensure_capacity() {
+    const int sr = std::max(sample_rate_, 1);
+    const int cap = std::max(sr * kMaxSeconds, 1);
+    if (cap == max_samples_) return;
+    max_samples_ = cap;
+    buffer_l_.assign(static_cast<size_t>(max_samples_), 0.0f);
+    buffer_r_.assign(static_cast<size_t>(max_samples_), 0.0f);
+}
+
+void Looper::reset() {
+    state_rt_ = State::Empty;
+    has_loop_rt_ = false;
+    record_pos_ = 0;
+    playhead_ = 0;
+    loop_length_ = 0;
+    loop_level_smoothed_ = clamp(params_[0].value, 0.0f, 1.0f);
+    pending_commands_.store(0, std::memory_order_relaxed);
+    publish_ui_snapshot();
+}
+
+void Looper::request_record_toggle() {
+    pending_commands_.fetch_or(CmdRecordToggle, std::memory_order_relaxed);
+}
+
+void Looper::request_play_toggle() {
+    pending_commands_.fetch_or(CmdPlayToggle, std::memory_order_relaxed);
+}
+
+void Looper::request_overdub_toggle() {
+    pending_commands_.fetch_or(CmdOverdubToggle, std::memory_order_relaxed);
+}
+
+void Looper::request_clear() {
+    pending_commands_.fetch_or(CmdClear, std::memory_order_relaxed);
+}
+
+int Looper::crossfade_samples_rt() const {
+    const float ms = params_[1].value;
+    const int xf = static_cast<int>(std::round((ms / 1000.0f) * static_cast<float>(sample_rate_)));
+    return std::clamp(xf, 0, std::max(loop_length_ / 2, 0));
+}
+
+void Looper::publish_ui_snapshot() {
+    ui_state_.store(static_cast<uint32_t>(state_rt_), std::memory_order_relaxed);
+    ui_has_loop_.store(has_loop_rt_ ? 1 : 0, std::memory_order_relaxed);
+    ui_loop_length_samples_.store(loop_length_, std::memory_order_relaxed);
+    ui_playhead_samples_.store(playhead_, std::memory_order_relaxed);
+}
+
+void Looper::clear_loop_rt() {
+    has_loop_rt_ = false;
+    loop_length_ = 0;
+    record_pos_ = 0;
+    playhead_ = 0;
+    state_rt_ = State::Empty;
+}
+
+void Looper::start_recording_rt() {
+    has_loop_rt_ = false;
+    loop_length_ = 0;
+    record_pos_ = 0;
+    playhead_ = 0;
+    state_rt_ = State::Recording;
+}
+
+void Looper::stop_recording_rt_and_play_rt() {
+    loop_length_ = std::clamp(record_pos_, 0, max_samples_);
+    const int min_len = static_cast<int>(std::round(kMinLoopSeconds * static_cast<float>(sample_rate_)));
+    if (loop_length_ < min_len) {
+        clear_loop_rt();
+        return;
+    }
+    has_loop_rt_ = true;
+    playhead_ = 0;
+    state_rt_ = State::Playing;
+}
+
+void Looper::toggle_play_rt() {
+    if (!has_loop_rt_) return;
+    if (state_rt_ == State::Playing || state_rt_ == State::Overdubbing) {
+        state_rt_ = State::Idle;
+    } else if (state_rt_ == State::Idle || state_rt_ == State::Empty) {
+        state_rt_ = State::Playing;
+    }
+}
+
+void Looper::toggle_overdub_rt() {
+    if (!has_loop_rt_) return;
+    if (state_rt_ == State::Overdubbing) {
+        state_rt_ = State::Playing;
+    } else if (state_rt_ == State::Playing) {
+        state_rt_ = State::Overdubbing;
+    } else if (state_rt_ == State::Idle) {
+        state_rt_ = State::Overdubbing;
+    }
+}
+
+void Looper::apply_pending_commands() {
+    const uint32_t cmds = pending_commands_.exchange(0, std::memory_order_relaxed);
+    if (cmds == 0) return;
+
+    if (cmds & CmdClear) {
+        clear_loop_rt();
+    }
+
+    if (cmds & CmdRecordToggle) {
+        if (state_rt_ == State::Recording) {
+            stop_recording_rt_and_play_rt();
+        } else {
+            start_recording_rt();
+        }
+    }
+
+    if (cmds & CmdPlayToggle) {
+        if (state_rt_ == State::Recording) {
+            stop_recording_rt_and_play_rt();
+        } else if (state_rt_ == State::Empty || state_rt_ == State::Idle ||
+                   state_rt_ == State::Playing || state_rt_ == State::Overdubbing) {
+            toggle_play_rt();
+        }
+    }
+
+    if (cmds & CmdOverdubToggle) {
+        if (state_rt_ != State::Recording) {
+            toggle_overdub_rt();
+        }
+    }
+}
+
+void Looper::process(float* buffer, int num_samples) {
+    if (!enabled_) return;
+    process_core(buffer, nullptr, num_samples, false);
+}
+
+void Looper::process_stereo(float* left, float* right, int num_samples) {
+    if (!enabled_) return;
+    process_core(left, right, num_samples, true);
+}
+
+void Looper::process_core(float* left, float* right, int num_samples, bool stereo) {
+    apply_pending_commands();
+
+    const float loop_level_target = clamp(params_[0].value, 0.0f, 1.0f);
+    const int cap = max_samples_;
+    if (cap <= 0) {
+        publish_ui_snapshot();
+        return;
+    }
+
+    if (state_rt_ == State::Recording) {
+        for (int i = 0; i < num_samples; ++i) {
+            if (record_pos_ >= cap) {
+                stop_recording_rt_and_play_rt();
+                break;
+            }
+            buffer_l_[record_pos_] = left[i];
+            if (stereo && right) buffer_r_[record_pos_] = right[i];
+            ++record_pos_;
+        }
+    }
+
+    if (has_loop_rt_ && loop_length_ > 0 &&
+        (state_rt_ == State::Playing || state_rt_ == State::Overdubbing)) {
+        const int xf = crossfade_samples_rt();
+        for (int i = 0; i < num_samples; ++i) {
+            loop_level_smoothed_ += loop_level_alpha_ * (loop_level_target - loop_level_smoothed_);
+            const float loop_level = loop_level_smoothed_;
+            const int pos = playhead_;
+            float loop_l = buffer_l_[pos];
+            float loop_r = (stereo && right) ? buffer_r_[pos] : loop_l;
+
+            if (xf > 0 && pos >= loop_length_ - xf) {
+                const int t = pos - (loop_length_ - xf); // 0..xf-1
+                const float w_end = static_cast<float>(xf - t) / static_cast<float>(xf);
+                const float w_start = 1.0f - w_end;
+                const int start_pos = t;
+                loop_l = buffer_l_[pos] * w_end + buffer_l_[start_pos] * w_start;
+                if (stereo && right) {
+                    loop_r = buffer_r_[pos] * w_end + buffer_r_[start_pos] * w_start;
+                } else {
+                    loop_r = loop_l;
+                }
+            }
+
+            const float in_l = left[i];
+            const float in_r = (stereo && right) ? right[i] : in_l;
+
+            float out_l = in_l + loop_l * loop_level;
+            float out_r = in_r + loop_r * loop_level;
+
+            if (state_rt_ == State::Overdubbing) {
+                buffer_l_[pos] = soft_clip(buffer_l_[pos] + in_l);
+                if (stereo && right) {
+                    buffer_r_[pos] = soft_clip(buffer_r_[pos] + in_r);
+                }
+            }
+
+            left[i] = soft_clip(out_l);
+            if (stereo && right) right[i] = soft_clip(out_r);
+
+            ++playhead_;
+            if (playhead_ >= loop_length_) playhead_ = 0;
+        }
+    } else {
+        // Keep smoothing responsive even when not actively mixing the loop.
+        loop_level_smoothed_ += loop_level_alpha_ * (loop_level_target - loop_level_smoothed_);
+    }
+
+    publish_ui_snapshot();
+}
+
+} // namespace Amplitron

src/audio/effects/looper.h

@@ -0,0 +1,109 @@
+#pragma once
+
+#include "audio/effect.h"
+
+#include <atomic>
+#include <cmath>
+#include <cstdint>
+#include <vector>
+
+namespace Amplitron {
+
+/**
+ * A simple in-chain looper (record / play / overdub / clear).
+ *
+ * Design goals:
+ * - No allocations inside process/process_stereo (buffer is preallocated).
+ * - Thread-safe UI visibility for state and loop position via atomics.
+ * - Minimal, predictable state machine for practice workflows.
+ */
+class Looper : public Effect {
+public:
+    enum class State : uint32_t {
+        Empty = 0, // no loop in memory
+        Idle,      // loop exists but not playing
+        Recording,
+        Playing,
+        Overdubbing,
+    };
+
+    Looper();
+
+    void process(float* buffer, int num_samples) override;
+    void process_stereo(float* left, float* right, int num_samples) override;
+    void set_sample_rate(int sample_rate) override;
+    void reset() override;
+    const char* name() const override { return "Looper"; }
+    std::vector<EffectParam>& params() override { return params_; }
+
+    // --- UI control (thread-safe) ---
+    void request_record_toggle();
+    void request_play_toggle();
+    void request_overdub_toggle();
+    void request_clear();
+
+    // --- UI status snapshot (thread-safe) ---
+    State state() const { return static_cast<State>(ui_state_.load(std::memory_order_relaxed)); }
+    bool has_loop() const { return ui_has_loop_.load(std::memory_order_relaxed) != 0; }
+    int loop_length_samples() const { return ui_loop_length_samples_.load(std::memory_order_relaxed); }
+    int playhead_samples() const { return ui_playhead_samples_.load(std::memory_order_relaxed); }
+
+private:
+    static constexpr int kMaxSeconds = 60;
+    static constexpr float kMinLoopSeconds = 0.10f;
+    static constexpr float kLoopLevelSmoothingSeconds = 0.02f;
+
+    enum CommandBits : uint32_t {
+        CmdRecordToggle  = 1u << 0,
+        CmdPlayToggle    = 1u << 1,
+        CmdOverdubToggle = 1u << 2,
+        CmdClear         = 1u << 3,
+    };
+
+    // Params (saved in presets): loop playback level + crossfade length.
+    std::vector<EffectParam> params_;
+
+    // Preallocated buffers (full capacity, mono or stereo).
+    std::vector<float> buffer_l_;
+    std::vector<float> buffer_r_;
+    int max_samples_ = 0;
+
+    // Audio-thread state (not atomic; only touched in process/process_stereo).
+    State state_rt_ = State::Empty;
+    bool has_loop_rt_ = false;
+    int record_pos_ = 0;
+    int playhead_ = 0;
+    int loop_length_ = 0;
+
+    float loop_level_smoothed_ = 0.80f;
+    float loop_level_alpha_ = 0.0f;
+
+    // UI-visible atomics (written from audio thread, read by GUI thread).
+    std::atomic<uint32_t> ui_state_{static_cast<uint32_t>(State::Empty)};
+    std::atomic<int> ui_has_loop_{0};
+    std::atomic<int> ui_loop_length_samples_{0};
+    std::atomic<int> ui_playhead_samples_{0};
+
+    // UI -> audio thread command mailbox (bitmask).
+    std::atomic<uint32_t> pending_commands_{0};
+
+    // Helpers
+    void ensure_capacity();
+    void apply_pending_commands();
+    void publish_ui_snapshot();
+    void clear_loop_rt();
+    void start_recording_rt();
+    void stop_recording_rt_and_play_rt();
+    void toggle_play_rt();
+    void toggle_overdub_rt();
+
+    static inline float soft_clip(float x) {
+        const float ax = std::fabs(x);
+        return x / (1.0f + ax);
+    }
+
+    inline int crossfade_samples_rt() const;
+    inline void process_core(float* left, float* right, int num_samples, bool stereo);
+};
+
+} // namespace Amplitron