From 5e687d38324b9f71b9c67bf0b7fad7f3ece009d1 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 21:44:17 +0200
Subject: [PATCH 01/26] chore: update libDaisy to v8.1.0

---
 .github/workflows/firmware.yaml     |  2 +-
 .vscode/tasks.json                  |  8 ---
 firmware/CMakeLists.txt             | 73 +++++++++---------------
 firmware/src/hardware/UiHardware.h  | 88 ++++++++++++++---------------
 firmware/tests/libDaisyCombined.cpp |  4 +-
 lib/libDaisy                        |  2 +-
 6 files changed, 77 insertions(+), 100 deletions(-)

diff --git a/.github/workflows/firmware.yaml b/.github/workflows/firmware.yaml
index 3512b08..ee92679 100644
--- a/.github/workflows/firmware.yaml
+++ b/.github/workflows/firmware.yaml
@@ -37,7 +37,7 @@ jobs:
         submodules: recursive
 
     - name: Configure
-      run: cmake -S firmware -B firmware/build -G "Unix Makefiles" -D CMAKE_TOOLCHAIN_FILE="$(pwd)/lib/libDaisy/cmake/toolchains/stm32h750xx.cmake" -D CMAKE_BUILD_TYPE=RelWithDebInfo -D TOOLCHAIN_PREFIX=$(which arm-none-eabi-gcc | sed -e "s/bin\/arm-none-eabi-gcc//")
+      run: cmake -S firmware -B firmware/build -G "Unix Makefiles" -D CMAKE_BUILD_TYPE=RelWithDebInfo -D TOOLCHAIN_PREFIX=$(which arm-none-eabi-gcc | sed -e "s/bin\/arm-none-eabi-gcc//")
 
     - name: Build
       run: cmake --build firmware/build
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 8b75eb1..3ac0b10 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -19,8 +19,6 @@
                 "-D",
                 "TOOLCHAIN_PREFIX=\"${env:HOME}/dev/gcc-arm-none-eabi-9-2020-q2-update\"",
                 "-D",
-                "CMAKE_TOOLCHAIN_FILE=\"${workspaceRoot}/lib/libDaisy/cmake/toolchains/stm32h750xx.cmake\"",
-                "-D",
                 "CMAKE_BUILD_TYPE=RelWithDebInfo",
                 "-S",
                 "firmware",
@@ -40,8 +38,6 @@
                     "-D",
                     "TOOLCHAIN_PREFIX=\\\"C:/Program Files (x86)/GNU Arm Embedded Toolchain/9 2020-q2-update\\\"",
                     "-D",
-                    "CMAKE_TOOLCHAIN_FILE=\\\"${workspaceRoot}/lib/libDaisy/cmake/toolchains/stm32h750xx.cmake\\\"",
-                    "-D",
                     "CMAKE_BUILD_TYPE=RelWithDebInfo",
                     "-S",
                     "firmware",
@@ -66,8 +62,6 @@
                 "-D",
                 "TOOLCHAIN_PREFIX=\"${env:HOME}/dev/gcc-arm-none-eabi-9-2020-q2-update\"",
                 "-D",
-                "CMAKE_TOOLCHAIN_FILE=\"${workspaceRoot}/lib/libDaisy/cmake/toolchains/stm32h750xx.cmake\"",
-                "-D",
                 "CMAKE_BUILD_TYPE=Debug",
                 "-S",
                 "firmware",
@@ -87,8 +81,6 @@
                     "-D",
                     "TOOLCHAIN_PREFIX=\\\"C:/Program Files (x86)/GNU Arm Embedded Toolchain/9 2020-q2-update\\\"",
                     "-D",
-                    "CMAKE_TOOLCHAIN_FILE=\\\"${workspaceRoot}/lib/libDaisy/cmake/toolchains/stm32h750xx.cmake\\\"",
-                    "-D",
                     "CMAKE_BUILD_TYPE=Debug",
                     "-S",
                     "firmware",
diff --git a/firmware/CMakeLists.txt b/firmware/CMakeLists.txt
index 255a826..39fa292 100644
--- a/firmware/CMakeLists.txt
+++ b/firmware/CMakeLists.txt
@@ -1,9 +1,27 @@
-cmake_policy(SET CMP0048 NEW)
-project(TapeLooper)
-cmake_minimum_required(VERSION 3.19)
 
-set(FIRMWARE_NAME TapeLooper)
+cmake_minimum_required(VERSION 3.30)
+
+if(WIN32)
+    set(TOOLCHAIN_EXT ".exe")
+else()
+    set(TOOLCHAIN_EXT "")
+endif()
+
+set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}/bin/arm-none-eabi-gcc${TOOLCHAIN_EXT})
+set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}/bin/arm-none-eabi-g++${TOOLCHAIN_EXT})
+
+if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
+    include(${CMAKE_CURRENT_LIST_DIR}/../lib/libDaisy/cmake/toolchains/ArmGNUToolchain.cmake)
+    #include(${CMAKE_CURRENT_LIST_DIR}/../lib/libDaisy/cmake/toolchains/autodetect.cmake)
+endif()
+
+project(TapeLoope)
+
+if(COMMAND cmake_policy)
+  cmake_policy(SET CMP0003 NEW)
+endif(COMMAND cmake_policy)
 
+set(FIRMWARE_NAME TapeLooper)
 set(FIRMWARE_SOURCES
     src/main.cpp
 )
@@ -12,16 +30,13 @@ set(FIRMWARE_SOURCES
 add_subdirectory(../dsp libTapeLooperDsp)
 
 # include libDaisy
-set(LIBDAISY_DIR ../lib/libDaisy)
-add_subdirectory(${LIBDAISY_DIR} libDaisy)
+add_subdirectory(../lib/libDaisy daisy)
 
-# linker script
-get_filename_component(LIBDAISY_DIR_ABS "${LIBDAISY_DIR}"
-                       REALPATH BASE_DIR "${CMAKE_SOURCE_DIR}")
-set(LINKER_SCRIPT ${LIBDAISY_DIR_ABS}/core/STM32H750IB_flash.lds)
+cmake_path(SET LOCAL_CMAKE_PATH "../lib/libDaisy/cmake")
+cmake_path(ABSOLUTE_PATH LOCAL_CMAKE_PATH)
 
-# firmware binary image
-add_executable(${FIRMWARE_NAME} ${FIRMWARE_SOURCES})
+list(APPEND CMAKE_MODULE_PATH ${LOCAL_CMAKE_PATH})
+include(DaisyProject)
 
 target_link_libraries(${FIRMWARE_NAME}
   PRIVATE
@@ -32,36 +47,4 @@ target_link_libraries(${FIRMWARE_NAME}
 set_target_properties(${FIRMWARE_NAME} PROPERTIES
     CXX_STANDARD 17
     CXX_STANDARD_REQUIRED YES
-    SUFFIX ".elf"
-    LINK_DEPENDS ${LINKER_SCRIPT}
-)
-
-target_link_options(${FIRMWARE_NAME} PUBLIC
-    -T ${LINKER_SCRIPT}
-    -Wl,-Map=${FIRMWARE_NAME}.map,--cref
-    -Wl,--check-sections
-    -Wl,--unresolved-symbols=report-all
-    -Wl,--warn-common
-    -Wl,--warn-section-align
-    -Wl,--print-memory-usage
-)
-
-add_custom_command(TARGET ${FIRMWARE_NAME} POST_BUILD
-    COMMAND ${CMAKE_OBJCOPY}
-    ARGS -O ihex
-    -S ${FIRMWARE_NAME}.elf
-    ${FIRMWARE_NAME}.hex
-    BYPRODUCTS
-    ${FIRMWARE_NAME}.hex
-    COMMENT "Generating HEX image"
-VERBATIM)
-
-add_custom_command(TARGET ${FIRMWARE_NAME} POST_BUILD
-    COMMAND ${CMAKE_OBJCOPY}
-    ARGS -O binary
-    -S ${FIRMWARE_NAME}.elf
-    ${FIRMWARE_NAME}.bin
-    BYPRODUCTS
-    ${FIRMWARE_NAME}.bin
-    COMMENT "Generating binary image"
-VERBATIM)
+)
\ No newline at end of file
diff --git a/firmware/src/hardware/UiHardware.h b/firmware/src/hardware/UiHardware.h
index 7b6e1f2..41c5670 100644
--- a/firmware/src/hardware/UiHardware.h
+++ b/firmware/src/hardware/UiHardware.h
@@ -40,11 +40,11 @@ class ButtonReader
         dmaBuffer_ = dmaBuffer;
 
         // shift register for the channel buttons
-        shiftRegisterLoadPin_.pin = { DSY_GPIOA, 4 };
-        shiftRegisterLoadPin_.mode = DSY_GPIO_MODE_OUTPUT_PP;
-        shiftRegisterLoadPin_.pull = DSY_GPIO_NOPULL;
-        dsy_gpio_init(&shiftRegisterLoadPin_);
-        dsy_gpio_write(&shiftRegisterLoadPin_, 1);
+        shiftRegisterLoadPin_.Init({ daisy::GPIOPort::PORTA, 4 },
+                                   daisy::GPIO::Mode::OUTPUT,
+                                   daisy::GPIO::Pull::NOPULL,
+                                   daisy::GPIO::Speed::MEDIUM);
+        shiftRegisterLoadPin_.Write(true);
 
         daisy::SpiHandle::Config config;
         config.periph = daisy::SpiHandle::Config::Peripheral::SPI_1;
@@ -55,27 +55,27 @@ class ButtonReader
         config.clock_phase = daisy::SpiHandle::Config::ClockPhase::ONE_EDGE;
         config.nss = daisy::SpiHandle::Config::NSS::SOFT;
         config.baud_prescaler = daisy::SpiHandle::Config::BaudPrescaler::PS_16;
-        config.pin_config.sclk = { DSY_GPIOA, 5 };
-        config.pin_config.miso = { DSY_GPIOG, 9 };
+        config.pin_config.sclk = { daisy::GPIOPort::PORTA, 5 };
+        config.pin_config.miso = { daisy::GPIOPort::PORTG, 9 };
         shiftRegisterSpi_.Init(config);
 
         // common section buttons
-        commonGpios_.settings.pin = { DSY_GPIOB, 7 };
-        commonGpios_.settings.mode = DSY_GPIO_MODE_INPUT;
-        commonGpios_.settings.pull = DSY_GPIO_NOPULL;
-        dsy_gpio_init(&commonGpios_.settings);
-        commonGpios_.save.pin = { DSY_GPIOG, 11 };
-        commonGpios_.save.mode = DSY_GPIO_MODE_INPUT;
-        commonGpios_.save.pull = DSY_GPIO_NOPULL;
-        dsy_gpio_init(&commonGpios_.save);
-        commonGpios_.load.pin = { DSY_GPIOG, 10 };
-        commonGpios_.load.mode = DSY_GPIO_MODE_INPUT;
-        commonGpios_.load.pull = DSY_GPIO_NOPULL;
-        dsy_gpio_init(&commonGpios_.load);
-        commonGpios_.rec.pin = { DSY_GPIOB, 12 };
-        commonGpios_.rec.mode = DSY_GPIO_MODE_INPUT;
-        commonGpios_.rec.pull = DSY_GPIO_NOPULL;
-        dsy_gpio_init(&commonGpios_.rec);
+        commonGpios_.settings.Init({ daisy::GPIOPort::PORTB, 7 },
+                                   daisy::GPIO::Mode::INPUT,
+                                   daisy::GPIO::Pull::NOPULL,
+                                   daisy::GPIO::Speed::LOW);
+        commonGpios_.save.Init({ daisy::GPIOPort::PORTG, 11 },
+                               daisy::GPIO::Mode::INPUT,
+                               daisy::GPIO::Pull::NOPULL,
+                               daisy::GPIO::Speed::LOW);
+        commonGpios_.load.Init({ daisy::GPIOPort::PORTG, 10 },
+                               daisy::GPIO::Mode::INPUT,
+                               daisy::GPIO::Pull::NOPULL,
+                               daisy::GPIO::Speed::LOW);
+        commonGpios_.rec.Init({ daisy::GPIOPort::PORTB, 12 },
+                              daisy::GPIO::Mode::INPUT,
+                              daisy::GPIO::Pull::NOPULL,
+                              daisy::GPIO::Speed::LOW);
     }
 
     bool getButtonState(Button buttonId) const
@@ -84,13 +84,13 @@ class ButtonReader
         switch (buttonId)
         {
             case Button::save:
-                return !dsy_gpio_read(&commonGpios_.save);
+                return !const_cast<daisy::GPIO*>(&commonGpios_.save)->Read();
             case Button::load:
-                return !dsy_gpio_read(&commonGpios_.load);
+                return !const_cast<daisy::GPIO*>(&commonGpios_.load)->Read();
             case Button::settings:
-                return !dsy_gpio_read(&commonGpios_.settings);
+                return !const_cast<daisy::GPIO*>(&commonGpios_.settings)->Read();
             case Button::record:
-                return !dsy_gpio_read(&commonGpios_.rec);
+                return !const_cast<daisy::GPIO*>(&commonGpios_.rec)->Read();
             case Button::chA_play:
                 return !getBit<2>();
             case Button::chA_up:
@@ -123,12 +123,12 @@ class ButtonReader
 
     void triggerReadout()
     {
-        dsy_gpio_write(&shiftRegisterLoadPin_, 0);
+        shiftRegisterLoadPin_.Write(false);
 
         constexpr auto kNumBytes = 2;
         shiftRegisterSpi_.DmaReceive((uint8_t*) dmaBuffer_, kNumBytes, nullptr, nullptr, nullptr);
 
-        dsy_gpio_write(&shiftRegisterLoadPin_, 1);
+        shiftRegisterLoadPin_.Write(true);
     }
 
 private:
@@ -140,15 +140,15 @@ class ButtonReader
 
     struct
     {
-        dsy_gpio settings;
-        dsy_gpio save;
-        dsy_gpio load;
-        dsy_gpio rec;
+        daisy::GPIO settings;
+        daisy::GPIO save;
+        daisy::GPIO load;
+        daisy::GPIO rec;
     } commonGpios_;
 
     uint16_t* dmaBuffer_ = nullptr;
     daisy::SpiHandle shiftRegisterSpi_;
-    dsy_gpio shiftRegisterLoadPin_;
+    daisy::GPIO shiftRegisterLoadPin_;
 };
 
 class KnobAndCvReader
@@ -163,18 +163,18 @@ class KnobAndCvReader
     {
         calibrationStorage_.Init(getDefaultCalibrationData(), kCalibrationDataOffset);
 
-        const dsy_gpio_pin mux0 = { DSY_GPIOA, 1 };
-        const dsy_gpio_pin mux1 = { DSY_GPIOA, 0 };
-        const dsy_gpio_pin mux2 = { DSY_GPIOD, 11 };
+        const daisy::Pin mux0 = { daisy::GPIOPort::PORTA, 1 };
+        const daisy::Pin mux1 = { daisy::GPIOPort::PORTA, 0 };
+        const daisy::Pin mux2 = { daisy::GPIOPort::PORTD, 11 };
 
         constexpr auto kNumChannelsPerAdc = 7;
         constexpr auto kNumAdcs = 4;
 
         daisy::AdcChannelConfig channelConfigs[kNumAdcs];
-        channelConfigs[0].InitMux({ DSY_GPIOC, 0 }, kNumChannelsPerAdc, mux0, mux1, mux2);
-        channelConfigs[1].InitMux({ DSY_GPIOA, 3 }, kNumChannelsPerAdc, mux0, mux1, mux2);
-        channelConfigs[2].InitMux({ DSY_GPIOB, 1 }, kNumChannelsPerAdc, mux0, mux1, mux2);
-        channelConfigs[3].InitMux({ DSY_GPIOA, 7 }, kNumChannelsPerAdc, mux0, mux1, mux2);
+        channelConfigs[0].InitMux({ daisy::GPIOPort::PORTC, 0 }, kNumChannelsPerAdc, mux0, mux1, mux2);
+        channelConfigs[1].InitMux({ daisy::GPIOPort::PORTA, 3 }, kNumChannelsPerAdc, mux0, mux1, mux2);
+        channelConfigs[2].InitMux({ daisy::GPIOPort::PORTB, 1 }, kNumChannelsPerAdc, mux0, mux1, mux2);
+        channelConfigs[3].InitMux({ daisy::GPIOPort::PORTA, 7 }, kNumChannelsPerAdc, mux0, mux1, mux2);
 
         adc_.Init(channelConfigs, kNumAdcs);
         adc_.Start();
@@ -423,13 +423,13 @@ class UiHardware
         daisy::I2CHandle i2c;
         daisy::I2CHandle::Config i2cCfg;
         i2cCfg.periph = daisy::I2CHandle::Config::Peripheral::I2C_1;
-        i2cCfg.pin_config.sda = { DSY_GPIOB, 9 };
-        i2cCfg.pin_config.scl = { DSY_GPIOB, 8 };
+        i2cCfg.pin_config.sda = { daisy::GPIOPort::PORTB, 9 };
+        i2cCfg.pin_config.scl = { daisy::GPIOPort::PORTB, 8 };
         i2cCfg.speed = daisy::I2CHandle::Config::Speed::I2C_400KHZ;
         i2cCfg.mode = daisy::I2CHandle::Config::Mode::I2C_MASTER;
         i2c.Init(i2cCfg);
 
-        ledDriver_.Init(i2c, { 0b00, 0b01, 0b10 }, bufferA, bufferB, { DSY_GPIOB, 6 });
+        ledDriver_.Init(i2c, { 0b00, 0b01, 0b10 }, bufferA, bufferB, { daisy::GPIOPort::PORTB, 6 });
     }
 
     void updateLedBrightnessValues()
diff --git a/firmware/tests/libDaisyCombined.cpp b/firmware/tests/libDaisyCombined.cpp
index 1f590a7..7f88597 100644
--- a/firmware/tests/libDaisyCombined.cpp
+++ b/firmware/tests/libDaisyCombined.cpp
@@ -1,4 +1,6 @@
 // include unit-testable code from libDaisy
 // which is required for some of the integration tests
 // that use the daisy::UI class.
-#include <../tests/libDaisyCombined.cpp>
+
+#include <sys/system.cpp>
+#include <ui/UI.cpp>
diff --git a/lib/libDaisy b/lib/libDaisy
index 8d106a2..9498417 160000
--- a/lib/libDaisy
+++ b/lib/libDaisy
@@ -1 +1 @@
-Subproject commit 8d106a2c822f687bcb8c86bed0b6f2c22f680999
+Subproject commit 9498417add4a4c76bc10737d5e9f43750a4da639

From 8780bca8654bc8ed29203d65de4072b2114b3868 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Thu, 5 Sep 2024 08:27:59 +0200
Subject: [PATCH 02/26] chore: update gcc-arm-none-eabi to version
 10-2020-q4-major

---
 .github/workflows/firmware.yaml | 2 +-
 .vscode/launch.json             | 4 ++--
 .vscode/tasks.json              | 8 ++++----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/firmware.yaml b/.github/workflows/firmware.yaml
index ee92679..c403fb0 100644
--- a/.github/workflows/firmware.yaml
+++ b/.github/workflows/firmware.yaml
@@ -24,7 +24,7 @@ jobs:
     - name: Install arm-none-eabi-gcc
       uses: fiam/arm-none-eabi-gcc@v1
       with:
-        release: '9-2019-q4' # The arm-none-eabi-gcc release to use.
+        release: '10-2020-q4' # The arm-none-eabi-gcc release to use.
 
     - name: Setup cmake
       uses: jwlawson/actions-setup-cmake@v1.9
diff --git a/.vscode/launch.json b/.vscode/launch.json
index b1df9b1..5a824f1 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -34,12 +34,12 @@
             },
             "linux": {
                 "MIMode": "gdb",
-                "MIDebuggerPath": "~/dev/gcc-arm-none-eabi-9-2020-q2-update/bin/arm-none-eabi-gdb",
+                "MIDebuggerPath": "~/dev/gcc-arm-none-eabi-10-2020-q4-major/bin/arm-none-eabi-gdb",
                 "debugServerPath": "openocd"
             },
             "osx": {
                 "MIMode": "gdb",
-                "MIDebuggerPath": "/Users/johanneselliesen/dev/gcc-arm-none-eabi-9-2020-q2-update/bin/arm-none-eabi-gdb",
+                "MIDebuggerPath": "/Users/johanneselliesen/dev/gcc-arm-none-eabi-10-2020-q4-major/bin/arm-none-eabi-gdb",
                 "debugServerPath": "openocd"
             },
             "windows": {
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 3ac0b10..ef65058 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -17,7 +17,7 @@
             "command": "cmake",
             "args": [
                 "-D",
-                "TOOLCHAIN_PREFIX=\"${env:HOME}/dev/gcc-arm-none-eabi-9-2020-q2-update\"",
+                "TOOLCHAIN_PREFIX=\"${env:HOME}/dev/gcc-arm-none-eabi-10-2020-q4-major\"",
                 "-D",
                 "CMAKE_BUILD_TYPE=RelWithDebInfo",
                 "-S",
@@ -36,7 +36,7 @@
                 "command": "cmake.exe",
                 "args": [
                     "-D",
-                    "TOOLCHAIN_PREFIX=\\\"C:/Program Files (x86)/GNU Arm Embedded Toolchain/9 2020-q2-update\\\"",
+                    "TOOLCHAIN_PREFIX=\\\"C:/Program Files (x86)/GNU Arm Embedded Toolchain/10 2020-q4-major\\\"",
                     "-D",
                     "CMAKE_BUILD_TYPE=RelWithDebInfo",
                     "-S",
@@ -60,7 +60,7 @@
             "command": "cmake",
             "args": [
                 "-D",
-                "TOOLCHAIN_PREFIX=\"${env:HOME}/dev/gcc-arm-none-eabi-9-2020-q2-update\"",
+                "TOOLCHAIN_PREFIX=\"${env:HOME}/dev/gcc-arm-none-eabi-10-2020-q4-major\"",
                 "-D",
                 "CMAKE_BUILD_TYPE=Debug",
                 "-S",
@@ -79,7 +79,7 @@
                 "command": "cmake.exe",
                 "args": [
                     "-D",
-                    "TOOLCHAIN_PREFIX=\\\"C:/Program Files (x86)/GNU Arm Embedded Toolchain/9 2020-q2-update\\\"",
+                    "TOOLCHAIN_PREFIX=\\\"C:/Program Files (x86)/GNU Arm Embedded Toolchain/10 2020-q4-major\\\"",
                     "-D",
                     "CMAKE_BUILD_TYPE=Debug",
                     "-S",

From 0d0b47dadc87e4ca4f27c4e7a57b949307df5f6c Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Sat, 10 Aug 2024 08:40:50 +0200
Subject: [PATCH 03/26] feat: allow to abort a recording immediately

this will be used when we want to restore a sample
from storage while a recording is running
---
 dsp/src/dsp/Recorder.h       |  9 +++++++++
 dsp/tests/Recorder_gtest.cpp | 35 ++++++++++++++++++++++++++++++++---
 2 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/dsp/src/dsp/Recorder.h b/dsp/src/dsp/Recorder.h
index 6645163..feb4479 100644
--- a/dsp/src/dsp/Recorder.h
+++ b/dsp/src/dsp/Recorder.h
@@ -62,6 +62,15 @@ class Recorder
         recHeadIdx_ = 0;
     }
 
+    void stopRecordingImmediately()
+    {
+        isRecording_ = false;
+        isFadingOut_ = false;
+        xfadePhase_ = 0.0f;
+        currentLength_ = recHeadIdx_;
+        recHeadIdx_ = 0;
+    }
+
     void setCrossfadeLength(size_t crossfadeLengthInSamples)
     {
         xFadeLengthInSamples_ = std::min(crossfadeLengthInSamples, buffer_.size_);
diff --git a/dsp/tests/Recorder_gtest.cpp b/dsp/tests/Recorder_gtest.cpp
index 068822e..c93b42c 100644
--- a/dsp/tests/Recorder_gtest.cpp
+++ b/dsp/tests/Recorder_gtest.cpp
@@ -97,12 +97,15 @@ TEST_F(DSP_Recorder, b_recordAndStop)
         {
             xfade += xFadeIncrement_;
             const float expectedSample = xfade * inputSequence_[ch][i]
-                                         + (1.0f - xfade) * inputSequence_[ch][i + expectedTotalNumSamples];
-            EXPECT_NEAR(expectedSample, storage_[ch][i], absError_) << "at i=" << i;
+                                         + (1.0f - xfade)
+                                               * inputSequence_[ch][i + expectedTotalNumSamples];
+            EXPECT_NEAR(expectedSample, storage_[ch][i], absError_)
+                << "at ch=" << ch << ", at i=" << i;
         }
         // compare the samples in the non-crossfaded portion
         for (size_t i = xFadeLengthInSamples_; i < expectedTotalNumSamples; i++)
-            EXPECT_NEAR(inputSequence_[ch][i], storage_[ch][i], absError_) << "at i=" << i;
+            EXPECT_NEAR(inputSequence_[ch][i], storage_[ch][i], absError_)
+                << "at ch=" << ch << ", at i=" << i;
     }
 
     if (HasFailure())
@@ -127,4 +130,30 @@ TEST_F(DSP_Recorder, b_recordAndStop)
             std::cout << "\n";
         }
     }
+}
+
+TEST_F(DSP_Recorder, c_stopRecordingImmediately)
+{
+    fillInputSequence();
+
+    recorder_.startRecording();
+    // record some samples, but don't fill the recording buffer yet
+    constexpr auto kNumSamples = blockSize_ / 2;
+    recorder_.process(inputSequence_.subBlock(0, kNumSamples));
+
+    recorder_.stopRecordingImmediately();
+
+    // No longer recording - no crossfading
+    EXPECT_FALSE(recorder_.isRecording());
+
+    // The recorded data is preserved
+    EXPECT_EQ(recorder_.getCurrentRecordingLength(), kNumSamples);
+    for (size_t ch = 0; ch < numChannels_; ch++)
+    {
+        for (size_t i = 0; i < kNumSamples; i++)
+        {
+            EXPECT_NEAR(inputSequence_[ch][i], storage_[ch][i], absError_)
+                << "at ch=" << ch << ", at i=" << i;
+        }
+    }
 }
\ No newline at end of file

From 91266202c98470631290678640094fb2f8341611 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Fri, 9 Aug 2024 19:37:02 +0200
Subject: [PATCH 04/26] feat: allow to prevent recording/playing in
 `TapeLooper`

This will be used to lock the looper while we save/restore
samples.
---
 dsp/src/dsp/TapeLooper.h       |  50 +++++++++-
 dsp/tests/TapeLooper_gtest.cpp | 177 +++++++++++++++++++++++++++++++++
 2 files changed, 223 insertions(+), 4 deletions(-)
 create mode 100644 dsp/tests/TapeLooper_gtest.cpp

diff --git a/dsp/src/dsp/TapeLooper.h b/dsp/src/dsp/TapeLooper.h
index 788ec42..849b46f 100644
--- a/dsp/src/dsp/TapeLooper.h
+++ b/dsp/src/dsp/TapeLooper.h
@@ -107,9 +107,9 @@ class TapeLooper
     {
     }
 
-    void switchState(LooperState state)
+    void switchState(LooperState newState)
     {
-        switch (state)
+        switch (newState)
         {
             default:
             case LooperState::stopped:
@@ -119,19 +119,25 @@ class TapeLooper
                     player_.stopPlaying();
                 break;
             case LooperState::playing:
+                if (preventPlayback_)
+                    return;
                 if (state_ == LooperState::recording)
                     recorder_.stopRecording();
                 player_.startPlaying(recorder_.getCurrentRecordingLength());
                 break;
             case LooperState::recording:
+                if (preventRecording_)
+                    return;
                 if (state_ == LooperState::playing)
                     player_.stopPlaying();
                 recorder_.startRecording();
                 break;
         }
-        state_ = state;
+        state_ = newState;
     }
 
+    bool isRecording() const { return recorder_.isRecording(); }
+
     LooperState getState() const { return state_; }
 
     void reset()
@@ -205,6 +211,8 @@ class TapeLooper
     template <typename StorageType>
     bool restore(ReadableMemory<StorageType>& mem)
     {
+        if (preventRecording_)
+            return false;
         if (!recorder_.restore(mem))
             return false;
 
@@ -222,11 +230,45 @@ class TapeLooper
         return true;
     }
 
-    const LooperStoragePtr<numChannels> getSampleStoragePtr() const { return storage_; }
+    LooperStoragePtr<numChannels> getSampleStoragePtr() { return storage_; }
+
+    void preventPlaybackAndRecording(bool stopRecordingImmediately = false)
+    {
+        preventPlayback_ = true;
+        preventRecording_ = true;
+        const auto previousState = getState();
+        switchState(LooperState::stopped);
+        if (previousState == LooperState::recording)
+        {
+            if (stopRecordingImmediately)
+                recorder_.stopRecordingImmediately();
+        }
+    }
+
+    void preventRecording(bool stopRecordingImmediately = false)
+    {
+        preventPlayback_ = false;
+        preventRecording_ = true;
+
+        if (getState() == LooperState::recording)
+        {
+            switchState(LooperState::stopped);
+            if (stopRecordingImmediately)
+                recorder_.stopRecordingImmediately();
+        }
+    }
+
+    void liftRestrictions()
+    {
+        preventPlayback_ = false;
+        preventRecording_ = false;
+    }
 
 private:
     const LooperStoragePtr<numChannels> storage_;
     LooperState state_;
     PlayerType player_;
     RecorderType recorder_;
+    bool preventPlayback_ = false;
+    bool preventRecording_ = false;
 };
