pub mod alignment;
pub mod disturbance;
pub mod dsp;
pub mod dsp_fft;
pub mod dsp_filters;
pub mod input;
pub mod input_buffers;
pub mod input_filters;
pub mod psychoacoustic;
pub mod score;
pub mod splitting;
pub mod types;
pub mod utterances;
pub mod vad;
pub use types::PesqError;
pub struct PesqContext {
original: types::SignalBuffer,
working: types::SignalBuffer,
model: types::SignalBuffer,
vad: types::VadData,
eight_k: bool,
}
impl PesqContext {
pub fn new(ref_wav: &[i16]) -> Result<Self, PesqError> {
Self::from_buffer(input::prepare_input(ref_wav)?, false)
}
pub fn new_8k(ref_wav: &[i16]) -> Result<Self, PesqError> {
Self::from_buffer(types::SignalBuffer::from_pcm(ref_wav)?, true)
}
fn from_buffer(reference: types::SignalBuffer, eight_k: bool) -> Result<Self, PesqError> {
let original = reference.clone();
let mut working = reference;
let divisor =
(original.nominal_len - 2 * types::MARGIN_SAMPLES + types::PADDING_SAMPLES) as f64;
input_buffers::normalize_one(&mut working, divisor);
dsp::apply_filter_curve(
&mut working.samples,
&dsp::IRS_RECEIVE_CURVE,
types::RATE_8K,
);
let model = working.clone();
input_filters::remove_dc(&mut working);
input_filters::input_iir_filter(&mut working);
let vad = vad::voice_activity_detection(&working);
Ok(Self {
original,
working,
model,
vad,
eight_k,
})
}
pub fn score(&self, deg_wav: &[i16]) -> Result<f32, PesqError> {
let mut degraded = if self.eight_k {
types::SignalBuffer::from_pcm(deg_wav)?
} else {
input::prepare_input(deg_wav)?
};
if degraded.nominal_len > self.original.nominal_len {
return score_pair(self.original.clone(), degraded);
}
let n_max = self.original.nominal_len;
let divisor = (n_max - 2 * types::MARGIN_SAMPLES + types::PADDING_SAMPLES) as f64;
input_buffers::normalize_one(&mut degraded, divisor);
dsp::apply_filter_curve(
&mut degraded.samples,
&dsp::IRS_RECEIVE_CURVE,
types::RATE_8K,
);
let mut model_degraded = degraded.clone();
input_filters::remove_dc(&mut degraded);
input_filters::input_iir_filter(&mut degraded);
let deg_vad = vad::voice_activity_detection(°raded);
let utterances =
utterances::align_utterances(&self.working, °raded, &self.vad, °_vad)?;
let mut model_reference = self.model.clone();
model_reference
.samples
.resize(n_max + types::PADDING_SAMPLES, 0.0);
model_degraded
.samples
.resize(n_max + types::PADDING_SAMPLES, 0.0);
Ok(score_aligned(input::AlignedPair {
reference: model_reference,
degraded: model_degraded,
utterances,
}))
}
}
pub fn pesq(ref_wav: &[i16], deg_wav: &[i16]) -> Result<f32, PesqError> {
let reference = input::prepare_input(ref_wav)?;
let degraded = input::prepare_input(deg_wav)?;
score_pair(reference, degraded)
}
pub fn pesq_8k(ref_wav: &[i16], deg_wav: &[i16]) -> Result<f32, PesqError> {
let reference = types::SignalBuffer::from_pcm(ref_wav)?;
let degraded = types::SignalBuffer::from_pcm(deg_wav)?;
score_pair(reference, degraded)
}
pub fn pesq_wb(ref_wav: &[i16], deg_wav: &[i16]) -> Result<f32, PesqError> {
let reference = types::SignalBuffer::from_pcm_at(ref_wav, types::RATE_16K)?;
let degraded = types::SignalBuffer::from_pcm_at(deg_wav, types::RATE_16K)?;
let raw = score_aligned(input::process_pair_wideband(reference, degraded)?);
Ok(score::mos_lqo_wb(f64::from(raw)))
}
fn score_pair(
reference: types::SignalBuffer,
degraded: types::SignalBuffer,
) -> Result<f32, PesqError> {
Ok(score_aligned(input::process_pair(reference, degraded)?))
}
fn score_aligned(pair: input::AlignedPair) -> f32 {
let model = psychoacoustic::run_frame_loop(&pair.reference, &pair.degraded, &pair.utterances);
let frames = disturbance::frame_disturbances(&pair.reference, &pair.degraded, &pair.utterances);
let indicators = disturbance::aggregate(&frames, model.frame_range.start);
score::raw_score(indicators.symmetric, indicators.asymmetric)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::WINDOW_SAMPLES;
fn silence_16k() -> Vec<i16> {
vec![0i16; 2 * types::MIN_INPUT_SAMPLES + 100]
}
fn noise_pair_16k() -> (Vec<i16>, Vec<i16>) {
let mut pcm = vec![0i16; 2 * 8000];
let mut state = 21u32;
let mut burst = 75usize;
let last = 8000 / WINDOW_SAMPLES - 75;
while burst + 60 <= last {
for i in 0..60 * WINDOW_SAMPLES {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
pcm[2 * (burst * WINDOW_SAMPLES + i)] =
(((state as f32 / u32::MAX as f32) * 2.0 - 1.0) * 3000.0) as i16;
}
burst += 90;
}
(pcm.clone(), pcm)
}
#[test]
fn pesq_rejects_short_input() {
let short = vec![0i16; 2 * types::MIN_INPUT_SAMPLES - 1];
assert_eq!(
pesq(&short, &silence_16k()).unwrap_err(),
PesqError::SignalTooShort {
samples: types::MIN_INPUT_SAMPLES - 1
}
);
assert_eq!(
pesq(&silence_16k(), &short).unwrap_err(),
PesqError::SignalTooShort {
samples: types::MIN_INPUT_SAMPLES - 1
}
);
}
#[test]
fn pesq_pipeline_runs_end_to_end() {
let (reference, degraded) = noise_pair_16k();
let score = pesq(&reference, °raded).expect("identical pair must score");
assert!(score.is_finite(), "score {score} is not finite");
assert!(score <= 4.5, "raw score {score} exceeds 4.5");
assert!(score > 3.5, "identical pair scored only {score}");
}
fn noise_bursts(seconds: usize, seed: u32) -> Vec<i16> {
let burst_samples = 60 * 2 * WINDOW_SAMPLES;
let cycle_samples = 90 * 2 * WINDOW_SAMPLES;
let mut pcm = vec![0i16; seconds * 16_000];
let mut state = seed;
let mut offset = 0usize;
while offset + burst_samples <= pcm.len() {
for sample in &mut pcm[offset..offset + burst_samples] {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*sample = (((state as f32 / u32::MAX as f32) * 2.0 - 1.0) * 3000.0) as i16;
}
offset += cycle_samples;
}
pcm
}
#[test]
fn pesq_context_scores_bit_identically_to_pesq() {
let reference = noise_bursts(2, 21);
let degraded = noise_bursts(2, 42);
let expected = pesq(&reference, °raded).unwrap();
let context = PesqContext::new(&reference).unwrap();
assert_eq!(
context.score(°raded).unwrap().to_bits(),
expected.to_bits()
);
let variant = noise_bursts(2, 43);
assert_eq!(
context.score(&variant).unwrap().to_bits(),
pesq(&reference, &variant).unwrap().to_bits()
);
}
#[test]
fn pesq_context_8k_scores_bit_identically_to_pesq_8k() {
let reference = input::decimate_16k_to_8k(&noise_bursts(2, 21));
let degraded = input::decimate_16k_to_8k(&noise_bursts(2, 42));
let expected = pesq_8k(&reference, °raded).unwrap();
let context = PesqContext::new_8k(&reference).unwrap();
assert_eq!(
context.score(°raded).unwrap().to_bits(),
expected.to_bits()
);
}
#[test]
fn pesq_context_recomputes_for_a_longer_degraded_signal() {
let reference = noise_bursts(2, 21);
let degraded = noise_bursts(3, 42);
let expected = pesq(&reference, °raded).unwrap();
let context = PesqContext::new(&reference).unwrap();
assert_eq!(
context.score(°raded).unwrap().to_bits(),
expected.to_bits()
);
}
#[test]
fn pesq_wb_rejects_short_input() {
let short = vec![0i16; 2 * types::MIN_INPUT_SAMPLES - 1];
assert_eq!(
pesq_wb(&short, &noise_bursts(1, 21)).unwrap_err(),
PesqError::SignalTooShort {
samples: 2 * types::MIN_INPUT_SAMPLES - 1
}
);
assert_eq!(
pesq_wb(&noise_bursts(1, 21), &short).unwrap_err(),
PesqError::SignalTooShort {
samples: 2 * types::MIN_INPUT_SAMPLES - 1
}
);
assert!(pesq_wb(&noise_bursts(1, 21), &noise_bursts(1, 22)).is_ok());
}
#[test]
fn pesq_wb_pipeline_runs_end_to_end() {
let reference = noise_bursts(2, 21);
let score = pesq_wb(&reference, &reference).expect("identical pair must score");
assert!(score.is_finite(), "score {score} is not finite");
assert!(
(0.999..=4.999).contains(&score),
"wideband MOS-LQO {score} outside [0.999, 4.999]"
);
assert!(score > 3.5, "identical pair scored only {score}");
let degraded = noise_bursts(2, 42);
assert!(pesq_wb(&reference, °raded).unwrap() <= score);
}
}