use crate::simd::scaled_add::add_scaled_scalar;
fn fast_cos(x: f32) -> f32 {
use std::f32::consts::PI;
let pi2 = PI * 2.0;
let xmod = x - (x * (0.5 / PI)).floor() * pi2;
let x_pi = xmod.min(pi2 - xmod);
let above = x_pi >= PI / 2.0;
let xh = if above { PI - x_pi } else { x_pi };
let xs = xh * 0.25;
let x2 = xs * xs;
let x4 = x2 * x2;
let pre = x4 * 0.06960438 + (x2 * -0.84087373 + 1.68179268);
let s1 = pre * pre - std::f32::consts::SQRT_2;
let s2 = s1 * s1 - 1.0;
if above { -s2 } else { s2 }
}
pub(crate) type ContinuousIdctFn = fn(&[[f32; 4]], f32) -> [f32; 4];
pub(super) fn continuous_idct_scalar(dct: &[[f32; 4]], t: f32) -> [f32; 4] {
let mut result = [0.0; 4];
for (i, row) in dct.iter().enumerate() {
let arg = std::f32::consts::PI / 32.0 * i as f32 * (t + 0.5);
let cos = fast_cos(arg);
add_scaled_scalar(&mut result, row, cos);
}
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn continuous_idct_matches_separate_channels() {
let channels: [[f32; 32]; 4] = std::array::from_fn(|c| {
std::array::from_fn(|i| {
if c == 3 && i != 0 {
0.0
} else {
((i * 17 + c * 7) % 41) as f32 * 0.01 - 0.2
}
})
});
let interleaved: [[f32; 4]; 32] = std::array::from_fn(|i| {
std::array::from_fn(|c| std::f32::consts::SQRT_2 * channels[c][i])
});
let selected = crate::splines::SplinesContext::get().continuous_idct;
let steps = if cfg!(miri) { 8 } else { 256 };
for k in 0..=steps {
let t = 31.0 * k as f32 / steps as f32;
let expected = channels.map(|channel| {
let mut result = 0.0;
for (i, v) in channel.into_iter().enumerate() {
let arg = std::f32::consts::PI / 32.0 * i as f32 * (t + 0.5);
result += std::f32::consts::SQRT_2 * v * fast_cos(arg);
}
result
});
assert_eq!(continuous_idct_scalar(&interleaved, t), expected);
assert_eq!(selected(&interleaved, t), expected, "t={t}");
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse2") {
assert_eq!(
unsafe { crate::sse::continuous_idct_sse2(&interleaved, t) },
expected
);
}
if std::is_x86_feature_detected!("sse4.1") {
assert_eq!(
unsafe { crate::sse::continuous_idct_sse41(&interleaved, t) },
expected
);
}
}
}
}
#[test]
fn continuous_idct_omits_trailing_zeros_bitwise() {
let selected = crate::splines::SplinesContext::get().continuous_idct;
let mut dct = [[0.0, -0.0, 0.0, -0.0]; 32];
for active in 1..=dct.len() {
let i = active - 1;
dct[i][i % 4] = if i % 2 == 0 { 0.37 } else { -0.19 };
for t in [0.0, 0.13, 1.0, 15.0, 27.375, 31.0] {
let expected = continuous_idct_scalar(&dct, t).map(f32::to_bits);
assert_eq!(
continuous_idct_scalar(&dct[..active], t).map(f32::to_bits),
expected
);
assert_eq!(
selected(&dct[..active], t).map(f32::to_bits),
expected,
"active={active}, t={t}"
);
}
}
}
}