diff --git a/dsp/tests/TapeLooper_gtest.cpp b/dsp/tests/TapeLooper_gtest.cpp
new file mode 100644
index 0000000..c0aa3a6
--- /dev/null
+++ b/dsp/tests/TapeLooper_gtest.cpp
@@ -0,0 +1,177 @@
+/**
+ * Copyright (C) Johannes Elliesen, 2021
+ *
+ * This program 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
+ * any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtest/gtest.h>
+#include <dsp/TapeLooper.h>
+
+class TapeLooperFixture : public ::testing::Test
+{
+public:
+    TapeLooperFixture() :
+        looper_(storage_) {}
+
+    void processOneBuffer()
+    {
+        TapeProcessorParameters processorParameters;
+        processorParameters.driveGain = 1.0f;
+        processorParameters.grainAmt = 0.0f;
+        AudioBuffer<1, kNumSamples> inBuffer;
+        AudioBuffer<1, kNumSamples> outBuffer;
+        looper_.process(1.0f, 0.0f, Direction::forwards, processorParameters, 1.0f, inBuffer, outBuffer);
+    }
+
+    void recordSomeAudio()
+    {
+        looper_.switchState(LooperState::recording);
+        processOneBuffer();
+        looper_.switchState(LooperState::stopped);
+        processOneBuffer();
+        EXPECT_FALSE(looper_.isRecording());
+    }
+
+    static constexpr auto kSampleRate = 100;
+    static constexpr auto kNumSamples = 100;
+
+    LooperStorage<kNumSamples, 1> storage_;
+    TapeLooper<kSampleRate, 1> looper_;
+};
+
+TEST_F(TapeLooperFixture, a_preventRecordingStopsCurrentRecording)
+{
+    looper_.switchState(LooperState::recording);
+    EXPECT_EQ(looper_.getState(), LooperState::recording);
+
+    looper_.preventRecording();
+    // looper aborts the recording
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+    // recorder is still crossfading out
+    EXPECT_TRUE(looper_.isRecording());
+
+    // after processing for a while
+    processOneBuffer();
+    // recorder has stopped
+    EXPECT_FALSE(looper_.isRecording());
+}
+
+TEST_F(TapeLooperFixture, b_preventRecordingImmediatelyStopsCurrentRecordingWithoutCrossfade)
+{
+    looper_.switchState(LooperState::recording);
+    EXPECT_EQ(looper_.getState(), LooperState::recording);
+
+    looper_.preventRecording(true);
+    // looper aborts the recording
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+    // recorder has stopped immediately
+    EXPECT_FALSE(looper_.isRecording());
+}
+
+TEST_F(TapeLooperFixture, c_preventRecordingPreventsStartingARecording)
+{
+    looper_.switchState(LooperState::stopped);
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+
+    looper_.preventRecording();
+    looper_.switchState(LooperState::recording);
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+
+    looper_.liftRestrictions();
+    looper_.switchState(LooperState::recording);
+    EXPECT_EQ(looper_.getState(), LooperState::recording);
+}
+
+TEST_F(TapeLooperFixture, d_preventRecordingStillAllowsPlayback)
+{
+    recordSomeAudio();
+
+    looper_.switchState(LooperState::stopped);
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+
+    looper_.preventRecording();
+    looper_.switchState(LooperState::playing);
+    EXPECT_EQ(looper_.getState(), LooperState::playing);
+}
+
+TEST_F(TapeLooperFixture, e_preventPlaybackAndRecordingStopsPlayback)
+{
+    recordSomeAudio();
+
+    looper_.switchState(LooperState::playing);
+    EXPECT_EQ(looper_.getState(), LooperState::playing);
+
+    looper_.preventPlaybackAndRecording();
+    // looper aborts the playback
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+}
+
+TEST_F(TapeLooperFixture, f_preventPlaybackAndRecordingStopsCurrentRecording)
+{
+    looper_.switchState(LooperState::recording);
+    EXPECT_EQ(looper_.getState(), LooperState::recording);
+
+    looper_.preventPlaybackAndRecording();
+    // looper aborts the recording
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+    // recorder is still crossfading out
+    EXPECT_TRUE(looper_.isRecording());
+
+    // after processing for a while
+    processOneBuffer();
+    // recorder has stopped
+    EXPECT_FALSE(looper_.isRecording());
+}
+
+TEST_F(TapeLooperFixture, g_preventPlaybackAndRecordingImmediatelyStopsCurrentRecordingWithoutCrossfade)
+{
+    looper_.switchState(LooperState::recording);
+    EXPECT_EQ(looper_.getState(), LooperState::recording);
+
+    looper_.preventPlaybackAndRecording(true);
+    // looper aborts the recording
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+    // recorder has stopped
+    EXPECT_FALSE(looper_.isRecording());
+}
+
+TEST_F(TapeLooperFixture, h_preventPlaybackAndRecordingPreventsStartingARecording)
+{
+    looper_.switchState(LooperState::stopped);
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+
+    looper_.preventPlaybackAndRecording();
+    looper_.switchState(LooperState::recording);
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+
+    looper_.liftRestrictions();
+    looper_.switchState(LooperState::recording);
+    EXPECT_EQ(looper_.getState(), LooperState::recording);
+}
+
+TEST_F(TapeLooperFixture, i_preventPlaybackAndRecordingPreventsStartingPlayback)
+{
+    recordSomeAudio();
+
+    looper_.switchState(LooperState::stopped);
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+
+    looper_.preventPlaybackAndRecording();
+    looper_.switchState(LooperState::playing);
+    EXPECT_EQ(looper_.getState(), LooperState::stopped);
+
+    looper_.liftRestrictions();
+    looper_.switchState(LooperState::playing);
+    EXPECT_EQ(looper_.getState(), LooperState::playing);
+}
\ No newline at end of file

From 8f214e35f67936b33fc6220d3cff1ca82de96f94 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Sat, 10 Aug 2024 08:48:17 +0200
Subject: [PATCH 05/26] feat: Add more getters to `TapeLooper`

---
 dsp/src/dsp/TapeLooper.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/dsp/src/dsp/TapeLooper.h b/dsp/src/dsp/TapeLooper.h
index 849b46f..f082294 100644
--- a/dsp/src/dsp/TapeLooper.h
+++ b/dsp/src/dsp/TapeLooper.h
@@ -230,8 +230,6 @@ class TapeLooper
         return true;
     }
 
-    LooperStoragePtr<numChannels> getSampleStoragePtr() { return storage_; }
-
     void preventPlaybackAndRecording(bool stopRecordingImmediately = false)
     {
         preventPlayback_ = true;
@@ -264,6 +262,11 @@ class TapeLooper
         preventRecording_ = false;
     }
 
+    LooperStoragePtr<numChannels> getSampleStoragePtr() { return storage_; }
+    size_t getPlaybackLength() const { return recorder_.getCurrentRecordingLength(); }
+    static constexpr size_t getNumChannels() { return numChannels; }
+    static constexpr size_t getSampleRate() { return sampleRate; }
+
 private:
     const LooperStoragePtr<numChannels> storage_;
     LooperState state_;

From e8bca5133639404b42d72d99a57ff66b46cdf7a1 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Fri, 16 Aug 2024 08:13:22 +0200
Subject: [PATCH 06/26] feat: Allow to set playback length without recording

this will be needed when we restore samples and write
them to the buffer directly
---
 dsp/src/dsp/Recorder.h   | 1 +
 dsp/src/dsp/TapeLooper.h | 1 +
 2 files changed, 2 insertions(+)

diff --git a/dsp/src/dsp/Recorder.h b/dsp/src/dsp/Recorder.h
index feb4479..00f78a2 100644
--- a/dsp/src/dsp/Recorder.h
+++ b/dsp/src/dsp/Recorder.h
@@ -140,6 +140,7 @@ class Recorder
         return true;
     }
 
+    void setCurrentPlaybackLength(size_t length) { currentLength_ = length; }
     size_t getCurrentRecordingLength() const { return currentLength_; }
     bool isRecording() const { return isRecording_ || isFadingOut_; }
 
diff --git a/dsp/src/dsp/TapeLooper.h b/dsp/src/dsp/TapeLooper.h
index f082294..5502126 100644
--- a/dsp/src/dsp/TapeLooper.h
+++ b/dsp/src/dsp/TapeLooper.h
@@ -263,6 +263,7 @@ class TapeLooper
     }
 
     LooperStoragePtr<numChannels> getSampleStoragePtr() { return storage_; }
+    void setPlaybackLength(size_t length) { recorder_.setCurrentPlaybackLength(length); }
     size_t getPlaybackLength() const { return recorder_.getCurrentRecordingLength(); }
     static constexpr size_t getNumChannels() { return numChannels; }
     static constexpr size_t getSampleRate() { return sampleRate; }

From 30619d77a95692d0e10691dbd7a036b0c197825d Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Fri, 16 Aug 2024 09:26:19 +0200
Subject: [PATCH 07/26] feat: Add empty `AudioSaveAndRecall`

---
 firmware/src/AudioSaveAndRecall.h         | 41 +++++++++++++++++++
 firmware/src/LooperController.h           | 50 ++++++++++++++++++++---
 firmware/src/hardware/FatFsFileIo.h       | 22 ++++++++++
 firmware/src/main.cpp                     |  9 +++-
 firmware/tests/LooperController_gtest.cpp | 11 ++++-
 5 files changed, 124 insertions(+), 9 deletions(-)
 create mode 100644 firmware/src/AudioSaveAndRecall.h
 create mode 100644 firmware/src/hardware/FatFsFileIo.h

diff --git a/firmware/src/AudioSaveAndRecall.h b/firmware/src/AudioSaveAndRecall.h
new file mode 100644
index 0000000..36bb3d3
--- /dev/null
+++ b/firmware/src/AudioSaveAndRecall.h
@@ -0,0 +1,41 @@
+/**
+ * Copyright (C) Johannes Elliesen, 2024
+ *
+ * This program 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
+ * any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+enum class AudioSaveAndRecallResult
+{
+    ok,
+    error
+};
+
+enum class StorageBank
+{
+    green,
+    yellow,
+    red,
+
+    count
+};
+
+typedef void (*AudioSaveAndRecallDoneCallbackPtr)(void* context, AudioSaveAndRecallResult result);
+
+template <typename FileIoProvider>
+class AudioSaveAndRecall
+{
+public:
+};
diff --git a/firmware/src/LooperController.h b/firmware/src/LooperController.h
index 8b83679..716bb54 100644
--- a/firmware/src/LooperController.h
+++ b/firmware/src/LooperController.h
@@ -24,6 +24,7 @@
 
 #include "constants.h"
 #include "util/LateInitializedObject.h"
+#include "AudioSaveAndRecall.h"
 
 enum class ChannelLayout
 {
@@ -48,15 +49,18 @@ class LooperController
     using MonoLooperType = typename LooperTypes::MonoLooperType;
     using StereoLooperType = typename LooperTypes::StereoLooperType;
     using ParameterProviderType = typename LooperTypes::ParameterProvider;
+    using AudioSaveAndRecallType = typename LooperTypes::AudioSaveAndRecallType;
 
     LooperController(std::array<MonoOrStereoLooperStoragePtr, numLoopers> looperStorage,
                      AudioBufferPtr<1> monoDownmixBuffer,
                      AudioBufferPtr<1> temporaryBuffer,
-                     const ParameterProviderType& paramProvider) :
+                     const ParameterProviderType& paramProvider,
+                     AudioSaveAndRecallType& audioSaveAndRecall) :
         looperStorage_(looperStorage),
         monoDownmixBuffer_(monoDownmixBuffer),
         temporaryBuffer_(temporaryBuffer),
-        paramProvider_(paramProvider)
+        paramProvider_(paramProvider),
+        audioSaveAndRecall_(audioSaveAndRecall)
     {
         for (size_t i = 0; i < numLoopers; i++)
             loopers_[i].initializeToLayout(ChannelLayout::stereo, looperStorage_[i]);
@@ -78,18 +82,51 @@ class LooperController
             return loopers_[looperIdx].looper.template as<StereoLooperType>().getState();
     }
 
-    void saveTo(size_t looperIdx, size_t slot)
+    void saveTo(StorageBank bank,
+                size_t looperIdx,
+                size_t slot,
+                AudioSaveAndRecallDoneCallbackPtr doneCallback,
+                void* doneCallbackContext)
     {
+        (void) (bank);
         (void) (looperIdx);
         (void) (slot);
-        // TODO
+        (void) (doneCallback);
+        (void) (doneCallbackContext);
+        /*
+        audioSaveAndRecall_.startSavingToFile(bank,
+                                              slot,
+                                              loopers_[looperIdx].looper,
+                                              doneCallback,
+                                              doneCallbackContext);
+        */
     }
 
-    void loadFrom(size_t looperIdx, size_t slot)
+    float getCurrentSaveOrLoadProgress()
     {
+        // return audioSaveAndRecall_.getCurrentProgress();
+        return 0.0f;
+    }
+
+    void loadFrom(StorageBank bank,
+                  size_t looperIdx,
+                  size_t slot,
+                  AudioSaveAndRecallDoneCallbackPtr doneCallback,
+                  void* doneCallbackContext)
+    {
+        (void) (bank);
         (void) (looperIdx);
         (void) (slot);
-        // TODO
+        (void) (doneCallback);
+        (void) (doneCallbackContext);
+        /*
+        // TODO: Reconfigure to correct channel layout
+        audioSaveAndRecall_.startReadingFromFiles(bank,
+                                                  slot,
+                                                  loopers_[looperIdx].looper,
+                                                  doneCallback,
+                                                  doneCallbackContext);
+        */
     }
 
     void setChannelLayout(size_t looperIdx, ChannelLayout channelLayout)
@@ -298,4 +335,5 @@ class LooperController
     AudioBufferPtr<1> monoDownmixBuffer_;
     AudioBufferPtr<1> temporaryBuffer_;
     const ParameterProviderType& paramProvider_;
+    AudioSaveAndRecallType& audioSaveAndRecall_;
 };
\ No newline at end of file
diff --git a/firmware/src/hardware/FatFsFileIo.h b/firmware/src/hardware/FatFsFileIo.h
new file mode 100644
index 0000000..2f81384
--- /dev/null
+++ b/firmware/src/hardware/FatFsFileIo.h
@@ -0,0 +1,22 @@
+/**
+ * Copyright (C) Johannes Elliesen, 2024
+ *
+ * This program 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
+ * any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+class FatFsFileIo
+{
+};
\ No newline at end of file
diff --git a/firmware/src/main.cpp b/firmware/src/main.cpp
index 4ee83ca..13021d9 100644
--- a/firmware/src/main.cpp
+++ b/firmware/src/main.cpp
@@ -21,6 +21,7 @@
 
 #include "constants.h"
 #include "dsp/PeakMeter.h"
+#include "hardware/FatFsFileIo.h"
 #include "hardware/UiHardware.h"
 #include "ui/TapeLooperUi.h"
 #include "dsp/TapeLooper.h"
@@ -37,6 +38,7 @@ struct LooperTypes
     using MonoLooperType = TapeLooper<sampleRateHz, 1>;
     using StereoLooperType = TapeLooper<sampleRateHz, 2>;
     using ParameterProvider = LooperParameterProviderType;
+    using AudioSaveAndRecallType = AudioSaveAndRecall<FatFsFileIo>;
 };
 using LooperControllerType = LooperController<LooperTypes, numLoopers>;
 using TapeLooperUiType = TapeLooperUi<UiHardware,
@@ -61,6 +63,7 @@ std::array<PeakMeter<blockSize, sampleRateHz>, 4> peakMeters;
 #define EXTERNAL_SDRAM_SECTION __attribute__((section(".sdram_bss")))
 LateInitializedObject<LooperStoragesType> EXTERNAL_SDRAM_SECTION looperStorages;
 LateInitializedObject<LooperParameterProviderType> looperParameterProvider;
+LateInitializedObject<LooperTypes::AudioSaveAndRecallType> audioSaveAndRecall;
 AudioBuffer<1, blockSize> monoDownmixBuffer;
 AudioBuffer<1, blockSize> temporaryBuffer;
 LateInitializedObject<LooperControllerType> looperController;
@@ -108,9 +111,10 @@ void initUi()
 
 void initDsp()
 {
-    // init the parameter provider
     looperParameterProvider.create();
 
+    audioSaveAndRecall.create();
+
     // initialize the looper storage in SDRAM
     const auto& rawStorages = *looperStorages.create();
     // build an array of storage pointers
@@ -123,7 +127,8 @@ void initDsp()
         arrayOfStoragePtrs,
         monoDownmixBuffer,
         temporaryBuffer,
-        looperParameterProvider);
+        looperParameterProvider,
+        audioSaveAndRecall);
 
     // init peak meters
     for (auto& peakMeter : peakMeters)
diff --git a/firmware/tests/LooperController_gtest.cpp b/firmware/tests/LooperController_gtest.cpp
index 5828a60..5a72031 100644
--- a/firmware/tests/LooperController_gtest.cpp
+++ b/firmware/tests/LooperController_gtest.cpp
@@ -125,11 +125,18 @@ class ParameterProviderMock
     MOCK_METHOD(ProcessorParametersMock, getProcessorParameters, (size_t looperChannel), (const));
 };
 
+class AudioSaveAndRecallMock
+{
+public:
+    // MOCK_METHOD(ReturnType, MethodName, (Args...), (Specs...));
+};
+
 struct LooperMockTypes
 {
     using MonoLooperType = ::testing::NiceMock<MonoLooperMock>;
     using StereoLooperType = ::testing::NiceMock<StereoLooperMock>;
     using ParameterProvider = ::testing::NiceMock<ParameterProviderMock>;
+    using AudioSaveAndRecallType = ::testing::NiceMock<AudioSaveAndRecallMock>;
 };
 
 class LooperController_Test : public ::testing::Test
@@ -139,7 +146,8 @@ class LooperController_Test : public ::testing::Test
         controller_(storage_,
                     monoDownmixBuffer_,
                     temporaryBuffer_,
-                    parameterProvider_)
+                    parameterProvider_,
+                    audioSaveAndRecall_)
     {
     }
 
@@ -164,6 +172,7 @@ class LooperController_Test : public ::testing::Test
     AudioBuffer<1, numSamples_> monoDownmixBuffer_;
     AudioBuffer<1, numSamples_> temporaryBuffer_;
     ::testing::NiceMock<ParameterProviderMock> parameterProvider_;
+    ::testing::NiceMock<AudioSaveAndRecallMock> audioSaveAndRecall_;
     LooperController<LooperMockTypes, numLoopers_> controller_;
     MockInstanceRegistry& looperInstanceRegistry_ = *mockInstances.GetStateForCurrentTest();
 };

From d28bb952503d9fa0578462c859ce54cd989f4b1a Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 4 Sep 2024 20:44:51 +0200
Subject: [PATCH 08/26] feat: allow to set recording progress from tests

---
 dsp/src/dsp/Recorder.h   | 2 ++
 dsp/src/dsp/TapeLooper.h | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/dsp/src/dsp/Recorder.h b/dsp/src/dsp/Recorder.h
index 00f78a2..21310e8 100644
--- a/dsp/src/dsp/Recorder.h
+++ b/dsp/src/dsp/Recorder.h
@@ -144,6 +144,8 @@ class Recorder
     size_t getCurrentRecordingLength() const { return currentLength_; }
     bool isRecording() const { return isRecording_ || isFadingOut_; }
 
+    void setRecordingProgressForTesting(size_t numSamplesDone) { recHeadIdx_ = numSamplesDone; }
+
 private:
     static constexpr float defaultXFadeLengthInS_ = 0.1f;
 
diff --git a/dsp/src/dsp/TapeLooper.h b/dsp/src/dsp/TapeLooper.h
index 5502126..75f53a7 100644
--- a/dsp/src/dsp/TapeLooper.h
+++ b/dsp/src/dsp/TapeLooper.h
@@ -268,6 +268,8 @@ class TapeLooper
     static constexpr size_t getNumChannels() { return numChannels; }
     static constexpr size_t getSampleRate() { return sampleRate; }
 
+    RecorderType& recorderForTesting() { return recorder_; }
+
 private:
     const LooperStoragePtr<numChannels> storage_;
     LooperState state_;

From 53a9e51dafdc31456afcc49956114493ad7418cb Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 01:56:13 +0200
Subject: [PATCH 09/26] chore: Move some libDaisy stubs in tests to a dedicated
 header file

---
 firmware/tests/LooperController_gtest.cpp |  1 +
 firmware/tests/Ui_gtest.cpp               |  1 +
 firmware/tests/libDaisyCombined.h         | 25 +++++++++++++++++++++++
 3 files changed, 27 insertions(+)
 create mode 100644 firmware/tests/libDaisyCombined.h

diff --git a/firmware/tests/LooperController_gtest.cpp b/firmware/tests/LooperController_gtest.cpp
index 5a72031..f0a3094 100644
--- a/firmware/tests/LooperController_gtest.cpp
+++ b/firmware/tests/LooperController_gtest.cpp
@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
+#include "libDaisyCombined.h"
 #include "LooperController.h"
 #include "../libDaisy/tests/TestIsolator.h"
 
diff --git a/firmware/tests/Ui_gtest.cpp b/firmware/tests/Ui_gtest.cpp
index 9f980cd..7ac9fbe 100644
--- a/firmware/tests/Ui_gtest.cpp
+++ b/firmware/tests/Ui_gtest.cpp
@@ -20,6 +20,7 @@
 
 #include <../tests/TestIsolator.h> // from libDaisy
 #include <sys/system.h> // from libDaisy
+#include "libDaisyCombined.h" // remaining libDaisy mocks/stubs
 #include "ui/TapeLooperUi.h"
 
 #include "mocks/LooperController_mock.h"
diff --git a/firmware/tests/libDaisyCombined.h b/firmware/tests/libDaisyCombined.h
new file mode 100644
index 0000000..0998f63
--- /dev/null
+++ b/firmware/tests/libDaisyCombined.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdint>
+
+// substitutes for the stuff provided by the daisy library
+#define FBIPMAX 0.999985f /**< close to 1.0f-LSB at 16 bit */
+#define FBIPMIN (-FBIPMAX) /**< - (1 - LSB) */
+#define F2S32_SCALE 2147483647.f /**< (2 ** 31) - 1 */
+#define S322F_SCALE 4.6566129e-10f /**< 1 / (2** 31) */
+#define S162F_SCALE 3.0517578125e-05f /**< 1 / (2** 15) */
+
+inline int32_t f2s32(float x)
+{
+    x = x <= FBIPMIN ? FBIPMIN : x;
+    x = x >= FBIPMAX ? FBIPMAX : x;
+    return (int32_t) (x * F2S32_SCALE);
+}
+inline float s322f(int32_t x)
+{
+    return (float) x * S322F_SCALE;
+}
+inline float s162f(int16_t x)
+{
+    return (float) x * S162F_SCALE;
+}
\ No newline at end of file

From 9d78b402edc61010d550bbe1c046753057e4d20e Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 4 Sep 2024 21:45:24 +0200
Subject: [PATCH 10/26] feat: add WavFileFormat.cpp

---
 firmware/CMakeLists.txt              |  1 +
 firmware/src/util/WavFileFormat.cpp  | 61 +++++++++++++++++++++++++++
 firmware/src/util/WavFileFormat.h    | 63 ++++++++++++++++++++++++++++
 firmware/tests/firmware_combined.cpp |  1 +
 4 files changed, 126 insertions(+)
 create mode 100644 firmware/src/util/WavFileFormat.cpp
 create mode 100644 firmware/src/util/WavFileFormat.h
 create mode 100644 firmware/tests/firmware_combined.cpp

diff --git a/firmware/CMakeLists.txt b/firmware/CMakeLists.txt
index 39fa292..8a68ed9 100644
--- a/firmware/CMakeLists.txt
+++ b/firmware/CMakeLists.txt
@@ -24,6 +24,7 @@ endif(COMMAND cmake_policy)
 set(FIRMWARE_NAME TapeLooper)
 set(FIRMWARE_SOURCES
     src/main.cpp
+    src/util/WavFileFormat.cpp
 )
 
 # include dsp library
diff --git a/firmware/src/util/WavFileFormat.cpp b/firmware/src/util/WavFileFormat.cpp
new file mode 100644
index 0000000..e9ae956
--- /dev/null
+++ b/firmware/src/util/WavFileFormat.cpp
@@ -0,0 +1,61 @@
+/**
+ * Copyright (C) Johannes Elliesen, 2024
+ *
+ * This program 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
+ * any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "WavFileFormat.h"
+
+void updateWavFileHeaderSizes(WavFileHeader& header, const int numSamples)
+{
+    header.dataBlocSize = numSamples * header.numBytesPerBloc;
+    header.fileSizeMinus8Bytes = header.dataBlocSize + sizeof(WavFileHeader) - 8;
+}
+
+WavFileHeader makeWavFileHeader32bitInt(const int sampleRate,
+                                        const int numChannels,
+                                        const int numSamples)
+{
+    WavFileHeader header;
+    header.audioFormat = WavFileFormatCode::pcm;
+    header.numAudioChannels = numChannels;
+    header.sampleRate = sampleRate;
+    header.numBitsPerSample = 32;
+    header.numBytesPerBloc = header.numAudioChannels
+                             * header.numBitsPerSample / 8;
+    header.numBytesPerSec = sampleRate * header.numBytesPerBloc;
+    updateWavFileHeaderSizes(header, numSamples);
+    return header;
+}
+
+WavFileHeader makeWavFileHeader32bitFloat(const int sampleRate,
+                                          const int numChannels,
+                                          const int numSamples)
+{
+    WavFileHeader header;
+    header.audioFormat = WavFileFormatCode::ieeeFloat;
+    header.numAudioChannels = numChannels;
+    header.sampleRate = sampleRate;
+    header.numBitsPerSample = 32;
+    header.numBytesPerBloc = header.numAudioChannels
+                             * header.numBitsPerSample / 8;
+    header.numBytesPerSec = sampleRate * header.numBytesPerBloc;
+    updateWavFileHeaderSizes(header, numSamples);
+    return header;
+}
+
+uint32_t getNumSamples(const WavFileHeader& header)
+{
+    return uint32_t(header.dataBlocSize / header.numBytesPerBloc);
+}
diff --git a/firmware/src/util/WavFileFormat.h b/firmware/src/util/WavFileFormat.h
new file mode 100644
index 0000000..27c15ea
--- /dev/null
+++ b/firmware/src/util/WavFileFormat.h
@@ -0,0 +1,63 @@
+/**
+ * Copyright (C) Johannes Elliesen, 2024
+ *
+ * This program 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
+ * any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+enum class WavFileFormatCode
+{
+    pcm = 0x0001,
+    ieeeFloat = 0x0003,
+    aLaw = 0x0006,
+    uLaw = 0x0007,
+    extensible = 0xFFFE,
+};
+
+#ifdef _MSC_VER
+#    pragma pack(push, 1)
+#    define PACKED_ATTRIBUTE
+#else
+#    define PACKED_ATTRIBUTE __attribute__((__packed__))
+#endif
+struct WavFileHeader
+{
+    uint32_t fileTypeBlocId = 0x46464952; // "RIFF"
+    uint32_t fileSizeMinus8Bytes;
+    uint32_t fileFormatId = 0x45564157; // "WAVE"
+    uint32_t formatBlocId = 0x20746d66; // "fmt "
+    uint32_t formatBlocSize = 0x10;
+    WavFileFormatCode audioFormat : 16;
+    uint16_t numAudioChannels;
+    uint32_t sampleRate;
+    uint32_t numBytesPerSec;
+    uint16_t numBytesPerBloc;
+    uint16_t numBitsPerSample;
+    uint32_t dataBlocId = 0x61746164; // "data"
+    uint32_t dataBlocSize;
+} PACKED_ATTRIBUTE;
+#ifdef _MSC_VER
+#    pragma pack(pop)
+#endif
+
+void updateWavFileHeaderSizes(WavFileHeader& header, int numSamples);
+
+WavFileHeader makeWavFileHeader32bitInt(int sampleRate, int numChannels, int numSamples = 0);
+
+WavFileHeader makeWavFileHeader32bitFloat(int sampleRate, int numChannels, int numSamples = 0);
+
+uint32_t getNumSamples(const WavFileHeader& header);
diff --git a/firmware/tests/firmware_combined.cpp b/firmware/tests/firmware_combined.cpp
new file mode 100644
index 0000000..9178721
--- /dev/null
+++ b/firmware/tests/firmware_combined.cpp
@@ -0,0 +1 @@
+#include "../src/util/WavFileFormat.cpp"
\ No newline at end of file

From 11ef983db7ec4319f54fde07ed8d5bd017ccac4b Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Tue, 7 Oct 2025 22:56:58 +0200
Subject: [PATCH 11/26] fix: don't destroy never created object

When calling `initializeToLayout` for the very first
time, the `LateInitializedObject` wasn't initialized
and we'd be calling the destructor of a dead object.
---
 firmware/src/LooperController.h | 33 ++++++++++++++++++++++++---------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/firmware/src/LooperController.h b/firmware/src/LooperController.h
index 716bb54..72af340 100644
--- a/firmware/src/LooperController.h
+++ b/firmware/src/LooperController.h
@@ -29,7 +29,8 @@
 enum class ChannelLayout
 {
     mono,
-    stereo
+    stereo,
+    invalid
 };
 
 enum class MotorAcceleration
@@ -226,23 +227,37 @@ class LooperController
                 looper.template destroy<typename LooperTypes::StereoLooperType>();
         }
 
-        ChannelLayout layout = ChannelLayout::stereo;
+        ChannelLayout layout = ChannelLayout::invalid;
         Direction direction = Direction::forwards;
         MotorAcceleration acceleration = MotorAcceleration::medium;
         LateInitializedObject<MonoLooperType, StereoLooperType> looper;
 
         void initializeToLayout(const ChannelLayout newLayout, MonoOrStereoLooperStoragePtr& storage)
         {
-            layout = newLayout;
-            if (layout == ChannelLayout::mono)
+            switch (layout)
             {
-                looper.template destroy<typename LooperTypes::StereoLooperType>();
-                looper.template create<typename LooperTypes::MonoLooperType>(storage);
+                case ChannelLayout::mono:
+                    looper.template destroy<typename LooperTypes::MonoLooperType>();
+                    break;
+                case ChannelLayout::stereo:
+                    looper.template destroy<typename LooperTypes::StereoLooperType>();
+                    break;
+                default:
+                    break;
             }
-            else
+
+            layout = newLayout;
+
+            switch (newLayout)
             {
-                looper.template destroy<typename LooperTypes::MonoLooperType>();
-                looper.template create<typename LooperTypes::StereoLooperType>(storage);
+                case ChannelLayout::mono:
+                    looper.template create<typename LooperTypes::MonoLooperType>(storage);
+                    break;
+                case ChannelLayout::stereo:
+                    looper.template create<typename LooperTypes::StereoLooperType>(storage);
+                    break;
+                default:
+                    break;
             }
         }
     };

From 08b1a7a639f8d79638aef752f9346cf575f1c33d Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Tue, 7 Oct 2025 23:24:49 +0200
Subject: [PATCH 12/26] chore: run firmware tests in test folder to be able to
 access files there

---
 .github/workflows/firmware.yaml | 6 +++---
 .vscode/launch.json             | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/firmware.yaml b/.github/workflows/firmware.yaml
index c403fb0..7fd98a2 100644
--- a/.github/workflows/firmware.yaml
+++ b/.github/workflows/firmware.yaml
@@ -72,14 +72,14 @@ jobs:
 
     - name: Run Tests
       run: |
-        cd firmware/tests/build/bin
-        ./TapeLooper_gtest --gtest_output=xml:gtestresults.xml
+        cd firmware/tests
+        ./build/bin/TapeLooper_gtest --gtest_output=xml:gtestresults.xml
 
     - name: Publish Test Results
       uses: EnricoMi/publish-unit-test-result-action@v1
       if: always()
       with:
-        files: firmware/tests/build/bin/**/*.xml
+        files: firmware/tests/**/*.xml
         github_token: ${{ secrets.GITHUB_TOKEN }}
 
 
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 5a824f1..a27a706 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -91,7 +91,7 @@
             "program": "${workspaceFolder}/firmware/tests/build/bin/TapeLooper_gtest",
             "args": [],
             "stopAtEntry": false,
