From 503d365869da4828b7e7d7c39779db33808f98f1 Mon Sep 17 00:00:00 2001 From: Paul Ferrand Date: Mon, 23 Sep 2019 10:23:24 +0200 Subject: [PATCH 1/2] Added back the `inline static` for cpp >= 17 --- sfizz/LeakDetector.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sfizz/LeakDetector.h b/sfizz/LeakDetector.h index 21f737d3..659d9033 100644 --- a/sfizz/LeakDetector.h +++ b/sfizz/LeakDetector.h @@ -60,7 +60,7 @@ private: }; std::atomic count { 0 }; }; - static ObjectCounter objectCounter; + inline static ObjectCounter objectCounter; }; #ifndef NDEBUG @@ -74,4 +74,4 @@ private: #else #define LEAK_DETECTOR(Class) -#endif \ No newline at end of file +#endif From d3280b5a2929b5125fb12fb061004080d281f047 Mon Sep 17 00:00:00 2001 From: paulfd Date: Wed, 25 Sep 2019 23:48:52 +0200 Subject: [PATCH 2/2] Moved everyone into the sfz namespace to avoid clashing when importing the lib --- benchmarks/BM_add.cpp | 16 +- benchmarks/BM_copy.cpp | 8 +- benchmarks/BM_cumsum.cpp | 8 +- benchmarks/BM_diff.cpp | 10 +- benchmarks/BM_fill.cpp | 18 +- benchmarks/BM_gain.cpp | 12 +- benchmarks/BM_interpolationCast.cpp | 8 +- benchmarks/BM_looping.cpp | 8 +- benchmarks/BM_mathfuns.cpp | 20 +- benchmarks/BM_mean.cpp | 8 +- benchmarks/BM_meanSquared.cpp | 8 +- benchmarks/BM_multiplyAdd.cpp | 8 +- benchmarks/BM_pan.cpp | 18 +- benchmarks/BM_pointerIterationOrOffsets.cpp | 4 +- benchmarks/BM_ramp.cpp | 34 ++-- benchmarks/BM_readInterleaved.cpp | 48 ++--- benchmarks/BM_saturating.cpp | 8 +- benchmarks/BM_subtract.cpp | 8 +- benchmarks/BM_writeInterleaved.cpp | 48 ++--- sfizz/ADSREnvelope.cpp | 16 +- sfizz/AudioBuffer.h | 6 +- sfizz/AudioSpan.h | 17 +- sfizz/Buffer.h | 4 + sfizz/Config.h | 4 +- sfizz/FilePool.cpp | 10 +- sfizz/HistoricalBuffer.h | 7 +- sfizz/LinearEnvelope.cpp | 4 +- sfizz/OnePoleFilter.h | 5 +- sfizz/SIMDDummy.cpp | 50 ++--- sfizz/SIMDHelpers.h | 6 +- sfizz/SIMDSSE.cpp | 50 ++--- sfizz/StereoBuffer.h | 186 ----------------- sfizz/StereoSpan.h | 189 ------------------ sfizz/Voice.cpp | 90 ++++----- tests/AudioBufferT.cpp | 30 +-- tests/BufferT.cpp | 30 +-- tests/CMakeLists.txt | 1 - tests/OnePoleFilterT.cpp | 4 +- tests/SIMDHelpersT.cpp | 160 +++++++-------- tests/StereoBufferT.cpp | 208 -------------------- 40 files changed, 407 insertions(+), 970 deletions(-) delete mode 100644 sfizz/StereoBuffer.h delete mode 100644 sfizz/StereoSpan.h delete mode 100644 tests/StereoBufferT.cpp diff --git a/benchmarks/BM_add.cpp b/benchmarks/BM_add.cpp index 8221e997..b65f076c 100644 --- a/benchmarks/BM_add.cpp +++ b/benchmarks/BM_add.cpp @@ -52,56 +52,56 @@ public: BENCHMARK_DEFINE_F(AddArray, Value_Scalar)(benchmark::State& state) { for (auto _ : state) { - add(1.1f, absl::MakeSpan(output)); + sfz::add(1.1f, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(AddArray, Value_SIMD)(benchmark::State& state) { for (auto _ : state) { - add(1.1f, absl::MakeSpan(output)); + sfz::add(1.1f, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(AddArray, Value_Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - add(1.1f, absl::MakeSpan(output).subspan(1)); + sfz::add(1.1f, absl::MakeSpan(output).subspan(1)); } } BENCHMARK_DEFINE_F(AddArray, Value_SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - add(1.1f, absl::MakeSpan(output).subspan(1)); + sfz::add(1.1f, absl::MakeSpan(output).subspan(1)); } } BENCHMARK_DEFINE_F(AddArray, Scalar)(benchmark::State& state) { for (auto _ : state) { - add(input, absl::MakeSpan(output)); + sfz::add(input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(AddArray, SIMD)(benchmark::State& state) { for (auto _ : state) { - add(input, absl::MakeSpan(output)); + sfz::add(input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(AddArray, Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - add(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::add(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } BENCHMARK_DEFINE_F(AddArray, SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - add(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::add(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } diff --git a/benchmarks/BM_copy.cpp b/benchmarks/BM_copy.cpp index 31399d9e..7d612e9c 100644 --- a/benchmarks/BM_copy.cpp +++ b/benchmarks/BM_copy.cpp @@ -60,14 +60,14 @@ BENCHMARK_DEFINE_F(CopyArray, StdCopy)(benchmark::State& state) { BENCHMARK_DEFINE_F(CopyArray, Scalar)(benchmark::State& state) { for (auto _ : state) { - copy(input, absl::MakeSpan(output)); + sfz::copy(input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(CopyArray, SIMD)(benchmark::State& state) { for (auto _ : state) { - copy(input, absl::MakeSpan(output)); + sfz::copy(input, absl::MakeSpan(output)); } } @@ -81,14 +81,14 @@ BENCHMARK_DEFINE_F(CopyArray, StdCopy_Unaligned)(benchmark::State& state) { BENCHMARK_DEFINE_F(CopyArray, Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - copy(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::copy(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } BENCHMARK_DEFINE_F(CopyArray, SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - copy(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::copy(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } diff --git a/benchmarks/BM_cumsum.cpp b/benchmarks/BM_cumsum.cpp index b91afe0e..9407e6e1 100644 --- a/benchmarks/BM_cumsum.cpp +++ b/benchmarks/BM_cumsum.cpp @@ -52,28 +52,28 @@ public: BENCHMARK_DEFINE_F(CumArray, Sum_Scalar)(benchmark::State& state) { for (auto _ : state) { - cumsum(input, absl::MakeSpan(output)); + sfz::cumsum(input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(CumArray, Sum_SIMD)(benchmark::State& state) { for (auto _ : state) { - cumsum(input, absl::MakeSpan(output)); + sfz::cumsum(input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(CumArray, Sum_Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - cumsum(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::cumsum(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } BENCHMARK_DEFINE_F(CumArray, Sum_SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - cumsum(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::cumsum(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } diff --git a/benchmarks/BM_diff.cpp b/benchmarks/BM_diff.cpp index ea7e6fdf..bacfe5f7 100644 --- a/benchmarks/BM_diff.cpp +++ b/benchmarks/BM_diff.cpp @@ -39,7 +39,7 @@ public: input = std::vector(state.range(0)); output = std::vector(state.range(0)); std::generate(input.begin(), input.end(), [&]() { return dist(gen); }); - cumsum(input, absl::MakeSpan(input)); + sfz::cumsum(input, absl::MakeSpan(input)); } void TearDown(const ::benchmark::State& state [[maybe_unused]]) { @@ -54,28 +54,28 @@ public: BENCHMARK_DEFINE_F(DiffArray, Diff_Scalar)(benchmark::State& state) { for (auto _ : state) { - diff(input, absl::MakeSpan(output)); + sfz::diff(input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(DiffArray, Diff_SIMD)(benchmark::State& state) { for (auto _ : state) { - diff(input, absl::MakeSpan(output)); + sfz::diff(input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(DiffArray, Diff_Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - diff(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::diff(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } BENCHMARK_DEFINE_F(DiffArray, Diff_SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - diff(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::diff(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } diff --git a/benchmarks/BM_fill.cpp b/benchmarks/BM_fill.cpp index 41f5c87a..a437531e 100644 --- a/benchmarks/BM_fill.cpp +++ b/benchmarks/BM_fill.cpp @@ -29,7 +29,7 @@ #include static void Dummy(benchmark::State& state) { - Buffer buffer (state.range(0)); + sfz::Buffer buffer (state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; @@ -40,42 +40,42 @@ static void Dummy(benchmark::State& state) { } static void FillScalar(benchmark::State& state) { - Buffer buffer (state.range(0)); + sfz::Buffer buffer (state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { - fill(absl::MakeSpan(buffer), dist(gen)); + sfz::fill(absl::MakeSpan(buffer), dist(gen)); } } static void FillScalar_unaligned(benchmark::State& state) { - Buffer buffer (state.range(0)); + sfz::Buffer buffer (state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { - fill(absl::MakeSpan(buffer).subspan(1), dist(gen)); + sfz::fill(absl::MakeSpan(buffer).subspan(1), dist(gen)); } } static void FillSIMD(benchmark::State& state) { - Buffer buffer (state.range(0)); + sfz::Buffer buffer (state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { - fill(absl::MakeSpan(buffer), dist(gen)); + sfz::fill(absl::MakeSpan(buffer), dist(gen)); } } static void FillSIMD_unaligned(benchmark::State& state) { - Buffer buffer (state.range(0)); + sfz::Buffer buffer (state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { - fill(absl::MakeSpan(buffer).subspan(1), dist(gen)); + sfz::fill(absl::MakeSpan(buffer).subspan(1), dist(gen)); } } diff --git a/benchmarks/BM_gain.cpp b/benchmarks/BM_gain.cpp index e59c7cef..f5385eaa 100644 --- a/benchmarks/BM_gain.cpp +++ b/benchmarks/BM_gain.cpp @@ -83,14 +83,14 @@ BENCHMARK_DEFINE_F(GainSingle, Straight)(benchmark::State& state) { BENCHMARK_DEFINE_F(GainSingle, Scalar)(benchmark::State& state) { for (auto _ : state) { - applyGain(gain, input, absl::MakeSpan(output)); + sfz::applyGain(gain, input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(GainSingle, SIMD)(benchmark::State& state) { for (auto _ : state) { - applyGain(gain, input, absl::MakeSpan(output)); + sfz::applyGain(gain, input, absl::MakeSpan(output)); } } @@ -105,28 +105,28 @@ BENCHMARK_DEFINE_F(GainArray, Straight)(benchmark::State& state) { BENCHMARK_DEFINE_F(GainArray, Scalar)(benchmark::State& state) { for (auto _ : state) { - applyGain(gain, input, absl::MakeSpan(output)); + sfz::applyGain(gain, input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(GainArray, SIMD)(benchmark::State& state) { for (auto _ : state) { - applyGain(gain, input, absl::MakeSpan(output)); + sfz::applyGain(gain, input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(GainArray, Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - applyGain(absl::MakeSpan(gain).subspan(1), absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::applyGain(absl::MakeSpan(gain).subspan(1), absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } BENCHMARK_DEFINE_F(GainArray, SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - applyGain(absl::MakeSpan(gain).subspan(1), absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::applyGain(absl::MakeSpan(gain).subspan(1), absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } diff --git a/benchmarks/BM_interpolationCast.cpp b/benchmarks/BM_interpolationCast.cpp index 0910a200..2411cadd 100644 --- a/benchmarks/BM_interpolationCast.cpp +++ b/benchmarks/BM_interpolationCast.cpp @@ -59,28 +59,28 @@ public: BENCHMARK_DEFINE_F(InterpolationCast, Scalar)(benchmark::State& state) { for (auto _ : state) { - sfzInterpolationCast(floatJumps, absl::MakeSpan(jumps), absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs)); + sfz::sfzInterpolationCast(floatJumps, absl::MakeSpan(jumps), absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs)); } } BENCHMARK_DEFINE_F(InterpolationCast, SIMD)(benchmark::State& state) { for (auto _ : state) { - sfzInterpolationCast(floatJumps, absl::MakeSpan(jumps), absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs)); + sfz::sfzInterpolationCast(floatJumps, absl::MakeSpan(jumps), absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs)); } } BENCHMARK_DEFINE_F(InterpolationCast, Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - sfzInterpolationCast(absl::MakeSpan(floatJumps).subspan(1), absl::MakeSpan(jumps).subspan(3), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1)); + sfz::sfzInterpolationCast(absl::MakeSpan(floatJumps).subspan(1), absl::MakeSpan(jumps).subspan(3), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1)); } } BENCHMARK_DEFINE_F(InterpolationCast, SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - sfzInterpolationCast(absl::MakeSpan(floatJumps).subspan(1), absl::MakeSpan(jumps).subspan(3), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1)); + sfz::sfzInterpolationCast(absl::MakeSpan(floatJumps).subspan(1), absl::MakeSpan(jumps).subspan(3), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1)); } } diff --git a/benchmarks/BM_looping.cpp b/benchmarks/BM_looping.cpp index 3a281833..4e1ba5e5 100644 --- a/benchmarks/BM_looping.cpp +++ b/benchmarks/BM_looping.cpp @@ -61,28 +61,28 @@ public: BENCHMARK_DEFINE_F(LoopingFixture, Scalar)(benchmark::State& state) { for (auto _ : state) { - loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 2.5f, loopEnd, loopStart); + sfz::loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 2.5f, loopEnd, loopStart); } } BENCHMARK_DEFINE_F(LoopingFixture, SIMD)(benchmark::State& state) { for (auto _ : state) { - loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 2.5f, loopEnd, loopStart); + sfz::loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 2.5f, loopEnd, loopStart); } } BENCHMARK_DEFINE_F(LoopingFixture, Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - loopingSFZIndex(absl::MakeSpan(jumps).subspan(1), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1), absl::MakeSpan(indices).subspan(3), 2.5f, loopEnd, loopStart); + sfz::loopingSFZIndex(absl::MakeSpan(jumps).subspan(1), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1), absl::MakeSpan(indices).subspan(3), 2.5f, loopEnd, loopStart); } } BENCHMARK_DEFINE_F(LoopingFixture, SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - loopingSFZIndex(absl::MakeSpan(jumps).subspan(1), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1), absl::MakeSpan(indices).subspan(3), 2.5f, loopEnd, loopStart); + sfz::loopingSFZIndex(absl::MakeSpan(jumps).subspan(1), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1), absl::MakeSpan(indices).subspan(3), 2.5f, loopEnd, loopStart); } } diff --git a/benchmarks/BM_mathfuns.cpp b/benchmarks/BM_mathfuns.cpp index df533384..08e9a50e 100644 --- a/benchmarks/BM_mathfuns.cpp +++ b/benchmarks/BM_mathfuns.cpp @@ -64,7 +64,7 @@ BENCHMARK_DEFINE_F(MyFixture, ScalarExp) (benchmark::State& state) { for (auto _ : state) { - exp(source, absl::MakeSpan(result)); + sfz::exp(source, absl::MakeSpan(result)); benchmark::DoNotOptimize(result); } } @@ -73,7 +73,7 @@ BENCHMARK_DEFINE_F(MyFixture, SIMDExp) (benchmark::State& state) { for (auto _ : state) { - exp(source, absl::MakeSpan(result)); + sfz::exp(source, absl::MakeSpan(result)); benchmark::DoNotOptimize(result); } } @@ -82,7 +82,7 @@ BENCHMARK_DEFINE_F(MyFixture, ScalarExp_Unaligned) (benchmark::State& state) { for (auto _ : state) { - exp(absl::MakeSpan(source).subspan(1), absl::MakeSpan(result).subspan(1)); + sfz::exp(absl::MakeSpan(source).subspan(1), absl::MakeSpan(result).subspan(1)); benchmark::DoNotOptimize(result); } } @@ -91,7 +91,7 @@ BENCHMARK_DEFINE_F(MyFixture, SIMDExp_Unaligned) (benchmark::State& state) { for (auto _ : state) { - exp(absl::MakeSpan(source).subspan(1), absl::MakeSpan(result).subspan(1)); + sfz::exp(absl::MakeSpan(source).subspan(1), absl::MakeSpan(result).subspan(1)); benchmark::DoNotOptimize(result); } } @@ -100,7 +100,7 @@ BENCHMARK_DEFINE_F(MyFixture, ScalarLog) (benchmark::State& state) { for (auto _ : state) { - log(source, absl::MakeSpan(result)); + sfz::log(source, absl::MakeSpan(result)); benchmark::DoNotOptimize(result); } } @@ -109,7 +109,7 @@ BENCHMARK_DEFINE_F(MyFixture, SIMDLog) (benchmark::State& state) { for (auto _ : state) { - log(source, absl::MakeSpan(result)); + sfz::log(source, absl::MakeSpan(result)); benchmark::DoNotOptimize(result); } } @@ -118,7 +118,7 @@ BENCHMARK_DEFINE_F(MyFixture, ScalarSin) (benchmark::State& state) { for (auto _ : state) { - sin(source, absl::MakeSpan(result)); + sfz::sin(source, absl::MakeSpan(result)); benchmark::DoNotOptimize(result); } } @@ -127,7 +127,7 @@ BENCHMARK_DEFINE_F(MyFixture, SIMDSin) (benchmark::State& state) { for (auto _ : state) { - sin(source, absl::MakeSpan(result)); + sfz::sin(source, absl::MakeSpan(result)); benchmark::DoNotOptimize(result); } } @@ -136,7 +136,7 @@ BENCHMARK_DEFINE_F(MyFixture, ScalarCos) (benchmark::State& state) { for (auto _ : state) { - cos(source, absl::MakeSpan(result)); + sfz::cos(source, absl::MakeSpan(result)); benchmark::DoNotOptimize(result); } } @@ -145,7 +145,7 @@ BENCHMARK_DEFINE_F(MyFixture, SIMDCos) (benchmark::State& state) { for (auto _ : state) { - cos(source, absl::MakeSpan(result)); + sfz::cos(source, absl::MakeSpan(result)); benchmark::DoNotOptimize(result); } } diff --git a/benchmarks/BM_mean.cpp b/benchmarks/BM_mean.cpp index 12fc22ce..7a457842 100644 --- a/benchmarks/BM_mean.cpp +++ b/benchmarks/BM_mean.cpp @@ -51,7 +51,7 @@ BENCHMARK_DEFINE_F(MeanArray, Scalar) (benchmark::State& state) { for (auto _ : state) { - auto result = mean(input); + auto result = sfz::mean(input); benchmark::DoNotOptimize(result); } } @@ -60,7 +60,7 @@ BENCHMARK_DEFINE_F(MeanArray, SIMD) (benchmark::State& state) { for (auto _ : state) { - auto result = mean(input); + auto result = sfz::mean(input); benchmark::DoNotOptimize(result); } } @@ -69,7 +69,7 @@ BENCHMARK_DEFINE_F(MeanArray, Scalar_Unaligned) (benchmark::State& state) { for (auto _ : state) { - auto result = mean(absl::MakeSpan(input).subspan(1)); + auto result = sfz::mean(absl::MakeSpan(input).subspan(1)); benchmark::DoNotOptimize(result); } } @@ -78,7 +78,7 @@ BENCHMARK_DEFINE_F(MeanArray, SIMD_Unaligned) (benchmark::State& state) { for (auto _ : state) { - auto result = mean(absl::MakeSpan(input).subspan(1)); + auto result = sfz::mean(absl::MakeSpan(input).subspan(1)); benchmark::DoNotOptimize(result); } } diff --git a/benchmarks/BM_meanSquared.cpp b/benchmarks/BM_meanSquared.cpp index 0e5999cb..a207f528 100644 --- a/benchmarks/BM_meanSquared.cpp +++ b/benchmarks/BM_meanSquared.cpp @@ -51,7 +51,7 @@ BENCHMARK_DEFINE_F(MeanSquaredArray, Scalar) (benchmark::State& state) { for (auto _ : state) { - auto result = meanSquared(input); + auto result = sfz::meanSquared(input); benchmark::DoNotOptimize(result); } } @@ -60,7 +60,7 @@ BENCHMARK_DEFINE_F(MeanSquaredArray, SIMD) (benchmark::State& state) { for (auto _ : state) { - auto result = meanSquared(input); + auto result = sfz::meanSquared(input); benchmark::DoNotOptimize(result); } } @@ -69,7 +69,7 @@ BENCHMARK_DEFINE_F(MeanSquaredArray, Scalar_Unaligned) (benchmark::State& state) { for (auto _ : state) { - auto result = meanSquared(absl::MakeSpan(input).subspan(1)); + auto result = sfz::meanSquared(absl::MakeSpan(input).subspan(1)); benchmark::DoNotOptimize(result); } } @@ -78,7 +78,7 @@ BENCHMARK_DEFINE_F(MeanSquaredArray, SIMD_Unaligned) (benchmark::State& state) { for (auto _ : state) { - auto result = meanSquared(absl::MakeSpan(input).subspan(1)); + auto result = sfz::meanSquared(absl::MakeSpan(input).subspan(1)); benchmark::DoNotOptimize(result); } } diff --git a/benchmarks/BM_multiplyAdd.cpp b/benchmarks/BM_multiplyAdd.cpp index 4fea543e..218d98ad 100644 --- a/benchmarks/BM_multiplyAdd.cpp +++ b/benchmarks/BM_multiplyAdd.cpp @@ -63,28 +63,28 @@ BENCHMARK_DEFINE_F(MultiplyAdd, Straight)(benchmark::State& state) { BENCHMARK_DEFINE_F(MultiplyAdd, Scalar)(benchmark::State& state) { for (auto _ : state) { - multiplyAdd(gain, input, absl::MakeSpan(output)); + sfz::multiplyAdd(gain, input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(MultiplyAdd, SIMD)(benchmark::State& state) { for (auto _ : state) { - multiplyAdd(gain, input, absl::MakeSpan(output)); + sfz::multiplyAdd(gain, input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(MultiplyAdd, Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - multiplyAdd(absl::MakeSpan(gain).subspan(1), absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::multiplyAdd(absl::MakeSpan(gain).subspan(1), absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } BENCHMARK_DEFINE_F(MultiplyAdd, SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - multiplyAdd(absl::MakeSpan(gain).subspan(1), absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::multiplyAdd(absl::MakeSpan(gain).subspan(1), absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } diff --git a/benchmarks/BM_pan.cpp b/benchmarks/BM_pan.cpp index 4530d4e7..5792b476 100644 --- a/benchmarks/BM_pan.cpp +++ b/benchmarks/BM_pan.cpp @@ -66,27 +66,27 @@ public: BENCHMARK_DEFINE_F(PanArray, Scalar)(benchmark::State& state) { for (auto _ : state) { - ::pan(pan, absl::MakeSpan(left), absl::MakeSpan(right)); + sfz::pan(pan, absl::MakeSpan(left), absl::MakeSpan(right)); } } BENCHMARK_DEFINE_F(PanArray, SIMD)(benchmark::State& state) { for (auto _ : state) { - ::pan(pan, absl::MakeSpan(left), absl::MakeSpan(right)); + sfz::pan(pan, absl::MakeSpan(left), absl::MakeSpan(right)); } } BENCHMARK_DEFINE_F(PanArray, BlockOps)(benchmark::State& state) { for (auto _ : state) { - ::fill(span2, 1.0f); - ::add(span1, span2); - ::applyGain(piFour, span2); - ::cos(span2, span1); - ::sin(span2, span2); - ::applyGain(span1, absl::MakeSpan(left)); - ::applyGain(span2, absl::MakeSpan(right)); + sfz::fill(span2, 1.0f); + sfz::add(span1, span2); + sfz::applyGain(piFour, span2); + sfz::cos(span2, span1); + sfz::sin(span2, span2); + sfz::applyGain(span1, absl::MakeSpan(left)); + sfz::applyGain(span2, absl::MakeSpan(right)); } } diff --git a/benchmarks/BM_pointerIterationOrOffsets.cpp b/benchmarks/BM_pointerIterationOrOffsets.cpp index 23b10fc0..118eccd3 100644 --- a/benchmarks/BM_pointerIterationOrOffsets.cpp +++ b/benchmarks/BM_pointerIterationOrOffsets.cpp @@ -42,7 +42,7 @@ public: jumps.resize(state.range(0)); offsets.resize(state.range(0)); absl::c_generate(jumps, [&]() { return jumpDist(gen); }); - cumsum(jumps, absl::MakeSpan(offsets)); + sfz::cumsum(jumps, absl::MakeSpan(offsets)); } void TearDown(const ::benchmark::State& state [[maybe_unused]]) { @@ -58,7 +58,7 @@ public: BENCHMARK_DEFINE_F(IterOffset, Pointers)(benchmark::State& state) { for (auto _ : state) { - diff(offsets, absl::MakeSpan(jumps)); + sfz::diff(offsets, absl::MakeSpan(jumps)); auto jump = jumps.begin(); auto in = source.begin(); auto out = result.begin(); diff --git a/benchmarks/BM_ramp.cpp b/benchmarks/BM_ramp.cpp index cb8ffdb5..2a57b5dc 100644 --- a/benchmarks/BM_ramp.cpp +++ b/benchmarks/BM_ramp.cpp @@ -28,7 +28,7 @@ static void Dummy(benchmark::State& state) { - Buffer output(state.range(0)); + sfz::Buffer output(state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; @@ -40,96 +40,96 @@ static void Dummy(benchmark::State& state) { } static void LinearScalar(benchmark::State& state) { - Buffer output(state.range(0)); + sfz::Buffer output(state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { auto value = dist(gen); - linearRamp(absl::MakeSpan(output), 0.0f, value); + sfz::linearRamp(absl::MakeSpan(output), 0.0f, value); } } static void LinearSIMD(benchmark::State& state) { - Buffer output(state.range(0)); + sfz::Buffer output(state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { auto value = dist(gen); - linearRamp(absl::MakeSpan(output), 0.0f, value); + sfz::linearRamp(absl::MakeSpan(output), 0.0f, value); } } static void LinearScalarUnaligned(benchmark::State& state) { - Buffer output(state.range(0)); + sfz::Buffer output(state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { auto value = dist(gen); - linearRamp(absl::MakeSpan(output).subspan(1), 0.0f, value); + sfz::linearRamp(absl::MakeSpan(output).subspan(1), 0.0f, value); } } static void LinearSIMDUnaligned(benchmark::State& state) { - Buffer output(state.range(0)); + sfz::Buffer output(state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { auto value = dist(gen); - linearRamp(absl::MakeSpan(output).subspan(1), 0.0f, value); + sfz::linearRamp(absl::MakeSpan(output).subspan(1), 0.0f, value); } } static void MulScalar(benchmark::State& state) { - Buffer output(state.range(0)); + sfz::Buffer output(state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { auto value = dist(gen); - multiplicativeRamp(absl::MakeSpan(output), 1.0f, value); + sfz::multiplicativeRamp(absl::MakeSpan(output), 1.0f, value); } } static void MulSIMD(benchmark::State& state) { - Buffer output(state.range(0)); + sfz::Buffer output(state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { auto value = dist(gen); - multiplicativeRamp(absl::MakeSpan(output), 1.0f, value); + sfz::multiplicativeRamp(absl::MakeSpan(output), 1.0f, value); } } static void MulScalarUnaligned(benchmark::State& state) { - Buffer output(state.range(0)); + sfz::Buffer output(state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { auto value = dist(gen); - multiplicativeRamp(absl::MakeSpan(output).subspan(1), 1.0f, value); + sfz::multiplicativeRamp(absl::MakeSpan(output).subspan(1), 1.0f, value); } } static void MulSIMDUnaligned(benchmark::State& state) { - Buffer output(state.range(0)); + sfz::Buffer output(state.range(0)); std::random_device rd { }; std::mt19937 gen { rd() }; std::uniform_real_distribution dist { 1, 2 }; for (auto _ : state) { auto value = dist(gen); - multiplicativeRamp(absl::MakeSpan(output).subspan(1), 1.0f, value); + sfz::multiplicativeRamp(absl::MakeSpan(output).subspan(1), 1.0f, value); } } diff --git a/benchmarks/BM_readInterleaved.cpp b/benchmarks/BM_readInterleaved.cpp index 4d30a949..e2e6e79e 100644 --- a/benchmarks/BM_readInterleaved.cpp +++ b/benchmarks/BM_readInterleaved.cpp @@ -29,64 +29,64 @@ #include static void Scalar(benchmark::State& state) { - Buffer input (state.range(0) * 2); - Buffer outputLeft (state.range(0)); - Buffer outputRight (state.range(0)); + sfz::Buffer input (state.range(0) * 2); + sfz::Buffer outputLeft (state.range(0)); + sfz::Buffer outputRight (state.range(0)); std::iota(input.begin(), input.end(), 1.0f); for (auto _ : state) { - readInterleaved(input, absl::MakeSpan(outputLeft), absl::MakeSpan(outputRight)); + sfz::readInterleaved(input, absl::MakeSpan(outputLeft), absl::MakeSpan(outputRight)); } } static void SSE(benchmark::State& state) { - Buffer input (state.range(0) * 2); - Buffer outputLeft (state.range(0)); - Buffer outputRight (state.range(0)); + sfz::Buffer input (state.range(0) * 2); + sfz::Buffer outputLeft (state.range(0)); + sfz::Buffer outputRight (state.range(0)); std::iota(input.begin(), input.end(), 1.0f); for (auto _ : state) { - readInterleaved(input, absl::MakeSpan(outputLeft), absl::MakeSpan(outputRight)); + sfz::readInterleaved(input, absl::MakeSpan(outputLeft), absl::MakeSpan(outputRight)); } } static void Scalar_Unaligned(benchmark::State& state) { - Buffer input (state.range(0) * 2); - Buffer outputLeft (state.range(0)); - Buffer outputRight (state.range(0)); + sfz::Buffer input (state.range(0) * 2); + sfz::Buffer outputLeft (state.range(0)); + sfz::Buffer outputRight (state.range(0)); std::iota(input.begin(), input.end(), 1.0f); for (auto _ : state) { - readInterleaved(absl::MakeSpan(input).subspan(2), absl::MakeSpan(outputLeft), absl::MakeSpan(outputRight)); + sfz::readInterleaved(absl::MakeSpan(input).subspan(2), absl::MakeSpan(outputLeft), absl::MakeSpan(outputRight)); } } static void SSE_Unaligned(benchmark::State& state) { - Buffer input (state.range(0) * 2); - Buffer outputLeft (state.range(0)); - Buffer outputRight (state.range(0)); + sfz::Buffer input (state.range(0) * 2); + sfz::Buffer outputLeft (state.range(0)); + sfz::Buffer outputRight (state.range(0)); std::iota(input.begin(), input.end(), 1.0f); for (auto _ : state) { - readInterleaved(absl::MakeSpan(input).subspan(2), absl::MakeSpan(outputLeft), absl::MakeSpan(outputRight)); + sfz::readInterleaved(absl::MakeSpan(input).subspan(2), absl::MakeSpan(outputLeft), absl::MakeSpan(outputRight)); } } static void Scalar_Unaligned_2(benchmark::State& state) { - Buffer input (state.range(0) * 2); - Buffer outputLeft (state.range(0)); - Buffer outputRight (state.range(0)); + sfz::Buffer input (state.range(0) * 2); + sfz::Buffer outputLeft (state.range(0)); + sfz::Buffer outputRight (state.range(0)); std::iota(input.begin(), input.end(), 1.0f); for (auto _ : state) { - readInterleaved(absl::MakeSpan(input).subspan(2), absl::MakeSpan(outputLeft).subspan(1), absl::MakeSpan(outputRight).subspan(3)); + sfz::readInterleaved(absl::MakeSpan(input).subspan(2), absl::MakeSpan(outputLeft).subspan(1), absl::MakeSpan(outputRight).subspan(3)); } } static void SSE_Unaligned_2(benchmark::State& state) { - Buffer input (state.range(0) * 2); - Buffer outputLeft (state.range(0)); - Buffer outputRight (state.range(0)); + sfz::Buffer input (state.range(0) * 2); + sfz::Buffer outputLeft (state.range(0)); + sfz::Buffer outputRight (state.range(0)); std::iota(input.begin(), input.end(), 1.0f); for (auto _ : state) { - readInterleaved(absl::MakeSpan(input).subspan(2), absl::MakeSpan(outputLeft).subspan(1), absl::MakeSpan(outputRight).subspan(3)); + sfz::readInterleaved(absl::MakeSpan(input).subspan(2), absl::MakeSpan(outputLeft).subspan(1), absl::MakeSpan(outputRight).subspan(3)); } } diff --git a/benchmarks/BM_saturating.cpp b/benchmarks/BM_saturating.cpp index a26ab73d..81d82141 100644 --- a/benchmarks/BM_saturating.cpp +++ b/benchmarks/BM_saturating.cpp @@ -60,28 +60,28 @@ public: BENCHMARK_DEFINE_F(SaturatingFixture, Scalar)(benchmark::State& state) { for (auto _ : state) { - saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 2.5f, loopEnd); + sfz::saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 2.5f, loopEnd); } } BENCHMARK_DEFINE_F(SaturatingFixture, SIMD)(benchmark::State& state) { for (auto _ : state) { - saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 2.5f, loopEnd); + sfz::saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 2.5f, loopEnd); } } BENCHMARK_DEFINE_F(SaturatingFixture, Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - saturatingSFZIndex(absl::MakeSpan(jumps).subspan(1), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1), absl::MakeSpan(indices).subspan(3), 2.5f, loopEnd); + sfz::saturatingSFZIndex(absl::MakeSpan(jumps).subspan(1), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1), absl::MakeSpan(indices).subspan(3), 2.5f, loopEnd); } } BENCHMARK_DEFINE_F(SaturatingFixture, SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - saturatingSFZIndex(absl::MakeSpan(jumps).subspan(1), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1), absl::MakeSpan(indices).subspan(3), 2.5f, loopEnd); + sfz::saturatingSFZIndex(absl::MakeSpan(jumps).subspan(1), absl::MakeSpan(leftCoeffs).subspan(2), absl::MakeSpan(rightCoeffs).subspan(1), absl::MakeSpan(indices).subspan(3), 2.5f, loopEnd); } } diff --git a/benchmarks/BM_subtract.cpp b/benchmarks/BM_subtract.cpp index 5235f6ee..2062dcdf 100644 --- a/benchmarks/BM_subtract.cpp +++ b/benchmarks/BM_subtract.cpp @@ -53,28 +53,28 @@ public: BENCHMARK_DEFINE_F(SubArray, Scalar)(benchmark::State& state) { for (auto _ : state) { - subtract(input, absl::MakeSpan(output)); + sfz::subtract(input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(SubArray, SIMD)(benchmark::State& state) { for (auto _ : state) { - subtract(input, absl::MakeSpan(output)); + sfz::subtract(input, absl::MakeSpan(output)); } } BENCHMARK_DEFINE_F(SubArray, Scalar_Unaligned)(benchmark::State& state) { for (auto _ : state) { - subtract(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::subtract(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } BENCHMARK_DEFINE_F(SubArray, SIMD_Unaligned)(benchmark::State& state) { for (auto _ : state) { - subtract(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); + sfz::subtract(absl::MakeSpan(input).subspan(1), absl::MakeSpan(output).subspan(1)); } } diff --git a/benchmarks/BM_writeInterleaved.cpp b/benchmarks/BM_writeInterleaved.cpp index d2921706..72932392 100644 --- a/benchmarks/BM_writeInterleaved.cpp +++ b/benchmarks/BM_writeInterleaved.cpp @@ -29,73 +29,73 @@ #include static void Interleaved_Write(benchmark::State& state) { - Buffer inputLeft (state.range(0)); - Buffer inputRight (state.range(0)); - Buffer output (state.range(0) * 2); + sfz::Buffer inputLeft (state.range(0)); + sfz::Buffer inputRight (state.range(0)); + sfz::Buffer output (state.range(0) * 2); std::iota(inputLeft.begin(), inputLeft.end(), 1.0f); std::iota(inputRight.begin(), inputRight.end(), 1.0f); for (auto _ : state) { - writeInterleaved(inputLeft, inputRight, absl::MakeSpan(output)); + sfz::writeInterleaved(inputLeft, inputRight, absl::MakeSpan(output)); } } static void Interleaved_Write_SSE(benchmark::State& state) { - Buffer inputLeft (state.range(0)); - Buffer inputRight (state.range(0)); - Buffer output (state.range(0) * 2); + sfz::Buffer inputLeft (state.range(0)); + sfz::Buffer inputRight (state.range(0)); + sfz::Buffer output (state.range(0) * 2); std::iota(inputLeft.begin(), inputLeft.end(), 1.0f); std::iota(inputRight.begin(), inputRight.end(), 1.0f); for (auto _ : state) { - writeInterleaved(inputLeft, inputRight, absl::MakeSpan(output)); + sfz::writeInterleaved(inputLeft, inputRight, absl::MakeSpan(output)); benchmark::DoNotOptimize(output); } } static void Unaligned_Interleaved_Write(benchmark::State& state) { - Buffer inputLeft (state.range(0)); - Buffer inputRight (state.range(0)); - Buffer output (state.range(0) * 2); + sfz::Buffer inputLeft (state.range(0)); + sfz::Buffer inputRight (state.range(0)); + sfz::Buffer output (state.range(0) * 2); std::iota(inputLeft.begin(), inputLeft.end(), 1.0f); std::iota(inputRight.begin(), inputRight.end(), 1.0f); for (auto _ : state) { - writeInterleaved(absl::MakeSpan(inputLeft).subspan(1) , absl::MakeSpan(inputRight).subspan(1), absl::MakeSpan(output).subspan(2)); + sfz::writeInterleaved(absl::MakeSpan(inputLeft).subspan(1) , absl::MakeSpan(inputRight).subspan(1), absl::MakeSpan(output).subspan(2)); benchmark::DoNotOptimize(output); } } static void Unaligned_Interleaved_Write_SSE(benchmark::State& state) { - Buffer inputLeft (state.range(0)); - Buffer inputRight (state.range(0)); - Buffer output (state.range(0) * 2); + sfz::Buffer inputLeft (state.range(0)); + sfz::Buffer inputRight (state.range(0)); + sfz::Buffer output (state.range(0) * 2); std::iota(inputLeft.begin(), inputLeft.end(), 1.0f); std::iota(inputRight.begin(), inputRight.end(), 1.0f); for (auto _ : state) { - writeInterleaved(absl::MakeSpan(inputLeft).subspan(1) , absl::MakeSpan(inputRight).subspan(1), absl::MakeSpan(output).subspan(2)); + sfz::writeInterleaved(absl::MakeSpan(inputLeft).subspan(1) , absl::MakeSpan(inputRight).subspan(1), absl::MakeSpan(output).subspan(2)); benchmark::DoNotOptimize(output); } } static void Unaligned_Interleaved_Write_2(benchmark::State& state) { - Buffer inputLeft (state.range(0)); - Buffer inputRight (state.range(0)); - Buffer output (state.range(0) * 2); + sfz::Buffer inputLeft (state.range(0)); + sfz::Buffer inputRight (state.range(0)); + sfz::Buffer output (state.range(0) * 2); std::iota(inputLeft.begin(), inputLeft.end(), 1.0f); std::iota(inputRight.begin(), inputRight.end(), 1.0f); for (auto _ : state) { - writeInterleaved(absl::MakeSpan(inputLeft) , absl::MakeSpan(inputRight).subspan(1), absl::MakeSpan(output).subspan(2)); + sfz::writeInterleaved(absl::MakeSpan(inputLeft) , absl::MakeSpan(inputRight).subspan(1), absl::MakeSpan(output).subspan(2)); benchmark::DoNotOptimize(output); } } static void Unaligned_Interleaved_Write_SSE_2(benchmark::State& state) { - Buffer inputLeft (state.range(0)); - Buffer inputRight (state.range(0)); - Buffer output (state.range(0) * 2); + sfz::Buffer inputLeft (state.range(0)); + sfz::Buffer inputRight (state.range(0)); + sfz::Buffer output (state.range(0) * 2); std::iota(inputLeft.begin(), inputLeft.end(), 1.0f); std::iota(inputRight.begin(), inputRight.end(), 1.0f); for (auto _ : state) { - writeInterleaved(absl::MakeSpan(inputLeft) , absl::MakeSpan(inputRight).subspan(1), absl::MakeSpan(output).subspan(2)); + sfz::writeInterleaved(absl::MakeSpan(inputLeft) , absl::MakeSpan(inputRight).subspan(1), absl::MakeSpan(output).subspan(2)); benchmark::DoNotOptimize(output); } } diff --git a/sfizz/ADSREnvelope.cpp b/sfizz/ADSREnvelope.cpp index 7d1a7ac7..3986ad66 100644 --- a/sfizz/ADSREnvelope.cpp +++ b/sfizz/ADSREnvelope.cpp @@ -119,7 +119,7 @@ void ADSREnvelope::getBlock(absl::Span output) noexcept switch (currentState) { case State::Delay: length = min(remainingSamples, delay); - ::fill(output, currentValue); + fill(output, currentValue); output.remove_prefix(length); remainingSamples -= length; delay -= length; @@ -131,7 +131,7 @@ void ADSREnvelope::getBlock(absl::Span output) noexcept [[fallthrough]]; case State::Attack: length = min(remainingSamples, attack); - currentValue = ::linearRamp(output, currentValue, step); + currentValue = linearRamp(output, currentValue, step); output.remove_prefix(length); remainingSamples -= length; attack -= length; @@ -143,7 +143,7 @@ void ADSREnvelope::getBlock(absl::Span output) noexcept [[fallthrough]]; case State::Hold: length = min(remainingSamples, hold); - ::fill(output, currentValue); + fill(output, currentValue); output.remove_prefix(length); remainingSamples -= length; hold -= length; @@ -155,7 +155,7 @@ void ADSREnvelope::getBlock(absl::Span output) noexcept [[fallthrough]]; case State::Decay: length = min(remainingSamples, decay); - currentValue = ::multiplicativeRamp(output, currentValue, step); + currentValue = multiplicativeRamp(output, currentValue, step); output.remove_prefix(length); remainingSamples -= length; decay -= length; @@ -169,7 +169,7 @@ void ADSREnvelope::getBlock(absl::Span output) noexcept break; case State::Release: length = min(remainingSamples, release); - currentValue = ::multiplicativeRamp(output, currentValue, step); + currentValue = multiplicativeRamp(output, currentValue, step); output.remove_prefix(length); remainingSamples -= length; release -= length; @@ -184,7 +184,7 @@ void ADSREnvelope::getBlock(absl::Span output) noexcept default: break; } - ::fill(output, currentValue); + fill(output, currentValue); if (shouldRelease) { remainingSamples = static_cast(originalSpan.size()); @@ -200,14 +200,14 @@ void ADSREnvelope::getBlock(absl::Span output) noexcept remainingSamples -= releaseDelay; length = min(remainingSamples, release); currentState = State::Release; - currentValue = ::multiplicativeRamp(originalSpan, currentValue, step); + currentValue = multiplicativeRamp(originalSpan, currentValue, step); originalSpan.remove_prefix(length); release -= length; if (release == 0) { currentValue = 0.0; currentState = State::Done; - ::fill(originalSpan, 0.0); + fill(originalSpan, 0.0); } } } diff --git a/sfizz/AudioBuffer.h b/sfizz/AudioBuffer.h index 123d90bb..2ef1b35a 100644 --- a/sfizz/AudioBuffer.h +++ b/sfizz/AudioBuffer.h @@ -30,6 +30,9 @@ #include #include +namespace sfz +{ + template class AudioBuffer { public: @@ -150,4 +153,5 @@ private: std::array buffers; int numChannels { 0 }; size_type numFrames { 0 }; -}; \ No newline at end of file +}; +} \ No newline at end of file diff --git a/sfizz/AudioSpan.h b/sfizz/AudioSpan.h index 7fe56593..b47a147e 100644 --- a/sfizz/AudioSpan.h +++ b/sfizz/AudioSpan.h @@ -32,6 +32,8 @@ #include #include +namespace sfz +{ template class AudioSpan { public: @@ -137,26 +139,26 @@ public: return 0.0; Type result = 0.0; for (int i = 0; i < numChannels; ++i) - result += ::meanSquared(getConstSpan(i)); + result += sfz::meanSquared(getConstSpan(i)); return result / numChannels; } void fill(Type value) noexcept { for (int i = 0; i < numChannels; ++i) - ::fill(getSpan(i), value); + sfz::fill(getSpan(i), value); } void applyGain(absl::Span gain) noexcept { for (int i = 0; i < numChannels; ++i) - ::applyGain(gain, getSpan(i)); + sfz::applyGain(gain, getSpan(i)); } void applyGain(Type gain) noexcept { for (int i = 0; i < numChannels; ++i) - ::applyGain(gain, getSpan(i)); + sfz::applyGain(gain, getSpan(i)); } template > @@ -165,7 +167,7 @@ public: ASSERT(other.getNumChannels() == numChannels); if (other.getNumChannels() == numChannels) { for (int i = 0; i < numChannels; ++i) - ::add(other.getConstSpan(i), getSpan(i)); + sfz::add(other.getConstSpan(i), getSpan(i)); } } @@ -175,7 +177,7 @@ public: ASSERT(other.getNumChannels() == numChannels); if (other.getNumChannels() == numChannels) { for (int i = 0; i < numChannels; ++i) - ::copy(other.getConstSpan(i), getSpan(i)); + sfz::copy(other.getConstSpan(i), getSpan(i)); } } @@ -217,4 +219,5 @@ private: std::array spans; size_type numFrames { 0 }; int numChannels { 0 }; -}; \ No newline at end of file +}; +} \ No newline at end of file diff --git a/sfizz/Buffer.h b/sfizz/Buffer.h index f1fc9294..7f7b11ea 100644 --- a/sfizz/Buffer.h +++ b/sfizz/Buffer.h @@ -29,6 +29,9 @@ #include #include #include + +namespace sfz +{ template class Buffer { public: @@ -157,3 +160,4 @@ private: pointer _alignedEnd { nullptr }; LEAK_DETECTOR(Buffer); }; +} \ No newline at end of file diff --git a/sfizz/Config.h b/sfizz/Config.h index 20b97e2c..f2a96a15 100644 --- a/sfizz/Config.h +++ b/sfizz/Config.h @@ -43,7 +43,6 @@ namespace config { constexpr float voiceStealingThreshold { 0.00001 }; } // namespace config -} // namespace sfz namespace SIMDConfig { constexpr unsigned int defaultAlignment { 16 }; @@ -66,4 +65,5 @@ namespace SIMDConfig { constexpr bool sfzInterpolationCast { true }; constexpr bool mean { false }; constexpr bool meanSquared { false }; -} \ No newline at end of file +} +} // namespace sfz \ No newline at end of file diff --git a/sfizz/FilePool.cpp b/sfizz/FilePool.cpp index dacf704b..e10377f3 100644 --- a/sfizz/FilePool.cpp +++ b/sfizz/FilePool.cpp @@ -35,15 +35,15 @@ using namespace std::chrono_literals; template -std::unique_ptr> readFromFile(SndfileHandle& sndFile, int numFrames) +std::unique_ptr> readFromFile(SndfileHandle& sndFile, int numFrames) { - auto returnedBuffer = std::make_unique>(sndFile.channels(), numFrames); + auto returnedBuffer = std::make_unique>(sndFile.channels(), numFrames); if (sndFile.channels() == 1) { sndFile.readf(returnedBuffer->channelWriter(0), numFrames); } else if (sndFile.channels() == 2) { - auto tempReadBuffer = std::make_unique>(1, 2 * numFrames); + auto tempReadBuffer = std::make_unique>(1, 2 * numFrames); sndFile.readf(tempReadBuffer->channelWriter(0), numFrames); - ::readInterleaved(tempReadBuffer->getSpan(0), returnedBuffer->getSpan(0), returnedBuffer->getSpan(1)); + sfz::readInterleaved(tempReadBuffer->getSpan(0), returnedBuffer->getSpan(0), returnedBuffer->getSpan(1)); } return returnedBuffer; } @@ -90,7 +90,7 @@ absl::optional sfz::FilePool::getFileInformation // By resetting the filepool data to a new, longer audiobuffer, we are creating 2 copies of the same audio data. // The filepool and the new regions have the longer copy, and the older regions have the shorter copy. // This is not entirely optimal, but is it better to write a double shared pointer ? - // std::shared_ptr>> is a bit ugly... + // std::shared_ptr>> is a bit ugly... alreadyPreloaded.reset(readFromFile(sndFile, preloadedSize).release()); } returnedValue.preloadedData = alreadyPreloaded; diff --git a/sfizz/HistoricalBuffer.h b/sfizz/HistoricalBuffer.h index 26725519..5e616b02 100644 --- a/sfizz/HistoricalBuffer.h +++ b/sfizz/HistoricalBuffer.h @@ -2,6 +2,8 @@ #include "SIMDHelpers.h" #include "absl/types/span.h" +namespace sfz +{ template class HistoricalBuffer { public: @@ -15,7 +17,7 @@ public: void resize(int size) { buffer.resize(size); - ::fill(absl::MakeSpan(buffer), 0.0); + fill(absl::MakeSpan(buffer), 0.0); index = 0; } @@ -30,10 +32,11 @@ public: ValueType getAverage() const { - return ::mean(buffer); + return mean(buffer); } private: std::vector buffer; size_t size { 0 }; size_t index { 0 }; }; +} \ No newline at end of file diff --git a/sfizz/LinearEnvelope.cpp b/sfizz/LinearEnvelope.cpp index 2584a866..c9c04d44 100644 --- a/sfizz/LinearEnvelope.cpp +++ b/sfizz/LinearEnvelope.cpp @@ -90,12 +90,12 @@ void LinearEnvelope::getBlock(absl::Span output) } const auto step = (event.second - currentValue) / length; - currentValue = ::linearRamp(output.subspan(index, length), currentValue, step); + currentValue = linearRamp(output.subspan(index, length), currentValue, step); index += length; } if (index < static_cast(output.size())) - ::fill(output.subspan(index), currentValue); + fill(output.subspan(index), currentValue); clear(); } diff --git a/sfizz/OnePoleFilter.h b/sfizz/OnePoleFilter.h index 58f1d9dc..72c71c3e 100644 --- a/sfizz/OnePoleFilter.h +++ b/sfizz/OnePoleFilter.h @@ -27,6 +27,8 @@ #include #include +namespace sfz +{ template class OnePoleFilter { public: @@ -134,4 +136,5 @@ private: *out = *in - intermediate - state; state += 2 * intermediate; } -}; \ No newline at end of file +}; +} \ No newline at end of file diff --git a/sfizz/SIMDDummy.cpp b/sfizz/SIMDDummy.cpp index fd19d1c2..f1409339 100644 --- a/sfizz/SIMDDummy.cpp +++ b/sfizz/SIMDDummy.cpp @@ -24,153 +24,153 @@ #include "SIMDHelpers.h" template <> -void readInterleaved(absl::Span input, absl::Span outputLeft, absl::Span outputRight) noexcept +void sfz::readInterleaved(absl::Span input, absl::Span outputLeft, absl::Span outputRight) noexcept { readInterleaved(input, outputLeft, outputRight); } template <> -void writeInterleaved(absl::Span inputLeft, absl::Span inputRight, absl::Span output) noexcept +void sfz::writeInterleaved(absl::Span inputLeft, absl::Span inputRight, absl::Span output) noexcept { writeInterleaved(inputLeft, inputRight, output); } template <> -void fill(absl::Span output, float value) noexcept +void sfz::fill(absl::Span output, float value) noexcept { fill(output, value); } template <> -void exp(absl::Span input, absl::Span output) noexcept +void sfz::exp(absl::Span input, absl::Span output) noexcept { exp(input, output); } template <> -void log(absl::Span input, absl::Span output) noexcept +void sfz::log(absl::Span input, absl::Span output) noexcept { log(input, output); } template <> -void sin(absl::Span input, absl::Span output) noexcept +void sfz::sin(absl::Span input, absl::Span output) noexcept { sin(input, output); } template <> -void cos(absl::Span input, absl::Span output) noexcept +void sfz::cos(absl::Span input, absl::Span output) noexcept { cos(input, output); } template <> -void applyGain(float gain, absl::Span input, absl::Span output) noexcept +void sfz::applyGain(float gain, absl::Span input, absl::Span output) noexcept { applyGain(gain, input, output); } template <> -void applyGain(absl::Span gain, absl::Span input, absl::Span output) noexcept +void sfz::applyGain(absl::Span gain, absl::Span input, absl::Span output) noexcept { applyGain(gain, input, output); } template <> -void multiplyAdd(absl::Span gain, absl::Span input, absl::Span output) noexcept +void sfz::multiplyAdd(absl::Span gain, absl::Span input, absl::Span output) noexcept { multiplyAdd(gain, input, output); } template <> -float loopingSFZIndex(absl::Span jumps, absl::Span leftCoeff, absl::Span rightCoeff, absl::Span indices, float floatIndex, float loopEnd, float loopStart) noexcept +float sfz::loopingSFZIndex(absl::Span jumps, absl::Span leftCoeff, absl::Span rightCoeff, absl::Span indices, float floatIndex, float loopEnd, float loopStart) noexcept { return loopingSFZIndex(jumps, leftCoeff, rightCoeff, indices, floatIndex, loopEnd, loopStart); } template <> -float saturatingSFZIndex(absl::Span jumps, absl::Span leftCoeff, absl::Span rightCoeff, absl::Span indices, float floatIndex, float loopEnd) noexcept +float sfz::saturatingSFZIndex(absl::Span jumps, absl::Span leftCoeff, absl::Span rightCoeff, absl::Span indices, float floatIndex, float loopEnd) noexcept { return saturatingSFZIndex(jumps, leftCoeff, rightCoeff, indices, floatIndex, loopEnd); } template <> -float linearRamp(absl::Span output, float start, float step) noexcept +float sfz::linearRamp(absl::Span output, float start, float step) noexcept { return linearRamp(output, start, step); } template <> -float multiplicativeRamp(absl::Span output, float start, float step) noexcept +float sfz::multiplicativeRamp(absl::Span output, float start, float step) noexcept { return multiplicativeRamp(output, start, step); } template <> -void add(absl::Span input, absl::Span output) noexcept +void sfz::add(absl::Span input, absl::Span output) noexcept { add(input, output); } template <> -void add(float value, absl::Span output) noexcept +void sfz::add(float value, absl::Span output) noexcept { add(value, output); } template <> -void subtract(absl::Span input, absl::Span output) noexcept +void sfz::subtract(absl::Span input, absl::Span output) noexcept { subtract(input, output); } template <> -void subtract(const float value, absl::Span output) noexcept +void sfz::subtract(const float value, absl::Span output) noexcept { subtract(value, output); } template <> -void copy(absl::Span input, absl::Span output) noexcept +void sfz::copy(absl::Span input, absl::Span output) noexcept { copy(input, output); } template <> -void pan(absl::Span panEnvelope, absl::Span leftBuffer, absl::Span rightBuffer) noexcept +void sfz::pan(absl::Span panEnvelope, absl::Span leftBuffer, absl::Span rightBuffer) noexcept { pan(panEnvelope, leftBuffer, rightBuffer); } template <> -float mean(absl::Span vector) noexcept +float sfz::mean(absl::Span vector) noexcept { return mean(vector); } template <> -float meanSquared(absl::Span vector) noexcept +float sfz::meanSquared(absl::Span vector) noexcept { return meanSquared(vector); } template <> -void cumsum(absl::Span input, absl::Span output) noexcept +void sfz::cumsum(absl::Span input, absl::Span output) noexcept { cumsum(input, output); } template<> -void sfzInterpolationCast(absl::Span floatJumps, absl::Span jumps, absl::Span leftCoeffs, absl::Span rightCoeffs) noexcept +void sfz::sfzInterpolationCast(absl::Span floatJumps, absl::Span jumps, absl::Span leftCoeffs, absl::Span rightCoeffs) noexcept { sfzInterpolationCast(floatJumps, jumps, leftCoeffs, rightCoeffs); } template <> -void diff(absl::Span input, absl::Span output) noexcept +void sfz::diff(absl::Span input, absl::Span output) noexcept { diff(input, output); } \ No newline at end of file diff --git a/sfizz/SIMDHelpers.h b/sfizz/SIMDHelpers.h index 6a9b2a90..dda5998f 100644 --- a/sfizz/SIMDHelpers.h +++ b/sfizz/SIMDHelpers.h @@ -29,6 +29,8 @@ #include #include +namespace sfz +{ template inline void snippetRead(const T*& input, T*& outputLeft, T*& outputRight) { @@ -569,4 +571,6 @@ void diff(absl::Span input, absl::Span output) noexcept } template <> -void cumsum(absl::Span input, absl::Span output) noexcept; \ No newline at end of file +void cumsum(absl::Span input, absl::Span output) noexcept; + +} // namespace sfz \ No newline at end of file diff --git a/sfizz/SIMDSSE.cpp b/sfizz/SIMDSSE.cpp index 7267cade..57997627 100644 --- a/sfizz/SIMDSSE.cpp +++ b/sfizz/SIMDSSE.cpp @@ -76,7 +76,7 @@ bool unaligned(const float* ptr1, const float* ptr2, const float* ptr3, const fl } template <> -void readInterleaved(absl::Span input, absl::Span outputLeft, absl::Span outputRight) noexcept +void sfz::readInterleaved(absl::Span input, absl::Span outputLeft, absl::Span outputRight) noexcept { // The size of the outputs is not big enough for the input... ASSERT(outputLeft.size() >= input.size() / 2); @@ -116,7 +116,7 @@ void readInterleaved(absl::Span input, absl::Span -void writeInterleaved(absl::Span inputLeft, absl::Span inputRight, absl::Span output) noexcept +void sfz::writeInterleaved(absl::Span inputLeft, absl::Span inputRight, absl::Span output) noexcept { // The size of the output is not big enough for the inputs... ASSERT(inputLeft.size() <= output.size() / 2); @@ -153,7 +153,7 @@ void writeInterleaved(absl::Span inputLeft, absl::Span } template <> -void fill(absl::Span output, float value) noexcept +void sfz::fill(absl::Span output, float value) noexcept { const auto mmValue = _mm_set_ps1(value); auto* out = output.begin(); @@ -173,7 +173,7 @@ void fill(absl::Span output, float value) noexcept } template <> -void exp(absl::Span input, absl::Span output) noexcept +void sfz::exp(absl::Span input, absl::Span output) noexcept { ASSERT(output.size() >= input.size()); auto* in = input.begin(); @@ -195,7 +195,7 @@ void exp(absl::Span input, absl::Span output) n } template <> -void cos(absl::Span input, absl::Span output) noexcept +void sfz::cos(absl::Span input, absl::Span output) noexcept { ASSERT(output.size() >= input.size()); auto* in = input.begin(); @@ -217,7 +217,7 @@ void cos(absl::Span input, absl::Span output) n } template <> -void log(absl::Span input, absl::Span output) noexcept +void sfz::log(absl::Span input, absl::Span output) noexcept { ASSERT(output.size() >= input.size()); auto* in = input.begin(); @@ -239,7 +239,7 @@ void log(absl::Span input, absl::Span output) n } template <> -void sin(absl::Span input, absl::Span output) noexcept +void sfz::sin(absl::Span input, absl::Span output) noexcept { ASSERT(output.size() >= input.size()); auto* in = input.begin(); @@ -261,7 +261,7 @@ void sin(absl::Span input, absl::Span output) n } template <> -void applyGain(float gain, absl::Span input, absl::Span output) noexcept +void sfz::applyGain(float gain, absl::Span input, absl::Span output) noexcept { auto* in = input.begin(); auto* out = output.begin(); @@ -283,7 +283,7 @@ void applyGain(float gain, absl::Span input, absl::Spa } template <> -void applyGain(absl::Span gain, absl::Span input, absl::Span output) noexcept +void sfz::applyGain(absl::Span gain, absl::Span input, absl::Span output) noexcept { auto* in = input.begin(); auto* out = output.begin(); @@ -306,7 +306,7 @@ void applyGain(absl::Span gain, absl::Span -void multiplyAdd(absl::Span gain, absl::Span input, absl::Span output) noexcept +void sfz::multiplyAdd(absl::Span gain, absl::Span input, absl::Span output) noexcept { auto* in = input.begin(); auto* out = output.begin(); @@ -331,7 +331,7 @@ void multiplyAdd(absl::Span gain, absl::Span -float loopingSFZIndex(absl::Span jumps, +float sfz::loopingSFZIndex(absl::Span jumps, absl::Span leftCoeffs, absl::Span rightCoeffs, absl::Span indices, @@ -393,7 +393,7 @@ float loopingSFZIndex(absl::Span jumps, } template <> -float saturatingSFZIndex(absl::Span jumps, +float sfz::saturatingSFZIndex(absl::Span jumps, absl::Span leftCoeffs, absl::Span rightCoeffs, absl::Span indices, @@ -451,7 +451,7 @@ float saturatingSFZIndex(absl::Span jumps, } template <> -float linearRamp(absl::Span output, float value, float step) noexcept +float sfz::linearRamp(absl::Span output, float value, float step) noexcept { auto* out = output.begin(); const auto* lastAligned = prevAligned(output.end()); @@ -476,7 +476,7 @@ float linearRamp(absl::Span output, float value, float step) } template <> -float multiplicativeRamp(absl::Span output, float value, float step) noexcept +float sfz::multiplicativeRamp(absl::Span output, float value, float step) noexcept { auto* out = output.begin(); const auto* lastAligned = prevAligned(output.end()); @@ -501,7 +501,7 @@ float multiplicativeRamp(absl::Span output, float value, flo } template <> -void add(absl::Span input, absl::Span output) noexcept +void sfz::add(absl::Span input, absl::Span output) noexcept { ASSERT(output.size() >= input.size()); auto* in = input.begin(); @@ -523,7 +523,7 @@ void add(absl::Span input, absl::Span output) n } template <> -void add(float value, absl::Span output) noexcept +void sfz::add(float value, absl::Span output) noexcept { auto* out = output.begin(); auto* sentinel = output.end(); @@ -543,7 +543,7 @@ void add(float value, absl::Span output) noexcept } template <> -void subtract(absl::Span input, absl::Span output) noexcept +void sfz::subtract(absl::Span input, absl::Span output) noexcept { ASSERT(output.size() >= input.size()); auto* in = input.begin(); @@ -565,7 +565,7 @@ void subtract(absl::Span input, absl::Span outp } template <> -void subtract(const float value, absl::Span output) noexcept +void sfz::subtract(const float value, absl::Span output) noexcept { auto* out = output.begin(); auto* sentinel = output.end(); @@ -585,7 +585,7 @@ void subtract(const float value, absl::Span output) noexcept } template <> -void copy(absl::Span input, absl::Span output) noexcept +void sfz::copy(absl::Span input, absl::Span output) noexcept { ASSERT(output.size() >= input.size()); auto* in = input.begin(); @@ -607,7 +607,7 @@ void copy(absl::Span input, absl::Span output) } template <> -void pan(absl::Span panEnvelope, absl::Span leftBuffer, absl::Span rightBuffer) noexcept +void sfz::pan(absl::Span panEnvelope, absl::Span leftBuffer, absl::Span rightBuffer) noexcept { ASSERT(leftBuffer.size() >= panEnvelope.size()); ASSERT(rightBuffer.size() >= panEnvelope.size()); @@ -643,7 +643,7 @@ void pan(absl::Span panEnvelope, absl::Span lef } template <> -float mean(absl::Span vector) noexcept +float sfz::mean(absl::Span vector) noexcept { float result { 0.0 }; if (vector.size() == 0) @@ -675,7 +675,7 @@ float mean(absl::Span vector) noexcept } template <> -float meanSquared(absl::Span vector) noexcept +float sfz::meanSquared(absl::Span vector) noexcept { float result { 0.0 }; if (vector.size() == 0) @@ -712,7 +712,7 @@ float meanSquared(absl::Span vector) noexcept } template <> -void cumsum(absl::Span input, absl::Span output) noexcept +void sfz::cumsum(absl::Span input, absl::Span output) noexcept { ASSERT(output.size() >= input.size()); if (input.size() == 0) @@ -744,7 +744,7 @@ void cumsum(absl::Span input, absl::Span output } template <> -void sfzInterpolationCast(absl::Span floatJumps, absl::Span jumps, absl::Span leftCoeffs, absl::Span rightCoeffs) noexcept +void sfz::sfzInterpolationCast(absl::Span floatJumps, absl::Span jumps, absl::Span leftCoeffs, absl::Span rightCoeffs) noexcept { ASSERT(jumps.size() >= floatJumps.size()); ASSERT(jumps.size() == leftCoeffs.size()); @@ -780,7 +780,7 @@ void sfzInterpolationCast(absl::Span floatJumps, absl: } template <> -void diff(absl::Span input, absl::Span output) noexcept +void sfz::diff(absl::Span input, absl::Span output) noexcept { ASSERT(output.size() >= input.size()); if (input.size() == 0) diff --git a/sfizz/StereoBuffer.h b/sfizz/StereoBuffer.h deleted file mode 100644 index fa1526b5..00000000 --- a/sfizz/StereoBuffer.h +++ /dev/null @@ -1,186 +0,0 @@ -// Copyright (c) 2019, Paul Ferrand -// All rights reserved. - -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: - -// 1. Redistributions of source code must retain the above copyright notice, this -// list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. - -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#pragma once -#include "Buffer.h" -#include "Config.h" -#include "Debug.h" -#include "LeakDetector.h" -#include "SIMDHelpers.h" -#include -#include -#include - -enum class Channel { left, right }; - -template -class StereoBuffer { -public: - static constexpr int numChannels { 2 }; - StereoBuffer() = default; - StereoBuffer(int numFrames) - { - resize(numFrames); - } - - bool resize(int numFrames) - { - // should have a positive number of frames... - ASSERT(numFrames >= 0); - if (leftBuffer.resize(static_cast(numFrames)) && rightBuffer.resize(static_cast(numFrames))) { - this->numFrames = numFrames; - return true; - } - - return false; - } - - absl::Span getConstSpan(Channel channel) const - { - switch (channel) { - case Channel::left: - return leftBuffer; - case Channel::right: - return rightBuffer; - } - } - - absl::Span getSpan(Channel channel) - { - switch (channel) { - default: - [[fallthrough]]; - case Channel::left: - return absl::MakeSpan(leftBuffer); - case Channel::right: - return absl::MakeSpan(rightBuffer); - } - } - - Type& getSample(Channel channel, int sampleIndex) noexcept - { - ASSERT(sampleIndex >= 0); - switch (channel) { - default: - [[fallthrough]]; - case Channel::left: - return leftBuffer[sampleIndex]; - case Channel::right: - return rightBuffer[sampleIndex]; - } - } - - void fill(Type value) noexcept - { - ::fill(absl::MakeSpan(leftBuffer), value); - ::fill(absl::MakeSpan(rightBuffer), value); - } - - void readInterleaved(absl::Span input) noexcept - { - ASSERT(input.size() <= static_cast(numChannels * numFrames)); - ::readInterleaved(input, absl::MakeSpan(leftBuffer), absl::MakeSpan(rightBuffer)); - } - - void writeInterleaved(absl::Span output) noexcept - { - ASSERT(output.size() >= static_cast(numChannels * numFrames)); - ::writeInterleaved(leftBuffer, rightBuffer, output); - } - - void add(const StereoBuffer& buffer) - { - ::add(buffer.getSpan(Channel::left), absl::MakeSpan(leftBuffer)); - ::add(buffer.getSpan(Channel::right), absl::MakeSpan(rightBuffer)); - } - - Type* getChannel(Channel channel) noexcept - { - switch (channel) { - case Channel::left: - return leftBuffer.data(); - case Channel::right: - return rightBuffer.data(); - default: - return {}; - } - } - - Type* begin(Channel channel) noexcept - { - switch (channel) { - case Channel::left: - return leftBuffer.data(); - case Channel::right: - return rightBuffer.data(); - default: - return {}; - } - } - std::pair getChannels() noexcept { return { leftBuffer.data(), rightBuffer.data() }; } - std::pair begins() noexcept { return { leftBuffer.data(), rightBuffer.data() }; } - - Type* end(Channel channel) noexcept - { - switch (channel) { - case Channel::left: - return leftBuffer.end(); - case Channel::right: - return rightBuffer.end(); - default: - return {}; - } - } - std::pair ends() { return { leftBuffer.end(), rightBuffer.end() }; } - - Type* alignedEnd(Channel channel) noexcept - { - switch (channel) { - case Channel::left: - return leftBuffer.alignedEnd(); - case Channel::right: - return rightBuffer.alignedEnd(); - default: - return {}; - } - } - std::pair alignedEnds() { return { leftBuffer.alignedEnd(), rightBuffer.alignedEnd() }; } - - Type& operator()(Channel channel, int sampleIndex) noexcept - { - return getSample(channel, sampleIndex); - } - - int getNumFrames() const noexcept { return numFrames; } - int getNumChannels() const noexcept { return numChannels; } - bool empty() const noexcept { return numFrames == 0; } - -private: - static constexpr auto TypeAlignment { Alignment / sizeof(Type) }; - static constexpr auto TypeAlignmentMask { TypeAlignment - 1 }; - static_assert(TypeAlignment * sizeof(Type) == Alignment, "The alignment does not appear to be divided by the size of the Type"); - int numFrames { 0 }; - Buffer leftBuffer {}; - Buffer rightBuffer {}; - LEAK_DETECTOR(StereoBuffer); -}; diff --git a/sfizz/StereoSpan.h b/sfizz/StereoSpan.h deleted file mode 100644 index 377a9c35..00000000 --- a/sfizz/StereoSpan.h +++ /dev/null @@ -1,189 +0,0 @@ -// Copyright (c) 2019, Paul Ferrand -// All rights reserved. - -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: - -// 1. Redistributions of source code must retain the above copyright notice, this -// list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. - -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#pragma once -#include "LeakDetector.h" -#include "SIMDHelpers.h" -#include "StereoBuffer.h" -#include -#include - -template -class StereoSpan { -public: - using ValueType = std::remove_cv_t; - template - StereoSpan() = delete; - StereoSpan(Type* leftBuffer, Type* rightBuffer, size_t numFrames) - : numFrames(numFrames) - , leftBuffer(leftBuffer, numFrames) - , rightBuffer(rightBuffer, numFrames) - { - } - - StereoSpan(void* leftBuffer, void* rightBuffer, size_t numFrames) - : numFrames(numFrames) - , leftBuffer(static_cast(leftBuffer), numFrames) - , rightBuffer(static_cast(rightBuffer), numFrames) - { - } - - StereoSpan(absl::Span leftBuffer, absl::Span rightBuffer) - : numFrames(std::min(leftBuffer.size(), rightBuffer.size())) - , leftBuffer(leftBuffer.first(numFrames)) - , rightBuffer(rightBuffer.first(numFrames)) - { - // Buffer really should be the same size here - ASSERT(leftBuffer.size() == rightBuffer.size()); - } - - StereoSpan(StereoBuffer&& buffer) - : numFrames(buffer.getNumFrames()) - , leftBuffer(buffer.getSpan(Channel::left)) - , rightBuffer(buffer.getSpan(Channel::right)) - { - } - - StereoSpan(StereoBuffer&& buffer) - : leftBuffer(buffer.getConstSpan(Channel::left)) - , rightBuffer(buffer.getConstSpan(Channel::right)) - , numFrames(buffer.getNumFrames()) - { - } - - StereoSpan(StereoBuffer& buffer) - : numFrames(buffer.getNumFrames()) - , leftBuffer(buffer.getSpan(Channel::left)) - , rightBuffer(buffer.getSpan(Channel::right)) - { - } - - StereoSpan(StereoBuffer& buffer) - : leftBuffer(buffer.getConstSpan(Channel::left)) - , rightBuffer(buffer.getConstSpan(Channel::right)) - , numFrames(buffer.getNumFrames()) - { - } - - StereoSpan(StereoBuffer& buffer, size_t numFrames) - : numFrames(numFrames) - , leftBuffer(buffer.getSpan(Channel::left).first(numFrames)) - , rightBuffer(buffer.getSpan(Channel::right).first(numFrames)) - { - } - - StereoSpan(const StereoBuffer& buffer, size_t numFrames) - : numFrames(numFrames) - , leftBuffer(buffer.getConstSpan(Channel::left).first(numFrames)) - , rightBuffer(buffer.getConstSpan(Channel::right).first(numFrames)) - { - } - - StereoSpan(const StereoSpan& span) - : numFrames(span.size()) - , leftBuffer(span.left()) - , rightBuffer(span.right()) - { - } - - StereoSpan(const StereoSpan& span) - : numFrames(span.size()) - , leftBuffer(span.left()) - , rightBuffer(span.right()) - { - - } - - void fill(Type value) noexcept - { - ::fill(leftBuffer, value); - ::fill(rightBuffer, value); - } - - void applyGain(absl::Span gain) noexcept - { - ::applyGain(gain, leftBuffer); - ::applyGain(gain, rightBuffer); - } - - void applyGain(Type gain) noexcept - { - ::applyGain(gain, leftBuffer); - ::applyGain(gain, rightBuffer); - } - - void readInterleaved(absl::Span input) noexcept - { - ASSERT(input.size() <= static_cast(numChannels * numFrames)); - ::readInterleaved(input, absl::MakeSpan(leftBuffer), absl::MakeSpan(rightBuffer)); - } - - void writeInterleaved(absl::Span output) noexcept - { - ASSERT(output.size() >= static_cast(numChannels * numFrames)); - ::writeInterleaved(leftBuffer, rightBuffer, output); - } - - void add(StereoSpan buffer) - { - ::add(buffer.left(), leftBuffer); - ::add(buffer.right(), rightBuffer); - } - - absl::Span left() const - { - return leftBuffer; - } - - absl::Span right() const - { - return rightBuffer; - } - - StereoSpan first(size_t length) const - { - return { leftBuffer.first(length), rightBuffer.first(length) }; - } - - StereoSpan last(size_t length) const - { - return { leftBuffer.last(length), rightBuffer.last(length) }; - } - - StereoSpan subspan(size_t pos, size_t length = absl::Span::npos) const - { - return { leftBuffer.subspan(pos, length), rightBuffer.subspan(pos, length) }; - } - - size_t size() const - { - return numFrames; - } - -private: - static constexpr int numChannels { 2 }; - size_t numFrames { 0 }; - absl::Span leftBuffer; - absl::Span rightBuffer; - LEAK_DETECTOR(StereoSpan); -}; \ No newline at end of file diff --git a/sfizz/Voice.cpp b/sfizz/Voice.cpp index 444e46b0..86b75a6e 100644 --- a/sfizz/Voice.cpp +++ b/sfizz/Voice.cpp @@ -263,29 +263,29 @@ void sfz::Voice::processMono(AudioSpan buffer) noexcept // Amplitude envelope amplitudeEnvelope.getBlock(span1); - ::applyGain(span1, leftBuffer); + applyGain(span1, leftBuffer); // AmpEG envelope egEnvelope.getBlock(span1); - ::applyGain(span1, leftBuffer); + applyGain(span1, leftBuffer); // Volume envelope volumeEnvelope.getBlock(span1); - ::applyGain(span1, leftBuffer); + applyGain(span1, leftBuffer); // Prepare for stereo output - ::copy(leftBuffer, rightBuffer); + copy(leftBuffer, rightBuffer); panEnvelope.getBlock(span1); // We assume that the pan envelope is already normalized between -1 and 1 // Check bm_pan for your architecture to check if it's interesting to use the pan helper instead - ::fill(span2, 1.0f); - ::add(span1, span2); - ::applyGain(piFour, span2); - ::cos(span2, span1); - ::sin(span2, span2); - ::applyGain(span1, leftBuffer); - ::applyGain(span2, rightBuffer); + fill(span2, 1.0f); + add(span1, span2); + applyGain(piFour, span2); + cos(span2, span1); + sin(span2, span2); + applyGain(span1, leftBuffer); + applyGain(span2, rightBuffer); } void sfz::Voice::processStereo(AudioSpan buffer) noexcept @@ -310,36 +310,36 @@ void sfz::Voice::processStereo(AudioSpan buffer) noexcept buffer.applyGain(span1); // Create mid/side from left/right in the output buffer - ::copy(rightBuffer, span1); - ::add(leftBuffer, rightBuffer); - ::subtract(span1, leftBuffer); - ::applyGain(sqrtTwoInv, leftBuffer); - ::applyGain(sqrtTwoInv, rightBuffer); + copy(rightBuffer, span1); + add(leftBuffer, rightBuffer); + subtract(span1, leftBuffer); + applyGain(sqrtTwoInv, leftBuffer); + applyGain(sqrtTwoInv, rightBuffer); // Apply the width process widthEnvelope.getBlock(span1); - ::fill(span2, 1.0f); - ::add(span1, span2); - ::applyGain(piFour, span2); - ::cos(span2, span1); - ::sin(span2, span2); - ::applyGain(span1, leftBuffer); - ::applyGain(span2, rightBuffer); + fill(span2, 1.0f); + add(span1, span2); + applyGain(piFour, span2); + cos(span2, span1); + sin(span2, span2); + applyGain(span1, leftBuffer); + applyGain(span2, rightBuffer); // Apply a position to the "left" channel which is supposed to be our mid channel // TODO: add panning here too? positionEnvelope.getBlock(span1); - ::fill(span2, 1.0f); - ::add(span1, span2); - ::applyGain(piFour, span2); - ::cos(span2, span1); - ::sin(span2, span2); - ::copy(leftBuffer, span3); - ::copy(rightBuffer, leftBuffer); - ::multiplyAdd(span1, span3, leftBuffer); - ::multiplyAdd(span2, span3, rightBuffer); - ::applyGain(sqrtTwoInv, leftBuffer); - ::applyGain(sqrtTwoInv, rightBuffer); + fill(span2, 1.0f); + add(span1, span2); + applyGain(piFour, span2); + cos(span2, span1); + sin(span2, span2); + copy(leftBuffer, span3); + copy(rightBuffer, leftBuffer); + multiplyAdd(span1, span3, leftBuffer); + multiplyAdd(span2, span3, rightBuffer); + applyGain(sqrtTwoInv, leftBuffer); + applyGain(sqrtTwoInv, rightBuffer); } void sfz::Voice::fillWithData(AudioSpan buffer) noexcept @@ -358,11 +358,11 @@ void sfz::Voice::fillWithData(AudioSpan buffer) noexcept auto leftCoeffs = tempSpan1.first(buffer.getNumFrames()); auto rightCoeffs = tempSpan2.first(buffer.getNumFrames()); - ::fill(jumps, pitchRatio * speedRatio); + fill(jumps, pitchRatio * speedRatio); jumps[0] += floatPositionOffset; - ::cumsum(jumps, jumps); - ::sfzInterpolationCast(jumps, indices, leftCoeffs, rightCoeffs); - ::add(sourcePosition, indices); + cumsum(jumps, jumps); + sfzInterpolationCast(jumps, indices, leftCoeffs, rightCoeffs); + add(sourcePosition, indices); //FIXME : all this casting is driving me crazy const auto sampleEnd = min(static_cast(region->trueSampleEnd()), static_cast(source.getNumFrames())) - 1; @@ -371,16 +371,16 @@ void sfz::Voice::fillWithData(AudioSpan buffer) noexcept for (auto* index = indices.begin(); index < indices.end(); ++index) { if (*index > sampleEnd) { const auto remainingElements = static_cast(std::distance(index, indices.end())); - ::subtract(offset, { index, remainingElements }); + subtract(offset, { index, remainingElements }); } } } else { for (auto* index = indices.begin(); index < indices.end(); ++index) { if (*index > sampleEnd) { const auto remainingElements = static_cast(std::distance(index, indices.end())); - ::fill(indices.last(remainingElements), sampleEnd); - ::fill(leftCoeffs.last(remainingElements), 0.0f); - ::fill(rightCoeffs.last(remainingElements), 1.0f); + fill(indices.last(remainingElements), sampleEnd); + fill(leftCoeffs.last(remainingElements), 0.0f); + fill(rightCoeffs.last(remainingElements), 1.0f); break; } } @@ -430,10 +430,10 @@ void sfz::Voice::fillWithGenerator(AudioSpan buffer) noexcept return; float step = baseFrequency * twoPi / sampleRate; - phase = ::linearRamp(tempSpan1, phase, step); + phase = linearRamp(tempSpan1, phase, step); - ::sin(tempSpan1.first(buffer.getNumFrames()), buffer.getSpan(0)); - ::copy(buffer.getSpan(0), buffer.getSpan(1)); + sin(tempSpan1.first(buffer.getNumFrames()), buffer.getSpan(0)); + copy(buffer.getSpan(0), buffer.getSpan(1)); // Wrap the phase so we don't loose too much precision on longer notes const auto numTwoPiWraps = static_cast(phase / twoPi); diff --git a/tests/AudioBufferT.cpp b/tests/AudioBufferT.cpp index 87ee67fd..a2f8f55b 100644 --- a/tests/AudioBufferT.cpp +++ b/tests/AudioBufferT.cpp @@ -29,28 +29,28 @@ using namespace Catch::literals; TEST_CASE("[AudioBuffer] Empty buffers") { - AudioBuffer floatBuffer; + sfz::AudioBuffer floatBuffer; REQUIRE(floatBuffer.empty()); REQUIRE(floatBuffer.getNumFrames() == 0); - AudioBuffer doubleBuffer; + sfz::AudioBuffer doubleBuffer; REQUIRE(doubleBuffer.empty()); REQUIRE(doubleBuffer.getNumFrames() == 0); - AudioBuffer intBuffer; + sfz::AudioBuffer intBuffer; REQUIRE(intBuffer.empty()); REQUIRE(intBuffer.getNumFrames() == 0); } TEST_CASE("[AudioBuffer] Non-empty") { - AudioBuffer floatBuffer(1, 10); + sfz::AudioBuffer floatBuffer(1, 10); REQUIRE(!floatBuffer.empty()); REQUIRE(floatBuffer.getNumFrames() == 10); REQUIRE(floatBuffer.getNumChannels() == 1); - AudioBuffer doubleBuffer(2, 10); + sfz::AudioBuffer doubleBuffer(2, 10); REQUIRE(!doubleBuffer.empty()); REQUIRE(doubleBuffer.getNumFrames() == 10); REQUIRE(doubleBuffer.getNumChannels() == 2); - AudioBuffer intBuffer(1, 10); + sfz::AudioBuffer intBuffer(1, 10); REQUIRE(!intBuffer.empty()); REQUIRE(intBuffer.getNumFrames() == 10); REQUIRE(intBuffer.getNumChannels() == 1); @@ -59,7 +59,7 @@ TEST_CASE("[AudioBuffer] Non-empty") TEST_CASE("[AudioBuffer] Access") { const int size { 5 }; - AudioBuffer buffer(2, size); + sfz::AudioBuffer buffer(2, size); for (size_t frameIdx = 0; frameIdx < buffer.getNumFrames(); ++frameIdx) { buffer.getSample(0, frameIdx) = static_cast(buffer.getNumFrames()) + frameIdx; buffer.getSample(1, frameIdx) = static_cast(buffer.getNumFrames()) - frameIdx; @@ -77,7 +77,7 @@ TEST_CASE("[AudioBuffer] Iterators") { const int size { 256 }; const float fillValue { 2.0f }; - AudioBuffer buffer(2, size); + sfz::AudioBuffer buffer(2, size); std::fill(buffer.channelWriter(0), buffer.channelWriterEnd(0), fillValue); std::fill(buffer.channelWriter(1), buffer.channelWriterEnd(1), fillValue); @@ -89,14 +89,14 @@ TEST_CASE("[AudioSpan] Constructions") { const int size { 256 }; const float fillValue { 2.0f }; - AudioBuffer buffer(2, size); + sfz::AudioBuffer buffer(2, size); std::fill(buffer.channelWriter(0), buffer.channelWriterEnd(0), fillValue); std::fill(buffer.channelWriter(1), buffer.channelWriterEnd(1), fillValue); - AudioSpan span { buffer }; - AudioSpan constSpan { buffer }; - AudioSpan manualSpan { { buffer.channelWriter(0), buffer.channelWriter(1) }, buffer.getNumFrames() }; - AudioSpan manualConstSpan { { buffer.channelReader(0), buffer.channelReader(1) }, buffer.getNumFrames() }; - AudioSpan manualSpan2 { {buffer.getSpan(0), buffer.getSpan(1) } }; - AudioSpan manualConstSpan2 { {buffer.getConstSpan(0), buffer.getConstSpan(1) } }; + sfz::AudioSpan span { buffer }; + sfz::AudioSpan constSpan { buffer }; + sfz::AudioSpan manualSpan { { buffer.channelWriter(0), buffer.channelWriter(1) }, buffer.getNumFrames() }; + sfz::AudioSpan manualConstSpan { { buffer.channelReader(0), buffer.channelReader(1) }, buffer.getNumFrames() }; + sfz::AudioSpan manualSpan2 { {buffer.getSpan(0), buffer.getSpan(1) } }; + sfz::AudioSpan manualConstSpan2 { {buffer.getConstSpan(0), buffer.getConstSpan(1) } }; } \ No newline at end of file diff --git a/tests/BufferT.cpp b/tests/BufferT.cpp index 138fc2b9..9c79ae22 100644 --- a/tests/BufferT.cpp +++ b/tests/BufferT.cpp @@ -28,38 +28,38 @@ using namespace Catch::literals; TEST_CASE("[Buffer] Empty (float)") { - Buffer emptyBuffer; + sfz::Buffer emptyBuffer; REQUIRE(emptyBuffer.empty()); REQUIRE(emptyBuffer.size() == 0); } TEST_CASE("[Buffer] Empty (int)") { - Buffer emptyBuffer; + sfz::Buffer emptyBuffer; REQUIRE(emptyBuffer.empty()); REQUIRE(emptyBuffer.size() == 0); } TEST_CASE("[Buffer] Empty (double)") { - Buffer emptyBuffer; + sfz::Buffer emptyBuffer; REQUIRE(emptyBuffer.empty()); REQUIRE(emptyBuffer.size() == 0); } TEST_CASE("[Buffer] Empty (uint8_t)") { - Buffer emptyBuffer; + sfz::Buffer emptyBuffer; REQUIRE(emptyBuffer.empty()); REQUIRE(emptyBuffer.size() == 0); } template -void checkBoundaries(Buffer& buffer, int expectedSize) +void checkBoundaries(sfz::Buffer& buffer, int expectedSize) { REQUIRE((int)buffer.size() == expectedSize); - REQUIRE(((size_t)buffer.data() & (SIMDConfig::defaultAlignment - 1)) == 0); - REQUIRE(((size_t)buffer.alignedEnd() & (SIMDConfig::defaultAlignment - 1)) == 0); + REQUIRE(((size_t)buffer.data() & (sfz::SIMDConfig::defaultAlignment - 1)) == 0); + REQUIRE(((size_t)buffer.alignedEnd() & (sfz::SIMDConfig::defaultAlignment - 1)) == 0); REQUIRE(std::distance(buffer.begin(), buffer.end()) == expectedSize); REQUIRE(std::distance(buffer.begin(), buffer.alignedEnd()) >= expectedSize); } @@ -67,7 +67,7 @@ void checkBoundaries(Buffer& buffer, int expectedSize) TEST_CASE("[Buffer] 10 floats ") { const int baseSize { 10 }; - Buffer buffer(baseSize); + sfz::Buffer buffer(baseSize); checkBoundaries(buffer, baseSize); for (auto& element : buffer) @@ -81,7 +81,7 @@ TEST_CASE("[Buffer] Resize 10 floats ") const int baseSize { 10 }; const int smallSize { baseSize / 2 }; const int bigSize { baseSize * 2 }; - Buffer buffer(baseSize); + sfz::Buffer buffer(baseSize); REQUIRE(!buffer.empty()); checkBoundaries(buffer, baseSize); @@ -103,7 +103,7 @@ TEST_CASE("[Buffer] Resize 4096 floats ") const int baseSize { 4096 }; const int smallSize { baseSize / 2 }; const int bigSize { baseSize * 2 }; - Buffer buffer(baseSize); + sfz::Buffer buffer(baseSize); REQUIRE(!buffer.empty()); checkBoundaries(buffer, baseSize); @@ -125,7 +125,7 @@ TEST_CASE("[Buffer] Resize 65536 floats ") const int baseSize { 10 }; const int smallSize { baseSize / 2 }; const int bigSize { baseSize * 2 }; - Buffer buffer(baseSize); + sfz::Buffer buffer(baseSize); REQUIRE(!buffer.empty()); checkBoundaries(buffer, baseSize); @@ -145,19 +145,19 @@ TEST_CASE("[Buffer] Resize 65536 floats ") TEST_CASE("[Buffer] Copy and move") { const int baseSize { 128 }; - Buffer buffer(baseSize); - Buffer copied { baseSize - 4 }; + sfz::Buffer buffer(baseSize); + sfz::Buffer copied { baseSize - 4 }; std::fill(buffer.begin(), buffer.end(), 1.0f); std::fill(copied.begin(), copied.end(), 2.0f); copied = buffer; checkBoundaries(copied, baseSize); REQUIRE(std::all_of(copied.begin(), copied.end(), [](auto value) { return value == 1.0f; })); - Buffer copyConstructed { buffer }; + sfz::Buffer copyConstructed { buffer }; checkBoundaries(copyConstructed, baseSize); REQUIRE(std::all_of(copyConstructed.begin(), copyConstructed.end(), [](auto value) { return value == 1.0f; })); - Buffer moveConstructed { std::move(buffer) }; + sfz::Buffer moveConstructed { std::move(buffer) }; REQUIRE(buffer.empty()); checkBoundaries(moveConstructed, baseSize); REQUIRE(std::all_of(moveConstructed.begin(), moveConstructed.end(), [](auto value) { return value == 1.0f; })); diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 77c6f23b..882ff0fd 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -12,7 +12,6 @@ set(SFIZZ_TEST_SOURCES RangeT.cpp OpcodeT.cpp BufferT.cpp - StereoBufferT.cpp SIMDHelpersT.cpp FilesT.cpp OnePoleFilterT.cpp diff --git a/tests/OnePoleFilterT.cpp b/tests/OnePoleFilterT.cpp index f19c3cff..6df0b485 100644 --- a/tests/OnePoleFilterT.cpp +++ b/tests/OnePoleFilterT.cpp @@ -67,7 +67,7 @@ void testLowpass(const fs::path& inputNumpyFile, const fs::path& outputNumpyFile for (auto& data : outputSpan) expectedData.push_back(static_cast(data)); - OnePoleFilter filter { gain }; + sfz::OnePoleFilter filter { gain }; std::vector outputData(size); filter.processLowpass(inputData, absl::MakeSpan(outputData)); REQUIRE(approxEqual(outputData, expectedData)); @@ -102,7 +102,7 @@ void testHighpass(const fs::path& inputNumpyFile, const fs::path& outputNumpyFil for (auto& data : outputSpan) expectedData.push_back(static_cast(data)); - OnePoleFilter filter { gain }; + sfz::OnePoleFilter filter { gain }; std::vector outputData(size); filter.processHighpass(inputData, absl::MakeSpan(outputData)); REQUIRE(approxEqual(outputData, expectedData)); diff --git a/tests/SIMDHelpersT.cpp b/tests/SIMDHelpersT.cpp index 138df243..a0e798fc 100644 --- a/tests/SIMDHelpersT.cpp +++ b/tests/SIMDHelpersT.cpp @@ -69,7 +69,7 @@ TEST_CASE("[Helpers] fill() - Manual buffer") { std::vector buffer(5); std::vector expected { fillValue, fillValue, fillValue, fillValue, fillValue }; - fill(absl::MakeSpan(buffer), fillValue); + sfz::fill(absl::MakeSpan(buffer), fillValue); REQUIRE(buffer == expected); } @@ -79,7 +79,7 @@ TEST_CASE("[Helpers] fill() - Small buffer") std::vector expected(smallBufferSize); std::fill(expected.begin(), expected.end(), fillValue); - fill(absl::MakeSpan(buffer), fillValue); + sfz::fill(absl::MakeSpan(buffer), fillValue); REQUIRE(buffer == expected); } @@ -89,7 +89,7 @@ TEST_CASE("[Helpers] fill() - Big buffer") std::vector expected(bigBufferSize); std::fill(expected.begin(), expected.end(), fillValue); - fill(absl::MakeSpan(buffer), fillValue); + sfz::fill(absl::MakeSpan(buffer), fillValue); REQUIRE(buffer == expected); } @@ -99,7 +99,7 @@ TEST_CASE("[Helpers] fill() - Small buffer -- SIMD") std::vector expected(smallBufferSize); std::fill(expected.begin(), expected.end(), fillValue); - fill(absl::MakeSpan(buffer), fillValue); + sfz::fill(absl::MakeSpan(buffer), fillValue); REQUIRE(buffer == expected); } @@ -109,7 +109,7 @@ TEST_CASE("[Helpers] fill() - Big buffer -- SIMD") std::vector expected(bigBufferSize); std::fill(expected.begin(), expected.end(), fillValue); - fill(absl::MakeSpan(buffer), fillValue); + sfz::fill(absl::MakeSpan(buffer), fillValue); REQUIRE(buffer == expected); } @@ -119,7 +119,7 @@ TEST_CASE("[Helpers] fill() - Small buffer -- doubles") std::vector expected(smallBufferSize); std::fill(expected.begin(), expected.end(), fillValue); - fill(absl::MakeSpan(buffer), fillValue); + sfz::fill(absl::MakeSpan(buffer), fillValue); REQUIRE(buffer == expected); } @@ -129,7 +129,7 @@ TEST_CASE("[Helpers] fill() - Big buffer -- doubles") std::vector expected(bigBufferSize); std::fill(expected.begin(), expected.end(), fillValue); - fill(absl::MakeSpan(buffer), fillValue); + sfz::fill(absl::MakeSpan(buffer), fillValue); REQUIRE(buffer == expected); } @@ -139,7 +139,7 @@ TEST_CASE("[Helpers] Interleaved read") std::array expected { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f }; std::array leftOutput; std::array rightOutput; - readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); + sfz::readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); std::array real; auto realIdx = 0; @@ -156,7 +156,7 @@ TEST_CASE("[Helpers] Interleaved read unaligned end") std::array expected { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f }; std::array leftOutput; std::array rightOutput; - readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); + sfz::readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); std::array real; auto realIdx = 0; @@ -173,7 +173,7 @@ TEST_CASE("[Helpers] Small interleaved read unaligned end") std::array expected { 0.0f, 1.0f, 2.0f, 10.0f, 11.0f, 12.0f }; std::array leftOutput; std::array rightOutput; - readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); + sfz::readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); std::array real; auto realIdx = 0; @@ -190,7 +190,7 @@ TEST_CASE("[Helpers] Interleaved read -- SIMD") std::array expected = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f }; std::array leftOutput; std::array rightOutput; - readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); + sfz::readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); std::array real; auto realIdx = 0; @@ -207,7 +207,7 @@ TEST_CASE("[Helpers] Interleaved read unaligned end -- SIMD") std::array expected = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f }; std::array leftOutput; std::array rightOutput; - readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); + sfz::readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); std::array real; auto realIdx = 0; @@ -224,7 +224,7 @@ TEST_CASE("[Helpers] Small interleaved read unaligned end -- SIMD") std::array expected { 0.0f, 1.0f, 2.0f, 10.0f, 11.0f, 12.0f }; std::array leftOutput; std::array rightOutput; - readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); + sfz::readInterleaved(input, absl::MakeSpan(leftOutput), absl::MakeSpan(rightOutput)); std::array real; auto realIdx = 0; @@ -243,8 +243,8 @@ TEST_CASE("[Helpers] Interleaved read SIMD vs Scalar") std::array leftOutputSIMD; std::array rightOutputSIMD; std::iota(input.begin(), input.end(), 0.0f); - readInterleaved(input, absl::MakeSpan(leftOutputScalar), absl::MakeSpan(rightOutputScalar)); - readInterleaved(input, absl::MakeSpan(leftOutputSIMD), absl::MakeSpan(rightOutputSIMD)); + sfz::readInterleaved(input, absl::MakeSpan(leftOutputScalar), absl::MakeSpan(rightOutputScalar)); + sfz::readInterleaved(input, absl::MakeSpan(leftOutputSIMD), absl::MakeSpan(rightOutputSIMD)); REQUIRE(leftOutputScalar == leftOutputSIMD); REQUIRE(rightOutputScalar == rightOutputSIMD); } @@ -264,7 +264,7 @@ TEST_CASE("[Helpers] Interleaved write") std::array rightInput { 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f }; std::array output; std::array expected { 0.0f, 10.0f, 1.0f, 11.0f, 2.0f, 12.0f, 3.0f, 13.0f, 4.0f, 14.0f, 5.0f, 15.0f, 6.0f, 16.0f, 7.0f, 17.0f }; - writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); + sfz::writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -274,7 +274,7 @@ TEST_CASE("[Helpers] Interleaved write unaligned end") std::array rightInput { 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f }; std::array output; std::array expected { 0.0f, 10.0f, 1.0f, 11.0f, 2.0f, 12.0f, 3.0f, 13.0f, 4.0f, 14.0f, 5.0f, 15.0f, 6.0f, 16.0f, 7.0f, 17.0f, 8.0f, 18.0f, 9.0f, 19.0f }; - writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); + sfz::writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -284,7 +284,7 @@ TEST_CASE("[Helpers] Small interleaved write unaligned end") std::array rightInput { 10.0f, 11.0f, 12.0f }; std::array output; std::array expected { 0.0f, 10.0f, 1.0f, 11.0f, 2.0f, 12.0f }; - writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); + sfz::writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -303,7 +303,7 @@ TEST_CASE("[Helpers] Interleaved write -- SIMD") std::array rightInput { 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f }; std::array output; std::array expected { 0.0f, 10.0f, 1.0f, 11.0f, 2.0f, 12.0f, 3.0f, 13.0f, 4.0f, 14.0f, 5.0f, 15.0f, 6.0f, 16.0f, 7.0f, 17.0f }; - writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); + sfz::writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -313,7 +313,7 @@ TEST_CASE("[Helpers] Interleaved write unaligned end -- SIMD") std::array rightInput { 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f }; std::array output; std::array expected = { 0.0f, 10.0f, 1.0f, 11.0f, 2.0f, 12.0f, 3.0f, 13.0f, 4.0f, 14.0f, 5.0f, 15.0f, 6.0f, 16.0f, 7.0f, 17.0f, 8.0f, 18.0f, 9.0f, 19.0f }; - writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); + sfz::writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -323,7 +323,7 @@ TEST_CASE("[Helpers] Small interleaved write unaligned end -- SIMD") std::array rightInput { 10.0f, 11.0f, 12.0f }; std::array output; std::array expected { 0.0f, 10.0f, 1.0f, 11.0f, 2.0f, 12.0f }; - writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); + sfz::writeInterleaved(leftInput, rightInput, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -335,8 +335,8 @@ TEST_CASE("[Helpers] Interleaved write SIMD vs Scalar") std::array outputSIMD; std::iota(leftInput.begin(), leftInput.end(), 0.0f); std::iota(rightInput.begin(), rightInput.end(), medBufferSize); - writeInterleaved(leftInput, rightInput, absl::MakeSpan(outputScalar)); - writeInterleaved(leftInput, rightInput, absl::MakeSpan(outputSIMD)); + sfz::writeInterleaved(leftInput, rightInput, absl::MakeSpan(outputScalar)); + sfz::writeInterleaved(leftInput, rightInput, absl::MakeSpan(outputSIMD)); REQUIRE(outputScalar == outputSIMD); } @@ -345,7 +345,7 @@ TEST_CASE("[Helpers] Gain, single") std::array input { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array output { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; std::array expected { fillValue, fillValue, fillValue, fillValue, fillValue }; - applyGain(fillValue, input, absl::MakeSpan(output)); + sfz::applyGain(fillValue, input, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -353,7 +353,7 @@ TEST_CASE("[Helpers] Gain, single and inplace") { std::array buffer { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array expected { fillValue, fillValue, fillValue, fillValue, fillValue }; - applyGain(fillValue, buffer, absl::MakeSpan(buffer)); + sfz::applyGain(fillValue, buffer, absl::MakeSpan(buffer)); REQUIRE(buffer == expected); } @@ -363,7 +363,7 @@ TEST_CASE("[Helpers] Gain, spans") std::array gain { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array output { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; std::array expected { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; - applyGain(gain, input, absl::MakeSpan(output)); + sfz::applyGain(gain, input, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -372,7 +372,7 @@ TEST_CASE("[Helpers] Gain, spans and inplace") std::array buffer { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array gain { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array expected { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; - applyGain(gain, buffer, absl::MakeSpan(buffer)); + sfz::applyGain(gain, buffer, absl::MakeSpan(buffer)); REQUIRE(buffer == expected); } @@ -381,7 +381,7 @@ TEST_CASE("[Helpers] Gain, single (SIMD)") std::array input { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array output { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; std::array expected { fillValue, fillValue, fillValue, fillValue, fillValue }; - applyGain(fillValue, input, absl::MakeSpan(output)); + sfz::applyGain(fillValue, input, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -389,7 +389,7 @@ TEST_CASE("[Helpers] Gain, single and inplace (SIMD)") { std::array buffer { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array expected { fillValue, fillValue, fillValue, fillValue, fillValue }; - applyGain(fillValue, buffer, absl::MakeSpan(buffer)); + sfz::applyGain(fillValue, buffer, absl::MakeSpan(buffer)); REQUIRE(buffer == expected); } @@ -399,7 +399,7 @@ TEST_CASE("[Helpers] Gain, spans (SIMD)") std::array gain { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array output { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f }; std::array expected { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; - applyGain(gain, input, absl::MakeSpan(output)); + sfz::applyGain(gain, input, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -408,7 +408,7 @@ TEST_CASE("[Helpers] Gain, spans and inplace (SIMD)") std::array buffer { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array gain { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array expected { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; - applyGain(gain, buffer, absl::MakeSpan(buffer)); + sfz::applyGain(gain, buffer, absl::MakeSpan(buffer)); REQUIRE(buffer == expected); } @@ -421,7 +421,7 @@ TEST_CASE("[Helpers] SFZ looping index") std::array expectedIndices { 2, 3, 4, 1, 2, 4 }; std::array expectedLeft { 0.9f, 0.7f, 0.4f, 1.0f, 0.5f, 0.9f }; std::array expectedRight { 0.1f, 0.3f, 0.6f, 0.0f, 0.5f, 0.1f }; - loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 6, 1); + sfz::loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 6, 1); REQUIRE(indices == expectedIndices); REQUIRE(approxEqual(leftCoeffs, expectedLeft)); REQUIRE(approxEqual(rightCoeffs, expectedRight)); @@ -436,7 +436,7 @@ TEST_CASE("[Helpers] SFZ looping index (SIMD)") std::array expectedIndices { 2, 3, 4, 1, 2, 4 }; std::array expectedLeft { 0.9f, 0.7f, 0.4f, 1.0f, 0.5f, 0.9f }; std::array expectedRight { 0.1f, 0.3f, 0.6f, 0.0f, 0.5f, 0.1f }; - loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 6, 1); + sfz::loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 6, 1); REQUIRE(indices == expectedIndices); REQUIRE(approxEqual(leftCoeffs, expectedLeft)); REQUIRE(approxEqual(rightCoeffs, expectedRight)); @@ -455,8 +455,8 @@ TEST_CASE("[Helpers] SFZ looping index (SIMD)") // std::vector indicesSIMD(bigBufferSize); // std::vector leftCoeffsSIMD(bigBufferSize); // std::vector rightCoeffsSIMD(bigBufferSize); -// loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, medBufferSize, 1); -// loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffsSIMD), absl::MakeSpan(rightCoeffsSIMD), absl::MakeSpan(indicesSIMD), 1.0f, medBufferSize, 1); +// sfz::loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, medBufferSize, 1); +// sfz::loopingSFZIndex(jumps, absl::MakeSpan(leftCoeffsSIMD), absl::MakeSpan(rightCoeffsSIMD), absl::MakeSpan(indicesSIMD), 1.0f, medBufferSize, 1); // for (int i = 0; i < bigBufferSize; ++i) // REQUIRE( ((static_cast(indices[i]) + rightCoeffs[i] == Approx(static_cast(indicesSIMD[i]) + rightCoeffsSIMD[i]).margin(1e-2)) // || (static_cast(indices[i]) + rightCoeffs[i] == Approx(static_cast(indicesSIMD[i]) + rightCoeffsSIMD[i] - static_cast(medBufferSize)).margin(2e-2))) ); @@ -471,7 +471,7 @@ TEST_CASE("[Helpers] SFZ saturating index") std::array expectedIndices { 2, 3, 4, 5, 5, 5 }; std::array expectedLeft { 0.9f, 0.7f, 0.4f, 0.0f, 0.0f, 0.0f }; std::array expectedRight { 0.1f, 0.3f, 0.6f, 1.0f, 1.0f, 1.0f }; - saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 6); + sfz::saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 6); REQUIRE(indices == expectedIndices); REQUIRE(approxEqual(leftCoeffs, expectedLeft)); REQUIRE(approxEqual(rightCoeffs, expectedRight)); @@ -486,7 +486,7 @@ TEST_CASE("[Helpers] SFZ saturating index (SIMD)") std::array expectedIndices { 2, 3, 4, 5, 5, 5 }; std::array expectedLeft { 0.9f, 0.7f, 0.4f, 0.0f, 0.0f, 0.0f }; std::array expectedRight { 0.1f, 0.3f, 0.6f, 1.0f, 1.0f, 1.0f }; - saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 6); + sfz::saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 6); REQUIRE(indices == expectedIndices); REQUIRE(approxEqualMargin(leftCoeffs, expectedLeft)); REQUIRE(approxEqualMargin(rightCoeffs, expectedRight)); @@ -505,8 +505,8 @@ TEST_CASE("[Helpers] SFZ saturating index (SIMD vs Scalar)") std::vector indicesSIMD(medBufferSize); std::vector leftCoeffsSIMD(medBufferSize); std::vector rightCoeffsSIMD(medBufferSize); - saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 78); - saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffsSIMD), absl::MakeSpan(rightCoeffsSIMD), absl::MakeSpan(indicesSIMD), 1.0f, 78); + sfz::saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffs), absl::MakeSpan(rightCoeffs), absl::MakeSpan(indices), 1.0f, 78); + sfz::saturatingSFZIndex(jumps, absl::MakeSpan(leftCoeffsSIMD), absl::MakeSpan(rightCoeffsSIMD), absl::MakeSpan(indicesSIMD), 1.0f, 78); for (int i = 0; i < medBufferSize; ++i) REQUIRE( static_cast(indices[i]) + rightCoeffs[i] == Approx(static_cast(indicesSIMD[i]) + rightCoeffsSIMD[i])); } @@ -517,7 +517,7 @@ TEST_CASE("[Helpers] Linear Ramp") const float v { fillValue }; std::array output; std::array expected { v, v + v, v + v + v, v + v + v + v, v + v + v + v + v, v + v + v + v + v + v }; - linearRamp(absl::MakeSpan(output), start, v); + sfz::linearRamp(absl::MakeSpan(output), start, v); REQUIRE(output == expected); } @@ -527,7 +527,7 @@ TEST_CASE("[Helpers] Linear Ramp (SIMD)") const float v { fillValue }; std::array output; std::array expected { v, v + v, v + v + v, v + v + v + v, v + v + v + v + v, v + v + v + v + v + v }; - linearRamp(absl::MakeSpan(output), start, v); + sfz::linearRamp(absl::MakeSpan(output), start, v); REQUIRE(approxEqual(output, expected)); } @@ -536,8 +536,8 @@ TEST_CASE("[Helpers] Linear Ramp (SIMD vs scalar)") const float start { 0.0f }; std::vector outputScalar(bigBufferSize); std::vector outputSIMD(bigBufferSize); - linearRamp(absl::MakeSpan(outputScalar), start, fillValue); - linearRamp(absl::MakeSpan(outputSIMD), start, fillValue); + sfz::linearRamp(absl::MakeSpan(outputScalar), start, fillValue); + sfz::linearRamp(absl::MakeSpan(outputSIMD), start, fillValue); REQUIRE(approxEqual(outputScalar, outputSIMD)); } @@ -546,8 +546,8 @@ TEST_CASE("[Helpers] Linear Ramp unaligned (SIMD vs scalar)") const float start { 0.0f }; std::vector outputScalar(bigBufferSize); std::vector outputSIMD(bigBufferSize); - linearRamp(absl::MakeSpan(outputScalar).subspan(1), start, fillValue); - linearRamp(absl::MakeSpan(outputSIMD).subspan(1), start, fillValue); + sfz::linearRamp(absl::MakeSpan(outputScalar).subspan(1), start, fillValue); + sfz::linearRamp(absl::MakeSpan(outputSIMD).subspan(1), start, fillValue); REQUIRE(approxEqual(outputScalar, outputSIMD)); } @@ -557,7 +557,7 @@ TEST_CASE("[Helpers] Multiplicative Ramp") const float v { fillValue }; std::array output; std::array expected { v, v * v, v * v * v, v * v * v * v, v * v * v * v * v, v * v * v * v * v * v }; - multiplicativeRamp(absl::MakeSpan(output), start, v); + sfz::multiplicativeRamp(absl::MakeSpan(output), start, v); REQUIRE(output == expected); } @@ -567,7 +567,7 @@ TEST_CASE("[Helpers] Multiplicative Ramp (SIMD)") const float v { fillValue }; std::array output; std::array expected { v, v * v, v * v * v, v * v * v * v, v * v * v * v * v, v * v * v * v * v * v }; - multiplicativeRamp(absl::MakeSpan(output), start, v); + sfz::multiplicativeRamp(absl::MakeSpan(output), start, v); REQUIRE(output == expected); } @@ -576,8 +576,8 @@ TEST_CASE("[Helpers] Multiplicative Ramp (SIMD vs scalar)") const float start { 1.0f }; std::vector outputScalar(bigBufferSize); std::vector outputSIMD(bigBufferSize); - multiplicativeRamp(absl::MakeSpan(outputScalar), start, fillValue); - multiplicativeRamp(absl::MakeSpan(outputSIMD), start, fillValue); + sfz::multiplicativeRamp(absl::MakeSpan(outputScalar), start, fillValue); + sfz::multiplicativeRamp(absl::MakeSpan(outputSIMD), start, fillValue); REQUIRE(approxEqual(outputScalar, outputSIMD)); } @@ -586,8 +586,8 @@ TEST_CASE("[Helpers] Multiplicative Ramp unaligned (SIMD vs scalar)") const float start { 1.0f }; std::vector outputScalar(bigBufferSize); std::vector outputSIMD(bigBufferSize); - multiplicativeRamp(absl::MakeSpan(outputScalar).subspan(1), start, fillValue); - multiplicativeRamp(absl::MakeSpan(outputSIMD).subspan(1), start, fillValue); + sfz::multiplicativeRamp(absl::MakeSpan(outputScalar).subspan(1), start, fillValue); + sfz::multiplicativeRamp(absl::MakeSpan(outputSIMD).subspan(1), start, fillValue); REQUIRE(approxEqual(outputScalar, outputSIMD)); } @@ -596,7 +596,7 @@ TEST_CASE("[Helpers] Add") std::array input { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array output { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array expected { 2.0, 3.0, 4.0, 5.0, 6.0 }; - add(input, absl::MakeSpan(output)); + sfz::add(input, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -605,7 +605,7 @@ TEST_CASE("[Helpers] Add (SIMD)") std::array input { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array output { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array expected { 2.0, 3.0, 4.0, 5.0, 6.0 }; - add(input, absl::MakeSpan(output)); + sfz::add(input, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -618,8 +618,8 @@ TEST_CASE("[Helpers] Add (SIMD vs scalar)") absl::c_fill(outputScalar, 0.0); absl::c_fill(outputSIMD, 0.0); - add(input, absl::MakeSpan(outputScalar)); - add(input, absl::MakeSpan(outputSIMD)); + sfz::add(input, absl::MakeSpan(outputScalar)); + sfz::add(input, absl::MakeSpan(outputSIMD)); REQUIRE(approxEqual(outputScalar, outputSIMD)); } @@ -628,7 +628,7 @@ TEST_CASE("[Helpers] Subtract") std::array input { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array output { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array expected { 0.0, -1.0, -2.0, -3.0, -4.0 }; - subtract(input, absl::MakeSpan(output)); + sfz::subtract(input, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -636,7 +636,7 @@ TEST_CASE("[Helpers] Subtract 2") { std::array output { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array expected { 0.0, 1.0, 2.0, 3.0, 4.0 }; - subtract(1.0f, absl::MakeSpan(output)); + sfz::subtract(1.0f, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -646,7 +646,7 @@ TEST_CASE("[Helpers] Subtract (SIMD)") std::array input { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array output { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; std::array expected { 0.0, -1.0, -2.0, -3.0, -4.0 }; - subtract(input, absl::MakeSpan(output)); + sfz::subtract(input, absl::MakeSpan(output)); REQUIRE(output == expected); } @@ -659,8 +659,8 @@ TEST_CASE("[Helpers] Subtract (SIMD vs scalar)") absl::c_fill(outputScalar, 0.0); absl::c_fill(outputSIMD, 0.0); - subtract(input, absl::MakeSpan(outputScalar)); - subtract(input, absl::MakeSpan(outputSIMD)); + sfz::subtract(input, absl::MakeSpan(outputScalar)); + sfz::subtract(input, absl::MakeSpan(outputSIMD)); REQUIRE(approxEqual(outputScalar, outputSIMD)); } @@ -671,8 +671,8 @@ TEST_CASE("[Helpers] Subtract 2 (SIMD vs scalar)") absl::c_iota(outputScalar, 0.0); absl::c_iota(outputSIMD, 0.0); - subtract(1.2f, absl::MakeSpan(outputScalar)); - subtract(1.2f, absl::MakeSpan(outputSIMD)); + sfz::subtract(1.2f, absl::MakeSpan(outputScalar)); + sfz::subtract(1.2f, absl::MakeSpan(outputSIMD)); REQUIRE(approxEqual(outputScalar, outputSIMD)); } @@ -680,7 +680,7 @@ TEST_CASE("[Helpers] copy") { std::array input { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array output { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; - copy(input, absl::MakeSpan(output)); + sfz::copy(input, absl::MakeSpan(output)); REQUIRE(output == input); } @@ -688,7 +688,7 @@ TEST_CASE("[Helpers] copy (SIMD)") { std::array input { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; std::array output { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; - copy(input, absl::MakeSpan(output)); + sfz::copy(input, absl::MakeSpan(output)); REQUIRE(output == input); } @@ -701,37 +701,37 @@ TEST_CASE("[Helpers] copy (SIMD vs scalar)") absl::c_fill(outputScalar, 0.0); absl::c_fill(outputSIMD, 0.0); - add(input, absl::MakeSpan(outputScalar)); - add(input, absl::MakeSpan(outputSIMD)); + sfz::add(input, absl::MakeSpan(outputScalar)); + sfz::add(input, absl::MakeSpan(outputSIMD)); REQUIRE(approxEqual(outputScalar, outputSIMD)); } TEST_CASE("[Helpers] Mean") { std::array input { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f }; - REQUIRE(mean(input) == 5.5f); - REQUIRE(mean(input) == 5.5f); + REQUIRE(sfz::mean(input) == 5.5f); + REQUIRE(sfz::mean(input) == 5.5f); } TEST_CASE("[Helpers] Mean (SIMD vs scalar)") { std::vector input(bigBufferSize); absl::c_iota(input, 0.0); - REQUIRE(mean(input) == Approx(mean(input)).margin(0.001)); + REQUIRE(sfz::mean(input) == Approx(sfz::mean(input)).margin(0.001)); } TEST_CASE("[Helpers] Mean Squared") { std::array input { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f }; - REQUIRE(meanSquared(input) == 38.5f); - REQUIRE(meanSquared(input) == 38.5f); + REQUIRE(sfz::meanSquared(input) == 38.5f); + REQUIRE(sfz::meanSquared(input) == 38.5f); } TEST_CASE("[Helpers] Mean Squared (SIMD vs scalar)") { std::vector input(medBufferSize); absl::c_iota(input, 0.0); - REQUIRE(meanSquared(input) == meanSquared(input)); + REQUIRE(sfz::meanSquared(input) == sfz::meanSquared(input)); } TEST_CASE("[Helpers] Cumulative sum ") @@ -739,7 +739,7 @@ TEST_CASE("[Helpers] Cumulative sum ") std::array input { 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f }; // 1.1 2.3 3.6 5.0 6.5 8.1 std::array output; std::array expected { 1.1f, 2.3f, 3.6f, 5.0f, 6.5f, 8.1f }; - cumsum(input, absl::MakeSpan(output)); + sfz::cumsum(input, absl::MakeSpan(output)); REQUIRE(approxEqual(output, expected)); } @@ -748,9 +748,9 @@ TEST_CASE("[Helpers] Cumulative sum (SIMD vs Scalar)") std::vector input(bigBufferSize); std::vector outputScalar(bigBufferSize); std::vector outputSIMD(bigBufferSize); - linearRamp(absl::MakeSpan(input), 0.0, 0.1); - cumsum(input, absl::MakeSpan(outputScalar)); - cumsum(input, absl::MakeSpan(outputSIMD)); + sfz::linearRamp(absl::MakeSpan(input), 0.0, 0.1); + sfz::cumsum(input, absl::MakeSpan(outputScalar)); + sfz::cumsum(input, absl::MakeSpan(outputSIMD)); REQUIRE(approxEqual(outputScalar, outputSIMD)); } @@ -759,7 +759,7 @@ TEST_CASE("[Helpers] Diff ") std::array input { 1.1f, 2.3f, 3.6f, 5.0f, 6.5f, 8.1f }; std::array output; std::array expected { 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f }; - diff(input, absl::MakeSpan(output)); + sfz::diff(input, absl::MakeSpan(output)); REQUIRE(approxEqual(output, expected)); } @@ -768,8 +768,8 @@ TEST_CASE("[Helpers] Diff (SIMD vs Scalar)") std::vector input(bigBufferSize); std::vector outputScalar(bigBufferSize); std::vector outputSIMD(bigBufferSize); - linearRamp(absl::MakeSpan(input), 0.0, 0.1); - diff(input, absl::MakeSpan(outputScalar)); - diff(input, absl::MakeSpan(outputSIMD)); + sfz::linearRamp(absl::MakeSpan(input), 0.0, 0.1); + sfz::diff(input, absl::MakeSpan(outputScalar)); + sfz::diff(input, absl::MakeSpan(outputSIMD)); REQUIRE(approxEqual(outputScalar, outputSIMD)); } \ No newline at end of file diff --git a/tests/StereoBufferT.cpp b/tests/StereoBufferT.cpp deleted file mode 100644 index 6c69d239..00000000 --- a/tests/StereoBufferT.cpp +++ /dev/null @@ -1,208 +0,0 @@ -// Copyright (c) 2019, Paul Ferrand -// All rights reserved. - -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: - -// 1. Redistributions of source code must retain the above copyright notice, this -// list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. - -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#include "StereoBuffer.h" -#include "catch2/catch.hpp" -#include -using namespace Catch::literals; - -TEST_CASE("[StereoBuffer] Empty buffers") -{ - StereoBuffer floatBuffer; - REQUIRE(floatBuffer.empty()); - REQUIRE(floatBuffer.getNumFrames() == 0); - StereoBuffer doubleBuffer; - REQUIRE(doubleBuffer.empty()); - REQUIRE(doubleBuffer.getNumFrames() == 0); - StereoBuffer intBuffer; - REQUIRE(intBuffer.empty()); - REQUIRE(intBuffer.getNumFrames() == 0); -} - -TEST_CASE("[StereoBuffer] Non-empty") -{ - StereoBuffer floatBuffer(10); - REQUIRE(!floatBuffer.empty()); - REQUIRE(floatBuffer.getNumFrames() == 10); - StereoBuffer doubleBuffer(10); - REQUIRE(!doubleBuffer.empty()); - REQUIRE(doubleBuffer.getNumFrames() == 10); - StereoBuffer intBuffer(10); - REQUIRE(!intBuffer.empty()); - REQUIRE(intBuffer.getNumFrames() == 10); -} - -TEST_CASE("[StereoBuffer] Access") -{ - const int size { 5 }; - StereoBuffer doubleBuffer(size); - for (auto frameIdx = 0; frameIdx < doubleBuffer.getNumFrames(); ++frameIdx) { - doubleBuffer.getSample(Channel::left, frameIdx) = static_cast(doubleBuffer.getNumFrames()) + frameIdx; - doubleBuffer.getSample(Channel::right, frameIdx) = static_cast(doubleBuffer.getNumFrames()) - frameIdx; - } - - for (auto frameIdx = 0; frameIdx < doubleBuffer.getNumFrames(); ++frameIdx) { - REQUIRE(doubleBuffer.getSample(Channel::left, frameIdx) == static_cast(doubleBuffer.getNumFrames()) + frameIdx); - REQUIRE(doubleBuffer(Channel::left, frameIdx) == static_cast(doubleBuffer.getNumFrames()) + frameIdx); - REQUIRE(doubleBuffer.getSample(Channel::right, frameIdx) == static_cast(doubleBuffer.getNumFrames()) - frameIdx); - REQUIRE(doubleBuffer(Channel::right, frameIdx) == static_cast(doubleBuffer.getNumFrames()) - frameIdx); - } -} - -TEST_CASE("[StereoBuffer] Iterators") -{ - const int size { 256 }; - const float fillValue { 2.0f }; - StereoBuffer buffer(size); - std::fill(buffer.begin(Channel::left), buffer.end(Channel::left), fillValue); - std::fill(buffer.begin(Channel::right), buffer.end(Channel::right), fillValue); - - REQUIRE(std::all_of(buffer.begin(Channel::left), buffer.end(Channel::left), [fillValue](auto value) { return value == fillValue; })); - REQUIRE(std::all_of(buffer.begin(Channel::right), buffer.end(Channel::right), [fillValue](auto value) { return value == fillValue; })); -} - -template -void channelAlignmentTest(int size) -{ - static constexpr auto AlignmentMask { Alignment - 1 }; - StereoBuffer buffer(size); - REQUIRE(((size_t)buffer.getChannel(Channel::left) & AlignmentMask) == 0); - REQUIRE(((size_t)buffer.getChannel(Channel::right) & AlignmentMask) == 0); -} - -TEST_CASE("[StereoBuffer] Channel alignments (floats)") -{ - channelAlignmentTest(4); - channelAlignmentTest(5); - channelAlignmentTest(8); - channelAlignmentTest(256); - channelAlignmentTest(257); - channelAlignmentTest(1023); - channelAlignmentTest(1024); - channelAlignmentTest(65537); - channelAlignmentTest(65536); - channelAlignmentTest(65535); - - channelAlignmentTest(4); - channelAlignmentTest(5); - channelAlignmentTest(8); - channelAlignmentTest(256); - channelAlignmentTest(257); - channelAlignmentTest(1023); - channelAlignmentTest(1024); - channelAlignmentTest(65537); - channelAlignmentTest(65536); - channelAlignmentTest(65535); - - channelAlignmentTest(4); - channelAlignmentTest(5); - channelAlignmentTest(8); - channelAlignmentTest(256); - channelAlignmentTest(257); - channelAlignmentTest(1023); - channelAlignmentTest(1024); - channelAlignmentTest(65537); - channelAlignmentTest(65536); - channelAlignmentTest(65535); -} - -TEST_CASE("[StereoBuffer] Channel alignments (doubles)") -{ - channelAlignmentTest(4); - channelAlignmentTest(5); - channelAlignmentTest(8); - channelAlignmentTest(256); - channelAlignmentTest(257); - channelAlignmentTest(1023); - channelAlignmentTest(1024); - channelAlignmentTest(65537); - channelAlignmentTest(65536); - channelAlignmentTest(65535); - - channelAlignmentTest(4); - channelAlignmentTest(5); - channelAlignmentTest(8); - channelAlignmentTest(256); - channelAlignmentTest(257); - channelAlignmentTest(1023); - channelAlignmentTest(1024); - channelAlignmentTest(65537); - channelAlignmentTest(65536); - channelAlignmentTest(65535); -} - -TEST_CASE("[AudioBuffer] fills") -{ - StereoBuffer buffer(10); - buffer.fill(1.3f); - std::array expected; - std::fill(expected.begin(), expected.end(), 1.3f); - std::array real { 0.0f }; - - for (auto frameIdx = 0; frameIdx < buffer.getNumFrames(); ++frameIdx) - real[frameIdx] = buffer(Channel::left, frameIdx); - REQUIRE(real == expected); - - for (auto frameIdx = 0; frameIdx < buffer.getNumFrames(); ++frameIdx) - real[frameIdx] = buffer(Channel::right, frameIdx); - REQUIRE(real == expected); -} - -TEST_CASE("[AudioBuffer] Fill a big Audiobuffer") -{ - constexpr int size { 2039247 }; - StereoBuffer buffer(size); - std::vector input(2 * size); - std::iota(input.begin(), input.end(), 1.0f); - buffer.readInterleaved(input); -} - -TEST_CASE("[StereoBuffer] Interleaved write -- Scalar") -{ - StereoBuffer buffer(10); - std::array input = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f }; - std::array output { 0.0f }; - buffer.readInterleaved(input); - buffer.writeInterleaved(absl::MakeSpan(output)); - REQUIRE(output == input); -} - -TEST_CASE("[StereoBuffer] Interleaved write -- SIMD") -{ - StereoBuffer buffer(10); - std::array input = { 0.0f, 10.0f, 1.0f, 11.0f, 2.0f, 12.0f, 3.0f, 13.0f, 4.0f, 14.0f, 5.0f, 15.0f, 6.0f, 16.0f, 7.0f, 17.0f, 8.0f, 18.0f, 9.0f, 19.0f }; - std::array output { 0.0f }; - buffer.readInterleaved(input); - buffer.writeInterleaved(absl::MakeSpan(output)); - REQUIRE(output == input); -} - -TEST_CASE("[StereoBuffer] Small interleaved write -- SIMD") -{ - StereoBuffer buffer(3); - std::array input = { 0.0f, 10.0f, 1.0f, 11.0f, 2.0f, 12.0f }; - std::array output { 0.0f }; - buffer.readInterleaved(input); - buffer.writeInterleaved(absl::MakeSpan(output)); - REQUIRE(output == input); -} \ No newline at end of file