Use SampleRate type consistently

src/effects/backends/builtin/balanceeffect.cpp

@@ -79,7 +79,7 @@ BalanceGroupState::BalanceGroupState(const mixxx::EngineParameters& engineParame
     m_high->setStartFromDry(true);
 }
 
-void BalanceGroupState::setFilters(int sampleRate, double freq) {
+void BalanceGroupState::setFilters(mixxx::audio::SampleRate sampleRate, double freq) {
     m_low->setFrequencyCorners(sampleRate, freq);
     m_high->setFrequencyCorners(sampleRate, freq);
 }

src/effects/backends/builtin/balanceeffect.h

@@ -12,7 +12,7 @@ class BalanceGroupState : public EffectState {
     BalanceGroupState(const mixxx::EngineParameters& engineParameters);
     ~BalanceGroupState() override = default;
 
-    void setFilters(int sampleRate, double freq);
+    void setFilters(mixxx::audio::SampleRate sampleRate, double freq);
 
     std::unique_ptr<EngineFilterLinkwitzRiley4Low> m_low;
     std::unique_ptr<EngineFilterLinkwitzRiley4High> m_high;

src/effects/backends/builtin/filtereffect.cpp

@@ -65,12 +65,12 @@ EffectManifestPointer FilterEffect::getManifest() {
 
 FilterGroupState::FilterGroupState(const mixxx::EngineParameters& engineParameters)
         : EffectState(engineParameters),
-          m_loFreq(kMaxCorner / engineParameters.sampleRate()),
+          m_loFreq(kMaxCorner),
           m_q(0.707106781),
-          m_hiFreq(kMinCorner / engineParameters.sampleRate()) {
+          m_hiFreq(kMinCorner) {
     m_buffer = mixxx::SampleBuffer(engineParameters.samplesPerBuffer());
-    m_pLowFilter = new EngineFilterBiquad1Low(1, m_loFreq, m_q, true);
-    m_pHighFilter = new EngineFilterBiquad1High(1, m_hiFreq, m_q, true);
+    m_pLowFilter = new EngineFilterBiquad1Low(engineParameters.sampleRate(), m_loFreq, m_q, true);
+    m_pHighFilter = new EngineFilterBiquad1High(engineParameters.sampleRate(), m_hiFreq, m_q, true);
 }
 
 FilterGroupState::~FilterGroupState() {
@@ -98,16 +98,13 @@ void FilterEffect::processChannel(
     double lpf;
     double q = m_pQ->value();
 
-    const double minCornerNormalized = kMinCorner / engineParameters.sampleRate();
-    const double maxCornerNormalized = kMaxCorner / engineParameters.sampleRate();
-
     if (enableState == EffectEnableState::Disabling) {
         // Ramp to dry, when disabling, this will ramp from dry when enabling as well
-        hpf = minCornerNormalized;
-        lpf = maxCornerNormalized;
+        hpf = kMinCorner;
+        lpf = kMaxCorner;
     } else {
-        hpf = m_pHPF->value() / engineParameters.sampleRate();
-        lpf = m_pLPF->value() / engineParameters.sampleRate();
+        hpf = m_pHPF->value();
+        lpf = m_pLPF->value();
     }
 
     if ((pState->m_loFreq != lpf) ||
@@ -128,22 +125,22 @@ void FilterEffect::processChannel(
             double qmax = 4 - 2 / 0.6 * ratio;
             clampedQ = math_min(clampedQ, qmax);
         }
-        pState->m_pLowFilter->setFrequencyCorners(1, lpf, clampedQ);
-        pState->m_pHighFilter->setFrequencyCorners(1, hpf, clampedQ);
+        pState->m_pLowFilter->setFrequencyCorners(engineParameters.sampleRate(), lpf, clampedQ);
+        pState->m_pHighFilter->setFrequencyCorners(engineParameters.sampleRate(), hpf, clampedQ);
     }
 
     const CSAMPLE* pLpfInput = pState->m_buffer.data();
     CSAMPLE* pHpfOutput = pState->m_buffer.data();
-    if (lpf >= maxCornerNormalized && pState->m_loFreq >= maxCornerNormalized) {
+    if (lpf >= kMaxCorner && pState->m_loFreq >= kMaxCorner) {
         // Lpf disabled Hpf can write directly to output
         pHpfOutput = pOutput;
         pLpfInput = pHpfOutput;
     }
 
-    if (hpf > minCornerNormalized) {
+    if (hpf > kMinCorner) {
         // hpf enabled, fade-in is handled in the filter when starting from pause
         pState->m_pHighFilter->process(pInput, pHpfOutput, engineParameters.samplesPerBuffer());
-    } else if (pState->m_hiFreq > minCornerNormalized) {
+    } else if (pState->m_hiFreq > kMinCorner) {
         // hpf disabling
         pState->m_pHighFilter->processAndPauseFilter(pInput,
                 pHpfOutput,
@@ -153,10 +150,10 @@ void FilterEffect::processChannel(
         pLpfInput = pInput;
     }
 
-    if (lpf < maxCornerNormalized) {
+    if (lpf < kMaxCorner) {
         // lpf enabled, fade-in is handled in the filter when starting from pause
         pState->m_pLowFilter->process(pLpfInput, pOutput, engineParameters.samplesPerBuffer());
-    } else if (pState->m_loFreq < maxCornerNormalized) {
+    } else if (pState->m_loFreq < kMaxCorner) {
         // hpf disabling
         pState->m_pLowFilter->processAndPauseFilter(pLpfInput,
                 pOutput,

src/effects/backends/builtin/filtereffect.h

@@ -14,7 +14,7 @@ struct FilterGroupState : public EffectState {
     FilterGroupState(const mixxx::EngineParameters& engineParameters);
     ~FilterGroupState() override;
 
-    void setFilters(int sampleRate, double lowFreq, double highFreq);
+    void setFilters(mixxx::audio::SampleRate sampleRate, double lowFreq, double highFreq);
 
     mixxx::SampleBuffer m_buffer;
     EngineFilterBiquad1Low* m_pLowFilter;

src/effects/backends/builtin/graphiceqeffect.cpp

@@ -1,8 +1,12 @@
 #include "effects/backends/builtin/graphiceqeffect.h"
 
+#include "audio/types.h"
 #include "util/math.h"
 
-#define Q 1.2247449
+namespace {
+constexpr double kQ = 1.2247449;
+constexpr auto kDefaultSampleRate = mixxx::audio::SampleRate(44100);
+} // namespace
 
 // static
 QString GraphicEQEffect::getId() {
@@ -92,12 +96,12 @@ GraphicEQEffectGroupState::GraphicEQEffectGroupState(
     m_centerFrequencies[7] = 9828;
 
     // Initialize the filters with default parameters
-    m_low = new EngineFilterBiquad1LowShelving(44100, m_centerFrequencies[0], Q);
-    m_high = new EngineFilterBiquad1HighShelving(44100, m_centerFrequencies[7], Q);
+    m_low = new EngineFilterBiquad1LowShelving(kDefaultSampleRate, m_centerFrequencies[0], kQ);
+    m_high = new EngineFilterBiquad1HighShelving(kDefaultSampleRate, m_centerFrequencies[7], kQ);
     for (int i = 1; i < 7; i++) {
-        m_bands.append(new EngineFilterBiquad1Peaking(44100,
+        m_bands.append(new EngineFilterBiquad1Peaking(kDefaultSampleRate,
                 m_centerFrequencies[i],
-                Q));
+                kQ));
     }
 }
 
@@ -114,11 +118,11 @@ GraphicEQEffectGroupState::~GraphicEQEffectGroupState() {
     }
 }
 
-void GraphicEQEffectGroupState::setFilters(int sampleRate) {
-    m_low->setFrequencyCorners(sampleRate, m_centerFrequencies[0], Q, m_oldLow);
-    m_high->setFrequencyCorners(sampleRate, m_centerFrequencies[7], Q, m_oldHigh);
+void GraphicEQEffectGroupState::setFilters(mixxx::audio::SampleRate sampleRate) {
+    m_low->setFrequencyCorners(sampleRate, m_centerFrequencies[0], kQ, m_oldLow);
+    m_high->setFrequencyCorners(sampleRate, m_centerFrequencies[7], kQ, m_oldHigh);
     for (int i = 0; i < 6; i++) {
-        m_bands[i]->setFrequencyCorners(sampleRate, m_centerFrequencies[i + 1], Q, m_oldMid[i]);
+        m_bands[i]->setFrequencyCorners(sampleRate, m_centerFrequencies[i + 1], kQ, m_oldMid[i]);
     }
 }
 
@@ -170,20 +174,20 @@ void GraphicEQEffect::processChannel(
     if (fLow != pState->m_oldLow) {
         pState->m_low->setFrequencyCorners(engineParameters.sampleRate(),
                 pState->m_centerFrequencies[0],
-                Q,
+                kQ,
                 fLow);
     }
     if (fHigh != pState->m_oldHigh) {
         pState->m_high->setFrequencyCorners(engineParameters.sampleRate(),
                 pState->m_centerFrequencies[7],
-                Q,
+                kQ,
                 fHigh);
     }
     for (int i = 0; i < 6; i++) {
         if (fMid[i] != pState->m_oldMid[i]) {
             pState->m_bands[i]->setFrequencyCorners(engineParameters.sampleRate(),
                     pState->m_centerFrequencies[i + 1],
-                    Q,
+                    kQ,
                     fMid[i]);
         }
     }

src/effects/backends/builtin/graphiceqeffect.h

@@ -17,7 +17,7 @@ class GraphicEQEffectGroupState : public EffectState {
     GraphicEQEffectGroupState(const mixxx::EngineParameters& engineParameters);
     ~GraphicEQEffectGroupState() override;
 
-    void setFilters(int sampleRate);
+    void setFilters(mixxx::audio::SampleRate sampleRate);
 
     EngineFilterBiquad1LowShelving* m_low;
     QList<EngineFilterBiquad1Peaking*> m_bands;

src/effects/backends/builtin/linkwitzriley8eqeffect.cpp

@@ -3,9 +3,11 @@
 #include "effects/backends/builtin/equalizer_util.h"
 #include "util/math.h"
 
-static constexpr unsigned int kStartupSamplerate = 44100;
-static constexpr unsigned int kStartupLoFreq = 246;
-static constexpr unsigned int kStartupHiFreq = 2484;
+namespace {
+constexpr auto kStartupSamplerate = mixxx::audio::SampleRate(44100);
+constexpr unsigned int kStartupLoFreq = 246;
+constexpr unsigned int kStartupHiFreq = 2484;
+} // namespace
 
 // static
 QString LinkwitzRiley8EQEffect::getId() {
@@ -60,7 +62,8 @@ LinkwitzRiley8EQEffectGroupState::~LinkwitzRiley8EQEffectGroupState() {
     SampleUtil::free(m_pHighBuf);
 }
 
-void LinkwitzRiley8EQEffectGroupState::setFilters(int sampleRate, int lowFreq, int highFreq) {
+void LinkwitzRiley8EQEffectGroupState::setFilters(
+        mixxx::audio::SampleRate sampleRate, int lowFreq, int highFreq) {
     m_low1->setFrequencyCorners(sampleRate, lowFreq);
     m_high1->setFrequencyCorners(sampleRate, lowFreq);
     m_low2->setFrequencyCorners(sampleRate, highFreq);

src/effects/backends/builtin/linkwitzriley8eqeffect.h

@@ -17,7 +17,7 @@ class LinkwitzRiley8EQEffectGroupState : public EffectState {
     LinkwitzRiley8EQEffectGroupState(const mixxx::EngineParameters& engineParameters);
     ~LinkwitzRiley8EQEffectGroupState() override;
 
-    void setFilters(int sampleRate, int lowFreq, int highFreq);
+    void setFilters(mixxx::audio::SampleRate sampleRate, int lowFreq, int highFreq);
 
     EngineFilterLinkwitzRiley8Low* m_low1;
     EngineFilterLinkwitzRiley8High* m_high1;

src/effects/backends/builtin/loudnesscontoureffect.cpp

@@ -80,7 +80,7 @@ LoudnessContourEffectGroupState::~LoudnessContourEffectGroupState() {
     SampleUtil::free(m_pBuf);
 }
 
-void LoudnessContourEffectGroupState::setFilters(int sampleRate, double gain) {
+void LoudnessContourEffectGroupState::setFilters(mixxx::audio::SampleRate sampleRate, double gain) {
     m_low->setFrequencyCorners(
             sampleRate, kLoPeakFreq, kLoPleakQ, gain);
     m_high->setFrequencyCorners(

src/effects/backends/builtin/loudnesscontoureffect.h

@@ -16,7 +16,7 @@ class LoudnessContourEffectGroupState final : public EffectState {
     LoudnessContourEffectGroupState(const mixxx::EngineParameters& engineParameters);
     ~LoudnessContourEffectGroupState() override;
 
-    void setFilters(int sampleRate, double gain);
+    void setFilters(mixxx::audio::SampleRate sampleRate, double gain);
 
     std::unique_ptr<EngineFilterBiquad1Peaking> m_low;
     std::unique_ptr<EngineFilterBiquad1HighShelving> m_high;
@@ -49,7 +49,7 @@ class LoudnessContourEffect
             const EffectEnableState enableState,
             const GroupFeatureState& groupFeatureState) override;
 
-    void setFilters(int sampleRate);
+    void setFilters(mixxx::audio::SampleRate sampleRate);
 
   private:
     LoudnessContourEffect(const LoudnessContourEffect&) = delete;

src/effects/backends/builtin/moogladder4filtereffect.h

@@ -13,7 +13,7 @@ class MoogLadder4FilterGroupState : public EffectState {
     MoogLadder4FilterGroupState(const mixxx::EngineParameters& engineParameters);
     ~MoogLadder4FilterGroupState() override;
 
-    void setFilters(int sampleRate, double lowFreq, double highFreq);
+    void setFilters(mixxx::audio::SampleRate sampleRate, double lowFreq, double highFreq);
 
     CSAMPLE* m_pBuf;
     EngineFilterMoogLadder4Low* m_pLowFilter;

src/effects/backends/builtin/parametriceqeffect.cpp

@@ -119,7 +119,7 @@ ParametricEQEffectGroupState::ParametricEQEffectGroupState(
     }
 }
 
-void ParametricEQEffectGroupState::setFilters(int sampleRate) {
+void ParametricEQEffectGroupState::setFilters(mixxx::audio::SampleRate sampleRate) {
     for (int i = 0; i < kBandCount; i++) {
         m_bands[i]->setFrequencyCorners(
                 sampleRate, m_oldCenter[i], m_oldQ[i], m_oldGain[i]);

src/effects/backends/builtin/parametriceqeffect.h

@@ -26,7 +26,7 @@ class ParametricEQEffectGroupState final : public EffectState {
     ParametricEQEffectGroupState(const mixxx::EngineParameters& engineParameters);
     ~ParametricEQEffectGroupState() override = default;
 
-    void setFilters(int sampleRate);
+    void setFilters(mixxx::audio::SampleRate sampleRate);
 
     // These containers are only appended in the constructor which is called on
     // the main thread, so there is no risk of allocation in the audio thread.

src/effects/backends/builtin/threebandbiquadeqeffect.cpp

@@ -97,7 +97,7 @@ ThreeBandBiquadEQEffectGroupState::ThreeBandBiquadEQEffectGroupState(
 }
 
 void ThreeBandBiquadEQEffectGroupState::setFilters(
-        int sampleRate, double lowFreqCorner, double highFreqCorner) {
+        mixxx::audio::SampleRate sampleRate, double lowFreqCorner, double highFreqCorner) {
     double lowCenter = getCenterFrequency(kMinimumFrequency, lowFreqCorner);
     double midCenter = getCenterFrequency(lowFreqCorner, highFreqCorner);
     double highCenter = getCenterFrequency(highFreqCorner, kMaximumFrequency);

src/effects/backends/builtin/threebandbiquadeqeffect.h

@@ -18,7 +18,7 @@ class ThreeBandBiquadEQEffectGroupState final : public EffectState {
     ~ThreeBandBiquadEQEffectGroupState() override = default;
 
     void setFilters(
-            int sampleRate, double lowFreqCorner, double highFreqCorner);
+            mixxx::audio::SampleRate sampleRate, double lowFreqCorner, double highFreqCorner);
 
     std::unique_ptr<EngineFilterBiquad1Peaking> m_lowBoost;
     std::unique_ptr<EngineFilterBiquad1Peaking> m_midBoost;
@@ -59,7 +59,9 @@ class ThreeBandBiquadEQEffect : public EffectProcessorImpl<ThreeBandBiquadEQEffe
             const EffectEnableState enableState,
             const GroupFeatureState& groupFeatureState) override;
 
-    void setFilters(int sampleRate, double lowFreqCorner, double highFreqCorner);
+    void setFilters(mixxx::audio::SampleRate sampleRate,
+            double lowFreqCorner,
+            double highFreqCorner);
 
   private:
     ThreeBandBiquadEQEffect(const ThreeBandBiquadEQEffect&) = delete;

src/engine/cachingreader/cachingreader.h

@@ -121,7 +121,9 @@ class CachingReader : public QObject {
   signals:
     // Emitted once a new track is loaded and ready to be read from.
     void trackLoading();
-    void trackLoaded(TrackPointer pTrack, int trackSampleRate, double trackNumSamples);
+    void trackLoaded(TrackPointer pTrack,
+            mixxx::audio::SampleRate trackSampleRate,
+            double trackNumSamples);
     void trackLoadFailed(TrackPointer pTrack, const QString& reason);
 
   private:

src/engine/cachingreader/cachingreaderworker.h

@@ -7,6 +7,7 @@
 #include <QtDebug>
 
 #include "audio/frame.h"
+#include "audio/types.h"
 #include "engine/cachingreader/cachingreaderchunk.h"
 #include "engine/engineworker.h"
 #include "sources/audiosource.h"
@@ -114,7 +115,7 @@ class CachingReaderWorker : public EngineWorker {
   signals:
     // Emitted once a new track is loaded and ready to be read from.
     void trackLoading();
-    void trackLoaded(TrackPointer pTrack, int sampleRate, double numSamples);
+    void trackLoaded(TrackPointer pTrack, mixxx::audio::SampleRate sampleRate, double numSamples);
     void trackLoadFailed(TrackPointer pTrack, const QString& reason);
 
   private:

src/engine/channelmixer.cpp

@@ -10,7 +10,7 @@ void ChannelMixer::applyEffectsAndMixChannels(const EngineMaster::GainCalculator
         CSAMPLE* pOutput,
         const ChannelHandle& outputHandle,
         unsigned int iBufferSize,
-        unsigned int iSampleRate,
+        mixxx::audio::SampleRate sampleRate,
         EngineEffectsManager* pEngineEffectsManager) {
     // Signal flow overview:
     // 1. Clear pOutput buffer
@@ -42,7 +42,7 @@ void ChannelMixer::applyEffectsAndMixChannels(const EngineMaster::GainCalculator
                 pChannelInfo->m_pBuffer,
                 pOutput,
                 iBufferSize,
-                iSampleRate,
+                sampleRate,
                 pChannelInfo->m_features,
                 oldGain,
                 newGain,
@@ -59,7 +59,7 @@ void ChannelMixer::applyEffectsInPlaceAndMixChannels(
         CSAMPLE* pOutput,
         const ChannelHandle& outputHandle,
         unsigned int iBufferSize,
-        unsigned int iSampleRate,
+        mixxx::audio::SampleRate sampleRate,
         EngineEffectsManager* pEngineEffectsManager) {
     // Signal flow overview:
     // 1. Calculate gains for each channel
@@ -87,7 +87,7 @@ void ChannelMixer::applyEffectsInPlaceAndMixChannels(
                 outputHandle,
                 pChannelInfo->m_pBuffer,
                 iBufferSize,
-                iSampleRate,
+                sampleRate,
                 pChannelInfo->m_features,
                 oldGain,
                 newGain,

src/engine/channelmixer.h

@@ -2,9 +2,10 @@
 
 #include <QVarLengthArray>
 
-#include "util/types.h"
-#include "engine/enginemaster.h"
+#include "audio/types.h"
 #include "effects/engineeffectsmanager.h"
+#include "engine/enginemaster.h"
+#include "util/types.h"
 
 class ChannelMixer {
   public:
@@ -20,7 +21,7 @@ class ChannelMixer {
             CSAMPLE* pOutput,
             const ChannelHandle& outputHandle,
             unsigned int iBufferSize,
-            unsigned int iSampleRate,
+            mixxx::audio::SampleRate sampleRate,
             EngineEffectsManager* pEngineEffectsManager);
     // This does modify the input channel buffers, then mixes them to make the output buffer.
     static void applyEffectsInPlaceAndMixChannels(
@@ -32,6 +33,6 @@ class ChannelMixer {
             CSAMPLE* pOutput,
             const ChannelHandle& outputHandle,
             unsigned int iBufferSize,
-            unsigned int iSampleRate,
+            mixxx::audio::SampleRate sampleRate,
             EngineEffectsManager* pEngineEffectsManager);
 };