Merge branch '2.3' of git@github.com:mixxxdj/mixxx.git into main

# Conflicts:
#	src/library/dao/trackdao.cpp

17 files changed, 149 insertions, 155 deletions

diff --git a/src/analyzer/analyzerbeats.cpp b/src/analyzer/analyzerbeats.cpp
index 2036e041fa..e6f8fbab53 100644
--- a/src/analyzer/analyzerbeats.cpp
+++ b/src/analyzer/analyzerbeats.cpp
@@ -38,8 +38,7 @@ AnalyzerBeats::AnalyzerBeats(UserSettingsPointer pConfig, bool enforceBpmDetecti
           m_bPreferencesFixedTempo(true),
           m_bPreferencesOffsetCorrection(false),
           m_bPreferencesFastAnalysis(false),
-          m_iSampleRate(0),
-          m_iTotalSamples(0),
+          m_totalSamples(0),
           m_iMaxSamplesToProcess(0),
           m_iCurrentSample(0),
           m_iMinBpm(0),
@@ -93,15 +92,15 @@ bool AnalyzerBeats::initialize(TrackPointer pTrack, int sampleRate, int totalSam
              << "\nRe-analyze when settings change:" << m_bPreferencesReanalyzeOldBpm
              << "\nFast analysis:" << m_bPreferencesFastAnalysis;
 
-    m_iSampleRate = sampleRate;
-    m_iTotalSamples = totalSamples;
+    m_sampleRate = sampleRate;
+    m_totalSamples = totalSamples;
     // In fast analysis mode, skip processing after
     // kFastAnalysisSecondsToAnalyze seconds are analyzed.
     if (m_bPreferencesFastAnalysis) {
         m_iMaxSamplesToProcess =
-                mixxx::kFastAnalysisSecondsToAnalyze * m_iSampleRate * mixxx::kAnalysisChannels;
+                mixxx::kFastAnalysisSecondsToAnalyze * m_sampleRate * mixxx::kAnalysisChannels;
     } else {
-        m_iMaxSamplesToProcess = m_iTotalSamples;
+        m_iMaxSamplesToProcess = m_totalSamples;
     }
     m_iCurrentSample = 0;
 
@@ -240,8 +239,8 @@ void AnalyzerBeats::storeResults(TrackPointer pTrack) {
                 extraVersionInfo,
                 m_bPreferencesFixedTempo,
                 m_bPreferencesOffsetCorrection,
-                m_iSampleRate,
-                m_iTotalSamples,
+                m_sampleRate,
+                m_totalSamples,
                 m_iMinBpm,
                 m_iMaxBpm);
         qDebug() << "AnalyzerBeats plugin detected" << beats.size()
@@ -249,7 +248,7 @@ void AnalyzerBeats::storeResults(TrackPointer pTrack) {
     } else {
         float bpm = m_pPlugin->getBpm();
         qDebug() << "AnalyzerBeats plugin detected constant BPM: " << bpm;
-        pBeats = BeatFactory::makeBeatGrid(m_iSampleRate, bpm, 0.0f);
+        pBeats = BeatFactory::makeBeatGrid(m_sampleRate, bpm, 0.0f);
     }
 
     mixxx::BeatsPointer pCurrentBeats = pTrack->getBeats();
diff --git a/src/analyzer/analyzerbeats.h b/src/analyzer/analyzerbeats.h
index 4efb2f3075..af9568477a 100644
--- a/src/analyzer/analyzerbeats.h
+++ b/src/analyzer/analyzerbeats.h
@@ -46,8 +46,8 @@ class AnalyzerBeats : public Analyzer {
     bool m_bPreferencesOffsetCorrection;
     bool m_bPreferencesFastAnalysis;
 
-    int m_iSampleRate;
-    int m_iTotalSamples;
+    mixxx::audio::SampleRate m_sampleRate;
+    SINT m_totalSamples;
     int m_iMaxSamplesToProcess;
     int m_iCurrentSample;
     int m_iMinBpm, m_iMaxBpm;
diff --git a/src/library/dlgtrackinfo.cpp b/src/library/dlgtrackinfo.cpp
index fa12428a51..3ca293f6ee 100644
--- a/src/library/dlgtrackinfo.cpp
+++ b/src/library/dlgtrackinfo.cpp
@@ -268,15 +268,14 @@ void DlgTrackInfo::populateFields(const Track& track) {
 }
 
 void DlgTrackInfo::reloadTrackBeats(const Track& track) {
-    const mixxx::BeatsPointer pBeats = track.getBeats();
-    if (pBeats) {
-        spinBpm->setValue(pBeats->getBpm());
-        m_pBeatsClone = pBeats->clone();
+    m_pBeatsClone = track.getBeats();
+    if (m_pBeatsClone) {
+        spinBpm->setValue(m_pBeatsClone->getBpm());
     } else {
-        m_pBeatsClone.clear();
         spinBpm->setValue(0.0);
     }
-    m_trackHasBeatMap = pBeats && !(pBeats->getCapabilities() & mixxx::Beats::BEATSCAP_SETBPM);
+    m_trackHasBeatMap = m_pBeatsClone &&
+            !(m_pBeatsClone->getCapabilities() & mixxx::Beats::BEATSCAP_SETBPM);
     bpmConst->setChecked(!m_trackHasBeatMap);
     bpmConst->setEnabled(m_trackHasBeatMap); // We cannot make turn a BeatGrid to a BeatMap
     spinBpm->setEnabled(!m_trackHasBeatMap); // We cannot change bpm continuously or tab them
diff --git a/src/library/rekordbox/rekordboxfeature.cpp b/src/library/rekordbox/rekordboxfeature.cpp
index 4f3c0a1677..454b45498d 100644
--- a/src/library/rekordbox/rekordboxfeature.cpp
+++ b/src/library/rekordbox/rekordboxfeature.cpp
@@ -890,7 +890,7 @@ void setHotCue(TrackPointer track,
 }
 
 void readAnalyze(TrackPointer track,
-        double sampleRate,
+        mixxx::audio::SampleRate sampleRate,
         int timingOffset,
         bool ignoreCues,
         const QString& anlzPath) {
@@ -940,7 +940,7 @@ void readAnalyze(TrackPointer track,
             }
 
             const auto pBeats = mixxx::BeatMap::makeBeatMap(
-                    static_cast<SINT>(sampleRate),
+                    sampleRate,
                     mixxx::rekordboxconstants::beatsSubversion,
                     beats);
             track->setBeats(pBeats);
@@ -1285,7 +1285,7 @@ TrackPointer RekordboxPlaylistModel::getTrack(const QModelIndex& index) const {
     }
 #endif
 
-    double sampleRate = static_cast<double>(track->getSampleRate());
+    mixxx::audio::SampleRate sampleRate = track->getSampleRate();
 
     QString anlzPath = index.sibling(index.row(), fieldIndex("analyze_path")).data().toString();
     QString anlzPathExt = anlzPath.left(anlzPath.length() - 3) + "EXT";
diff --git a/src/test/beatmaptest.cpp b/src/test/beatmaptest.cpp
index 66abad5ae4..75ac937f0f 100644
--- a/src/test/beatmaptest.cpp
+++ b/src/test/beatmaptest.cpp
@@ -12,10 +12,9 @@ namespace {
 
 class BeatMapTest : public testing::Test {
   protected:
-
     BeatMapTest()
             : m_pTrack(Track::newTemporary()),
-              m_iSampleRate(100),
+              m_iSampleRate(10000),
               m_iFrameSize(2) {
         m_pTrack->setAudioProperties(
                 mixxx::audio::ChannelCount(2),
@@ -279,15 +278,15 @@ TEST_F(BeatMapTest, TestBpmAround) {
 
     // The average of the first 8 beats should be different than the average
     // of the last 8 beats.
-    EXPECT_DOUBLE_EQ(64.024390243902445,
-                     pMap->getBpmAroundPosition(4 * approx_beat_length, 4));
-    EXPECT_DOUBLE_EQ(118.98016997167139,
-                     pMap->getBpmAroundPosition(60 * approx_beat_length, 4));
+    EXPECT_DOUBLE_EQ(63.937645572318047,
+            pMap->getBpmAroundPosition(4 * approx_beat_length, 4));
+    EXPECT_DOUBLE_EQ(118.96668932698844,
+            pMap->getBpmAroundPosition(60 * approx_beat_length, 4));
     // Also test at the beginning and end of the track
-    EXPECT_DOUBLE_EQ(62.968515742128936,
-                     pMap->getBpmAroundPosition(0, 4));
-    EXPECT_DOUBLE_EQ(118.98016997167139,
-                     pMap->getBpmAroundPosition(65 * approx_beat_length, 4));
+    EXPECT_DOUBLE_EQ(62.937377309576974,
+            pMap->getBpmAroundPosition(0, 4));
+    EXPECT_DOUBLE_EQ(118.96668932698844,
+            pMap->getBpmAroundPosition(65 * approx_beat_length, 4));
 
     // Try a really, really short track
     beats = createBeatVector(10, 3, getBeatLengthFrames(filebpm));
diff --git a/src/test/enginesynctest.cpp b/src/test/enginesynctest.cpp
index f7ee2fd45b..6d1a57954e 100644
--- a/src/test/enginesynctest.cpp
+++ b/src/test/enginesynctest.cpp
@@ -2403,13 +2403,13 @@ TEST_F(EngineSyncTest, BeatMapQantizePlay) {
     mixxx::BeatsPointer pBeats1 = BeatFactory::makeBeatGrid(m_pTrack1->getSampleRate(), 120, 0.0);
     m_pTrack1->setBeats(pBeats1);
 
-    constexpr int kSampleRate = 44100;
+    constexpr auto kSampleRate = mixxx::audio::SampleRate(44100);
 
-    auto pBeats2 = mixxx::BeatMap::makeBeatMap(
-            kSampleRate,
+    auto pBeats2 = mixxx::BeatMap::makeBeatMap(kSampleRate,
             QString(),
             // Add two beats at 120 Bpm
-            QVector<double>({kSampleRate / 2, kSampleRate}));
+            QVector<double>({static_cast<double>(kSampleRate) / 2,
+                    static_cast<double>(kSampleRate)}));
     m_pTrack2->setBeats(pBeats2);
 
     ControlObject::set(ConfigKey(m_sGroup1, "quantize"), 1.0);
diff --git a/src/track/beatfactory.cpp b/src/track/beatfactory.cpp
index 2bf9c1e416..9929ff18fe 100644
--- a/src/track/beatfactory.cpp
+++ b/src/track/beatfactory.cpp
@@ -7,7 +7,7 @@
 #include "track/beatutils.h"
 
 mixxx::BeatsPointer BeatFactory::loadBeatsFromByteArray(
-        SINT sampleRate,
+        mixxx::audio::SampleRate sampleRate,
         const QString& beatsVersion,
         const QString& beatsSubVersion,
         const QByteArray& beatsSerialized) {
@@ -26,13 +26,15 @@ mixxx::BeatsPointer BeatFactory::loadBeatsFromByteArray(
 }
 
 mixxx::BeatsPointer BeatFactory::makeBeatGrid(
-        SINT sampleRate, double dBpm, double dFirstBeatSample) {
+        mixxx::audio::SampleRate sampleRate,
+        double dBpm,
+        double dFirstBeatSample) {
     return mixxx::BeatGrid::makeBeatGrid(sampleRate, QString(), dBpm, dFirstBeatSample);
 }
 
 // static
 QString BeatFactory::getPreferredVersion(
-        const bool bEnableFixedTempoCorrection) {
+        bool bEnableFixedTempoCorrection) {
     if (bEnableFixedTempoCorrection) {
         return BEAT_GRID_2_VERSION;
     }
@@ -40,10 +42,10 @@ QString BeatFactory::getPreferredVersion(
 }
 
 QString BeatFactory::getPreferredSubVersion(
-        const bool bEnableFixedTempoCorrection,
-        const bool bEnableOffsetCorrection,
-        const int iMinBpm,
-        const int iMaxBpm,
+        bool bEnableFixedTempoCorrection,
+        bool bEnableOffsetCorrection,
+        int iMinBpm,
+        int iMaxBpm,
         const QHash<QString, QString>& extraVersionInfo) {
     const char* kSubVersionKeyValueSeparator = "=";
     const char* kSubVersionFragmentSeparator = "|";
@@ -92,29 +94,32 @@ QString BeatFactory::getPreferredSubVersion(
 mixxx::BeatsPointer BeatFactory::makePreferredBeats(
         const QVector<double>& beats,
         const QHash<QString, QString>& extraVersionInfo,
-        const bool bEnableFixedTempoCorrection,
-        const bool bEnableOffsetCorrection,
-        const int iSampleRate,
-        const int iTotalSamples,
-        const int iMinBpm,
-        const int iMaxBpm) {
+        bool bEnableFixedTempoCorrection,
+        bool bEnableOffsetCorrection,
+        mixxx::audio::SampleRate sampleRate,
+        SINT totalSamples,
+        int iMinBpm,
+        int iMaxBpm) {
     const QString version = getPreferredVersion(bEnableFixedTempoCorrection);
     const QString subVersion = getPreferredSubVersion(bEnableFixedTempoCorrection,
                                                       bEnableOffsetCorrection,
                                                       iMinBpm, iMaxBpm,
                                                       extraVersionInfo);
 
-    BeatUtils::printBeatStatistics(beats, iSampleRate);
+    BeatUtils::printBeatStatistics(beats, sampleRate);
     if (version == BEAT_GRID_2_VERSION) {
-        double globalBpm = BeatUtils::calculateBpm(beats, iSampleRate, iMinBpm, iMaxBpm);
+        double globalBpm = BeatUtils::calculateBpm(beats, sampleRate, iMinBpm, iMaxBpm);
         double firstBeat = BeatUtils::calculateFixedTempoFirstBeat(
-            bEnableOffsetCorrection,
-            beats, iSampleRate, iTotalSamples, globalBpm);
+                bEnableOffsetCorrection,
+                beats,
+                sampleRate,
+                totalSamples,
+                globalBpm);
         auto pGrid = mixxx::BeatGrid::makeBeatGrid(
-                iSampleRate, subVersion, globalBpm, firstBeat * 2);
+                sampleRate, subVersion, globalBpm, firstBeat * 2);
         return pGrid;
     } else if (version == BEAT_MAP_VERSION) {
-        auto pBeatMap = mixxx::BeatMap::makeBeatMap(iSampleRate, subVersion, beats);
+        auto pBeatMap = mixxx::BeatMap::makeBeatMap(sampleRate, subVersion, beats);
         return pBeatMap;
     } else {
         qDebug() << "ERROR: Could not determine what type of beatgrid to create.";
diff --git a/src/track/beatfactory.h b/src/track/beatfactory.h
index dda238bf4d..865dbeaaa0 100644
--- a/src/track/beatfactory.h
+++ b/src/track/beatfactory.h
@@ -9,31 +9,31 @@ class Track;
 class BeatFactory {
   public:
     static mixxx::BeatsPointer loadBeatsFromByteArray(
-            SINT sampleRat,
+            mixxx::audio::SampleRate sampleRate,
             const QString& beatsVersion,
             const QString& beatsSubVersion,
             const QByteArray& beatsSerialized);
     static mixxx::BeatsPointer makeBeatGrid(
-            SINT sampleRat,
+            mixxx::audio::SampleRate sampleRate,
             double dBpm,
             double dFirstBeatSample);
 
-    static QString getPreferredVersion(const bool bEnableFixedTempoCorrection);
+    static QString getPreferredVersion(bool bEnableFixedTempoCorrection);
 
     static QString getPreferredSubVersion(
-            const bool bEnableFixedTempoCorrection,
-            const bool bEnableOffsetCorrection,
-            const int iMinBpm,
-            const int iMaxBpm,
+            bool bEnableFixedTempoCorrection,
+            bool bEnableOffsetCorrection,
+            int iMinBpm,
+            int iMaxBpm,
             const QHash<QString, QString>& extraVersionInfo);
 
     static mixxx::BeatsPointer makePreferredBeats(
             const QVector<double>& beats,
             const QHash<QString, QString>& extraVersionInfo,
-            const bool bEnableFixedTempoCorrection,
-            const bool bEnableOffsetCorrection,
-            const int iSampleRate,
-            const int iTotalSamples,
-            const int iMinBpm,
-            const int iMaxBpm);
+            bool bEnableFixedTempoCorrection,
+            bool bEnableOffsetCorrection,
+            mixxx::audio::SampleRate iSampleRate,
+            SINT totalSamples,
+            int iMinBpm,
+            int iMaxBpm);
 };
diff --git a/src/track/beatgrid.cpp b/src/track/beatgrid.cpp
index 10aaa7e4a2..8b81e4d83c 100644
--- a/src/track/beatgrid.cpp
+++ b/src/track/beatgrid.cpp
@@ -40,12 +40,12 @@ class BeatGridIterator : public BeatIterator {
 };
 
 BeatGrid::BeatGrid(
-        SINT iSampleRate,
+        audio::SampleRate sampleRate,
         const QString& subVersion,
         const mixxx::track::io::BeatGrid& grid,
         double beatLength)
         : m_subVersion(subVersion),
-          m_iSampleRate(iSampleRate),
+          m_sampleRate(sampleRate),
           m_grid(grid),
           m_dBeatLength(beatLength) {
     // BeatGrid should live in the same thread as the track it is associated
@@ -54,7 +54,7 @@ BeatGrid::BeatGrid(
 
 BeatGrid::BeatGrid(const BeatGrid& other, const mixxx::track::io::BeatGrid& grid, double beatLength)
         : m_subVersion(other.m_subVersion),
-          m_iSampleRate(other.m_iSampleRate),
+          m_sampleRate(other.m_sampleRate),
           m_grid(grid),
           m_dBeatLength(beatLength) {
 }
@@ -65,7 +65,7 @@ BeatGrid::BeatGrid(const BeatGrid& other)
 
 // static
 BeatsPointer BeatGrid::makeBeatGrid(
-        SINT iSampleRate,
+        audio::SampleRate sampleRate,
         const QString& subVersion,
         double dBpm,
         double dFirstBeatSample) {
@@ -79,14 +79,14 @@ BeatsPointer BeatGrid::makeBeatGrid(
     grid.mutable_first_beat()->set_frame_position(
             static_cast<google::protobuf::int32>(dFirstBeatSample / kFrameSize));
     // Calculate beat length as sample offsets
-    double beatLength = (60.0 * iSampleRate / dBpm) * kFrameSize;
+    double beatLength = (60.0 * sampleRate / dBpm) * kFrameSize;
 
-    return BeatsPointer(new BeatGrid(iSampleRate, subVersion, grid, beatLength));
+    return BeatsPointer(new BeatGrid(sampleRate, subVersion, grid, beatLength));
 }
 
 // static
 BeatsPointer BeatGrid::makeBeatGrid(
-        SINT sampleRate,
+        audio::SampleRate sampleRate,
         const QString& subVersion,
         const QByteArray& byteArray) {
     mixxx::track::io::BeatGrid grid;
@@ -111,11 +111,6 @@ QByteArray BeatGrid::toByteArray() const {
     return QByteArray(output.data(), static_cast<int>(output.length()));
 }
 
-BeatsPointer BeatGrid::clone() const {
-    BeatsPointer other(new BeatGrid(*this));
-    return other;
-}
-
 double BeatGrid::firstBeatSample() const {
     return m_grid.first_beat().frame_position() * kFrameSize;
 }
@@ -134,7 +129,7 @@ QString BeatGrid::getSubVersion() const {
 
 // internal use only
 bool BeatGrid::isValid() const {
-    return m_iSampleRate > 0 && bpm() > 0;
+    return m_sampleRate.isValid() && bpm() > 0;
 }
 
 // This could be implemented in the Beats Class itself.
@@ -333,7 +328,7 @@ BeatsPointer BeatGrid::scale(enum BPMScale scale) const {
     }
     grid.mutable_bpm()->set_bpm(bpm);
 
-    double beatLength = (60.0 * m_iSampleRate / bpm) * kFrameSize;
+    double beatLength = (60.0 * m_sampleRate / bpm) * kFrameSize;
     return BeatsPointer(new BeatGrid(*this, grid, beatLength));
 }
 
@@ -343,7 +338,7 @@ BeatsPointer BeatGrid::setBpm(double dBpm) {
     }
     mixxx::track::io::BeatGrid grid = m_grid;
     grid.mutable_bpm()->set_bpm(dBpm);
-    double beatLength = (60.0 * m_iSampleRate / dBpm) * kFrameSize;
+    double beatLength = (60.0 * m_sampleRate / dBpm) * kFrameSize;
     return BeatsPointer(new BeatGrid(*this, grid, beatLength));
 }
 
diff --git a/src/track/beatgrid.h b/src/track/beatgrid.h
index 2a7a0cc7eb..886a814171 100644
--- a/src/track/beatgrid.h
+++ b/src/track/beatgrid.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <QMutex>
-
 #include "proto/beats.pb.h"
 #include "track/beats.h"
 
@@ -20,13 +18,13 @@ class BeatGrid final : public Beats {
     ~BeatGrid() override = default;
 
     static BeatsPointer makeBeatGrid(
-            SINT iSampleRate,
+            audio::SampleRate sampleRate,
             const QString& subVersion,
             double dBpm,
             double dFirstBeatSample);
 
     static BeatsPointer makeBeatGrid(
-            SINT iSampleRate,
+            audio::SampleRate sampleRate,
             const QString& subVersion,
             const QByteArray& byteArray);
 
@@ -57,22 +55,21 @@ class BeatGrid final : public Beats {
     double getBpm() const override;
     double getBpmAroundPosition(double curSample, int n) const override;
 
-    SINT getSampleRate() const override {
-        return m_iSampleRate;
+    audio::SampleRate getSampleRate() const override {
+        return m_sampleRate;
     }
 
     ////////////////////////////////////////////////////////////////////////////
     // Beat mutations
     ////////////////////////////////////////////////////////////////////////////
 
-    BeatsPointer clone() const override;
     BeatsPointer translate(double dNumSamples) const override;
     BeatsPointer scale(enum BPMScale scale) const override;
     BeatsPointer setBpm(double dBpm) override;
 
   private:
     BeatGrid(
-            SINT iSampleRate,
+            audio::SampleRate sampleRate,
             const QString& subVersion,
             const mixxx::track::io::BeatGrid& grid,
             double beatLength);
@@ -89,7 +86,7 @@ class BeatGrid final : public Beats {
     // The sub-version of this beatgrid.
     const QString m_subVersion;
     // The number of samples per second
-    const SINT m_iSampleRate;
+    const audio::SampleRate m_sampleRate;
     // Data storage for BeatGrid
     const mixxx::track::io::BeatGrid m_grid;
     // The length of a beat in samples
diff --git a/src/track/beatmap.cpp b/src/track/beatmap.cpp
index 9b2b98cf74..45176c71f5 100644
--- a/src/track/beatmap.cpp
+++ b/src/track/beatmap.cpp
@@ -127,7 +127,7 @@ void scaleFourth(BeatList* pBeats) {
     }
 }
 
-double calculateNominalBpm(const BeatList& beats, SINT sampleRate) {
+double calculateNominalBpm(const BeatList& beats, mixxx::audio::SampleRate sampleRate) {
     QVector<double> beatvect;
     beatvect.reserve(beats.size());
     for (const auto& beat : beats) {
@@ -177,19 +177,19 @@ class BeatMapIterator : public BeatIterator {
 };
 
 BeatMap::BeatMap(
-        SINT sampleRate,
+        audio::SampleRate sampleRate,
         const QString& subVersion,
         BeatList beats,
         double nominalBpm)
         : m_subVersion(subVersion),
-          m_iSampleRate(sampleRate),
+          m_sampleRate(sampleRate),
           m_nominalBpm(nominalBpm),
           m_beats(std::move(beats)) {
 }
 
 BeatMap::BeatMap(const BeatMap& other, BeatList beats, double nominalBpm)
         : m_subVersion(other.m_subVersion),
-          m_iSampleRate(other.m_iSampleRate),
+          m_sampleRate(other.m_sampleRate),
           m_nominalBpm(nominalBpm),
           m_beats(std::move(beats)) {
 }
@@ -200,7 +200,7 @@ BeatMap::BeatMap(const BeatMap& other)
 
 // static
 BeatsPointer BeatMap::makeBeatMap(
-        SINT sampleRate,
+        audio::SampleRate sampleRate,
         const QString& subVersion,
         const QByteArray& byteArray) {
     double nominalBpm = 0.0;
@@ -222,7 +222,7 @@ BeatsPointer BeatMap::makeBeatMap(
 
 // static
 BeatsPointer BeatMap::makeBeatMap(
-        SINT sampleRate,
+        audio::SampleRate sampleRate,
         const QString& subVersion,
         const QVector<double>& beats) {
     BeatList beatList;
@@ -260,11 +260,6 @@ QByteArray BeatMap::toByteArray() const {
     return QByteArray(output.data(), static_cast<int>(output.length()));
 }
 
-BeatsPointer BeatMap::clone() const {
-    BeatsPointer other(new BeatMap(*this));
-    return other;
-}
-
 QString BeatMap::getVersion() const {
     return BEAT_MAP_VERSION;
 }
@@ -274,7 +269,7 @@ QString BeatMap::getSubVersion() const {
 }
 
 bool BeatMap::isValid() const {
-    return m_iSampleRate > 0 && m_beats.size() > 0;
+    return m_sampleRate.isValid() && m_beats.size() > 0;
 }
 
 double BeatMap::findNextBeat(double dSamples) const {
@@ -316,7 +311,7 @@ double BeatMap::findNthBeat(double dSamples, int n) const {
 
     // If the position is within 1/10th of a second of the next or previous
     // beat, pretend we are on that beat.
-    const double kFrameEpsilon = 0.1 * m_iSampleRate;
+    const double kFrameEpsilon = 0.1 * m_sampleRate;
 
     // Back-up by one.
     if (it != m_beats.begin()) {
@@ -406,7 +401,7 @@ bool BeatMap::findPrevNextBeats(
 
     // If the position is within 1/10th of a second of the next or previous
     // beat, pretend we are on that beat.
-    const double kFrameEpsilon = 0.1 * m_iSampleRate;
+    const double kFrameEpsilon = 0.1 * m_sampleRate;
 
     // Back-up by one.
     if (it != m_beats.begin()) {
@@ -549,7 +544,7 @@ double BeatMap::getBpmAroundPosition(double curSample, int n) const {
         return -1;
     }
 
-    const int kFrameEpsilon = m_iSampleRate / 20;
+    const int kFrameEpsilon = m_sampleRate / 20;
 
     int numberOfBeats = 0;
     for (const auto& beat : m_beats) {
@@ -562,7 +557,7 @@ double BeatMap::getBpmAroundPosition(double curSample, int n) const {
         }
     }
 
-    return BeatUtils::calculateAverageBpm(numberOfBeats, m_iSampleRate, lowerFrame, upperFrame);
+    return BeatUtils::calculateAverageBpm(numberOfBeats, m_sampleRate, lowerFrame, upperFrame);
 }
 
 BeatsPointer BeatMap::translate(double dNumSamples) const {
@@ -631,7 +626,7 @@ BeatsPointer BeatMap::scale(enum BPMScale scale) const {
         return BeatsPointer(new BeatMap(*this));
     }
 
-    double bpm = calculateNominalBpm(beats, m_iSampleRate);
+    double bpm = calculateNominalBpm(beats, m_sampleRate);
     return BeatsPointer(new BeatMap(*this, beats, bpm));
 }
 
diff --git a/src/track/beatmap.h b/src/track/beatmap.h
index 334b017e5e..d42e569722 100644
--- a/src/track/beatmap.h
+++ b/src/track/beatmap.h
@@ -7,8 +7,6 @@
 
 #pragma once
 
-#include <QMutex>
-
 #include "proto/beats.pb.h"
 #include "track/beats.h"
 
@@ -26,12 +24,12 @@ class BeatMap final : public Beats {
     ~BeatMap() override = default;
 
     static BeatsPointer makeBeatMap(
-            SINT sampleRate,
+            audio::SampleRate sampleRate,
             const QString& subVersion,
             const QByteArray& byteArray);
 
     static BeatsPointer makeBeatMap(
-            SINT sampleRate,
+            audio::SampleRate sampleRate,
             const QString& subVersion,
             const QVector<double>& beats);
 
@@ -61,21 +59,20 @@ class BeatMap final : public Beats {
     double getBpm() const override;
     double getBpmAroundPosition(double curSample, int n) const override;
 
-    SINT getSampleRate() const override {
-        return m_iSampleRate;
+    audio::SampleRate getSampleRate() const override {
+        return m_sampleRate;
     }
 
     ////////////////////////////////////////////////////////////////////////////
     // Beat mutations
     ////////////////////////////////////////////////////////////////////////////
 
-    BeatsPointer clone() const override;
     BeatsPointer translate(double dNumSamples) const override;
     BeatsPointer scale(enum BPMScale scale) const override;
     BeatsPointer setBpm(double dBpm) override;
 
   private:
-    BeatMap(SINT sampleRate,
+    BeatMap(audio::SampleRate sampleRate,
             const QString& subVersion,
             BeatList beats,
             double nominalBpm);
@@ -87,7 +84,7 @@ class BeatMap final : public Beats {
     bool isValid() const;
 
     const QString m_subVersion;
-    const SINT m_iSampleRate;
+    const audio::SampleRate m_sampleRate;
     const double m_nominalBpm;
     const BeatList m_beats;
 };
diff --git a/src/track/beats.h b/src/track/beats.h
index 1b3bb9f121..6f2540ab1d 100644
--- a/src/track/beats.h
+++ b/src/track/beats.h
@@ -1,10 +1,11 @@
 #pragma once
 
-#include <QString>
-#include <QList>
 #include <QByteArray>
+#include <QList>
 #include <QSharedPointer>
+#include <QString>
 
+#include "audio/types.h"
 #include "util/memory.h"
 #include "util/types.h"
 
@@ -133,14 +134,12 @@ class Beats {
         return kMaxBpm;
     }
 
-    virtual SINT getSampleRate() const = 0;
+    virtual audio::SampleRate getSampleRate() const = 0;
 
     ////////////////////////////////////////////////////////////////////////////
     // Beat mutations
     ////////////////////////////////////////////////////////////////////////////
 
-    virtual BeatsPointer clone() const = 0;
-
     // Translate all beats in the song by dNumSamples samples. Beats that lie
     // before the start of the track or after the end of the track are not
     // removed. Beats instance must have the capability BEATSCAP_TRANSLATE.
diff --git a/src/track/beatutils.cpp b/src/track/beatutils.cpp
index 17d0acc13c..30c296241f 100644
--- a/src/track/beatutils.cpp
+++ b/src/track/beatutils.cpp
@@ -24,7 +24,8 @@ const int kHistogramDecimalPlaces = 2;
 const double kHistogramDecimalScale = pow(10.0, kHistogramDecimalPlaces);
 const double kBpmFilterTolerance = 1.0;
 
-void BeatUtils::printBeatStatistics(const QVector<double>& beats, int SampleRate) {
+void BeatUtils::printBeatStatistics(
+        const QVector<double>& beats, mixxx::audio::SampleRate sampleRate) {
     if (!sDebug) {
         return;
     }
@@ -35,7 +36,7 @@ void BeatUtils::printBeatStatistics(const QVector<double>& beats, int SampleRate
         double beat_end = beats.at(i);
 
         // Time needed to count a bar (N beats)
-        const double time = (beat_end - beat_start) / SampleRate;
+        const double time = (beat_end - beat_start) / sampleRate;
         if (time == 0) {
             continue;
         }
@@ -80,9 +81,9 @@ double BeatUtils::computeSampleMedian(const QList<double>& sortedItems) {
 
 QList<double> BeatUtils::computeWindowedBpmsAndFrequencyHistogram(
         const QVector<double>& beats,
-        const int windowSize,
-        const int windowStep,
-        const int sampleRate,
+        int windowSize,
+        int windowStep,
+        mixxx::audio::SampleRate sampleRate,
         QMap<double, int>* frequencyHistogram) {
     QList<double> averageBpmList;
     for (int i = windowSize; i < beats.size(); i += windowStep) {
@@ -110,8 +111,8 @@ QList<double> BeatUtils::computeWindowedBpmsAndFrequencyHistogram(
 
 double BeatUtils::computeFilteredWeightedAverage(
         const QMap<double, int>& frequencyTable,
-        const double filterCenter,
-        const double filterTolerance,
+        double filterCenter,
+        double filterTolerance,
         QMap<double, int>* filteredFrequencyTable) {
     double filterWeightedAverage = 0.0;
     int filterSum = 0;
@@ -145,7 +146,7 @@ double BeatUtils::computeFilteredWeightedAverage(
 }
 
 double BeatUtils::calculateAverageBpm(int numberOfBeats,
-        int sampleRate,
+        mixxx::audio::SampleRate sampleRate,
         double lowerFrame,
         double upperFrame) {
     double frames = upperFrame - lowerFrame;
@@ -156,8 +157,11 @@ double BeatUtils::calculateAverageBpm(int numberOfBeats,
     return 60.0 * numberOfBeats * sampleRate / frames;
 }
 
-double BeatUtils::calculateBpm(const QVector<double>& beats, int SampleRate,
-                               int min_bpm, int max_bpm) {
+double BeatUtils::calculateBpm(
+        const QVector<double>& beats,
+        mixxx::audio::SampleRate sampleRate,
+        int min_bpm,
+        int max_bpm) {
     if (beats.isEmpty()) {
         return mixxx::Bpm::kValueUndefined;
     }
@@ -197,12 +201,12 @@ double BeatUtils::calculateBpm(const QVector<double>& beats, int SampleRate,
     // If we don't have enough beats for our regular approach, just divide the #
     // of beats by the duration in minutes.
     if (beats.size() <= N) {
-        return calculateAverageBpm(beats.size() - 1, SampleRate, beats.first(), beats.last());
+        return calculateAverageBpm(beats.size() - 1, sampleRate, beats.first(), beats.last());
     }
 
     QMap<double, int> frequency_table;
     QList<double> average_bpm_list = computeWindowedBpmsAndFrequencyHistogram(
-        beats, N, 1, SampleRate, &frequency_table);
+            beats, N, 1, sampleRate, &frequency_table);
 
     // Get the median BPM.
     std::sort(average_bpm_list.begin(), average_bpm_list.end());
@@ -262,7 +266,7 @@ double BeatUtils::calculateBpm(const QVector<double>& beats, int SampleRate,
          double beat_end = beats.at(i);
 
          // Time needed to count a bar (N beats)
-         double time = (beat_end - beat_start) / SampleRate;
+         double time = (beat_end - beat_start) / sampleRate;
          if (time == 0) {
              continue;
          }
@@ -288,7 +292,7 @@ double BeatUtils::calculateBpm(const QVector<double>& beats, int SampleRate,
              } else {
                  counter += 1;
              }
-             double time2 = (beat_end - firstCorrect