use super::*;
#[test]
fn noop_plan_is_identity() {
assert_eq!(NoopResampler.plan(1920, 1080), Ok(None));
}
#[test]
fn area_identity_plans_none() {
assert_eq!(AreaResampler::to(8, 8).plan(8, 8), Ok(None));
}
#[test]
fn area_zero_output_rejected() {
let err = AreaResampler::to(4, 0).plan(8, 8).unwrap_err();
match err {
ResampleError::ZeroOutputDimension(e) => {
assert_eq!(e.out_w(), 4);
assert_eq!(e.out_h(), 0);
}
other => panic!("expected ZeroOutputDimension, got {other:?}"),
}
}
#[test]
fn area_upscale_rejected_per_axis() {
let err = AreaResampler::to(4, 16).plan(8, 8).unwrap_err();
match err {
ResampleError::UpscaleUnsupported(e) => {
assert_eq!((e.src_w(), e.src_h()), (8, 8));
assert_eq!((e.out_w(), e.out_h()), (4, 16));
}
other => panic!("expected UpscaleUnsupported, got {other:?}"),
}
}
#[test]
fn area_plan_reports_geometry() {
let plan = AreaResampler::to(336, 189)
.plan(1920, 1080)
.expect("valid downscale")
.expect("non-identity");
assert_eq!(plan.out_w(), 336);
assert_eq!(plan.out_h(), 189);
assert_eq!(plan.out_dims(), (336, 189));
assert_eq!((plan.src_w(), plan.src_h()), (1920, 1080));
}
#[test]
fn area_integer_ratio_spans() {
let plan = AreaResampler::to(4, 4)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
for axis in [plan.h(), plan.v()] {
assert_eq!(axis.out_len(), 4);
for j in 0..4 {
let (start, weights) = axis.span(j);
assert_eq!(start, 2 * j);
assert_eq!(weights, &[4, 4]);
}
}
}
#[test]
fn area_fractional_spans_8_to_3() {
let plan = AreaResampler::to(3, 8)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let h = plan.h();
assert_eq!(h.out_len(), 3);
assert_eq!(h.span(0), (0, &[3usize, 3, 2][..]));
assert_eq!(h.span(1), (2, &[1usize, 3, 3, 1][..]));
assert_eq!(h.span(2), (5, &[2usize, 3, 3][..]));
let v = plan.v();
assert_eq!(v.out_len(), 8);
for j in 0..8 {
assert_eq!(v.span(j), (j, &[8usize][..]));
}
}
#[test]
fn area_spans_handle_the_upsample_direction() {
let spans = AxisSpans::area(4, 6).expect("upsample coverage is valid");
assert_eq!(spans.out_len(), 6);
let expected: [(usize, &[usize]); 6] = [
(0, &[4]),
(0, &[2, 2]),
(1, &[4]),
(2, &[4]),
(2, &[2, 2]),
(3, &[4]),
];
for (j, &(start, weights)) in expected.iter().enumerate() {
assert_eq!(spans.span(j), (start, weights), "span {j}");
}
}
#[test]
fn area_spans_partition_the_source() {
let plan = AreaResampler::to(336, 189)
.plan(1920, 1080)
.expect("valid")
.expect("non-identity");
for (axis, src, out) in [(plan.h(), 1920, 336), (plan.v(), 1080, 189)] {
assert_eq!(axis.out_len(), out);
let mut prev_start = None;
for j in 0..out {
let (start, weights) = axis.span(j);
assert_eq!(weights.iter().sum::<usize>(), src, "span {j} sum");
assert!(weights.iter().all(|&w| w > 0), "span {j} zero tap");
assert!(weights.len() == 6 || weights.len() == 7, "span {j} taps");
if let Some(p) = prev_start {
assert!(start > p, "span {j} start not increasing");
}
prev_start = Some(start);
}
let (last_start, last_weights) = axis.span(out - 1);
assert_eq!(last_start + last_weights.len(), src);
assert_eq!(axis.span(0).0, 0);
}
}
#[cfg(feature = "yuv-planar")]
fn direct_area_2d(plan: &ResamplePlan, src: &[u8], channels: usize) -> std::vec::Vec<u8> {
let (out_w, out_h) = plan.out_dims();
let src_w = plan.src_w();
let denom = (src_w as u64) * (plan.src_h() as u64);
let mut out = std::vec![0u8; out_w * out_h * channels];
for oy in 0..out_h {
let (vy, vw) = plan.v().span(oy);
for ox in 0..out_w {
let (hx, hw) = plan.h().span(ox);
for c in 0..channels {
let mut acc = 0u64;
for (dy, &wy) in vw.iter().enumerate() {
for (dx, &wx) in hw.iter().enumerate() {
let s = src[((vy + dy) * src_w + hx + dx) * channels + c] as u64;
acc += (wy as u64) * (wx as u64) * s;
}
}
out[(oy * out_w + ox) * channels + c] = ((acc + denom / 2) / denom) as u8;
}
}
}
out
}
#[cfg(feature = "yuv-planar")]
fn stream_collect(plan: &ResamplePlan, src: &[u8], channels: usize) -> std::vec::Vec<u8> {
let (out_w, out_h) = plan.out_dims();
let src_w = plan.src_w();
let mut stream = AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), channels)
.expect("realistic geometry");
let mut out = std::vec![0u8; out_w * out_h * channels];
let mut emitted = std::vec::Vec::new();
for y in 0..plan.src_h() {
let row = &src[y * src_w * channels..(y + 1) * src_w * channels];
stream
.feed_row(y, row, true, |oy, finalized| {
emitted.push(oy);
out[oy * out_w * channels..(oy + 1) * out_w * channels].copy_from_slice(finalized);
})
.expect("rows arrive in order");
}
assert_eq!(emitted, (0..out_h).collect::<std::vec::Vec<_>>());
out
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_matches_direct_2d_reference_fractional() {
let plan = AreaResampler::to(3, 3)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let src: std::vec::Vec<u8> = (0..64u8).collect();
assert_eq!(
stream_collect(&plan, &src, 1),
direct_area_2d(&plan, &src, 1)
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_matches_direct_2d_reference_multichannel() {
let plan = AreaResampler::to(4, 3)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let mut src = std::vec![0u8; 8 * 8 * 3];
for (i, px) in src.chunks_exact_mut(3).enumerate() {
px[0] = i as u8;
px[1] = (3 * i % 251) as u8;
px[2] = 255 - i as u8;
}
assert_eq!(
stream_collect(&plan, &src, 3),
direct_area_2d(&plan, &src, 3)
);
}
#[cfg(feature = "yuv-planar")]
fn direct_area_2d_u16(plan: &ResamplePlan, src: &[u16], channels: usize) -> std::vec::Vec<u16> {
let (out_w, out_h) = plan.out_dims();
let src_w = plan.src_w();
let denom = (src_w as u64) * (plan.src_h() as u64);
let mut out = std::vec![0u16; out_w * out_h * channels];
for oy in 0..out_h {
let (vy, vw) = plan.v().span(oy);
for ox in 0..out_w {
let (hx, hw) = plan.h().span(ox);
for c in 0..channels {
let mut acc = 0u64;
for (dy, &wy) in vw.iter().enumerate() {
for (dx, &wx) in hw.iter().enumerate() {
let s = src[((vy + dy) * src_w + hx + dx) * channels + c] as u64;
acc += (wy as u64) * (wx as u64) * s;
}
}
out[(oy * out_w + ox) * channels + c] = ((acc + denom / 2) / denom) as u16;
}
}
}
out
}
#[cfg(feature = "yuv-planar")]
fn stream_collect_u16(plan: &ResamplePlan, src: &[u16], channels: usize) -> std::vec::Vec<u16> {
let (out_w, out_h) = plan.out_dims();
let src_w = plan.src_w();
let mut stream = AreaStream::<u16>::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), channels)
.expect("realistic geometry");
let mut out = std::vec![0u16; out_w * out_h * channels];
let mut emitted = std::vec::Vec::new();
for y in 0..plan.src_h() {
let row = &src[y * src_w * channels..(y + 1) * src_w * channels];
stream
.feed_row(y, row, true, |oy, finalized| {
emitted.push(oy);
out[oy * out_w * channels..(oy + 1) * out_w * channels].copy_from_slice(finalized);
})
.expect("rows arrive in order");
}
assert_eq!(emitted, (0..out_h).collect::<std::vec::Vec<_>>());
out
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_u16_matches_direct_2d_reference_fractional() {
let plan = AreaResampler::to(3, 3)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let src: std::vec::Vec<u16> = (0..64u16).map(|i| i * 1040).collect();
assert_eq!(
stream_collect_u16(&plan, &src, 1),
direct_area_2d_u16(&plan, &src, 1)
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_u16_matches_direct_2d_reference_multichannel() {
let plan = AreaResampler::to(4, 3)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let mut src = std::vec![0u16; 8 * 8 * 3];
for (i, px) in src.chunks_exact_mut(3).enumerate() {
px[0] = (i as u16) * 1000;
px[1] = ((7 * i) % 211) as u16 * 300;
px[2] = 65535 - (i as u16) * 1000;
}
assert_eq!(
stream_collect_u16(&plan, &src, 3),
direct_area_2d_u16(&plan, &src, 3)
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_u16_exact_2x2_block_mean() {
let plan = AreaResampler::to(2, 2)
.plan(4, 4)
.expect("valid")
.expect("non-identity");
let src: std::vec::Vec<u16> = std::vec![
60000, 60002, 10, 11, 60004, 60006, 12, 13, 1, 2, 65535, 65533, 3, 5, 65531, 65529, ];
assert_eq!(
stream_collect_u16(&plan, &src, 1),
std::vec![60003u16, 12, 3, 65532]
);
}
#[cfg(feature = "yuv-planar")]
fn direct_area_2d_f32(plan: &ResamplePlan, src: &[f32], channels: usize) -> std::vec::Vec<f32> {
let (out_w, out_h) = plan.out_dims();
let src_w = plan.src_w();
let denom = (src_w as f64) * (plan.src_h() as f64);
let mut out = std::vec![0f32; out_w * out_h * channels];
for oy in 0..out_h {
let (vy, vw) = plan.v().span(oy);
for ox in 0..out_w {
let (hx, hw) = plan.h().span(ox);
for c in 0..channels {
let mut acc = 0f64;
for (dy, &wy) in vw.iter().enumerate() {
for (dx, &wx) in hw.iter().enumerate() {
let s = src[((vy + dy) * src_w + hx + dx) * channels + c] as f64;
acc += (wy as f64) * (wx as f64) * s;
}
}
out[(oy * out_w + ox) * channels + c] = (acc / denom) as f32;
}
}
}
out
}
#[cfg(feature = "yuv-planar")]
fn stream_collect_f32(plan: &ResamplePlan, src: &[f32], channels: usize) -> std::vec::Vec<f32> {
let (out_w, out_h) = plan.out_dims();
let src_w = plan.src_w();
let mut stream = AreaStream::<f32>::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), channels)
.expect("realistic geometry");
let mut out = std::vec![0f32; out_w * out_h * channels];
let mut emitted = std::vec::Vec::new();
for y in 0..plan.src_h() {
let row = &src[y * src_w * channels..(y + 1) * src_w * channels];
stream
.feed_row(y, row, false, |oy, finalized| {
emitted.push(oy);
out[oy * out_w * channels..(oy + 1) * out_w * channels].copy_from_slice(finalized);
})
.expect("rows arrive in order");
}
assert_eq!(emitted, (0..out_h).collect::<std::vec::Vec<_>>());
out
}
#[cfg(feature = "yuv-planar")]
fn assert_f32_close(a: &[f32], b: &[f32], tol: f32) {
assert_eq!(a.len(), b.len(), "length");
for (i, (&x, &y)) in a.iter().zip(b.iter()).enumerate() {
assert!((x - y).abs() <= tol, "index {i}: {x} vs {y} (tol {tol})");
}
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_f32_matches_direct_2d_reference_fractional() {
let plan = AreaResampler::to(3, 3)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let src: std::vec::Vec<f32> = (0..64).map(|i| i as f32 * 0.1).collect();
assert_f32_close(
&stream_collect_f32(&plan, &src, 1),
&direct_area_2d_f32(&plan, &src, 1),
1e-4,
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_f32_matches_direct_2d_reference_multichannel() {
let plan = AreaResampler::to(4, 3)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let mut src = std::vec![0f32; 8 * 8 * 3];
for (i, px) in src.chunks_exact_mut(3).enumerate() {
px[0] = i as f32 * 0.5;
px[1] = 100.0 - i as f32 * 0.25;
px[2] = ((7 * i) % 211) as f32;
}
assert_f32_close(
&stream_collect_f32(&plan, &src, 3),
&direct_area_2d_f32(&plan, &src, 3),
1e-2,
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_f32_exact_2x2_block_mean() {
let plan = AreaResampler::to(2, 2)
.plan(4, 4)
.expect("valid")
.expect("non-identity");
let src: std::vec::Vec<f32> = std::vec![
1.0, 2.0, 10.0, 12.0, 3.0, 4.0, 14.0, 16.0, 0.5, 1.5, 100.0, 102.0, 2.5, 3.5, 104.0, 106.0, ];
assert_f32_close(
&stream_collect_f32(&plan, &src, 1),
&std::vec![2.5f32, 13.0, 2.0, 103.0],
1e-3,
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_f32_preserves_large_finite_values_without_overflow() {
let plan = AreaResampler::to(2, 2)
.plan(4, 4)
.expect("valid")
.expect("non-identity");
let big = 1.0e38f32;
let src = std::vec![big; 4 * 4];
for (i, &v) in stream_collect_f32(&plan, &src, 1).iter().enumerate() {
assert!(v.is_finite(), "output {i} overflowed to {v}");
assert!((v - big).abs() <= big * 1e-5, "output {i}: {v} vs {big}");
}
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_identity_vertical_axis_emits_every_row() {
let plan = AreaResampler::to(3, 8)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let src: std::vec::Vec<u8> = (0..64u8).collect();
assert_eq!(
stream_collect(&plan, &src, 1),
direct_area_2d(&plan, &src, 1)
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_creation_fails_recoverably_on_huge_row_buffers() {
let plan = AreaResampler::to(4, 4)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let err = AreaStream::<u8>::new(
plan.h(),
plan.v(),
plan.src_w(),
plan.src_h(),
usize::MAX / 16,
)
.unwrap_err();
assert!(err.is_allocation_failed(), "got {err:?}");
}
#[cfg(feature = "yuv-planar")]
#[test]
fn area_chroma_420_reports_allocation_failure_as_such() {
let err = ResamplePlan::area_chroma_420(4, 8, 2, usize::MAX / 8, 0.0, 0.0, false).unwrap_err();
assert!(err.is_allocation_failed(), "got {err:?}");
}
#[cfg(feature = "yuv-planar")]
#[test]
fn area_halved_weights_the_odd_tail_row_by_its_luma_coverage() {
let spans = AxisSpans::area_halved(9, 3).expect("valid");
assert_eq!(spans.out_len(), 3);
assert_eq!(spans.span(0), (0, &[6usize, 3][..]));
assert_eq!(spans.span(1), (1, &[3usize, 6][..]));
assert_eq!(spans.span(2), (3, &[6usize, 3][..]));
let even = AxisSpans::area_halved(8, 4).expect("valid");
for j in 0..4 {
assert_eq!(even.span(j), (j, &[8usize][..]));
}
}
#[cfg(feature = "yuv-planar")]
#[test]
fn area_chroma_phased_v_folds_the_bottom_triangle() {
let even = AxisSpans::area_chroma_phased_v(8, 3).expect("valid");
assert_eq!(even.out_len(), 3);
assert_eq!(even.span(0), (0, &[14usize, 2][..]));
assert_eq!(even.span(1), (0, &[1usize, 10, 5][..]));
assert_eq!(even.span(2), (2, &[7usize, 9][..]));
for o in 0..3 {
assert_eq!(even.span(o).1.iter().sum::<usize>(), 2 * 8, "span {o} sum");
}
let odd = AxisSpans::area_chroma_phased_v(5, 2).expect("valid");
assert_eq!(odd.out_len(), 2);
assert_eq!(odd.span(0), (0, &[9usize, 1][..]));
assert_eq!(odd.span(1), (0, &[1usize, 7, 2][..]));
for o in 0..2 {
assert_eq!(odd.span(o).1.iter().sum::<usize>(), 2 * 5, "span {o} sum");
}
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_two_row_window_matches_blend_then_bin_oracle() {
let plan = ResamplePlan::area_chroma_420(1, 8, 1, 3, 0.0, 1.0, false).expect("valid Bottom plan");
assert_eq!(
plan.src_h(),
16,
"Bottom V spans sum to 2*luma_h -> scaled denom"
);
let chroma = [10u8, 20, 40, 80]; let mut stream =
AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), 1).expect("realistic geometry");
let mut out = [0u8; 3];
let mut emitted = std::vec::Vec::new();
for (y, &c) in chroma.iter().enumerate() {
stream
.feed_row(y, &[c], true, |oy, finalized| {
emitted.push(oy);
out[oy] = finalized[0];
})
.expect("chroma rows arrive in order");
}
assert_eq!(
emitted,
std::vec![0, 1, 2],
"each output finalizes once, in order"
);
assert_eq!(out, [11, 26, 63], "2-row-window blend-then-bin oracle");
assert_eq!(out.to_vec(), direct_area_2d(&plan, &chroma, 1));
for &(cw, luma_h, ow, oh, channels) in &[(2usize, 8, 2, 3, 2), (4, 12, 3, 5, 3)] {
let plan = ResamplePlan::area_chroma_420(cw, luma_h, ow, oh, 0.0, 1.0, false).expect("valid");
let chroma_h = luma_h.div_ceil(2);
let mut src = std::vec![0u8; cw * chroma_h * channels];
lcg_fill(&mut src, 0x51 ^ luma_h as u32);
let mut streamed = std::vec![0u8; ow * oh * channels];
let mut stream =
AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), channels).expect("geometry");
for y in 0..chroma_h {
let row = &src[y * cw * channels..(y + 1) * cw * channels];
stream
.feed_row(y, row, true, |oy, fin| {
streamed[oy * ow * channels..(oy + 1) * ow * channels].copy_from_slice(fin);
})
.expect("rows in order");
}
assert_eq!(
streamed,
direct_area_2d(&plan, &src, channels),
"{cw}x{chroma_h}->{ow}x{oh} c{channels} Bottom stream vs direct span-sum"
);
}
let (cw, luma_h, ow, oh, channels) = (4usize, 12, 3, 5, 2);
let plan =
ResamplePlan::area_chroma_420(cw, luma_h, ow, oh, 0.5, 1.0, false).expect("combined plan");
assert_eq!(
(plan.src_w(), plan.src_h()),
(8 * cw, 2 * luma_h),
"both denominators scale"
);
let chroma_h = luma_h.div_ceil(2);
let mut src = std::vec![0u8; cw * chroma_h * channels];
lcg_fill(&mut src, 0x9e);
let mut stream = AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), channels)
.expect("combined guards admit realistic geometry");
let mut emitted = std::vec::Vec::new();
for y in 0..chroma_h {
let row = &src[y * cw * channels..(y + 1) * cw * channels];
stream
.feed_row(y, row, true, |oy, _| emitted.push(oy))
.expect("rows in order");
}
assert_eq!(
emitted,
(0..oh).collect::<std::vec::Vec<_>>(),
"every output finalizes under both scales"
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn area_chroma_phased_v_top_folds_the_forward_triangle() {
let even = AxisSpans::area_chroma_phased_v_top(8, 3).expect("valid");
assert_eq!(even.out_len(), 3);
assert_eq!(even.span(0), (0, &[9usize, 7][..]));
assert_eq!(even.span(1), (1, &[5usize, 10, 1][..]));
assert_eq!(even.span(2), (2, &[2usize, 14][..]));
for o in 0..3 {
assert_eq!(even.span(o).1.iter().sum::<usize>(), 2 * 8, "span {o} sum");
}
let odd = AxisSpans::area_chroma_phased_v_top(5, 2).expect("valid");
assert_eq!(odd.out_len(), 2);
assert_eq!(odd.span(0), (0, &[6usize, 4][..]));
assert_eq!(odd.span(1), (1, &[4usize, 6][..]));
for o in 0..2 {
assert_eq!(odd.span(o).1.iter().sum::<usize>(), 2 * 5, "span {o} sum");
}
let bottom = AxisSpans::area_chroma_phased_v(8, 3).expect("valid");
assert_ne!(even.span(0), bottom.span(0), "Top out0 != Bottom out0");
}
#[cfg(feature = "yuv-planar")]
#[test]
fn top_forward_stream_matches_reconstruct_then_bin_oracle() {
let plan = ResamplePlan::area_chroma_420(1, 8, 1, 3, 0.0, 0.0, true).expect("valid Top plan");
assert_eq!(
plan.src_h(),
16,
"Top V spans sum to 2*luma_h -> scaled denom"
);
assert!(
!plan.has_chroma_v_phase(),
"Top is v = 0, not Bottom's v = 1"
);
let chroma = [10u8, 20, 40, 80];
let mut stream =
AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), 1).expect("realistic geometry");
let mut out = [0u8; 3];
let mut emitted = std::vec::Vec::new();
for (y, &c) in chroma.iter().enumerate() {
stream
.feed_row(y, &[c], true, |oy, finalized| {
emitted.push(oy);
out[oy] = finalized[0];
})
.expect("chroma rows arrive in order");
}
assert_eq!(emitted, std::vec![0, 1, 2], "each output finalizes once");
assert_eq!(out, [14, 36, 75], "forward reconstruct-then-bin oracle");
assert_eq!(out.to_vec(), direct_area_2d(&plan, &chroma, 1));
let bottom = ResamplePlan::area_chroma_420(1, 8, 1, 3, 0.0, 1.0, false).expect("Bottom");
assert_ne!(
direct_area_2d(&plan, &chroma, 1),
direct_area_2d(&bottom, &chroma, 1),
"Top vertical output must differ from Bottom"
);
for &(cw, luma_h, ow, oh, channels) in &[(2usize, 8, 2, 3, 2), (4, 12, 3, 5, 3)] {
let plan =
ResamplePlan::area_chroma_420(cw, luma_h, ow, oh, 0.0, 0.0, true).expect("valid Top plan");
let chroma_h = luma_h.div_ceil(2);
let mut src = std::vec![0u8; cw * chroma_h * channels];
lcg_fill(&mut src, 0x37 ^ luma_h as u32);
let mut streamed = std::vec![0u8; ow * oh * channels];
let mut stream =
AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), channels).expect("geometry");
for y in 0..chroma_h {
let row = &src[y * cw * channels..(y + 1) * cw * channels];
stream
.feed_row(y, row, true, |oy, fin| {
streamed[oy * ow * channels..(oy + 1) * ow * channels].copy_from_slice(fin);
})
.expect("rows in order");
}
assert_eq!(
streamed,
direct_area_2d(&plan, &src, channels),
"{cw}x{chroma_h}->{ow}x{oh} c{channels} Top stream vs direct span-sum"
);
}
}
#[cfg(feature = "yuv-planar")]
#[test]
fn top_forward_window_depth_matches_bottom() {
let frac = ResamplePlan::area_chroma_420(2, 8, 2, 3, 0.0, 0.0, true).expect("Top frac");
assert_eq!(
frac.v().window_depth(),
2,
"a fractional Top downscale opens two rows"
);
let exact = ResamplePlan::area_chroma_420(2, 8, 2, 4, 0.0, 0.0, true).expect("Top exact");
assert_eq!(
exact.v().window_depth(),
1,
"an exact 2:1 Top downscale opens one row"
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn co_sited_area_stream_allocates_no_lookahead() {
let cosited =
ResamplePlan::area_chroma_420(2, 8, 2, 4, 0.0, 0.0, false).expect("valid co-sited plan");
assert_eq!(
cosited.v().window_depth(),
1,
"co-sited spans never overlap mid-row"
);
let s = AreaStream::<u8>::new(
cosited.h(),
cosited.v(),
cosited.src_w(),
cosited.src_h(),
1,
)
.expect("realistic geometry");
assert!(
s.acc_next.is_empty(),
"a co-sited stream must not allocate the look-ahead accumulator"
);
let bottom =
ResamplePlan::area_chroma_420(2, 8, 2, 3, 0.0, 1.0, false).expect("valid Bottom plan");
assert_eq!(
bottom.v().window_depth(),
2,
"a Bottom downscale opens two rows"
);
let b = AreaStream::<u8>::new(bottom.h(), bottom.v(), bottom.src_w(), bottom.src_h(), 1)
.expect("realistic geometry");
assert!(
!b.acc_next.is_empty(),
"a Bottom downscale needs the look-ahead accumulator"
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn phased_v_exceeding_two_open_rows_is_rejected() {
let plan = ResamplePlan::area_chroma_420(2, 3, 2, 7, 0.0, 1.0, false).expect("plan builds");
assert!(
plan.v().window_depth() > 2,
"the 3->7 Bottom shape opens more than two rows at once"
);
let err = AreaStream::<u8>::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), 1)
.expect_err("a >2-open-row plan must be rejected, not streamed");
assert!(
matches!(err, ResampleError::UpscaleUnsupported(_)),
"expected UpscaleUnsupported, got {err:?}"
);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_rejects_out_of_order_duplicate_and_skipped_rows() {
let plan = AreaResampler::to(4, 4)
.plan(8, 8)
.expect("valid")
.expect("non-identity");
let row = [0u8; 8];
let mut stream = AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), 1).unwrap();
let err = stream.feed_row(1, &row, true, |_, _| {}).unwrap_err();
match err {
ResampleError::OutOfSequenceRow(e) => {
assert_eq!((e.expected(), e.got()), (0, 1));
}
other => panic!("expected OutOfSequenceRow, got {other:?}"),
}
stream.feed_row(0, &row, true, |_, _| {}).unwrap();
let err = stream.feed_row(0, &row, true, |_, _| {}).unwrap_err();
assert!(err.is_out_of_sequence_row());
let err = stream.feed_row(2, &row, true, |_, _| {}).unwrap_err();
match err {
ResampleError::OutOfSequenceRow(e) => {
assert_eq!((e.expected(), e.got()), (1, 2));
}
other => panic!("expected OutOfSequenceRow, got {other:?}"),
}
stream.reset();
stream.feed_row(0, &row, true, |_, _| {}).unwrap();
}
#[test]
fn round_div_half_up_is_exact_and_overflow_free() {
for d in 1u64..=9 {
for a in 0u64..=200 {
assert_eq!(round_div_half_up(a, d), (a + d / 2) / d, "a={a} d={d}");
}
}
let d = u64::MAX / 255;
assert_eq!(round_div_half_up(d * 255, d), 255);
assert_eq!(round_div_half_up(u64::MAX, u64::MAX), 1);
assert_eq!(round_div_half_up(u64::MAX - 1, u64::MAX), 1);
assert_eq!(round_div_half_up(u64::MAX / 2, u64::MAX), 0);
assert_eq!(round_div_half_up(u64::MAX / 2 + 1, u64::MAX), 1);
}
#[cfg(feature = "yuv-planar")]
#[test]
fn stream_constant_input_is_constant() {
let plan = AreaResampler::to(3, 2)
.plan(7, 5)
.expect("valid")
.expect("non-identity");
let src = std::vec![173u8; 7 * 5];
assert!(stream_collect(&plan, &src, 1).iter().all(|&v| v == 173));
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
fn lcg_fill(buf: &mut [u8], seed: u32) {
let mut state = seed;
for b in buf {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*b = (state >> 8) as u8;
}
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
#[test]
fn area_matches_cv2_inter_area_within_one_lsb() {
for &(src_w, src_h, out_w, out_h, channels, seed, golden) in super::cv2_goldens::ALL {
let mut src = std::vec![0u8; src_w * src_h * channels];
lcg_fill(&mut src, seed);
let plan = AreaResampler::to(out_w, out_h)
.plan(src_w, src_h)
.expect("valid downscale")
.expect("non-identity");
let mut stream =
AreaStream::new(plan.h(), plan.v(), src_w, src_h, channels).expect("realistic geometry");
let mut ours = std::vec![0u8; out_w * out_h * channels];
for y in 0..src_h {
let row = &src[y * src_w * channels..(y + 1) * src_w * channels];
stream
.feed_row(y, row, true, |oy, finalized| {
ours[oy * out_w * channels..(oy + 1) * out_w * channels].copy_from_slice(finalized);
})
.expect("rows in order");
}
assert_eq!(golden.len(), ours.len(), "{src_w}x{src_h}->{out_w}x{out_h}");
for (i, (a, b)) in ours.iter().zip(golden.iter()).enumerate() {
assert!(
a.abs_diff(*b) <= 1,
"{src_w}x{src_h}->{out_w}x{out_h} c{channels} idx {i}: ours {a} vs cv2 {b}"
);
}
}
}
#[test]
fn plan_error_display_names_geometry() {
let upscale = ResampleError::UpscaleUnsupported(UpscaleUnsupported::new(1920, 1080, 3840, 2160));
assert!(upscale.is_upscale_unsupported());
let msg = format!("{upscale}");
assert!(msg.contains("1920x1080"), "{msg}");
assert!(msg.contains("3840x2160"), "{msg}");
let zero = ResampleError::ZeroOutputDimension(ZeroOutputDimension::new(0, 189));
assert!(zero.is_zero_output_dimension());
assert!(format!("{zero}").contains("0x189"));
let overflow = ResampleError::Overflow(PlanGeometry::new(usize::MAX, 2, 3, 1));
let alloc = ResampleError::AllocationFailed(PlanGeometry::new(usize::MAX, 1, 1, 1));
assert!(alloc.is_allocation_failed());
assert!(format!("{alloc}").contains("allocation"));
assert!(overflow.is_overflow());
let msg = format!("{overflow}");
assert!(msg.contains("3x1"), "{msg}");
}
#[test]
fn area_plans_products_beyond_32_bits() {
let plan = AreaResampler::to(62_000, 1)
.plan(70_000, 2)
.expect("coordinates must not overflow 32-bit usize")
.expect("non-identity");
let h = plan.h();
assert_eq!(h.out_len(), 62_000);
let (first_start, first) = h.span(0);
assert_eq!(first_start, 0);
assert_eq!(first.iter().sum::<usize>(), 70_000);
let (last_start, last) = h.span(61_999);
assert_eq!(last_start + last.len(), 70_000);
}
#[test]
fn area_taps_formula_is_exact() {
for src in 1..=24usize {
for out in 1..=src {
let expected = AxisSpans::area_taps(src, out).unwrap();
let plan = AreaResampler::to(out, 1).plan(src, 1);
if out == src {
assert_eq!(expected, src);
continue;
}
let plan = plan.expect("valid").expect("non-identity");
let total: usize = (0..out).map(|j| plan.h().span(j).1.len()).sum();
assert_eq!(total, expected, "src={src} out={out}");
}
}
assert_eq!(AxisSpans::area_taps(usize::MAX, 1), Some(usize::MAX));
}
#[test]
fn area_tiny_output_huge_source_fails_recoverably() {
let err = AreaResampler::to(1, 1).plan(usize::MAX, 1).unwrap_err();
assert!(err.is_allocation_failed(), "got {err:?}");
}
#[test]
fn area_overflow_rejected() {
let err = AreaResampler::to(usize::MAX / 2, 1)
.plan(usize::MAX - 1, 1)
.unwrap_err();
#[cfg(target_pointer_width = "64")]
assert!(err.is_overflow(), "got {err:?}");
#[cfg(target_pointer_width = "32")]
assert!(err.is_allocation_failed(), "got {err:?}");
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
#[test]
fn h_pass_simd_matches_scalar_bit_exact() {
let cases: &[(usize, usize, usize)] = if cfg!(miri) {
&[(64, 7, 1), (64, 7, 3), (12, 11, 3), (8, 3, 1), (5, 4, 3)]
} else {
&[
(1920, 336, 1),
(1920, 336, 3),
(640, 7, 1),
(640, 7, 3),
(4096, 4095, 1),
(4096, 4095, 3),
(5, 4, 3),
(8, 3, 1),
(70_000, 66_000, 1),
(256, 8, 1), (256, 8, 3),
(264, 8, 1), (264, 8, 3),
(336, 8, 1), (336, 8, 3),
(400, 8, 1), (400, 8, 3),
(120, 8, 1), (120, 8, 3),
(160, 8, 1), (160, 8, 3),
]
};
for &(src_w, out_w, channels) in cases {
let plan = AreaResampler::to(out_w, 1)
.plan(src_w, 2)
.expect("valid geometry")
.expect("strict downscale");
let mut scalar = AreaStream::new(plan.h(), plan.v(), src_w, 2, channels).unwrap();
let mut simd = AreaStream::new(plan.h(), plan.v(), src_w, 2, channels).unwrap();
let mut row = std::vec![0u8; src_w * channels];
for y in 0..2usize {
lcg_fill(&mut row, (src_w * 31 + out_w * 7 + channels + y) as u32);
let mut scalar_rows = std::vec::Vec::new();
let mut simd_rows = std::vec::Vec::new();
scalar
.feed_row(y, &row, false, |oy, r| {
scalar_rows.push((oy, r.to_vec()));
})
.unwrap();
simd
.feed_row(y, &row, true, |oy, r| {
simd_rows.push((oy, r.to_vec()));
})
.unwrap();
assert_eq!(
scalar.h_tmp, simd.h_tmp,
"h_tmp diverged: src_w={src_w} out_w={out_w} c={channels} y={y}"
);
assert_eq!(
scalar.acc, simd.acc,
"acc diverged: src_w={src_w} out_w={out_w} c={channels} y={y}"
);
assert_eq!(
scalar_rows, simd_rows,
"emitted rows diverged: src_w={src_w} out_w={out_w} c={channels}"
);
}
}
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
fn lcg_fill_u16(buf: &mut [u16], seed: u32) {
let mut state = seed;
for b in buf {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*b = (state >> 8) as u16;
}
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
#[test]
fn h_pass_u16_simd_matches_scalar_bit_exact() {
let cases: &[(usize, usize, usize)] = if cfg!(miri) {
&[(64, 7, 1), (64, 7, 3), (12, 11, 3), (8, 3, 1), (5, 4, 3)]
} else {
&[
(1920, 336, 1),
(1920, 336, 3),
(640, 7, 1),
(640, 7, 3),
(4096, 4095, 1),
(4096, 4095, 3),
(5, 4, 3),
(8, 3, 1),
(70_000, 66_000, 1),
(256, 8, 1),
(256, 8, 3),
(264, 8, 1),
(264, 8, 3),
(336, 8, 1),
(336, 8, 3),
(400, 8, 1),
(400, 8, 3),
(120, 8, 1),
(120, 8, 3),
(160, 8, 1),
(160, 8, 3),
]
};
for &(src_w, out_w, channels) in cases {
let plan = AreaResampler::to(out_w, 1)
.plan(src_w, 2)
.expect("valid geometry")
.expect("strict downscale");
let mut scalar = AreaStream::<u16>::new(plan.h(), plan.v(), src_w, 2, channels).unwrap();
let mut simd = AreaStream::<u16>::new(plan.h(), plan.v(), src_w, 2, channels).unwrap();
let mut row = std::vec![0u16; src_w * channels];
for y in 0..2usize {
lcg_fill_u16(&mut row, (src_w * 31 + out_w * 7 + channels + y) as u32);
let mut scalar_rows = std::vec::Vec::new();
let mut simd_rows = std::vec::Vec::new();
scalar
.feed_row(y, &row, false, |oy, r| {
scalar_rows.push((oy, r.to_vec()));
})
.unwrap();
simd
.feed_row(y, &row, true, |oy, r| {
simd_rows.push((oy, r.to_vec()));
})
.unwrap();
assert_eq!(
scalar.h_tmp, simd.h_tmp,
"h_tmp diverged: src_w={src_w} out_w={out_w} c={channels} y={y}"
);
assert_eq!(
scalar.acc, simd.acc,
"acc diverged: src_w={src_w} out_w={out_w} c={channels} y={y}"
);
assert_eq!(
scalar_rows, simd_rows,
"emitted rows diverged: src_w={src_w} out_w={out_w} c={channels}"
);
}
}
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
fn lcg_fill_f32(buf: &mut [f32], seed: u32) {
let mut state = seed;
for v in buf {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
let int = ((state >> 8) & 0x3FFF) as f32;
let frac = (state & 0xFF) as f32 / 256.0;
*v = int + frac;
}
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
fn assert_close_rel_f64(a: &[f64], b: &[f64], rel: f64, ctx: &str) {
assert_eq!(a.len(), b.len(), "{ctx} length");
for (i, (&x, &y)) in a.iter().zip(b.iter()).enumerate() {
let tol = rel * x.abs().max(y.abs()) + 1e-6;
assert!((x - y).abs() <= tol, "{ctx}[{i}]: {x} vs {y} (rel {rel})");
}
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
#[test]
fn h_pass_f32_simd_matches_scalar_within_tolerance() {
let cases: &[(usize, usize, usize)] = if cfg!(miri) {
&[(64, 7, 1), (64, 7, 3), (12, 11, 3), (8, 3, 1), (5, 4, 3)]
} else {
&[
(1920, 336, 1),
(1920, 336, 3),
(640, 7, 1),
(640, 7, 3),
(4096, 8, 1),
(4096, 8, 3),
(4096, 4095, 1),
(4096, 4095, 3),
(5, 4, 3),
(8, 3, 1),
(256, 8, 1),
(256, 8, 3),
(264, 8, 1),
(264, 8, 3),
(336, 8, 1),
(336, 8, 3),
(400, 8, 1),
(400, 8, 3),
(120, 8, 1),
(160, 8, 3),
]
};
for &(src_w, out_w, channels) in cases {
let plan = AreaResampler::to(out_w, 1)
.plan(src_w, 2)
.expect("valid geometry")
.expect("strict downscale");
let mut scalar = AreaStream::<f32>::new(plan.h(), plan.v(), src_w, 2, channels).unwrap();
let mut simd = AreaStream::<f32>::new(plan.h(), plan.v(), src_w, 2, channels).unwrap();
let mut row = std::vec![0f32; src_w * channels];
for y in 0..2usize {
lcg_fill_f32(&mut row, (src_w * 31 + out_w * 7 + channels + y) as u32);
let mut scalar_rows = std::vec::Vec::new();
let mut simd_rows = std::vec::Vec::new();
scalar
.feed_row(y, &row, false, |oy, r| scalar_rows.push((oy, r.to_vec())))
.unwrap();
simd
.feed_row(y, &row, true, |oy, r| simd_rows.push((oy, r.to_vec())))
.unwrap();
assert_close_rel_f64(
&scalar.h_tmp,
&simd.h_tmp,
1e-9,
&std::format!("h_tmp src_w={src_w} out_w={out_w} c={channels} y={y}"),
);
assert_close_rel_f64(
&scalar.acc,
&simd.acc,
1e-9,
&std::format!("acc src_w={src_w} out_w={out_w} c={channels} y={y}"),
);
assert_eq!(scalar_rows.len(), simd_rows.len(), "emitted count");
for ((soy, srow), (doy, drow)) in scalar_rows.iter().zip(simd_rows.iter()) {
assert_eq!(soy, doy, "emitted index");
for (i, (&a, &b)) in srow.iter().zip(drow.iter()).enumerate() {
let tol = 1e-6 * a.abs().max(b.abs()) + 1e-3;
assert!(
(a - b).abs() <= tol,
"emitted row src_w={src_w} out_w={out_w} c={channels} [{i}]: {a} vs {b}"
);
}
}
}
}
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
#[test]
fn h_pass_f32_simd_matches_scalar_with_non_finite_padding() {
let cases: &[(usize, usize, usize)] =
&[(16, 8, 1), (16, 8, 3), (24, 8, 1), (24, 8, 3), (48, 8, 3)];
for &(src_w, out_w, channels) in cases {
let plan = AreaResampler::to(out_w, 1)
.plan(src_w, 2)
.expect("valid geometry")
.expect("strict downscale");
let mut scalar = AreaStream::<f32>::new(plan.h(), plan.v(), src_w, 2, channels).unwrap();
let mut simd = AreaStream::<f32>::new(plan.h(), plan.v(), src_w, 2, channels).unwrap();
let mut row = std::vec![0f32; src_w * channels];
for y in 0..2usize {
lcg_fill_f32(&mut row, (src_w * 17 + out_w * 5 + channels + y) as u32);
row[2 * channels] = f32::NAN;
row[5 * channels + (channels - 1)] = f32::INFINITY;
row[9 * channels] = f32::NEG_INFINITY;
let mut s_rows = std::vec::Vec::new();
let mut d_rows = std::vec::Vec::new();
scalar
.feed_row(y, &row, false, |oy, r| s_rows.push((oy, r.to_vec())))
.unwrap();
simd
.feed_row(y, &row, true, |oy, r| d_rows.push((oy, r.to_vec())))
.unwrap();
assert_eq!(s_rows.len(), d_rows.len(), "emitted count");
for ((_, srow), (_, drow)) in s_rows.iter().zip(d_rows.iter()) {
for (i, (&a, &b)) in srow.iter().zip(drow.iter()).enumerate() {
assert_eq!(
a.is_finite(),
b.is_finite(),
"finiteness mismatch src_w={src_w} out_w={out_w} c={channels} [{i}]: scalar {a} simd {b}"
);
if a.is_finite() {
let tol = 1e-6 * a.abs().max(b.abs()) + 1e-3;
assert!((a - b).abs() <= tol, "value [{i}]: {a} vs {b}");
} else {
assert_eq!(
a.is_nan(),
b.is_nan(),
"nan-vs-inf [{i}]: scalar {a} simd {b}"
);
}
}
}
}
}
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
mod filter_simd_parity {
use super::super::{
BlackmanSinc, CatmullRom, CubicBSpline, FilterKernel, FilterSample, FilterStream,
FilteredResampler, Lanczos3, Resampler, SpanKind, Triangle,
};
fn lcg(n: usize, seed: u32) -> std::vec::Vec<u8> {
let mut state = seed;
let mut out = std::vec![0u8; n];
for b in &mut out {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*b = (state >> 8) as u8;
}
out
}
#[allow(clippy::too_many_arguments)]
fn stream<S, K>(
kernel: K,
src: &[S],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
channels: usize,
use_simd: bool,
) -> std::vec::Vec<S>
where
S: FilterSample,
K: FilterKernel,
{
let plan = FilteredResampler::new(ow, oh, kernel)
.plan(sw, sh)
.expect("valid downscale")
.expect("non-identity");
assert_eq!(plan.kind(), SpanKind::Filter);
let fh = plan.filter_h().expect("h windows");
let fv = plan.filter_v().expect("v windows");
let mut s = FilterStream::<S>::new(fh, fv, sw, sh, channels).expect("geometry");
let mut out = std::vec![S::default(); ow * oh * channels];
for y in 0..sh {
let row = &src[y * sw * channels..(y + 1) * sw * channels];
s.feed_row(y, row, use_simd, |oy, fin| {
out[oy * ow * channels..(oy + 1) * ow * channels].copy_from_slice(fin);
})
.expect("rows in order");
}
out
}
fn geoms() -> &'static [(usize, usize, usize, usize)] {
if cfg!(miri) {
&[(16, 12, 5, 4), (12, 12, 4, 3)]
} else {
&[
(64, 48, 17, 13),
(200, 60, 41, 19),
(128, 96, 8, 7),
(96, 17, 31, 6),
(300, 200, 100, 67),
]
}
}
#[test]
fn u8_simd_matches_scalar_within_one_lsb() {
let mut worst = 0u8;
for &(sw, sh, ow, oh) in geoms() {
for ch in [1usize, 3] {
for (ki, kernel) in [0u8, 1, 2].into_iter().enumerate() {
let src = lcg(sw * sh * ch, (sw * 7 + sh * 3 + ow + ch + ki) as u32 + 1);
let (a, b) = match kernel {
0 => (
stream(Triangle, &src, sw, sh, ow, oh, ch, false),
stream(Triangle, &src, sw, sh, ow, oh, ch, true),
),
1 => (
stream(CatmullRom, &src, sw, sh, ow, oh, ch, false),
stream(CatmullRom, &src, sw, sh, ow, oh, ch, true),
),
_ => (
stream(Lanczos3, &src, sw, sh, ow, oh, ch, false),
stream(Lanczos3, &src, sw, sh, ow, oh, ch, true),
),
};
assert_eq!(a.len(), b.len());
for (i, (&s, &d)) in a.iter().zip(b.iter()).enumerate() {
let diff = s.abs_diff(d);
worst = worst.max(diff);
assert!(
diff <= 1,
"u8 k{kernel} {sw}x{sh}->{ow}x{oh} c{ch} [{i}]: scalar {s} simd {d}"
);
}
}
}
}
std::eprintln!("filter u8 SIMD-vs-scalar: max abs diff = {worst}");
}
#[test]
fn u16_simd_matches_scalar_within_one_lsb() {
let mut worst = 0u16;
for &(sw, sh, ow, oh) in geoms() {
for ch in [1usize, 3] {
for kernel in [0u8, 1, 2] {
let raw = lcg(sw * sh * ch, (sw * 5 + sh * 11 + ow + ch) as u32 + 7);
let src: std::vec::Vec<u16> = raw
.iter()
.map(|&v| (u16::from(v) << 8) | u16::from(v))
.collect();
let (a, b) = match kernel {
0 => (
stream(Triangle, &src, sw, sh, ow, oh, ch, false),
stream(Triangle, &src, sw, sh, ow, oh, ch, true),
),
1 => (
stream(CatmullRom, &src, sw, sh, ow, oh, ch, false),
stream(CatmullRom, &src, sw, sh, ow, oh, ch, true),
),
_ => (
stream(Lanczos3, &src, sw, sh, ow, oh, ch, false),
stream(Lanczos3, &src, sw, sh, ow, oh, ch, true),
),
};
for (i, (&s, &d)) in a.iter().zip(b.iter()).enumerate() {
let diff = s.abs_diff(d);
worst = worst.max(diff);
assert!(
diff <= 1,
"u16 k{kernel} {sw}x{sh}->{ow}x{oh} c{ch} [{i}]: scalar {s} simd {d}"
);
}
}
}
}
std::eprintln!("filter u16 SIMD-vs-scalar: max abs diff = {worst}");
}
#[test]
fn f32_simd_matches_scalar_within_tolerance() {
let mut worst = 0.0f32;
for &(sw, sh, ow, oh) in geoms() {
for ch in [1usize, 3] {
for kernel in [0u8, 1, 2] {
let src: std::vec::Vec<f32> = lcg(sw * sh * ch, (sw * 13 + sh * 5 + ow + ch) as u32 + 3)
.into_iter()
.map(|b| f32::from(b) + f32::from(b) / 256.0)
.collect();
let (a, b) = match kernel {
0 => (
stream(Triangle, &src, sw, sh, ow, oh, ch, false),
stream(Triangle, &src, sw, sh, ow, oh, ch, true),
),
1 => (
stream(CatmullRom, &src, sw, sh, ow, oh, ch, false),
stream(CatmullRom, &src, sw, sh, ow, oh, ch, true),
),
_ => (
stream(Lanczos3, &src, sw, sh, ow, oh, ch, false),
stream(Lanczos3, &src, sw, sh, ow, oh, ch, true),
),
};
for (i, (&s, &d)) in a.iter().zip(b.iter()).enumerate() {
let diff = (s - d).abs();
worst = worst.max(diff);
let tol = 1e-4 * s.abs().max(d.abs()) + 1e-2;
assert!(
diff <= tol,
"f32 k{kernel} {sw}x{sh}->{ow}x{oh} c{ch} [{i}]: scalar {s} simd {d}"
);
}
}
}
}
std::eprintln!("filter f32 SIMD-vs-scalar: max abs diff = {worst}");
}
#[test]
fn phase4_kernels_resample_end_to_end_simd_matches_scalar() {
for &(sw, sh, ow, oh) in geoms() {
for ch in [1usize, 3] {
let src_u8 = lcg(sw * sh * ch, (sw + sh + ow + ch) as u32 + 17);
for (a, b) in [
(
stream(BlackmanSinc, &src_u8, sw, sh, ow, oh, ch, false),
stream(BlackmanSinc, &src_u8, sw, sh, ow, oh, ch, true),
),
(
stream(CubicBSpline, &src_u8, sw, sh, ow, oh, ch, false),
stream(CubicBSpline, &src_u8, sw, sh, ow, oh, ch, true),
),
] {
assert_eq!(a.len(), ow * oh * ch);
for (&s, &d) in a.iter().zip(b.iter()) {
assert!(s.abs_diff(d) <= 1, "u8 {sw}x{sh}->{ow}x{oh}: {s} vs {d}");
}
}
let src_u16: std::vec::Vec<u16> = src_u8
.iter()
.map(|&v| (u16::from(v) << 8) | u16::from(v))
.collect();
for (a, b) in [
(
stream(BlackmanSinc, &src_u16, sw, sh, ow, oh, ch, false),
stream(BlackmanSinc, &src_u16, sw, sh, ow, oh, ch, true),
),
(
stream(CubicBSpline, &src_u16, sw, sh, ow, oh, ch, false),
stream(CubicBSpline, &src_u16, sw, sh, ow, oh, ch, true),
),
] {
for (&s, &d) in a.iter().zip(b.iter()) {
assert!(s.abs_diff(d) <= 1, "u16 {sw}x{sh}->{ow}x{oh}: {s} vs {d}");
}
}
let src_f32: std::vec::Vec<f32> = src_u8
.iter()
.map(|&v| f32::from(v) + f32::from(v) / 256.0)
.collect();
for (a, b) in [
(
stream(BlackmanSinc, &src_f32, sw, sh, ow, oh, ch, false),
stream(BlackmanSinc, &src_f32, sw, sh, ow, oh, ch, true),
),
(
stream(CubicBSpline, &src_f32, sw, sh, ow, oh, ch, false),
stream(CubicBSpline, &src_f32, sw, sh, ow, oh, ch, true),
),
] {
for (&s, &d) in a.iter().zip(b.iter()) {
let tol = 1e-4 * s.abs().max(d.abs()) + 1e-2;
assert!((s - d).abs() <= tol, "f32 {sw}x{sh}->{ow}x{oh}: {s} vs {d}");
}
}
}
}
}
}
#[cfg(any(
feature = "yuv-planar",
feature = "rgb",
feature = "gbr",
feature = "gray",
feature = "xyz",
feature = "bayer",
feature = "mono",
feature = "yuv-semi-planar",
feature = "yuv-packed",
feature = "yuv-444-packed",
feature = "y2xx",
feature = "v210",
feature = "rgb-legacy"
))]
mod pil_parity {
use super::super::{
CatmullRom, FilterKernel, FilterStream, FilteredResampler, Lanczos3, Resampler, SpanKind,
Triangle, pil_goldens,
};
fn lcg_bytes(n: usize, seed: u32) -> std::vec::Vec<u8> {
let mut state = seed;
let mut out = std::vec![0u8; n];
for b in &mut out {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*b = (state >> 8) as u8;
}
out
}
fn source_u8(sw: usize, sh: usize, channels: usize, seed: u32) -> std::vec::Vec<u8> {
lcg_bytes(sw * sh * channels, seed)
}
fn source_u16(sw: usize, sh: usize, seed: u32) -> std::vec::Vec<u16> {
let raw = lcg_bytes(sw * sh, seed);
let n = raw.len();
(0..n)
.map(|i| {
let v = u16::from(raw[i]);
let rolled = u16::from(raw[(i + n - 1) % n]);
(v << 8) | rolled
})
.collect()
}
fn source_f32(sw: usize, sh: usize, seed: u32) -> std::vec::Vec<f32> {
lcg_bytes(sw * sh, seed)
.into_iter()
.map(|b| b as f32 + b as f32 / 256.0)
.collect()
}
const MIRI_MAX_SRC_PX: usize = 1_500;
trait GoldenDims {
fn src_px(&self) -> usize;
}
impl<T: 'static> GoldenDims for (usize, usize, usize, usize, usize, u32, &'static [T]) {
fn src_px(&self) -> usize {
self.0 * self.1
}
}
fn miri_subset<G: GoldenDims>(all: &'static [G]) -> impl Iterator<Item = &'static G> {
all
.iter()
.filter(|g| !cfg!(miri) || g.src_px() <= MIRI_MAX_SRC_PX)
}
#[allow(clippy::too_many_arguments)]
fn run_with<S, K>(
kernel: K,
src: &[S],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
channels: usize,
use_simd: bool,
) -> std::vec::Vec<S>
where
S: super::super::FilterSample,
K: FilterKernel,
{
let plan = FilteredResampler::new(ow, oh, kernel)
.plan(sw, sh)
.expect("valid downscale")
.expect("non-identity");
assert_eq!(plan.kind(), SpanKind::Filter);
let fh = plan.filter_h().expect("filter plan carries h windows");
let fv = plan.filter_v().expect("filter plan carries v windows");
let mut stream = FilterStream::<S>::new(fh, fv, sw, sh, channels).expect("realistic geometry");
let mut out = std::vec![S::default(); ow * oh * channels];
for y in 0..sh {
let row = &src[y * sw * channels..(y + 1) * sw * channels];
stream
.feed_row(y, row, use_simd, |oy, finalized| {
out[oy * ow * channels..(oy + 1) * ow * channels].copy_from_slice(finalized);
})
.expect("rows in order");
}
out
}
fn run<S, K>(
kernel: K,
src: &[S],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
channels: usize,
) -> std::vec::Vec<S>
where
S: super::super::FilterSample,
K: FilterKernel,
{
run_with(kernel, src, sw, sh, ow, oh, channels, false)
}
fn assert_u_within(
ours: &[u8],
golden: &[u8],
tol: u8,
worst: &mut u8,
ctx: core::fmt::Arguments<'_>,
) {
assert_eq!(ours.len(), golden.len(), "{ctx} length");
for (i, (a, b)) in ours.iter().zip(golden.iter()).enumerate() {
let d = a.abs_diff(*b);
*worst = (*worst).max(d);
assert!(d <= tol, "{ctx} idx {i}: ours {a} vs pil {b}");
}
}
#[test]
fn filter_upscale_constant_stays_constant() {
for ch in [1usize, 3] {
let src = std::vec![123u8; 3 * 3 * ch];
for (name, out) in [
("Triangle", run(Triangle, &src, 3, 3, 7, 7, ch)),
("CatmullRom", run(CatmullRom, &src, 3, 3, 7, 7, ch)),
("Lanczos3", run(Lanczos3, &src, 3, 3, 7, 7, ch)),
] {
assert_eq!(out.len(), 7 * 7 * ch, "{name}: upscaled output length");
assert!(
out.iter().all(|&v| v == 123),
"{name}: constant {ch}-channel upscale must stay constant, got {out:?}"
);
}
}
}
#[test]
fn filter_upscale_plan_builds_filter_spans() {
let plan = FilteredResampler::new(16, 4, Triangle)
.plan(8, 8)
.expect("upscale width must plan")
.expect("non-identity");
assert_eq!(plan.kind(), SpanKind::Filter);
assert_eq!(plan.out_dims(), (16, 4));
}
const PIL_U8_TOL: u8 = 0;
#[test]
fn u8_matches_pil() {
let mut worst = 0u8;
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::TRIANGLE_U8) {
let src = source_u8(sw, sh, ch, seed);
let ours = run(Triangle, &src, sw, sh, ow, oh, ch);
assert_u_within(
&ours,
golden,
PIL_U8_TOL,
&mut worst,
std::format_args!("Triangle {sw}x{sh}->{ow}x{oh} c{ch}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::CATMULLROM_U8) {
let src = source_u8(sw, sh, ch, seed);
let ours = run(CatmullRom, &src, sw, sh, ow, oh, ch);
assert_u_within(
&ours,
golden,
PIL_U8_TOL,
&mut worst,
std::format_args!("CatmullRom {sw}x{sh}->{ow}x{oh} c{ch}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::LANCZOS3_U8) {
let src = source_u8(sw, sh, ch, seed);
let ours = run(Lanczos3, &src, sw, sh, ow, oh, ch);
assert_u_within(
&ours,
golden,
PIL_U8_TOL,
&mut worst,
std::format_args!("Lanczos3 {sw}x{sh}->{ow}x{oh} c{ch}"),
);
}
std::eprintln!("PIL u8 parity: max abs diff = {worst}");
}
fn assert_u16_within(
ours: &[u16],
golden: &[u16],
tol: u16,
worst: &mut u16,
ctx: core::fmt::Arguments<'_>,
) {
assert_eq!(ours.len(), golden.len(), "{ctx} length");
for (i, (a, b)) in ours.iter().zip(golden.iter()).enumerate() {
let d = a.abs_diff(*b);
*worst = (*worst).max(d);
assert!(d <= tol, "{ctx} idx {i}: ours {a} vs pil {b}");
}
}
#[test]
fn u16_matches_pil_within_one_lsb() {
let mut worst = 0u16;
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::TRIANGLE_U16) {
let src = source_u16(sw, sh, seed);
let ours = run(Triangle, &src, sw, sh, ow, oh, ch);
assert_u16_within(
&ours,
golden,
1,
&mut worst,
std::format_args!("Triangle {sw}x{sh}->{ow}x{oh}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::CATMULLROM_U16) {
let src = source_u16(sw, sh, seed);
let ours = run(CatmullRom, &src, sw, sh, ow, oh, ch);
assert_u16_within(
&ours,
golden,
1,
&mut worst,
std::format_args!("CatmullRom {sw}x{sh}->{ow}x{oh}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::LANCZOS3_U16) {
let src = source_u16(sw, sh, seed);
let ours = run(Lanczos3, &src, sw, sh, ow, oh, ch);
assert_u16_within(
&ours,
golden,
1,
&mut worst,
std::format_args!("Lanczos3 {sw}x{sh}->{ow}x{oh}"),
);
}
std::eprintln!("PIL u16 parity: max abs diff = {worst}");
}
fn assert_f32_within(
ours: &[f32],
golden: &[f32],
worst: &mut f32,
ctx: core::fmt::Arguments<'_>,
) {
assert_eq!(ours.len(), golden.len(), "{ctx} length");
for (i, (a, b)) in ours.iter().zip(golden.iter()).enumerate() {
let d = (a - b).abs();
*worst = worst.max(d);
let tol = 1e-3 * a.abs().max(b.abs()) + 1e-2;
assert!(d <= tol, "{ctx} idx {i}: ours {a} vs pil {b} (d {d})");
}
}
#[test]
fn f32_matches_pil_within_tolerance() {
let mut worst = 0.0f32;
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::TRIANGLE_F32) {
let src = source_f32(sw, sh, seed);
let ours = run(Triangle, &src, sw, sh, ow, oh, ch);
assert_f32_within(
&ours,
golden,
&mut worst,
std::format_args!("Triangle {sw}x{sh}->{ow}x{oh}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::CATMULLROM_F32) {
let src = source_f32(sw, sh, seed);
let ours = run(CatmullRom, &src, sw, sh, ow, oh, ch);
assert_f32_within(
&ours,
golden,
&mut worst,
std::format_args!("CatmullRom {sw}x{sh}->{ow}x{oh}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::LANCZOS3_F32) {
let src = source_f32(sw, sh, seed);
let ours = run(Lanczos3, &src, sw, sh, ow, oh, ch);
assert_f32_within(
&ours,
golden,
&mut worst,
std::format_args!("Lanczos3 {sw}x{sh}->{ow}x{oh}"),
);
}
std::eprintln!("PIL f32 parity: max abs diff = {worst}");
}
#[test]
fn u8_matches_pil_simd() {
let mut worst = 0u8;
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::TRIANGLE_U8) {
let src = source_u8(sw, sh, ch, seed);
let ours = run_with(Triangle, &src, sw, sh, ow, oh, ch, true);
assert_u_within(
&ours,
golden,
PIL_U8_TOL,
&mut worst,
std::format_args!("Triangle SIMD {sw}x{sh}->{ow}x{oh} c{ch}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::CATMULLROM_U8) {
let src = source_u8(sw, sh, ch, seed);
let ours = run_with(CatmullRom, &src, sw, sh, ow, oh, ch, true);
assert_u_within(
&ours,
golden,
PIL_U8_TOL,
&mut worst,
std::format_args!("CatmullRom SIMD {sw}x{sh}->{ow}x{oh} c{ch}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::LANCZOS3_U8) {
let src = source_u8(sw, sh, ch, seed);
let ours = run_with(Lanczos3, &src, sw, sh, ow, oh, ch, true);
assert_u_within(
&ours,
golden,
PIL_U8_TOL,
&mut worst,
std::format_args!("Lanczos3 SIMD {sw}x{sh}->{ow}x{oh} c{ch}"),
);
}
std::eprintln!("PIL u8 parity (SIMD): max abs diff = {worst}");
}
#[test]
fn u16_matches_pil_within_one_lsb_simd() {
let mut worst = 0u16;
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::TRIANGLE_U16) {
let src = source_u16(sw, sh, seed);
let ours = run_with(Triangle, &src, sw, sh, ow, oh, ch, true);
assert_u16_within(
&ours,
golden,
1,
&mut worst,
std::format_args!("Triangle SIMD {sw}x{sh}->{ow}x{oh}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::CATMULLROM_U16) {
let src = source_u16(sw, sh, seed);
let ours = run_with(CatmullRom, &src, sw, sh, ow, oh, ch, true);
assert_u16_within(
&ours,
golden,
1,
&mut worst,
std::format_args!("CatmullRom SIMD {sw}x{sh}->{ow}x{oh}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::LANCZOS3_U16) {
let src = source_u16(sw, sh, seed);
let ours = run_with(Lanczos3, &src, sw, sh, ow, oh, ch, true);
assert_u16_within(
&ours,
golden,
1,
&mut worst,
std::format_args!("Lanczos3 SIMD {sw}x{sh}->{ow}x{oh}"),
);
}
std::eprintln!("PIL u16 parity (SIMD): max abs diff = {worst}");
}
#[test]
fn f32_matches_pil_within_tolerance_simd() {
let mut worst = 0.0f32;
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::TRIANGLE_F32) {
let src = source_f32(sw, sh, seed);
let ours = run_with(Triangle, &src, sw, sh, ow, oh, ch, true);
assert_f32_within(
&ours,
golden,
&mut worst,
std::format_args!("Triangle SIMD {sw}x{sh}->{ow}x{oh}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::CATMULLROM_F32) {
let src = source_f32(sw, sh, seed);
let ours = run_with(CatmullRom, &src, sw, sh, ow, oh, ch, true);
assert_f32_within(
&ours,
golden,
&mut worst,
std::format_args!("CatmullRom SIMD {sw}x{sh}->{ow}x{oh}"),
);
}
for &(sw, sh, ow, oh, ch, seed, golden) in miri_subset(pil_goldens::LANCZOS3_F32) {
let src = source_f32(sw, sh, seed);
let ours = run_with(Lanczos3, &src, sw, sh, ow, oh, ch, true);
assert_f32_within(
&ours,
golden,
&mut worst,
std::format_args!("Lanczos3 SIMD {sw}x{sh}->{ow}x{oh}"),
);
}
std::eprintln!("PIL f32 parity (SIMD): max abs diff = {worst}");
}
}