-            "cwd": "${workspaceFolder}/firmware/tests/build/bin",
+            "cwd": "${workspaceFolder}/firmware/tests/",
             "environment": [],
             "externalConsole": false,
             "logging": {

From 95c9d3aea23c418ccde3aeddf11993f3667953d1 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 11:36:26 +0200
Subject: [PATCH 13/26] chore: update Visual Studio version and github actions

---
 .github/workflows/firmware.yaml |  4 ++--
 .github/workflows/plugin.yaml   | 26 +++++++++++++-------------
 .vscode/tasks.json              |  4 ++--
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/firmware.yaml b/.github/workflows/firmware.yaml
index 7fd98a2..c2e9a24 100644
--- a/.github/workflows/firmware.yaml
+++ b/.github/workflows/firmware.yaml
@@ -43,13 +43,13 @@ jobs:
       run: cmake --build firmware/build
 
     - name: Upload Firmware hex
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
         name: TapeLooper.hex
         path: firmware/build/TapeLooper.hex
 
     - name: Upload Firmware bin
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
         name: TapeLooper.bin
         path: firmware/build/TapeLooper.bin
diff --git a/.github/workflows/plugin.yaml b/.github/workflows/plugin.yaml
index d5ae327..afcdec5 100644
--- a/.github/workflows/plugin.yaml
+++ b/.github/workflows/plugin.yaml
@@ -18,7 +18,7 @@ jobs:
   ###############################################################################
   # builds the plugin on windows
   testBuildWindows:
-    runs-on: windows-2019
+    runs-on: windows-2025
 
     steps:
     - name: Setup cmake
@@ -33,7 +33,7 @@ jobs:
 
     - name: Configure
       run: |
-        cmake.exe -G "Visual Studio 16 2019" -A x64 -B plugin/build -S plugin
+        cmake.exe -G "Visual Studio 17 2022" -A x64 -B plugin/build -S plugin
 
     - name: Build
       run: |
@@ -44,13 +44,13 @@ jobs:
         plugin/build/Release/TapeLooperPlugin_Gtest.exe --gtest_output=xml:TestResults\gtestResults_windows.xml
 
     - name: Upload Test Results
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
-        name: TestResults
+        name: TestResults_Windows
         path: TestResults/**
 
     - name: Upload executable
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
         name: TapeLooperPlugin_Windows
         path: |
@@ -95,13 +95,13 @@ jobs:
         plugin/build/Release/TapeLooperPlugin_Gtest --gtest_output=xml:TestResults/gtestResults_macos.xml
 
     - name: Upload Test Results
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
-        name: TestResults
+        name: TestResults_MacOS
         path: TestResults/**
 
     - name: Upload executable
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
         name: TapeLooperPlugin_MacOS
         path: |
@@ -142,13 +142,13 @@ jobs:
         plugin/build/TapeLooperPlugin_Gtest --gtest_output=xml:TestResults/gtestResults_ubuntu.xml
 
     - name: Upload Test Results
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
-        name: TestResults
+        name: TestResults_Linux
         path: TestResults/**
 
     - name: Upload executable
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
         name: TapeLooperPlugin_Linux
         path: |
@@ -167,9 +167,9 @@ jobs:
 
     steps:
       - name: Download Artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
-          name: TestResults
+          pattern: TestResults_*
           path: TestResults
 
       - name: Publish Test Results
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index ef65058..dea65e9 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -168,7 +168,7 @@
                     "-D",
                     "CMAKE_EXPORT_COMPILE_COMMANDS=1",
                     "-G",
-                    "\\\"Visual Studio 16 2019\\\""
+                    "\\\"Visual Studio 17 2022\\\""
                 ]
             },
             "group": {
@@ -207,7 +207,7 @@
                     "-D",
                     "CMAKE_EXPORT_COMPILE_COMMANDS=1",
                     "-G",
-                    "\\\"Visual Studio 16 2019\\\""
+                    "\\\"Visual Studio 17 2022\\\""
                 ]
             },
             "group": {

From 31cf105e4f04f5ade1c3d7560ca2b7bde844763a Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 4 Sep 2024 21:50:37 +0200
Subject: [PATCH 14/26] feat: implement AudioSaveAndRecall

---
 firmware/src/AudioSaveAndRecall.h             | 626 ++++++++++++++++++
 firmware/src/hardware/FatFsFileIo.h           |  26 +
 firmware/tests/AudioSaveAndRecall_gtest.cpp   | 540 +++++++++++++++
 firmware/tests/data/monoSaw_float.wav         | Bin 0 -> 272 bytes
 firmware/tests/data/monoSaw_int16.wav         | Bin 0 -> 140 bytes
 firmware/tests/data/monoSaw_int24.wav         | Bin 0 -> 188 bytes
 firmware/tests/data/monoSaw_int32.wav         | Bin 0 -> 236 bytes
 firmware/tests/data/monoSineWaves.wav         | Bin 0 -> 19244 bytes
 firmware/tests/data/stereoSaw_float.wav       | Bin 0 -> 472 bytes
 .../tests/data/stereoSaw_float_Ableton.wav    | Bin 0 -> 464 bytes
 firmware/tests/data/stereoSaw_int16.wav       | Bin 0 -> 236 bytes
 firmware/tests/data/stereoSaw_int24.wav       | Bin 0 -> 332 bytes
 firmware/tests/data/stereoSaw_int32.wav       | Bin 0 -> 428 bytes
 firmware/tests/data/stereoSineWaves.wav       | Bin 0 -> 38444 bytes
 firmware/tests/libDaisyCombined.h             |   7 +
 15 files changed, 1199 insertions(+)
 create mode 100644 firmware/tests/AudioSaveAndRecall_gtest.cpp
 create mode 100644 firmware/tests/data/monoSaw_float.wav
 create mode 100644 firmware/tests/data/monoSaw_int16.wav
 create mode 100644 firmware/tests/data/monoSaw_int24.wav
 create mode 100644 firmware/tests/data/monoSaw_int32.wav
 create mode 100644 firmware/tests/data/monoSineWaves.wav
 create mode 100644 firmware/tests/data/stereoSaw_float.wav
 create mode 100644 firmware/tests/data/stereoSaw_float_Ableton.wav
 create mode 100644 firmware/tests/data/stereoSaw_int16.wav
 create mode 100644 firmware/tests/data/stereoSaw_int24.wav
 create mode 100644 firmware/tests/data/stereoSaw_int32.wav
 create mode 100644 firmware/tests/data/stereoSineWaves.wav

diff --git a/firmware/src/AudioSaveAndRecall.h b/firmware/src/AudioSaveAndRecall.h
index 36bb3d3..b6b92cf 100644
--- a/firmware/src/AudioSaveAndRecall.h
+++ b/firmware/src/AudioSaveAndRecall.h
@@ -17,6 +17,12 @@
 
 #pragma once
 
+#include <util/FixedCapStr.h>
+#include <dsp/TapeLooper.h>
+#include "util/WavFileFormat.h"
+
+using AudioFileName = daisy::FixedCapStr<32>;
+
 enum class AudioSaveAndRecallResult
 {
     ok,
@@ -38,4 +44,624 @@ template <typename FileIoProvider>
 class AudioSaveAndRecall
 {
 public:
+    AudioSaveAndRecall()
+    {
+        isStorageSlotUsedBitfield_[0] = 0;
+        isStorageSlotUsedBitfield_[1] = 0;
+        isStorageSlotUsedBitfield_[2] = 0;
+    }
+
+    void scanOrInitLibrary()
+    {
+        fileIo_.makeFolderIfNotExistent(libraryBaseFolder_);
+
+        for (size_t bank = 0; bank < kNumBanks; bank++)
+        {
+            for (size_t slot = 0; slot < kNumSlots; slot++)
+            {
+                const auto filename = makeWavFileNameFor(StorageBank(bank), slot);
+
+                if (const auto isInUse = fileIo_.hasFile(filename))
+                    isStorageSlotUsedBitfield_[bank] |= (1 << slot);
+                else
+                    isStorageSlotUsedBitfield_[bank] &= ~(1 << slot);
+            }
+        }
+    }
+
+    template <typename LooperType>
+    void startSavingToFile(StorageBank bank,
+                           int slot,
+                           LooperType& looper,
+                           AudioSaveAndRecallDoneCallbackPtr doneCallback,
+                           void* doneCallbackContext)
+    {
+        startSavingToFile(makeWavFileNameFor(bank, slot),
+                          looper,
+                          doneCallback,
+                          doneCallbackContext);
+    }
+
+    template <typename LooperType>
+    void startSavingToFile(const AudioFileName& filename,
+                           LooperType& looper,
+                           AudioSaveAndRecallDoneCallbackPtr doneCallback,
+                           void* doneCallbackContext)
+    {
+        static_assert(LooperType::getNumChannels() <= kMaxNumChannels_);
+
+        looperPtr_ = &looper;
+        doneCallback_ = doneCallback;
+        doneCallbackContext_ = doneCallbackContext;
+
+        looper.preventRecording();
+        liftRestrictionsFunc_ = [](void* looperPtr)
+        {
+            LooperType* looper = reinterpret_cast<LooperType*>(looperPtr);
+            looper->liftRestrictions();
+        };
+
+        totalNumFrames_ = looper.getPlaybackLength();
+
+        if (totalNumFrames_ == 0)
+        {
+            abort(false);
+            return;
+        }
+
+        if (
+            !fileIo_.openForWriting(filename)
+            || !writeWavHeader(totalNumFrames_, looper.getNumChannels(), looper.getSampleRate()))
+        {
+            abort(true);
+            return;
+        }
+
+        writeOrReadFunc_ = [](AudioSaveAndRecall* storage, void* looperPtr)
+        {
+            LooperType* looper = reinterpret_cast<LooperType*>(looperPtr);
+
+            // wait while the current recording is still crossfading out
+            if (looper->isRecording())
+                return ReadOrWriteResult::inProgress;
+
+            const auto numSamplesLeft = storage->totalNumFrames_ - storage->numFramesDone_;
+
+            if (numSamplesLeft <= 0)
+            {
+                return ReadOrWriteResult::error;
+            }
+
+            const auto numFramesInThisChunk = std::min(size_t(numSamplesLeft), kNumFramesPerChunk_);
+            const auto writeSuccessful = storage->writeBuffer(looper->getSampleStoragePtr(),
+                                                              storage->numFramesDone_,
+                                                              numFramesInThisChunk);
+            if (!writeSuccessful)
+            {
+                return ReadOrWriteResult::error;
+            }
+
+            storage->numFramesDone_ += numFramesInThisChunk;
+
+            const auto isNowDone = storage->numFramesDone_ == storage->totalNumFrames_;
+            if (isNowDone)
+            {
+                storage->fileIo_.closeFile();
+                return ReadOrWriteResult::completed;
+            }
+            return ReadOrWriteResult::inProgress;
+        };
+    }
+
+    size_t getNumChannelsInFile(StorageBank bank,
+                                int slot)
+    {
+        return getNumChannelsInFile(makeWavFileNameFor(bank, slot));
+    }
+
+    size_t getNumChannelsInFile(const AudioFileName& filename)
+    {
+        if (isSavingOrRecalling())
+        {
+            return 0;
+        }
+
+        if (!fileIo_.openForReading(filename))
+        {
+            return 0;
+        }
+
+        if (!readWavHeader() || !isCompatibleFormat())
+        {
+            fileIo_.closeFile();
+            return 0;
+        }
+
+        fileIo_.closeFile();
+        return size_t(wavHeader_.numAudioChannels);
+    }
+
+    template <typename LooperType>
+    void startReadingFromFile(StorageBank bank,
+                              int slot,
+                              LooperType& looper,
+                              AudioSaveAndRecallDoneCallbackPtr doneCallback,
+                              void* doneCallbackContext)
+    {
+        startReadingFromFile(makeWavFileNameFor(bank, slot),
+                             looper,
+                             doneCallback,
+                             doneCallbackContext);
+    }
+
+    template <typename LooperType>
+    void startReadingFromFile(const AudioFileName& filename,
+                              LooperType& looper,
+                              AudioSaveAndRecallDoneCallbackPtr doneCallback,
+                              void* doneCallbackContext)
+    {
+        static_assert(LooperType::getNumChannels() <= kMaxNumChannels_);
+
+        looperPtr_ = &looper;
+        doneCallback_ = doneCallback;
+        doneCallbackContext_ = doneCallbackContext;
+
+        looper.preventPlaybackAndRecording(true);
+        liftRestrictionsFunc_ = [](void* looperPtr)
+        {
+            LooperType* looper = reinterpret_cast<LooperType*>(looperPtr);
+            looper->liftRestrictions();
+        };
+
+        if (!fileIo_.openForReading(filename))
+        {
+            abort(false);
+            return;
+        }
+
+        if (!readWavHeader()
+            || !isCompatibleFormat()
+            || LooperType::getNumChannels() != wavHeader_.numAudioChannels)
+        {
+            abort(true);
+            return;
+        }
+
+        totalNumFrames_ = std::min(looper.getSampleStoragePtr().numSamples,
+                                   size_t(getNumSamples(wavHeader_)));
+
+        writeOrReadFunc_ = [](AudioSaveAndRecall* storage, void* looperPtr)
+        {
+            LooperType* looper = reinterpret_cast<LooperType*>(looperPtr);
+
+            const auto numSamplesLeft = storage->totalNumFrames_ - storage->numFramesDone_;
+            const auto numFramesInThisChunk = std::min(numSamplesLeft, kNumFramesPerChunk_);
+
+            const auto numSamplesRead = storage->readBuffer(looper->getSampleStoragePtr(),
+                                                            storage->numFramesDone_,
+                                                            numFramesInThisChunk);
+            if (numSamplesRead < 0)
+            {
+                return ReadOrWriteResult::error;
+            }
+
+            storage->numFramesDone_ += numSamplesRead;
+
+            const auto isNowDone = storage->totalNumFrames_ == storage->numFramesDone_;
+            if (isNowDone)
+            {
+                looper->setPlaybackLength(storage->totalNumFrames_);
+                storage->fileIo_.closeFile();
+                return ReadOrWriteResult::completed;
+            }
+            return ReadOrWriteResult::inProgress;
+        };
+    }
+
+    float getCurrentProgress() const
+    {
+        if (totalNumFrames_ <= 0)
+            return -1.0f;
+        return float(numFramesDone_) / float(totalNumFrames_);
+    }
+
+    bool isSavingOrRecalling() const
+    {
+        return totalNumFrames_ > 0;
+    }
+
+    void readOrWriteNextChunk()
+    {
+        if (writeOrReadFunc_)
+        {
+            const auto result = writeOrReadFunc_(this, looperPtr_);
+
+            if (result == ReadOrWriteResult::error)
+            {
+                abort(true);
+                return;
+            }
+            else if (result == ReadOrWriteResult::completed)
+            {
+                liftRestrictionsFunc_(looperPtr_);
+                if (doneCallback_)
+                {
+                    doneCallback_(doneCallbackContext_, AudioSaveAndRecallResult::ok);
+                }
+
+                doneCallback_ = nullptr;
+                doneCallbackContext_ = nullptr;
+                liftRestrictionsFunc_ = nullptr;
+                looperPtr_ = nullptr;
+            }
+        }
+    }
+
+    FileIoProvider& getFileIoProviderForTesting() { return fileIo_; }
+
+    void abort()
+    {
+        if (isSavingOrRecalling())
+        {
+            abort(true);
+        }
+    }
+
+private:
+    void abort(bool shouldCloseFile)
+    {
+        if (shouldCloseFile)
+            fileIo_.closeFile();
+
+        if (liftRestrictionsFunc_)
+        {
+            liftRestrictionsFunc_(looperPtr_);
+        }
+
+        if (doneCallback_)
+        {
+            doneCallback_(doneCallbackContext_, AudioSaveAndRecallResult::error);
+        }
+
+        doneCallback_ = nullptr;
+        doneCallbackContext_ = nullptr;
+        liftRestrictionsFunc_ = nullptr;
+        looperPtr_ = nullptr;
+        totalNumFrames_ = 0;
+        numFramesDone_ = 0;
+    }
+
+    bool writeWavHeader(size_t totalNumFrames, size_t numChannelsPerFrame, int sampleRate)
+    {
+        wavHeader_ = makeWavFileHeader32bitInt(sampleRate, numChannelsPerFrame, totalNumFrames);
+
+        return fileIo_.write(&wavHeader_, sizeof(wavHeader_));
+    }
+
+    bool readWavHeader()
+    {
+        const auto skipForwardUntil = [&](int32_t value)
+        {
+            int32_t last4Bytes = 0;
+            while (last4Bytes != value)
+            {
+                uint8_t nextByte;
+                if (fileIo_.read(&nextByte, 1) != 1)
+                {
+                    return false;
+                }
+
+                last4Bytes = ((last4Bytes >> 8) & 0x00FFFFFF)
+                             | (nextByte << 24);
+            }
+            return true;
+        };
+
+        // read Master RIFF chunk
+        {
+            const auto kMasterRiffChunkSize = 3 * sizeof(int32_t);
+            const auto numBytesRead = fileIo_.read(&wavHeader_.fileTypeBlocId, kMasterRiffChunkSize);
+
+            // invalid Master RIFF chunk
+            if (numBytesRead != kMasterRiffChunkSize
+                || wavHeader_.fileTypeBlocId != 0x46464952 // "RIFF"
+                || wavHeader_.fileFormatId != 0x45564157 // "WAVE"
+            )
+            {
+                return false;
+            }
+        }
+
+        // read fmt chunk
+        {
+            if (!skipForwardUntil(0x20746d66)) // "fmt"
+            {
+                return false;
+            }
+            wavHeader_.formatBlocId = 0x20746d66;
+
+            const auto kFmtChunkContentSize = 5 * sizeof(int32_t);
+            if (fileIo_.read(&wavHeader_.formatBlocSize, kFmtChunkContentSize) != kFmtChunkContentSize)
+            {
+                return false;
+            }
+
+            if (wavHeader_.formatBlocSize < 0x10) // fmt chunk size can never be <16bytes
+            {
+                return false;
+            }
+        }
+
+        // there can be additional sections in the file. Skip forward if our
+        // data section doesn't point to the right data yet.
+        {
+            if (!skipForwardUntil(0x61746164)) // "data"
+            {
+                return false;
+            }
+
+            wavHeader_.dataBlocId = 0x61746164;
+            if (fileIo_.read(&wavHeader_.dataBlocSize, sizeof(wavHeader_.dataBlocSize)) != sizeof(wavHeader_.dataBlocSize))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    bool isCompatibleFormat() const
+    {
+        const auto isCompatibleSampleFormat =
+            // 16bit PCM or 24bit PCM or 32bit PCM
+            (wavHeader_.audioFormat == WavFileFormatCode::pcm
+             && (wavHeader_.numBitsPerSample == 16
+                 || wavHeader_.numBitsPerSample == 24
+                 || wavHeader_.numBitsPerSample == 32))
+            // 32bit float
+            || (wavHeader_.audioFormat == WavFileFormatCode::ieeeFloat
+                && wavHeader_.numBitsPerSample == 32);
+
+        const auto isCompatibleNumChannels =
+            wavHeader_.numAudioChannels == 1
+            || wavHeader_.numAudioChannels == 2;
+
+        return isCompatibleSampleFormat && isCompatibleNumChannels;
+    }
+
+    template <size_t numChannels>
+    bool writeBuffer(LooperStoragePtr<numChannels> storage, const size_t startFrame, const size_t numFrames)
+    {
+        float* inPtr[numChannels];
+
+        for (size_t ch = 0; ch < numChannels; ch++)
+            inPtr[ch] = &storage.data[ch][startFrame];
+
+        int32_t* outPtr = &writeBuffer_[0];
+
+        size_t numFramesLeft = numFrames;
+        while (numFramesLeft > 0)
+        {
+            for (size_t ch = 0; ch < numChannels; ch++)
+            {
+                *outPtr = f2s32(*inPtr[ch]);
+                outPtr++;
+                inPtr[ch]++;
+            }
+            numFramesLeft--;
+        }
+
+        const auto numBytes = std::distance(&writeBuffer_[0], outPtr) * sizeof(int32_t);
+        return fileIo_.write(writeBuffer_, numBytes);
+    }
+
+    template <size_t numChannels>
+    int32_t readBuffer(LooperStoragePtr<numChannels> storage, const size_t startFrame, const size_t maxNumFrames)
+    {
+        float* outPtr[numChannels];
+
+        for (size_t ch = 0; ch < numChannels; ch++)
+            outPtr[ch] = &storage.data[ch][startFrame];
+
+        uint8_t* inPtr = reinterpret_cast<uint8_t*>(&writeBuffer_[0]);
+        int32_t numFramesRead = 0;
+
+        if (wavHeader_.audioFormat == WavFileFormatCode::ieeeFloat)
+        {
+            constexpr auto kFrameSize = sizeof(float);
+            const auto maxNumBytes = maxNumFrames * numChannels * kFrameSize;
+            const auto bytesRead = fileIo_.read(writeBuffer_, maxNumBytes);
+
+            if (bytesRead < 0)
+            {
+                return -1;
+            }
+
+            numFramesRead = bytesRead / kFrameSize;
+            size_t numFramesLeft = numFramesRead;
+            while (numFramesLeft > 0)
+            {
+                for (size_t ch = 0; ch < numChannels; ch++)
+                {
+                    *outPtr[ch] = *reinterpret_cast<float*>(inPtr);
+                    inPtr += kFrameSize;
+                    outPtr[ch]++;
+                }
+                numFramesLeft--;
+            }
+        }
+        else if (wavHeader_.audioFormat == WavFileFormatCode::pcm && wavHeader_.numBitsPerSample == 32)
+        {
+            constexpr auto kFrameSize = sizeof(int32_t);
+            const auto maxNumBytes = maxNumFrames * numChannels * kFrameSize;
+            const auto bytesRead = fileIo_.read(writeBuffer_, maxNumBytes);
+
+            if (bytesRead < 0)
+            {
+                return -1;
+            }
+
+            numFramesRead = bytesRead / kFrameSize;
+            size_t numFramesLeft = numFramesRead;
+            while (numFramesLeft > 0)
+            {
+                for (size_t ch = 0; ch < numChannels; ch++)
+                {
+                    *outPtr[ch] = s322f(*reinterpret_cast<int32_t*>(inPtr));
+                    inPtr += kFrameSize;
+                    outPtr[ch]++;
+                }
+                numFramesLeft--;
+            }
+        }
+        else if (wavHeader_.audioFormat == WavFileFormatCode::pcm && wavHeader_.numBitsPerSample == 24)
+        {
+            constexpr auto kFrameSize = sizeof(int8_t) * 3;
+            const auto maxNumBytes = maxNumFrames * numChannels * kFrameSize;
+            const auto bytesRead = fileIo_.read(writeBuffer_, maxNumBytes);
+
+            if (bytesRead < 0)
+            {
+                return -1;
+            }
+
+            numFramesRead = bytesRead / kFrameSize;
+            size_t numFramesLeft = numFramesRead;
+            while (numFramesLeft > 0)
+            {
+                for (size_t ch = 0; ch < numChannels; ch++)
+                {
+                    *outPtr[ch] = s242f(*reinterpret_cast<int32_t*>(inPtr) & 0xFFFFFF);
+                    inPtr += kFrameSize;
+                    outPtr[ch]++;
+                }
+                numFramesLeft--;
+            }
+        }
+        else if (wavHeader_.audioFormat == WavFileFormatCode::pcm && wavHeader_.numBitsPerSample == 16)
+        {
+            constexpr auto kFrameSize = sizeof(int16_t);
+            const auto maxNumBytes = maxNumFrames * numChannels * kFrameSize;
+            const auto bytesRead = fileIo_.read(writeBuffer_, maxNumBytes);
+
+            if (bytesRead < 0)
+            {
+                return -1;
+            }
+
+            numFramesRead = bytesRead / kFrameSize;
+            size_t numFramesLeft = numFramesRead;
+            while (numFramesLeft > 0)
+            {
+                for (size_t ch = 0; ch < numChannels; ch++)
+                {
+                    *outPtr[ch] = s162f(*reinterpret_cast<int16_t*>(inPtr));
+                    inPtr += kFrameSize;
+                    outPtr[ch]++;
+                }
+                numFramesLeft--;
+            }
+        }
+
+        return numFramesRead / numChannels;
+    }
+
+    AudioFileName makeFileNameWithoutExtensionFor(const StorageBank bank,
+                                                  const int slot)
+    {
+        auto filename = libraryBaseFolder_;
+        switch (bank)
+        {
+            case StorageBank::green:
+                filename.Append("green-");
+                break;
+            case StorageBank::yellow:
+                filename.Append("yellow-");
+                break;
+            case StorageBank::red:
+                filename.Append("red-");
+                break;
+            default:
+                return "";
+        }
+        switch (slot / 4)
+        {
+            case 0:
+                filename.Append("A");
+                break;
+            case 1:
+                filename.Append("B");
+                break;
+            case 2:
+                filename.Append("C");
+                break;
+            case 3:
+                filename.Append("D");
+                break;
+            default:
+                return "";
+        }
+        switch (slot % 4)
+        {
+            case 0:
+                filename.Append("0");
+                break;
+            case 1:
+                filename.Append("1");
+                break;
+            case 2:
+                filename.Append("2");
+                break;
+            case 3:
+                filename.Append("3");
+                break;
+            default:
+                return "";
+        }
+        return filename;
+    }
+
+    AudioFileName makeWavFileNameFor(const StorageBank bank,
+                                     const int slot)
+    {
+        auto name = makeFileNameWithoutExtensionFor(bank, slot);
+        name.Append(".wav");
+        return name;
+    }
+
+    static constexpr size_t kNumFramesPerChunk_ = 1000;
+    static constexpr size_t kBitsPerSample_ = 32u;
+    static constexpr size_t kMaxNumChannels_ = 2u;
+    static constexpr size_t kWriteBufferSizeBytes_ = kNumFramesPerChunk_
+                                                     * kMaxNumChannels_
+                                                     * kBitsPerSample_ / 8u;
+
+    WavFileHeader wavHeader_;
+
+    enum class ReadOrWriteResult
+    {
+        inProgress,
+        completed,
+        error
+    };
+    typedef ReadOrWriteResult (*WriteOrReadFuncPtr)(AudioSaveAndRecall* storage, void* looper);
+    typedef void (*LiftRestrictionsFuncPtr)(void* looper);
+
+    FileIoProvider fileIo_;
+
+    size_t totalNumFrames_ = 0;
+    size_t numFramesDone_ = 0;
+    WriteOrReadFuncPtr writeOrReadFunc_ = nullptr;
+    LiftRestrictionsFuncPtr liftRestrictionsFunc_ = nullptr;
+    void* looperPtr_ = nullptr;
+    AudioSaveAndRecallDoneCallbackPtr doneCallback_ = nullptr;
+    void* doneCallbackContext_ = nullptr;
+
+    int32_t writeBuffer_[kWriteBufferSizeBytes_ / sizeof(int32_t)];
+
+    static constexpr auto kNumSlots = 16;
+    static constexpr auto kNumBanks = int(StorageBank::count);
+    int16_t isStorageSlotUsedBitfield_[kNumBanks];
+
+    const AudioFileName libraryBaseFolder_ = "loops";
 };
diff --git a/firmware/src/hardware/FatFsFileIo.h b/firmware/src/hardware/FatFsFileIo.h
index 2f81384..4d37701 100644
--- a/firmware/src/hardware/FatFsFileIo.h
+++ b/firmware/src/hardware/FatFsFileIo.h
@@ -19,4 +19,30 @@
 
 class FatFsFileIo
 {
+public:
+    bool openForReading(const char* fileName)
+    {
+        (void) (fileName);
+        return false;
+    }
+
+    bool openForWriting(const char* fileName)
+    {
+        (void) (fileName);
+        return false;
+    }
+
+    bool write(void* data, size_t size)
+    {
+        return false;
+    }
+
+    int32_t read(void* data, size_t maxSize)
+    {
+        return -1;
+    }
+
+    void closeFile()
+    {
+    }
 };
\ No newline at end of file
diff --git a/firmware/tests/AudioSaveAndRecall_gtest.cpp b/firmware/tests/AudioSaveAndRecall_gtest.cpp
new file mode 100644
index 0000000..4c0312f
--- /dev/null
+++ b/firmware/tests/AudioSaveAndRecall_gtest.cpp
@@ -0,0 +1,540 @@
+/**
+ * Copyright (C) Johannes Elliesen, 2024
+ *
+ * This program 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
+ * any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock-matchers.h>
+#include <math.h>
+#include <cmath>
+#include <iostream>
+#include <fstream>
+#include <string>
+
+// uncomment to update the test references
+// #define WRITE_REFERENCES
+
+#include "libDaisyCombined.h"
+#include "AudioSaveAndRecall.h"
+namespace
+{
+    static constexpr auto kSampleRate = 48000;
+
+    std::vector<float> makeSawWave(double frequency, size_t numSamples)
+    {
+        const float kIncrement = float(2.0f * frequency / double(kSampleRate));
+        float value = 0.0f;
+
+        std::vector<float> result(numSamples);
+        for (auto& sample : result)
+        {
+            sample = value;
+            value += kIncrement;
+            if (value >= 0.9999f)
+            {
+                value = -1.0f;
+            }
+        }
+
+        return result;
+    }
+
+    std::vector<std::byte> readReferenceFile(const char* filename)
+    {
+        std::ifstream referenceFile(filename, std::ios::binary);
+        EXPECT_TRUE(referenceFile.is_open());
+
+        std::vector<std::byte> contents;
+
+        char b;
+        while (referenceFile.read(&b, sizeof(b)))
+        {
+            contents.push_back(std::byte(b));
+        }
+        referenceFile.close();
+
+        return contents;
+    }
+
+#ifdef WRITE_REFERENCES
+    void writeReferenceFile(const char* filename, const std::vector<std::byte>& data)
+    {
+        std::ofstream referenceFile(filename, std::ios::binary);
+        EXPECT_TRUE(referenceFile.is_open());
+
+        for (std::byte byte : data)
+        {
+            referenceFile << std::ofstream::char_type(byte);
+        }
+        referenceFile.close();
+    }
+#endif
+} // namespace
+
+class TestFileIo
+{
+public:
+    bool openForReading(const AudioFileName& fileName)
+    {
+        lastFileName_ = fileName;
+
+        if (simulateFileOpenError_)
+            return false;
+
+        readIndex_ = 0;
+        return true;
+    }
+
+    bool openForWriting(const AudioFileName& fileName)
+    {
+        lastFileName_ = fileName;
+
+        if (simulateFileOpenError_)
+            return false;
+
+        dataWritten_.clear();
+        return true;
+    }
+
+    bool write(void* data, size_t size)
+    {
+        if (simulateFileWriteError_)
+            return false;
+
+        dataWritten_.insert(dataWritten_.end(),
+                            static_cast<std::byte*>(data),
+                            static_cast<std::byte*>(data) + size);
+        return true;
+    }
+
+    int32_t read(void* data, size_t maxSize)
+    {
+        if (simulateFileOpenError_)
+        {
+            return -1;
+        }
+
+        uint8_t* outPtr = reinterpret_cast<uint8_t*>(data);
+
+        const auto numRead = std::min(maxSize, dataToRead_.size() - readIndex_);
+        for (size_t i = 0; i < numRead; i++)
+        {
+            *outPtr = uint8_t(dataToRead_[readIndex_ + i]);
+            outPtr++;
+        }
+
+        readIndex_ += numRead;
+        return numRead;
+    }
+
+    void closeFile()
+    {
+        closeFileCalled_ = true;
+    }
+
+    AudioFileName lastFileName_;
+    std::vector<std::byte> dataWritten_;
+    std::vector<std::byte> dataToRead_;
+    size_t readIndex_ = 0;
+    bool closeFileCalled_ = false;
+
+    bool simulateFileOpenError_ = false;
+    bool simulateFileWriteError_ = false;
+};
+
+class AudioSaveAndRecallFixture : public ::testing::Test
+{
+public:
+    AudioSaveAndRecallFixture() :
+        monoLooper_(monoBuffer_),
+        stereoLooper_(stereoBuffer_)
+    {
+        fillBuffersWithSilence();
+        monoLooper_.setPlaybackLength(kNumSamples);
+        stereoLooper_.setPlaybackLength(kNumSamples);
+    }
+
+    static constexpr auto kNumSamples = 48000;
+    LooperStorage<kNumSamples, 1> monoBuffer_;
+    LooperStorage<kNumSamples, 2> stereoBuffer_;
+    TapeLooper<kSampleRate, 1> monoLooper_;
+    TapeLooper<kSampleRate, 2> stereoLooper_;
+
+    AudioSaveAndRecallResult doneCallbackResult_ =
+        AudioSaveAndRecallResult(-1); // invalid
+
+    static void doneCallback(void* contextPtr, AudioSaveAndRecallResult result)
+    {
+        auto* resultFlag = reinterpret_cast<AudioSaveAndRecallResult*>(contextPtr);
+        *resultFlag = result;
+    };
+
+    void fillBuffersWithSilence()
+    {
+        for (size_t i = 0; i < kNumSamples; i++)
+        {
+            stereoBuffer_.data[0][i] = 0.0f;
+            stereoBuffer_.data[1][i] = 0.0f;
+            monoBuffer_.data[0][i] = 0.0f;
+        }
+    }
+
+    void fillBuffersWithSineWaves()
+    {
+        const auto freq1 = 480.0f;
+        const auto phaseIncrement1 = freq1 / float(kSampleRate);
+        const auto freq2 = 640.0f;
+        const auto phaseIncrement2 = freq2 / float(kSampleRate);
+
+        auto phase1 = 0.0f;
+        auto phase2 = 0.0f;
+
+        for (size_t i = 0; i < kNumSamples; i++)
+        {
+            stereoBuffer_.data[0][i] = std::sin(phase1 * 2.0f * M_PI);
+            stereoBuffer_.data[1][i] = std::sin(phase2 * 2.0f * M_PI);
+            monoBuffer_.data[0][i] = stereoBuffer_.data[0][i];
+
+            phase1 += phaseIncrement1;
+            if (phase1 >= 1.0f)
+                phase1 -= 1.0f;
+            phase2 += phaseIncrement2;
+            if (phase2 >= 1.0f)
+                phase2 -= 1.0f;
+        }
+    }
+};
+
+TEST_F(AudioSaveAndRecallFixture, a_saveToFile_failWhenNoDataInLooper)
+{
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    monoLooper_.setPlaybackLength(0);
+
+    sut.getFileIoProviderForTesting().simulateFileOpenError_ = true;
+    sut.startSavingToFile("dummyFilename",
+                          monoLooper_,
+                          &doneCallback,
+                          &doneCallbackResult_);
+
+    // doesn't even open the file
+    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "");
+    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::error);
+    EXPECT_EQ(sut.getCurrentProgress(), -1.0f);
+}
+
+TEST_F(AudioSaveAndRecallFixture, b_saveToFile_failWhenFileDoesntOpen)
+{
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    sut.getFileIoProviderForTesting().simulateFileOpenError_ = true;
+    sut.startSavingToFile("dummyFilename",
+                          monoLooper_,
+                          &doneCallback,
+                          &doneCallbackResult_);
+
+    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::error);
+    EXPECT_EQ(sut.getCurrentProgress(), -1.0f);
+    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+}
+
+TEST_F(AudioSaveAndRecallFixture, c_saveToFile_failWhenErrorWhileWriting)
+{
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    sut.startSavingToFile("dummyFilename",
+                          monoLooper_,
+                          &doneCallback,
+                          &doneCallbackResult_);
+
+    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult(-1)); // not called yet
+    EXPECT_EQ(sut.getCurrentProgress(), 0.0f);
+    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+
+    // make some progress
+    sut.readOrWriteNextChunk();
+    EXPECT_GT(sut.getCurrentProgress(), 0.0f);
+    EXPECT_LT(sut.getCurrentProgress(), 1.0f);
+
+    // simulate file IO error
+    sut.getFileIoProviderForTesting().simulateFileWriteError_ = true;
+    sut.readOrWriteNextChunk();
+
+    // operation was aborted
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::error);
+    EXPECT_EQ(sut.getCurrentProgress(), -1.0f);
+    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+}
+
+TEST_F(AudioSaveAndRecallFixture, d_saveToFile_saveFileButWaitUntilRecordingDoneAndPreventNewRecording)
+{
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    monoLooper_.switchState(LooperState::recording);
+    monoLooper_.recorderForTesting().setRecordingProgressForTesting(2000);
+
+    sut.startSavingToFile("dummyFilename",
+                          monoLooper_,
+                          &doneCallback,
+                          &doneCallbackResult_);
+
+    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult(-1)); // not called yet
+    EXPECT_EQ(sut.getCurrentProgress(), 0.0f);
+    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+
+    // the looper was stopped when saving started...
+    EXPECT_EQ(monoLooper_.getState(), LooperState::stopped);
+    // the looper should still be recording (crossfading out)
+    EXPECT_TRUE(monoLooper_.isRecording());
+
+    // attempt to write
+    sut.readOrWriteNextChunk();
+    // nothing happened yet
+    EXPECT_EQ(sut.getCurrentProgress(), 0.0f);
+
+    // simulate that crossfading is now complete by brutally aborting the recording
+    monoLooper_.recorderForTesting().stopRecordingImmediately();
+    monoLooper_.setPlaybackLength(kNumSamples);
+
+    // attempt to write again
+    sut.readOrWriteNextChunk();
+    // now we have some progress
+    EXPECT_GT(sut.getCurrentProgress(), 0.0f);
+}
+
+TEST_F(AudioSaveAndRecallFixture, e_saveToFile_saveFileAndAllowPlaybackButPreventNewRecording)
+{
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    sut.startSavingToFile("dummyFilename",
+                          monoLooper_,
+                          &doneCallback,
+                          &doneCallbackResult_);
+
+    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult(-1)); // not called yet
+    EXPECT_EQ(sut.getCurrentProgress(), 0.0f);
+    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+
+    // attempt to start a new recording while we're saving
+    monoLooper_.switchState(LooperState::recording);
+    // but new recordings should be prevented
+    EXPECT_EQ(monoLooper_.getState(), LooperState::stopped);
+    EXPECT_FALSE(monoLooper_.isRecording());
+
+    // but we can still play the loop while we're saving
+    monoLooper_.switchState(LooperState::playing);
+    EXPECT_EQ(monoLooper_.getState(), LooperState::playing);
+
+    // complete the saving operation
+    int timeout = 1000;
+    while (timeout-- > 0 && doneCallbackResult_ != AudioSaveAndRecallResult::ok)
+    {
+        sut.readOrWriteNextChunk();
+    }
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::ok);
+
+    // attempt a recording again
+    monoLooper_.switchState(LooperState::recording);
+    // and new recordings should be allowed again
+    EXPECT_EQ(monoLooper_.getState(), LooperState::recording);
+    EXPECT_TRUE(monoLooper_.isRecording());
+}
+
+TEST_F(AudioSaveAndRecallFixture, f_saveToFile_saveFileAndReportProgress)
+{
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    sut.startSavingToFile("dummyFilename",
+                          monoLooper_,
+                          &doneCallback,
+                          &doneCallbackResult_);
+
+    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult(-1)); // not called yet
+    EXPECT_EQ(sut.getCurrentProgress(), 0.0f);
+    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+
+    // write until completed
+    int timeout = 1000;
+    auto lastProgress = 0.0f;
+    while (timeout-- > 0 && doneCallbackResult_ != AudioSaveAndRecallResult::ok)
+    {
+        sut.readOrWriteNextChunk();
+        EXPECT_GT(sut.getCurrentProgress(), lastProgress);
+        lastProgress = sut.getCurrentProgress();
+    }
+    EXPECT_EQ(sut.getCurrentProgress(), 1.0f);
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::ok);
+    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+}
+
+TEST_F(AudioSaveAndRecallFixture, g_saveToFile_producesValidMonoWavFile)
+{
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    constexpr auto kNumTestSamples = 4800;
+    constexpr auto kReferenceFilename = "data/monoSineWaves.wav";
+
+    fillBuffersWithSineWaves();
+    monoLooper_.setPlaybackLength(kNumTestSamples);
+
+    sut.startSavingToFile("dummyFilename",
+                          monoLooper_,
+                          &doneCallback,
+                          &doneCallbackResult_);
+
+    // write until completed
+    int timeout = 1000;
+    while (timeout-- > 0 && doneCallbackResult_ != AudioSaveAndRecallResult::ok)
+    {
+        sut.readOrWriteNextChunk();
+    }
+    EXPECT_EQ(sut.getCurrentProgress(), 1.0f);
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::ok);
+    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+
+#ifdef WRITE_REFERENCES
+    writeReferenceFile(kReferenceFilename, sut.getFileIoProviderForTesting().dataWritten_);
+#endif
+
+    const auto expectedFileContents = readReferenceFile(kReferenceFilename);
+    EXPECT_EQ(sut.getFileIoProviderForTesting().dataWritten_, expectedFileContents);
+}
+
+TEST_F(AudioSaveAndRecallFixture, h_saveToFile_producesValidStereoWavFile)
+{
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    constexpr auto kNumTestSamples = 4800;
+    constexpr auto kReferenceFilename = "data/stereoSineWaves.wav";
+
+    fillBuffersWithSineWaves();
+    stereoLooper_.setPlaybackLength(kNumTestSamples);
+
+    sut.startSavingToFile("dummyFilename",
+                          stereoLooper_,
+                          &doneCallback,
+                          &doneCallbackResult_);
+
+    // write until completed
+    int timeout = 1000;
+    while (timeout-- > 0 && doneCallbackResult_ != AudioSaveAndRecallResult::ok)
+    {
+        sut.readOrWriteNextChunk();
+    }
+    EXPECT_EQ(sut.getCurrentProgress(), 1.0f);
+    EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::ok);
+    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+
+#ifdef WRITE_REFERENCES
+    writeReferenceFile(kReferenceFilename, sut.getFileIoProviderForTesting().dataWritten_);
+#endif
+
+    const auto expectedFileContents = readReferenceFile(kReferenceFilename);
+    EXPECT_EQ(sut.getFileIoProviderForTesting().dataWritten_, expectedFileContents);
+}
+
+class AudioSaveAndRecallParameterizedFileFormatFixture :
+    public AudioSaveAndRecallFixture,
+    public ::testing::WithParamInterface<std::tuple<const char*, const char*, float>>
+{
+};
+
+TEST_P(AudioSaveAndRecallParameterizedFileFormatFixture, canReadMonoWav)
+{
+    const auto [referenceFileNameMono, referenceFileNameStereo, epsilon] = GetParam();
+
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    constexpr auto kExpectedNumSamples = 48;
+
+    sut.getFileIoProviderForTesting().dataToRead_ = readReferenceFile(referenceFileNameMono);
+
+    sut.startReadingFromFile("dummyFilename",
+                             monoLooper_,
+                             &doneCallback,
+                             &doneCallbackResult_);
+
+    // read until completed
+    int timeout = 1000;
+    while (timeout-- > 0 && doneCallbackResult_ != AudioSaveAndRecallResult::ok)
+    {
+        sut.readOrWriteNextChunk();
+    }
+
+    const auto kExpectedSawWav = makeSawWave(1000.0, kExpectedNumSamples);
+
+    const auto actualSamples = std::vector<float>(monoBuffer_.data[0],
+                                                  monoBuffer_.data[0] + monoLooper_.getPlaybackLength());
+
+    EXPECT_THAT(actualSamples,
+                ::testing::Pointwise(::testing::FloatNear(epsilon),
+                                     kExpectedSawWav));
+}
+
+TEST_P(AudioSaveAndRecallParameterizedFileFormatFixture, canReadStereoWav)
+{
+    const auto [referenceFileNameMono, referenceFileNameStereo, epsilon] = GetParam();
+
+    AudioSaveAndRecall<TestFileIo> sut;
+
+    constexpr auto kExpectedNumSamples = 48;
+
+    sut.getFileIoProviderForTesting().dataToRead_ = readReferenceFile(referenceFileNameStereo);
+
+    sut.startReadingFromFile("dummyFilename",
+                             stereoLooper_,
+                             &doneCallback,
+                             &doneCallbackResult_);
+
+    // read until completed
+    int timeout = 1000;
+    while (timeout-- > 0 && doneCallbackResult_ != AudioSaveAndRecallResult::ok)
+    {
+        sut.readOrWriteNextChunk();
+    }
+
+    const auto kExpectedSawWavLeft = makeSawWave(1000.0, kExpectedNumSamples);
+    const auto kExpectedSawWavRight = makeSawWave(2000.0, kExpectedNumSamples);
+
+    const auto actualSamplesLeft = std::vector<float>(stereoBuffer_.data[0],
+                                                      stereoBuffer_.data[0] + stereoLooper_.getPlaybackLength());
+    const auto actualSamplesRight = std::vector<float>(stereoBuffer_.data[1],
+                                                       stereoBuffer_.data[1] + stereoLooper_.getPlaybackLength());
+
+    EXPECT_THAT(actualSamplesLeft,
+                ::testing::Pointwise(::testing::FloatNear(epsilon),
+                                     kExpectedSawWavLeft));
+    EXPECT_THAT(actualSamplesRight,
+                ::testing::Pointwise(::testing::FloatNear(epsilon),
+                                     kExpectedSawWavRight));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    AudioSaveAndRecall_loadFromFile_canReadWavs,
+    AudioSaveAndRecallParameterizedFileFormatFixture,
+    ::testing::Values(
+        std::make_tuple("data/monoSaw_int16.wav", "data/stereoSaw_int16.wav", 3e-4f),
+        std::make_tuple("data/monoSaw_int24.wav", "data/stereoSaw_int24.wav", 1e-6f),
+        std::make_tuple("data/monoSaw_int32.wav", "data/stereoSaw_int32.wav", 1e-6f),
+        std::make_tuple("data/monoSaw_float.wav", "data/stereoSaw_float.wav", 1e-6f),
+        // Ableton uses the JUNK segment to encode a messsage in the file.
+        std::make_tuple("data/monoSaw_float.wav", "data/stereoSaw_float_Ableton.wav", 1e-6f)));
diff --git a/firmware/tests/data/monoSaw_float.wav b/firmware/tests/data/monoSaw_float.wav
new file mode 100644
index 0000000000000000000000000000000000000000..eb2a36c07b3a3243d879e124093b70898586c24e
GIT binary patch
literal 272
zcmWm7I|{-;6oujAqYx__!7_C!o0KN8h+u3)7;Ozo5Wy~jWj2x41x%J8N!)}>uu0(>
z{4+3|?_6fMyY*@{>Pd&?K1y$yGm$h<Px%Y{`Wnhnnw+vBb<W*J%T4!&FM2$`7by>B
z_?%?Po9s?$-9>5b0{YlD#`wG=3%bQ`{J||&P}*@|%ruZ3>|zgxIK~Da@fF{3-jEHw
kVU7)safm(aVh2z07>jIc_SNjI*^djHlZNhMb@K{We`<eNod5s;

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/monoSaw_int16.wav b/firmware/tests/data/monoSaw_int16.wav
new file mode 100644
index 0000000000000000000000000000000000000000..bc142e973bb85a03fa53e03265bfb93584194703
GIT binary patch
literal 140
zcmWIYbaQKAU|<M$40BD(Em05vvKfJ}VK<Ob&d9*TAi$84Sdy3k<T5aXv99D|5(pMu
zEA?MKRCTr1fBi7iHCBJ^qg<DGu?GZ%u8aB~ADX%*>tB9E>B=gGhVa(qU91xVr>>jz
rZ+_^~wX6QDkJ`F?7t?{zqbpA_UkJLo?$+P?5l>gVV*U{Pb@eX*S%o)$

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/monoSaw_int24.wav b/firmware/tests/data/monoSaw_int24.wav
new file mode 100644
index 0000000000000000000000000000000000000000..d23edd2827f8a10c333acab1e6ce63f8e8803daa
GIT binary patch
literal 188
zcmV;t07L&$Nk&Gr00012K~_a(ZFC?I000010097iy8r-yG6Dbt02lydVRT`T00000
z003201+1zH{r?YHRTZbI8Uz3!QdK3bsw)2fFIQDHsj4~x06<h#MXjnz{Qpl{RaK{|
zS_1%JQ&nZGs%rlKZ&+1zsj7Ma0DxFkg{P{D0|1axRh6!)n*INuSXHH{s;UA2uvAsG
qt*W~H|G!vO#i**v0|3xdRn@Gj+5iCHR8{4ys_Fm$@KaUwud4d-f=m+t

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/monoSaw_int32.wav b/firmware/tests/data/monoSaw_int32.wav
new file mode 100644
index 0000000000000000000000000000000000000000..4ce029db962d115c4f3c45df7d7600d4076144b0
GIT binary patch
literal 236
zcmWm1Aq)X=7>4mbqezM(T~Q=Okxp<M>1O*d>25=?*#wGoMUfOmx?;00T~R1k6iHDe
zfg+fqNFMJ~es8nxICo=AyV|M^MiVQG6BHc4D``^3GChCd$K3xqBI!sq1GAn;E>z89
z%N8lbszqGFWn95_AW{od8`#ByyV%2hJj7!>#WNh>IbPr;Ug0$k@dhi7@DA^BY>OOY
Y)e}DB3%=r;C-MkYpZM*He736JA4~R7u>b%7

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/monoSineWaves.wav b/firmware/tests/data/monoSineWaves.wav
new file mode 100644
index 0000000000000000000000000000000000000000..635cda99cc6a41c51085910deab78c469020b8f4
GIT binary patch
literal 19244
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
Wi?LhUH`dge+^;$~oe>-IT>lSORHljm

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/stereoSaw_float.wav b/firmware/tests/data/stereoSaw_float.wav
new file mode 100644
index 0000000000000000000000000000000000000000..7aaf68f7cfcb726cf385f70eafa70ef64a383f0a
GIT binary patch
literal 472
zcmXYrJx;?w5Jo@#BotB5SfX@8<BBFFu~Q@xp+QI{Z7fiPEJ0=Zy+kgtJ_1UdBha{`
zrpPIHUlL2>*?BWN`<@@B)1MP*K7N@jKbrJf(wR;bzB&9}=u)Yc)oXK3c}F}=#*a5-
zuITgj?_CPHYv(KeZ&gzTH;-Q%v->v2V`L*R5k_z#j>@tm`aPqUm*t8&$=zcnm$vi@
zc<)*G4qn4WgszPPSl#&!{Z2~Z1w4ai@F6^b7jVI6)cxkLD{iC(JZ!v^dH5GOuDzRi
zQFF)sHQD|Pc(98(E;HV+f8lv{52@{+d7j-V-2MsN{sZ{l-+MUk{5HM46Kso<{UhA|
ZE1c{f;PMXY-aW$pBJ3a62bPiJ`X7Q}q=x_i

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/stereoSaw_float_Ableton.wav b/firmware/tests/data/stereoSaw_float_Ableton.wav
new file mode 100644
index 0000000000000000000000000000000000000000..7aa9666c8a81899c5a6c9c260016a6b870842963
GIT binary patch
literal 464
zcmXwzK}y3w6o#LQAYHl1&c&>Q+b&HaXu%W|gwbsyrP4s_qIIFGT%wnlxbOmLdWl@3
zr||pJ8hA|J_ul;TJwJ>_zb9s|w=eg(e;i+#+0*yeqF7Gn#p>FP=gW8ZG3(Ejb8fa+
zyGwS??9}dl%-q|#U6`|Ju`Vid{=YiJH+2ZdiW4|hC2%Sv-g~O+8MD;;4Skeq#!hOs
zW0t`??ZWr)5^hx0)?olETis#aVgk?LF+7G3;SoH88$74)wuh{+HJiYztuon%e{zOK
z+3XuVcjRAk%6|f{<RXqs&KvU2v`_YsUjDK6$#!u0M{xNM;Jv?c_}}YoX1x<^hm-sR
bT>cxJ<X^!}8T6fIl>Cj7e`pRY<_ygr2nMI@

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/stereoSaw_int16.wav b/firmware/tests/data/stereoSaw_int16.wav
new file mode 100644
index 0000000000000000000000000000000000000000..25318d4f683ee62b3787d13d8fb86797376cbeef
GIT binary patch
literal 236
zcmV<I02BXGNk&HG00012K~_a(ZFC?I0000100IDjy8r+H?g9V=01yCVVRT`@00000
z000101*!_G3Re{X5dI%k6|E|(8dEg@AOS#CC96uSDpghgFaKXyHLYr=I#YE7KmveL
zMX8FdN>-KrPye4+RjsP3T2r+EU;@BaWvI%jYFE_(Z~)*|b*t*CdQ|lQfB^tig{lgx
zidGf>j{qQ8m8vSInpQOgpa4KorK(D<s#aD0uK-|IwW?~Vx>j`ozyN?$#jA>~%2k#A
m&j6rT)vBtg+E=v!;Qzl><*Ul8>Q>bN@crLa^{?ux`cd^`7h$CU

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/stereoSaw_int24.wav b/firmware/tests/data/stereoSaw_int24.wav
new file mode 100644
index 0000000000000000000000000000000000000000..ed5f42289ff8e66152e0e6033ee85e9e4940b6a7
GIT binary patch
literal 332
zcmW-bAxr{c0EOQjXrO3ea~3HUl7(UsH(`^agL?;F5jHWfISUjM#X_=BELaroabpyU
z7K(*pqL?Tal7)iqes8|?w)ghFS3J$<Pb{E(?B=d-nyGC77HqWNB2$lJ6Fa!7HEXG;
z^B;lS@RbOZaG4CvmW5QA$$`?+uEz|JTAL%6`(qWP^f?I}#8D+P12u*^EVE@H3$)3c
z)ETPavKyK+;Hg3mC10MyiH)j_X^C}Tvp@}(b7O9Sh0B(-40K1Xq7fUY@V>9aKpl@s
z8xKEb&tZ3@bf8Cvnb7orY=zGeXdt<yjd5r$Bg9CJK(9r%fN30Uhwm@y1e$s58uRgM
ldJ%M_NS`H6EG(iw<d-z_wRAX-;X8&!k*mIzBdssE`U4e#hs*!~

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/stereoSaw_int32.wav b/firmware/tests/data/stereoSaw_int32.wav
new file mode 100644
index 0000000000000000000000000000000000000000..dcf67886951f66aba6b1f090c56c13fa8ebac19a
GIT binary patch
literal 428
zcmXxeAxH#46vpv6;Xp1~ET%0Mlf_~h!yUNk5T1%@4%Dz97;cMcie;1KifMv^ymV!Y
zmMIpK<%$@tSWK2HCjXDcg%3V{^A^6N!_nxW=iJG`@$m9$T5LGydT!0d7s_Yft-HdV
zPo|T|&Hr~Q(x0miEJ0)wx8DluS#>9=Zh4VCGvevnQMI(UC?eP{33h{5_&#3SEs69Y
z-jI?$!^R}h1ygcHZ?Ql!{UWQr;guIzVAo`c*GcsozZr|Hut*$!YuoWAbo=k%0-t5u
zsCw_a{R#K@BUTcn3pOW#-eMJbrq@^|(TludO}0(l{&zg#3taIJyv3Fz2azwkO>DIr
O?8n}0v)PmCuk}BVBbNC9

literal 0
HcmV?d00001

diff --git a/firmware/tests/data/stereoSineWaves.wav b/firmware/tests/data/stereoSineWaves.wav
new file mode 100644
index 0000000000000000000000000000000000000000..136c28a91f594d68de6bf372ea1eda9ce9156906
GIT binary patch
literal 38444
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

literal 0
HcmV?d00001

diff --git a/firmware/tests/libDaisyCombined.h b/firmware/tests/libDaisyCombined.h
index 0998f63..027ac7a 100644
--- a/firmware/tests/libDaisyCombined.h
+++ b/firmware/tests/libDaisyCombined.h
@@ -7,6 +7,8 @@
 #define FBIPMIN (-FBIPMAX) /**< - (1 - LSB) */
 #define F2S32_SCALE 2147483647.f /**< (2 ** 31) - 1 */
 #define S322F_SCALE 4.6566129e-10f /**< 1 / (2** 31) */
+#define S242F_SCALE 1.192092896e-07f /**< 1 / (2 ** 23) */
+#define S24SIGN 0x800000 /**< 2 ** 23 */
 #define S162F_SCALE 3.0517578125e-05f /**< 1 / (2** 15) */
 
 inline int32_t f2s32(float x)
@@ -19,6 +21,11 @@ inline float s322f(int32_t x)
 {
     return (float) x * S322F_SCALE;
 }
+inline float s242f(int32_t x)
+{
+    x = (x ^ S24SIGN) - S24SIGN; // sign extend aka ((x<<8)>>8)
+    return (float) x * S242F_SCALE;
+}
 inline float s162f(int16_t x)
 {
     return (float) x * S162F_SCALE;

From 30359c1a0becd23b0bc2d9e183f0726b68685978 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 10:34:56 +0200
Subject: [PATCH 15/26] feat: LooperController can start save and recall

---
 firmware/src/LooperController.h              | 79 +++++++++++++-------
 firmware/tests/mocks/LooperController_mock.h | 34 ++++++++-
 2 files changed, 82 insertions(+), 31 deletions(-)

diff --git a/firmware/src/LooperController.h b/firmware/src/LooperController.h
index 72af340..ac9d31b 100644
--- a/firmware/src/LooperController.h
+++ b/firmware/src/LooperController.h
@@ -89,24 +89,23 @@ class LooperController
                 AudioSaveAndRecallDoneCallbackPtr doneCallback,
                 void* doneCallbackContext)
     {
-        (void) (bank);
-        (void) (looperIdx);
-        (void) (slot);
-        (void) (doneCallback);
-        (void) (doneCallbackContext);
-        /*
-        audioSaveAndRecall_.startSavingToFile(bank,
-                                              slot,
-                                              loopers_[looperIdx].looper,
-                                              doneCallback,
-                                              doneCallbackContext);
-        */
+        if (loopers_[looperIdx].layout == ChannelLayout::mono)
+            audioSaveAndRecall_.startSavingToFile(bank,
+                                                  slot,
+                                                  loopers_[looperIdx].looper.template as<MonoLooperType>(),
+                                                  doneCallback,
+                                                  doneCallbackContext);
+        else
+            audioSaveAndRecall_.startSavingToFile(bank,
+                                                  slot,
+                                                  loopers_[looperIdx].looper.template as<StereoLooperType>(),
+                                                  doneCallback,
+                                                  doneCallbackContext);
     }
 
     float getCurrentSaveOrLoadProgress()
     {
-        // return audioSaveAndRecall_.getCurrentProgress();
-        return 0.0f;
+        return audioSaveAndRecall_.getCurrentProgress();
     }
 
     void loadFrom(StorageBank bank,
@@ -115,19 +114,45 @@ class LooperController
                   AudioSaveAndRecallDoneCallbackPtr doneCallback,
                   void* doneCallbackContext)
     {
-        (void) (bank);
-        (void) (looperIdx);
-        (void) (slot);
-        (void) (doneCallback);
-        (void) (doneCallbackContext);
-        /*
-        // TODO: Reconfigure to correct channel layout
-        audioSaveAndRecall_.startReadingFromFiles(bank,
-                                                  slot,
-                                                  loopers_[looperIdx].looper,
-                                                  doneCallback,
-                                                  doneCallbackContext);
-        */
+        const auto numChannels = audioSaveAndRecall_.getNumChannelsInFile(bank, slot);
+        if (numChannels == 0)
+        {
+            if (doneCallback)
+            {
+                doneCallback(doneCallbackContext, AudioSaveAndRecallResult::error);
+            }
+            return;
+        }
+
+        if (numChannels == 1 && getChannelLayout(looperIdx) != ChannelLayout::mono)
+        {
+            setChannelLayout(looperIdx, ChannelLayout::mono);
+        }
+        else if (numChannels == 2 && getChannelLayout(looperIdx) != ChannelLayout::stereo)
+        {
+            setChannelLayout(looperIdx, ChannelLayout::stereo);
+        }
+
+        if (loopers_[looperIdx].layout == ChannelLayout::mono)
+            audioSaveAndRecall_.startReadingFromFile(bank,
+                                                     slot,
+                                                     loopers_[looperIdx].looper.template as<MonoLooperType>(),
+                                                     doneCallback,
+                                                     doneCallbackContext);
+        else
+            audioSaveAndRecall_.startReadingFromFile(bank,
+                                                     slot,
+                                                     loopers_[looperIdx].looper.template as<StereoLooperType>(),
+                                                     doneCallback,
+                                                     doneCallbackContext);
+    }
+
+    void abortLoadOrSaveOperation()
+    {
+        if (audioSaveAndRecall_.isSavingOrRecalling())
+        {
+            audioSaveAndRecall_.abort();
+        }
     }
 
     void setChannelLayout(size_t looperIdx, ChannelLayout channelLayout)
diff --git a/firmware/tests/mocks/LooperController_mock.h b/firmware/tests/mocks/LooperController_mock.h
index b3362f9..ece8ae9 100644
--- a/firmware/tests/mocks/LooperController_mock.h
+++ b/firmware/tests/mocks/LooperController_mock.h
@@ -23,6 +23,7 @@
 
 #include <dsp/TapeLooper.h>
 #include "LooperController.h"
+#include "AudioSaveAndRecall.h"
 
 template <size_t numLoopers>
 class LooperControllerMock
@@ -64,20 +65,39 @@ class LooperControllerMock
             return LooperState::stopped;
     }
 
