RingDelayBuffer: ring buffer for delay handling

CMakeLists.txt

@@ -937,6 +937,7 @@ add_library(mixxx-lib STATIC EXCLUDE_FROM_ALL
   src/util/performancetimer.cpp
   src/util/rangelist.cpp
   src/util/readaheadsamplebuffer.cpp
+  src/util/ringdelaybuffer.cpp
   src/util/rotary.cpp
   src/util/runtimeloggingcategory.cpp
   src/util/sample.cpp
@@ -1682,6 +1683,7 @@ add_executable(mixxx-test
   src/test/replaygaintest.cpp
   src/test/rescalertest.cpp
   src/test/rgbcolor_test.cpp
+  src/test/ringdelaybuffer_test.cpp
   src/test/samplebuffertest.cpp
   src/test/sampleutiltest.cpp
   src/test/schemamanager_test.cpp

src/test/ringdelaybuffer_test.cpp

@@ -0,0 +1,151 @@
+// Tests for ringdelaybuffer.h
+
+#include "util/ringdelaybuffer.h"
+
+#include <benchmark/benchmark.h>
+#include <gtest/gtest.h>
+
+#include <QTest>
+
+#include "test/mixxxtest.h"
+#include "util/sample.h"
+#include "util/samplebuffer.h"
+#include "util/types.h"
+
+namespace {
+
+class RingDelayBufferTest : public MixxxTest {
+  protected:
+    void SetUp() override {
+        m_pRingDelayBuffer = std::make_unique<RingDelayBuffer>(m_ringDelayBufferSize);
+    }
+
+    void TearDown() override {
+    }
+
+    void AssertIdenticalBufferEquals(const CSAMPLE* pBuffer,
+            int iBufferLen,
+            const CSAMPLE* pReferenceBuffer,
+            int iReferenceBufferLength) {
+        EXPECT_EQ(iBufferLen, iReferenceBufferLength);
+
+        for (int i = 0; i < iBufferLen; ++i) {
+            EXPECT_FLOAT_EQ(pBuffer[i], pReferenceBuffer[i]);
+        }
+    }
+
+    std::unique_ptr<RingDelayBuffer> m_pRingDelayBuffer;
+    const SINT m_ringDelayBufferSize = 8;
+};
+
+TEST_F(RingDelayBufferTest, ReadWriteNoDelayTest) {
+    const SINT numSamplesHalf = 2;
+    const SINT numSamples = 4;
+    const CSAMPLE inputBuffer[] = {-100.0, 100.0, -99.0, 99.0};
+    const CSAMPLE inputBufferHalf[] = {-98.0, 98.0};
+    const CSAMPLE firstExpectedResult[] = {-50.0, 50.0, -99.0, 99.0};
+    const CSAMPLE secondExpectedResult[] = {-99.0, 99.0, -98.0, 98.0};
+    const CSAMPLE thirdExpectedResult[] = {-100.0, 100.0, -99.0, 99.0};
+
+    mixxx::SampleBuffer output(numSamples);
+
+    EXPECT_EQ(m_pRingDelayBuffer->write(inputBuffer, numSamples), numSamples);
+    EXPECT_EQ(m_pRingDelayBuffer->read(output.data(), numSamples, 0), numSamples);
+
+    AssertIdenticalBufferEquals(output.data(),
+            numSamples,
+            firstExpectedResult,
+            numSamples);
+
+    EXPECT_EQ(m_pRingDelayBuffer->write(inputBufferHalf, numSamplesHalf), numSamplesHalf);
+    EXPECT_EQ(m_pRingDelayBuffer->read(output.data(), numSamples, 0), numSamples);
+
+    AssertIdenticalBufferEquals(output.data(), numSamples, secondExpectedResult, numSamples);
+
+    // Write and read over one ring.
+    EXPECT_EQ(m_pRingDelayBuffer->write(inputBuffer, numSamples), numSamples);
+    EXPECT_EQ(m_pRingDelayBuffer->read(output.data(), numSamples, 0), numSamples);
+
+    AssertIdenticalBufferEquals(output.data(), numSamples, thirdExpectedResult, numSamples);
+}
+
+TEST_F(RingDelayBufferTest, ReadWriteDelayTest) {
+    const SINT numSamples = 4;
+    const SINT firstDelaySize = 2;
+    const SINT secondDelaySize = 4;
+    const CSAMPLE inputBuffer[] = {-100.0, 100.0, -99.0, 99.0};
+    const CSAMPLE firstExpectedResult[] = {-50.0, 50.0, -99.0, 99.0};
+    const CSAMPLE secondExpectedResult[] = {0.0, 0.0, -50.0, 50.0};
+    const CSAMPLE thirdExpectedResult[] = {-50.0, 50.0, -99.0, 99.0};
+
+    mixxx::SampleBuffer output(numSamples);
+
+    // Read without delay.
+    EXPECT_EQ(m_pRingDelayBuffer->write(inputBuffer, numSamples), numSamples);
+    EXPECT_EQ(m_pRingDelayBuffer->read(output.data(), numSamples, 0), numSamples);
+
+    AssertIdenticalBufferEquals(output.data(), numSamples, firstExpectedResult, numSamples);
+
+    // Read with delay.
+    EXPECT_EQ(m_pRingDelayBuffer->read(output.data(), numSamples, firstDelaySize), numSamples);
+
+    AssertIdenticalBufferEquals(output.data(), numSamples, secondExpectedResult, numSamples);
+
+    // Fill the second half of the delay buffer with the first input data.
+    EXPECT_EQ(m_pRingDelayBuffer->write(inputBuffer, numSamples), numSamples);
+
+    // Read with delay (not circle around).
+    EXPECT_EQ(m_pRingDelayBuffer->read(output.data(), numSamples, secondDelaySize), numSamples);
+
+    AssertIdenticalBufferEquals(output.data(), numSamples, thirdExpectedResult, numSamples);
+}
+
+static void BM_WriteReadWholeBufferNoDelay(benchmark::State& state) {
+    const SINT ringDelayBufferSize = static_cast<SINT>(state.range(0));
+    const SINT numSamples = ringDelayBufferSize / 2;
+
+    RingDelayBuffer m_ringDelayBuffer(ringDelayBufferSize);
+
+    mixxx::SampleBuffer input(numSamples);
+    mixxx::SampleBuffer output(numSamples);
+
+    SampleUtil::fill(input.data(), 0.0f, numSamples);
+
+    for (auto _ : state) {
+        state.PauseTiming();
+        m_ringDelayBuffer.clear();
+        state.ResumeTiming();
+
+        m_ringDelayBuffer.write(input.data(), numSamples);
+        m_ringDelayBuffer.read(output.data(), numSamples, 0);
+        m_ringDelayBuffer.write(input.data(), numSamples);
+        m_ringDelayBuffer.read(output.data(), numSamples, 0);
+    }
+}
+BENCHMARK(BM_WriteReadWholeBufferNoDelay)->Range(64, 4 << 10);
+
+static void BM_WriteReadWholeBufferDelay(benchmark::State& state) {
+    const SINT ringDelayBufferSize = static_cast<SINT>(state.range(0));
+    const SINT numSamples = ringDelayBufferSize / 2;
+    const SINT delaySize = numSamples;
+
+    RingDelayBuffer m_ringDelayBuffer(ringDelayBufferSize);
+
+    mixxx::SampleBuffer input(numSamples);
+    mixxx::SampleBuffer output(numSamples);
+
+    SampleUtil::fill(input.data(), 0.0f, numSamples);
+
+    for (auto _ : state) {
+        state.PauseTiming();
+        m_ringDelayBuffer.clear();
+        state.ResumeTiming();
+
+        m_ringDelayBuffer.write(input.data(), numSamples);
+        m_ringDelayBuffer.read(output.data(), numSamples, delaySize);
+        m_ringDelayBuffer.write(input.data(), numSamples);
+        m_ringDelayBuffer.read(output.data(), numSamples, delaySize);
+    }
+}
+BENCHMARK(BM_WriteReadWholeBufferDelay)->Range(64, 4 << 10);
+} // namespace

src/util/ringdelaybuffer.cpp

@@ -0,0 +1,158 @@
+/*
+* $Id$
+* Portable Audio I/O Library
+* Ring Buffer utility.
+*
+* Author: Phil Burk, http://www.softsynth.com
+* modified for SMP safety on OS X by Bjorn Roche.
+* also allowed for const where possible.
+* modified for multiple-byte-sized data elements by Sven Fischer
+*
+* This program is distributed with the PortAudio Portable Audio Library.
+* For more information see: http://www.portaudio.com
+* Copyright (c) 1999-2000 Ross Bencina and Phil Burk
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files
+* (the "Software"), to deal in the Software without restriction,
+* including without limitation the rights to use, copy, modify, merge,
+* publish, distribute, sublicense, and/or sell copies of the Software,
+* and to permit persons to whom the Software is furnished to do so,
+* subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/*
+* The text above constitutes the entire PortAudio license; however,
+* the PortAudio community also makes the following non-binding requests:
+*
+* Any person wishing to distribute modifications to the Software is
+* requested to send the modifications to the original developer so that
+* they can be incorporated into the canonical version. It is also
+* requested that these non-binding requests be included along with the
+* license above.
+*/
+
+#include "ringdelaybuffer.h"
+
+#include "util/math.h"
+#include "util/sample.h"
+
+using ReadableSlice = mixxx::SampleBuffer::ReadableSlice;
+using WritableSlice = mixxx::SampleBuffer::WritableSlice;
+
+namespace {
+SINT copyRing(const ReadableSlice pSourceBuffer,
+        SINT sourcePos,
+        const WritableSlice pDestBuffer,
+        SINT destPos,
+        const SINT numItems) {
+    const SINT newSourcePos = sourcePos + numItems;
+    const SINT newDestPos = destPos + numItems;
+
+    VERIFY_OR_DEBUG_ASSERT(newSourcePos <= pSourceBuffer.length() ||
+            newDestPos <= pDestBuffer.length()) {
+        return 0;
+    }
+
+    // Check to see if the copy is not contiguous.
+    if (newSourcePos > pSourceBuffer.length() ||
+            newDestPos > pDestBuffer.length()) {
+        // Copy is not contiguous.
+        SINT firstDataBlockSize = math_min(pSourceBuffer.length() - sourcePos,
+                pDestBuffer.length() - destPos);
+
+        SampleUtil::copy(pDestBuffer.data(destPos),
+                pSourceBuffer.data(sourcePos),
+                firstDataBlockSize);
+
+        sourcePos = (sourcePos + firstDataBlockSize) % pSourceBuffer.length();
+        destPos = (destPos + firstDataBlockSize) % pDestBuffer.length();
+
+        // The second data part is the start of the ring buffer.
+        SampleUtil::copy(pDestBuffer.data(destPos),
+                pSourceBuffer.data(sourcePos),
+                numItems - firstDataBlockSize);
+    } else {
+        // Copy is contiguous.
+        SampleUtil::copy(pDestBuffer.data(destPos),
+                pSourceBuffer.data(sourcePos),
+                numItems);
+    }
+
+    return numItems;
+}
+
+} // anonymous namespace
+
+RingDelayBuffer::RingDelayBuffer(SINT bufferSize)
+        : m_firstInputBuffer(true),
+          m_writePos(0),
+          m_buffer(bufferSize) {
+    // Set the ring delay buffer items to 0.
+    m_buffer.fill(0);
+}
+
+SINT RingDelayBuffer::read(CSAMPLE* pBuffer, const SINT itemsToRead, const SINT delayItems) {
+    const SINT shift = itemsToRead + delayItems;
+
+    VERIFY_OR_DEBUG_ASSERT(shift <= m_buffer.size()) {
+        return 0;
+    }
+
+    SINT readPos = m_writePos - shift;
+
+    if (readPos < 0) {
+        readPos = readPos + m_buffer.size();
+    }
+
+    return copyRing(ReadableSlice(m_buffer.data(), m_buffer.size()),
+            readPos,
+            WritableSlice(pBuffer, itemsToRead),
+            0,
+            itemsToRead);
+}
+
+SINT RingDelayBuffer::write(const CSAMPLE* pBuffer, const SINT itemsToWrite) {
+    VERIFY_OR_DEBUG_ASSERT(itemsToWrite <= m_buffer.size()) {
+        return 0;
+    }
+
+    SINT copiedItems;
+    if (m_firstInputBuffer) {
+        // If the first input buffer is written, the first sample is on the index 0.
+        // Based on the checking of an available number of samples, the situation,
+        // that the writing will be non-contiguous cannot occur.
+        // The itemsToWrite value is multiply by 2 to
+        SampleUtil::copyWithRampingGain(m_buffer.data(), pBuffer, 0.0f, 1.0f, itemsToWrite);
+        m_firstInputBuffer = false;
+        copiedItems = itemsToWrite;
+    } else {
+        copiedItems = copyRing(ReadableSlice(pBuffer, itemsToWrite),
+                0,
+                WritableSlice(m_buffer.data(), m_buffer.size()),
+                m_writePos,
+                itemsToWrite);
+    }
+
+    // Calculate the new write position. If the new write position
+    // is after the ring delay buffer end, move it around from the start
+    // of the ring delay buffer.
+    m_writePos = (m_writePos + copiedItems);
+
+    if (m_writePos >= m_buffer.size()) {
+        m_writePos = m_writePos - m_buffer.size();
+    }
+
+    return copiedItems;
+}