diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0427601..224de23 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -502,7 +502,8 @@ jobs: -DCMAKE_BUILD_TYPE=Release -DSRT_BUILD_BENCHMARKS=ON -DSRT_BUILD_COMPARE_BENCH=ON - && cmake --build build-host -j 4 --target srt_bench_compare + -DSRT_BUILD_COMPARE_SHIM=ON + && cmake --build build-host -j 4 --target srt_bench_compare srt_r8b_shim - name: Build M55 comparison workload run: > @@ -512,6 +513,7 @@ jobs: -DSRT_BUILD_TESTS=OFF -DSRT_BUILD_EXAMPLES=OFF -DSRT_BUILD_ICOUNT_BENCH=ON -DSRT_ICOUNT_COMPARE=ON && cmake --build build-m55 -j 4 --target cmp_icount_lsr_medium + cmp_icount_srt_q15 cmp_icount_r8b_120 clang-format: name: clang-format diff --git a/.github/workflows/compare.yml b/.github/workflows/compare.yml index 01409cd..c2c1673 100644 --- a/.github/workflows/compare.yml +++ b/.github/workflows/compare.yml @@ -58,7 +58,10 @@ jobs: -DSRT_BUILD_TESTS=OFF -DSRT_BUILD_EXAMPLES=OFF \ -DSRT_BUILD_ICOUNT_BENCH=ON -DSRT_ICOUNT_COMPARE=ON cmake --build build-$tgt -j 4 - for bin in cmp_icount_srt_float cmp_icount_lsr_medium cmp_icount_lsr_best; do + # Each engine at 2 s and 4 s: the difference is steady state, the + # remainder construction (bench/icount/cmp_main.cpp). + for bin in $(for e in srt_float srt_q15 lsr_medium lsr_best r8b_120 r8b_120_tb8; do + echo cmp_icount_$e cmp_icount_${e}_4s; done); do out=$(qemu-system-arm -M $machine -nographic -semihosting \ -d plugin -plugin /tmp/libinsncount.so \ -kernel build-$tgt/bench/icount/$bin 2>&1) @@ -122,7 +125,8 @@ jobs: -DSRT_BUILD_TESTS=OFF -DSRT_BUILD_EXAMPLES=OFF \ -DSRT_BUILD_ICOUNT_BENCH=ON -DSRT_ICOUNT_COMPARE=ON cmake --build build-hex -j 4 - for bin in cmp_icount_srt_float cmp_icount_lsr_medium cmp_icount_lsr_best; do + for bin in $(for e in srt_float srt_q15 lsr_medium lsr_best r8b_120 r8b_120_tb8; do + echo cmp_icount_$e cmp_icount_${e}_4s; done); do out=$(qemu-hexagon -d plugin -plugin /tmp/libinsncount.so \ build-hex/bench/icount/$bin 2>&1) echo "$out" | grep -q 'SRT_ICOUNT_DONE ok=1' || { diff --git a/CMakeLists.txt b/CMakeLists.txt index 1c1995f..6041b4c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -77,3 +77,11 @@ option(SRT_BUILD_CAPI "Build the C ABI shared library" OFF) if(SRT_BUILD_CAPI) add_subdirectory(tools/capi) endif() + +# ctypes shim over r8brain-free-src for the comparison notebook (fetched at a +# commit pin; comparison-only, never linked into the library). See +# notebooks/asrc_comparison.ipynb and docs/COMPARISON.md. +option(SRT_BUILD_COMPARE_SHIM "Build the r8brain shim for the comparison notebook" OFF) +if(SRT_BUILD_COMPARE_SHIM) + add_subdirectory(tools/compare_shim) +endif() diff --git a/README.md b/README.md index 9a7bf9f..648d102 100644 --- a/README.md +++ b/README.md @@ -218,8 +218,8 @@ sample-granular transfer, 0.5 FS sine, 1 s analysis window after settling): | `transparent()` (L=512, T=80) | 133 dB | — | — | 108 dB | 0.83 ms | AES17-style THD+N measured under identical conditions against -libsamplerate, soxr and hardware datasheet figures: -[docs/COMPARISON.md](docs/COMPARISON.md) (−132 dB THD+N / 149 dB DR at the +libsamplerate, soxr, r8brain-free-src and hardware datasheet figures: +[docs/COMPARISON.md](docs/COMPARISON.md) (−134 dB THD+N / 149 dB DR at the 24-bit interface, servo in the loop; [notebooks/asrc_comparison.ipynb](notebooks/asrc_comparison.ipynb)). @@ -311,9 +311,10 @@ two USB audio dongles, a Pi + Pico 2, two Pis over Ethernet), see Methodology, optimization roadmap and regression gating live in [docs/PERFORMANCE.md](docs/PERFORMANCE.md). Build the benchmarks with `-DSRT_BUILD_BENCHMARKS=ON` (host only). A measured computational -head-to-head against libsamplerate and soxr — host wall-clock and embedded -instruction counts (`-DSRT_BUILD_COMPARE_BENCH=ON`, `SRT_ICOUNT_COMPARE`) — -lives in [docs/COMPARISON.md](docs/COMPARISON.md). +head-to-head against libsamplerate, soxr and r8brain-free-src — host +wall-clock and embedded instruction counts, steady state and construction +(`-DSRT_BUILD_COMPARE_BENCH=ON`, `SRT_ICOUNT_COMPARE`) — lives in +[docs/COMPARISON.md](docs/COMPARISON.md). Executed instructions per fixed workload (`bench/icount/`), measured under QEMU with a counting plugin — deterministic, and gated in CI at ±3% against `bench/baselines.json`: @@ -440,3 +441,6 @@ window design (Kaiser 1974), band-limited interpolation (J. O. Smith, CCRMA), polyphase decomposition and the harris length estimate, and textbook 2nd-order PLL servo design. No third-party source was copied. GoogleTest (BSD-3) is fetched for tests only and is not part of the shipped headers. +r8brain-free-src (MIT) is fetched at a commit pin only when the opt-in +comparison builds are enabled (`cmake/r8brain.cmake`); it is never linked +into the library or its tests. diff --git a/bench/compare/CMakeLists.txt b/bench/compare/CMakeLists.txt index e63f6fd..4c450fb 100644 --- a/bench/compare/CMakeLists.txt +++ b/bench/compare/CMakeLists.txt @@ -1,10 +1,12 @@ # Head-to-head computational comparison against general-purpose resamplers -# (libsamplerate, soxr) at a fixed, known near-unity ratio. Host-only: -# the competitor libraries come from the system (pkg-config). See -# docs/COMPARISON.md for the methodology and the measured numbers. +# (libsamplerate, soxr, r8brain-free-src) at a fixed, known near-unity ratio. +# Host-only: libsamplerate and soxr come from the system (pkg-config); +# r8brain is header-only and fetched at a commit pin (cmake/r8brain.cmake). +# See docs/COMPARISON.md for the methodology and the measured numbers. find_package(PkgConfig REQUIRED) pkg_check_modules(SAMPLERATE REQUIRED IMPORTED_TARGET samplerate) pkg_check_modules(SOXR REQUIRED IMPORTED_TARGET soxr) +include(${PROJECT_SOURCE_DIR}/cmake/r8brain.cmake) add_executable(srt_bench_compare bench_compare.cpp) target_link_libraries(srt_bench_compare PRIVATE @@ -12,4 +14,5 @@ target_link_libraries(srt_bench_compare PRIVATE srt_warnings benchmark::benchmark_main PkgConfig::SAMPLERATE - PkgConfig::SOXR) + PkgConfig::SOXR + srt_r8brain) diff --git a/bench/compare/bench_compare.cpp b/bench/compare/bench_compare.cpp index bdeedd4..86a4ac9 100644 --- a/bench/compare/bench_compare.cpp +++ b/bench/compare/bench_compare.cpp @@ -11,12 +11,22 @@ // // Quality pairing (stopband attenuation, vendor-stated): // srt balanced (120 dB) ~ libsamplerate MEDIUM (121 dB) ~ soxr HQ (~120 dB) +// ~ r8brain ReqAtten=120 (default 2% transition band, +// and 8%: the lowest-latency setting flat to 20 kHz) // srt transparent (140 dB) ~ libsamplerate BEST (144 dB) ~ soxr VHQ (~170 dB) +// ~ r8brain CDSPResampler16 (136.45 dB) +// plus r8brain's CDSPResampler24 (180.15 dB), its preset for 24-bit/float work. +// +// r8brain is mono per instance with double-precision I/O, so the harness runs +// one instance per channel and pays the float<->double (de)interleave inside +// the timed loop — the cost any float-interleaved caller pays to use it. #include #include +#include #include #include +#include #include #include #include @@ -174,6 +184,37 @@ namespace { state.SetItemsProcessed(frames); } + void r8bBench(benchmark::State& state, double reqAtten, double transBandPct, std::size_t channels) { + std::vector> rs; + for (std::size_t c = 0; c < channels; ++c) + rs.push_back(std::make_unique(48000.0, 48000.0 * kRatio, static_cast(kBlock), + transBandPct, reqAtten, r8b::fprLinearPhase)); + InputTap in(48000, channels); + std::vector inBlock(kBlock * channels); + std::vector chIn(kBlock); + std::vector out(4 * kBlock * channels); + + std::int64_t frames = 0; + for (auto _ : state) { + in.pop(inBlock.data(), kBlock); + int got = 0; + for (std::size_t c = 0; c < channels; ++c) { + for (std::size_t i = 0; i < kBlock; ++i) + chIn[i] = inBlock[i * channels + c]; + double* op = nullptr; + got = rs[c]->process(chIn.data(), static_cast(kBlock), op); + for (int i = 0; i < got; ++i) + out[static_cast(i) * channels + c] = static_cast(op[i]); + } + benchmark::DoNotOptimize(out.data()); + frames += got; + } + // Input frames consumed before the first output frame appears: r8brain + // hides its filter delay by withholding output, so this is its latency. + state.counters["latency_frames"] = rs[0]->getInLenBeforeOutPos(0); + state.SetItemsProcessed(frames); + } + // --- ~120 dB tier: mono / stereo / 8ch ------------------------------------- void BM_SRT_Balanced_1ch(benchmark::State& s) { srtBench(s, tap::samplerate::filter_spec::balanced(), 1); @@ -211,6 +252,28 @@ namespace { BENCHMARK(BM_SOXR_HQ_1ch); BENCHMARK(BM_SOXR_HQ_2ch); BENCHMARK(BM_SOXR_HQ_8ch); + void BM_R8B_120dB_1ch(benchmark::State& s) { + r8bBench(s, 120.0, 2.0, 1); + } + void BM_R8B_120dB_2ch(benchmark::State& s) { + r8bBench(s, 120.0, 2.0, 2); + } + void BM_R8B_120dB_8ch(benchmark::State& s) { + r8bBench(s, 120.0, 2.0, 8); + } + BENCHMARK(BM_R8B_120dB_1ch); + BENCHMARK(BM_R8B_120dB_2ch); + BENCHMARK(BM_R8B_120dB_8ch); + // r8brain's default 2% transition band keeps its passband flat far past + // 20 kHz and pays for it in delay. The passband-matched row takes the + // lowest-latency linear-phase setting still flat to 20 kHz like srt + // balanced, from the sweep in notebooks/asrc_comparison.ipynb: 8% (200 + // input frames; latency is not monotonic in the knob — 10% costs 212 — + // and 12% already droops 0.11 dB at 20 kHz). + void BM_R8B_120dB_TB8_2ch(benchmark::State& s) { + r8bBench(s, 120.0, 8.0, 2); + } + BENCHMARK(BM_R8B_120dB_TB8_2ch); // --- ~140 dB tier, stereo --------------------------------------------------- void BM_SRT_Transparent_2ch(benchmark::State& s) { @@ -225,9 +288,17 @@ namespace { BENCHMARK(BM_SRT_Transparent_2ch); BENCHMARK(BM_LSR_Best_2ch); BENCHMARK(BM_SOXR_VHQ_2ch); + void BM_R8B_16bit_2ch(benchmark::State& s) { + r8bBench(s, 136.45, 2.0, 2); // CDSPResampler16's preset attenuation + } + void BM_R8B_24bit_2ch(benchmark::State& s) { + r8bBench(s, 180.15, 2.0, 2); // CDSPResampler24's preset attenuation + } + BENCHMARK(BM_R8B_16bit_2ch); + BENCHMARK(BM_R8B_24bit_2ch); - // --- Fixed-point (no competitor analog; libsamplerate and soxr are - // float-only engines — this is the row embedded targets actually run) ------ + // --- Fixed-point (no competitor analog; libsamplerate, soxr and r8brain + // are floating-point engines — this is the row embedded targets actually run) ------ void BM_SRT_Q15_Balanced_2ch(benchmark::State& s) { srtBench(s, tap::samplerate::filter_spec::balanced(), 2); } diff --git a/bench/icount/CMakeLists.txt b/bench/icount/CMakeLists.txt index 8fd6435..065535e 100644 --- a/bench/icount/CMakeLists.txt +++ b/bench/icount/CMakeLists.txt @@ -23,7 +23,7 @@ foreach(_sc IN LISTS _srt_icount_scenarios) endforeach() # Cross-resampler comparison workloads (docs/COMPARISON.md): same fixed -# workload through our datapath and through libsamplerate, built for the +# workload through our datapath and through libsamplerate and r8brain, built for the # same target. Named cmp_icount_* so the ratchet's srt_icount_* glob never # picks them up — competitor counts are recorded in docs, not gated. option(SRT_ICOUNT_COMPARE "Build resampler-comparison icount workloads" OFF) @@ -39,21 +39,36 @@ if(SRT_ICOUNT_COMPARE) URL_HASH SHA256=3258da280511d24b49d6b08615bbe824d0cacc9842b0e4caf11c52cf2b043893) FetchContent_MakeAvailable(libsamplerate) - add_executable(cmp_icount_srt_float cmp_main.cpp) - target_compile_definitions(cmp_icount_srt_float PRIVATE SRT_CMP_ENGINE=0) - target_link_libraries(cmp_icount_srt_float PRIVATE - SampleRateTap::SampleRateTap srt_warnings) - - foreach(_eng IN ITEMS 1 2) - if(_eng EQUAL 1) - set(_name lsr_medium) - else() - set(_name lsr_best) - endif() - add_executable(cmp_icount_${_name} cmp_main.cpp) - target_compile_features(cmp_icount_${_name} PRIVATE cxx_std_20) - target_compile_definitions(cmp_icount_${_name} PRIVATE SRT_CMP_ENGINE=${_eng}) - # No srt_warnings: samplerate.h is third-party. - target_link_libraries(cmp_icount_${_name} PRIVATE samplerate) + # name:engine. Each engine is built twice, at the default 2 s and at 4 s + # (suffix _4s): the difference is the steady-state cost, the remainder is + # one-time construction (cmp_main.cpp's header). + set(_srt_cmp_engines srt_float:0 lsr_medium:1 lsr_best:2 r8b_120:3 r8b_120_tb8:4 srt_q15:5) + # r8brain-free-src, same pin as bench/compare. It compiles bare-metal only + # with a no-op std::mutex supplied for thread-less newlib toolchains + # (r8b_single_thread_mutex.h says why that is exact for this workload). + include(${PROJECT_SOURCE_DIR}/cmake/r8brain.cmake) + foreach(_e IN LISTS _srt_cmp_engines) + string(REPLACE ":" ";" _parts "${_e}") + list(GET _parts 0 _name) + list(GET _parts 1 _eng) + foreach(_secs IN ITEMS 2 4) + set(_bin cmp_icount_${_name}) + if(_secs EQUAL 4) + set(_bin ${_bin}_4s) + endif() + add_executable(${_bin} cmp_main.cpp) + target_compile_features(${_bin} PRIVATE cxx_std_20) + target_compile_definitions(${_bin} PRIVATE SRT_CMP_ENGINE=${_eng} SRT_CMP_SECONDS=${_secs}) + if(_eng EQUAL 0 OR _eng EQUAL 5) + target_link_libraries(${_bin} PRIVATE SampleRateTap::SampleRateTap srt_warnings) + elseif(_eng LESS_EQUAL 2) + # No srt_warnings: samplerate.h is third-party. + target_link_libraries(${_bin} PRIVATE samplerate) + else() + target_compile_options(${_bin} PRIVATE -include ${CMAKE_CURRENT_SOURCE_DIR}/r8b_single_thread_mutex.h) + # No srt_warnings: the r8brain headers are third-party. + target_link_libraries(${_bin} PRIVATE srt_r8brain) + endif() + endforeach() endforeach() endif() diff --git a/bench/icount/cmp_main.cpp b/bench/icount/cmp_main.cpp index ba5c164..f4ca5ad 100644 --- a/bench/icount/cmp_main.cpp +++ b/bench/icount/cmp_main.cpp @@ -2,8 +2,8 @@ // comparison (docs/COMPARISON.md). Same shape as icount_main.cpp but the // engine is selected at compile time and the ratio is fixed and known — // SampleRateTap runs its bare datapath (fractional_resampler, constant eps) -// and libsamplerate runs src_process() with the same ratio, so the -// comparison is engine-vs-engine with no servo on either side. +// and libsamplerate / r8brain-free-src run their own process() with the same +// ratio, so the comparison is engine-vs-engine with no servo on either side. // // These binaries are intentionally named cmp_icount_* so the ratchet // (scripts/icount.py, glob srt_icount_*) never sees them: competitor @@ -12,7 +12,15 @@ // // SRT_CMP_ENGINE: 0 = SampleRateTap (balanced), 1 = libsamplerate // SRC_SINC_MEDIUM_QUALITY, 2 = libsamplerate -// SRC_SINC_BEST_QUALITY +// SRC_SINC_BEST_QUALITY, 3 = r8brain 120 dB at its default +// 2% transition band, 4 = r8brain 120 dB at 8% (the +// lowest-latency setting still flat to 20 kHz, like balanced), +// 5 = SampleRateTap (balanced) Q15 — no competitor analog +// +// SRT_CMP_SECONDS (default 2) sets the workload length. Every count includes +// one-time construction (filter design, table and FFT setup), so CMake builds +// each engine at 2 s and 4 s: the difference is the steady-state cost of 2 s +// of audio, the remainder is construction (docs/COMPARISON.md reports both). #include #include #include @@ -20,18 +28,28 @@ #include #include -#if SRT_CMP_ENGINE == 0 +#if SRT_CMP_ENGINE == 0 || SRT_CMP_ENGINE == 5 +#include + #include "srt/polyphase_filter.h" -#else +#include "srt/sample_traits.h" +#elif SRT_CMP_ENGINE <= 2 #include +#else +#include + +#include #endif namespace { - constexpr std::size_t kCh = 2; - constexpr std::size_t kBlock = 32; - constexpr std::size_t kBlocks = 2 * 48000 / kBlock; // 2 s of input at 48 kHz - constexpr double kRatio = 1.0 + 200e-6; // output rate / input rate + constexpr std::size_t kCh = 2; + constexpr std::size_t kBlock = 32; +#ifndef SRT_CMP_SECONDS +#define SRT_CMP_SECONDS 2 +#endif + constexpr std::size_t kBlocks = SRT_CMP_SECONDS * 48000 / kBlock; // input at 48 kHz + constexpr double kRatio = 1.0 + 200e-6; // output rate / input rate std::vector sineInput(std::size_t frames) { std::vector out(frames * kCh); @@ -42,14 +60,34 @@ namespace { return out; } +#if SRT_CMP_ENGINE == 0 || SRT_CMP_ENGINE == 5 + #if SRT_CMP_ENGINE == 0 + using Sample = float; +#else + using Sample = std::int16_t; +#endif + + // A template so `if constexpr` discards the branch the sample type can't take. + template + std::vector toSample(const std::vector& in) { + std::vector out(in.size()); + for (std::size_t i = 0; i < in.size(); ++i) { + if constexpr (std::is_floating_point_v) + out[i] = in[i]; + else + out[i] = tap::samplerate::detail::round_sat(static_cast(in[i]) + * static_cast(std::numeric_limits::max())); + } + return out; + } double run() { - const tap::samplerate::polyphase_filter_bank bank(tap::samplerate::filter_spec::balanced(), 48000.0); - tap::samplerate::fractional_resampler rs(bank, kCh); - const auto input = sineInput(12000); // 0.25 s, cycled - std::size_t pos = 0; - const auto pop = [&](float* dst, std::size_t n) { + const tap::samplerate::polyphase_filter_bank bank(tap::samplerate::filter_spec::balanced(), 48000.0); + tap::samplerate::fractional_resampler rs(bank, kCh); + const auto input = toSample(sineInput(12000)); // 0.25 s, cycled + std::size_t pos = 0; + const auto pop = [&](Sample* dst, std::size_t n) { const std::size_t avail = 12000 - pos; const std::size_t take = n < avail ? n : avail; for (std::size_t i = 0; i < take * kCh; ++i) @@ -57,8 +95,8 @@ namespace { pos = (pos + take) % 12000; return take; }; - const double eps = 1.0 / kRatio - 1.0; - std::vector out(kBlock * kCh); + const double eps = 1.0 / kRatio - 1.0; + std::vector out(kBlock * kCh); if (!rs.prime(pop)) return std::numeric_limits::quiet_NaN(); @@ -71,7 +109,7 @@ namespace { return sink; } -#else +#elif SRT_CMP_ENGINE <= 2 double run() { #if SRT_CMP_ENGINE == 1 @@ -112,6 +150,44 @@ namespace { return sink; } +#else + + // r8brain is mono per instance with double-precision I/O: one instance per + // channel, float<->double (de)interleave counted, as any float caller pays. + double run() { +#if SRT_CMP_ENGINE == 3 + constexpr double kTransBandPct = 2.0; +#else + constexpr double kTransBandPct = 8.0; +#endif + std::unique_ptr rs[kCh]; + for (auto& r : rs) + r = std::make_unique(48000.0, 48000.0 * kRatio, static_cast(kBlock), kTransBandPct, + 120.0, r8b::fprLinearPhase); + + const auto input = sineInput(12000); // 0.25 s, cycled + std::size_t pos = 0; + std::vector chIn(kBlock); + std::vector out(4 * kBlock * kCh); + + double sink = 0.0; + for (std::size_t b = 0; b < kBlocks; ++b) { + int got = 0; + for (std::size_t c = 0; c < kCh; ++c) { + for (std::size_t i = 0; i < kBlock; ++i) + chIn[i] = static_cast(input[(pos + i) * kCh + c]); + double* op = nullptr; + got = rs[c]->process(chIn.data(), static_cast(kBlock), op); + for (int i = 0; i < got; ++i) + out[static_cast(i) * kCh + c] = static_cast(op[i]); + } + pos = (pos + kBlock) % 12000; + if (got > 0) + sink += static_cast(out[0]); + } + return sink; + } + #endif } // namespace diff --git a/bench/icount/r8b_single_thread_mutex.h b/bench/icount/r8b_single_thread_mutex.h new file mode 100644 index 0000000..b7e144a --- /dev/null +++ b/bench/icount/r8b_single_thread_mutex.h @@ -0,0 +1,24 @@ +// Forced include for the r8brain-free-src comparison workloads only +// (cmp_icount_r8b_*, docs/COMPARISON.md). r8brain guards its process-wide +// filter-design cache with std::mutex and offers no hook to replace it; +// newlib toolchains built without thread support (arm-none-eabi) declare no +// std::mutex, so r8brain does not compile bare-metal as shipped. The icount +// workload is single-threaded, so a no-op lock is behaviorally exact — it +// only removes the lock/unlock calls around the one-time filter-design cache +// lookups, never touching the per-sample path. Hosted toolchains (Hexagon's +// musl, x86) keep the real std::mutex: this header is a no-op there. +#pragma once + +#include + +#if defined(__GLIBCXX__) && !defined(_GLIBCXX_HAS_GTHREADS) +namespace std { + struct mutex { + constexpr mutex() noexcept = default; + mutex(const mutex&) = delete; + mutex& operator=(const mutex&) = delete; + void lock() noexcept {} + void unlock() noexcept {} + }; +} // namespace std +#endif diff --git a/book/src/part0/two-crystals.md b/book/src/part0/two-crystals.md index 6064b3e..cb96738 100644 --- a/book/src/part0/two-crystals.md +++ b/book/src/part0/two-crystals.md @@ -204,8 +204,11 @@ and the comparison document names its mechanism exactly: a 48-tap window with a creeping phase, instead of general-ratio machinery. On targets without floating-point hardware the dividend compounds — the Q15 fixed-point datapath has no libsamplerate analog at all, and on a -Pico-class Cortex-M33 the cheapest libsamplerate option costs about 9.8× -what SampleRateTap's intended configuration does. +Pico-class Cortex-M33 the cheapest libsamplerate option costs about 56× +the Q15 datapath's steady-state cost of 879 instructions per frame. (An +earlier revision said 9.8×, from a per-frame figure that folded the +converter's one-time construction into a 2 s workload; the comparison +document now reports steady state and construction separately.) The soxr rows teach a different lesson, and reading them honestly is a preview of the next chapter. At the ~120 dB tier soxr converts 32.4 diff --git a/cmake/r8brain.cmake b/cmake/r8brain.cmake new file mode 100644 index 0000000..ea16c60 --- /dev/null +++ b/cmake/r8brain.cmake @@ -0,0 +1,30 @@ +# r8brain-free-src (Aleksey Vaneev, MIT) for the resampler comparison only +# (docs/COMPARISON.md): included by bench/compare, bench/icount (SRT_ICOUNT_COMPARE) +# and tools/compare_shim so the host benchmark, the embedded counts and the +# notebook all measure the same pinned engine. Never linked into the library +# or its tests. +# +# Upstream's last tag (version-6.5) predates the current 7.x line, so this is a +# commit pin (commits are immutable; tags can move): master at r8bbase.h +# R8B_VERSION "7.5". Stock configuration: Ooura FFT (no IPP/PFFFT), double +# precision internally. +if(NOT TARGET srt_r8brain) + include(FetchContent) + FetchContent_Declare( + r8brain + GIT_REPOSITORY https://github.com/avaneev/r8brain-free-src.git + GIT_TAG 9e73d2dd59fd5b95108fdb4f590083e35758b45f # 7.5 + # Header-only upstream with no CMake project: fetch, don't add_subdirectory. + SOURCE_SUBDIR do-not-add) + FetchContent_MakeAvailable(r8brain) + + add_library(srt_r8brain INTERFACE) + # SYSTEM: third-party headers stay out of our -Wconversion/-Wshadow gate. + target_include_directories(srt_r8brain SYSTEM INTERFACE ${r8brain_SOURCE_DIR}) + # The filter cache's std::mutex. Bare-metal targets have no threads; the + # icount workloads supply a single-threaded stand-in there instead. + if(NOT SRT_BARE_METAL) + find_package(Threads REQUIRED) + target_link_libraries(srt_r8brain INTERFACE Threads::Threads) + endif() +endif() diff --git a/docs/COMPARISON.md b/docs/COMPARISON.md index 62a5ffb..603b1ea 100644 --- a/docs/COMPARISON.md +++ b/docs/COMPARISON.md @@ -3,14 +3,14 @@ Two different kinds of product get called an "SRC": **full ASRCs** that recover the clock ratio themselves (hardware chips, OS audio engines, SampleRateTap), and **resampler libraries** that must be handed the ratio by -an external servo (libsamplerate, soxr, zita-resampler). The second group -solves only half of the drift problem. +an external servo (libsamplerate, soxr, r8brain-free-src, zita-resampler). +The second group solves only half of the drift problem. ## Measured, identical conditions (software subjects) From [notebooks/asrc_comparison.ipynb](../notebooks/asrc_comparison.ipynb) -(2026-06-11): one AES17-style measurement implementation applied to every -subject — 997 Hz at −1 dBFS across a +200 ppm clock crossing +(re-executed 2026-09-25): one AES17-style measurement implementation applied +to every subject — 997 Hz at −1 dBFS across a +200 ppm clock crossing (48 009.6 → 48 000 Hz), fundamental removed by exact fit + ±20 Hz notch, residual integrated 20 Hz–20 kHz; DR per AES17 (−60 dBFS, A-weighted). The **24-bit interface** columns quantize each subject's output to 24 bits — @@ -21,20 +21,33 @@ signals before use. | Subject | Clock knowledge | THD+N (24-bit IO) | THD+N (float IO) | DR A-wtd (24-bit IO) | |---|---|---:|---:|---:| -| **SampleRateTap** (balanced, float) | **recovered by servo** | **−132.1 dB** | −132.3 dB | **149.1 dB** | +| **SampleRateTap** (balanced, float) | **recovered by servo** | **−133.9 dB** | −134.3 dB | **149.1 dB** | | libsamplerate `sinc_best` | given exact ratio (oracle) | −143.5 dB | −149.4 dB | 149.1 dB | | soxr `VHQ` | given exact ratio (oracle) | −143.8 dB | −150.8 dB | 149.1 dB | +| r8brain-free-src `CDSPResampler24` | given exact ratio (oracle) | −143.9 dB | −150.8 dB | 149.1 dB | | naive FIFO (drop on full) | n/a | −34.7 dB | −34.7 dB | 94.7 dB | +SampleRateTap's row moved from −132.1 dB (2026-06-11) when the notebook was +re-executed for the r8brain row: the balanced preset gained its compensated +prototype (transmission zeros at k·fs) on 2026-07-04, and this is the first +re-measurement since. The library rows are unchanged to the displayed +precision. + Reading guide: - The oracle-fed libraries measure at the *format ceilings* (float32 I/O ≈ −150 dB; 24-bit ≈ −143.5 dB; A-weighted 24-bit DR ceiling = 149.1 dB). Near-unity is their easy regime — libsamplerate's published "97 dB worst - case" applies to aggressive ratios, not this one. -- SampleRateTap's −132 dB includes the entire problem: the servo discovered + case" applies to aggressive ratios, not this one. All three are at the + ceilings, so this measurement cannot rank them against each other. +- r8brain is measured through its offline `oneshot()` path (filter delay + removed, tail flushed) via a two-function C shim over the pinned headers + (`tools/compare_shim/`, `cmake/r8brain.cmake`), since it has no maintained + Python binding. Its preset for 24-bit/float work, `CDSPResampler24` + (180.15 dB stopband, 2 % transition band), is the subject. +- SampleRateTap's −134 dB includes the entire problem: the servo discovered the ratio from FIFO occupancy and the conversion ran causally at 1.5 ms - latency. The ~11 dB to the oracle libraries is the measured price of + latency. The ~10 dB to the oracle libraries is the measured price of clock recovery + real-time operation — the part of the problem the libraries do not solve. - The naive FIFO row is the cost of doing nothing. @@ -46,44 +59,78 @@ known near-unity ratio 1 + 200 ppm, streaming in 128-frame blocks (`bench/compare/`, `-DSRT_BUILD_COMPARE_BENCH=ON`). SampleRateTap runs its datapath with a constant rate deviation (the servo is quiescent at a fixed ratio); the libraries take the ratio as an input. Quality tiers are paired -by vendor-stated stopband: balanced ≈ `MEDIUM` ≈ `HQ` (~120 dB), -transparent ≈ `BEST` ≈ `VHQ` (~140 dB+). Latency figures are measured: -SampleRateTap's is the filter group delay, libsamplerate's the input -buffered before its first streaming output, soxr's via `soxr_delay()`. - -### Host wall-clock (x86, GCC 13.3 -O2, shared Xeon @ 2.10 GHz, 2026-06-12) - -Million output frames/s — relative ratios are the meaningful figures on a -shared machine; all subjects ran in the same session. +by vendor-stated stopband: balanced ≈ `MEDIUM` ≈ `HQ` ≈ r8brain at +`ReqAtten` 120 dB (~120 dB), transparent ≈ `BEST` ≈ `VHQ` ≈ r8brain's +16-bit preset (~140 dB+). r8brain is mono per instance with double I/O, so +the harness runs one instance per channel and the float↔double +(de)interleave is inside the timed loop — what any float-interleaved caller +pays to use it. Latency figures are measured: SampleRateTap's is the filter +group delay, libsamplerate's the input buffered before its first streaming +output, soxr's via `soxr_delay()` (it varies with the streaming state; the +range over the mono/stereo/8-ch runs is shown), r8brain's via `getInLenBeforeOutPos(0)` — the +input it consumes before its first output. + +### r8brain's latency is a transition-band choice + +r8brain's delay is set by its transition-band parameter (percent of the +band below Nyquist), and a wider band rolls the passband off. Measured on +the pinned engine at 120 dB and this ratio (notebook, "Latency vs. +passband"): the default 2 % band withholds **789 input frames (16.4 ms)**, +flat far past 20 kHz; the lowest-latency setting still flat to 20 kHz like +`balanced` is **8 %: 200 frames (4.2 ms)** linear-phase, 143 frames +(3.0 ms) minimum-phase (latency is not monotonic in the knob: 10 % costs +212, and 12 % already droops 0.11 dB at 20 kHz). Its ~1 ms settings exist +only at a 45 % band, which is −35 dB at 20 kHz. The tables below carry both +the default and the passband-matched 8 % configuration. + +### Host wall-clock (x86, GCC 13.3 -O3 (CMake Release), shared Xeon @ 2.10 GHz, 2026-09-25) + +Million output frames/s, median of 5 — relative ratios are the meaningful +figures on a shared machine; all subjects ran in the same session. +libsamplerate 0.2.2 and soxr 0.1.3 are the Ubuntu 24.04 packages; r8brain +is the pinned commit (7.5), stock configuration (Ooura FFT). | Engine (~120 dB tier) | mono | stereo | 8-ch | algorithmic latency | |---|---:|---:|---:|---:| -| **SampleRateTap** balanced | 15.6 | 10.5 | 3.0 | **24 frames (0.50 ms)** | -| libsamplerate `MEDIUM` (0.2.2) | 4.4 | 3.7 | 1.4 | 46 frames (0.96 ms) | -| soxr `HQ` (0.1.3) | 72.9 | 32.4 | 8.4 | 556–607 frames (11.6–12.6 ms) | +| **SampleRateTap** balanced | 20.3 | 14.6 | 3.0 | **24 frames (0.50 ms)** | +| libsamplerate `MEDIUM` (0.2.2) | 5.2 | 4.8 | 1.9 | 46 frames (0.96 ms)¹ | +| soxr `HQ` (0.1.3) | 114.3 | 52.9 | 12.9 | 424–788 frames (8.8–16.4 ms) | +| r8brain 120 dB, default 2 % band | 35.4 | 16.5 | 4.1 | 789 frames (16.4 ms) | +| r8brain 120 dB, 8 % band (flat to 20 kHz) | — | 17.9 | — | 200 frames (4.2 ms) | | Engine (~140 dB tier) | stereo | algorithmic latency | |---|---:|---:| -| **SampleRateTap** transparent | 5.8 | 40 frames (0.83 ms) | -| libsamplerate `BEST` | 0.9 | 143 frames (3.0 ms) | -| soxr `VHQ` | 22.2 | 777 frames (16.2 ms) | +| **SampleRateTap** transparent | 9.6 | 40 frames (0.83 ms) | +| libsamplerate `BEST` | 1.6 | 143 frames (3.0 ms)¹ | +| soxr `VHQ` | 32.1 | 433 frames (9.0 ms) | +| r8brain `CDSPResampler16` (136.45 dB) | 18.4 | 1,782 frames (37.1 ms) | +| r8brain `CDSPResampler24` (180.15 dB) | 14.1 | 1,700 frames (35.4 ms) | | No competitor analog | stereo | | |---|---:|---| -| **SampleRateTap** Q15 balanced | 17.5 | the row FPU-less embedded targets actually run | +| **SampleRateTap** Q15 balanced | 21.9 | the row FPU-less embedded targets actually run | + +¹ Measured 2026-06-12 on the same library version; the harness reports +latency counters for soxr and r8brain only. Reading guide: - **soxr wins raw host throughput, and the latency column is why.** It - processes in large internal batches with SIMD throughout (soxr latency - measured via `soxr_delay()`). At ~12–16 ms it is a fine batch/offline - resampler and unusable inside a 1–2 ms live monitoring budget — the - regime SampleRateTap is built for. There is no setting that buys soxr's - throughput at SampleRateTap's latency. + processes in large internal batches with SIMD throughout. At ~9–16 ms it + is a fine batch/offline resampler and unusable inside a 1–2 ms live + monitoring budget — the regime SampleRateTap is built for. There is no + setting that buys soxr's throughput at SampleRateTap's latency. +- **r8brain out-runs SampleRateTap on x86 at the ~120 dB tier** — 1.7× + mono, 1.1× stereo, 1.4× at 8 channels (1.2× stereo passband-matched) — + and at the ~140 dB tier (1.9× for its 136 dB preset). Its FFT block + convolution amortizes well on a desktop core. The price is the same as + soxr's: 8× SampleRateTap's filter delay at the matched passband and 33× + at its default, 45× at the 140 dB tier. On the embedded targets the + ranking reverses, and it has no fixed-point option (next section). - **libsamplerate is the closest architectural analog** (streaming - time-domain polyphase, block-by-block) and SampleRateTap is 2.9–3.6× - (mono/stereo; 2.1× at 8 channels, where both engines amortize) - faster at the matched ~120 dB tier, 6.2× at ~140 dB, while also carrying + time-domain polyphase, block-by-block) and SampleRateTap is 3.1–3.9× + (stereo/mono; 1.5× at 8 channels, where both engines amortize) + faster at the matched ~120 dB tier, 6.1× at ~140 dB, while also carrying ~2–3.6× less latency. That is the near-unity specialization dividend: a 48-tap window with a creeping phase instead of general-ratio machinery. @@ -94,30 +141,74 @@ Reading guide: Same comparison workload cross-compiled per target (`SRT_ICOUNT_COMPARE`, `.github/workflows/compare.yml`; deterministic counts, methodology as the -ratchet in [PERFORMANCE.md](PERFORMANCE.md)). Stereo float, 2 s of audio. -libsamplerate 0.2.2; arm-none-eabi-gcc 13.2.1, hexagon-clang 19.1.5, -O2. - -| Target | **SampleRateTap** balanced | lsr `MEDIUM` | lsr `BEST` | +ratchet in [PERFORMANCE.md](PERFORMANCE.md)). Stereo, float I/O (Q15 for +the Q15 row), 32-frame blocks. libsamplerate 0.2.2, r8brain at the pinned +commit; arm-none-eabi-gcc 13.2.1, hexagon-clang 19.1.5, -O3 (CMake Release; +earlier revisions said -O2, but the build type was the same). Measured +2026-09-25. + +Every engine is built at 2 s and 4 s of audio: the difference is the +**steady-state** cost per output frame, the remainder the **one-time +construction** (filter design, tables, FFT setup). Earlier revisions of +this table divided the 2 s total by the frame count, which folds +construction into the per-frame figure; the libsamplerate totals under +that old metric reproduce the previous table exactly (2,218 / 6,400 on +M55, 49,424 / 149,426 on M33, 9,102 / 26,959 on Hexagon). + +Steady state, instructions per stereo output frame (× = vs. SampleRateTap +balanced float): + +| Engine | Cortex-M55 | Cortex-M33 (Pico 2 class) | Hexagon | |---|---:|---:|---:| -| Cortex-M55 | **899** | 2,218 (2.5×) | 6,400 (7.1×) | -| Cortex-M33 (Pico 2 class) | 18,842¹ | 49,424 (2.6×) | 149,426 (7.9×) | -| Hexagon | **3,275** | 9,102 (2.8×) | 26,959 (8.2×) | +| **SampleRateTap** balanced, float | **821** | 15,302² | **2,754** | +| **SampleRateTap** balanced, Q15 | 1,163 | **879** | **457** | +| r8brain 120 dB, default 2 % band³ | 1,002 (1.2×) | 30,004 (2.0×) | 6,060 (2.2×) | +| r8brain 120 dB, 8 % band (flat to 20 kHz)³ | 934 (1.1×) | 26,619 (1.7×) | 5,420 (2.0×) | +| libsamplerate `MEDIUM` | 2,203 (2.7×) | 49,206 (3.2×) | 9,025 (3.3×) | +| libsamplerate `BEST` | 6,392 (7.8×) | 149,420 (9.8×) | 26,916 (9.8×) | + +One-time construction, millions of instructions: -¹ The float datapath is soft-double-bound on the FP64-less M33 — the -README directs Pico-class parts to Q15, where the **full converter** -(servo and FIFO included) costs ~5,043 instructions/frame (post-C4): -libsamplerate has no fixed-point path, so its cheapest option on such parts costs -**~9.8×** what SampleRateTap's intended configuration does. +| Engine | Cortex-M55 | Cortex-M33 | Hexagon | +|---|---:|---:|---:| +| **SampleRateTap** balanced, float | 23.6 | 1,268 | 181 | +| **SampleRateTap** balanced, Q15 | 24.6 | 1,281 | 184 | +| r8brain 120 dB, default 2 % band | 1.6 | 38.1 | 11.3 | +| r8brain 120 dB, 8 % band | 1.8 | 45.5 | 12.6 | +| libsamplerate `MEDIUM` | 1.4 | 20.9 | 7.4 | +| libsamplerate `BEST` | 0.8 | 0.7 | 4.1 | + +² The float datapath is soft-double-bound on the FP64-less M33 — the +README directs Pico-class parts to Q15, where the steady-state datapath +costs **879 instructions/frame**: libsamplerate has no fixed-point path, so +its cheapest option on such parts costs **~56×** that, and r8brain (double +precision throughout, no fixed-point path either) **~30×**. On the M55, +whose FPU and Helium serve float well, the float datapath is the cheaper +of our two. + +³ r8brain guards its process-wide filter cache with `std::mutex` and has no +hook to replace it; the thread-less arm-none-eabi newlib declares none, so +the Cortex-M builds force-include `bench/icount/r8b_single_thread_mutex.h` +(a no-op lock — exact for this single-threaded workload, and outside the +per-sample path). Hexagon's musl build uses the real mutex. + +**Construction is the one column SampleRateTap loses.** Its filter design +(the compensated prototype, run in double at construction) costs ~1.3 G +instructions on the M33, where double is emulated — seconds of start-up on +a 150 MHz part (instructions are not cycles), against tens of millions for +r8brain and libsamplerate. It is paid once per converter, never on the +audio path, but it is a real cost for devices that construct at boot. ## The landscape | | Type | Clock recovery | Ratio range | Quality | Latency | Footprint / targets | License & form | |---|---|---|---|---|---|---|---| -| **SampleRateTap** | software ASRC | built-in (PI servo on FIFO occupancy) | near-unity (±~1000 ppm) | −132 dB THD+N / 149 dB DR measured above; Q15/Q31 paths for FPU-less DSPs | **1.5 ms default** (0.5 ms filter); sub-ms with `fast()` | 308× RT/core x86; ~515 insn/sample Q15 kernel-only on Hexagon (full converter ~1,245/frame stereo), CI-gated | MIT, header-only C++20 | +| **SampleRateTap** | software ASRC | built-in (PI servo on FIFO occupancy) | near-unity (±~1000 ppm) | −134 dB THD+N / 149 dB DR measured above; Q15/Q31 paths for FPU-less DSPs | **1.5 ms default** (0.5 ms filter); sub-ms with `fast()` | 308× RT/core x86; Q15 datapath 457 insn/frame stereo steady-state on Hexagon, 879 on M33 (above), CI-gated | MIT, header-only C++20 | | [AD1896][ad1896] (ADI) | hardware ASRC | built-in | 1:8 up / 7.75:1 down | THD+N −117 dB min / −133 dB best; 142 dB DNR (datasheet) | sub-ms–ms, mode dependent | dedicated chip, one stereo pair | proprietary | | [SRC4392][src4392] (TI) | hardware ASRC | built-in (automatic) | 1:16–16:1 | THD+N −140 dB typ; 144 dB DR (datasheet) | selectable filter delay | dedicated chip + DIR/DIT | proprietary | | [libsamplerate][lsr] | resampler library | **no** — caller supplies ratio | 1/256–256 | measured above (near-unity); 97 dB worst-case across ratios (own docs) | filter-dependent, offline-friendly | portable C, float | BSD-2 | | [soxr][soxr] | resampler library | no (fixed ratio + bounded VR mode) | wide | measured above (near-unity) | quality-dependent | portable C, SIMD | LGPL | +| [r8brain-free-src][r8b] | resampler library | no — caller supplies ratio | arbitrary | measured above (near-unity, 24-bit preset at the format ceilings); stopband user-set 49–218 dB | transition-band dependent: 16 ms default at 120 dB here, 4.2 ms flat to 20 kHz, ~1 ms only with a 13 kHz-class roll-off | double precision, no fixed-point path; SSE2/AVX/NEON; ~1.1–2.2× SampleRateTap's float steady state on the embedded targets above | MIT, header-only C++ | | zita-resampler + zita-ajbridge | resampler + DLL servo | ajbridge adds a delay-locked loop | near-unity (bridge) | designed for 24-bit transparency; no published CI-verified figures | several ms (period-driven) | Linux/JACK, float | GPL | | OS engines (CoreAudio, WASAPI shared, PipeWire) | system ASRC | built-in, opaque | device-dependent | unpublished; generally well below the above | typically 5–20 ms | bundled | n/a | @@ -133,7 +224,7 @@ libsamplerate has no fixed-point path, so its cheapest option on such parts cost common nominal rate — that restriction is what buys the 48-tap datapath, 0.5 ms filter delay, and embedded-class compute. For genuine rate *conversion*, put a synchronous resampler in the chain — - soxr/libsamplerate, or for exactly 44.1↔48 the family's own + soxr/libsamplerate/r8brain, or for exactly 44.1↔48 the family's own [RatioTap](https://github.com/tap/RatioTap), which cross-validates its output against this library's engine. - **Coarse-block operation is a different regime** (cent-scale low-rate FM @@ -147,3 +238,4 @@ libsamplerate has no fixed-point path, so its cheapest option on such parts cost [src4392]: https://www.ti.com/product/SRC4392 [lsr]: https://libsndfile.github.io/libsamplerate/quality.html [soxr]: https://github.com/chirlu/soxr +[r8b]: https://github.com/avaneev/r8brain-free-src diff --git a/notebooks/asrc_comparison.ipynb b/notebooks/asrc_comparison.ipynb index e6cf261..c4f2c8f 100644 --- a/notebooks/asrc_comparison.ipynb +++ b/notebooks/asrc_comparison.ipynb @@ -27,6 +27,7 @@ "| SampleRateTap (balanced) | full ASRC, float path | **must discover the ratio itself** (servo) |\n", "| libsamplerate `sinc_best` | resampler library | given the exact ratio (oracle) |\n", "| soxr `VHQ` | resampler library | given the exact ratio (oracle) |\n", + "| r8brain-free-src `CDSPResampler24` | resampler library | given the exact ratio (oracle) |\n", "| naive FIFO | drop a sample when full | n/a |\n", "\n", "Note the asymmetry is *against* SampleRateTap: the resampler libraries are\n", @@ -43,10 +44,10 @@ "id": "33be1d66", "metadata": { "execution": { - "iopub.execute_input": "2026-06-11T22:04:40.230704Z", - "iopub.status.busy": "2026-06-11T22:04:40.230479Z", - "iopub.status.idle": "2026-06-11T22:04:40.544484Z", - "shell.execute_reply": "2026-06-11T22:04:40.543270Z" + "iopub.execute_input": "2026-09-25T22:35:07.256740Z", + "iopub.status.busy": "2026-09-25T22:35:07.256473Z", + "iopub.status.idle": "2026-09-25T22:35:07.680451Z", + "shell.execute_reply": "2026-09-25T22:35:07.679469Z" } }, "outputs": [ @@ -54,7 +55,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "loaded libsrt_capi.so; libsamplerate via samplerate 0.2.4, soxr 1.1.0\n" + "loaded libsrt_capi.so, libsrt_r8b_shim.so; libsamplerate via samplerate 0.2.4, soxr 1.1.0\n" ] } ], @@ -68,11 +69,11 @@ "EPS = 200e-6\n", "FS_IN = FS * (1 + EPS)\n", "REPO = pathlib.Path.cwd().parent if pathlib.Path.cwd().name == \"notebooks\" else pathlib.Path.cwd()\n", - "CAPI_DIR = REPO / \"build\" / \"tools\" / \"capi\"\n", + "TOOLS_DIR = REPO / \"build\" / \"tools\"\n", "\n", - "def _find_dso():\n", - " for name in (\"libsrt_capi.so\", \"libsrt_capi.dylib\", \"srt_capi.dll\"):\n", - " hits = sorted(CAPI_DIR.rglob(name))\n", + "def _find_dso(stem):\n", + " for name in (f\"lib{stem}.so\", f\"lib{stem}.dylib\", f\"{stem}.dll\"):\n", + " hits = sorted(TOOLS_DIR.rglob(name))\n", " if hits:\n", " return hits[0]\n", " return None\n", @@ -83,14 +84,18 @@ " print(r.stdout); print(r.stderr, file=sys.stderr)\n", " raise RuntimeError(\"command failed: \" + \" \".join(cmd))\n", "\n", - "DSO = _find_dso()\n", - "if DSO is None:\n", + "# srt_capi is our C ABI; srt_r8b_shim is a two-function C shim over the\n", + "# pinned r8brain-free-src headers (tools/compare_shim/, cmake/r8brain.cmake),\n", + "# which has no maintained Python binding.\n", + "DSO, R8B_DSO = _find_dso(\"srt_capi\"), _find_dso(\"srt_r8b_shim\")\n", + "if DSO is None or R8B_DSO is None:\n", " _run([\"cmake\", \"-B\", str(REPO / \"build\"), \"-S\", str(REPO),\n", - " \"-DCMAKE_BUILD_TYPE=Release\", \"-DSRT_BUILD_CAPI=ON\"])\n", + " \"-DCMAKE_BUILD_TYPE=Release\", \"-DSRT_BUILD_CAPI=ON\",\n", + " \"-DSRT_BUILD_COMPARE_SHIM=ON\"])\n", " _run([\"cmake\", \"--build\", str(REPO / \"build\"), \"--target\", \"srt_capi\",\n", - " \"--config\", \"Release\", \"-j\"])\n", - " DSO = _find_dso()\n", - "assert DSO is not None\n", + " \"srt_r8b_shim\", \"--config\", \"Release\", \"-j\"])\n", + " DSO, R8B_DSO = _find_dso(\"srt_capi\"), _find_dso(\"srt_r8b_shim\")\n", + "assert DSO is not None and R8B_DSO is not None\n", "\n", "_lib = ctypes.CDLL(str(DSO))\n", "_lib.srt_create.restype = ctypes.c_void_p\n", @@ -120,7 +125,33 @@ " if getattr(self, \"_h\", None):\n", " _lib.srt_destroy(self._h)\n", "\n", - "print(f\"loaded {DSO.name}; libsamplerate via samplerate \"\n", + "_r8b = ctypes.CDLL(str(R8B_DSO))\n", + "_r8b.srt_r8b_oneshot.restype = ctypes.c_int\n", + "_r8b.srt_r8b_oneshot.argtypes = [_FLOATP, ctypes.c_int, ctypes.c_double,\n", + " ctypes.c_double, ctypes.c_double,\n", + " ctypes.c_double, ctypes.c_int, _FLOATP,\n", + " ctypes.c_int]\n", + "_r8b.srt_r8b_latency_frames.restype = ctypes.c_int\n", + "_r8b.srt_r8b_latency_frames.argtypes = [ctypes.c_double] * 4 + [ctypes.c_int]\n", + "\n", + "def r8b_resample(x, fs_in, fs_out, trans_band=2.0, atten=180.15,\n", + " min_phase=False):\n", + " \"\"\"Whole-buffer r8brain conversion (its oneshot(): delay removed, tail\n", + " flushed). Defaults are CDSPResampler24, the preset for 24-bit/float.\"\"\"\n", + " x = np.ascontiguousarray(x, np.float32)\n", + " y = np.zeros(int(round(len(x) * fs_out / fs_in)), np.float32)\n", + " rc = _r8b.srt_r8b_oneshot(x.ctypes.data_as(_FLOATP), len(x), fs_in,\n", + " fs_out, trans_band, atten, int(min_phase),\n", + " y.ctypes.data_as(_FLOATP), len(y))\n", + " assert rc == 0\n", + " return y\n", + "\n", + "def r8b_latency_frames(fs_in, fs_out, trans_band, atten, min_phase=False):\n", + " \"\"\"Input frames r8brain consumes before its first streaming output.\"\"\"\n", + " return _r8b.srt_r8b_latency_frames(fs_in, fs_out, trans_band, atten,\n", + " int(min_phase))\n", + "\n", + "print(f\"loaded {DSO.name}, {R8B_DSO.name}; libsamplerate via samplerate \"\n", " f\"{getattr(samplerate, '__version__', '?')}, soxr {soxr.__version__}\")" ] }, @@ -149,10 +180,10 @@ "id": "4d60057f", "metadata": { "execution": { - "iopub.execute_input": "2026-06-11T22:04:40.546643Z", - "iopub.status.busy": "2026-06-11T22:04:40.546313Z", - "iopub.status.idle": "2026-06-11T22:04:40.739129Z", - "shell.execute_reply": "2026-06-11T22:04:40.736208Z" + "iopub.execute_input": "2026-09-25T22:35:07.683305Z", + "iopub.status.busy": "2026-09-25T22:35:07.683059Z", + "iopub.status.idle": "2026-09-25T22:35:07.970083Z", + "shell.execute_reply": "2026-09-25T22:35:07.960753Z" } }, "outputs": [ @@ -160,7 +191,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "injected -100.0 dBFS noise -> measured THD+N -96.80 dB (expect -96.79), refined f0 997.0030 Hz\n", + "injected -100.0 dBFS noise -> measured THD+N -96.80 dB (expect -96.79), refined f0 997.0030 Hz\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "injected -130.0 dBFS noise -> measured THD+N -126.80 dB (expect -126.79), refined f0 997.0030 Hz\n", "instrument calibrated\n" ] @@ -252,10 +289,10 @@ "id": "39d1202b", "metadata": { "execution": { - "iopub.execute_input": "2026-06-11T22:04:40.742470Z", - "iopub.status.busy": "2026-06-11T22:04:40.742218Z", - "iopub.status.idle": "2026-06-11T22:04:50.846428Z", - "shell.execute_reply": "2026-06-11T22:04:50.844983Z" + "iopub.execute_input": "2026-09-25T22:35:07.972234Z", + "iopub.status.busy": "2026-09-25T22:35:07.971986Z", + "iopub.status.idle": "2026-09-25T22:35:17.337375Z", + "shell.execute_reply": "2026-09-25T22:35:17.336453Z" } }, "outputs": [ @@ -263,7 +300,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "SampleRateTap (servo) THD+N -132.10 dB (24-bit IO) -132.34 dB (float IO)\n", + "SampleRateTap (servo) THD+N -133.91 dB (24-bit IO) -134.28 dB (float IO)\n", "libsamplerate sinc_best (oracle ratio) THD+N -143.50 dB (24-bit IO) -149.35 dB (float IO)\n", "soxr VHQ (oracle ratio) THD+N -143.82 dB (24-bit IO) -150.75 dB (float IO)\n" ] @@ -272,6 +309,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "r8brain 24-bit (oracle ratio) THD+N -143.85 dB (24-bit IO) -150.75 dB (float IO)\n", "naive FIFO drops THD+N -34.66 dB (24-bit IO) -34.66 dB (float IO)\n" ] } @@ -318,6 +356,9 @@ "def via_soxr(x, analyze_s):\n", " return mid_window(soxr.resample(x, FS_IN, FS, quality=\"VHQ\"), analyze_s)\n", "\n", + "def via_r8brain(x, analyze_s):\n", + " return mid_window(r8b_resample(x, FS_IN, FS), analyze_s)\n", + "\n", "def via_naive(x, analyze_s):\n", " period = int(round(1 / EPS))\n", " keep = np.ones(len(x), dtype=bool)\n", @@ -330,6 +371,7 @@ " \"SampleRateTap (servo)\": via_sampleratetap(x_full, SECONDS, SETTLE),\n", " \"libsamplerate sinc_best (oracle ratio)\": via_libsamplerate(x_full, ANALYZE),\n", " \"soxr VHQ (oracle ratio)\": via_soxr(x_full, ANALYZE),\n", + " \"r8brain 24-bit (oracle ratio)\": via_r8brain(x_full, ANALYZE),\n", " \"naive FIFO drops\": via_naive(x_full, ANALYZE),\n", "}\n", "thdn, thdn24 = {}, {}\n", @@ -360,10 +402,10 @@ "id": "71c6d73f", "metadata": { "execution": { - "iopub.execute_input": "2026-06-11T22:04:50.848669Z", - "iopub.status.busy": "2026-06-11T22:04:50.848343Z", - "iopub.status.idle": "2026-06-11T22:05:00.829816Z", - "shell.execute_reply": "2026-06-11T22:05:00.825161Z" + "iopub.execute_input": "2026-09-25T22:35:17.339424Z", + "iopub.status.busy": "2026-09-25T22:35:17.338887Z", + "iopub.status.idle": "2026-09-25T22:35:26.926565Z", + "shell.execute_reply": "2026-09-25T22:35:26.925665Z" } }, "outputs": [ @@ -371,7 +413,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "SampleRateTap (servo) DR 149.1 dB (24-bit IO) 192.3 dB (float IO)\n", + "SampleRateTap (servo) DR 149.1 dB (24-bit IO) 194.3 dB (float IO)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "libsamplerate sinc_best (oracle ratio) DR 149.1 dB (24-bit IO) 210.2 dB (float IO)\n", "soxr VHQ (oracle ratio) DR 149.1 dB (24-bit IO) 211.8 dB (float IO)\n" ] @@ -380,6 +428,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "r8brain 24-bit (oracle ratio) DR 149.1 dB (24-bit IO) 211.7 dB (float IO)\n", "naive FIFO drops DR 94.7 dB (24-bit IO) 94.7 dB (float IO)\n" ] } @@ -390,6 +439,7 @@ " \"SampleRateTap (servo)\": via_sampleratetap(x_quiet, SECONDS, SETTLE),\n", " \"libsamplerate sinc_best (oracle ratio)\": via_libsamplerate(x_quiet, ANALYZE),\n", " \"soxr VHQ (oracle ratio)\": via_soxr(x_quiet, ANALYZE),\n", + " \"r8brain 24-bit (oracle ratio)\": via_r8brain(x_quiet, ANALYZE),\n", " \"naive FIFO drops\": via_naive(x_quiet, ANALYZE),\n", "}\n", "dr, dr24 = {}, {}\n", @@ -415,16 +465,16 @@ "id": "276b9635", "metadata": { "execution": { - "iopub.execute_input": "2026-06-11T22:05:00.832122Z", - "iopub.status.busy": "2026-06-11T22:05:00.831912Z", - "iopub.status.idle": "2026-06-11T22:05:01.614746Z", - "shell.execute_reply": "2026-06-11T22:05:01.613546Z" + "iopub.execute_input": "2026-09-25T22:35:26.928798Z", + "iopub.status.busy": "2026-09-25T22:35:26.928157Z", + "iopub.status.idle": "2026-09-25T22:35:27.686363Z", + "shell.execute_reply": "2026-09-25T22:35:27.684988Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -437,9 +487,10 @@ "output_type": "stream", "text": [ "subject THD+N 24b THD+N fl DR 24b DR fl\n", - "SampleRateTap (servo) -132.10 -132.34 149.1 192.3\n", + "SampleRateTap (servo) -133.91 -134.28 149.1 194.3\n", "libsamplerate sinc_best (oracle ratio) -143.50 -149.35 149.1 210.2\n", "soxr VHQ (oracle ratio) -143.82 -150.75 149.1 211.8\n", + "r8brain 24-bit (oracle ratio) -143.85 -150.75 149.1 211.7\n", "naive FIFO drops -34.66 -34.66 94.7 94.7\n" ] } @@ -447,21 +498,23 @@ "source": [ "names = list(subjects.keys())\n", "fig, ax = plt.subplots(1, 2, figsize=(13.5, 5))\n", - "colors = [\"tab:green\", \"tab:blue\", \"tab:orange\", \"tab:red\"]\n", + "colors = [\"tab:green\", \"tab:blue\", \"tab:orange\", \"tab:purple\", \"tab:red\"]\n", "ax[0].barh(names[::-1], [-thdn24[n] for n in names][::-1], color=colors[::-1])\n", "ax[0].set(xlabel=\"|THD+N| [dB] (997 Hz, −1 dBFS, 20 Hz–20 kHz, 24-bit IO)\",\n", " title=\"THD+N, identical measurement, 24-bit interface\")\n", "for hw, v in ((\"AD1896 datasheet min\", 117), (\"AD1896 best\", 133),\n", " (\"SRC4392 typ\", 140)):\n", " ax[0].axvline(v, ls=\"--\", lw=0.8, color=\"gray\")\n", - " ax[0].text(v, 3.45, \" \" + hw, rotation=90, fontsize=7, va=\"top\", color=\"gray\")\n", + " ax[0].text(v, len(names) - 0.55, \" \" + hw, rotation=90, fontsize=7, va=\"top\", color=\"gray\")\n", "ax[0].grid(alpha=0.3, axis=\"x\")\n", "\n", - "for name, y in subjects.items():\n", + "for k, (name, y) in enumerate(subjects.items()):\n", " w = np.kaiser(len(y), 24.0)\n", " Y = np.abs(np.fft.rfft(y.astype(np.float64) * w)) / (np.sum(w) / 2)\n", " f = np.fft.rfftfreq(len(y), 1 / FS)\n", + " # Same colors as the bars; the naive FIFO's splatter goes underneath.\n", " ax[1].plot(f / 1e3, 20 * np.log10(np.maximum(Y, 1e-12)), lw=0.6,\n", + " color=colors[k], zorder=0 if \"naive\" in name else 2,\n", " label=name.split(\" (\")[0])\n", "ax[1].set(xlabel=\"frequency [kHz]\", ylabel=\"dBFS\", xlim=(0, 24), ylim=(-200, 0),\n", " title=\"output spectra (−1 dBFS, 997 Hz, float IO)\")\n", @@ -473,7 +526,140 @@ " print(f\"{n_:42s} {thdn24[n_]:10.2f} {thdn[n_]:9.2f} {dr24[n_]:7.1f} {dr[n_]:7.1f}\")\n", "\n", "first = names[0]\n", - "assert thdn[first] < -130 and dr24[first] > 130\n" + "assert thdn[first] < -130 and dr24[first] > 130\n", + "# r8brain's 24-bit preset sits at the 24-bit interface ceiling, like the\n", + "# other oracle-fed libraries (docs/COMPARISON.md).\n", + "r8b_name = \"r8brain 24-bit (oracle ratio)\"\n", + "assert thdn24[r8b_name] < -143.0 and dr24[r8b_name] > 149.0\n" + ] + }, + { + "cell_type": "markdown", + "id": "01e79820", + "metadata": {}, + "source": [ + "## Latency vs. passband: where r8brain's delay comes from\n", + "\n", + "r8brain is a streaming engine too, so its latency is a fair question.\n", + "Its streaming latency is the number of input frames it consumes before\n", + "producing the first output (it hides its filter delay by withholding\n", + "output). That number is set by the **transition band** knob, and a\n", + "wide transition band pulls the passband edge down. The honest comparison\n", + "fixes the passband SampleRateTap `balanced` delivers (flat to 20 kHz) and\n", + "asks what r8brain's delay is there. Both axes below are measured on the\n", + "pinned engine through the shim: latency from `getInLenBeforeOutPos(0)`,\n", + "passband gain from a 20 kHz sine fit through `oneshot()`, at 120 dB\n", + "stopband (the `balanced` tier), same +200 ppm ratio.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e3623f3a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-25T22:35:27.688564Z", + "iopub.status.busy": "2026-09-25T22:35:27.688389Z", + "iopub.status.idle": "2026-09-25T22:35:27.968845Z", + "shell.execute_reply": "2026-09-25T22:35:27.967743Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trans band phase latency gain @ 20 kHz\n", + " 2.0% linear 789 fr 16.44 ms +0.0000 dB\n", + " 2.0% min 554 fr 11.54 ms +0.0000 dB\n", + " 5.0% linear 420 fr 8.75 ms +0.0000 dB\n", + " 5.0% min 328 fr 6.83 ms +0.0000 dB\n", + " 8.0% linear 200 fr 4.17 ms -0.0000 dB\n", + " 8.0% min 143 fr 2.98 ms -0.0004 dB\n", + " 10.0% linear 212 fr 4.42 ms -0.0004 dB\n", + " 10.0% min 167 fr 3.48 ms -0.0007 dB\n", + " 12.0% linear 220 fr 4.58 ms -0.1109 dB\n", + " 12.0% min 183 fr 3.81 ms -0.1110 dB\n", + " 15.0% linear 100 fr 2.08 ms -1.4886 dB\n", + " 15.0% min 71 fr 1.48 ms -1.4912 dB\n", + " 20.0% linear 108 fr 2.25 ms -6.9984 dB\n", + " 20.0% min 87 fr 1.81 ms -6.9994 dB\n", + " 30.0% linear 116 fr 2.42 ms -20.1669 dB\n", + " 30.0% min 103 fr 2.15 ms -20.1696 dB\n", + " 45.0% linear 57 fr 1.19 ms -35.4380 dB\n", + " 45.0% min 50 fr 1.04 ms -35.4380 dB\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "lowest-latency r8brain setting flat to 20 kHz (within 0.01 dB): 8% transition band, min phase, 143 frames = 2.98 ms\n" + ] + } + ], + "source": [ + "def gain_db(y, f, fs, skip=0.25):\n", + " \"\"\"Least-squares amplitude of a known-frequency sine, in dB re 0.5.\"\"\"\n", + " a, b = int(len(y) * skip), int(len(y) * (1 - skip))\n", + " tt = np.arange(a, b)\n", + " A = np.column_stack([np.sin(2 * np.pi * f / fs * tt),\n", + " np.cos(2 * np.pi * f / fs * tt)])\n", + " c, *_ = np.linalg.lstsq(A, y[a:b].astype(np.float64), rcond=None)\n", + " return 20 * np.log10(np.hypot(*c) / 0.5)\n", + "\n", + "probe = (0.5 * np.sin(2 * np.pi * 20000.0 / FS_IN * np.arange(1 << 16))\n", + " ).astype(np.float32)\n", + "SRT_GD = 24 # balanced filter group delay, input frames (README \"Latency\")\n", + "rows = []\n", + "for tb in (2.0, 5.0, 8.0, 10.0, 12.0, 15.0, 20.0, 30.0, 45.0):\n", + " for mp in (False, True):\n", + " lat = r8b_latency_frames(FS_IN, FS, tb, 120.0, mp)\n", + " g20 = gain_db(r8b_resample(probe, FS_IN, FS, tb, 120.0, mp),\n", + " 20000.0, FS)\n", + " rows.append((tb, mp, lat, g20))\n", + "\n", + "print(f\"{'trans band':>10s} {'phase':>7s} {'latency':>14s} {'gain @ 20 kHz':>14s}\")\n", + "for tb, mp, lat, g20 in rows:\n", + " print(f\"{tb:9.1f}% {'min' if mp else 'linear':>7s} {lat:5d} fr {lat / FS * 1e3:5.2f} ms\"\n", + " f\" {g20:+13.4f} dB\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "# Markers, not lines: latency is not monotonic in the transition band.\n", + "for mp, mk in ((False, \"o\"), (True, \"s\")):\n", + " pts = [(lat / FS * 1e3, g20) for tb, m, lat, g20 in rows if m == mp]\n", + " ax.plot(*zip(*pts), mk, label=f\"r8brain 120 dB, {'min' if mp else 'linear'} phase\")\n", + "for tb, mp, lat, g20 in rows:\n", + " if not mp: # rotated so the 8/10/12 % cluster stays legible\n", + " ax.annotate(f\"{tb:g}%\", (lat / FS * 1e3, g20), textcoords=\"offset points\",\n", + " xytext=(0, 6), fontsize=7, rotation=60)\n", + "ax.plot([SRT_GD / FS * 1e3], [0.0], \"*\", ms=14, color=\"tab:green\",\n", + " label=\"SampleRateTap balanced (filter delay)\")\n", + "ax.set(xscale=\"log\", xlabel=\"streaming latency [ms] (log)\",\n", + " ylabel=\"gain at 20 kHz [dB]\", ylim=(-40, 6),\n", + " title=\"r8brain latency vs. passband (transition band swept 2 % to 45 %)\")\n", + "ax.axhline(-0.1, ls=\"--\", lw=0.8, color=\"gray\")\n", + "ax.grid(alpha=0.3, which=\"both\"); ax.legend(fontsize=8)\n", + "plt.tight_layout(); plt.show()\n", + "\n", + "flat = [(tb, mp, lat) for tb, mp, lat, g20 in rows if g20 > -0.01]\n", + "best = min(flat, key=lambda r: r[2])\n", + "print(f\"lowest-latency r8brain setting flat to 20 kHz (within 0.01 dB): \"\n", + " f\"{best[0]:.0f}% transition band, {'min' if best[1] else 'linear'} phase, \"\n", + " f\"{best[2]} frames = {best[2] / FS * 1e3:.2f} ms\")\n", + "# Pins for docs/COMPARISON.md and bench/compare's passband-matched row.\n", + "assert all(lat > 4 * SRT_GD for tb, mp, lat in flat)\n", + "assert [r for r in rows if r[0] == 10.0 and not r[1]][0][3] > -0.01\n" ] }, { @@ -483,17 +669,27 @@ "source": [ "## Reading the results\n", "\n", - "- **At the 24-bit interface — the chip-comparable condition — all three real\n", - " converters reach the 24-bit format ceiling (~−143 dB THD+N)**, matching or\n", - " exceeding the best hardware datasheet figures. Their differences live\n", - " below the 24-bit floor and only appear at float precision.\n", - "- At float precision the oracle-fed libraries sit at the float32 I/O ceiling\n", - " (~−150 dB); SampleRateTap measures ~−136 dB *with the servo in the loop* —\n", - " the residual is phase-table interpolation images plus servo sidebands\n", - " beyond the ±20 Hz notch. The libraries were handed the exact ratio and ran\n", - " offline over the whole file; the ASRC discovered the clock itself and ran\n", - " causally at 1.5 ms latency. That gap is the measured price of the part of\n", - " the problem the libraries do not solve.\n", + "- **The oracle-fed libraries all reach the format ceilings.** libsamplerate\n", + " `sinc_best`, soxr `VHQ` and r8brain's 24-bit preset each measure at the\n", + " 24-bit interface ceiling (~−143.5 dB THD+N, 149.1 dB DR) and at the float32\n", + " I/O ceiling (~−150 dB). Their differences live below both floors, so this\n", + " measurement cannot rank them: at near-unity with the exact ratio handed to\n", + " them, all three are transparent.\n", + "- **SampleRateTap measures ~−134 dB with the servo in the loop**, about 10 dB\n", + " above the 24-bit ceiling and at 149.1 dB DR (the same DR as the libraries,\n", + " because A-weighted DR at −60 dBFS sits under the 24-bit floor for every\n", + " real converter here). The residual is phase-table interpolation images\n", + " plus servo sidebands beyond the ±20 Hz notch. The libraries were handed\n", + " the exact ratio and ran offline over the whole file; the ASRC discovered\n", + " the clock itself and ran causally at 1.5 ms latency. That gap is the\n", + " measured price of the part of the problem the libraries do not solve.\n", + "- **r8brain's delay is a design choice, not a constant.** The sweep above\n", + " shows the whole trade: at its default 2 % transition band it withholds\n", + " 789 input frames (16 ms) before the first output; relaxing the band cuts\n", + " that to ~1 ms, but only by rolling the passband off to −35 dB at 20 kHz.\n", + " Holding the passband SampleRateTap `balanced` delivers (flat to 20 kHz),\n", + " its floor is 200 frames (4.2 ms) linear-phase, 143 frames (3.0 ms)\n", + " minimum-phase, against `balanced`'s 24-frame filter delay.\n", "- libsamplerate's own \"97 dB worst case\" spec is for aggressive ratios;\n", " near-unity is its easy regime and it measures far better here. Conversely,\n", " near-unity is the *only* regime of the drift problem.\n", @@ -501,7 +697,9 @@ "\n", "Hardware caveats remain: silicon is measured through an analog test loop\n", "with wider notches (both flatter the number); these software measurements\n", - "are pristine-digital. See `docs/COMPARISON.md` for the full landscape table.\n" + "are pristine-digital. See `docs/COMPARISON.md` for the full landscape table,\n", + "including the computational comparison (host throughput and embedded\n", + "instruction counts) for every subject here.\n" ] } ], diff --git a/tools/compare_shim/CMakeLists.txt b/tools/compare_shim/CMakeLists.txt new file mode 100644 index 0000000..8955881 --- /dev/null +++ b/tools/compare_shim/CMakeLists.txt @@ -0,0 +1,10 @@ +# ctypes shim over r8brain-free-src for notebooks/asrc_comparison.ipynb (the +# notebook has no maintained Python binding to lean on, unlike libsamplerate +# and soxr). Comparison-only: it never touches the library. The pin is shared +# with bench/compare via cmake/r8brain.cmake, so both measure the same engine. +include(${PROJECT_SOURCE_DIR}/cmake/r8brain.cmake) + +add_library(srt_r8b_shim SHARED srt_r8b_shim.cpp) +target_compile_features(srt_r8b_shim PRIVATE cxx_std_20) +target_link_libraries(srt_r8b_shim PRIVATE srt_r8brain srt_warnings) +set_target_properties(srt_r8b_shim PROPERTIES POSITION_INDEPENDENT_CODE ON) diff --git a/tools/compare_shim/srt_r8b_shim.cpp b/tools/compare_shim/srt_r8b_shim.cpp new file mode 100644 index 0000000..a1bcf82 --- /dev/null +++ b/tools/compare_shim/srt_r8b_shim.cpp @@ -0,0 +1,69 @@ +/// \file srt_r8b_shim.cpp +/// \brief C entry points over r8brain-free-src's CDSPResampler, so the +/// comparison notebook (notebooks/asrc_comparison.ipynb) can measure the +/// real C++ engine through ctypes. Build with SRT_BUILD_COMPARE_SHIM=ON. +/// +/// Two calls, both taking r8brain's own design knobs verbatim (transition +/// band in percent, stop-band attenuation in dB, linear or minimum phase): +/// a whole-buffer conversion through r8brain's oneshot() — which removes the +/// filter delay and flushes the tail, the library's documented offline +/// usage — and the streaming latency, i.e. the input frames r8brain +/// consumes before its first output frame (getInLenBeforeOutPos(0)). +/// +/// Errors surface as a nonzero return / -1, never as an exception across +/// the C boundary. +// SPDX-License-Identifier: MIT +// Copyright 2026 SampleRateTap contributors +#include +#include + +#include + +namespace { + + constexpr int k_max_in_len = 4096; // oneshot() block size; any value works + + r8b::EDSPFilterPhaseResponse phase(int min_phase) { + return min_phase != 0 ? r8b::fprMinPhase : r8b::fprLinearPhase; + } + +} // namespace + +extern "C" { + +/// Convert `n_in` mono float frames at `src_hz` into exactly `n_out` frames at +/// `dst_hz`. Returns 0 on success, -1 on invalid arguments or failure. +int srt_r8b_oneshot(const float* in, int n_in, double src_hz, double dst_hz, double trans_band_pct, double atten_db, + int min_phase, float* out, int n_out) noexcept { + if (in == nullptr || out == nullptr || n_in < 0 || n_out < 0 || src_hz <= 0.0 || dst_hz <= 0.0) { + return -1; + } + try { + r8b::CDSPResampler rs(src_hz, dst_hz, k_max_in_len, trans_band_pct, atten_db, phase(min_phase)); + // oneshot() takes a mutable pointer; never write through the caller's. + std::vector copy(in, in + n_in); + rs.oneshot(copy.data(), n_in, out, n_out); + return 0; + } + catch (const std::exception&) { + return -1; + } +} + +/// Streaming latency: input frames consumed before the first output frame. +/// Returns -1 on invalid arguments or failure. +int srt_r8b_latency_frames(double src_hz, double dst_hz, double trans_band_pct, double atten_db, + int min_phase) noexcept { + if (src_hz <= 0.0 || dst_hz <= 0.0) { + return -1; + } + try { + const r8b::CDSPResampler rs(src_hz, dst_hz, k_max_in_len, trans_band_pct, atten_db, phase(min_phase)); + return rs.getInLenBeforeOutPos(0); + } + catch (const std::exception&) { + return -1; + } +} + +} // extern "C"