-    void saveTo(size_t looperIdx, size_t slot)
+    void saveTo(StorageBank bank,
+                size_t looperIdx,
+                size_t slot,
+                AudioSaveAndRecallDoneCallbackPtr doneCallback,
+                void* doneCallbackContext)
     {
+        (void) (doneCallback);
+        (void) (doneCallbackContext);
+
         std::ostringstream stringStream;
-        stringStream << "saveTo(" << looperIdx << ", " << slot << ")";
+        stringStream << "saveTo(" << int(bank) << ", " << looperIdx << ", " << slot << ")";
         events += stringStream.str() + "\n";
     }
 
-    void loadFrom(size_t looperIdx, size_t slot)
+    void loadFrom(StorageBank bank,
+                  size_t looperIdx,
+                  size_t slot,
+                  AudioSaveAndRecallDoneCallbackPtr doneCallback,
+                  void* doneCallbackContext)
     {
+        (void) (doneCallback);
+        (void) (doneCallbackContext);
+
         std::ostringstream stringStream;
-        stringStream << "loadFrom(" << looperIdx << ", " << slot << ")";
+        stringStream << "loadFrom(" << int(bank) << ", " << looperIdx << ", " << slot << ")";
         events += stringStream.str() + "\n";
     }
 
+    void abortLoadOrSaveOperation()
+    {
+        events += "abortLoadOrSaveOperation()\n";
+    }
+
     void setChannelLayout(size_t looperIdx, ChannelLayout channelLayout)
     {
         std::ostringstream stringStream;
@@ -87,6 +107,12 @@ class LooperControllerMock
         events += stringStream.str() + "\n";
     }
 
+    float getCurrentSaveOrLoadProgress()
+    {
+        events += "getCurrentSaveOrLoadProgress()\n";
+        return -1.0f;
+    }
+
     std::function<ChannelLayout(size_t looperIdx)> getChannelLayoutMock_;
     ChannelLayout getChannelLayout(size_t looperIdx) const
     {

From 20c62a9ea150bf749dad6ed933a547d156d11f94 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 10:35:18 +0200
Subject: [PATCH 16/26] feat: UiHardware provides array of all channel LEDs

---
 firmware/src/hardware/UiHardware.h     | 22 ++++++++++++++++++++++
 firmware/tests/mocks/UiHardware_mock.h | 22 ++++++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/firmware/src/hardware/UiHardware.h b/firmware/src/hardware/UiHardware.h
index 41c5670..be864b9 100644
--- a/firmware/src/hardware/UiHardware.h
+++ b/firmware/src/hardware/UiHardware.h
@@ -407,6 +407,28 @@ class UiHardware
         buttons_.triggerReadout();
     }
 
+    static const std::array<Led, 16> allChannelLeds()
+    {
+        return {
+            Led::chA_m2,
+            Led::chA_m1,
+            Led::chA_p1,
+            Led::chA_p2,
+            Led::chB_m2,
+            Led::chB_m1,
+            Led::chB_p1,
+            Led::chB_p2,
+            Led::chC_m2,
+            Led::chC_m1,
+            Led::chC_p1,
+            Led::chC_p2,
+            Led::chD_m2,
+            Led::chD_m1,
+            Led::chD_p1,
+            Led::chD_p2,
+        };
+    }
+
 private:
     UiHardware(const UiHardware&) = delete;
     UiHardware& operator=(const UiHardware&) = delete;
diff --git a/firmware/tests/mocks/UiHardware_mock.h b/firmware/tests/mocks/UiHardware_mock.h
index de101be..c7d2418 100644
--- a/firmware/tests/mocks/UiHardware_mock.h
+++ b/firmware/tests/mocks/UiHardware_mock.h
@@ -69,6 +69,28 @@ class UiHardwareMock
         }
     }
 
+    static const std::array<Led, 16> allChannelLeds()
+    {
+        return {
+            Led::chA_m2,
+            Led::chA_m1,
+            Led::chA_p1,
+            Led::chA_p2,
+            Led::chB_m2,
+            Led::chB_m1,
+            Led::chB_p1,
+            Led::chB_p2,
+            Led::chC_m2,
+            Led::chC_m1,
+            Led::chC_p1,
+            Led::chC_p2,
+            Led::chD_m2,
+            Led::chD_m1,
+            Led::chD_p1,
+            Led::chD_p2,
+        };
+    }
+
     KnobsAndCvMock& getKnobsAndCv() { return knobsAndCv_; };
 
     KnobsAndCvMock knobsAndCv_;

From c5b91043e5e2b779c7e5f2fd4e8c2c6f71692b64 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Tue, 7 Oct 2025 23:25:14 +0200
Subject: [PATCH 17/26] feat: implement UI pages for loading and saving

---
 firmware/src/ui/TapeLooperUi.h     |   3 +-
 firmware/src/ui/UiLoadOrSavePage.h | 407 +++++++++++++++++++++++++++++
 firmware/src/ui/UiLoadPage.h       | 102 --------
 firmware/src/ui/UiSavePage.h       | 102 --------
 4 files changed, 408 insertions(+), 206 deletions(-)
 create mode 100644 firmware/src/ui/UiLoadOrSavePage.h
 delete mode 100644 firmware/src/ui/UiLoadPage.h
 delete mode 100644 firmware/src/ui/UiSavePage.h

diff --git a/firmware/src/ui/TapeLooperUi.h b/firmware/src/ui/TapeLooperUi.h
index 7686ffc..8499a44 100644
--- a/firmware/src/ui/TapeLooperUi.h
+++ b/firmware/src/ui/TapeLooperUi.h
@@ -26,8 +26,7 @@
 #include "UiBasePage.h"
 #include "UiCalibrationPage.h"
 #include "UiSettingsPage.h"
-#include "UiSavePage.h"
-#include "UiLoadPage.h"
+#include "UiLoadOrSavePage.h"
 #include "UiRecordingPage.h"
 
 template <typename UiHardwareType,
