Make the Sampler's waveform markers draggable

- The start, the end and the loop point each have a handle now, and
  neither trim can be dragged past the other

- Turning looping on drops the loop point in the middle of the range,
  where it can be seen and taken hold of

- The offsets moved to the amp envelope column, a row each

- The picture was read from the file again for every pad setting, and
  some whole-second offsets read back a second short

Author: juzzlin

CHANGELOG

@@ -21,10 +21,14 @@ New features:
 
 * Add a loop point to the Sampler's pads
   - The pad plays its range once and then repeats only what follows the point
+  - Turning looping on drops the point in the middle of the range
 
 * Draw the pad's amp envelope over the Sampler's waveform
   - White lines over the range, the release included
 
+* Drag the Sampler's start, end and loop markers on the waveform
+  - Each has a handle, and neither trim can be dragged past the other
+
 * Add choke groups to the Sampler's pads
   - Triggering a pad silences the other pads sharing its group
   - Eight groups, the way a closed hi-hat cuts off an open one
@@ -35,6 +39,12 @@ Bug fixes:
   - A malformed size reported "stoi" instead of saying what was wrong
   - A zero or negative size was accepted and saved over the stored one
 
+* Stop rebuilding the Sampler's waveform for every pad setting
+  - The sample file was read again on every knob move
+
+* Fix the Sampler's offsets at whole seconds
+  - Some read back a second short, with a thousand milliseconds beside them
+
 Other:
 
 7.3.0

src/CMakeLists.txt

@@ -61,6 +61,7 @@ set(QML_SOURCE_FILES
     ${QML_BASE_DIR}/Components/ShortcutHintAction.qml
     ${QML_BASE_DIR}/Components/SyncSlider.qml
     ${QML_BASE_DIR}/Components/VirtualKeyboard.qml
+    ${QML_BASE_DIR}/Components/WaveformMarker.qml
     ${QML_BASE_DIR}/Components/WaveformView.qml
     ${QML_BASE_DIR}/Constants.qml
     ${QML_BASE_DIR}/Dialogs/AboutDialog.qml

src/unit_tests/sampler_controller_test/sampler_controller_test.cpp

@@ -155,6 +155,58 @@ void SamplerControllerTest::test_selectedPadLoopStart_secondsAndMilliseconds_sho
     QVERIFY(std::abs(sampler->sampleLoopStart(SamplerDevice::padStartNote) - 2.25) < 0.001);
 }
 
