Merge pull request #11988 from abique/alex/reduce-sample-buffer-memor…

…y-usage

Alex/reduce sample buffer memory usage

src/effects/backends/builtin/balanceeffect.cpp

@@ -67,7 +67,7 @@ EffectManifestPointer BalanceEffect::getManifest() {
 
 BalanceGroupState::BalanceGroupState(const mixxx::EngineParameters& engineParameters)
         : EffectState(engineParameters),
-          m_pHighBuf(MAX_BUFFER_LEN),
+          m_pHighBuf(engineParameters.samplesPerBuffer()),
           m_oldSampleRate(engineParameters.sampleRate()),
           m_freq(kMinCornerHz),
           m_oldBalance(0),

src/effects/backends/builtin/linkwitzriley8eqeffect.cpp

@@ -41,9 +41,9 @@ LinkwitzRiley8EQEffectGroupState::LinkwitzRiley8EQEffectGroupState(
           m_oldSampleRate(engineParameters.sampleRate()),
           m_loFreq(kStartupLoFreq),
           m_hiFreq(kStartupHiFreq) {
-    m_pLowBuf = SampleUtil::alloc(MAX_BUFFER_LEN);
-    m_pMidBuf = SampleUtil::alloc(MAX_BUFFER_LEN);
-    m_pHighBuf = SampleUtil::alloc(MAX_BUFFER_LEN);
+    m_pLowBuf = SampleUtil::alloc(kMaxEngineSamples);
+    m_pMidBuf = SampleUtil::alloc(kMaxEngineSamples);
+    m_pHighBuf = SampleUtil::alloc(kMaxEngineSamples);
 
     m_low1 = new EngineFilterLinkwitzRiley8Low(engineParameters.sampleRate(), kStartupLoFreq);
     m_high1 = new EngineFilterLinkwitzRiley8High(engineParameters.sampleRate(), kStartupLoFreq);

src/effects/backends/builtin/pitchshifteffect.cpp

@@ -25,15 +25,13 @@ PitchShiftGroupState::PitchShiftGroupState(
 }
 
 PitchShiftGroupState::~PitchShiftGroupState() {
-    SampleUtil::free(m_retrieveBuffer[0]);
-    SampleUtil::free(m_retrieveBuffer[1]);
 }
 
 void PitchShiftGroupState::initializeBuffer(
         const mixxx::EngineParameters& engineParameters) {
-    m_retrieveBuffer[0] = SampleUtil::alloc(
+    m_retrieveBuffer[0] = mixxx::SampleBuffer(
             engineParameters.framesPerBuffer());
-    m_retrieveBuffer[1] = SampleUtil::alloc(
+    m_retrieveBuffer[1] = mixxx::SampleBuffer(
             engineParameters.framesPerBuffer());
 }
 
@@ -132,6 +130,8 @@ void PitchShiftEffect::processChannel(
     Q_UNUSED(groupFeatures);
     Q_UNUSED(enableState);
 
+    DEBUG_ASSERT(engineParameters.framesPerBuffer() <= pState->m_retrieveBuffer[0].size());
+
     if (const bool formantPreserving = m_pFormantPreservingParameter->toBool();
             m_currentFormant != formantPreserving) {
         m_currentFormant = formantPreserving;
@@ -219,12 +219,15 @@ void PitchShiftEffect::processChannel(
     pState->m_pRubberBand->setPitchScale(pitch);
 
     SampleUtil::deinterleaveBuffer(
-            pState->m_retrieveBuffer[0],
-            pState->m_retrieveBuffer[1],
+            pState->m_retrieveBuffer[0].data(),
+            pState->m_retrieveBuffer[1].data(),
             pInput,
             engineParameters.framesPerBuffer());
+
+    CSAMPLE* retrieveBuffers[2]{pState->m_retrieveBuffer[0].data(),
+            pState->m_retrieveBuffer[1].data()};
     pState->m_pRubberBand->process(
-            pState->m_retrieveBuffer,
+            retrieveBuffers,
             engineParameters.framesPerBuffer(),
             false);
 
@@ -234,11 +237,11 @@ void PitchShiftEffect::processChannel(
             engineParameters.framesPerBuffer());
 
     SINT receivedFrames = pState->m_pRubberBand->retrieve(
-            pState->m_retrieveBuffer,
+            retrieveBuffers,
             framesToRead);
 
     SampleUtil::interleaveBuffer(pOutput,
-            pState->m_retrieveBuffer[0],
-            pState->m_retrieveBuffer[1],
+            pState->m_retrieveBuffer[0].data(),
+            pState->m_retrieveBuffer[1].data(),
             receivedFrames);
 }

src/effects/backends/builtin/pitchshifteffect.h

@@ -11,6 +11,7 @@
 #include "util/defs.h"
 #include "util/math.h"
 #include "util/sample.h"
+#include "util/samplebuffer.h"
 #include "util/types.h"
 
 namespace RubberBand {
@@ -26,7 +27,7 @@ class PitchShiftGroupState : public EffectState {
     void audioParametersChanged(const mixxx::EngineParameters& engineParameters);
 
     std::unique_ptr<RubberBand::RubberBandStretcher> m_pRubberBand;
-    CSAMPLE* m_retrieveBuffer[2];
+    mixxx::SampleBuffer m_retrieveBuffer[2];
 };
 
 class PitchShiftEffect final : public EffectProcessorImpl<PitchShiftGroupState> {

src/effects/backends/lv2/lv2effectprocessor.cpp

@@ -9,10 +9,10 @@ LV2EffectProcessor::LV2EffectProcessor(LV2EffectManifestPointer pManifest)
           m_pPlugin(pManifest->getPlugin()),
           m_audioPortIndices(pManifest->getAudioPortIndices()),
           m_controlPortIndices(pManifest->getControlPortIndices()) {
-    m_inputL = new float[MAX_BUFFER_LEN];
-    m_inputR = new float[MAX_BUFFER_LEN];
-    m_outputL = new float[MAX_BUFFER_LEN];
-    m_outputR = new float[MAX_BUFFER_LEN];
+    m_inputL = new float[kMaxEngineSamples];
+    m_inputR = new float[kMaxEngineSamples];
+    m_outputL = new float[kMaxEngineSamples];
+    m_outputR = new float[kMaxEngineSamples];
 }
 
 void LV2EffectProcessor::loadEngineEffectParameters(

src/engine/bufferscalers/enginebufferscalerubberband.cpp

@@ -155,8 +155,8 @@ SINT EngineBufferScaleRubberBand::retrieveAndDeinterleave(
 
     DEBUG_ASSERT(received_frames <= frames);
     SampleUtil::interleaveBuffer(pBuffer,
-            m_buffers[0].data() + frame_offset,
-            m_buffers[1].data() + frame_offset,
+            m_buffers[0].data(frame_offset),
+            m_buffers[1].data(frame_offset),
             received_frames);
 
     return received_frames;

src/engine/cachingreader/cachingreaderchunk.cpp

@@ -17,19 +17,6 @@ constexpr SINT kInvalidChunkIndex = -1;
 
 } // anonymous namespace
 
-// One chunk should contain 1/2 - 1/4th of a second of audio.
-// 8192 frames contain about 170 ms of audio at 48 kHz, which
-// is well above (hopefully) the latencies people are seeing.
-// At 10 ms latency one chunk is enough for 17 callbacks.
-// Additionally the chunk size should be a power of 2 for
-// easier memory alignment.
-// TODO(XXX): The optimum value of the "constant" kFrames depends
-// on the properties of the AudioSource as the remarks above suggest!
-const mixxx::audio::ChannelCount CachingReaderChunk::kChannels = mixxx::kEngineChannelCount;
-const SINT CachingReaderChunk::kFrames = 8192; // ~ 170 ms at 48 kHz
-const SINT CachingReaderChunk::kSamples =
-        CachingReaderChunk::frames2samples(CachingReaderChunk::kFrames);
-
 CachingReaderChunk::CachingReaderChunk(
         mixxx::SampleBuffer::WritableSlice sampleBuffer)
         : m_index(kInvalidChunkIndex),

src/engine/cachingreader/cachingreaderchunk.h

@@ -15,17 +15,25 @@
 // and the worker.
 class CachingReaderChunk {
 public:
-    static const mixxx::audio::ChannelCount kChannels;
-    static const SINT kFrames;
-    static const SINT kSamples;
-
-    // Converts frames to samples
-    static SINT frames2samples(SINT frames) {
-        return frames * kChannels;
-    }
-    static double dFrames2samples(SINT frames) {
-        return static_cast<double>(frames) * kChannels;
-    }
+  // One chunk should contain 1/2 - 1/4th of a second of audio.
+  // 8192 frames contain about 170 ms of audio at 48 kHz, which
+  // is well above (hopefully) the latencies people are seeing.
+  // At 10 ms latency one chunk is enough for 17 callbacks.
+  // Additionally the chunk size should be a power of 2 for
+  // easier memory alignment.
+  // TODO(XXX): The optimum value of the "constant" kFrames depends
+  // on the properties of the AudioSource as the remarks above suggest!
+  static constexpr mixxx::audio::ChannelCount kChannels = mixxx::kEngineChannelCount;
+  static constexpr SINT kFrames = 8192; // ~ 170 ms at 48 kHz
+  static constexpr SINT kSamples = kFrames * kChannels;
+
+  // Converts frames to samples
+  static constexpr SINT frames2samples(SINT frames) noexcept {
+      return frames * kChannels;
+  }
+  static constexpr double dFrames2samples(SINT frames) noexcept {
+      return static_cast<double>(frames) * kChannels;
+  }
     // Converts samples to frames
     static SINT samples2frames(SINT samples) {
         DEBUG_ASSERT(0 == (samples % kChannels));
@@ -36,7 +44,7 @@ class CachingReaderChunk {
     static SINT indexForFrame(
             /*const mixxx::AudioSourcePointer& pAudioSource,*/
             SINT frameIndex) {
-        //DEBUG_ASSERT(pAudioSource->frameIndexRange().contains(frameIndex));
+        // DEBUG_ASSERT(pAudioSource->frameIndexRange().contains(frameIndex));
         const SINT frameIndexOffset = frameIndex /*- pAudioSource->frameIndexMin()*/;
         return frameIndexOffset / kFrames;
     }
@@ -45,7 +53,7 @@ class CachingReaderChunk {
     CachingReaderChunk(const CachingReaderChunk&) = delete;
     CachingReaderChunk(CachingReaderChunk&&) = delete;
 
-    SINT getIndex() const {
+    SINT getIndex() const noexcept {
         return m_index;
     }
 
@@ -74,9 +82,9 @@ class CachingReaderChunk {
     void init(SINT index);
 
 private:
-    SINT frameIndexOffset() const {
+  SINT frameIndexOffset() const noexcept {
         return m_index * kFrames;
-    }
+  }
 
     SINT m_index;
 
@@ -104,7 +112,7 @@ class CachingReaderChunkForOwner: public CachingReaderChunk {
         READ_PENDING
     };
 
-    State getState() const {
+    State getState() const noexcept {
         return m_state;
     }
 
@@ -139,8 +147,8 @@ class CachingReaderChunkForOwner: public CachingReaderChunk {
             CachingReaderChunkForOwner** ppTail);
 
 private:
-    State m_state;
+  State m_state;
 
-    CachingReaderChunkForOwner* m_pPrev; // previous item in double-linked list
-    CachingReaderChunkForOwner* m_pNext; // next item in double-linked list
+  CachingReaderChunkForOwner* m_pPrev; // previous item in double-linked list
+  CachingReaderChunkForOwner* m_pNext; // next item in double-linked list
 };

src/engine/channelmixer.cpp

@@ -39,7 +39,7 @@ void ChannelMixer::applyEffectsAndMixChannels(const EngineMixer::GainCalculator&
         gainCache.m_gain = newGain;
         pEngineEffectsManager->processPostFaderAndMix(pChannelInfo->m_handle,
                 outputHandle,
-                pChannelInfo->m_pBuffer,
+                pChannelInfo->m_pBuffer.data(),
                 pOutput,
                 iBufferSize,
                 sampleRate,
@@ -85,13 +85,13 @@ void ChannelMixer::applyEffectsInPlaceAndMixChannels(
         gainCache.m_gain = newGain;
         pEngineEffectsManager->processPostFaderInPlace(pChannelInfo->m_handle,
                 outputHandle,
-                pChannelInfo->m_pBuffer,
+                pChannelInfo->m_pBuffer.data(),
                 iBufferSize,
                 sampleRate,
                 pChannelInfo->m_features,
                 oldGain,
                 newGain,
                 fadeout);
-        SampleUtil::add(pOutput, pChannelInfo->m_pBuffer, iBufferSize);
+        SampleUtil::add(pOutput, pChannelInfo->m_pBuffer.data(), iBufferSize);
     }
 }

src/engine/effects/engineeffect.cpp

@@ -40,7 +40,7 @@ EngineEffect::EngineEffect(EffectManifestPointer pManifest,
     // At this point the SoundDevice is not set up so we use the kInitalSampleRate.
     const mixxx::EngineParameters engineParameters(
             kInitalSampleRate,
-            MAX_BUFFER_LEN / mixxx::kEngineChannelCount);
+            kMaxEngineFrames);
     m_pProcessor->initialize(activeInputChannels, registeredOutputChannels, engineParameters);
     m_effectRampsFromDry = pManifest->effectRampsFromDry();
 }
@@ -62,7 +62,7 @@ void EngineEffect::initalizeInputChannel(ChannelHandle inputChannel) {
     // At this point the SoundDevice is not set up so we use the kInitalSampleRate.
     const mixxx::EngineParameters engineParameters(
             kInitalSampleRate,
-            MAX_BUFFER_LEN / mixxx::kEngineChannelCount);
+            kMaxEngineFrames);
     m_pProcessor->initializeInputChannel(inputChannel, engineParameters);
 }
 

src/engine/effects/engineeffectchain.cpp

@@ -11,8 +11,8 @@ EngineEffectChain::EngineEffectChain(const QString& group,
           m_enableState(EffectEnableState::Enabled),
           m_mixMode(EffectChainMixMode::DrySlashWet),
           m_dMix(0),
-          m_buffer1(MAX_BUFFER_LEN),
-          m_buffer2(MAX_BUFFER_LEN) {
+          m_buffer1(kMaxEngineSamples),
+          m_buffer2(kMaxEngineSamples) {
     // Try to prevent memory allocation.
     m_effects.reserve(256);
 
@@ -179,6 +179,8 @@ bool EngineEffectChain::process(const ChannelHandle& inputHandle,
         const mixxx::audio::SampleRate sampleRate,
         const GroupFeatureState& groupFeatures,
         bool fadeout) {
+    DEBUG_ASSERT(numSamples <= kMaxEngineSamples);
+
     // Compute the effective enable state from the channel input routing switch and
     // the chain's enable state. When either of these are turned on/off, send the
     // effects the intermediate enabling/disabling signal.

src/engine/effects/engineeffectsmanager.cpp

@@ -8,8 +8,8 @@
 
 EngineEffectsManager::EngineEffectsManager(std::unique_ptr<EffectsResponsePipe> pResponsePipe)
         : m_pResponsePipe(std::move(pResponsePipe)),
-          m_buffer1(MAX_BUFFER_LEN),
-          m_buffer2(MAX_BUFFER_LEN) {
+          m_buffer1(kMaxEngineSamples),
+          m_buffer2(kMaxEngineSamples) {
     // Try to prevent memory allocation.
     m_effects.reserve(256);
 }

src/engine/engine.h

@@ -9,7 +9,7 @@ static constexpr audio::ChannelCount kEngineChannelCount =
         audio::ChannelCount::stereo();
 
 // Contains the information needed to process a buffer of audio
-class EngineParameters {
+class EngineParameters final {
   public:
     SINT framesPerBuffer() const {
         return m_framesPerBuffer;
@@ -34,6 +34,7 @@ class EngineParameters {
                       sampleRate),
               m_framesPerBuffer(framesPerBuffer) {
         DEBUG_ASSERT(framesPerBuffer > 0);
+        DEBUG_ASSERT(sampleRate > 0);
     }
 
   private:

src/engine/enginebuffer.cpp

@@ -101,7 +101,7 @@ EngineBuffer::EngineBuffer(const QString& group,
           m_iEnableSyncQueued(SYNC_REQUEST_NONE),
           m_iSyncModeQueued(static_cast<int>(SyncMode::Invalid)),
           m_bPlayAfterLoading(false),
-          m_pCrossfadeBuffer(SampleUtil::alloc(MAX_BUFFER_LEN)),
+          m_pCrossfadeBuffer(SampleUtil::alloc(kMaxEngineSamples)),
           m_bCrossfadeReady(false),
           m_iLastBufferSize(0) {
     // This should be a static assertion, but isValid() is not constexpr.
@@ -110,7 +110,7 @@ EngineBuffer::EngineBuffer(const QString& group,
     m_queuedSeek.setValue(kNoQueuedSeek);
 
     // zero out crossfade buffer
-    SampleUtil::clear(m_pCrossfadeBuffer, MAX_BUFFER_LEN);
+    SampleUtil::clear(m_pCrossfadeBuffer, kMaxEngineSamples);
 
     m_pReader = new CachingReader(group, pConfig);
     connect(m_pReader, &CachingReader::trackLoading,