diff --git a/firmware/src/ui/UiLoadOrSavePage.h b/firmware/src/ui/UiLoadOrSavePage.h
new file mode 100644
index 0000000..26eddd9
--- /dev/null
+++ b/firmware/src/ui/UiLoadOrSavePage.h
@@ -0,0 +1,407 @@
+/**
+ * Copyright (C) Johannes Elliesen, 2021
+ *
+ * This program 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
+ * any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <array>
+#include <memory>
+
+#include <ui/UI.h>
+#include <dsp/TapeLooper.h>
+
+#include "../constants.h"
+#include "../hardware/UiHardwareTypes.h"
+#include "LooperParameterProvider.h"
+
+template <typename LooperControllerType, typename UiHardwareType, Led PageLed>
+class UiLoadOrSavePage : public daisy::UiPage
+{
+public:
+    UiLoadOrSavePage(LooperControllerType& looperController) :
+        looperController_(looperController)
+    {
+    }
+
+    virtual ~UiLoadOrSavePage() {}
+
+    bool IsOpaque(const daisy::UiCanvasDescriptor&) override { return false; }
+
+    void OnShow() override
+    {
+        stage_ = Stage::selectChannel;
+        selectedChannel_ = -1;
+    }
+
+    void Draw(const daisy::UiCanvasDescriptor& canvas) override
+    {
+        UiHardwareType& hardware = *((UiHardwareType*) canvas.handle_);
+
+        // light up the page led
+        hardware.setLed(PageLed, LedColour::pulsingRed);
+
+        switch (stage_)
+        {
+            case Stage::selectChannel:
+                drawSelectChannel(hardware);
+                break;
+            case Stage::selectBankAndSlot:
+                drawSelectBankAndSlot(hardware);
+                break;
+            case Stage::saveOrLoadInProgress:
+                drawProgress(hardware);
+                break;
+            case Stage::displayError:
+                drawResult(hardware, AudioSaveAndRecallResult::error);
+                break;
+            case Stage::displaySuccess:
+                drawResult(hardware, AudioSaveAndRecallResult::ok);
+                break;
+            default:
+                break;
+        }
+    }
+
+    bool OnButton(uint16_t buttonID, uint8_t numberOfPresses, bool isRetriggering) override
+    {
+        (void) (isRetriggering); // ignore this argument
+
+        // swallow but ignore button-up messages
+        if (numberOfPresses < 1)
+            return true;
+
+        const Button button = Button(buttonID);
+        switch (button)
+        {
+            case Button::record:
+                [[fallthrough]];
+            case Button::settings:
+                looperController_.abortLoadOrSaveOperation();
+                Close(); // close this page
+                return false; // pass event to the page below to open the respective page
+            case Button::save:
+                return handleSaveButton();
+            case Button::load:
+                return handleLoadButton();
+            default:
+                break;
+        }
+
+        switch (stage_)
+        {
+            case Stage::selectChannel:
+                return onButtonInChannelSelection(button);
+            case Stage::selectBankAndSlot:
+                return onButtonInBankAndSlotSelection(button);
+            default:
+                // any button press while showing
+                if (stage_ == Stage::displaySuccess || stage_ == Stage::displayError)
+                {
+                    Close();
+                }
+                break;
+        }
+
+        return true;
+    }
+
+    bool OnPotMoved(uint16_t, float) override
+    {
+        return false; // passthrough pot events to the base page
+    }
+
+protected:
+    UiLoadOrSavePage(const UiLoadOrSavePage&) = delete;
+    UiLoadOrSavePage& operator=(const UiLoadOrSavePage&) = delete;
+
+    static LedColour getBankColourPulsing(StorageBank bank)
+    {
+        if (bank == StorageBank::green)
+            return LedColour::pulsingGreen;
+        if (bank == StorageBank::yellow)
+            return LedColour::pulsingYellow;
+        if (bank == StorageBank::red)
+            return LedColour::pulsingRed;
+
+        return LedColour::off;
+    };
+
+    static LedColour getBankColour(StorageBank bank)
+    {
+        if (bank == StorageBank::green)
+            return LedColour::green;
+        if (bank == StorageBank::yellow)
+            return LedColour::yellow;
+        if (bank == StorageBank::red)
+            return LedColour::red;
+
+        return LedColour::off;
+    };
+
+    void drawSelectChannel(UiHardwareType& hardware)
+    {
+        hardware.setLed(Led::chA_p2, LedColour::pulsingYellow);
+        hardware.setLed(Led::chA_p1, LedColour::pulsingYellow);
+        hardware.setLed(Led::chA_m1, LedColour::pulsingYellow);
+        hardware.setLed(Led::chA_m2, LedColour::pulsingYellow);
+
+        hardware.setLed(Led::chB_p2, LedColour::pulsingYellow);
+        hardware.setLed(Led::chB_p1, LedColour::pulsingYellow);
+        hardware.setLed(Led::chB_m1, LedColour::pulsingYellow);
+        hardware.setLed(Led::chB_m2, LedColour::pulsingYellow);
+
+        hardware.setLed(Led::chC_p2, LedColour::pulsingYellow);
+        hardware.setLed(Led::chC_p1, LedColour::pulsingYellow);
+        hardware.setLed(Led::chC_m1, LedColour::pulsingYellow);
+        hardware.setLed(Led::chC_m2, LedColour::pulsingYellow);
+
+        hardware.setLed(Led::chD_p2, LedColour::pulsingYellow);
+        hardware.setLed(Led::chD_p1, LedColour::pulsingYellow);
+        hardware.setLed(Led::chD_m1, LedColour::pulsingYellow);
+        hardware.setLed(Led::chD_m2, LedColour::pulsingYellow);
+    }
+
+    void drawSelectBankAndSlot(UiHardwareType& hardware)
+    {
+        const auto bankColour = this->getBankColour(this->selectedBank_);
+        const auto bankColourPulsing = this->getBankColourPulsing(this->selectedBank_);
+
+        hardware.setLed(Led::settings, bankColourPulsing);
+
+        const auto allLeds = UiHardwareType::allChannelLeds();
+        for (size_t i = 0; i < allLeds.size(); i++)
+        {
+            hardware.setLed(allLeds[i], this->selectedSlot_ == int(i) ? bankColorPulsing : LedColour::off);
+        }
+    }
+
+    void drawProgress(UiHardwareType& hardware)
+    {
+        const auto allLeds = UiHardwareType::allChannelLeds();
+        for (size_t i = 0; i < allLeds.size(); i++)
+        {
+            const auto shouldBeOn = looperController_.getCurrentSaveOrLoadProgress()
+                                    > float(i) / float(allLeds.size() - 1);
+            hardware.setLed(allLeds[i], shouldBeOn ? LedColour::pulsingYellow : LedColour::off);
+        }
+    }
+
+    void drawResult(UiHardwareType& hardware, AudioSaveAndRecallResult result)
+    {
+        const auto color = result == AudioSaveAndRecallResult::ok ? LedColour::pulsingGreen : LedColour::pulsingRed;
+        for (auto led : UiHardwareType::allChannelLeds())
+        {
+            hardware.setLed(led, color);
+        }
+
+        if (daisy::System::GetNow() >= closeAfterTime_)
+        {
+            Close();
+        }
+    }
+
+    bool onButtonInChannelSelection(Button button)
+    {
+        switch (button)
+        {
+            case Button::chA_play:
+                selectedChannel_ = 0;
+                stage_ = Stage::selectBankAndSlot;
+                break;
+            case Button::chB_play:
+                selectedChannel_ = 1;
+                stage_ = Stage::selectBankAndSlot;
+                break;
+            case Button::chC_play:
+                selectedChannel_ = 2;
+                stage_ = Stage::selectBankAndSlot;
+                break;
+            case Button::chD_play:
+                selectedChannel_ = 3;
+                stage_ = Stage::selectBankAndSlot;
+                break;
+            default:
+                break;
+        }
+
+        return true;
+    }
+
+    bool onButtonInBankAndSlotSelection(Button button)
+    {
+        const auto handleChannelUp = [&](int channel)
+        {
+            if (selectedSlot_ / 4 != channel)
+            {
+                selectedSlot_ = selectedSlot_ % 4 + channel * 4;
+                return;
+            }
+            selectedSlot_ = std::min(selectedSlot_ + 1, channel * 4 + 3);
+        };
+        const auto handleChannelDown = [&](int channel)
+        {
+            if (selectedSlot_ / 4 != channel)
+            {
+                selectedSlot_ = selectedSlot_ % 4 + channel * 4;
+                return;
+            }
+            selectedSlot_ = std::max(selectedSlot_ - 1, channel * 4);
+        };
+
+        switch (button)
+        {
+            case Button::chA_down:
+                handleChannelDown(0);
+                break;
+            case Button::chA_up:
+                handleChannelUp(0);
+                break;
+            case Button::chB_down:
+                handleChannelDown(1);
+                break;
+            case Button::chB_up:
+                handleChannelUp(1);
+                break;
+            case Button::chC_down:
+                handleChannelDown(2);
+                break;
+            case Button::chC_up:
+                handleChannelUp(2);
+                break;
+            case Button::chD_down:
+                handleChannelDown(3);
+                break;
+            case Button::chD_up:
+                handleChannelUp(3);
+                break;
+            case Button::settings:
+                selectedBank_ = StorageBank((int(selectedBank_) + 1) % int(StorageBank::count));
+                break;
+            default:
+                break;
+        }
+
+        return true;
+    }
+
+    virtual bool handleSaveButton() = 0;
+    virtual bool handleLoadButton() = 0;
+
+    static void doneCallback(void* context, AudioSaveAndRecallResult result)
+    {
+        const auto page = static_cast<UiLoadOrSavePage*>(context);
+        page->stage_ = result == AudioSaveAndRecallResult::ok ? Stage::displaySuccess : Stage::displayError;
+        page->closeAfterTime_ = daisy::System::GetNow() + 2000;
+    }
+
+    enum class Stage
+    {
+        selectChannel,
+        selectBankAndSlot,
+        saveOrLoadInProgress,
+        displaySuccess,
+        displayError,
+    };
+
+    Stage stage_ = Stage::selectChannel;
+    StorageBank selectedBank_ = StorageBank::green;
+    int selectedChannel_ = -1;
+    int selectedSlot_ = 0;
+    LooperControllerType& looperController_;
+    uint32_t closeAfterTime_ = -1;
+};
+
+template <typename LooperControllerType, typename UiHardwareType>
+class UiSavePage : public UiLoadOrSavePage<LooperControllerType, UiHardwareType, Led::save>
+{
+    using ParentType = UiLoadOrSavePage<LooperControllerType, UiHardwareType, Led::save>;
+
+public:
+    UiSavePage(LooperControllerType& looperController) :
+        ParentType(looperController)
+    {
+    }
+
+    ~UiSavePage() = default;
+
+    bool handleSaveButton() override
+    {
+        if (this->stage_ == ParentType::Stage::selectBankAndSlot)
+        {
+            this->stage_ = ParentType::Stage::saveOrLoadInProgress;
+            this->looperController_.saveTo(this->selectedBank_,
+                                           this->selectedChannel_,
+                                           this->selectedSlot_,
+                                           &this->doneCallback,
+                                           this);
+        }
+        else if (this->stage_ == ParentType::Stage::selectChannel
+                 || this->stage_ == ParentType::Stage::displaySuccess
+                 || this->stage_ == ParentType::Stage::displayError)
+        {
+            Close();
+        }
+        return true;
+    }
+
+    bool handleLoadButton() override
+    {
+        this->looperController_.abortLoadOrSaveOperation();
+        this->Close();
+        return false; // pass event to the page below to open the respective page
+    }
+};
+
+template <typename LooperControllerType, typename UiHardwareType>
+class UiLoadPage : public UiLoadOrSavePage<LooperControllerType, UiHardwareType, Led::load>
+{
+    using ParentType = UiLoadOrSavePage<LooperControllerType, UiHardwareType, Led::load>;
+
+public:
+    UiLoadPage(LooperControllerType& looperController) :
+        ParentType(looperController)
+    {
+    }
+
+    ~UiLoadPage() = default;
+
+    bool handleSaveButton() override
+    {
+        this->looperController_.abortLoadOrSaveOperation();
+        this->Close();
+        return false; // pass event to the page below to open the respective page
+    }
+
+    bool handleLoadButton() override
+    {
+        if (this->stage_ == ParentType::Stage::selectBankAndSlot)
+        {
+            this->stage_ = ParentType::Stage::saveOrLoadInProgress;
+            this->looperController_.loadFrom(this->selectedBank_,
+                                             this->selectedChannel_,
+                                             this->selectedSlot_,
+                                             &this->doneCallback,
+                                             this);
+        }
+        else if (this->stage_ == ParentType::Stage::selectChannel
+                 || this->stage_ == ParentType::Stage::displaySuccess
+                 || this->stage_ == ParentType::Stage::displayError)
+        {
+            Close();
+        }
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/firmware/src/ui/UiLoadPage.h b/firmware/src/ui/UiLoadPage.h
deleted file mode 100644
index 58f3157..0000000
--- a/firmware/src/ui/UiLoadPage.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <array>
-#include <memory>
-
-#include <ui/UI.h>
-#include <dsp/TapeLooper.h>
-
-#include "../constants.h"
-#include "../hardware/UiHardwareTypes.h"
-#include "LooperParameterProvider.h"
-
-template <typename LooperControllerType, typename UiHardwareType>
-class UiLoadPage : public daisy::UiPage
-{
-public:
-    UiLoadPage(LooperControllerType& looperController) :
-        looperController_(looperController)
-    {
-    }
-
-    virtual ~UiLoadPage() {}
-
-    bool IsOpaque(const daisy::UiCanvasDescriptor&) override { return false; }
-
-    void Draw(const daisy::UiCanvasDescriptor& canvas) override
-    {
-        UiHardwareType& hardware = *((UiHardwareType*) canvas.handle_);
-
-        // light up the load page led
-        hardware.setLed(Led::load, LedColour::pulsingRed);
-
-        // update channel octave LEDs to show the currently selected slot
-        // TODO
-        const auto updateChannelOctaveLeds = [&](size_t looperChannel, std::array<Led, 4> ledIds)
-        {
-            (void) (looperChannel);
-            hardware.setLed(ledIds[0], LedColour::off);
-            hardware.setLed(ledIds[1], LedColour::off);
-            hardware.setLed(ledIds[2], LedColour::off);
-            hardware.setLed(ledIds[3], LedColour::off);
-        };
-        updateChannelOctaveLeds(0, { Led::chA_m2, Led::chA_m1, Led::chA_p1, Led::chA_p2 });
-        updateChannelOctaveLeds(1, { Led::chB_m2, Led::chB_m1, Led::chB_p1, Led::chB_p2 });
-        updateChannelOctaveLeds(2, { Led::chC_m2, Led::chC_m1, Led::chC_p1, Led::chC_p2 });
-        updateChannelOctaveLeds(3, { Led::chD_m2, Led::chD_m1, Led::chD_p1, Led::chD_p2 });
-    }
-
-    bool OnButton(uint16_t buttonID, uint8_t numberOfPresses, bool isRetriggering) override
-    {
-        (void) (isRetriggering); // ignore this argument
-
-        // swallow but ignore button-up messages
-        if (numberOfPresses < 1)
-            return true;
-
-        const Button button = Button(buttonID);
-        switch (button)
-        {
-            // channel play buttons
-            case Button::load:
-                Close(); // close this page
-                break;
-            case Button::record:
-            case Button::save:
-            case Button::settings:
-                Close(); // close this page
-                return false; // pass event to the page below to open the respective page
-            default:
-                break;
-        }
-        return true;
-    }
-
-    bool OnPotMoved(uint16_t, float) override
-    {
-        return false; // passthrough pot events to the base page
-    }
-
-private:
-    UiLoadPage(const UiLoadPage&) = delete;
-    UiLoadPage& operator=(const UiLoadPage&) = delete;
-
-    LooperControllerType& looperController_;
-};
\ No newline at end of file
diff --git a/firmware/src/ui/UiSavePage.h b/firmware/src/ui/UiSavePage.h
deleted file mode 100644
index 338d50f..0000000
--- a/firmware/src/ui/UiSavePage.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <array>
-#include <memory>
-
-#include <ui/UI.h>
-#include <dsp/TapeLooper.h>
-
-#include "../constants.h"
-#include "../hardware/UiHardwareTypes.h"
-#include "LooperParameterProvider.h"
-
-template <typename LooperControllerType, typename UiHardwareType>
-class UiSavePage : public daisy::UiPage
-{
-public:
-    UiSavePage(LooperControllerType& looperController) :
-        looperController_(looperController)
-    {
-    }
-
-    virtual ~UiSavePage() {}
-
-    bool IsOpaque(const daisy::UiCanvasDescriptor&) override { return false; }
-
-    void Draw(const daisy::UiCanvasDescriptor& canvas) override
-    {
-        UiHardwareType& hardware = *((UiHardwareType*) canvas.handle_);
-
-        // light up the save page led
-        hardware.setLed(Led::save, LedColour::pulsingRed);
-
-        // update channel octave LEDs to show the currently selected slot
-        // TODO
-        const auto updateChannelOctaveLeds = [&](size_t looperChannel, std::array<Led, 4> ledIds)
-        {
-            (void) (looperChannel);
-            hardware.setLed(ledIds[0], LedColour::off);
-            hardware.setLed(ledIds[1], LedColour::off);
-            hardware.setLed(ledIds[2], LedColour::off);
-            hardware.setLed(ledIds[3], LedColour::off);
-        };
-        updateChannelOctaveLeds(0, { Led::chA_m2, Led::chA_m1, Led::chA_p1, Led::chA_p2 });
-        updateChannelOctaveLeds(1, { Led::chB_m2, Led::chB_m1, Led::chB_p1, Led::chB_p2 });
-        updateChannelOctaveLeds(2, { Led::chC_m2, Led::chC_m1, Led::chC_p1, Led::chC_p2 });
-        updateChannelOctaveLeds(3, { Led::chD_m2, Led::chD_m1, Led::chD_p1, Led::chD_p2 });
-    }
-
-    bool OnButton(uint16_t buttonID, uint8_t numberOfPresses, bool isRetriggering) override
-    {
-        (void) (isRetriggering); // ignore this argument
-
-        // swallow but ignore button-up messages
-        if (numberOfPresses < 1)
-            return true;
-
-        const Button button = Button(buttonID);
-        switch (button)
-        {
-            // channel play buttons
-            case Button::save:
-                Close(); // close this page
-                break;
-            case Button::record:
-            case Button::load:
-            case Button::settings:
-                Close(); // close this page
-                return false; // pass event to the page below to open the respective page
-            default:
-                break;
-        }
-        return true;
-    }
-
-    bool OnPotMoved(uint16_t, float) override
-    {
-        return false; // passthrough pot events to the base page
-    }
-
-private:
-    UiSavePage(const UiSavePage&) = delete;
-    UiSavePage& operator=(const UiSavePage&) = delete;
-
-    LooperControllerType& looperController_;
-};
\ No newline at end of file

From e739627881487628c4f5e1c6aa3105ace3a732ae Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 12:04:19 +0200
Subject: [PATCH 18/26] feat: main loop processes save or load operation

---
 firmware/src/LooperController.h              | 20 +++++++++++++++-----
 firmware/src/main.cpp                        |  4 ++++
 firmware/tests/mocks/LooperController_mock.h |  5 +++++
 3 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/firmware/src/LooperController.h b/firmware/src/LooperController.h
index ac9d31b..7b6031d 100644
--- a/firmware/src/LooperController.h
+++ b/firmware/src/LooperController.h
@@ -103,11 +103,6 @@ class LooperController
                                                   doneCallbackContext);
     }
 
-    float getCurrentSaveOrLoadProgress()
-    {
-        return audioSaveAndRecall_.getCurrentProgress();
-    }
-
     void loadFrom(StorageBank bank,
                   size_t looperIdx,
                   size_t slot,
@@ -147,6 +142,16 @@ class LooperController
                                                      doneCallbackContext);
     }
 
+    float getCurrentSaveOrLoadProgress()
+    {
+        return audioSaveAndRecall_.getCurrentProgress();
+    }
+
+    bool isSavingOrRecalling()
+    {
+        return audioSaveAndRecall_.isSavingOrRecalling();
+    }
+
     void abortLoadOrSaveOperation()
     {
         if (audioSaveAndRecall_.isSavingOrRecalling())
@@ -155,6 +160,11 @@ class LooperController
         }
     }
 
+    void processSaveOrLoadOperation()
+    {
+        audioSaveAndRecall_.readOrWriteNextChunk();
+    }
+
     void setChannelLayout(size_t looperIdx, ChannelLayout channelLayout)
     {
         loopers_[looperIdx].initializeToLayout(channelLayout, looperStorage_[looperIdx]);
diff --git a/firmware/src/main.cpp b/firmware/src/main.cpp
index 13021d9..6f3e33c 100644
--- a/firmware/src/main.cpp
+++ b/firmware/src/main.cpp
@@ -216,6 +216,10 @@ int main(void)
         constexpr auto kUpdateIntervalMs = 20;
         while (daisy::System::GetNow() < lastUpdate + kUpdateIntervalMs)
         {
+            if (looperController->isSavingOrRecalling())
+            {
+                looperController->processSaveOrLoadOperation();
+            }
         }
         lastUpdate = daisy::System::GetNow();
     }
diff --git a/firmware/tests/mocks/LooperController_mock.h b/firmware/tests/mocks/LooperController_mock.h
index ece8ae9..ebe8da1 100644
--- a/firmware/tests/mocks/LooperController_mock.h
+++ b/firmware/tests/mocks/LooperController_mock.h
@@ -113,6 +113,11 @@ class LooperControllerMock
         return -1.0f;
     }
 
+    bool isSavingOrRecalling()
+    {
+        return false;
+    }
+
     std::function<ChannelLayout(size_t looperIdx)> getChannelLayoutMock_;
     ChannelLayout getChannelLayout(size_t looperIdx) const
     {

From 8c58c175f8b945d88ef788e0b4f0fd7a80e287d0 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 16:54:06 +0200
Subject: [PATCH 19/26] chore: remove plugin

The plugin isn't actively used anymore for development
and will hopefully be replaced with a VCV rack version eventually.

For now, let's remove the plugin to reduce the maintenance.
---
 .github/workflows/plugin.yaml    | 180 --------------
 .vscode/launch.json              |  47 ----
 .vscode/tasks.json               | 117 ---------
 README.md                        |   3 +-
 plugin/CMakeLists.txt            | 189 ---------------
 plugin/lib/JUCE                  |   1 -
 plugin/src/DspDefinitions.h      |  37 ---
 plugin/src/PluginEditor.cpp      |  67 ------
 plugin/src/PluginEditor.h        |  42 ----
 plugin/src/PluginProcessor.cpp   | 249 --------------------
 plugin/src/PluginProcessor.h     |  72 ------
 plugin/src/TapeLooperComponent.h | 196 ----------------
 plugin/src/TapeLooperProcessor.h | 391 -------------------------------
 plugin/tests/Example_gtest.cpp   |  41 ----
 14 files changed, 1 insertion(+), 1631 deletions(-)
 delete mode 100644 .github/workflows/plugin.yaml
 delete mode 100644 plugin/CMakeLists.txt
 delete mode 160000 plugin/lib/JUCE
 delete mode 100644 plugin/src/DspDefinitions.h
 delete mode 100644 plugin/src/PluginEditor.cpp
 delete mode 100644 plugin/src/PluginEditor.h
 delete mode 100644 plugin/src/PluginProcessor.cpp
 delete mode 100644 plugin/src/PluginProcessor.h
 delete mode 100644 plugin/src/TapeLooperComponent.h
 delete mode 100644 plugin/src/TapeLooperProcessor.h
 delete mode 100644 plugin/tests/Example_gtest.cpp

diff --git a/.github/workflows/plugin.yaml b/.github/workflows/plugin.yaml
deleted file mode 100644
index afcdec5..0000000
--- a/.github/workflows/plugin.yaml
+++ /dev/null
@@ -1,180 +0,0 @@
-name: Plugin Checks And Builds
-on:
-  # run for all pull requests
-  # Run for all commits (e.g. on feature branches)
-  push:
-    paths:
-    - 'dsp/**'
-    - 'plugin/**'
-    - 'lib/**'
-    - '.github/workflows/**'
-  pull_request:
-    paths:
-    - 'dsp/**'
-    - 'plugin/**'
-    - 'lib/**'
-    - '.github/workflows/**'
-jobs:
-  ###############################################################################
-  # builds the plugin on windows
-  testBuildWindows:
-    runs-on: windows-2025
-
-    steps:
-    - name: Setup cmake
-      uses: jwlawson/actions-setup-cmake@v1.8
-      with:
-        cmake-version: '3.30.x'
-
-    - name: Checkout
-      uses: actions/checkout@v2
-      with:
-        submodules: recursive
-
-    - name: Configure
-      run: |
-        cmake.exe -G "Visual Studio 17 2022" -A x64 -B plugin/build -S plugin
-
-    - name: Build
-      run: |
-        cmake --build plugin/build --config Release
-
-    - name: Run Tests
-      run: |
-        plugin/build/Release/TapeLooperPlugin_Gtest.exe --gtest_output=xml:TestResults\gtestResults_windows.xml
-
-    - name: Upload Test Results
-      uses: actions/upload-artifact@v4
-      with:
-        name: TestResults_Windows
-        path: TestResults/**
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: TapeLooperPlugin_Windows
-        path: |
-          plugin\build\TapeLooperPlugin_artefacts\Release\VST3\Tape Looper Plugin.vst3\Contents\x86_64-win\Tape Looper Plugin.vst3
-          plugin\build\TapeLooperPlugin_artefacts\Release\Standalone\Tape Looper Plugin.exe
-          plugin/build/Release/TapeLooperPlugin_Gtest.exe
-          TestResults\gtestResults_windows.xml
-  ###############################################################################
-  # builds the plugin on macos
-  testBuildMacOS:
-    runs-on: macos-latest
-
-    steps:
-    - name: Setup cmake
-      uses: jwlawson/actions-setup-cmake@v1.8
-      with:
-        cmake-version: '3.30.x'
-
-    - uses: maxim-lobanov/setup-xcode@v1
-      with:
-        xcode-version: latest-stable
-
-    - name: Select Xcode
-      run: |
-        sudo xcode-select --reset
-
-    - name: Checkout
-      uses: actions/checkout@v2
-      with:
-        submodules: recursive
-
-    - name: Configure
-      run: |
-        cmake -G "Xcode" -B plugin/build -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64" -S plugin
-
-    - name: Build
-      run: |
-        cmake --build plugin/build --config Release
-
-    - name: Run Tests
-      run: |
-        plugin/build/Release/TapeLooperPlugin_Gtest --gtest_output=xml:TestResults/gtestResults_macos.xml
-
-    - name: Upload Test Results
-      uses: actions/upload-artifact@v4
-      with:
-        name: TestResults_MacOS
-        path: TestResults/**
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: TapeLooperPlugin_MacOS
-        path: |
-          plugin/build/TapeLooperPlugin_artefacts/Release/VST3/Tape Looper Plugin.vst3/**
-          plugin/build/TapeLooperPlugin_artefacts/Release/Standalone/Tape Looper Plugin.app/**
-          plugin/build/Release/TapeLooperPlugin_Gtest
-          TestResults/gtestResults_macos.xml
-  ###############################################################################
-  # builds the plugin on ubuntu
-  testBuildUbuntu:
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Setup cmake
-      uses: jwlawson/actions-setup-cmake@v1.8
-      with:
-        cmake-version: '3.30.x'
-
-    - name: Setup dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get -y install g++ libfreetype6-dev libx11-dev libxinerama-dev libxrandr-dev libxcursor-dev mesa-common-dev libasound2-dev freeglut3-dev libxcomposite-dev
-    - name: Checkout
-      uses: actions/checkout@v2
-      with:
-        submodules: recursive
-
-    - name: Configure
-      run: |
-        cmake -G "Unix Makefiles" -B plugin/build -S plugin
-
-    - name: Build
-      run: |
-        cmake --build plugin/build --config Release
-
-    - name: Run Tests
-      run: |
-        plugin/build/TapeLooperPlugin_Gtest --gtest_output=xml:TestResults/gtestResults_ubuntu.xml
-
-    - name: Upload Test Results
-      uses: actions/upload-artifact@v4
-      with:
-        name: TestResults_Linux
-        path: TestResults/**
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: TapeLooperPlugin_Linux
-        path: |
-          plugin/build/TapeLooperPlugin_artefacts/VST3/Tape Looper Plugin.vst3
-          plugin/build/TapeLooperPlugin_artefacts/Standalone/Tape Looper Plugin
-          plugin/build/TapeLooperPlugin_Gtest
-          TestResults/gtestResults_ubuntu.xml
-  ###############################################################################
-  # uploads test results from the previous jobs
-  publishTestResults:
-    name: "Publish Unit Tests Results"
-    needs: [testBuildUbuntu, testBuildMacOS, testBuildWindows]
-    runs-on: ubuntu-latest
-    # the dependency jobs might be skipped, we don't need to run this job then
-    if: success() || failure()
-
-    steps:
-      - name: Download Artifacts
-        uses: actions/download-artifact@v4
-        with:
-          pattern: TestResults_*
-          path: TestResults
-
-      - name: Publish Test Results
-        uses: EnricoMi/publish-unit-test-result-action@v1
-        if: always()
-        with:
-          files: TestResults/**/*.xml
-          github_token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.vscode/launch.json b/.vscode/launch.json
index a27a706..34d3657 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -106,53 +106,6 @@
             "windows": {
                 "MIMode": "gdb",
             }
-        },
-        {
-            "name": "Plugin Tests",
-            "type": "cppdbg",
-            "request": "launch",
-            "program": "${workspaceFolder}/plugin/build/TapeLooperPlugin_Gtest",
-            "args": [],
-            "stopAtEntry": false,
-            "cwd": "${workspaceFolder}/plugin/build",
-            "environment": [],
-            "externalConsole": false,
-            "logging": {
-                "engineLogging": false
-            },
-            "preLaunchTask": "build plugin",
-
-            "osx": {
-                "type": "lldb",
-                "MIMode": "lldb",
-            },
-            "windows": {
-                "MIMode": "gdb",
-            }
-        },
-        {
-            "name": "Standalone Plugin",
-            "type": "cppdbg",
-            "request": "launch",
-            "args": [],
-            "stopAtEntry": false,
-            "cwd": "${workspaceFolder}/plugin/build",
-            "environment": [],
-            "externalConsole": false,
-            "logging": {
-                "engineLogging": false
-            },
-            "preLaunchTask": "build plugin",
-
-            "osx": {
-                "type": "lldb",
-                "MIMode": "lldb",
-                "program": "${workspaceFolder}/plugin/build/TapeLooperPlugin_artefacts/Standalone/Tape Looper Plugin.app/Contents/MacOS/Tape Looper Plugin",
-            },
-            "windows": {
-                "MIMode": "gdb",
-                "program": "${workspaceFolder}/plugin/build/TapeLooperPlugin_artefacts/Standalone/Tape Looper Plugin.exe",
-            }
         }
     ]
 }
\ No newline at end of file
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index dea65e9..6f6c9d5 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -141,123 +141,6 @@
             },
             "problemMatcher": []
         },