+void SamplerControllerTest::test_selectedPadStartOffset_wholeSecond_shouldReadBackWhole()
+{
+    // An offset is stored as a fraction of a minute in a float, which lands a hair either side of the
+    // second it was set to. Seventeen lands under, and split by flooring it read as sixteen seconds
+    // and a thousand milliseconds.
+    auto reader = std::make_unique<MockAudioFileReader>();
+    reader->setFrames(static_cast<int64_t>(Constants::defaultSampleRate()) * 20);
+    const auto sampler = std::make_shared<SamplerDevice>("Test Sampler", std::move(reader));
+    SamplerController controller { sampler };
+    controller.setSelectedPad(0);
+    controller.loadSample(0, "test.wav");
+
+    controller.setSelectedPadStartOffsetSeconds(17);
+
+    QCOMPARE(controller.selectedPadStartOffsetSeconds(), 17);
+    QCOMPARE(controller.selectedPadStartOffsetMilliseconds(), 0);
+}
+
+void SamplerControllerTest::test_selectedPadLoop_enabled_shouldDropTheLoopPointInTheMiddleOfTheRange()
+{
+    // Four seconds trimmed by a second at each end leaves a two second range, so the point lands one
+    // second in from where the range begins.
+    auto reader = std::make_unique<MockAudioFileReader>();
+    reader->setFrames(static_cast<int64_t>(Constants::defaultSampleRate()) * 4);
+    const auto sampler = std::make_shared<SamplerDevice>("Test Sampler", std::move(reader));
+    SamplerController controller { sampler };
+    controller.setSelectedPad(0);
+    controller.loadSample(0, "test.wav");
+    controller.setSelectedPadStartOffsetSeconds(1);
+    controller.setSelectedPadEndOffsetSeconds(1);
+
+    controller.setSelectedPadLoop(true);
+
+    QCOMPARE(controller.selectedPadLoopStartSeconds(), 1);
+    QCOMPARE(controller.selectedPadLoopStartMilliseconds(), 0);
+}
+
+void SamplerControllerTest::test_selectedPadLoop_enabled_shouldKeepALoopPointThePadAlreadyHas()
+{
+    auto reader = std::make_unique<MockAudioFileReader>();
+    reader->setFrames(static_cast<int64_t>(Constants::defaultSampleRate()) * 4);
+    const auto sampler = std::make_shared<SamplerDevice>("Test Sampler", std::move(reader));
+    SamplerController controller { sampler };
+    controller.setSelectedPad(0);
+    controller.loadSample(0, "test.wav");
+    controller.setSelectedPadLoopStartSeconds(3);
+
+    controller.setSelectedPadLoop(true);
+
+    QCOMPARE(controller.selectedPadLoopStartSeconds(), 3);
+}
+
 void SamplerControllerTest::test_reset_shouldRestoreDefaultValues()
 {
     const auto sampler = std::make_shared<SamplerDevice>("Test Sampler");

src/unit_tests/sampler_controller_test/sampler_controller_test.hpp

@@ -16,6 +16,9 @@ private slots:
     void test_sampleRateChange_shouldUpdateHzValues();
     void test_properties_shouldUpdateDeviceAndEmitSignals();
     void test_selectedPadLoopStart_secondsAndMilliseconds_shouldCombineIntoOneOffset();
+    void test_selectedPadStartOffset_wholeSecond_shouldReadBackWhole();
+    void test_selectedPadLoop_enabled_shouldDropTheLoopPointInTheMiddleOfTheRange();
+    void test_selectedPadLoop_enabled_shouldKeepALoopPointThePadAlreadyHas();
     void test_reset_shouldRestoreDefaultValues();
     void test_setSampler_shouldRefreshGlobalSwitchesToReflectNewInstance();
     void test_loadedPads_shouldListOnlyLoadedPads();

src/view/controllers/sampler_controller.cpp

@@ -179,38 +179,40 @@ void SamplerController::setSelectedPadHpfCutoff(double cutoff)
     }
 }
 
