Add FramePos type and use it for beatgrid creation

CMakeLists.txt

@@ -1508,6 +1508,7 @@ add_executable(mixxx-test
   src/test/enginemicrophonetest.cpp
   src/test/enginesynctest.cpp
   src/test/fileinfo_test.cpp
+  src/test/frametest.cpp
   src/test/globaltrackcache_test.cpp
   src/test/hotcuecontrol_test.cpp
   src/test/imageutils_test.cpp

src/analyzer/analyzerbeats.cpp

@@ -219,7 +219,7 @@ void AnalyzerBeats::storeResults(TrackPointer pTrack) {
 
     mixxx::BeatsPointer pBeats;
     if (m_pPlugin->supportsBeatTracking()) {
-        QVector<double> beats = m_pPlugin->getBeats();
+        QVector<mixxx::audio::FramePos> beats = m_pPlugin->getBeats();
         QHash<QString, QString> extraVersionInfo = getExtraVersionInfo(
                 m_pluginId, m_bPreferencesFastAnalysis);
         pBeats = BeatFactory::makePreferredBeats(
@@ -232,7 +232,7 @@ void AnalyzerBeats::storeResults(TrackPointer pTrack) {
     } else {
         float bpm = m_pPlugin->getBpm();
         qDebug() << "AnalyzerBeats plugin detected constant BPM: " << bpm;
-        pBeats = BeatFactory::makeBeatGrid(m_sampleRate, bpm, 0.0f);
+        pBeats = BeatFactory::makeBeatGrid(m_sampleRate, bpm, mixxx::audio::kStartFramePos);
     }
 
     pTrack->trySetBeats(pBeats);

src/analyzer/plugins/analyzerplugin.h

@@ -2,6 +2,7 @@
 
 #include <QString>
 
+#include "audio/frame.h"
 #include "track/beats.h"
 #include "track/keys.h"
 #include "util/types.h"
@@ -71,8 +72,8 @@ class AnalyzerBeatsPlugin : public AnalyzerPlugin {
     virtual float getBpm() const {
         return 0.0f;
     }
-    virtual QVector<double> getBeats() const {
-        return QVector<double>();
+    virtual QVector<mixxx::audio::FramePos> getBeats() const {
+        return {};
     }
 };
 

src/analyzer/plugins/analyzerqueenmarybeats.cpp

@@ -107,7 +107,7 @@ bool AnalyzerQueenMaryBeats::finalize() {
     for (size_t i = 0; i < beats.size(); ++i) {
         // we add the halve m_stepSize here, because the beat
         // is detected between the two samples.
-        double result = (beats.at(i) * m_stepSize) + m_stepSize / 2;
+        const auto result = mixxx::audio::FramePos((beats.at(i) * m_stepSize) + m_stepSize / 2);
         m_resultBeats.push_back(result);
     }
 

src/analyzer/plugins/analyzerqueenmarybeats.h

@@ -40,7 +40,7 @@ class AnalyzerQueenMaryBeats : public AnalyzerBeatsPlugin {
         return true;
     }
 
-    QVector<double> getBeats() const override {
+    QVector<mixxx::audio::FramePos> getBeats() const override {
         return m_resultBeats;
     }
 
@@ -51,7 +51,7 @@ class AnalyzerQueenMaryBeats : public AnalyzerBeatsPlugin {
     int m_windowSize;
     int m_stepSize;
     std::vector<double> m_detectionResults;
-    QVector<double> m_resultBeats;
+    QVector<mixxx::audio::FramePos> m_resultBeats;
 };
 
 } // namespace mixxx

src/audio/frame.h

@@ -0,0 +1,147 @@
+#pragma once
+
+#include <QDebug>
+#include <cmath>
+#include <limits>
+
+#include "engine/engine.h"
+#include "util/fpclassify.h"
+
+namespace mixxx {
+namespace audio {
+/// FrameDiff_t can be used to store the difference in position between
+/// two frames and to store the length of a segment of track in terms of frames.
+typedef double FrameDiff_t;
+
+/// FramePos defines the position of a frame in a track
+/// with respect to a fixed origin, i.e. start of the track.
+class FramePos final {
+  public:
+    typedef double value_t;
+    static constexpr value_t kStartValue = 0;
+    static constexpr value_t kInvalidValue = std::numeric_limits<FramePos::value_t>::quiet_NaN();
+
+    constexpr FramePos()
+            : m_framePosition(kInvalidValue) {
+    }
+
+    constexpr explicit FramePos(value_t framePosition)
+            : m_framePosition(framePosition) {
+    }
+
+    static constexpr FramePos fromEngineSamplePos(double engineSamplePos) {
+        return FramePos(engineSamplePos / mixxx::kEngineChannelCount);
+    }
+
+    constexpr double toEngineSamplePos() const {
+        return value() * mixxx::kEngineChannelCount;
+    }
+
+    bool isValid() const {
+        return !util_isnan(m_framePosition);
+    }
+
+    void setValue(value_t framePosition) {
+        m_framePosition = framePosition;
+    }
+
+    constexpr value_t value() const {
+        return m_framePosition;
+    }
+
+    bool isFractional() const {
+        value_t integerPart;
+        return std::modf(value(), &integerPart) != 0;
+    }
+
+    [[nodiscard]] FramePos toFullFrames() const {
+        return FramePos(std::floor(value()));
+    }
+
+    FramePos& operator+=(FrameDiff_t increment) {
+        m_framePosition += increment;
+        return *this;
+    }
+
+    FramePos& operator-=(FrameDiff_t decrement) {
+        m_framePosition -= decrement;
+        return *this;
+    }
+
+    FramePos& operator*=(double multiple) {
+        m_framePosition *= multiple;
+        return *this;
+    }
+
+    FramePos& operator/=(double divisor) {
+        m_framePosition /= divisor;
+        return *this;
+    }
+
+  private:
+    value_t m_framePosition;
+};
+
+/// FramePos can be added to a FrameDiff_t
+inline FramePos operator+(FramePos framePos, FrameDiff_t frameDiff) {
+    return FramePos(framePos.value() + frameDiff);
+}
+
+/// FramePos can be subtracted from a FrameDiff_t
+inline FramePos operator-(FramePos framePos, FrameDiff_t frameDiff) {
+    return FramePos(framePos.value() - frameDiff);
+}
+
+/// Two FramePos can be subtracted to get a FrameDiff_t
+inline FrameDiff_t operator-(FramePos framePos1, FramePos framePos2) {
+    return framePos1.value() - framePos2.value();
+}
+
+// Adding two FramePos is not allowed since every FramePos shares a common
+// reference or origin i.e. the start of the track.
+
+/// FramePos can be multiplied or divided by a double
+inline FramePos operator*(FramePos framePos, double multiple) {
+    return FramePos(framePos.value() * multiple);
+}
+
+inline FramePos operator/(FramePos framePos, double divisor) {
+    return FramePos(framePos.value() / divisor);
+}
+
+inline bool operator<(FramePos frame1, FramePos frame2) {
+    return frame1.value() < frame2.value();
+}
+
+inline bool operator<=(FramePos frame1, FramePos frame2) {
+    return frame1.value() <= frame2.value();
+}
+
+inline bool operator>(FramePos frame1, FramePos frame2) {
+    return frame1.value() > frame2.value();
+}
+
+inline bool operator>=(FramePos frame1, FramePos frame2) {
+    return frame1.value() >= frame2.value();
+}
+
+inline bool operator==(FramePos frame1, FramePos frame2) {
+    return frame1.value() == frame2.value();
+}
+
+inline bool operator!=(FramePos frame1, FramePos frame2) {
+    return !(frame1.value() == frame2.value());
+}
+
+inline QDebug operator<<(QDebug dbg, FramePos arg) {
+    dbg << arg.value();
+    return dbg;
+}
+
+constexpr FramePos kInvalidFramePos = FramePos(FramePos::kInvalidValue);
+constexpr FramePos kStartFramePos = FramePos(FramePos::kStartValue);
+} // namespace audio
+} // namespace mixxx
+
+Q_DECLARE_TYPEINFO(mixxx::audio::FramePos, Q_MOVABLE_TYPE);
+Q_DECLARE_METATYPE(mixxx::audio::FramePos);

src/library/dao/trackdao.cpp

@@ -1255,7 +1255,8 @@ bool setTrackBeats(const QSqlRecord& record, const int column,
         }
     } else {
         // Load a temorary beat grid without offset that will be replaced by the analyzer.
-        const auto pBeats = BeatFactory::makeBeatGrid(pTrack->getSampleRate(), bpm, 0.0);
+        const auto pBeats = BeatFactory::makeBeatGrid(
+                pTrack->getSampleRate(), bpm, mixxx::audio::kStartFramePos);
         pTrack->trySetBeats(pBeats);
     }
     return false;

src/library/dlgtrackinfo.cpp

@@ -581,8 +581,11 @@ void DlgTrackInfo::slotBpmConstChanged(int state) {
             // The cue point should be set on a beat, so this seems
             // to be a good alternative
             CuePosition cue = m_pLoadedTrack->getCuePoint();
-            m_pBeatsClone = BeatFactory::makeBeatGrid(
-                    m_pLoadedTrack->getSampleRate(), spinBpm->value(), cue.getPosition());
+            m_pBeatsClone =
+                    BeatFactory::makeBeatGrid(m_pLoadedTrack->getSampleRate(),
+                            spinBpm->value(),
+                            mixxx::audio::FramePos::fromEngineSamplePos(
+                                    cue.getPosition()));
         } else {
             m_pBeatsClone.clear();
         }
@@ -618,7 +621,9 @@ void DlgTrackInfo::slotSpinBpmValueChanged(double value) {
     if (!m_pBeatsClone) {
         CuePosition cue = m_pLoadedTrack->getCuePoint();
         m_pBeatsClone = BeatFactory::makeBeatGrid(
-                m_pLoadedTrack->getSampleRate(), value, cue.getPosition());
+                m_pLoadedTrack->getSampleRate(),
+                value,
+                mixxx::audio::FramePos::fromEngineSamplePos(cue.getPosition()));
     }
 
     double oldValue = m_pBeatsClone->getBpm();

src/library/rekordbox/rekordboxfeature.cpp

@@ -925,7 +925,7 @@ void readAnalyze(TrackPointer track,
                     static_cast<rekordbox_anlz_t::beat_grid_tag_t*>(
                             (*section)->body());
 
-            QVector<double> beats;
+            QVector<mixxx::audio::FramePos> beats;
 
             for (std::vector<rekordbox_anlz_t::beat_grid_beat_t*>::iterator
                             beat = beatGridTag->beats()->begin();
@@ -936,7 +936,7 @@ void readAnalyze(TrackPointer track,
                 if (time < 1) {
                     time = 1;
                 }
-                beats << (sampleRateKhz * static_cast<double>(time));
+                beats << mixxx::audio::FramePos(sampleRateKhz * static_cast<double>(time));
             }
 
             const auto pBeats = mixxx::BeatMap::makeBeatMap(

src/mixxxapplication.cpp

@@ -4,6 +4,7 @@
 #include <QTouchEvent>
 #include <QtDebug>
 
+#include "audio/frame.h"
 #include "audio/types.h"
 #include "control/controlproxy.h"
 #include "library/trackset/crate/crateid.h"
@@ -97,6 +98,7 @@ void MixxxApplication::registerMetaTypes() {
     qRegisterMetaType<mixxx::cache_key_t>("mixxx::cache_key_t");
     qRegisterMetaType<mixxx::Bpm>("mixxx::Bpm");
     qRegisterMetaType<mixxx::Duration>("mixxx::Duration");
+    qRegisterMetaType<mixxx::audio::FramePos>("mixxx::audio::FramePos");
     qRegisterMetaType<std::optional<mixxx::RgbColor>>("std::optional<mixxx::RgbColor>");
     qRegisterMetaType<mixxx::FileInfo>("mixxx::FileInfo");
 }

src/test/beatgridtest.cpp

@@ -29,7 +29,10 @@ TEST(BeatGridTest, Scale) {
     double bpm = 60.0;
     pTrack->trySetBpm(bpm);
 
-    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(), QString(), bpm, 0);
+    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(),
+            QString(),
+            bpm,
+            mixxx::audio::kStartFramePos);
 
     EXPECT_DOUBLE_EQ(bpm, pGrid->getBpm());
     pGrid = pGrid->scale(Beats::DOUBLE);
@@ -60,7 +63,10 @@ TEST(BeatGridTest, TestNthBeatWhenOnBeat) {
     pTrack->trySetBpm(bpm);
     double beatLength = (60.0 * sampleRate / bpm) * kFrameSize;
 
-    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(), QString(), bpm, 0);
+    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(),
+            QString(),
+            bpm,
+            mixxx::audio::kStartFramePos);
     // Pretend we're on the 20th beat;
     double position = beatLength * 20;
 
@@ -99,7 +105,10 @@ TEST(BeatGridTest, TestNthBeatWhenOnBeat_BeforeEpsilon) {
     pTrack->trySetBpm(bpm);
     double beatLength = (60.0 * sampleRate / bpm) * kFrameSize;
 
-    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(), QString(), bpm, 0);
+    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(),
+            QString(),
+            bpm,
+            mixxx::audio::kStartFramePos);
 
     // Pretend we're just before the 20th beat.
     const double kClosestBeat = 20 * beatLength;
@@ -140,7 +149,10 @@ TEST(BeatGridTest, TestNthBeatWhenOnBeat_AfterEpsilon) {
     pTrack->trySetBpm(bpm);
     double beatLength = (60.0 * sampleRate / bpm) * kFrameSize;
 
-    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(), QString(), bpm, 0);
+    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(),
+            QString(),
+            bpm,
+            mixxx::audio::kStartFramePos);
 
     // Pretend we're just before the 20th beat.
     const double kClosestBeat = 20 * beatLength;
@@ -181,7 +193,10 @@ TEST(BeatGridTest, TestNthBeatWhenNotOnBeat) {
     pTrack->trySetBpm(bpm);
     double beatLength = (60.0 * sampleRate / bpm) * kFrameSize;
 
-    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(), QString(), bpm, 0);
+    auto pGrid = BeatGrid::makeBeatGrid(pTrack->getSampleRate(),
+            QString(),
+            bpm,
+            mixxx::audio::kStartFramePos);
 
     // Pretend we're half way between the 20th and 21st beat
     double previousBeat = beatLength * 20.0;