-        {
-            "label": "configure plugin",
-            "type": "shell",
-            "command": "cmake",
-            "args": [
-                "-S",
-                "plugin",
-                "-B",
-                "plugin/build",
-                "-D",
-                "CMAKE_EXPORT_COMPILE_COMMANDS=1",
-                "-G",
-                "\"Unix Makefiles\""
-            ],
-            "options": {
-                "cwd": "${workspaceRoot}"
-            },
-            "windows": {
-                "command": "cmake.exe",
-                "args": [
-                    "-S",
-                    "plugin",
-                    "-B",
-                    "plugin/build",
-                    "-D",
-                    "CMAKE_EXPORT_COMPILE_COMMANDS=1",
-                    "-G",
-                    "\\\"Visual Studio 17 2022\\\""
-                ]
-            },
-            "group": {
-                "kind": "build"
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "configure plugin (debug)",
-            "type": "shell",
-            "command": "cmake",
-            "args": [
-                "-D",
-                "CMAKE_BUILD_TYPE=Debug",
-                "-S",
-                "plugin",
-                "-B",
-                "plugin/build",
-                "-D",
-                "CMAKE_EXPORT_COMPILE_COMMANDS=1",
-                "-G",
-                "\"Unix Makefiles\""
-            ],
-            "options": {
-                "cwd": "${workspaceRoot}"
-            },
-            "windows": {
-                "command": "cmake.exe",
-                "args": [
-                    "-D",
-                    "CMAKE_BUILD_TYPE=Debug",
-                    "-S",
-                    "plugin",
-                    "-B",
-                    "plugin/build",
-                    "-D",
-                    "CMAKE_EXPORT_COMPILE_COMMANDS=1",
-                    "-G",
-                    "\\\"Visual Studio 17 2022\\\""
-                ]
-            },
-            "group": {
-                "kind": "build"
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "build plugin",
-            "type": "shell",
-            "command": "cmake",
-            "args": [
-                "--build",
-                "plugin/build"
-            ],
-            "options": {
-                "cwd": "${workspaceRoot}"
-            },
-            "group": {
-                "kind": "build"
-            },
-            "problemMatcher": [
-                "$gcc"
-            ]
-        },
-        {
-            "label": "clean-plugin",
-            "osx": {
-                "command": "make",
-                "args": [
-                    "clean"
-                ]
-            },
-            "linux": {
-                "command": "make",
-                "args": [
-                    "clean"
-                ]
-            },
-            "windows": {
-                "command": "make.exe",
-                "args": [
-                    "clean"
-                ]
-            },
-            "options": {
-                "cwd": "${workspaceRoot}/plugin/build"
-            },
-            "problemMatcher": []
-        },
         {
             "label": "buildTests-TapeLooperDSP",
             "command": "make",
diff --git a/README.md b/README.md
index 7205bec..0c44599 100644
--- a/README.md
+++ b/README.md
@@ -2,9 +2,8 @@
 
 [![DSP Library Checks](https://github.com/TheSlowGrowth/TapeLooper/actions/workflows/dsp.yaml/badge.svg)](https://github.com/TheSlowGrowth/TapeLooper/actions/workflows/dsp.yaml)
 [![Firmware Checks And Builds](https://github.com/TheSlowGrowth/TapeLooper/actions/workflows/firmware.yaml/badge.svg)](https://github.com/TheSlowGrowth/TapeLooper/actions/workflows/firmware.yaml)
-[![Plugin Checks And Builds](https://github.com/TheSlowGrowth/TapeLooper/actions/workflows/plugin.yaml/badge.svg)](https://github.com/TheSlowGrowth/TapeLooper/actions/workflows/plugin.yaml)
 [![Formatting](https://github.com/TheSlowGrowth/TapeLooper/actions/workflows/formatting.yaml/badge.svg)](https://github.com/TheSlowGrowth/TapeLooper/actions/workflows/formatting.yaml)
 
-Hey explorer! This repo is just a construction site. We're trying to build a digital tape looper, that will hopefully become a desktop device and / or a Eurorack synth module. 
+Hey explorer! This repo is just a construction site. We're trying to build a digital tape looper, that will hopefully become a desktop device and / or a Eurorack synth module.
 
 
diff --git a/plugin/CMakeLists.txt b/plugin/CMakeLists.txt
deleted file mode 100644
index 9704abe..0000000
--- a/plugin/CMakeLists.txt
+++ /dev/null
@@ -1,189 +0,0 @@
-# Example Audio Plugin CMakeLists.txt
-
-# To get started on a new plugin, copy this entire folder (containing this file and C++ sources) to
-# a convenient location, and then start making modifications.
-
-# The first line of any CMake project should be a call to `cmake_minimum_required`, which checks
-# that the installed CMake will be able to understand the following CMakeLists, and ensures that
-# CMake's behaviour is compatible with the named version. This is a standard CMake command, so more
-# information can be found in the CMake docs.
-
-cmake_minimum_required(VERSION 3.15)
-
-# The top-level CMakeLists.txt file for a project must contain a literal, direct call to the
-# `project()` command. `project()` sets up some helpful variables that describe source/binary
-# directories, and the current project version. This is a standard CMake command.
-
-project(TAPE_LOOPER_PLUGIN VERSION 0.0.1)
-
-add_subdirectory(lib/JUCE)
-add_subdirectory(../dsp build)
-
-# If you are building a VST2 or AAX plugin, CMake needs to be told where to find these SDKs on your
-# system. This setup should be done before calling `juce_add_plugin`.
-
-# juce_set_vst2_sdk_path(...)
-# juce_set_aax_sdk_path(...)
-
-# `juce_add_plugin` adds a static library target with the name passed as the first argument
-# (TapeLooperPlugin here). This target is a normal CMake target, but has a lot of extra properties set
-# up by default. As well as this shared code static library, this function adds targets for each of
-# the formats specified by the FORMATS arguments. This function accepts many optional arguments.
-# Check the readme at `docs/CMake API.md` in the JUCE repo for the full list.
-
-juce_add_plugin(TapeLooperPlugin
-    # VERSION ...                               # Set this if the plugin version is different to the project version
-    # ICON_BIG ...                              # ICON_* arguments specify a path to an image file to use as an icon for the Standalone
-    # ICON_SMALL ...
-    # COMPANY_NAME ...                          # Specify the name of the plugin's author
-    # IS_SYNTH TRUE/FALSE                       # Is this a synth or an effect?
-    # NEEDS_MIDI_INPUT TRUE/FALSE               # Does the plugin need midi input?
-    # NEEDS_MIDI_OUTPUT TRUE/FALSE              # Does the plugin need midi output?
-    # IS_MIDI_EFFECT TRUE/FALSE                 # Is this plugin a MIDI effect?
-    # EDITOR_WANTS_KEYBOARD_FOCUS TRUE/FALSE    # Does the editor need keyboard focus?
-    # COPY_PLUGIN_AFTER_BUILD TRUE/FALSE        # Should the plugin be installed to a default location after building?
-    PLUGIN_MANUFACTURER_CODE TSG                # A four-character manufacturer id with at least one upper-case character
-    PLUGIN_CODE Tplp                            # A unique four-character plugin id with exactly one upper-case character
-                                                # GarageBand 10.3 requires the first letter to be upper-case, and the remaining letters to be lower-case
-    FORMATS AU VST3 Standalone                  # The formats to build. Other valid formats are: AAX Unity VST AU AUv3
-    PRODUCT_NAME "Tape Looper Plugin")          # The name of the final executable, which can differ from the target name
-set_property(TARGET TapeLooperPlugin PROPERTY CXX_STANDARD 17)
-
-# `juce_generate_juce_header` will create a JuceHeader.h for a given target, which will be generated
-# into your build tree. This should be included with `#include <JuceHeader.h>`. The include path for
-# this header will be automatically added to the target. The main function of the JuceHeader is to
-# include all your JUCE module headers; if you're happy to include module headers directly, you
-# probably don't need to call this.
-
-juce_generate_juce_header(TapeLooperPlugin)
-
-# `target_sources` adds source files to a target. We pass the target that needs the sources as the
-# first argument, then a visibility parameter for the sources which should normally be PRIVATE.
-# Finally, we supply a list of source files that will be built into the target. This is a standard
-# CMake command.
-
-set(
-    plugin_sourcefiles
-
-    src/PluginEditor.h
-    src/PluginEditor.cpp
-    src/PluginProcessor.h
-    src/PluginProcessor.cpp
-
-    src/DspDefinitions.h
-    src/TapeLooperProcessor.h
-
-    src/TapeLooperComponent.h
-)
-
-target_sources(TapeLooperPlugin
-    PRIVATE
-        ${plugin_sourcefiles}
-)
-
-foreach(source IN LISTS plugin_sourcefiles)
-    get_filename_component(source_path "${source}" PATH)
-    string(REPLACE "/" "\\" source_path_msvc "${source_path}")
-    source_group("${source_path_msvc}" FILES "${source}")
-endforeach()
-
-# `target_compile_definitions` adds some preprocessor definitions to our target. In a Projucer
-# project, these might be passed in the 'Preprocessor Definitions' field. JUCE modules also make use
-# of compile definitions to switch certain features on/off, so if there's a particular feature you
-# need that's not on by default, check the module header for the correct flag to set here. These
-# definitions will be visible both to your code, and also the JUCE module code, so for new
-# definitions, pick unique names that are unlikely to collide! This is a standard CMake command.
-
-target_compile_definitions(TapeLooperPlugin
-    PUBLIC
-        # JUCE_WEB_BROWSER and JUCE_USE_CURL would be on by default, but you might not need them.
-        JUCE_WEB_BROWSER=0  # If you remove this, add `NEEDS_WEB_BROWSER TRUE` to the `juce_add_plugin` call
-        JUCE_USE_CURL=0     # If you remove this, add `NEEDS_CURL TRUE` to the `juce_add_plugin` call
-        JUCE_MODAL_LOOPS_PERMITTED=1
-        JUCE_VST3_CAN_REPLACE_VST2=0
-        MANUAL_INLINE=inline # overrides inline statements used to optimize dsp code for the hardware
-        _USE_MATH_DEFINES
-)
-
-# If your target needs extra binary assets, you can add them here. The first argument is the name of
-# a new static library target that will include all the binary resources. There is an optional
-# `NAMESPACE` argument that can specify the namespace of the generated binary data class. Finally,
-# the SOURCES argument should be followed by a list of source files that should be built into the
-# static library. These source files can be of any kind (wav data, images, fonts, icons etc.).
-# Conversion to binary-data will happen when your target is built.
-
-# juce_add_binary_data(AudioPluginData SOURCES ...)
-
-# `target_link_libraries` links libraries and JUCE modules to other libraries or executables. Here,
-# we're linking our executable target to the `juce::juce_audio_utils` module. Inter-module
-# dependencies are resolved automatically, so `juce_core`, `juce_events` and so on will also be
-# linked automatically. If we'd generated a binary data target above, we would need to link to it
-# here too. This is a standard CMake command.
-
-target_link_libraries(TapeLooperPlugin
-    PRIVATE
-        # AudioPluginData           # If we'd created a binary data target, we'd link to it here
-        juce::juce_audio_utils
-    PUBLIC
-        tapeLooperDsp
-        juce::juce_recommended_config_flags
-        juce::juce_recommended_lto_flags
-        juce::juce_recommended_warning_flags)
-
-###################################################################################################
-## Googletest console application
-###################################################################################################
-
-# find thread library
-find_package(Threads)
-
-# include directories
-include_directories(
-    ../lib/googletest/googletest/include
-    ../lib/googletest/googletest
-    src/
-)
-
-set(
-    test_sourcefiles
-
-    tests/Example_gtest.cpp
-)
-
-# This target adds a googletest executable
-add_executable(TapeLooperPlugin_Gtest)
-
-set_target_properties (TapeLooperPlugin_Gtest PROPERTIES
-    FOLDER TapeLooperPlugin
-)
-
-target_sources(TapeLooperPlugin_Gtest
-    PRIVATE
-        ${test_sourcefiles}
-        ../lib/googletest/googletest/src/gtest-all.cc
-        ../lib/googletest/googletest/src/gtest_main.cc)
-
-foreach(source IN LISTS test_sourcefiles)
-    get_filename_component(source_path "${source}" PATH)
-    string(REPLACE "/" "\\" source_path_msvc "${source_path}")
-    source_group("${source_path_msvc}" FILES "${source}")
-endforeach()
-
-# link thread library
-target_link_libraries(TapeLooperPlugin_Gtest
-    PRIVATE
-        ${CMAKE_THREAD_LIBS_INIT}
-        juce::juce_gui_extra
-        juce::juce_dsp
-        TapeLooperPlugin
-    PUBLIC
-        juce::juce_recommended_config_flags
-        juce::juce_recommended_lto_flags
-        juce::juce_recommended_warning_flags
-    )
-
-
-set_property(TARGET TapeLooperPlugin_Gtest
-    PROPERTY
-        CXX_STANDARD 17
-)
\ No newline at end of file
diff --git a/plugin/lib/JUCE b/plugin/lib/JUCE
deleted file mode 160000
index 46ea879..0000000
--- a/plugin/lib/JUCE
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 46ea879739533ca0cdc689b967edfc5390c46ef7
diff --git a/plugin/src/DspDefinitions.h b/plugin/src/DspDefinitions.h
deleted file mode 100644
index f699283..0000000
--- a/plugin/src/DspDefinitions.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-namespace dspdefs
-{
-    constexpr size_t numLoopers = 4;
-    constexpr double loopLengthInS = 60.0;
-
-    constexpr float speedMin = 0.25f;
-    constexpr float speedMax = 4.0f;
-
-    namespace paramIds
-    {
-        const auto chState = "chState";
-        const auto chSpeed = "chSpeed";
-        const auto chDrive = "chDrive";
-        const auto chGrainAmt = "chGrainAmt";
-        const auto chWowAndFlutterAmt = "chWowAndFlutterAmt";
-        const auto chPostGain = "chPostGain";
-    } // namespace paramIds
-} // namespace dspdefs
diff --git a/plugin/src/PluginEditor.cpp b/plugin/src/PluginEditor.cpp
deleted file mode 100644
index fa85324..0000000
--- a/plugin/src/PluginEditor.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PluginProcessor.h"
-#include "PluginEditor.h"
-#include "DspDefinitions.h"
-
-//==============================================================================
-TapeLooperPluginAudioProcessorEditor::TapeLooperPluginAudioProcessorEditor(TapeLooperPluginAudioProcessor& p) :
-    AudioProcessorEditor(&p), processorRef(p)
-{
-    juce::ignoreUnused(processorRef);
-
-    for (size_t i = 0; i < dspdefs::numLoopers; i++)
-    {
-        const juce::String chStr(i);
-        auto comp = std::make_unique<TapeLooperComponent>(
-            *(juce::AudioParameterChoice*) p.parameters_.getParameter(dspdefs::paramIds::chState + chStr),
-            *(juce::AudioParameterFloat*) p.parameters_.getParameter(dspdefs::paramIds::chSpeed + chStr),
-            *(juce::AudioParameterFloat*) p.parameters_.getParameter(dspdefs::paramIds::chDrive + chStr),
-            *(juce::AudioParameterFloat*) p.parameters_.getParameter(dspdefs::paramIds::chGrainAmt + chStr),
-            *(juce::AudioParameterFloat*) p.parameters_.getParameter(dspdefs::paramIds::chWowAndFlutterAmt + chStr),
-            *(juce::AudioParameterFloat*) p.parameters_.getParameter(dspdefs::paramIds::chPostGain + chStr));
-        addAndMakeVisible(*comp);
-        looperComponents_.add(std::move(comp));
-    }
-
-    // Make sure that before the constructor has finished, you've set the
-    // editor's size to whatever you need it to be.
-    setSize(400, 600);
-}
-
-TapeLooperPluginAudioProcessorEditor::~TapeLooperPluginAudioProcessorEditor()
-{
-}
-
-//==============================================================================
-void TapeLooperPluginAudioProcessorEditor::paint(juce::Graphics& g)
-{
-    // (Our component is opaque, so we must completely fill the background with a solid colour)
-    g.fillAll(getLookAndFeel().findColour(juce::ResizableWindow::backgroundColourId));
-}
-
-void TapeLooperPluginAudioProcessorEditor::resized()
-{
-    const auto numComponents = looperComponents_.size();
-    const auto looperCompWidth = float(getWidth()) / float(numComponents);
-    for (int i = 0; i < numComponents; i++)
-    {
-        const auto rect = juce::Rectangle<float>(0.0f, 0.0f, looperCompWidth, float(getHeight()));
-        looperComponents_[i]->setBounds(rect.withPosition(looperCompWidth * float(i), 0.0f).toNearestInt());
-    }
-}
diff --git a/plugin/src/PluginEditor.h b/plugin/src/PluginEditor.h
deleted file mode 100644
index fbc030d..0000000
--- a/plugin/src/PluginEditor.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include "PluginProcessor.h"
-#include "TapeLooperComponent.h"
-
-//==============================================================================
-class TapeLooperPluginAudioProcessorEditor : public juce::AudioProcessorEditor
-{
-public:
-    explicit TapeLooperPluginAudioProcessorEditor(TapeLooperPluginAudioProcessor&);
-    ~TapeLooperPluginAudioProcessorEditor() override;
-
-    //==============================================================================
-    void paint(juce::Graphics&) override;
-    void resized() override;
-
-private:
-    // This reference is provided as a quick way for your editor to
-    // access the processor object that created it.
-    TapeLooperPluginAudioProcessor& processorRef;
-
-    juce::OwnedArray<TapeLooperComponent> looperComponents_;
-
-    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(TapeLooperPluginAudioProcessorEditor)
-};
diff --git a/plugin/src/PluginProcessor.cpp b/plugin/src/PluginProcessor.cpp
deleted file mode 100644
index 8ea2d62..0000000
--- a/plugin/src/PluginProcessor.cpp
+++ /dev/null
@@ -1,249 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PluginProcessor.h"
-#include "PluginEditor.h"
-#include "DspDefinitions.h"
-
-//==============================================================================
-TapeLooperPluginAudioProcessor::TapeLooperPluginAudioProcessor() :
-    AudioProcessor(BusesProperties()
-                       .withInput("Input", juce::AudioChannelSet::stereo(), true)
-                       .withOutput("Output", juce::AudioChannelSet::stereo(), true)),
-    parameters_(*this, nullptr, juce::Identifier("TapeLooper"), getParameterLayout()),
-    loopers_(parameters_)
-{
-}
-
-TapeLooperPluginAudioProcessor::~TapeLooperPluginAudioProcessor()
-{
-}
-
-//==============================================================================
-const juce::String TapeLooperPluginAudioProcessor::getName() const
-{
-    return JucePlugin_Name;
-}
-
-bool TapeLooperPluginAudioProcessor::acceptsMidi() const
-{
-#if JucePlugin_WantsMidiInput
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool TapeLooperPluginAudioProcessor::producesMidi() const
-{
-#if JucePlugin_ProducesMidiOutput
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool TapeLooperPluginAudioProcessor::isMidiEffect() const
-{
-#if JucePlugin_IsMidiEffect
-    return true;
-#else
-    return false;
-#endif
-}
-
-double TapeLooperPluginAudioProcessor::getTailLengthSeconds() const
-{
-    return 0.0;
-}
-
-int TapeLooperPluginAudioProcessor::getNumPrograms()
-{
-    return 1; // NB: some hosts don't cope very well if you tell them there are 0 programs,
-              // so this should be at least 1, even if you're not really implementing programs.
-}
-
-int TapeLooperPluginAudioProcessor::getCurrentProgram()
-{
-    return 0;
-}
-
-void TapeLooperPluginAudioProcessor::setCurrentProgram(int index)
-{
-    juce::ignoreUnused(index);
-}
-
-const juce::String TapeLooperPluginAudioProcessor::getProgramName(int index)
-{
-    juce::ignoreUnused(index);
-    return {};
-}
-
-void TapeLooperPluginAudioProcessor::changeProgramName(int index, const juce::String& newName)
-{
-    juce::ignoreUnused(index, newName);
-}
-
-//==============================================================================
-void TapeLooperPluginAudioProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)
-{
-    juce::dsp::ProcessSpec specs;
-    specs.numChannels = juce::uint32(getMainBusNumInputChannels());
-    specs.maximumBlockSize = juce::uint32(samplesPerBlock) * 2u; // safety for some weird hosts
-    specs.sampleRate = sampleRate;
-
-    loopers_.prepareToPlay(specs);
-}
-
-void TapeLooperPluginAudioProcessor::releaseResources()
-{
-    // When playback stops, you can use this as an opportunity to free up any
-    // spare memory, etc.
-}
-
-bool TapeLooperPluginAudioProcessor::isBusesLayoutSupported(const BusesLayout& layouts) const
-{
-    // This is the place where you check if the layout is supported.
-    // Some plugin hosts, such as certain GarageBand versions, will only
-    // load plugins that support stereo bus layouts.
-    if (layouts.getMainOutputChannelSet() != juce::AudioChannelSet::stereo())
-        return false;
-    if (layouts.getMainOutputChannelSet() != layouts.getMainInputChannelSet())
-        return false;
-    return true;
-}
-
-void TapeLooperPluginAudioProcessor::processBlock(juce::AudioBuffer<float>& buffer,
-                                                  juce::MidiBuffer& midiMessages)
-{
-    juce::ignoreUnused(midiMessages);
-
-    juce::ScopedNoDenormals noDenormals;
-
-    loopers_.processBlock(buffer);
-}
-
-//==============================================================================
-bool TapeLooperPluginAudioProcessor::hasEditor() const
-{
-    return true; // (change this to false if you choose to not supply an editor)
-}
-
-juce::AudioProcessorEditor* TapeLooperPluginAudioProcessor::createEditor()
-{
-    return new TapeLooperPluginAudioProcessorEditor(*this);
-}
-
-//==============================================================================
-void TapeLooperPluginAudioProcessor::getStateInformation(juce::MemoryBlock& destData)
-{
-    try
-    {
-        loopers_.saveState(destData);
-    }
-    catch (const std::exception& e)
-    {
-        juce::NativeMessageBox::showAsync(
-            juce::MessageBoxOptions()
-                .withTitle(juce::String("Exception saving state"))
-                .withMessage(juce::String("Exception saving state: ") + e.what())
-                .withIconType(juce::MessageBoxIconType::WarningIcon),
-            [](int) {});
-    }
-}
-
-void TapeLooperPluginAudioProcessor::setStateInformation(const void* data, int sizeInBytes)
-{
-    try
-    {
-        loopers_.recallState(data, size_t(sizeInBytes));
-    }
-    catch (const std::exception& e)
-    {
-        juce::NativeMessageBox::showAsync(
-            juce::MessageBoxOptions()
-                .withTitle(juce::String("Exception recalling state"))
-                .withMessage(juce::String("Exception recalling state: ") + e.what())
-                .withIconType(juce::MessageBoxIconType::WarningIcon),
-            [](int) {});
-    }
-}
-
-juce::AudioProcessorValueTreeState::ParameterLayout TapeLooperPluginAudioProcessor::getParameterLayout()
-{
-    juce::AudioProcessorValueTreeState::ParameterLayout result;
-
-    for (size_t i = 0; i < dspdefs::numLoopers; i++)
-    {
-        const juce::String chStr(i);
-
-        result.add(std::make_unique<juce::AudioParameterChoice>(juce::String(dspdefs::paramIds::chState) + chStr, // parameterID
-                                                                "Playback State " + chStr, // parameter name
-                                                                juce::StringArray({ "<", "stop", ">", "rec" }), // choices
-                                                                1) // default index
-        );
-        juce::NormalisableRange<float> speedRange(dspdefs::speedMin, dspdefs::speedMax);
-        speedRange.setSkewForCentre(1.0f);
-        result.add(std::make_unique<juce::AudioParameterFloat>(juce::String(dspdefs::paramIds::chSpeed) + chStr, // parameterID
-                                                               "Speed " + chStr, // parameter name
-                                                               speedRange, // mapping
-                                                               1.0f, // default value
-                                                               "", // label
-                                                               juce::AudioProcessorParameter::genericParameter, // category
-                                                               [](float value, int)
-                                                               { return juce::String(value, 2); }) // value-to-string function
-        );
-        juce::NormalisableRange<float> driveRange(0.25f, 4.0f);
-        driveRange.setSkewForCentre(1.0f);
-        result.add(std::make_unique<juce::AudioParameterFloat>(juce::String(dspdefs::paramIds::chDrive) + chStr, // parameterID
-                                                               "Drive " + chStr, // parameter name
-                                                               driveRange, // mapping
-                                                               1.0f, // default value
-                                                               "", // label
-                                                               juce::AudioProcessorParameter::genericParameter, // category
-                                                               [](float value, int)
-                                                               { return juce::String(value, 2); }) // value-to-string function
-        );
-        result.add(std::make_unique<juce::AudioParameterFloat>(juce::String(dspdefs::paramIds::chGrainAmt) + chStr, // parameterID
-                                                               "GrainAmt " + chStr, // parameter name
-                                                               0.0f, // minimum value
-                                                               1.0f, // maximum value
-                                                               0.25f) // default value
-        );
-        result.add(std::make_unique<juce::AudioParameterFloat>(juce::String(dspdefs::paramIds::chWowAndFlutterAmt) + chStr, // parameterID
-                                                               "WowAndFlutterAmt " + chStr, // parameter name
-                                                               0.0f, // minimum value
-                                                               1.0f, // maximum value
-                                                               0.25f) // default value
-        );
-        result.add(std::make_unique<juce::AudioParameterFloat>(juce::String(dspdefs::paramIds::chPostGain) + chStr, // parameterID
-                                                               "PostGain " + chStr, // parameter name
-                                                               0.0f, // minimum value
-                                                               2.0f, // maximum value
-                                                               1.0f) // default value
-        );
-    }
-
-    return result;
-}
-
-//==============================================================================
-// This creates new instances of the plugin..
-juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()
-{
-    return new TapeLooperPluginAudioProcessor();
-}
diff --git a/plugin/src/PluginProcessor.h b/plugin/src/PluginProcessor.h
deleted file mode 100644
index 3a1efaf..0000000
--- a/plugin/src/PluginProcessor.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <juce_audio_processors/juce_audio_processors.h>
-#include "TapeLooperProcessor.h"
-
-//==============================================================================
-class TapeLooperPluginAudioProcessor : public juce::AudioProcessor
-{
-public:
-    //==============================================================================
-    TapeLooperPluginAudioProcessor();
-    ~TapeLooperPluginAudioProcessor() override;
-
-    //==============================================================================
-    void prepareToPlay(double sampleRate, int samplesPerBlock) override;
-    void releaseResources() override;
-
-    bool isBusesLayoutSupported(const BusesLayout& layouts) const override;
-
-    void processBlock(juce::AudioBuffer<float>&, juce::MidiBuffer&) override;
-    using AudioProcessor::processBlock;
-
-    //==============================================================================
-    juce::AudioProcessorEditor* createEditor() override;
-    bool hasEditor() const override;
-
-    //==============================================================================
-    const juce::String getName() const override;
-
-    bool acceptsMidi() const override;
-    bool producesMidi() const override;
-    bool isMidiEffect() const override;
-    double getTailLengthSeconds() const override;
-
-    //==============================================================================
-    int getNumPrograms() override;
-    int getCurrentProgram() override;
-    void setCurrentProgram(int index) override;
-    const juce::String getProgramName(int index) override;
-    void changeProgramName(int index, const juce::String& newName) override;
-
-    //==============================================================================
-    void getStateInformation(juce::MemoryBlock& destData) override;
-    void setStateInformation(const void* data, int sizeInBytes) override;
-
-    juce::AudioProcessorValueTreeState parameters_;
-
-private:
-    //==============================================================================
-    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(TapeLooperPluginAudioProcessor)
-
-    TapeLooperBank loopers_;
-
-    juce::AudioProcessorValueTreeState::ParameterLayout getParameterLayout();
-};
diff --git a/plugin/src/TapeLooperComponent.h b/plugin/src/TapeLooperComponent.h
deleted file mode 100644
index 5864700..0000000
--- a/plugin/src/TapeLooperComponent.h
+++ /dev/null
@@ -1,196 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <juce_gui_basics/juce_gui_basics.h>
-#include <juce_audio_plugin_client/juce_audio_plugin_client.h>
-
-class PlayStopRecButtons : public juce::Component, private juce::Button::Listener
-{
-public:
-    PlayStopRecButtons(juce::AudioParameterChoice& playStateParameter) :
-        paramAttachment_(playStateParameter, [this](float val)
-                         { updateButtons(val); })
-    {
-        recButton_.setButtonText("Rec");
-        addAndMakeVisible(recButton_);
-        recButton_.addListener(this);
-
-        revButton_.setButtonText("<");
-        addAndMakeVisible(revButton_);
-        revButton_.addListener(this);
-
-        stopButton_.setButtonText("Stop");
-        addAndMakeVisible(stopButton_);
-        stopButton_.addListener(this);
-
-        forwButton_.setButtonText(">");
-        addAndMakeVisible(forwButton_);
-        forwButton_.addListener(this);
-
-        paramAttachment_.sendInitialUpdate();
-    }
-
-    ~PlayStopRecButtons() override
-    {
-        recButton_.removeListener(this);
-        revButton_.removeListener(this);
-        stopButton_.removeListener(this);
-        forwButton_.removeListener(this);
-    }
-
-    void resized() override
-    {
-        auto bounds = getLocalBounds();
-        const auto quarterOfWidth = int(float(getWidth()) / 4.0f);
-
-        recButton_.setBounds(bounds.removeFromTop(getHeight() / 2));
-        revButton_.setBounds(bounds.removeFromLeft(quarterOfWidth));
-        forwButton_.setBounds(bounds.removeFromRight(quarterOfWidth));
-        stopButton_.setBounds(bounds);
-    }
-
-private:
-    juce::TextButton recButton_;
-    juce::TextButton revButton_;
-    juce::TextButton stopButton_;
-    juce::TextButton forwButton_;
-    juce::ParameterAttachment paramAttachment_;
-
-    void updateButtons(float val)
-    {
-        const auto choice = int(std::round(val));
-        revButton_.setToggleState(choice == 0, juce::NotificationType::dontSendNotification);
-        stopButton_.setToggleState(choice == 1, juce::NotificationType::dontSendNotification);
-        forwButton_.setToggleState(choice == 2, juce::NotificationType::dontSendNotification);
-        recButton_.setToggleState(choice == 3, juce::NotificationType::dontSendNotification);
-    }
-
-    void buttonClicked(juce::Button* bttn) override
-    {
-        if (bttn == &revButton_)
-            paramAttachment_.setValueAsCompleteGesture(0.0f);
-        else if (bttn == &stopButton_)
-            paramAttachment_.setValueAsCompleteGesture(1.0f);
-        else if (bttn == &forwButton_)
-            paramAttachment_.setValueAsCompleteGesture(2.0f);
-        else if (bttn == &recButton_)
-            paramAttachment_.setValueAsCompleteGesture(3.0f);
-    }
-};
-
-class TapeLooperComponent : public juce::Component
-{
-public:
-    TapeLooperComponent(juce::AudioParameterChoice& playStateParameter,
-                        juce::AudioParameterFloat& speedParameter,
-                        juce::AudioParameterFloat& driveParameter,
-                        juce::AudioParameterFloat& grainAmtParameter,
-                        juce::AudioParameterFloat& wowAndFlutterAmtParameter,
-                        juce::AudioParameterFloat& postGainParameter) :
-        playStopRecButtons_(playStateParameter),
-        speedSliderAttachment_(speedParameter, speedSlider_),
-        driveSliderAttachment_(driveParameter, driveSlider_),
-        grainAmtSliderAttachment_(grainAmtParameter, grainAmtSlider_),
-        wowAndFlutterAmtSliderAttachment_(wowAndFlutterAmtParameter, wowAndFlutterAmtSlider_),
-        postGainSliderAttachment_(postGainParameter, postGainSlider_)
-    {
-        addAndMakeVisible(playStopRecButtons_);
-
-        speedSlider_.setSliderStyle(juce::Slider::SliderStyle::RotaryHorizontalVerticalDrag);
-        speedSlider_.setTextBoxStyle(juce::Slider::TextEntryBoxPosition::TextBoxBelow, false, 40, 25);
-        addAndMakeVisible(speedSlider_);
-
-        driveSlider_.setSliderStyle(juce::Slider::SliderStyle::RotaryHorizontalVerticalDrag);
-        driveSlider_.setTextBoxStyle(juce::Slider::TextEntryBoxPosition::TextBoxBelow, false, 40, 25);
-        addAndMakeVisible(driveSlider_);
-
-        grainAmtSlider_.setSliderStyle(juce::Slider::SliderStyle::RotaryHorizontalVerticalDrag);
-        grainAmtSlider_.setTextBoxStyle(juce::Slider::TextEntryBoxPosition::TextBoxBelow, false, 40, 25);
-        addAndMakeVisible(grainAmtSlider_);
-
-        wowAndFlutterAmtSlider_.setSliderStyle(juce::Slider::SliderStyle::RotaryHorizontalVerticalDrag);
-        wowAndFlutterAmtSlider_.setTextBoxStyle(juce::Slider::TextEntryBoxPosition::TextBoxBelow, false, 40, 25);
-        addAndMakeVisible(wowAndFlutterAmtSlider_);
-
-        postGainSlider_.setSliderStyle(juce::Slider::SliderStyle::LinearVertical);
-        postGainSlider_.setTextBoxStyle(juce::Slider::TextEntryBoxPosition::TextBoxBelow, false, 40, 25);
-        addAndMakeVisible(postGainSlider_);
-
-        speedSliderAttachment_.sendInitialUpdate();
-        driveSliderAttachment_.sendInitialUpdate();
-        grainAmtSliderAttachment_.sendInitialUpdate();
-        wowAndFlutterAmtSliderAttachment_.sendInitialUpdate();
-        postGainSliderAttachment_.sendInitialUpdate();
-    }
-
-    void resized() override
-    {
-        auto bounds = getLocalBounds().reduced(1);
-
-        const auto buttonHeight = 25;
-
-        playStopRecButtons_.setBounds(bounds.removeFromTop(2 * buttonHeight));
-        bounds.removeFromTop(1); // padding
-        const auto rotarySliderWidth = std::min(bounds.getWidth(), 60);
-        speedSlider_.setBounds(bounds.removeFromTop(rotarySliderWidth + buttonHeight));
-        bounds.removeFromTop(1); // padding
-        driveSlider_.setBounds(bounds.removeFromTop(rotarySliderWidth + buttonHeight));
-        bounds.removeFromTop(1); // padding
-        grainAmtSlider_.setBounds(bounds.removeFromTop(rotarySliderWidth + buttonHeight));
-        bounds.removeFromTop(1); // padding
-        wowAndFlutterAmtSlider_.setBounds(bounds.removeFromTop(rotarySliderWidth + buttonHeight));
-        bounds.removeFromTop(1); // padding
-        postGainSlider_.setBounds(bounds);
-    }
-
-    void paint(juce::Graphics& g) override
-    {
-        const auto drawVerticalText = [&](const juce::String& text, juce::Rectangle<int> boundingBox)
-        {
-            g.saveState();
-            g.setOrigin(boundingBox.getCentre());
-            g.addTransform(juce::AffineTransform().rotated(-juce::MathConstants<float>::halfPi));
-            g.drawSingleLineText(text,
-                                 0,
-                                 0,
-                                 juce::Justification::horizontallyCentred);
-            g.restoreState();
-        };
-
-        g.setColour(findColour(juce::Label::ColourIds::textColourId));
-        drawVerticalText("Speed", speedSlider_.getBounds().withWidth(20));
-        drawVerticalText("Drive", driveSlider_.getBounds().withWidth(20));
-        drawVerticalText("Grain", grainAmtSlider_.getBounds().withWidth(20));
-        drawVerticalText("Wow & Flutter", wowAndFlutterAmtSlider_.getBounds().withWidth(20));
-        drawVerticalText("Volume", postGainSlider_.getBounds().withWidth(20));
-    }
-
-private:
-    PlayStopRecButtons playStopRecButtons_;
-    juce::Slider speedSlider_;
-    juce::SliderParameterAttachment speedSliderAttachment_;
-    juce::Slider driveSlider_;
-    juce::SliderParameterAttachment driveSliderAttachment_;
-    juce::Slider grainAmtSlider_;
-    juce::SliderParameterAttachment grainAmtSliderAttachment_;
-    juce::Slider wowAndFlutterAmtSlider_;
-    juce::SliderParameterAttachment wowAndFlutterAmtSliderAttachment_;
-    juce::Slider postGainSlider_;
-    juce::SliderParameterAttachment postGainSliderAttachment_;
-};
diff --git a/plugin/src/TapeLooperProcessor.h b/plugin/src/TapeLooperProcessor.h
deleted file mode 100644
index df6a75c..0000000
--- a/plugin/src/TapeLooperProcessor.h
+++ /dev/null
@@ -1,391 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include "DspDefinitions.h"
-#include <algorithm>
-#include <juce_audio_plugin_client/juce_audio_plugin_client.h>
-#include <juce_dsp/juce_dsp.h>
-
-#include <dsp/TapeLooper.h>
-#include <util/Memory.h>
-
-class MemoryBlockStorageProvider
-{
-public:
-    MemoryBlockStorageProvider(juce::MemoryBlock& mem) :
-        size_(mem.getSize()),
-        ptr_((uint8_t*) mem.getData())
-    {
-    }
-
-    constexpr size_t getAvailableSize() const { return size_; }
-
-    void write(const void* srcData, size_t sizeToWrite)
-    {
-        if (size_ >= sizeToWrite)
-        {
-            memcpy(ptr_, srcData, sizeToWrite);
-            ptr_ += sizeToWrite;
-            size_ -= sizeToWrite;
-        }
-    }
-
-    size_t size_;
-    uint8_t* ptr_;
-};
-
-class RawMemoryStorageProvider
-{
-public:
-    RawMemoryStorageProvider(const void* data, size_t size) :
-        size_(size),
-        ptr_((uint8_t*) data)
-    {
-    }
-
-    constexpr size_t getAvailableSize() const { return size_; }
-
-    void read(void* destData, size_t sizeToRead)
-    {
-        if (size_ >= sizeToRead)
-        {
-            memcpy(destData, ptr_, sizeToRead);
-            ptr_ += sizeToRead;
-            size_ -= sizeToRead;
-        }
-    }
-
-    size_t size_;
-    uint8_t* ptr_;
-};
-
-class ITapeLooperProcessor
-{
-public:
-    virtual ~ITapeLooperProcessor() {}
-
-    virtual void prepareToPlay() = 0;
-    virtual void processBlock(juce::dsp::AudioBlock<const float> input,
-                              juce::dsp::AudioBlock<float> outputToAddTo) = 0;
-    virtual size_t getStateSizeInBytes() const = 0;
-    virtual void saveState(WritableMemory<MemoryBlockStorageProvider>& mem) const = 0;
-    virtual void recallState(ReadableMemory<RawMemoryStorageProvider>& mem) = 0;
-};
-
-template <size_t samplerate>
-class TapeLooperProcessor : public ITapeLooperProcessor
-{
-public:
-    TapeLooperProcessor(juce::AudioParameterChoice& stateParameter,
-                        juce::AudioParameterFloat& speedParameter,
-                        juce::AudioParameterFloat& driveParameter,
-                        juce::AudioParameterFloat& grainAmtParameter,
-                        juce::AudioParameterFloat& wowAndFlutterAmtParameter,
-                        juce::AudioParameterFloat& postGainParameter,
-                        const LooperStoragePtr<2>& storage) :
-        stateParameter_(stateParameter),
-        speedParameter_(speedParameter),
-        driveParameter_(driveParameter),
-        grainAmtParameter_(grainAmtParameter),
-        wowAndFlutterAmtParameter_(wowAndFlutterAmtParameter),
-        postGainParameter_(postGainParameter),
-        looper_(storage)
-    {
-    }
-
-    void prepareToPlay() override
-    {
-        looper_.reset();
-    }
-
-    void processBlock(juce::dsp::AudioBlock<const float> input,
-                      juce::dsp::AudioBlock<float> outputToAddTo) override
-    {
-        const auto speed = speedParameter_.get();
-        const auto drive = driveParameter_.get();
-        const auto grainAmt = grainAmtParameter_.get();
-        const auto wowAndFlutterAmt = wowAndFlutterAmtParameter_.get();
-        const auto postGain = postGainParameter_.get();
-
-        Direction direction = Direction::forwards;
-        LooperState nextState = LooperState::stopped;
-        const auto stateIndex = stateParameter_.getIndex();
-        if (stateIndex == 0)
-        {
-            nextState = LooperState::playing;
-            direction = Direction::backwards;
-        }
-        else if (stateIndex == 1)
-            nextState = LooperState::stopped;
-        else if (stateIndex == 2)
-        {
-            nextState = LooperState::playing;
-            direction = Direction::forwards;
-        }
-        else if (stateIndex == 3)
-            nextState = LooperState::recording;
-
-        if (nextState != looper_.getState())
-            looper_.switchState(nextState);
-
-        typename TapeLooper<samplerate, 2>::ProcessorType::Parameters params;
-        params.driveGain = drive;
-        params.grainAmt = grainAmt;
-
-        const float* inChPtrs[2] = { input.getChannelPointer(0),
-                                     input.getChannelPointer(1) };
-        float* outChPtrs[2] = { outputToAddTo.getChannelPointer(0),
-                                outputToAddTo.getChannelPointer(1) };
-        looper_.process(speed,
-                        wowAndFlutterAmt,
-                        direction,
-                        params,
-                        postGain,
-                        AudioBufferPtr<2, const float>(
-                            inChPtrs, input.getNumSamples()),
-                        AudioBufferPtr<2, float>(
-                            outChPtrs, outputToAddTo.getNumSamples()));
-    }
-
-    size_t getStateSizeInBytes() const override
-    {
-        return looper_.getSaveAndRecallStorageSize()
-               + sizeof(ParameterValues);
-    }
-
-    void saveState(WritableMemory<MemoryBlockStorageProvider>& mem) const override
-    {
-        if (mem.getRemainingSize() < getStateSizeInBytes())
-            throw std::runtime_error("Not enough memory to store looper state");
-
-        bool result = true;
-
-        result &= looper_.save(mem);
-
-        ParameterValues params;
-        params.state = uint8_t(stateParameter_.getIndex());
-        params.speed = speedParameter_.get();
-        params.drive = driveParameter_.get();
-        params.grainAmt = grainAmtParameter_.get();
-        params.wowAndFlutter = wowAndFlutterAmtParameter_.get();
-        params.postGain = postGainParameter_.get();
-        result &= mem.writeItem(params);
-
-        if (!result)
-            throw std::runtime_error("Error saving looper state");
-    }
-
-    void recallState(ReadableMemory<RawMemoryStorageProvider>& mem) override
-    {
-        if (mem.getRemainingSize() < getStateSizeInBytes())
-            throw std::runtime_error("Not enough memory to restore looper state");
-
-        bool result = true;
-
-        result &= looper_.restore(mem);
-
-        ParameterValues params;
-        result &= mem.readItem(params);
-
-        if (!result)
-            throw std::runtime_error("Error loading looper state");
-
-        const auto setParam = [](juce::RangedAudioParameter& param, float value)
-        {
-            param.beginChangeGesture();
-            param.setValueNotifyingHost(param.convertTo0to1(value));
-            param.endChangeGesture();
-        };
-        setParam(stateParameter_, float(params.state));
-        setParam(speedParameter_, params.speed);
-        setParam(driveParameter_, params.drive);
-        setParam(grainAmtParameter_, params.grainAmt);
-        setParam(wowAndFlutterAmtParameter_, params.wowAndFlutter);
-        setParam(postGainParameter_, params.postGain);
-    }
-
-private:
-    juce::AudioParameterChoice& stateParameter_;
-    juce::AudioParameterFloat& speedParameter_;
-    juce::AudioParameterFloat& driveParameter_;
-    juce::AudioParameterFloat& grainAmtParameter_;
-    juce::AudioParameterFloat& wowAndFlutterAmtParameter_;
-    juce::AudioParameterFloat& postGainParameter_;
-
-    struct ParameterValues
-    {
-        uint8_t state;
-        float speed;
-        float drive;
-        float grainAmt;
-        float wowAndFlutter;
-        float postGain;
-    };
-
-    using TapeLooperType = TapeLooper<samplerate, 2>;
-    TapeLooperType looper_;
-};
-
-class TapeLooperBank
-{
-public:
-    TapeLooperBank(juce::AudioProcessorValueTreeState& parameters) :
-        parameters_(parameters),
-        currentSampleRate_(0)
-    {
-    }
-
-    void prepareToPlay(const juce::dsp::ProcessSpec& specs)
-    {
-        inputTmpBuffer_.setSize(2, int(specs.maximumBlockSize));
-        inputTmpBuffer_.clear();
-
-        createInstancesFor(specs.sampleRate);
-
-        for (auto processor : processors_)
-            processor->prepareToPlay();
-    }
-
-    void processBlock(juce::dsp::AudioBlock<float> buffer)
-    {
-        for (size_t ch = 0; ch < std::min(buffer.getNumChannels(), size_t(inputTmpBuffer_.getNumChannels())); ch++)
-            inputTmpBuffer_.copyFrom(int(ch), 0, buffer.getChannelPointer(ch), int(buffer.getNumSamples()));
-        const auto inputBuffer = juce::dsp::AudioBlock<float>(
-            inputTmpBuffer_.getArrayOfWritePointers(),
-            buffer.getNumChannels(),
-            buffer.getNumSamples());
-
-        // process loopers
-        buffer.clear();
-        for (auto processor : processors_)
-            processor->processBlock(inputBuffer, buffer);
-    }
-
-    void saveState(juce::MemoryBlock& memory)
-    {
-        size_t sizeNeeded = 0;
-        for (auto processor : processors_)
-            sizeNeeded += processor->getStateSizeInBytes();
-
-        memory.setSize(sizeNeeded, true);
-        MemoryBlockStorageProvider storageProvider(memory);
-        WritableMemory<MemoryBlockStorageProvider> writableMem(storageProvider);
-
-        for (auto processor : processors_)
-            processor->saveState(writableMem);
-    }
-
-    void recallState(const void* data, size_t sizeInBytes)
-    {
-        RawMemoryStorageProvider storageProvider(data, sizeInBytes);
-        ReadableMemory<RawMemoryStorageProvider> readableMem(storageProvider);
-
-        for (auto processor : processors_)
-            processor->recallState(readableMem);
-    }
-
-private:
-    void createInstancesFor(double sampleRate)
-    {
-        static constexpr auto supportedSampleRates = { 44100, 48000, 88200, 96000 };
-
-        if (sampleRate != currentSampleRate_)
-        {
-            // init storage
-            const int numSamples = int(std::ceil(dspdefs::loopLengthInS * sampleRate));
-            storage_.setSize(int(dspdefs::numLoopers) * 2 /* stereo */,
-                             numSamples,
-                             false,
-                             true);
-
-            // init processors
-            const auto sampleRateToUse = getClosestSampleRate(supportedSampleRates, sampleRate);
-            switch (sampleRateToUse)
-            {
-                default:
-                case 44100u:
-                    createProcessorInstances<TapeLooperProcessor<44100u>>();
-                    break;
-                case 48000u:
-                    createProcessorInstances<TapeLooperProcessor<48000u>>();
-                    break;
-                case 88200u:
-                    createProcessorInstances<TapeLooperProcessor<88200u>>();
-                    break;
-                case 96000u:
-                    createProcessorInstances<TapeLooperProcessor<96000u>>();
-                    break;
-            }
-        }
-
-        currentSampleRate_ = sampleRate;
-    }
-
-    size_t getClosestSampleRate(const std::initializer_list<int>& supportedSampleRates, double sampleRate)
-    {
-        size_t result = 0;
-        double currentDistance = 10.0e12;
-        for (const auto sr : supportedSampleRates)
-        {
-            const auto distance = std::abs(double(sr) - sampleRate);
-            if (distance < currentDistance)
-            {
-                result = size_t(sr);
-                currentDistance = distance;
-            }
-        }
-        return result;
-    }
-
-    template <typename ProcessorType>
-    void createProcessorInstances()
-    {
-        processors_.clear();
-        for (size_t i = 0; i < dspdefs::numLoopers; i++)
-        {
-            LooperStoragePtr<2> storagePtr;
-            storagePtr.data[0] = storage_.getWritePointer(int(2 * i));
-            storagePtr.data[1] = storage_.getWritePointer(int(2 * i + 1));
-            storagePtr.numSamples = size_t(storage_.getNumSamples());
-
-            const juce::String chStr(i);
-            auto& stateParameter = *(juce::AudioParameterChoice*) parameters_.getParameter(dspdefs::paramIds::chState + chStr);
-            auto& speedParameter = *(juce::AudioParameterFloat*) parameters_.getParameter(dspdefs::paramIds::chSpeed + chStr);
-            auto& driveParameter = *(juce::AudioParameterFloat*) parameters_.getParameter(dspdefs::paramIds::chDrive + chStr);
-            auto& grainAmtParameter = *(juce::AudioParameterFloat*) parameters_.getParameter(dspdefs::paramIds::chGrainAmt + chStr);
-            auto& wowAndFlutterAmtParameter = *(juce::AudioParameterFloat*) parameters_.getParameter(dspdefs::paramIds::chWowAndFlutterAmt + chStr);
-            auto& postGainParameter = *(juce::AudioParameterFloat*) parameters_.getParameter(dspdefs::paramIds::chPostGain + chStr);
-
-            processors_.add(new ProcessorType(stateParameter,
-                                              speedParameter,
-                                              driveParameter,
-                                              grainAmtParameter,
-                                              wowAndFlutterAmtParameter,
-                                              postGainParameter,
-                                              storagePtr));
-        }
-    }
-
-    juce::AudioProcessorValueTreeState& parameters_;
-
-    double currentSampleRate_;
-    juce::AudioBuffer<float> storage_;
-    juce::AudioBuffer<float> inputTmpBuffer_;
-    juce::OwnedArray<ITapeLooperProcessor> processors_;
-};
diff --git a/plugin/tests/Example_gtest.cpp b/plugin/tests/Example_gtest.cpp
deleted file mode 100644
index 24ec4f1..0000000
--- a/plugin/tests/Example_gtest.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * Copyright (C) Johannes Elliesen, 2021
- *
- * This program 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
- * any later version.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PluginProcessor.h"
-#include <gtest/gtest.h>
-
-/* This example test shows how to create an instance of the plugin as
-   part of a test. */
-TEST(ExampleTest, CreatePluginAndGUITest)
-{
-    juce::ScopedJuceInitialiser_GUI juceInitializer;
-    auto messageManager = juce::MessageManager::getInstance();
-    messageManager->setCurrentThreadAsMessageThread();
-
-    auto pluginInstance = std::make_unique<TapeLooperPluginAudioProcessor>();
-    EXPECT_NE(pluginInstance, nullptr);
-    auto gui = pluginInstance->createEditorIfNeeded();
-    EXPECT_NE(gui, nullptr);
-
-    messageManager->runDispatchLoopUntil(200);
-
-    pluginInstance->editorBeingDeleted(gui);
-    delete gui;
-
-    pluginInstance.reset();
-    messageManager->deleteInstance();
-}
\ No newline at end of file

From c267be24ac282dc7a1199f5e56feadce9e6f58c6 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 19:16:17 +0200
Subject: [PATCH 20/26] feat: extract loop library into its own class and
 namespace

---
 firmware/CMakeLists.txt              |   1 +
 firmware/src/AudioSaveAndRecall.cpp  |  84 +++++++++++++++
 firmware/src/AudioSaveAndRecall.h    | 152 +++++++++++----------------
 firmware/tests/firmware_combined.cpp |   3 +-
 4 files changed, 149 insertions(+), 91 deletions(-)
 create mode 100644 firmware/src/AudioSaveAndRecall.cpp

diff --git a/firmware/CMakeLists.txt b/firmware/CMakeLists.txt
index 8a68ed9..37da238 100644
--- a/firmware/CMakeLists.txt
+++ b/firmware/CMakeLists.txt
@@ -23,6 +23,7 @@ endif(COMMAND cmake_policy)
 
 set(FIRMWARE_NAME TapeLooper)
 set(FIRMWARE_SOURCES
+    src/AudioSaveAndRecall.cpp
     src/main.cpp
     src/util/WavFileFormat.cpp
 )
diff --git a/firmware/src/AudioSaveAndRecall.cpp b/firmware/src/AudioSaveAndRecall.cpp
new file mode 100644
index 0000000..fcee53e
--- /dev/null
+++ b/firmware/src/AudioSaveAndRecall.cpp
@@ -0,0 +1,84 @@
+/**
+ * Copyright (C) Johannes Elliesen, 2024
+ *
+ * This program 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
+ * any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "AudioSaveAndRecall.h"
+
+namespace loop_library
+{
+    AudioFileName makeFileNameWithoutExtensionFor(const StorageBank bank,
+                                                  const int slot)
+    {
+        auto filename = AudioFileName(kLibraryBaseFolder);
+        switch (bank)
+        {
+            case StorageBank::green:
+                filename.Append("green-");
+                break;
+            case StorageBank::yellow:
+                filename.Append("yellow-");
+                break;
+            case StorageBank::red:
+                filename.Append("red-");
+                break;
+            default:
+                return "";
+        }
+        switch (slot / 4)
+        {
+            case 0:
+                filename.Append("A");
+                break;
+            case 1:
+                filename.Append("B");
+                break;
+            case 2:
+                filename.Append("C");
+                break;
+            case 3:
+                filename.Append("D");
+                break;
+            default:
+                return "";
+        }
+        switch (slot % 4)
+        {
+            case 0:
+                filename.Append("0");
+                break;
+            case 1:
+                filename.Append("1");
+                break;
+            case 2:
+                filename.Append("2");
+                break;
+            case 3:
+                filename.Append("3");
+                break;
+            default:
+                return "";
+        }
+        return filename;
+    }
+
+    AudioFileName makeWavFileNameFor(const StorageBank bank,
+                                     const int slot)
+    {
+        auto name = makeFileNameWithoutExtensionFor(bank, slot);
+        name.Append(".wav");
+        return name;
+    }
+} // namespace loop_library
diff --git a/firmware/src/AudioSaveAndRecall.h b/firmware/src/AudioSaveAndRecall.h
index b6b92cf..a9a0e41 100644
--- a/firmware/src/AudioSaveAndRecall.h
+++ b/firmware/src/AudioSaveAndRecall.h
@@ -21,6 +21,11 @@
 #include <dsp/TapeLooper.h>
 #include "util/WavFileFormat.h"
 
+extern int32_t f2s32(float x);
+extern float s322f(int32_t x);
+extern float s242f(int32_t x);
+extern float s162f(int16_t x);
+
 using AudioFileName = daisy::FixedCapStr<32>;
 
 enum class AudioSaveAndRecallResult
@@ -40,33 +45,69 @@ enum class StorageBank
 
 typedef void (*AudioSaveAndRecallDoneCallbackPtr)(void* context, AudioSaveAndRecallResult result);
 
-template <typename FileIoProvider>
-class AudioSaveAndRecall
+namespace loop_library
 {
-public:
-    AudioSaveAndRecall()
-    {
-        isStorageSlotUsedBitfield_[0] = 0;
-        isStorageSlotUsedBitfield_[1] = 0;
-        isStorageSlotUsedBitfield_[2] = 0;
-    }
+    static auto kLibraryBaseFolder = "loops/";
+
+    AudioFileName makeFileNameWithoutExtensionFor(const StorageBank bank,
+                                                  const int slot);
+    AudioFileName makeWavFileNameFor(const StorageBank bank,
+                                     const int slot);
 
-    void scanOrInitLibrary()
+    template <typename FileIoProvider>
+    class Library
     {
-        fileIo_.makeFolderIfNotExistent(libraryBaseFolder_);
+    public:
+        Library(FileIoProvider& fileIo) :
+            fileIo_(fileIo)
+        {
+            for (int i = 0; i < int(StorageBank::count); i++)
+            {
+                isStorageSlotUsedBitfield_[i] = 0;
+            }
+        }
 
-        for (size_t bank = 0; bank < kNumBanks; bank++)
+        void scanOrInitLibrary()
         {
-            for (size_t slot = 0; slot < kNumSlots; slot++)
+            fileIo_.makeFolderIfNotExistent(loop_library::kLibraryBaseFolder);
+
+            for (size_t bank = 0; bank < kNumBanks; bank++)
             {
-                const auto filename = makeWavFileNameFor(StorageBank(bank), slot);
+                for (size_t slot = 0; slot < kNumSlots; slot++)
+                {
+                    const auto filename = loop_library::makeWavFileNameFor(StorageBank(bank), slot);
 
-                if (const auto isInUse = fileIo_.hasFile(filename))
-                    isStorageSlotUsedBitfield_[bank] |= (1 << slot);
-                else
-                    isStorageSlotUsedBitfield_[bank] &= ~(1 << slot);
+                    if (const auto isInUse = fileIo_.hasFile(filename))
+                        isStorageSlotUsedBitfield_[bank] |= (1 << slot);
+                    else
+                        isStorageSlotUsedBitfield_[bank] &= ~(1 << slot);
+                }
             }
         }
+
+        bool hasLoop(StorageBank bank, int slot)
+        {
+            if (slot < 0 || slot >= kNumSlots)
+                return false;
+
+            return isStorageSlotUsedBitfield_[int(bank)] & (1 << slot);
+        }
+
+    private:
+        FileIoProvider& fileIo_;
+
+        static constexpr auto kNumSlots = 16;
+        static constexpr auto kNumBanks = int(StorageBank::count);
+        int16_t isStorageSlotUsedBitfield_[kNumBanks];
+    };
+}; // namespace loop_library
+
+template <typename FileIoProvider>
+class AudioSaveAndRecall
+{
+public:
+    AudioSaveAndRecall()
+    {
     }
 
     template <typename LooperType>
@@ -76,7 +117,7 @@ class AudioSaveAndRecall
                            AudioSaveAndRecallDoneCallbackPtr doneCallback,
                            void* doneCallbackContext)
     {
-        startSavingToFile(makeWavFileNameFor(bank, slot),
+        startSavingToFile(loop_library::makeWavFileNameFor(bank, slot),
                           looper,
                           doneCallback,
                           doneCallbackContext);
@@ -156,7 +197,7 @@ class AudioSaveAndRecall
     size_t getNumChannelsInFile(StorageBank bank,
                                 int slot)
     {
-        return getNumChannelsInFile(makeWavFileNameFor(bank, slot));
+        return getNumChannelsInFile(loop_library::makeWavFileNameFor(bank, slot));
     }
 
     size_t getNumChannelsInFile(const AudioFileName& filename)
@@ -188,7 +229,7 @@ class AudioSaveAndRecall
                               AudioSaveAndRecallDoneCallbackPtr doneCallback,
                               void* doneCallbackContext)
     {
-        startReadingFromFile(makeWavFileNameFor(bank, slot),
+        startReadingFromFile(loop_library::makeWavFileNameFor(bank, slot),
                              looper,
                              doneCallback,
                              doneCallbackContext);
@@ -566,69 +607,6 @@ class AudioSaveAndRecall
         return numFramesRead / numChannels;
     }
 
-    AudioFileName makeFileNameWithoutExtensionFor(const StorageBank bank,
-                                                  const int slot)
-    {
-        auto filename = libraryBaseFolder_;
-        switch (bank)
-        {
-            case StorageBank::green:
-                filename.Append("green-");
-                break;
-            case StorageBank::yellow:
-                filename.Append("yellow-");
-                break;
-            case StorageBank::red:
-                filename.Append("red-");
-                break;
-            default:
-                return "";
-        }
-        switch (slot / 4)
-        {
-            case 0:
-                filename.Append("A");
-                break;
-            case 1:
-                filename.Append("B");
-                break;
-            case 2:
-                filename.Append("C");
-                break;
-            case 3:
-                filename.Append("D");
-                break;
-            default:
-                return "";
-        }
-        switch (slot % 4)
-        {
-            case 0:
-                filename.Append("0");
-                break;
-            case 1:
-                filename.Append("1");
-                break;
-            case 2:
-                filename.Append("2");
-                break;
-            case 3:
-                filename.Append("3");
-                break;
-            default:
-                return "";
-        }
-        return filename;
-    }
-
-    AudioFileName makeWavFileNameFor(const StorageBank bank,
-                                     const int slot)
-    {
-        auto name = makeFileNameWithoutExtensionFor(bank, slot);
-        name.Append(".wav");
-        return name;
-    }
-
     static constexpr size_t kNumFramesPerChunk_ = 1000;
     static constexpr size_t kBitsPerSample_ = 32u;
     static constexpr size_t kMaxNumChannels_ = 2u;
@@ -658,10 +636,4 @@ class AudioSaveAndRecall
     void* doneCallbackContext_ = nullptr;
 
     int32_t writeBuffer_[kWriteBufferSizeBytes_ / sizeof(int32_t)];
-
-    static constexpr auto kNumSlots = 16;
-    static constexpr auto kNumBanks = int(StorageBank::count);
-    int16_t isStorageSlotUsedBitfield_[kNumBanks];
-
-    const AudioFileName libraryBaseFolder_ = "loops";
 };
diff --git a/firmware/tests/firmware_combined.cpp b/firmware/tests/firmware_combined.cpp
index 9178721..ca7393b 100644
--- a/firmware/tests/firmware_combined.cpp
+++ b/firmware/tests/firmware_combined.cpp
@@ -1 +1,2 @@
-#include "../src/util/WavFileFormat.cpp"
\ No newline at end of file
+#include "../src/util/WavFileFormat.cpp"
+#include "../src/AudioSaveAndRecall.cpp"
\ No newline at end of file

From a74f946ad488eee52d260e0f89d1bf69fea296f9 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 19:24:07 +0200
Subject: [PATCH 21/26] refactor: extract file io ownership from
 `AudioSaveAndRecall`

---
 firmware/src/AudioSaveAndRecall.h           |  5 +-
 firmware/src/main.cpp                       |  5 +-
 firmware/tests/AudioSaveAndRecall_gtest.cpp | 71 +++++++++++----------
 3 files changed, 43 insertions(+), 38 deletions(-)

diff --git a/firmware/src/AudioSaveAndRecall.h b/firmware/src/AudioSaveAndRecall.h
index a9a0e41..b28e4c4 100644
--- a/firmware/src/AudioSaveAndRecall.h
+++ b/firmware/src/AudioSaveAndRecall.h
@@ -106,7 +106,8 @@ template <typename FileIoProvider>
 class AudioSaveAndRecall
 {
 public:
-    AudioSaveAndRecall()
+    AudioSaveAndRecall(FileIoProvider& fileIo) :
+        fileIo_(fileIo)
     {
     }
 
@@ -625,7 +626,7 @@ class AudioSaveAndRecall
     typedef ReadOrWriteResult (*WriteOrReadFuncPtr)(AudioSaveAndRecall* storage, void* looper);
     typedef void (*LiftRestrictionsFuncPtr)(void* looper);
 
-    FileIoProvider fileIo_;
+    FileIoProvider& fileIo_;
 
     size_t totalNumFrames_ = 0;
     size_t numFramesDone_ = 0;
diff --git a/firmware/src/main.cpp b/firmware/src/main.cpp
index 6f3e33c..482b021 100644
--- a/firmware/src/main.cpp
+++ b/firmware/src/main.cpp
@@ -55,6 +55,7 @@ daisy::UiEventQueue uiEventQueue;
 UiHardware::LedDmaBufferType DMA_BUFFER_MEM_SECTION ledDmaBufferA, ledDmaBufferB;
 uint16_t DMA_BUFFER_MEM_SECTION buttonShiftRegisterDmaBuffer;
 
+LateInitializedObject<FatFsFileIo> fileIo;
 LateInitializedObject<UiHardware> uiHardware;
 LateInitializedObject<TapeLooperUiType> ui;
 
@@ -113,7 +114,7 @@ void initDsp()
 {
     looperParameterProvider.create();
 
-    audioSaveAndRecall.create();
+    audioSaveAndRecall.create(fileIo);
 
     // initialize the looper storage in SDRAM
     const auto& rawStorages = *looperStorages.create();
@@ -147,6 +148,8 @@ void configurePlatform()
     seed.Init(true /* enable 480MHz boost */);
     seed.SetAudioBlockSize(blockSize);
     seed.SetAudioSampleRate(sampleRate);
+
+    fileIo.create();
 }
 
 void audioCallback(const float* const* in, float** out, size_t size)
diff --git a/firmware/tests/AudioSaveAndRecall_gtest.cpp b/firmware/tests/AudioSaveAndRecall_gtest.cpp
index 4c0312f..a2956c5 100644
--- a/firmware/tests/AudioSaveAndRecall_gtest.cpp
+++ b/firmware/tests/AudioSaveAndRecall_gtest.cpp
@@ -171,6 +171,7 @@ class AudioSaveAndRecallFixture : public ::testing::Test
     LooperStorage<kNumSamples, 2> stereoBuffer_;
     TapeLooper<kSampleRate, 1> monoLooper_;
     TapeLooper<kSampleRate, 2> stereoLooper_;
+    TestFileIo fileIo_;
 
     AudioSaveAndRecallResult doneCallbackResult_ =
         AudioSaveAndRecallResult(-1); // invalid
@@ -219,19 +220,19 @@ class AudioSaveAndRecallFixture : public ::testing::Test
 
 TEST_F(AudioSaveAndRecallFixture, a_saveToFile_failWhenNoDataInLooper)
 {
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
     monoLooper_.setPlaybackLength(0);
 
-    sut.getFileIoProviderForTesting().simulateFileOpenError_ = true;
+    fileIo_.simulateFileOpenError_ = true;
     sut.startSavingToFile("dummyFilename",
                           monoLooper_,
                           &doneCallback,
                           &doneCallbackResult_);
 
     // doesn't even open the file
-    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "");
-    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_STREQ(fileIo_.lastFileName_, "");
+    EXPECT_FALSE(fileIo_.closeFileCalled_);
 
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::error);
     EXPECT_EQ(sut.getCurrentProgress(), -1.0f);
@@ -239,33 +240,33 @@ TEST_F(AudioSaveAndRecallFixture, a_saveToFile_failWhenNoDataInLooper)
 
 TEST_F(AudioSaveAndRecallFixture, b_saveToFile_failWhenFileDoesntOpen)
 {
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
-    sut.getFileIoProviderForTesting().simulateFileOpenError_ = true;
+    fileIo_.simulateFileOpenError_ = true;
     sut.startSavingToFile("dummyFilename",
                           monoLooper_,
                           &doneCallback,
                           &doneCallbackResult_);
 
-    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_STREQ(fileIo_.lastFileName_, "dummyFilename");
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::error);
     EXPECT_EQ(sut.getCurrentProgress(), -1.0f);
-    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_TRUE(fileIo_.closeFileCalled_);
 }
 
 TEST_F(AudioSaveAndRecallFixture, c_saveToFile_failWhenErrorWhileWriting)
 {
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
     sut.startSavingToFile("dummyFilename",
                           monoLooper_,
                           &doneCallback,
                           &doneCallbackResult_);
 
-    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_STREQ(fileIo_.lastFileName_, "dummyFilename");
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult(-1)); // not called yet
     EXPECT_EQ(sut.getCurrentProgress(), 0.0f);
-    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_FALSE(fileIo_.closeFileCalled_);
 
     // make some progress
     sut.readOrWriteNextChunk();
@@ -273,18 +274,18 @@ TEST_F(AudioSaveAndRecallFixture, c_saveToFile_failWhenErrorWhileWriting)
     EXPECT_LT(sut.getCurrentProgress(), 1.0f);
 
     // simulate file IO error
-    sut.getFileIoProviderForTesting().simulateFileWriteError_ = true;
+    fileIo_.simulateFileWriteError_ = true;
     sut.readOrWriteNextChunk();
 
     // operation was aborted
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::error);
     EXPECT_EQ(sut.getCurrentProgress(), -1.0f);
-    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_TRUE(fileIo_.closeFileCalled_);
 }
 
 TEST_F(AudioSaveAndRecallFixture, d_saveToFile_saveFileButWaitUntilRecordingDoneAndPreventNewRecording)
 {
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
     monoLooper_.switchState(LooperState::recording);
     monoLooper_.recorderForTesting().setRecordingProgressForTesting(2000);
@@ -294,10 +295,10 @@ TEST_F(AudioSaveAndRecallFixture, d_saveToFile_saveFileButWaitUntilRecordingDone
                           &doneCallback,
                           &doneCallbackResult_);
 
-    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_STREQ(fileIo_.lastFileName_, "dummyFilename");
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult(-1)); // not called yet
     EXPECT_EQ(sut.getCurrentProgress(), 0.0f);
-    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_FALSE(fileIo_.closeFileCalled_);
 
     // the looper was stopped when saving started...
     EXPECT_EQ(monoLooper_.getState(), LooperState::stopped);
@@ -321,17 +322,17 @@ TEST_F(AudioSaveAndRecallFixture, d_saveToFile_saveFileButWaitUntilRecordingDone
 
 TEST_F(AudioSaveAndRecallFixture, e_saveToFile_saveFileAndAllowPlaybackButPreventNewRecording)
 {
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
     sut.startSavingToFile("dummyFilename",
                           monoLooper_,
                           &doneCallback,
                           &doneCallbackResult_);
 
-    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_STREQ(fileIo_.lastFileName_, "dummyFilename");
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult(-1)); // not called yet
     EXPECT_EQ(sut.getCurrentProgress(), 0.0f);
-    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_FALSE(fileIo_.closeFileCalled_);
 
     // attempt to start a new recording while we're saving
     monoLooper_.switchState(LooperState::recording);
@@ -360,17 +361,17 @@ TEST_F(AudioSaveAndRecallFixture, e_saveToFile_saveFileAndAllowPlaybackButPreven
 
 TEST_F(AudioSaveAndRecallFixture, f_saveToFile_saveFileAndReportProgress)
 {
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
     sut.startSavingToFile("dummyFilename",
                           monoLooper_,
                           &doneCallback,
                           &doneCallbackResult_);
 
-    EXPECT_STREQ(sut.getFileIoProviderForTesting().lastFileName_, "dummyFilename");
+    EXPECT_STREQ(fileIo_.lastFileName_, "dummyFilename");
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult(-1)); // not called yet
     EXPECT_EQ(sut.getCurrentProgress(), 0.0f);
-    EXPECT_FALSE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_FALSE(fileIo_.closeFileCalled_);
 
     // write until completed
     int timeout = 1000;
@@ -383,12 +384,12 @@ TEST_F(AudioSaveAndRecallFixture, f_saveToFile_saveFileAndReportProgress)
     }
     EXPECT_EQ(sut.getCurrentProgress(), 1.0f);
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::ok);
-    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_TRUE(fileIo_.closeFileCalled_);
 }
 
 TEST_F(AudioSaveAndRecallFixture, g_saveToFile_producesValidMonoWavFile)
 {
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
     constexpr auto kNumTestSamples = 4800;
     constexpr auto kReferenceFilename = "data/monoSineWaves.wav";
@@ -409,19 +410,19 @@ TEST_F(AudioSaveAndRecallFixture, g_saveToFile_producesValidMonoWavFile)
     }
     EXPECT_EQ(sut.getCurrentProgress(), 1.0f);
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::ok);
-    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_TRUE(fileIo_.closeFileCalled_);
 
 #ifdef WRITE_REFERENCES
-    writeReferenceFile(kReferenceFilename, sut.getFileIoProviderForTesting().dataWritten_);
+    writeReferenceFile(kReferenceFilename, fileIo_.dataWritten_);
 #endif
 
     const auto expectedFileContents = readReferenceFile(kReferenceFilename);
-    EXPECT_EQ(sut.getFileIoProviderForTesting().dataWritten_, expectedFileContents);
+    EXPECT_EQ(fileIo_.dataWritten_, expectedFileContents);
 }
 
 TEST_F(AudioSaveAndRecallFixture, h_saveToFile_producesValidStereoWavFile)
 {
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
     constexpr auto kNumTestSamples = 4800;
     constexpr auto kReferenceFilename = "data/stereoSineWaves.wav";
@@ -442,14 +443,14 @@ TEST_F(AudioSaveAndRecallFixture, h_saveToFile_producesValidStereoWavFile)
     }
     EXPECT_EQ(sut.getCurrentProgress(), 1.0f);
     EXPECT_EQ(doneCallbackResult_, AudioSaveAndRecallResult::ok);
-    EXPECT_TRUE(sut.getFileIoProviderForTesting().closeFileCalled_);
+    EXPECT_TRUE(fileIo_.closeFileCalled_);
 
 #ifdef WRITE_REFERENCES
-    writeReferenceFile(kReferenceFilename, sut.getFileIoProviderForTesting().dataWritten_);
+    writeReferenceFile(kReferenceFilename, fileIo_.dataWritten_);
 #endif
 
     const auto expectedFileContents = readReferenceFile(kReferenceFilename);
-    EXPECT_EQ(sut.getFileIoProviderForTesting().dataWritten_, expectedFileContents);
+    EXPECT_EQ(fileIo_.dataWritten_, expectedFileContents);
 }
 
 class AudioSaveAndRecallParameterizedFileFormatFixture :
@@ -462,11 +463,11 @@ TEST_P(AudioSaveAndRecallParameterizedFileFormatFixture, canReadMonoWav)
 {
     const auto [referenceFileNameMono, referenceFileNameStereo, epsilon] = GetParam();
 
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
     constexpr auto kExpectedNumSamples = 48;
 
-    sut.getFileIoProviderForTesting().dataToRead_ = readReferenceFile(referenceFileNameMono);
+    fileIo_.dataToRead_ = readReferenceFile(referenceFileNameMono);
 
     sut.startReadingFromFile("dummyFilename",
                              monoLooper_,
@@ -494,11 +495,11 @@ TEST_P(AudioSaveAndRecallParameterizedFileFormatFixture, canReadStereoWav)
 {
     const auto [referenceFileNameMono, referenceFileNameStereo, epsilon] = GetParam();
 
-    AudioSaveAndRecall<TestFileIo> sut;
+    AudioSaveAndRecall<TestFileIo> sut(fileIo_);
 
     constexpr auto kExpectedNumSamples = 48;
 
-    sut.getFileIoProviderForTesting().dataToRead_ = readReferenceFile(referenceFileNameStereo);
+    fileIo_.dataToRead_ = readReferenceFile(referenceFileNameStereo);
 
     sut.startReadingFromFile("dummyFilename",
                              stereoLooper_,

From 8d4cc9c3fe8c16935a6d091d64160b671059e957 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 19:40:51 +0200
Subject: [PATCH 22/26] feat: pass loop library into save and load ui pages

---
 firmware/src/main.cpp                   | 11 +++++--
 firmware/src/ui/TapeLooperUi.h          | 16 +++++++----
 firmware/src/ui/UiLoadOrSavePage.h      | 35 ++++++++++++++---------
 firmware/tests/Ui_gtest.cpp             |  8 ++++--
 firmware/tests/mocks/LoopLibrary_mock.h | 38 +++++++++++++++++++++++++
 5 files changed, 85 insertions(+), 23 deletions(-)
 create mode 100644 firmware/tests/mocks/LoopLibrary_mock.h

diff --git a/firmware/src/main.cpp b/firmware/src/main.cpp
index 482b021..62275f6 100644
--- a/firmware/src/main.cpp
+++ b/firmware/src/main.cpp
@@ -41,10 +41,13 @@ struct LooperTypes
     using AudioSaveAndRecallType = AudioSaveAndRecall<FatFsFileIo>;
 };
 using LooperControllerType = LooperController<LooperTypes, numLoopers>;
+using LoopLibraryType = loop_library::Library<FatFsFileIo>;
+
 using TapeLooperUiType = TapeLooperUi<UiHardware,
                                       PeakMeter<blockSize, sampleRateHz>,
                                       LooperControllerType,
-                                      LooperParameterProviderType>;
+                                      LooperParameterProviderType,
+                                      LoopLibraryType>;
 using LooperStoragesType = std::array<MonoOrStereoLooperStorage<looperSamplesPerChannel>, numLoopers>;
 
 // hardware static objects
@@ -57,6 +60,7 @@ uint16_t DMA_BUFFER_MEM_SECTION buttonShiftRegisterDmaBuffer;
 
 LateInitializedObject<FatFsFileIo> fileIo;
 LateInitializedObject<UiHardware> uiHardware;
+LateInitializedObject<LoopLibraryType> loopLibrary;
 LateInitializedObject<TapeLooperUiType> ui;
 
 // dsp static objects
@@ -95,6 +99,8 @@ void initUi()
                                         ledDmaBufferB,
                                         &buttonShiftRegisterDmaBuffer);
 
+    loopLibrary.create(fileIo);
+
     // init the UI
     ui.create(
         hardware,
@@ -103,7 +109,8 @@ void initUi()
         uiEventQueue,
         peakMeters,
         looperController,
-        looperParameterProvider);
+        looperParameterProvider,
+        loopLibrary);
 }
 
 // ===================================================================
diff --git a/firmware/src/ui/TapeLooperUi.h b/firmware/src/ui/TapeLooperUi.h
index 8499a44..c706294 100644
--- a/firmware/src/ui/TapeLooperUi.h
+++ b/firmware/src/ui/TapeLooperUi.h
@@ -32,7 +32,8 @@
 template <typename UiHardwareType,
           typename PeakMeterType,
           typename LooperControllerType,
-          typename ParameterProviderType>
+          typename ParameterProviderType,
+          typename LoopLibraryType>
 class TapeLooperUi
 {
 public:
@@ -42,15 +43,16 @@ class TapeLooperUi
                  daisy::UiEventQueue& eventQueue,
                  const std::array<PeakMeterType, 4>& peakMeters,
                  LooperControllerType& looperController,
-                 ParameterProviderType& looperParameterProvider) :
+                 ParameterProviderType& looperParameterProvider,
+                 LoopLibraryType& loopLibrary) :
         uiHardware_(uiHardware),
         eventQueue_(eventQueue),
         calibrationPage_(uiHardware),
         settingsPage_(looperController,
                       looperParameterProvider,
                       calibrationPage_),
-        savePage_(looperController),
-        loadPage_(looperController),
+        savePage_(looperController, loopLibrary),
+        loadPage_(looperController, loopLibrary),
         recordingPage_(looperController),
         basePage_(peakMeters,
                   looperController,
@@ -92,10 +94,12 @@ class TapeLooperUi
                    ParameterProviderType>
         settingsPage_;
     UiSavePage<LooperControllerType,
-               UiHardwareType>
+               UiHardwareType,
+               LoopLibraryType>
         savePage_;
     UiLoadPage<LooperControllerType,
-               UiHardwareType>
+               UiHardwareType,
+               LoopLibraryType>
         loadPage_;
     UiRecordingPage<LooperControllerType,
                     UiHardwareType>
diff --git a/firmware/src/ui/UiLoadOrSavePage.h b/firmware/src/ui/UiLoadOrSavePage.h
index 26eddd9..c5a08e3 100644
--- a/firmware/src/ui/UiLoadOrSavePage.h
+++ b/firmware/src/ui/UiLoadOrSavePage.h
@@ -27,12 +27,16 @@
 #include "../hardware/UiHardwareTypes.h"
 #include "LooperParameterProvider.h"
 
-template <typename LooperControllerType, typename UiHardwareType, Led PageLed>
+template <typename LooperControllerType,
+          typename UiHardwareType,
+          typename LoopLibraryType,
+          Led PageLed>
 class UiLoadOrSavePage : public daisy::UiPage
 {
 public:
-    UiLoadOrSavePage(LooperControllerType& looperController) :
-        looperController_(looperController)
+    UiLoadOrSavePage(LooperControllerType& looperController, LoopLibraryType& loopLibrary) :
+        looperController_(looperController),
+        loopLibrary_(loopLibrary)
     {
     }
 
@@ -321,17 +325,20 @@ class UiLoadOrSavePage : public daisy::UiPage
     int selectedChannel_ = -1;
     int selectedSlot_ = 0;
     LooperControllerType& looperController_;
+    LoopLibraryType& loopLibrary_;
     uint32_t closeAfterTime_ = -1;
 };
 
-template <typename LooperControllerType, typename UiHardwareType>
-class UiSavePage : public UiLoadOrSavePage<LooperControllerType, UiHardwareType, Led::save>
+template <typename LooperControllerType,
+          typename UiHardwareType,
+          typename LoopLibraryType>
+class UiSavePage : public UiLoadOrSavePage<LooperControllerType, UiHardwareType, LoopLibraryType, Led::save>
 {
-    using ParentType = UiLoadOrSavePage<LooperControllerType, UiHardwareType, Led::save>;
+    using ParentType = UiLoadOrSavePage<LooperControllerType, UiHardwareType, LoopLibraryType, Led::save>;
 
 public:
-    UiSavePage(LooperControllerType& looperController) :
-        ParentType(looperController)
+    UiSavePage(LooperControllerType& looperController, LoopLibraryType& loopLibrary) :
+        ParentType(looperController, loopLibrary)
     {
     }
 
@@ -365,14 +372,16 @@ class UiSavePage : public UiLoadOrSavePage<LooperControllerType, UiHardwareType,
     }
 };
 
-template <typename LooperControllerType, typename UiHardwareType>
-class UiLoadPage : public UiLoadOrSavePage<LooperControllerType, UiHardwareType, Led::load>
+template <typename LooperControllerType,
+          typename UiHardwareType,
+          typename LoopLibraryType>
+class UiLoadPage : public UiLoadOrSavePage<LooperControllerType, UiHardwareType, LoopLibraryType, Led::load>
 {
-    using ParentType = UiLoadOrSavePage<LooperControllerType, UiHardwareType, Led::load>;
+    using ParentType = UiLoadOrSavePage<LooperControllerType, UiHardwareType, LoopLibraryType, Led::load>;
 
 public:
-    UiLoadPage(LooperControllerType& looperController) :
-        ParentType(looperController)
+    UiLoadPage(LooperControllerType& looperController, LoopLibraryType& loopLibrary) :
+        ParentType(looperController, loopLibrary)
     {
     }
 
diff --git a/firmware/tests/Ui_gtest.cpp b/firmware/tests/Ui_gtest.cpp
index 7ac9fbe..c931351 100644
--- a/firmware/tests/Ui_gtest.cpp
+++ b/firmware/tests/Ui_gtest.cpp
@@ -24,6 +24,7 @@
 #include "ui/TapeLooperUi.h"
 
 #include "mocks/LooperController_mock.h"
+#include "mocks/LoopLibrary_mock.h"
 #include "mocks/ParameterProvider_mock.h"
 #include "mocks/PeakMeter_mock.h"
 #include "mocks/UiHardware_mock.h"
@@ -119,7 +120,8 @@ class UiFixture : public ::testing::Test
             eventQueue_,
             peakMeters_,
             looperController_,
-            looperParameterProvider_)
+            looperParameterProvider_,
+            loopLibrary_)
     {
         uiTestMockFunctionIsolator.GetStateForCurrentTest()->clearCanvasFunction =
             [&](const daisy::UiCanvasDescriptor&)
@@ -328,10 +330,12 @@ class UiFixture : public ::testing::Test
     std::array<PeakMeterMock, numLoopers_> peakMeters_;
     LooperControllerMock<numLoopers_> looperController_;
     ParameterProviderMock<numLoopers_> looperParameterProvider_;
+    LoopLibraryMock loopLibrary_;
     TapeLooperUi<UiHardwareMock,
                  PeakMeterMock,
                  LooperControllerMock<numLoopers_>,
-                 ParameterProviderMock<numLoopers_>>
+                 ParameterProviderMock<numLoopers_>,
+                 LoopLibraryMock>
         ui_;
 };
 