+SamplerController::OffsetParts SamplerController::splitSeconds(double seconds)
+{
+    // Rounded to whole milliseconds before it is split, not floored: an offset is stored as a
+    // fraction of a minute in a float, which does not land exactly on the second it was set to, and
+    // flooring a value a hair short of one reads it as no seconds and a thousand milliseconds.
+    const auto milliseconds = std::llround(std::max(0.0, seconds) * 1000.0);
+    return { static_cast<int>(milliseconds / 1000), static_cast<int>(milliseconds % 1000) };
+}
+
 int SamplerController::selectedPadStartOffsetSeconds() const
 {
-    if (!m_sampler || m_selectedPad < 0) {
-        return 0;
-    }
-    return static_cast<int>(m_sampler->sampleStartOffset(static_cast<uint8_t>(noteForPad(m_selectedPad))));
+    const auto note = selectedNote();
+    return note ? splitSeconds(m_sampler->sampleStartOffset(*note)).seconds : 0;
 }
 
 void SamplerController::setSelectedPadStartOffsetSeconds(int seconds)
 {
-    if (m_sampler && m_selectedPad >= 0) {
-        const double currentOffset = m_sampler->sampleStartOffset(static_cast<uint8_t>(noteForPad(m_selectedPad)));
-        const double milliseconds = (currentOffset - std::floor(currentOffset)) * 1000.0;
-        m_sampler->setSampleStartOffset(static_cast<uint8_t>(noteForPad(m_selectedPad)), static_cast<double>(seconds) + milliseconds / 1000.0);
+    if (const auto note = selectedNote(); note) {
+        const auto current = splitSeconds(m_sampler->sampleStartOffset(*note));
+        m_sampler->setSampleStartOffset(*note, seconds + current.milliseconds / 1000.0);
     }
 }
 
 int SamplerController::selectedPadStartOffsetMilliseconds() const
 {
-    if (!m_sampler || m_selectedPad < 0) {
-        return 0;
-    }
-    const double offset = m_sampler->sampleStartOffset(static_cast<uint8_t>(noteForPad(m_selectedPad)));
-    return static_cast<int>(std::round((offset - std::floor(offset)) * 1000.0));
+    const auto note = selectedNote();
+    return note ? splitSeconds(m_sampler->sampleStartOffset(*note)).milliseconds : 0;
 }
 
 void SamplerController::setSelectedPadStartOffsetMilliseconds(int milliseconds)
 {
-    if (m_sampler && m_selectedPad >= 0) {
-        const double currentOffset = m_sampler->sampleStartOffset(static_cast<uint8_t>(noteForPad(m_selectedPad)));
-        const double seconds = std::floor(currentOffset);
-        m_sampler->setSampleStartOffset(static_cast<uint8_t>(noteForPad(m_selectedPad)), seconds + static_cast<double>(milliseconds) / 1000.0);
+    if (const auto note = selectedNote(); note) {
+        const auto current = splitSeconds(m_sampler->sampleStartOffset(*note));
+        m_sampler->setSampleStartOffset(*note, current.seconds + milliseconds / 1000.0);
     }
 }
 
@@ -225,83 +227,61 @@ std::optional<uint8_t> SamplerController::selectedNote() const
 int SamplerController::selectedPadEndOffsetSeconds() const
 {
     const auto note = selectedNote();
-    if (!note) {
-        return 0;
-    }
-    return static_cast<int>(std::floor(m_sampler->sampleEndOffset(*note)));
+    return note ? splitSeconds(m_sampler->sampleEndOffset(*note)).seconds : 0;
 }
 
 void SamplerController::setSelectedPadEndOffsetSeconds(int seconds)
 {
-    const auto note = selectedNote();
-    if (!note) {
-        return;
+    if (const auto note = selectedNote(); note) {
+        const auto current = splitSeconds(m_sampler->sampleEndOffset(*note));
+        m_sampler->setSampleEndOffset(*note, seconds + current.milliseconds / 1000.0);
+        emit selectedPadEndOffsetChanged();
     }
-    const double current = m_sampler->sampleEndOffset(*note);
-    m_sampler->setSampleEndOffset(*note, static_cast<double>(seconds) + (current - std::floor(current)));
-    emit selectedPadEndOffsetChanged();
 }
 
 int SamplerController::selectedPadEndOffsetMilliseconds() const
 {
     const auto note = selectedNote();
-    if (!note) {
-        return 0;
-    }
-    const double offset = m_sampler->sampleEndOffset(*note);
-    return static_cast<int>(std::round((offset - std::floor(offset)) * 1000.0));
+    return note ? splitSeconds(m_sampler->sampleEndOffset(*note)).milliseconds : 0;
 }
 
 void SamplerController::setSelectedPadEndOffsetMilliseconds(int milliseconds)
 {
-    const auto note = selectedNote();
-    if (!note) {
-        return;
+    if (const auto note = selectedNote(); note) {
+        const auto current = splitSeconds(m_sampler->sampleEndOffset(*note));
+        m_sampler->setSampleEndOffset(*note, current.seconds + milliseconds / 1000.0);
+        emit selectedPadEndOffsetChanged();
     }
-    const double current = m_sampler->sampleEndOffset(*note);
-    m_sampler->setSampleEndOffset(*note, std::floor(current) + static_cast<double>(milliseconds) / 1000.0);
-    emit selectedPadEndOffsetChanged();
 }
 
 int SamplerController::selectedPadLoopStartSeconds() const
 {
     const auto note = selectedNote();
-    if (!note) {
-        return 0;
-    }
-    return static_cast<int>(std::floor(m_sampler->sampleLoopStart(*note)));
+    return note ? splitSeconds(m_sampler->sampleLoopStart(*note)).seconds : 0;
 }
 
 void SamplerController::setSelectedPadLoopStartSeconds(int seconds)
 {
-    const auto note = selectedNote();
-    if (!note) {
-        return;
+    if (const auto note = selectedNote(); note) {
+        const auto current = splitSeconds(m_sampler->sampleLoopStart(*note));
+        m_sampler->setSampleLoopStart(*note, seconds + current.milliseconds / 1000.0);
+        emit selectedPadLoopStartChanged();
     }
-    const double current = m_sampler->sampleLoopStart(*note);
-    m_sampler->setSampleLoopStart(*note, static_cast<double>(seconds) + (current - std::floor(current)));
-    emit selectedPadLoopStartChanged();
 }
 
 int SamplerController::selectedPadLoopStartMilliseconds() const
 {
     const auto note = selectedNote();
-    if (!note) {
-        return 0;
-    }
-    const double offset = m_sampler->sampleLoopStart(*note);
-    return static_cast<int>(std::round((offset - std::floor(offset)) * 1000.0));
+    return note ? splitSeconds(m_sampler->sampleLoopStart(*note)).milliseconds : 0;
 }
 
 void SamplerController::setSelectedPadLoopStartMilliseconds(int milliseconds)
 {
-    const auto note = selectedNote();
-    if (!note) {
-        return;
+    if (const auto note = selectedNote(); note) {
+        const auto current = splitSeconds(m_sampler->sampleLoopStart(*note));
+        m_sampler->setSampleLoopStart(*note, current.seconds + milliseconds / 1000.0);
+        emit selectedPadLoopStartChanged();
     }
-    const double current = m_sampler->sampleLoopStart(*note);
-    m_sampler->setSampleLoopStart(*note, std::floor(current) + static_cast<double>(milliseconds) / 1000.0);
-    emit selectedPadLoopStartChanged();
 }
 
 double SamplerController::selectedPadTune() const
@@ -432,6 +412,16 @@ void SamplerController::setSelectedPadLoop(bool loop)
     const auto note = selectedNote();
     if (note && m_sampler->sampleLoop(*note) != loop) {
         m_sampler->setSampleLoop(*note, loop);
+        // A loop point at the beginning of the range sits underneath the start marker, where it can
+        // be neither seen nor taken hold of. Turning looping on drops it in the middle of the range
+        // instead, which is somewhere to drag it from. A point the pad already carries is its own.
+        if (loop && m_sampler->sampleLoopStart(*note) <= 0.0) {
+            const auto range = m_sampler->sampleDuration(*note) - m_sampler->sampleStartOffset(*note) - m_sampler->sampleEndOffset(*note);
+            if (range > 0.0) {
+                m_sampler->setSampleLoopStart(*note, range / 2.0);
+                emit selectedPadLoopStartChanged();
+            }
+        }
         emit selectedPadLoopChanged();
     }
 }

src/view/controllers/sampler_controller.hpp

@@ -194,6 +194,15 @@ class SamplerController : public DeviceController
     void samplerChanged();
 
 private:
+    //! One offset as the whole-second and millisecond halves the dialog's two spin boxes edit.
+    struct OffsetParts
+    {
+        int seconds = 0;
+        int milliseconds = 0;
+    };
+
+    static OffsetParts splitSeconds(double seconds);
+
     int noteForPad(int padIndex) const;
 
     //! The note of the selected pad, or nothing when no pad is selected.