MayaFlux 1.0.0
Digital-First Multimedia Processing Framework
Loading...
Searching...
No Matches
Resample.cpp
Go to the documentation of this file.
1#include "Resample.hpp"
2
4
5#include <execution>
6
8
9namespace {
10
11 constexpr size_t k_block = 2048;
12
13 double bessel_i0(double x) noexcept
14 {
15 const double quarter = 0.25 * x * x;
16 double term = 1.0;
17 double sum = 1.0;
18 for (uint32_t k = 1; k < 500; ++k) {
19 term *= quarter / (static_cast<double>(k) * static_cast<double>(k));
20 sum += term;
21 if (term < 1e-17 * sum) {
22 break;
23 }
24 }
25 return sum;
26 }
27
28 std::vector<double> design_filter(uint32_t up, uint32_t down, const ResampleConfig& config)
29 {
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);
35
36 std::vector<double> h(taps);
37 double sum = 0.0;
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;
44 sum += h[n];
45 }
46
47 const double scale = static_cast<double>(up) / sum;
48 for (double& tap : h) {
49 tap *= scale;
50 }
51 return h;
52 }
53
54 struct Polyphase {
55 std::vector<double> reversed;
56 std::vector<size_t> offset;
57 size_t half {};
58 };
59
60 Polyphase build_polyphase(const std::vector<double>& h, uint32_t up)
61 {
62 Polyphase table;
63 table.half = (h.size() - 1) / 2;
64 table.offset.assign(static_cast<size_t>(up) + 1, 0);
65 table.reversed.reserve(h.size());
66
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) {
70 taps.push_back(h[i]);
71 }
72 table.reversed.insert(table.reversed.end(), taps.rbegin(), taps.rend());
73 table.offset[size_t { phase } + 1] = table.reversed.size();
74 }
75 return table;
76 }
77
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
80 {
81 const size_t base = k * down + table.half;
82 const size_t phase = base % up;
83 const size_t newest = base / up;
84
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();
88
89 double acc = 0.0;
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) {
93 acc += coefficients[i] * x[i];
94 }
95 return acc;
96 }
97
98 for (size_t i = 0; i < count; ++i) {
99 const size_t index = newest + 1 + i;
100 if (index < count) {
101 continue;
102 }
103 const size_t sample = index - count;
104 if (sample >= origin && sample < end) {
105 acc += coefficients[i] * src[sample - origin];
106 }
107 }
108 return acc;
109 }
110
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)
113 {
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);
120 }
121 });
122 }
123
124}
125
126size_t resampled_length(size_t samples, uint32_t from_rate, uint32_t to_rate) noexcept
127{
128 if (from_rate == 0 || to_rate == 0) {
129 return 0;
130 }
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));
133}
134
135std::vector<double> resample(
136 std::span<const double> src, uint32_t from_rate, uint32_t to_rate, const ResampleConfig& config)
137{
138 if (src.empty() || from_rate == 0 || to_rate == 0) {
139 return {};
140 }
141 if (from_rate == to_rate) {
142 return { src.begin(), src.end() };
143 }
144
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;
148
149 const auto table = build_polyphase(design_filter(up, down, config), up);
150 std::vector<double> out(resampled_length(src.size(), from_rate, to_rate));
151 fill_outputs(src, 0, table, 0, out, up, down);
152 return out;
153}
154
156 uint32_t from_rate {};
157 uint32_t to_rate {};
158 uint32_t up {};
159 uint32_t down {};
160 bool passthrough {};
161 Polyphase table;
162 size_t max_taps {};
163 std::vector<double> history;
164 uint64_t origin {};
165 uint64_t seen {};
166 uint64_t emitted {};
167
168 [[nodiscard]] uint64_t newest_for(uint64_t k) const noexcept
169 {
170 return (k * down + table.half) / up;
171 }
172
173 [[nodiscard]] uint64_t ready_end() const noexcept
174 {
175 const uint64_t reach = seen * up;
176 return reach > table.half ? (reach - table.half - 1) / down + 1 : 0;
177 }
178
179 std::vector<double> produce(uint64_t end)
180 {
181 std::vector<double> out(end > emitted ? end - emitted : 0);
182 fill_outputs(history, origin, table, emitted, out, up, down);
183 emitted += out.size();
184 return out;
185 }
186
187 void trim()
188 {
189 const uint64_t newest = newest_for(emitted);
190 const uint64_t keep_from = newest + 1 > max_taps ? newest + 1 - max_taps : 0;
191 if (keep_from <= origin) {
192 return;
193 }
194 const uint64_t drop = std::min<uint64_t>(keep_from - origin, history.size());
195 history.erase(history.begin(), history.begin() + static_cast<std::ptrdiff_t>(drop));
196 origin += drop;
197 }
198
199 void clear() noexcept
200 {
201 history.clear();
202 origin = 0;
203 seen = 0;
204 emitted = 0;
205 }
206};
207
208Resampler::Resampler(uint32_t from_rate, uint32_t to_rate, const ResampleConfig& config)
209 : m_impl(std::make_unique<Impl>())
210{
211 if (from_rate == 0 || to_rate == 0) {
212 error<std::invalid_argument>(Journal::Component::Kinesis, Journal::Context::Runtime,
213 std::source_location::current(), "Resampler rates must be greater than 0");
214 }
215 auto& impl = *m_impl;
216 impl.from_rate = from_rate;
217 impl.to_rate = to_rate;
218 impl.passthrough = from_rate == to_rate;
219 if (impl.passthrough) {
220 return;
221 }
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;
228}
229
230Resampler::~Resampler() = default;
231Resampler::Resampler(Resampler&&) noexcept = default;
232Resampler& Resampler::operator=(Resampler&&) noexcept = default;
233
234std::vector<double> Resampler::push(std::span<const double> src)
235{
236 auto& impl = *m_impl;
237 if (impl.passthrough) {
238 impl.seen += src.size();
239 return { src.begin(), src.end() };
240 }
241 impl.history.insert(impl.history.end(), src.begin(), src.end());
242 impl.seen += src.size();
243
244 auto out = impl.produce(impl.ready_end());
245 impl.trim();
246 return out;
247}
248
249std::vector<double> Resampler::flush()
250{
251 auto& impl = *m_impl;
252 std::vector<double> out;
253 if (!impl.passthrough) {
254 out = impl.produce(resampled_length(impl.seen, impl.from_rate, impl.to_rate));
255 }
256 impl.clear();
257 return out;
258}
259
260void Resampler::reset() noexcept
261{
262 m_impl->clear();
263}
264
265size_t Resampler::lookahead() const noexcept
266{
267 return m_impl->passthrough ? 0 : m_impl->table.half / m_impl->up;
268}
269
270size_t Resampler::retained() const noexcept
271{
272 return m_impl->history.size();
273}
274
275} // namespace MayaFlux::Kinesis::Discrete
Anti-aliased sample rate conversion by a rational ratio for MayaFlux::Kinesis.
size_t retained() const noexcept
Input samples currently held.
Definition Resample.cpp:270
void reset() noexcept
Start a new stream without releasing anything.
Definition Resample.cpp:260
std::vector< double > flush()
End the stream.
Definition Resample.cpp:249
std::vector< double > push(std::span< const double > src)
Continue the stream with more input.
Definition Resample.cpp:234
Resampler(uint32_t from_rate, uint32_t to_rate, const ResampleConfig &config={})
Construct a resampler.
Definition Resample.cpp:208
size_t lookahead() const noexcept
Input samples an output reads beyond its own time, 0 for equal rates.
Definition Resample.cpp:265
resample as a stream: block by block, with the filter history kept between calls
Definition Resample.hpp:81
@ 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.
Definition Resample.cpp:135
std::vector< double > sum(std::span< const double > data, size_t n_windows, uint32_t hop_size, uint32_t window_size)
Sum per window.
Definition Analysis.cpp:490
size_t resampled_length(size_t samples, uint32_t from_rate, uint32_t to_rate) noexcept
Number of samples resample returns.
Definition Resample.cpp:126
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).
Definition Analysis.cpp:506
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.
Definition Tendency.hpp:98
Design of the anti-aliasing filter of resample.
Definition Resample.hpp:23
std::vector< double > produce(uint64_t end)
Definition Resample.cpp:179
uint64_t newest_for(uint64_t k) const noexcept
Definition Resample.cpp:168