diff --git a/firmware/tests/mocks/LoopLibrary_mock.h b/firmware/tests/mocks/LoopLibrary_mock.h
new file mode 100644
index 0000000..5828635
--- /dev/null
+++ b/firmware/tests/mocks/LoopLibrary_mock.h
@@ -0,0 +1,38 @@
+/**
+ * Copyright (C) Johannes Elliesen, 2025
+ *
+ * This program 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
+ * any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include "AudioSaveAndRecall.h"
+
+class LoopLibraryMock
+{
+public:
+    void scanOrInitLibrary()
+    {
+    }
+
+    bool hasLoop(StorageBank bank, int slot)
+    {
+        (void) (bank);
+        (void) (slot);
+
+        return false;
+    }
+};
\ No newline at end of file

From 7acffb04d4aa692561d75e132038fa68982c4eaa Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 20:48:59 +0200
Subject: [PATCH 23/26] feat: Save and load pages show existing loops

---
 firmware/src/AudioSaveAndRecall.h           |  6 +++++
 firmware/src/hardware/FatFsFileIo.h         | 14 ++++++++++
 firmware/src/ui/UiLoadOrSavePage.h          | 29 ++++++++++++++-------
 firmware/tests/AudioSaveAndRecall_gtest.cpp |  2 ++
 4 files changed, 41 insertions(+), 10 deletions(-)

diff --git a/firmware/src/AudioSaveAndRecall.h b/firmware/src/AudioSaveAndRecall.h
index b28e4c4..0962c3d 100644
--- a/firmware/src/AudioSaveAndRecall.h
+++ b/firmware/src/AudioSaveAndRecall.h
@@ -69,6 +69,8 @@ namespace loop_library
 
         void scanOrInitLibrary()
         {
+            fileIo_.ensureVolumeMounted();
+
             fileIo_.makeFolderIfNotExistent(loop_library::kLibraryBaseFolder);
 
             for (size_t bank = 0; bank < kNumBanks; bank++)
@@ -132,6 +134,8 @@ class AudioSaveAndRecall
     {
         static_assert(LooperType::getNumChannels() <= kMaxNumChannels_);
 
+        fileIo_.ensureVolumeMounted();
+
         looperPtr_ = &looper;
         doneCallback_ = doneCallback;
         doneCallbackContext_ = doneCallbackContext;
@@ -244,6 +248,8 @@ class AudioSaveAndRecall
     {
         static_assert(LooperType::getNumChannels() <= kMaxNumChannels_);
 
+        fileIo_.ensureVolumeMounted();
+
         looperPtr_ = &looper;
         doneCallback_ = doneCallback;
         doneCallbackContext_ = doneCallbackContext;
diff --git a/firmware/src/hardware/FatFsFileIo.h b/firmware/src/hardware/FatFsFileIo.h
index 4d37701..e735782 100644
--- a/firmware/src/hardware/FatFsFileIo.h
+++ b/firmware/src/hardware/FatFsFileIo.h
@@ -20,6 +20,20 @@
 class FatFsFileIo
 {
 public:
+    void ensureVolumeMounted() {}
+
+    bool makeFolderIfNotExistent(const char* folderName)
+    {
+        (void) (folderName);
+        return false;
+    }
+
+    bool hasFile(const char* fileName)
+    {
+        (void) (fileName);
+        return false;
+    }
+
     bool openForReading(const char* fileName)
     {
         (void) (fileName);
diff --git a/firmware/src/ui/UiLoadOrSavePage.h b/firmware/src/ui/UiLoadOrSavePage.h
index c5a08e3..d66003e 100644
--- a/firmware/src/ui/UiLoadOrSavePage.h
+++ b/firmware/src/ui/UiLoadOrSavePage.h
@@ -90,12 +90,6 @@ class UiLoadOrSavePage : public daisy::UiPage
         const Button button = Button(buttonID);
         switch (button)
         {
-            case Button::record:
-                [[fallthrough]];
-            case Button::settings:
-                looperController_.abortLoadOrSaveOperation();
-                Close(); // close this page
-                return false; // pass event to the page below to open the respective page
             case Button::save:
                 return handleSaveButton();
             case Button::load:
@@ -111,7 +105,7 @@ class UiLoadOrSavePage : public daisy::UiPage
             case Stage::selectBankAndSlot:
                 return onButtonInBankAndSlotSelection(button);
             default:
-                // any button press while showing
+                // any button press while showing success or error closes the page
                 if (stage_ == Stage::displaySuccess || stage_ == Stage::displayError)
                 {
                     Close();
@@ -127,6 +121,11 @@ class UiLoadOrSavePage : public daisy::UiPage
         return false; // passthrough pot events to the base page
     }
 
+    void OnFocusGained() override
+    {
+        loopLibrary_.scanOrInitLibrary();
+    }
+
 protected:
     UiLoadOrSavePage(const UiLoadOrSavePage&) = delete;
     UiLoadOrSavePage& operator=(const UiLoadOrSavePage&) = delete;
@@ -188,7 +187,17 @@ class UiLoadOrSavePage : public daisy::UiPage
         const auto allLeds = UiHardwareType::allChannelLeds();
         for (size_t i = 0; i < allLeds.size(); i++)
         {
-            hardware.setLed(allLeds[i], this->selectedSlot_ == int(i) ? bankColorPulsing : LedColour::off);
+            if (this->selectedSlot_ == int(i))
+            {
+                hardware.setLed(allLeds[i], bankColourPulsing);
+            }
+            else
+            {
+                hardware.setLed(allLeds[i],
+                                loopLibrary_.hasLoop(selectedBank_, i)
+                                    ? bankColour
+                                    : LedColour::off);
+            }
         }
     }
 
@@ -359,7 +368,7 @@ class UiSavePage : public UiLoadOrSavePage<LooperControllerType, UiHardwareType,
                  || this->stage_ == ParentType::Stage::displaySuccess
                  || this->stage_ == ParentType::Stage::displayError)
         {
-            Close();
+            this->Close();
         }
         return true;
     }
@@ -409,7 +418,7 @@ class UiLoadPage : public UiLoadOrSavePage<LooperControllerType, UiHardwareType,
                  || this->stage_ == ParentType::Stage::displaySuccess
                  || this->stage_ == ParentType::Stage::displayError)
         {
-            Close();
+            this->Close();
         }
         return true;
     }
diff --git a/firmware/tests/AudioSaveAndRecall_gtest.cpp b/firmware/tests/AudioSaveAndRecall_gtest.cpp
index a2956c5..022d46e 100644
--- a/firmware/tests/AudioSaveAndRecall_gtest.cpp
+++ b/firmware/tests/AudioSaveAndRecall_gtest.cpp
@@ -86,6 +86,8 @@ namespace
 class TestFileIo
 {
 public:
+    void ensureVolumeMounted() {}
+
     bool openForReading(const AudioFileName& fileName)
     {
         lastFileName_ = fileName;

From f780e022d3c386f16e8ddc2df3e105d585744295 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Wed, 8 Oct 2025 21:25:21 +0200
Subject: [PATCH 24/26] feat: implement fatfs based file IO

---
 firmware/src/AudioSaveAndRecall.h           |  4 +-
 firmware/src/hardware/FatFsFileIo.h         | 82 +++++++++++++++++----
 firmware/tests/AudioSaveAndRecall_gtest.cpp |  7 +-
 3 files changed, 75 insertions(+), 18 deletions(-)

diff --git a/firmware/src/AudioSaveAndRecall.h b/firmware/src/AudioSaveAndRecall.h
index 0962c3d..0514534 100644
--- a/firmware/src/AudioSaveAndRecall.h
+++ b/firmware/src/AudioSaveAndRecall.h
@@ -383,7 +383,7 @@ class AudioSaveAndRecall
     {
         wavHeader_ = makeWavFileHeader32bitInt(sampleRate, numChannelsPerFrame, totalNumFrames);
 
-        return fileIo_.write(&wavHeader_, sizeof(wavHeader_));
+        return fileIo_.write(&wavHeader_, sizeof(wavHeader_)) == int32_t(sizeof(wavHeader_));
     }
 
     bool readWavHeader()
@@ -500,7 +500,7 @@ class AudioSaveAndRecall
         }
 
         const auto numBytes = std::distance(&writeBuffer_[0], outPtr) * sizeof(int32_t);
-        return fileIo_.write(writeBuffer_, numBytes);
+        return fileIo_.write(writeBuffer_, numBytes) == int32_t(numBytes);
     }
 
     template <size_t numChannels>
diff --git a/firmware/src/hardware/FatFsFileIo.h b/firmware/src/hardware/FatFsFileIo.h
index e735782..717fe93 100644
--- a/firmware/src/hardware/FatFsFileIo.h
+++ b/firmware/src/hardware/FatFsFileIo.h
@@ -17,46 +17,102 @@
 
 #pragma once
 
+#include <per/sdmmc.h>
+#include <fatfs.h>
+#include <util/hal_map.h>
+
+extern SD_HandleTypeDef hsd1;
+
 class FatFsFileIo
 {
 public:
-    void ensureVolumeMounted() {}
+    FatFsFileIo()
+    {
+        Init();
+    }
+
+    void ensureVolumeMounted()
+    {
+        isMounted_ = f_mount(&fileSystem_.GetSDFileSystem(), fileSystem_.GetSDPath(), 1) == FR_OK;
+
+        // In case of an error, reinitialize the peripheral and try again.
+        // Someone could have removed the SD and plugged it back in
+        if (!isMounted_)
+        {
+            // unmount
+            f_mount(nullptr, fileSystem_.GetSDPath(), 0);
+            fileSystem_.DeInit();
+
+            HAL_SD_DeInit(&hsd1);
+            memset(&hsd1, 0, sizeof(hsd1));
+
+            daisy::System::DelayUs(10000);
+
+            Init();
+
+            isMounted_ = f_mount(&fileSystem_.GetSDFileSystem(), fileSystem_.GetSDPath(), 1) == FR_OK;
+        }
+    }
 
     bool makeFolderIfNotExistent(const char* folderName)
     {
-        (void) (folderName);
-        return false;
+        return f_mkdir(folderName) == FR_OK;
     }
 
     bool hasFile(const char* fileName)
     {
-        (void) (fileName);
-        return false;
+        const auto canOpenForReading = openForReading(fileName);
+        if (canOpenForReading)
+        {
+            closeFile();
+        }
+        return canOpenForReading;
     }
 
     bool openForReading(const char* fileName)
     {
-        (void) (fileName);
-        return false;
+        const auto result = f_open(&file_, fileName, FA_OPEN_EXISTING | FA_READ);
+        return result == FR_OK;
     }
 
     bool openForWriting(const char* fileName)
     {
-        (void) (fileName);
-        return false;
+        const auto result = f_open(&file_, fileName, FA_CREATE_ALWAYS | FA_WRITE);
+        return result == FR_OK;
     }
 
-    bool write(void* data, size_t size)
+    int32_t write(const void* data, size_t size)
     {
-        return false;
+        UINT bytesWritten = 0;
+        const auto result = f_write(&file_, data, UINT(size), &bytesWritten);
+        return result == FR_OK ? int32_t(bytesWritten) : -1;
     }
 
     int32_t read(void* data, size_t maxSize)
     {
-        return -1;
+        UINT bytesRead = 0;
+        const auto result = f_read(&file_, data, UINT(maxSize), &bytesRead);
+        return result == FR_OK ? int32_t(bytesRead) : -1;
     }
 
-    void closeFile()
+    bool closeFile()
     {
+        const auto result = f_close(&file_);
+        return result == FR_OK;
     }
+
+private:
+    void Init()
+    {
+        daisy::SdmmcHandler::Config sdCfg;
+        sdCfg.Defaults();
+        sdCfg.speed = daisy::SdmmcHandler::Speed::STANDARD;
+        sd_.Init(sdCfg);
+        fileSystem_.Init(daisy::FatFSInterface::Config::MEDIA_SD);
+    }
+
+    bool isMounted_ = false;
+    daisy::SdmmcHandler sd_;
+    daisy::FatFSInterface fileSystem_;
+    FIL file_;
 };
\ No newline at end of file
diff --git a/firmware/tests/AudioSaveAndRecall_gtest.cpp b/firmware/tests/AudioSaveAndRecall_gtest.cpp
index 022d46e..13bedd2 100644
--- a/firmware/tests/AudioSaveAndRecall_gtest.cpp
+++ b/firmware/tests/AudioSaveAndRecall_gtest.cpp
@@ -110,15 +110,16 @@ class TestFileIo
         return true;
     }
 
-    bool write(void* data, size_t size)
+    int32_t write(void* data, size_t size)
     {
         if (simulateFileWriteError_)
-            return false;
+            return -1;
 
         dataWritten_.insert(dataWritten_.end(),
                             static_cast<std::byte*>(data),
                             static_cast<std::byte*>(data) + size);
-        return true;
+
+        return int32_t(size);
     }
 
     int32_t read(void* data, size_t maxSize)

From aa1e765be239d6692eb2211d6de614a52bd631cf Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Thu, 9 Oct 2025 23:35:51 +0200
Subject: [PATCH 25/26] chore: use a more up to date setup step in firmware CI
 build

---
 .github/workflows/firmware.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/firmware.yaml b/.github/workflows/firmware.yaml
index c2e9a24..2d3a661 100644
--- a/.github/workflows/firmware.yaml
+++ b/.github/workflows/firmware.yaml
@@ -22,9 +22,9 @@ jobs:
 
     steps:
     - name: Install arm-none-eabi-gcc
-      uses: fiam/arm-none-eabi-gcc@v1
+      uses: carlosperate/arm-none-eabi-gcc-action@v1
       with:
-        release: '10-2020-q4' # The arm-none-eabi-gcc release to use.
+        release: '10-2020-q4'
 
     - name: Setup cmake
       uses: jwlawson/actions-setup-cmake@v1.9

From f2721066fd826af648da34b68142fd8a1ce610c5 Mon Sep 17 00:00:00 2001
From: TheSlowGrowth <9356320+TheSlowGrowth@users.noreply.github.com>
Date: Mon, 13 Apr 2026 22:16:43 +0200
Subject: [PATCH 26/26] chore: add .cache to .gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index dd4a973..1713b4b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -47,3 +47,4 @@ plugin/build
 
 # macOS crap
 .DS_Store
+firmware/.cache