Enclose sample buffering classes into namespace 'mixxx'

21 files changed, 112 insertions, 82 deletions

diff --git a/src/analyzer/analyzerqueue.cpp b/src/analyzer/analyzerqueue.cpp
index cbbca1bb4d..13ebe0569e 100644
--- a/src/analyzer/analyzerqueue.cpp
+++ b/src/analyzer/analyzerqueue.cpp
@@ -198,7 +198,7 @@ bool AnalyzerQueue::doAnalysis(
                 audioSourceProxy.readSampleFrames(
                         mixxx::WritableSampleFrames(
                                 inputFrameIndexRange,
-                                SampleBuffer::WritableSlice(m_sampleBuffer)));
+                                mixxx::SampleBuffer::WritableSlice(m_sampleBuffer)));
         // To compare apples to apples, let's only look at blocks that are
         // the full block size.
         if (readableSampleFrames.frameIndexRange().length() == kAnalysisFramesPerBlock) {
diff --git a/src/analyzer/analyzerqueue.h b/src/analyzer/analyzerqueue.h
index abd4a912c4..41bd403b85 100644
--- a/src/analyzer/analyzerqueue.h
+++ b/src/analyzer/analyzerqueue.h
@@ -78,7 +78,7 @@ class AnalyzerQueue : public QThread {
     bool m_exit;
     QAtomicInt m_aiCheckPriorities;
 
-    SampleBuffer m_sampleBuffer;
+    mixxx::SampleBuffer m_sampleBuffer;
 
     // The processing queue and associated mutex
     QQueue<TrackPointer> m_queuedTracks;
diff --git a/src/effects/native/balanceeffect.h b/src/effects/native/balanceeffect.h
index 33453d7b84..25abdcc4ef 100644
--- a/src/effects/native/balanceeffect.h
+++ b/src/effects/native/balanceeffect.h
@@ -19,7 +19,7 @@ class BalanceGroupState final {
     std::unique_ptr<EngineFilterLinkwitzRiley4Low> m_low;
     std::unique_ptr<EngineFilterLinkwitzRiley4High> m_high;
 
-    SampleBuffer m_pHighBuf;
+    mixxx::SampleBuffer m_pHighBuf;
 
     unsigned int m_oldSampleRate;
     int m_freq;
diff --git a/src/effects/native/biquadfullkilleqeffect.h b/src/effects/native/biquadfullkilleqeffect.h
index f786a3924d..b9c8f96ffe 100644
--- a/src/effects/native/biquadfullkilleqeffect.h
+++ b/src/effects/native/biquadfullkilleqeffect.h
@@ -35,10 +35,10 @@ class BiquadFullKillEQEffectGroupState final {
     std::unique_ptr<EngineFilterBiquad1HighShelving> m_highKill;
     std::unique_ptr<LVMixEQEffectGroupState<EngineFilterBessel4Low>> m_lvMixIso;
 
-    SampleBuffer m_pLowBuf;
-    SampleBuffer m_pBandBuf;
-    SampleBuffer m_pHighBuf;
-    SampleBuffer m_tempBuf;
+    mixxx::SampleBuffer m_pLowBuf;
+    mixxx::SampleBuffer m_pBandBuf;
+    mixxx::SampleBuffer m_pHighBuf;
+    mixxx::SampleBuffer m_tempBuf;
 
     double m_oldLowBoost;
     double m_oldMidBoost;
diff --git a/src/effects/native/echoeffect.h b/src/effects/native/echoeffect.h
index 52cea0504e..cb8e17dcf4 100644
--- a/src/effects/native/echoeffect.h
+++ b/src/effects/native/echoeffect.h
@@ -31,7 +31,7 @@ struct EchoGroupState {
         ping_pong = 0;
     }
 
-    SampleBuffer delay_buf;
+    mixxx::SampleBuffer delay_buf;
     CSAMPLE_GAIN prev_send;
     CSAMPLE_GAIN prev_feedback;
     int prev_delay_samples;
diff --git a/src/effects/native/threebandbiquadeqeffect.h b/src/effects/native/threebandbiquadeqeffect.h
index effd4c6990..57d92dda64 100644
--- a/src/effects/native/threebandbiquadeqeffect.h
+++ b/src/effects/native/threebandbiquadeqeffect.h
@@ -28,7 +28,7 @@ class ThreeBandBiquadEQEffectGroupState final {
     std::unique_ptr<EngineFilterBiquad1Peaking> m_lowCut;
     std::unique_ptr<EngineFilterBiquad1Peaking> m_midCut;
     std::unique_ptr<EngineFilterBiquad1HighShelving> m_highCut;
-    SampleBuffer m_tempBuf;
+    mixxx::SampleBuffer m_tempBuf;
     double m_oldLowBoost;
     double m_oldMidBoost;
     double m_oldHighBoost;
diff --git a/src/engine/cachingreader.cpp b/src/engine/cachingreader.cpp
index a10458c2fa..514c235405 100644
--- a/src/engine/cachingreader.cpp
+++ b/src/engine/cachingreader.cpp
@@ -46,7 +46,7 @@ CachingReader::CachingReader(QString group,
     for (SINT i = 0; i < kNumberOfCachedChunksInMemory; ++i) {
         CachingReaderChunkForOwner* c =
                 new CachingReaderChunkForOwner(
-                        SampleBuffer::WritableSlice(
+                        mixxx::SampleBuffer::WritableSlice(
                                 m_sampleBuffer,
                                 CachingReaderChunk::kSamples * i,
                                 CachingReaderChunk::kSamples));
diff --git a/src/engine/cachingreader.h b/src/engine/cachingreader.h
index c0c372fbf4..4bc67ee700 100644
--- a/src/engine/cachingreader.h
+++ b/src/engine/cachingreader.h
@@ -158,7 +158,7 @@ class CachingReader : public QObject {
     CachingReaderChunkForOwner* m_lruCachingReaderChunk;
 
     // The raw memory buffer which is divided up into chunks.
-    SampleBuffer m_sampleBuffer;
+    mixxx::SampleBuffer m_sampleBuffer;
 
     // The readable frame index range as reported by the worker.
     mixxx::IndexRange m_readableFrameIndexRange;
diff --git a/src/engine/cachingreaderchunk.cpp b/src/engine/cachingreaderchunk.cpp
index 9a41bfaec0..a76539a3ba 100644
--- a/src/engine/cachingreaderchunk.cpp
+++ b/src/engine/cachingreaderchunk.cpp
@@ -30,7 +30,7 @@ const SINT CachingReaderChunk::kSamples =
         CachingReaderChunk::frames2samples(CachingReaderChunk::kFrames);
 
 CachingReaderChunk::CachingReaderChunk(
-        SampleBuffer::WritableSlice sampleBuffer)
+        mixxx::SampleBuffer::WritableSlice sampleBuffer)
         : m_index(kInvalidChunkIndex),
           m_sampleBuffer(sampleBuffer) {
     DEBUG_ASSERT(sampleBuffer.size() == kSamples);
@@ -60,7 +60,7 @@ mixxx::IndexRange CachingReaderChunk::frameIndexRange(
 
 mixxx::IndexRange CachingReaderChunk::bufferSampleFrames(
         const mixxx::AudioSourcePointer& pAudioSource,
-        SampleBuffer::WritableSlice tempOutputBuffer) {
+        mixxx::SampleBuffer::WritableSlice tempOutputBuffer) {
     const auto sourceFrameIndexRange = frameIndexRange(pAudioSource);
     mixxx::AudioSourceStereoProxy audioSourceProxy(
             pAudioSource,
@@ -70,7 +70,7 @@ mixxx::IndexRange CachingReaderChunk::bufferSampleFrames(
             audioSourceProxy.readSampleFrames(
                     mixxx::WritableSampleFrames(
                             sourceFrameIndexRange,
-                            SampleBuffer::WritableSlice(m_sampleBuffer)));
+                            mixxx::SampleBuffer::WritableSlice(m_sampleBuffer)));
     DEBUG_ASSERT(m_bufferedSampleFrames.frameIndexRange() <= sourceFrameIndexRange);
     return m_bufferedSampleFrames.frameIndexRange();
 }
@@ -114,7 +114,7 @@ mixxx::IndexRange CachingReaderChunk::readBufferedSampleFramesReverse(
 }
 
 CachingReaderChunkForOwner::CachingReaderChunkForOwner(
-        SampleBuffer::WritableSlice sampleBuffer)
+        mixxx::SampleBuffer::WritableSlice sampleBuffer)
         : CachingReaderChunk(sampleBuffer),
           m_state(FREE),
           m_pPrev(nullptr),
diff --git a/src/engine/cachingreaderchunk.h b/src/engine/cachingreaderchunk.h
index 1608fa835a..463e736666 100644
--- a/src/engine/cachingreaderchunk.h
+++ b/src/engine/cachingreaderchunk.h
@@ -55,7 +55,7 @@ public:
     // range of frames that have been read.
     mixxx::IndexRange bufferSampleFrames(
             const mixxx::AudioSourcePointer& pAudioSource,
-            SampleBuffer::WritableSlice tempOutputBuffer);
+            mixxx::SampleBuffer::WritableSlice tempOutputBuffer);
 
     mixxx::IndexRange readBufferedSampleFrames(
             CSAMPLE* sampleBuffer,
@@ -66,7 +66,7 @@ public:
 
 protected:
     explicit CachingReaderChunk(
-            SampleBuffer::WritableSlice sampleBuffer);
+            mixxx::SampleBuffer::WritableSlice sampleBuffer);
     virtual ~CachingReaderChunk();
 
     void init(SINT index);
@@ -80,7 +80,7 @@ private:
 
     // The worker thread will fill the sample buffer and
     // set the corresponding frame index range.
-    SampleBuffer::WritableSlice m_sampleBuffer;
+    mixxx::SampleBuffer::WritableSlice m_sampleBuffer;
     mixxx::ReadableSampleFrames m_bufferedSampleFrames;
 };
 
@@ -90,7 +90,7 @@ private:
 class CachingReaderChunkForOwner: public CachingReaderChunk {
 public:
     explicit CachingReaderChunkForOwner(
-            SampleBuffer::WritableSlice sampleBuffer);
+            mixxx::SampleBuffer::WritableSlice sampleBuffer);
     ~CachingReaderChunkForOwner() override;
 
     void init(SINT index);
diff --git a/src/engine/cachingreaderworker.cpp b/src/engine/cachingreaderworker.cpp
index c34a6c3e98..292340702b 100644
--- a/src/engine/cachingreaderworker.cpp
+++ b/src/engine/cachingreaderworker.cpp
@@ -49,7 +49,7 @@ ReaderStatusUpdate CachingReaderWorker::processReadRequest(
     // and adjust the max. readable frame index if decoding errors occur.
     const mixxx::IndexRange bufferedFrameIndexRange = pChunk->bufferSampleFrames(
             m_pAudioSource,
-            SampleBuffer::WritableSlice(m_tempReadBuffer));
+            mixxx::SampleBuffer::WritableSlice(m_tempReadBuffer));
     ReaderStatus status = bufferedFrameIndexRange.empty() ? CHUNK_READ_EOF : CHUNK_READ_SUCCESS;
     if (chunkFrameIndexRange != bufferedFrameIndexRange) {
         kLogger.warning()
@@ -171,7 +171,7 @@ void CachingReaderWorker::loadTrack(const TrackPointer& pTrack) {
 
     const SINT tempReadBufferSize = m_pAudioSource->frames2samples(CachingReaderChunk::kFrames);
     if (m_tempReadBuffer.size() != tempReadBufferSize) {
-        SampleBuffer(tempReadBufferSize).swap(m_tempReadBuffer);
+        mixxx::SampleBuffer(tempReadBufferSize).swap(m_tempReadBuffer);
     }
 
     // Initially assume that the complete content offered by audio source
diff --git a/src/engine/cachingreaderworker.h b/src/engine/cachingreaderworker.h
index ade24e5c98..4d60e7c3ed 100644
--- a/src/engine/cachingreaderworker.h
+++ b/src/engine/cachingreaderworker.h
@@ -101,7 +101,7 @@ class CachingReaderWorker : public EngineWorker {
 
     // Temporary buffer for reading samples from all channels
     // before conversion to a stereo signal.
-    SampleBuffer m_tempReadBuffer;
+    mixxx::SampleBuffer m_tempReadBuffer;
 
     // The maximum readable frame index of the AudioSource. Might
     // be adjusted when decoding errors occur to prevent reading
diff --git a/src/engine/effects/engineeffectchain.h b/src/engine/effects/engineeffectchain.h
index c5d3067307..c19d8ff459 100644
--- a/src/engine/effects/engineeffectchain.h
+++ b/src/engine/effects/engineeffectchain.h
@@ -66,8 +66,8 @@ class EngineEffectChain : public EffectsRequestHandler {
     EffectChain::InsertionType m_insertionType;
     CSAMPLE m_dMix;
     QList<EngineEffect*> m_effects;
-    SampleBuffer m_buffer1;
-    SampleBuffer m_buffer2;
+    mixxx::SampleBuffer m_buffer1;
+    mixxx::SampleBuffer m_buffer2;
     ChannelHandleMap<ChannelStatus> m_channelStatus;
 
     DISALLOW_COPY_AND_ASSIGN(EngineEffectChain);
diff --git a/src/musicbrainz/chromaprinter.cpp b/src/musicbrainz/chromaprinter.cpp
index a7c2e3a801..58a465efc7 100644
--- a/src/musicbrainz/chromaprinter.cpp
+++ b/src/musicbrainz/chromaprinter.cpp
@@ -50,7 +50,7 @@ QString calcFingerprint(const mixxx::AudioSourcePointer& pAudioSource) {
     // Allocate a sample buffer with maximum size to avoid the
     // implicit allocation of a temporary buffer when reducing
     // the audio signal to stereo.
-    SampleBuffer sampleBuffer(math_max(
+    mixxx::SampleBuffer sampleBuffer(math_max(
             inputFrameIndexRange.length() * kFingerprintChannels,
             pAudioSource->frames2samples(inputFrameIndexRange.length())));
 
@@ -58,7 +58,7 @@ QString calcFingerprint(const mixxx::AudioSourcePointer& pAudioSource) {
             audioSourceProxy.readSampleFrames(
                     mixxx::WritableSampleFrames(
                             inputFrameIndexRange,
-                            SampleBuffer::WritableSlice(sampleBuffer)));
+                            mixxx::SampleBuffer::WritableSlice(sampleBuffer)));
     if (inputFrameIndexRange != readableSampleFrames.frameIndexRange()) {
         qWarning() << "Failed to read sample data for fingerprint";
         return QString();
diff --git a/src/test/nativeeffects_test.cpp b/src/test/nativeeffects_test.cpp
index 71a67b3185..c57a46103e 100644
--- a/src/test/nativeeffects_test.cpp
+++ b/src/test/nativeeffects_test.cpp
@@ -40,8 +40,8 @@ void benchmarkNativeEffectDefaultParameters(const unsigned int sampleRate,
     GroupFeatureState featureState;
     EffectProcessor::EnableState enableState = EffectProcessor::ENABLED;
 
-    SampleBuffer input(numSamples);
-    SampleBuffer output(numSamples);
+    mixxx::SampleBuffer input(numSamples);
+    mixxx::SampleBuffer output(numSamples);
 
     while (pState->KeepRunning()) {
         effect.process(channel1, input.data(), output.data(), numSamples,
diff --git a/src/test/samplebuffertest.cpp b/src/test/samplebuffertest.cpp
index 6f74f472e9..fc405f013d 100644
--- a/src/test/samplebuffertest.cpp
+++ b/src/test/samplebuffertest.cpp
@@ -15,8 +15,8 @@ public:
 protected:
     static const SINT kCapacity;
 
-    SINT writeTail(ReadAheadSampleBuffer* pSampleBuffer, SINT size) {
-        const SampleBuffer::WritableSlice writableSlice(
+    SINT writeTail(mixxx::ReadAheadSampleBuffer* pSampleBuffer, SINT size) {
+        const mixxx::SampleBuffer::WritableSlice writableSlice(
                 pSampleBuffer->writeToTail(size));
         for (SINT i = 0; i < writableSlice.size(); ++i) {
             writableSlice[i] = m_writeValue;
@@ -25,8 +25,8 @@ protected:
         return writableSlice.size();
     }
 
-    SINT readHeadAndVerify(ReadAheadSampleBuffer* pSampleBuffer, SINT size) {
-        const SampleBuffer::ReadableSlice readableSlice(
+    SINT readHeadAndVerify(mixxx::ReadAheadSampleBuffer* pSampleBuffer, SINT size) {
+        const mixxx::SampleBuffer::ReadableSlice readableSlice(
                 pSampleBuffer->readFromHead(size));
         for (SINT i = 0; i < readableSlice.size(); ++i) {
             EXPECT_EQ(readableSlice[i], m_readValue);
@@ -35,8 +35,8 @@ protected:
         return readableSlice.size();
     }
 
-    SINT readTailAndVerify(ReadAheadSampleBuffer* pSampleBuffer, SINT size) {
-        const SampleBuffer::ReadableSlice readableSlice(
+    SINT readTailAndVerify(mixxx::ReadAheadSampleBuffer* pSampleBuffer, SINT size) {
+        const mixxx::SampleBuffer::ReadableSlice readableSlice(
                 pSampleBuffer->readFromTail(size));
         for (SINT i = readableSlice.size(); i-- > 0; ) {
             m_writeValue -= CSAMPLE_ONE;
@@ -45,7 +45,7 @@ protected:
         return readableSlice.size();
     }
 
-    void reset(ReadAheadSampleBuffer* pSampleBuffer) {
+    void clear(mixxx::ReadAheadSampleBuffer* pSampleBuffer) {
         pSampleBuffer->reset();
         m_writeValue = CSAMPLE_ZERO;
         m_readValue = CSAMPLE_ZERO;
@@ -59,19 +59,19 @@ private:
 const SINT ReadAheadSampleBufferTest::kCapacity = 100;
 
 TEST_F(ReadAheadSampleBufferTest, emptyWithoutCapacity) {
-    ReadAheadSampleBuffer sampleBuffer;
+    mixxx::ReadAheadSampleBuffer sampleBuffer;
     EXPECT_TRUE(sampleBuffer.isEmpty());
 
     sampleBuffer.reset();
     EXPECT_TRUE(sampleBuffer.isEmpty());
 
-    const SampleBuffer::WritableSlice writableSlice(
+    const mixxx::SampleBuffer::WritableSlice writableSlice(
             sampleBuffer.writeToTail(10));
     EXPECT_EQ(writableSlice.data(), static_cast<CSAMPLE*>(NULL));
     EXPECT_EQ(writableSlice.size(), 0);
     EXPECT_TRUE(sampleBuffer.isEmpty());
 
-    const SampleBuffer::ReadableSlice readableSlice(
+    const mixxx::SampleBuffer::ReadableSlice readableSlice(
             sampleBuffer.readFromHead(10));
     EXPECT_EQ(readableSlice.data(), static_cast<const CSAMPLE*>(NULL));
     EXPECT_EQ(readableSlice.size(), 0);
@@ -79,7 +79,7 @@ TEST_F(ReadAheadSampleBufferTest, emptyWithoutCapacity) {
 }
 
 TEST_F(ReadAheadSampleBufferTest, emptyWithCapacity) {
-    ReadAheadSampleBuffer sampleBuffer(kCapacity);
+    mixxx::ReadAheadSampleBuffer sampleBuffer(kCapacity);
     EXPECT_TRUE(sampleBuffer.isEmpty());
 
     sampleBuffer.reset();
@@ -87,7 +87,7 @@ TEST_F(ReadAheadSampleBufferTest, emptyWithCapacity) {
 }
 
 TEST_F(ReadAheadSampleBufferTest, readWriteTrim) {
-    ReadAheadSampleBuffer sampleBuffer(kCapacity);
+    mixxx::ReadAheadSampleBuffer sampleBuffer(kCapacity);
 
     SINT writeCount1 = writeTail(&sampleBuffer, kCapacity + 10);
     EXPECT_EQ(writeCount1, kCapacity); // buffer is full
@@ -104,7 +104,7 @@ TEST_F(ReadAheadSampleBufferTest, readWriteTrim) {
     EXPECT_FALSE(sampleBuffer.isEmpty());
 
     // Trim buffer contents by reallocation
-    ReadAheadSampleBuffer(sampleBuffer).swap(sampleBuffer);
+    mixxx::ReadAheadSampleBuffer(sampleBuffer).swap(sampleBuffer);
 
     SINT writeCount3 = writeTail(&sampleBuffer, kCapacity);
     EXPECT_EQ(writeCount3, readCount1); // buffer has been refilled
@@ -116,7 +116,7 @@ TEST_F(ReadAheadSampleBufferTest, readWriteTrim) {
     EXPECT_EQ(sampleBuffer.getTailCapacity(), 0);
 
     // Trim buffer contents by reallocation
-    ReadAheadSampleBuffer(sampleBuffer).swap(sampleBuffer);
+    mixxx::ReadAheadSampleBuffer(sampleBuffer).swap(sampleBuffer);
     
     SINT writeCount4 = writeTail(&sampleBuffer, kCapacity);
     EXPECT_EQ(writeCount4, readCount2); // buffer has been refilled
@@ -128,7 +128,7 @@ TEST_F(ReadAheadSampleBufferTest, readWriteTrim) {
 }
 
 TEST_F(ReadAheadSampleBufferTest, shrink) {
-    ReadAheadSampleBuffer sampleBuffer(kCapacity);
+    mixxx::ReadAheadSampleBuffer sampleBuffer(kCapacity);
 
     SINT writeCount1 = writeTail(&sampleBuffer, kCapacity - 10);
     EXPECT_EQ(writeCount1, kCapacity - 10);
@@ -154,7 +154,7 @@ TEST_F(ReadAheadSampleBufferTest, shrink) {
 }
 
 TEST_F(ReadAheadSampleBufferTest, reset) {
-    ReadAheadSampleBuffer sampleBuffer(kCapacity);
+    mixxx::ReadAheadSampleBuffer sampleBuffer(kCapacity);
 
     SINT writeCount = writeTail(&sampleBuffer, 10);
     EXPECT_EQ(writeCount, 10);
diff --git a/src/test/soundproxy_test.cpp b/src/test/soundproxy_test.cpp
index 61d9b6cc82..56721a67b7 100644
--- a/src/test/soundproxy_test.cpp
+++ b/src/test/soundproxy_test.cpp
@@ -127,7 +127,7 @@ class SoundSourceProxyTest: public MixxxTest {
             const auto readRange = pAudioSource->readSampleFrames(
                     mixxx::WritableSampleFrames(
                             nextRange,
-                            SampleBuffer::WritableSlice(
+                            mixxx::SampleBuffer::WritableSlice(
                                     m_skipSampleBuffer.data(),
                                     m_skipSampleBuffer.size()))).frameIndexRange();
             if (readRange.empty()) {
@@ -149,7 +149,7 @@ class SoundSourceProxyTest: public MixxxTest {
     }
 
   private:
-    SampleBuffer m_skipSampleBuffer;
+    mixxx::SampleBuffer m_skipSampleBuffer;
 };
 
 TEST_F(SoundSourceProxyTest, open) {
@@ -207,9 +207,9 @@ TEST_F(SoundSourceProxyTest, seekForwardBackward) {
             // skip test file
             continue;
         }
-        SampleBuffer contReadData(
+        mixxx::SampleBuffer contReadData(
                 pContReadSource->frames2samples(kReadFrameCount));
-        SampleBuffer seekReadData(
+        mixxx::SampleBuffer seekReadData(
                 pContReadSource->frames2samples(kReadFrameCount));
 
         SINT contFrameIndex = pContReadSource->frameIndexMin();
@@ -223,7 +223,7 @@ TEST_F(SoundSourceProxyTest, seekForwardBackward) {
                     pContReadSource->readSampleFrames(
                             mixxx::WritableSampleFrames(
                                     readFrameIndexRange,
-                                    SampleBuffer::WritableSlice(contReadData)));
+                                    mixxx::SampleBuffer::WritableSlice(contReadData)));
             ASSERT_FALSE(contSampleFrames.frameIndexRange().empty());
             ASSERT_LE(contSampleFrames.frameIndexRange(), readFrameIndexRange);
             ASSERT_EQ(contSampleFrames.frameIndexRange().start(), readFrameIndexRange.start());
@@ -242,7 +242,7 @@ TEST_F(SoundSourceProxyTest, seekForwardBackward) {
                     pSeekReadSource->readSampleFrames(
                             mixxx::WritableSampleFrames(
                                     readFrameIndexRange,
-                                    SampleBuffer::WritableSlice(seekReadData)));
+                                    mixxx::SampleBuffer::WritableSlice(seekReadData)));
 
             // Both buffers should be equal
             ASSERT_EQ(contSampleFrames.frameIndexRange(), seekSampleFrames.frameIndexRange());
@@ -269,7 +269,7 @@ TEST_F(SoundSourceProxyTest, seekForwardBackward) {
                     pSeekReadSource->readSampleFrames(
                             mixxx::WritableSampleFrames(
                                     readFrameIndexRange,
-                                    SampleBuffer::WritableSlice(seekReadData)));
+                                    mixxx::SampleBuffer::WritableSlice(seekReadData)));
 
             // Both buffers should again be equal
             ASSERT_EQ(contSampleFrames.frameIndexRange(), seekSampleFrames.frameIndexRange());
@@ -318,9 +318,9 @@ TEST_F(SoundSourceProxyTest, skipAndRead) {
         ASSERT_EQ(pContReadSource->frameIndexRange(), pSkipReadSource->frameIndexRange());
         SINT skipFrameIndex = pSkipReadSource->frameIndexMin();
 
-        SampleBuffer contReadData(
+        mixxx::SampleBuffer contReadData(
                 pContReadSource->frames2samples(kReadFrameCount));
-        SampleBuffer skipReadData(
+        mixxx::SampleBuffer skipReadData(
                 pSkipReadSource->frames2samples(kReadFrameCount));
 
         SINT minFrameIndex = pContReadSource->frameIndexMin();
@@ -345,7 +345,7 @@ TEST_F(SoundSourceProxyTest, skipAndRead) {
                         pContReadSource->readSampleFrames(
                                 mixxx::WritableSampleFrames(
                                         skippingFrameIndexRange,
-                                        SampleBuffer::WritableSlice(contReadData)));
+                                        mixxx::SampleBuffer::WritableSlice(contReadData)));
                 ASSERT_FALSE(skippedSampleFrames.frameIndexRange().empty());
                 ASSERT_EQ(skippedSampleFrames.frameIndexRange().start(), contFrameIndex);
                 contFrameIndex += skippedSampleFrames.frameIndexRange().length();
@@ -355,7 +355,7 @@ TEST_F(SoundSourceProxyTest, skipAndRead) {
                     pContReadSource->readSampleFrames(
                             mixxx::WritableSampleFrames(
                                     readFrameIndexRange,
-                                    SampleBuffer::WritableSlice(contReadData)));
+                                    mixxx::SampleBuffer::WritableSlice(contReadData)));
             ASSERT_FALSE(contSampleFrames.frameIndexRange().empty());
             ASSERT_LE(contSampleFrames.frameIndexRange(), readFrameIndexRange);
             ASSERT_EQ(contSampleFrames.frameIndexRange().start(), readFrameIndexRange.start());
@@ -379,7 +379,7 @@ TEST_F(SoundSourceProxyTest, skipAndRead) {
                     pSkipReadSource->readSampleFrames(
                             mixxx::WritableSampleFrames(
                                     readFrameIndexRange,
-                                    SampleBuffer::WritableSlice(skipReadData)));
+                                    mixxx::SampleBuffer::WritableSlice(skipReadData)));
 
             skipFrameIndex += skippedSampleFrames.frameIndexRange().length();
 
@@ -424,7 +424,7 @@ TEST_F(SoundSourceProxyTest, seekBoundaries) {
             // skip test file
             continue;
         }
-        SampleBuffer seekReadData(
+        mixxx::SampleBuffer seekReadData(
                 pSeekReadSource->frames2samples(kReadFrameCount));
 
         std::vector<SINT> seekFrameIndices;
@@ -464,20 +464,20 @@ TEST_F(SoundSourceProxyTest, seekBoundaries) {
                                     seekFrameIndex));
             ASSERT_TRUE(skipFrameIndexRange.empty() ||
                     (skipFrameIndexRange.end() == seekFrameIndex));
-            SampleBuffer contReadData(
+            mixxx::SampleBuffer contReadData(
                     pContReadSource->frames2samples(kReadFrameCount));
             const auto contSampleFrames =
                     pContReadSource->readSampleFrames(
                             mixxx::WritableSampleFrames(
                                     readFrameIndexRange,
-                                    SampleBuffer::WritableSlice(contReadData)));
+                                    mixxx::SampleBuffer::WritableSlice(contReadData)));
                     ASSERT_EQ(expectedFrameIndexRange, contSampleFrames.frameIndexRange());
 
             const auto seekSampleFrames =
                     pSeekReadSource->readSampleFrames(
                             mixxx::WritableSampleFrames(
                                     readFrameIndexRange,
-                                    SampleBuffer::WritableSlice(seekReadData)));
+                                    mixxx::SampleBuffer::WritableSlice(seekReadData)));
             ASSERT_EQ(expectedFrameIndexRange, seekSampleFrames.frameIndexRange());
 
             if (seekSampleFrames.frameIndexRange().empty()) {
@@ -531,13 +531,13 @@ TEST_F(SoundSourceProxyTest, readBeyondEnd) {
         ASSERT_LT(remainingFrames, kReadFrameCount);
 
         // Read beyond the end
-        SampleBuffer readBuffer(
+        mixxx::SampleBuffer readBuffer(
                 pAudioSource->frames2samples(kReadFrameCount));
         EXPECT_EQ(
                 mixxx::IndexRange::forward(seekIndex, remainingFrames),
                 pAudioSource->readSampleFrames(
                         mixxx::WritableSampleFrames(
                                 mixxx::IndexRange::forward(seekIndex, kReadFrameCount),
-                                SampleBuffer::WritableSlice(readBuffer))).frameIndexRange());
+                                mixxx::SampleBuffer::WritableSlice(readBuffer))).frameIndexRange());
     }
 }
diff --git a/src/util/readaheadsamplebuffer.cpp b/src/util/readaheadsamplebuffer.cpp
index 0095153597..aac36ec059 100644
--- a/src/util/readaheadsamplebuffer.cpp
+++ b/src/util/readaheadsamplebuffer.cpp
@@ -2,16 +2,20 @@
 
 #include "util/sample.h"
 
+
 #define DEBUG_ASSERT_CLASS_INVARIANT_ReadAheadSampleBuffer \
-    DEBUG_ASSERT(0 <= m_headOffset); \
-    DEBUG_ASSERT(m_headOffset <= m_tailOffset); \
-    DEBUG_ASSERT(m_tailOffset <= m_sampleBuffer.size()); \
-    DEBUG_ASSERT(!isEmpty() || (0 == m_headOffset)); \
-    DEBUG_ASSERT(!isEmpty() || (0 == m_tailOffset))
+    DEBUG_ASSERT(m_readableRange.orientation() != IndexRange::Orientation::Backward); \
+    DEBUG_ASSERT(0 <= m_readableRange.start()); \
+    DEBUG_ASSERT(m_readableRange.end() <= m_sampleBuffer.size()); \
+    DEBUG_ASSERT(!empty() || (0 == m_readableRange.start())); \
+    DEBUG_ASSERT(!empty() || (0 == m_readableRange.end()))
+
+
+namespace mixxx {
 
 ReadAheadSampleBuffer::ReadAheadSampleBuffer()
-    : m_headOffset(0),
-      m_tailOffset(0) {
+    : ReadAheadSampleBuffer(0),
+      m_readableRange(IndexRange::between(0, 0)) {
     
     DEBUG_ASSERT_CLASS_INVARIANT_ReadAheadSampleBuffer;
 }
@@ -119,3 +123,5 @@ SampleBuffer::ReadableSlice ReadAheadSampleBuffer::readFromHead(SINT size) {
     DEBUG_ASSERT_CLASS_INVARIANT_ReadAheadSampleBuffer;
     return headSlice;
 }
+
+} // namespace mixxx
diff --git a/src/util/readaheadsamplebuffer.h b/src/util/readaheadsamplebuffer.h
index e7ae286044..b46ef71b47 100644
--- a/src/util/readaheadsamplebuffer.h
+++ b/src/util/readaheadsamplebuffer.h
@@ -1,16 +1,17 @@
-#ifndef MIXXX_UTIL_SINGULARSAMPLEBUFFER_H
-#define MIXXX_UTIL_SINGULARSAMPLEBUFFER_H
+#ifndef MIXXX_UTIL_READAHEADSAMPLEBUFFER_H
+#define MIXXX_UTIL_READAHEADSAMPLEBUFFER_H
 
 #include "util/samplebuffer.h"
 
-// A singular FIFO/LIFO sample buffer with fixed capacity and range
-// checking.
-//
-// Common use case: Consume all buffered samples before the capacity
-// is exhausted.
+
+namespace mixxx {
+
+// A FIFO/LIFO sample buffer with fixed capacity and range checking.
+// It works best when consuming all buffered samples before writing
+// any new samples.
 //
-// This class is not thread-safe and not intended to be used from multiple
-// threads!
+// This class is not thread-safe and is not intended to be used from
+// multiple threads!
 class ReadAheadSampleBuffer {
   public:
     ReadAheadSampleBuffer();
@@ -90,4 +91,16 @@ class ReadAheadSampleBuffer {
     SINT m_tailOffset;
 };
 
-#endif // MIXXX_UTIL_SINGULARSAMPLEBUFFER_H
+} // namespace mixxx
+
+namespace std {
+    
+// Template specialization of std::swap() for ReadAheadSampleBuffer
+template<>
+inline void swap(::mixxx::ReadAheadSampleBuffer& lhs, ::mixxx::ReadAheadSampleBuffer& rhs) {
+    lhs.swap(rhs);
+}
+
+}  // namespace std
+
+#endif // MIXXX_UTIL_READAHEADSAMPLEBUFFER_H
diff --git a/src/util/samplebuffer.cpp b/src/util/samplebuffer.cpp
index 5f94f0f36f..8b4167411c 100644
--- a/src/util/samplebuffer.cpp
+++ b/src/util/samplebuffer.cpp
@@ -2,6 +2,9 @@
 
 #include "util/sample.h"
 
+
+namespace mixxx {
+
 SampleBuffer::SampleBuffer(SINT size)
         : m_data((size > 0) ? SampleUtil::alloc(size) : nullptr),
           m_size((m_data != nullptr) ? size : 0) {
@@ -19,3 +22,5 @@ void SampleBuffer::clear() {
 void SampleBuffer::fill(CSAMPLE value) {
     SampleUtil::fill(data(), value, size());
 }
+
+} // namespace mixxx
diff --git a/src/util/samplebuffer.h b/src/util/samplebuffer.h
index 4c23241156..379f8c47be 100644
--- a/src/util/samplebuffer.h
+++ b/src/util/samplebuffer.h
@@ -5,9 +5,13 @@
 
 #include "util/types.h"
 
+
+namespace mixxx {
+
 // A sample buffer with properly aligned memory to enable SSE optimizations.
 // After construction the content of the buffer is uninitialized. No resize
-// operation is provided intentionally because malloc might block!
+// operation is provided intentionally because malloc might block! Copying
+// has intentionally been disabled, because it should not be needed.
 //
 // Hint: If the size of an existing sample buffer ever needs to be altered
 // after construction this can simply be achieved by swapping the contents
@@ -174,11 +178,13 @@ class SampleBuffer {
     SINT m_size;
 };
 
+} // namespace mixxx
+
 namespace std {
 
-// Template specialization of std::swap for SampleBuffer.
+// Template specialization of std::swap() for SampleBuffer
 template<>
-inline void swap(SampleBuffer& lhs, SampleBuffer& rhs) {
+inline void swap(::mixxx::SampleBuffer& lhs, ::mixxx::SampleBuffer& rhs) {
     lhs.swap(rhs);
 }