1use alloc::collections::VecDeque;
4use alloc::vec::Vec;
5use core::time::Duration;
6
7use crate::errors::{ConfigError, PLANAR_CHANNELS, PLANAR_LENGTHS, PLANAR_PENDING};
8use crate::filter::{CUTOFF_HZ, HighPass};
9use crate::math;
10use crate::sample::{Layout, Sample};
11
12const NANOS_PER_SEC: u128 = 1_000_000_000;
13
14fn round_samples(d: Duration, rate: u32) -> u128 {
16 (d.as_nanos() * u128::from(rate) + NANOS_PER_SEC / 2) / NANOS_PER_SEC
17}
18
19fn saturating_usize(v: u128) -> usize {
20 usize::try_from(v).unwrap_or(usize::MAX)
21}
22
23#[derive(Clone, Debug, PartialEq)]
28#[non_exhaustive]
29pub struct AnalyzeConfig {
30 window: Duration,
31 hop: Duration,
32}
33
34impl Default for AnalyzeConfig {
35 fn default() -> Self {
37 Self {
38 window: Duration::from_millis(30),
39 hop: Duration::from_millis(10),
40 }
41 }
42}
43
44impl AnalyzeConfig {
45 pub fn frames(mut self, window: Duration, hop: Duration) -> Result<Self, ConfigError> {
51 if hop.is_zero() || window < hop {
52 return Err(ConfigError::InvalidFrames);
53 }
54 self.window = window;
55 self.hop = hop;
56 Ok(self)
57 }
58}
59
60#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
63pub(crate) enum Domain {
64 Decibels,
66 Scores,
68}
69
70#[derive(Clone, Debug)]
77pub struct Analyzer {
78 layout: Layout,
79 hop: u64,
80 window: u64,
81 filters: Vec<HighPass>,
82 pending: Vec<f32>,
84 buffer: VecDeque<(f64, bool)>,
86 buffer_start: u64,
88 received: u64,
89 values: Vec<f32>,
90 zero: Vec<bool>,
91}
92
93impl Analyzer {
94 pub fn new(layout: Layout, config: &AnalyzeConfig) -> Result<Self, ConfigError> {
103 validate_layout(layout)?;
104 if f64::from(layout.sample_rate) <= 2.0 * CUTOFF_HZ {
105 return Err(ConfigError::SampleRateTooLow);
106 }
107 let hop = round_samples(config.hop, layout.sample_rate);
108 if hop == 0 {
109 return Err(ConfigError::HopTooShort);
110 }
111 let hop = u64::from(u32::try_from(hop).map_err(|_| ConfigError::InvalidFrames)?);
112 let window = u64::try_from(round_samples(config.window, layout.sample_rate))
114 .map_err(|_| ConfigError::InvalidFrames)?;
115 Ok(Self {
116 layout,
117 hop,
118 window,
119 filters: (0..layout.channels)
120 .map(|_| HighPass::new(layout.sample_rate))
121 .collect(),
122 pending: Vec::new(),
123 buffer: VecDeque::new(),
124 buffer_start: 0,
125 received: 0,
126 values: Vec::new(),
127 zero: Vec::new(),
128 })
129 }
130
131 pub fn push_interleaved<S: Sample>(&mut self, pcm: &[S]) {
133 let channels = usize::from(self.layout.channels);
134 let mut rest = pcm;
135 if !self.pending.is_empty() {
136 let take = (channels - self.pending.len()).min(rest.len());
137 self.pending.extend(rest[..take].iter().map(|s| s.to_f32()));
138 rest = &rest[take..];
139 if self.pending.len() < channels {
140 return;
141 }
142 let frame = core::mem::take(&mut self.pending);
143 self.process(frame.iter().copied());
144 }
145 let mut chunks = rest.chunks_exact(channels);
146 for frame in &mut chunks {
147 self.process(frame.iter().map(|s| s.to_f32()));
148 }
149 self.pending
150 .extend(chunks.remainder().iter().map(|s| s.to_f32()));
151 }
152
153 pub fn push_planar<S: Sample>(&mut self, pcm: &[&[S]]) {
160 assert!(self.pending.is_empty(), "{PLANAR_PENDING}");
161 assert_eq!(
162 pcm.len(),
163 usize::from(self.layout.channels),
164 "{PLANAR_CHANNELS}"
165 );
166 let len = pcm.first().map_or(0, |c| c.len());
167 assert!(pcm.iter().all(|c| c.len() == len), "{PLANAR_LENGTHS}");
168 for i in 0..len {
169 self.process(pcm.iter().map(|c| c[i].to_f32()));
170 }
171 }
172
173 #[must_use]
175 pub fn finish(mut self) -> Analysis {
176 let len = self.received;
177 let frames = len.div_ceil(self.hop);
178 while (self.values.len() as u64) < frames {
179 self.emit(len);
180 }
181 Analysis {
182 layout: self.layout,
183 len,
184 frame_rate: self.layout.sample_rate,
185 hop: self.hop as u32,
186 domain: Domain::Decibels,
187 values: self.values,
188 zero: self.zero,
189 }
190 }
191
192 fn process(&mut self, frame: impl Iterator<Item = f32>) {
193 let mut power = 0.0;
194 let mut nonzero = false;
195 for (filter, x) in self.filters.iter_mut().zip(frame) {
196 let x = if x.is_finite() { x } else { 0.0 };
198 nonzero |= x != 0.0;
199 let y = filter.process(f64::from(x));
200 power += y * y;
201 }
202 self.buffer
203 .push_back((power / f64::from(self.layout.channels), nonzero));
204 self.received += 1;
205 while self.window_end(self.values.len() as u64) <= self.received {
206 self.emit(self.received);
207 }
208 }
209
210 fn window_start(&self, i: u64) -> u64 {
212 (i * self.hop).saturating_sub((self.window - self.hop) / 2)
213 }
214
215 fn window_end(&self, i: u64) -> u64 {
216 i * self.hop + self.window - (self.window - self.hop) / 2
217 }
218
219 fn emit(&mut self, available: u64) {
221 let i = self.values.len() as u64;
222 let start = self.window_start(i);
223 let end = self.window_end(i).min(available);
224 let from = (start - self.buffer_start) as usize;
225 let to = (end - self.buffer_start) as usize;
226 let mut power = 0.0;
227 let mut nonzero = false;
228 for &(p, nz) in self.buffer.range(from..to) {
229 power += p;
230 nonzero |= nz;
231 }
232 let power = if nonzero {
234 power / (to - from) as f64
235 } else {
236 0.0
237 };
238 self.values.push(math::power_to_db(power) as f32);
239 self.zero.push(!nonzero);
240 let next = self.window_start(i + 1).min(self.received);
241 while self.buffer_start < next {
242 self.buffer.pop_front();
243 self.buffer_start += 1;
244 }
245 }
246}
247
248fn validate_layout(layout: Layout) -> Result<(), ConfigError> {
249 if layout.sample_rate == 0 {
250 return Err(ConfigError::ZeroSampleRate);
251 }
252 if layout.channels == 0 {
253 return Err(ConfigError::ZeroChannels);
254 }
255 Ok(())
256}
257
258#[derive(Clone, Debug, PartialEq)]
265#[cfg_attr(
266 feature = "serde",
267 derive(serde::Serialize, serde::Deserialize),
268 serde(try_from = "AnalysisData")
269)]
270pub struct Analysis {
271 layout: Layout,
272 len: u64,
273 frame_rate: u32,
274 hop: u32,
275 domain: Domain,
276 values: Vec<f32>,
277 zero: Vec<bool>,
278}
279
280impl Analysis {
281 pub fn from_scores(
297 layout: Layout,
298 len: u64,
299 score_rate: u32,
300 hop: u32,
301 scores: Vec<f32>,
302 ) -> Result<Self, ConfigError> {
303 let zero = alloc::vec![false; scores.len()];
304 let analysis = Self {
305 layout,
306 len,
307 frame_rate: score_rate,
308 hop,
309 domain: Domain::Scores,
310 values: scores,
311 zero,
312 };
313 analysis.validate()?;
314 Ok(analysis)
315 }
316
317 #[must_use]
319 pub fn layout(&self) -> Layout {
320 self.layout
321 }
322
323 #[must_use]
325 pub fn sample_count(&self) -> u64 {
326 self.len
327 }
328
329 fn validate(&self) -> Result<(), ConfigError> {
330 validate_layout(self.layout)?;
331 let frame_samples = u64::from(self.hop) * u64::from(self.layout.sample_rate);
332 if self.frame_rate == 0 || self.hop == 0 || frame_samples < u64::from(self.frame_rate) {
333 return Err(ConfigError::InvalidScoreFrames);
334 }
335 let valid = |v: &f32| match self.domain {
336 Domain::Decibels => v.is_finite(),
337 Domain::Scores => (0.0..=1.0).contains(v),
338 };
339 let zero_scores = self.domain == Domain::Scores && self.zero.iter().any(|z| *z);
340 if !self.values.iter().all(valid) || zero_scores {
341 return Err(ConfigError::InvalidValue);
342 }
343 let n = self.values.len();
344 let len = u128::from(self.len);
345 let covered = if self.len == 0 {
346 n == 0
347 } else {
348 n > 0 && self.start(n - 1) < len && len < self.start(n + 1)
349 };
350 if !covered || self.zero.len() != n {
351 return Err(ConfigError::FrameCountMismatch);
352 }
353 Ok(())
354 }
355
356 pub(crate) fn frames(&self) -> usize {
358 self.values.len()
359 }
360
361 pub(crate) fn domain(&self) -> Domain {
362 self.domain
363 }
364
365 pub(crate) fn values(&self) -> &[f32] {
366 &self.values
367 }
368
369 pub(crate) fn zero(&self) -> &[bool] {
371 &self.zero
372 }
373
374 fn start(&self, i: usize) -> u128 {
376 let num = i as u128 * u128::from(self.hop) * u128::from(self.layout.sample_rate);
377 num / u128::from(self.frame_rate)
378 }
379
380 pub(crate) fn position(&self, k: usize) -> u64 {
382 if k >= self.frames() {
383 self.len
384 } else {
385 self.start(k) as u64
387 }
388 }
389
390 pub(crate) fn frame_secs(&self) -> f64 {
392 f64::from(self.hop) / f64::from(self.frame_rate)
393 }
394
395 fn frame_fraction(&self, d: Duration) -> (u128, u128) {
397 (
398 d.as_nanos() * u128::from(self.frame_rate),
399 u128::from(self.hop) * NANOS_PER_SEC,
400 )
401 }
402
403 pub(crate) fn frames_in(&self, d: Duration) -> usize {
405 let (num, den) = self.frame_fraction(d);
406 saturating_usize((num + den / 2) / den)
407 }
408
409 pub(crate) fn frames_ceil(&self, d: Duration) -> usize {
411 let (num, den) = self.frame_fraction(d);
412 saturating_usize(num.div_ceil(den))
413 }
414
415 pub(crate) fn frames_floor(&self, d: Duration) -> usize {
417 let (num, den) = self.frame_fraction(d);
418 saturating_usize(num / den)
419 }
420
421 pub(crate) fn samples_floor(&self, d: Duration) -> u64 {
423 let samples = d.as_nanos() * u128::from(self.layout.sample_rate) / NANOS_PER_SEC;
424 u64::try_from(samples).unwrap_or(u64::MAX)
425 }
426
427 pub(crate) fn samples_in(&self, d: Duration) -> f64 {
429 (d.as_nanos() * u128::from(self.layout.sample_rate)) as f64 / NANOS_PER_SEC as f64
430 }
431}
432
433#[cfg(feature = "serde")]
435#[derive(serde::Deserialize)]
436struct AnalysisData {
437 layout: Layout,
438 len: u64,
439 frame_rate: u32,
440 hop: u32,
441 domain: Domain,
442 values: Vec<f32>,
443 zero: Vec<bool>,
444}
445
446#[cfg(feature = "serde")]
447impl TryFrom<AnalysisData> for Analysis {
448 type Error = ConfigError;
449
450 fn try_from(d: AnalysisData) -> Result<Self, ConfigError> {
451 let analysis = Self {
452 layout: d.layout,
453 len: d.len,
454 frame_rate: d.frame_rate,
455 hop: d.hop,
456 domain: d.domain,
457 values: d.values,
458 zero: d.zero,
459 };
460 analysis.validate()?;
461 Ok(analysis)
462 }
463}