use alloc::collections::VecDeque;
use alloc::vec::Vec;
use core::time::Duration;
use crate::errors::{ConfigError, PLANAR_CHANNELS, PLANAR_LENGTHS, PLANAR_PENDING};
use crate::filter::{CUTOFF_HZ, HighPass};
use crate::math;
use crate::sample::{Layout, Sample};
const NANOS_PER_SEC: u128 = 1_000_000_000;
fn round_samples(d: Duration, rate: u32) -> u128 {
(d.as_nanos() * u128::from(rate) + NANOS_PER_SEC / 2) / NANOS_PER_SEC
}
fn saturating_usize(v: u128) -> usize {
usize::try_from(v).unwrap_or(usize::MAX)
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct AnalyzeConfig {
window: Duration,
hop: Duration,
}
impl Default for AnalyzeConfig {
fn default() -> Self {
Self {
window: Duration::from_millis(30),
hop: Duration::from_millis(10),
}
}
}
impl AnalyzeConfig {
pub fn frames(mut self, window: Duration, hop: Duration) -> Result<Self, ConfigError> {
if hop.is_zero() || window < hop {
return Err(ConfigError::InvalidFrames);
}
self.window = window;
self.hop = hop;
Ok(self)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub(crate) enum Domain {
Decibels,
Scores,
}
#[derive(Clone, Debug)]
pub struct Analyzer {
layout: Layout,
hop: u64,
window: u64,
filters: Vec<HighPass>,
pending: Vec<f32>,
buffer: VecDeque<(f64, bool)>,
buffer_start: u64,
received: u64,
values: Vec<f32>,
zero: Vec<bool>,
}
impl Analyzer {
pub fn new(layout: Layout, config: &AnalyzeConfig) -> Result<Self, ConfigError> {
validate_layout(layout)?;
if f64::from(layout.sample_rate) <= 2.0 * CUTOFF_HZ {
return Err(ConfigError::SampleRateTooLow);
}
let hop = round_samples(config.hop, layout.sample_rate);
if hop == 0 {
return Err(ConfigError::HopTooShort);
}
let hop = u64::from(u32::try_from(hop).map_err(|_| ConfigError::InvalidFrames)?);
let window = u64::try_from(round_samples(config.window, layout.sample_rate))
.map_err(|_| ConfigError::InvalidFrames)?;
Ok(Self {
layout,
hop,
window,
filters: (0..layout.channels)
.map(|_| HighPass::new(layout.sample_rate))
.collect(),
pending: Vec::new(),
buffer: VecDeque::new(),
buffer_start: 0,
received: 0,
values: Vec::new(),
zero: Vec::new(),
})
}
pub fn push_interleaved<S: Sample>(&mut self, pcm: &[S]) {
let channels = usize::from(self.layout.channels);
let mut rest = pcm;
if !self.pending.is_empty() {
let take = (channels - self.pending.len()).min(rest.len());
self.pending.extend(rest[..take].iter().map(|s| s.to_f32()));
rest = &rest[take..];
if self.pending.len() < channels {
return;
}
let frame = core::mem::take(&mut self.pending);
self.process(frame.iter().copied());
}
let mut chunks = rest.chunks_exact(channels);
for frame in &mut chunks {
self.process(frame.iter().map(|s| s.to_f32()));
}
self.pending
.extend(chunks.remainder().iter().map(|s| s.to_f32()));
}
pub fn push_planar<S: Sample>(&mut self, pcm: &[&[S]]) {
assert!(self.pending.is_empty(), "{PLANAR_PENDING}");
assert_eq!(
pcm.len(),
usize::from(self.layout.channels),
"{PLANAR_CHANNELS}"
);
let len = pcm.first().map_or(0, |c| c.len());
assert!(pcm.iter().all(|c| c.len() == len), "{PLANAR_LENGTHS}");
for i in 0..len {
self.process(pcm.iter().map(|c| c[i].to_f32()));
}
}
#[must_use]
pub fn finish(mut self) -> Analysis {
let len = self.received;
let frames = len.div_ceil(self.hop);
while (self.values.len() as u64) < frames {
self.emit(len);
}
Analysis {
layout: self.layout,
len,
frame_rate: self.layout.sample_rate,
hop: self.hop as u32,
domain: Domain::Decibels,
values: self.values,
zero: self.zero,
}
}
fn process(&mut self, frame: impl Iterator<Item = f32>) {
let mut power = 0.0;
let mut nonzero = false;
for (filter, x) in self.filters.iter_mut().zip(frame) {
let x = if x.is_finite() { x } else { 0.0 };
nonzero |= x != 0.0;
let y = filter.process(f64::from(x));
power += y * y;
}
self.buffer
.push_back((power / f64::from(self.layout.channels), nonzero));
self.received += 1;
while self.window_end(self.values.len() as u64) <= self.received {
self.emit(self.received);
}
}
fn window_start(&self, i: u64) -> u64 {
(i * self.hop).saturating_sub((self.window - self.hop) / 2)
}
fn window_end(&self, i: u64) -> u64 {
i * self.hop + self.window - (self.window - self.hop) / 2
}
fn emit(&mut self, available: u64) {
let i = self.values.len() as u64;
let start = self.window_start(i);
let end = self.window_end(i).min(available);
let from = (start - self.buffer_start) as usize;
let to = (end - self.buffer_start) as usize;
let mut power = 0.0;
let mut nonzero = false;
for &(p, nz) in self.buffer.range(from..to) {
power += p;
nonzero |= nz;
}
let power = if nonzero {
power / (to - from) as f64
} else {
0.0
};
self.values.push(math::power_to_db(power) as f32);
self.zero.push(!nonzero);
let next = self.window_start(i + 1).min(self.received);
while self.buffer_start < next {
self.buffer.pop_front();
self.buffer_start += 1;
}
}
}
fn validate_layout(layout: Layout) -> Result<(), ConfigError> {
if layout.sample_rate == 0 {
return Err(ConfigError::ZeroSampleRate);
}
if layout.channels == 0 {
return Err(ConfigError::ZeroChannels);
}
Ok(())
}
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(try_from = "AnalysisData")
)]
pub struct Analysis {
layout: Layout,
len: u64,
frame_rate: u32,
hop: u32,
domain: Domain,
values: Vec<f32>,
zero: Vec<bool>,
}
impl Analysis {
pub fn from_scores(
layout: Layout,
len: u64,
score_rate: u32,
hop: u32,
scores: Vec<f32>,
) -> Result<Self, ConfigError> {
let zero = alloc::vec![false; scores.len()];
let analysis = Self {
layout,
len,
frame_rate: score_rate,
hop,
domain: Domain::Scores,
values: scores,
zero,
};
analysis.validate()?;
Ok(analysis)
}
#[must_use]
pub fn layout(&self) -> Layout {
self.layout
}
#[must_use]
pub fn sample_count(&self) -> u64 {
self.len
}
fn validate(&self) -> Result<(), ConfigError> {
validate_layout(self.layout)?;
let frame_samples = u64::from(self.hop) * u64::from(self.layout.sample_rate);
if self.frame_rate == 0 || self.hop == 0 || frame_samples < u64::from(self.frame_rate) {
return Err(ConfigError::InvalidScoreFrames);
}
let valid = |v: &f32| match self.domain {
Domain::Decibels => v.is_finite(),
Domain::Scores => (0.0..=1.0).contains(v),
};
let zero_scores = self.domain == Domain::Scores && self.zero.iter().any(|z| *z);
if !self.values.iter().all(valid) || zero_scores {
return Err(ConfigError::InvalidValue);
}
let n = self.values.len();
let len = u128::from(self.len);
let covered = if self.len == 0 {
n == 0
} else {
n > 0 && self.start(n - 1) < len && len < self.start(n + 1)
};
if !covered || self.zero.len() != n {
return Err(ConfigError::FrameCountMismatch);
}
Ok(())
}
pub(crate) fn frames(&self) -> usize {
self.values.len()
}
pub(crate) fn domain(&self) -> Domain {
self.domain
}
pub(crate) fn values(&self) -> &[f32] {
&self.values
}
pub(crate) fn zero(&self) -> &[bool] {
&self.zero
}
fn start(&self, i: usize) -> u128 {
let num = i as u128 * u128::from(self.hop) * u128::from(self.layout.sample_rate);
num / u128::from(self.frame_rate)
}
pub(crate) fn position(&self, k: usize) -> u64 {
if k >= self.frames() {
self.len
} else {
self.start(k) as u64
}
}
pub(crate) fn frame_secs(&self) -> f64 {
f64::from(self.hop) / f64::from(self.frame_rate)
}
fn frame_fraction(&self, d: Duration) -> (u128, u128) {
(
d.as_nanos() * u128::from(self.frame_rate),
u128::from(self.hop) * NANOS_PER_SEC,
)
}
pub(crate) fn frames_in(&self, d: Duration) -> usize {
let (num, den) = self.frame_fraction(d);
saturating_usize((num + den / 2) / den)
}
pub(crate) fn frames_ceil(&self, d: Duration) -> usize {
let (num, den) = self.frame_fraction(d);
saturating_usize(num.div_ceil(den))
}
pub(crate) fn frames_floor(&self, d: Duration) -> usize {
let (num, den) = self.frame_fraction(d);
saturating_usize(num / den)
}
pub(crate) fn samples_floor(&self, d: Duration) -> u64 {
let samples = d.as_nanos() * u128::from(self.layout.sample_rate) / NANOS_PER_SEC;
u64::try_from(samples).unwrap_or(u64::MAX)
}
pub(crate) fn samples_in(&self, d: Duration) -> f64 {
(d.as_nanos() * u128::from(self.layout.sample_rate)) as f64 / NANOS_PER_SEC as f64
}
}
#[cfg(feature = "serde")]
#[derive(serde::Deserialize)]
struct AnalysisData {
layout: Layout,
len: u64,
frame_rate: u32,
hop: u32,
domain: Domain,
values: Vec<f32>,
zero: Vec<bool>,
}
#[cfg(feature = "serde")]
impl TryFrom<AnalysisData> for Analysis {
type Error = ConfigError;
fn try_from(d: AnalysisData) -> Result<Self, ConfigError> {
let analysis = Self {
layout: d.layout,
len: d.len,
frame_rate: d.frame_rate,
hop: d.hop,
domain: d.domain,
values: d.values,
zero: d.zero,
};
analysis.validate()?;
Ok(analysis)
}
}