mod bad_intervals;
mod norms;
#[cfg(test)]
mod tests;
#[cfg(test)]
mod tests_realign;
mod time_weight;
use crate::psychoacoustic::run_frame_loop;
use crate::types::{Rate, SignalBuffer, Utterance};
use norms::{asymmetric_densities, deadzone_removed, lp_norm, power_normalized};
#[derive(Debug, Clone, PartialEq)]
pub struct FrameDisturbances {
pub symmetric: Vec<f32>,
pub asymmetric: Vec<f32>,
pub skipped: Vec<bool>,
pub time_weights: Vec<f32>,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct DisturbanceIndicators {
pub symmetric: f64,
pub asymmetric: f64,
}
pub const BAD_FRAME_GATE: f32 = 30.0;
pub const MIN_BAD_INTERVAL_FRAMES: usize = 5;
pub const MAX_BAD_INTERVALS: usize = 1000;
pub const BAD_INTERVAL_SEARCH_SAMPLES: usize = 4 * crate::psychoacoustic::FRAME_LEN;
pub fn bad_interval_search_samples(rate: Rate) -> usize {
4 * rate.frame_len()
}
pub const MIN_CORRELATION: f32 = 0.5;
pub const DISTURBANCE_CAP: f32 = 45.0;
pub const LONG_SIGNAL_FRAME_COUNT: usize = 1000;
pub const SYLLABLE_FRAMES: usize = 20;
pub const SYLLABLE_STEP: usize = 10;
pub const SYLLABLE_EXPONENT: f64 = 6.0;
pub const TIME_EXPONENT: f64 = 2.0;
pub fn frame_disturbances(
reference: &SignalBuffer,
degraded: &SignalBuffer,
utterances: &[Utterance],
) -> FrameDisturbances {
let model = run_frame_loop(reference, degraded, utterances);
let rate = model.rate;
let bands = rate.num_bands();
let frame_start = model.frame_range.start;
let frame_stop = model.frame_range.stop;
let mut symmetric = vec![0.0f32; frame_stop + 1];
let mut asymmetric = vec![0.0f32; frame_stop + 1];
let mut d = vec![0.0f32; bands];
let mut d_asym = vec![0.0f32; bands];
let mut bad_frames_exist = false;
for frame in frame_start..=frame_stop {
let base = frame * bands;
deadzone_removed(
&model.loudness_ref[base..base + bands],
&model.loudness_deg[base..base + bands],
&mut d,
);
let d_sym = lp_norm(&d, 2.0, rate) as f32;
if d_sym > BAD_FRAME_GATE {
bad_frames_exist = true;
}
asymmetric_densities(
&d,
&model.pitch_ref[base..base + bands],
&model.pitch_deg[base..base + bands],
&mut d_asym,
);
symmetric[frame] = d_sym;
asymmetric[frame] = lp_norm(&d_asym, 1.0, rate) as f32;
}
let skipped = crate::utterances::negative_delay_skip_flags(utterances, frame_stop, rate);
for (frame, &skip) in skipped.iter().enumerate() {
if skip {
symmetric[frame] = 0.0;
asymmetric[frame] = 0.0;
}
}
if bad_frames_exist {
bad_intervals::realign(
reference,
degraded,
utterances,
&model,
&mut symmetric,
&mut asymmetric,
);
}
for frame in frame_start..=frame_stop {
symmetric[frame] = power_normalized(symmetric[frame], model.audible_ref[frame]);
asymmetric[frame] = power_normalized(asymmetric[frame], model.audible_ref[frame]);
}
FrameDisturbances {
symmetric,
asymmetric,
skipped,
time_weights: time_weight::time_weights(
frame_stop,
reference.nominal_len.max(degraded.nominal_len),
rate,
),
}
}
pub fn aggregate(frames: &FrameDisturbances, frame_start: usize) -> DisturbanceIndicators {
DisturbanceIndicators {
symmetric: aggregate_indicator(&frames.symmetric, &frames.time_weights, frame_start),
asymmetric: aggregate_indicator(&frames.asymmetric, &frames.time_weights, frame_start),
}
}
fn aggregate_indicator(values: &[f32], weights: &[f32], frame_start: usize) -> f64 {
let frame_stop = values.len() - 1;
let mut sum = 0.0f64;
let mut weight_sum = 0.0f64;
let mut window_start = frame_start;
while window_start <= frame_stop {
let end = (window_start + SYLLABLE_FRAMES).min(frame_stop + 1);
let power_sum: f64 = values[window_start..end]
.iter()
.map(|&value| f64::from(value).powi(6))
.sum();
let syllable = (power_sum / SYLLABLE_FRAMES as f64).powf(1.0 / SYLLABLE_EXPONENT);
let weight = f64::from(weights[window_start - frame_start]);
sum += (weight * syllable).powi(2);
weight_sum += weight * weight;
window_start += SYLLABLE_STEP;
}
if weight_sum == 0.0 {
return 0.0;
}
(sum / weight_sum).powf(1.0 / TIME_EXPONENT)
}