11 constexpr size_t k_block = 2048;
13 double bessel_i0(
double x)
noexcept
15 const double quarter = 0.25 * x * x;
18 for (uint32_t k = 1; k < 500; ++k) {
19 term *= quarter / (
static_cast<double>(k) *
static_cast<double>(k));
21 if (term < 1e-17 *
sum) {
28 std::vector<double> design_filter(uint32_t up, uint32_t down,
const ResampleConfig& config)
30 const uint32_t max_rate = std::max(up, down);
31 const size_t half =
static_cast<size_t>(std::max<uint32_t>(config.zero_crossings, 1)) * max_rate;
32 const size_t taps = 2 * half + 1;
33 const double cutoff = 1.0 /
static_cast<double>(max_rate);
34 const double beta_norm = bessel_i0(config.kaiser_beta);
36 std::vector<double> h(taps);
38 for (
size_t n = 0; n < taps; ++n) {
39 const double x = cutoff * (
static_cast<double>(n) -
static_cast<double>(half));
40 const double sinc = x == 0.0 ? 1.0 : std::sin(std::numbers::pi * x) / (std::numbers::pi * x);
41 const double r = 2.0 *
static_cast<double>(n) /
static_cast<double>(taps - 1) - 1.0;
42 const double window = bessel_i0(config.kaiser_beta * std::sqrt(std::max(0.0, 1.0 - r * r))) / beta_norm;
43 h[n] = cutoff * sinc * window;
47 const double scale =
static_cast<double>(up) /
sum;
48 for (
double& tap : h) {
55 std::vector<double> reversed;
56 std::vector<size_t> offset;
60 Polyphase build_polyphase(
const std::vector<double>& h, uint32_t up)
63 table.half = (h.size() - 1) / 2;
64 table.offset.assign(
static_cast<size_t>(up) + 1, 0);
65 table.reversed.reserve(h.size());
67 for (uint32_t phase = 0; phase < up; ++phase) {
68 std::vector<double> taps;
69 for (
size_t i = phase; i < h.size(); i += up) {
72 table.reversed.insert(table.reversed.end(), taps.rbegin(), taps.rend());
73 table.offset[
size_t { phase } + 1] = table.reversed.size();
78 double output_sample(std::span<const double> src,
size_t origin,
const Polyphase& table,
79 size_t k, uint32_t up, uint32_t down)
noexcept
81 const size_t base = k * down + table.half;
82 const size_t phase = base % up;
83 const size_t newest = base / up;
85 const double*
coefficients = table.reversed.data() + table.offset[phase];
86 const size_t count = table.offset[phase + 1] - table.offset[phase];
87 const size_t end = origin + src.size();
90 if (newest + 1 >=
count + origin && newest < end) {
91 const double* x = src.data() + (newest + 1 -
count - origin);
92 for (
size_t i = 0; i <
count; ++i) {
98 for (
size_t i = 0; i <
count; ++i) {
99 const size_t index = newest + 1 + i;
103 const size_t sample = index -
count;
104 if (sample >= origin && sample < end) {
111 void fill_outputs(std::span<const double> src,
size_t origin,
const Polyphase& table,
112 size_t first, std::span<double> out, uint32_t up, uint32_t down)
114 const size_t blocks = (out.size() + k_block - 1) / k_block;
115 const auto ids = std::views::iota(
size_t { 0 }, blocks);
116 std::for_each(std::execution::par_unseq, ids.begin(), ids.end(), [&](
size_t block) {
117 const size_t stop = std::min(out.size(), (block + 1) * k_block);
118 for (size_t i = block * k_block; i < stop; ++i) {
119 out[i] = output_sample(src, origin, table, first + i, up, down);
128 if (from_rate == 0 || to_rate == 0) {
131 const uint64_t
scaled =
static_cast<uint64_t
>(samples) * to_rate;
132 return static_cast<size_t>(
scaled / from_rate + (
scaled % from_rate != 0 ? 1U : 0U));
136 std::span<const double> src, uint32_t from_rate, uint32_t to_rate,
const ResampleConfig& config)
138 if (src.empty() || from_rate == 0 || to_rate == 0) {
141 if (from_rate == to_rate) {
142 return { src.begin(), src.end() };
145 const uint32_t divisor = std::gcd(from_rate, to_rate);
146 const uint32_t up = to_rate / divisor;
147 const uint32_t down = from_rate / divisor;
149 const auto table = build_polyphase(design_filter(up, down, config), up);
151 fill_outputs(src, 0, table, 0, out, up, down);
175 const uint64_t reach =
seen *
up;
176 return reach >
table.half ? (reach -
table.half - 1) /
down + 1 : 0;
190 const uint64_t keep_from = newest + 1 >
max_taps ? newest + 1 -
max_taps : 0;
191 if (keep_from <=
origin) {
194 const uint64_t drop = std::min<uint64_t>(keep_from -
origin,
history.size());
211 if (from_rate == 0 || to_rate == 0) {
213 std::source_location::current(),
"Resampler rates must be greater than 0");
216 impl.from_rate = from_rate;
217 impl.to_rate = to_rate;
218 impl.passthrough = from_rate == to_rate;
219 if (impl.passthrough) {
222 const uint32_t divisor = std::gcd(from_rate, to_rate);
223 impl.up = to_rate / divisor;
224 impl.down = from_rate / divisor;
225 const auto filter = design_filter(impl.up, impl.down, config);
226 impl.table = build_polyphase(filter, impl.up);
227 impl.max_taps = (filter.size() + impl.up - 1) / impl.up;
237 if (impl.passthrough) {
238 impl.seen += src.size();
239 return { src.begin(), src.end() };
241 impl.history.insert(impl.history.end(), src.begin(), src.end());
242 impl.seen += src.size();
244 auto out = impl.produce(impl.ready_end());
252 std::vector<double> out;
253 if (!impl.passthrough) {
254 out = impl.produce(
resampled_length(impl.seen, impl.from_rate, impl.to_rate));
272 return m_impl->history.size();
Anti-aliased sample rate conversion by a rational ratio for MayaFlux::Kinesis.
std::unique_ptr< Impl > m_impl
size_t retained() const noexcept
Input samples currently held.
void reset() noexcept
Start a new stream without releasing anything.
std::vector< double > flush()
End the stream.
std::vector< double > push(std::span< const double > src)
Continue the stream with more input.
Resampler(uint32_t from_rate, uint32_t to_rate, const ResampleConfig &config={})
Construct a resampler.
size_t lookahead() const noexcept
Input samples an output reads beyond its own time, 0 for equal rates.
resample as a stream: block by block, with the filter history kept between calls
@ Runtime
General runtime operations (default fallback).
@ Kinesis
General mathematical and physics algorithns.
std::vector< double > resample(std::span< const double > src, uint32_t from_rate, uint32_t to_rate, const ResampleConfig &config)
Resample a sequence from one rate to another with an anti-aliasing filter.
std::vector< double > sum(std::span< const double > data, size_t n_windows, uint32_t hop_size, uint32_t window_size)
Sum per window.
size_t resampled_length(size_t samples, uint32_t from_rate, uint32_t to_rate) noexcept
Number of samples resample returns.
std::vector< double > count(std::span< const double > data, size_t n_windows, uint32_t hop_size, uint32_t window_size)
Sample count per window (as double for pipeline uniformity).
std::function< float(glm::vec2)> scaled(std::function< float(glm::vec2)> norm, float lo, float hi)
Rescale a normalized projection onto an arbitrary range.
Tendency< D, float > scale(const Tendency< D, float > &t, float factor)
Uniform scaling of a scalar-output tendency.
Design of the anti-aliasing filter of resample.
uint64_t ready_end() const noexcept
std::vector< double > produce(uint64_t end)
uint64_t newest_for(uint64_t k) const noexcept
std::vector< double > history