#[cfg(all(test, feature = "std"))]
use super::*;
#[cfg(all(test, feature = "std"))]
pub(super) fn solid_v30x_frame(width: u32, height: u32, u: u32, y: u32, v: u32) -> Vec<u32> {
let word = (v << 22) | (y << 12) | (u << 2);
std::vec![word; (width as usize) * (height as usize)]
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_luma_only_extracts_y_bytes_downshifted() {
let buf = solid_v30x_frame(6, 8, 512, 256, 512);
let src = V30XFrame::new(&buf, 6, 8, 6);
let mut luma = std::vec![0u8; 6 * 8];
let mut sink = MixedSinker::<V30X>::new(6, 8).with_luma(&mut luma).unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert!(luma.iter().all(|&y| y == 64), "luma {luma:?}");
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_with_luma_u16_extracts_y_native_depth() {
let buf = solid_v30x_frame(6, 8, 512, 0x3FC, 512);
let src = V30XFrame::new(&buf, 6, 8, 6);
let mut luma = std::vec![0u16; 6 * 8];
let mut sink = MixedSinker::<V30X>::new(6, 8)
.with_luma_u16(&mut luma)
.unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert!(
luma.iter().all(|&y| y == 0x3FC),
"luma_u16 expected 0x3FC, got {:?}",
&luma[..8]
);
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_rgb_only_converts_gray_to_gray() {
let buf = solid_v30x_frame(12, 4, 512, 512, 512);
let src = V30XFrame::new(&buf, 12, 4, 12);
let mut rgb = std::vec![0u8; 12 * 4 * 3];
let mut sink = MixedSinker::<V30X>::new(12, 4).with_rgb(&mut rgb).unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for px in rgb.chunks(3) {
assert!(px[0].abs_diff(128) <= 4);
assert_eq!(px[0], px[1]);
assert_eq!(px[1], px[2]);
}
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_rgba_only_converts_gray_to_gray_with_opaque_alpha() {
let buf = solid_v30x_frame(12, 4, 512, 512, 512);
let src = V30XFrame::new(&buf, 12, 4, 12);
let mut rgba = std::vec![0u8; 12 * 4 * 4];
let mut sink = MixedSinker::<V30X>::new(12, 4)
.with_rgba(&mut rgba)
.unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for px in rgba.chunks(4) {
assert_eq!(px[3], 0xFF);
}
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_rgb_u16_only_converts_gray_to_gray_native_depth() {
let buf = solid_v30x_frame(12, 4, 512, 512, 512);
let src = V30XFrame::new(&buf, 12, 4, 12);
let mut rgb = std::vec![0u16; 12 * 4 * 3];
let mut sink = MixedSinker::<V30X>::new(12, 4)
.with_rgb_u16(&mut rgb)
.unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for px in rgb.chunks(3) {
assert!(px[0].abs_diff(512) <= 16, "expected ~512, got {}", px[0]);
}
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_rgba_u16_alpha_is_max() {
let buf = solid_v30x_frame(12, 4, 512, 512, 512);
let src = V30XFrame::new(&buf, 12, 4, 12);
let mut rgba = std::vec![0u16; 12 * 4 * 4];
let mut sink = MixedSinker::<V30X>::new(12, 4)
.with_rgba_u16(&mut rgba)
.unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for px in rgba.chunks(4) {
assert_eq!(px[3], 0x3FF);
}
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_hsv_only_produces_valid_hue_range() {
let buf = solid_v30x_frame(12, 4, 512, 512, 512);
let src = V30XFrame::new(&buf, 12, 4, 12);
let n = 12 * 4;
let mut h = std::vec![0u8; n];
let mut s = std::vec![0u8; n];
let mut v_plane = std::vec![0u8; n];
let mut sink = MixedSinker::<V30X>::new(12, 4)
.with_hsv(&mut h, &mut s, &mut v_plane)
.unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert!(h.iter().all(|&x| x == 0), "H {h:?}");
assert!(s.iter().all(|&x| x == 0), "S {s:?}");
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_with_rgb_and_with_rgba_byte_identical_u8() {
let w = 12u32;
let h = 4u32;
let buf = solid_v30x_frame(w, h, 200, 700, 400);
let src = V30XFrame::new(&buf, w, h, w);
let mut rgb = std::vec![0u8; (w * h) as usize * 3];
let mut rgba = std::vec![0u8; (w * h) as usize * 4];
let mut sink = MixedSinker::<V30X>::new(w as usize, h as usize)
.with_rgb(&mut rgb)
.unwrap()
.with_rgba(&mut rgba)
.unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for i in 0..(w * h) as usize {
assert_eq!(rgba[i * 4], rgb[i * 3]);
assert_eq!(rgba[i * 4 + 1], rgb[i * 3 + 1]);
assert_eq!(rgba[i * 4 + 2], rgb[i * 3 + 2]);
assert_eq!(rgba[i * 4 + 3], 0xFF);
}
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_with_rgb_u16_and_with_rgba_u16_byte_identical() {
let w = 12u32;
let h = 4u32;
let buf = solid_v30x_frame(w, h, 200, 700, 400);
let src = V30XFrame::new(&buf, w, h, w);
let mut rgb = std::vec![0u16; (w * h) as usize * 3];
let mut rgba = std::vec![0u16; (w * h) as usize * 4];
let mut sink = MixedSinker::<V30X>::new(w as usize, h as usize)
.with_rgb_u16(&mut rgb)
.unwrap()
.with_rgba_u16(&mut rgba)
.unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for i in 0..(w * h) as usize {
assert_eq!(rgba[i * 4], rgb[i * 3]);
assert_eq!(rgba[i * 4 + 1], rgb[i * 3 + 1]);
assert_eq!(rgba[i * 4 + 2], rgb[i * 3 + 2]);
assert_eq!(rgba[i * 4 + 3], 0x3FF);
}
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_with_simd_false_matches_with_simd_true() {
for w in [1usize, 2, 4, 7, 8, 15, 16, 17, 31, 32, 33, 1920, 1921] {
let h = 2usize;
let mut buf = std::vec![0u32; w * h];
let mut state = 0xC0FFEE_u32;
for word in &mut buf {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
let u = (state >> 2) & 0x3FF;
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
let y = (state >> 2) & 0x3FF;
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
let v = (state >> 2) & 0x3FF;
*word = (v << 22) | (y << 12) | (u << 2);
}
let src = V30XFrame::new(&buf, w as u32, h as u32, w as u32);
let mut rgb_simd = std::vec![0u8; w * h * 3];
let mut rgb_scalar = std::vec![0u8; w * h * 3];
let mut sink_simd = MixedSinker::<V30X>::new(w, h)
.with_rgb(&mut rgb_simd)
.unwrap();
let mut sink_scalar = MixedSinker::<V30X>::new(w, h)
.with_rgb(&mut rgb_scalar)
.unwrap()
.with_simd(false);
v30x_to(
&src,
false,
sink_simd.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
v30x_to(
&src,
false,
sink_scalar.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
assert_eq!(rgb_simd, rgb_scalar, "V30X SIMD≠scalar at width {w}");
}
}
#[cfg(feature = "yuv-planar")]
fn pack_yuv444p10_to_v30x(
y_plane: &[u16],
u_plane: &[u16],
v_plane: &[u16],
width: usize,
height: usize,
) -> Vec<u32> {
let mut packed = Vec::with_capacity(width * height);
for r in 0..height {
for c in 0..width {
let y = (y_plane[r * width + c] & 0x3FF) as u32;
let u = (u_plane[r * width + c] & 0x3FF) as u32;
let v = (v_plane[r * width + c] & 0x3FF) as u32;
packed.push((v << 22) | (y << 12) | (u << 2));
}
}
packed
}
#[test]
#[cfg(all(test, feature = "std", feature = "yuv-planar"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_planar_parity_with_yuv444p10() {
let width = 16usize;
let height = 4usize;
let mut yp = std::vec![0u16; width * height];
let mut up = std::vec![0u16; width * height];
let mut vp = std::vec![0u16; width * height];
pseudo_random_u16_low_n_bits(&mut yp, 0xC0FFEE, 10);
pseudo_random_u16_low_n_bits(&mut up, 0xBADF00D, 10);
pseudo_random_u16_low_n_bits(&mut vp, 0xFEEDFACE, 10);
let planar = Yuv444p10Frame::new(
&yp,
&up,
&vp,
width as u32,
height as u32,
width as u32,
width as u32,
width as u32,
);
let packed = pack_yuv444p10_to_v30x(&yp, &up, &vp, width, height);
let v30x = V30XFrame::new(&packed, width as u32, height as u32, width as u32);
let mut p_rgb = std::vec![0u8; width * height * 3];
let mut v_rgb = std::vec![0u8; width * height * 3];
let mut p_sink = MixedSinker::<Yuv444p10>::new(width, height)
.with_rgb(&mut p_rgb)
.unwrap();
let mut v_sink = MixedSinker::<V30X>::new(width, height)
.with_rgb(&mut v_rgb)
.unwrap();
yuv444p10_to(
&planar,
false,
p_sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
v30x_to(&v30x, false, v_sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
assert_eq!(p_rgb, v_rgb, "V30X ↔ Yuv444p10 u8 RGB diverges");
let mut p_rgb_u16 = std::vec![0u16; width * height * 3];
let mut v_rgb_u16 = std::vec![0u16; width * height * 3];
let mut p_sink2 = MixedSinker::<Yuv444p10>::new(width, height)
.with_rgb_u16(&mut p_rgb_u16)
.unwrap();
let mut v_sink2 = MixedSinker::<V30X>::new(width, height)
.with_rgb_u16(&mut v_rgb_u16)
.unwrap();
yuv444p10_to(
&planar,
false,
p_sink2.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
v30x_to(&v30x, false, v_sink2.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
assert_eq!(p_rgb_u16, v_rgb_u16, "V30X ↔ Yuv444p10 u16 RGB diverges");
}
#[test]
#[cfg(all(test, feature = "std"))]
fn v30x_rgba_u16_buffer_too_short_returns_err() {
let mut rgba = std::vec![0u16; 6 * 7 * 4];
let result = MixedSinker::<V30X>::new(6, 8).with_rgba_u16(&mut rgba);
let Err(err) = result else {
panic!("expected InsufficientRgbaU16Buffer");
};
assert_eq!(
err,
MixedSinkerError::InsufficientRgbaU16Buffer(InsufficientBuffer::new(192, 168))
);
}
#[cfg(all(test, feature = "std"))]
fn pseudo_random_v30x(n: usize, seed: u32) -> Vec<u32> {
let mut buf = std::vec![0u32; n];
let mut state = seed;
for word in &mut buf {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
let u = (state >> 2) & 0x3FF;
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
let y = (state >> 2) & 0x3FF;
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
let v = (state >> 2) & 0x3FF;
*word = (v << 22) | (y << 12) | (u << 2);
}
buf
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_hsv_row_matches_rgb_then_hsv() {
use crate::row::{rgb_to_hsv_row, v30x_to_hsv_row, v30x_to_rgb_row};
for &w in &[1usize, 2, 4, 7, 8, 15, 16, 17, 31, 64, 65] {
let buf = pseudo_random_v30x(w, 0x2468_ACE0);
for &matrix in &[
KernelMatrix::Bt601,
KernelMatrix::Bt709,
KernelMatrix::Bt2020Ncl,
] {
for &full in &[true, false] {
for &use_simd in &[false, true] {
let mut rgb = std::vec![0u8; w * 3];
v30x_to_rgb_row(&buf, &mut rgb, w, matrix, full, use_simd);
let mut rh = std::vec![0u8; w];
let mut rs = std::vec![0u8; w];
let mut rv = std::vec![0u8; w];
rgb_to_hsv_row(&rgb, &mut rh, &mut rs, &mut rv, w, use_simd);
let mut h = std::vec![0u8; w];
let mut s = std::vec![0u8; w];
let mut v = std::vec![0u8; w];
v30x_to_hsv_row(&buf, &mut h, &mut s, &mut v, w, matrix, full, use_simd);
assert_eq!(
(h, s, v),
(rh, rs, rv),
"v30x HSV≠RGB→HSV (w={w} {matrix:?} full={full} simd={use_simd})"
);
}
}
}
}
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_hsv_only_is_rgb_free_and_matches_reference() {
use crate::row::{rgb_to_hsv_row, v30x_to_rgb_row};
let (w, h) = (16usize, 8usize);
let buf = pseudo_random_v30x(w * h, 0x1357_9BDF);
let src = V30XFrame::new(&buf, w as u32, h as u32, w as u32);
let mut hh = std::vec![0u8; w * h];
let mut ss = std::vec![0u8; w * h];
let mut vv = std::vec![0u8; w * h];
let scratch_len = {
let mut sink = MixedSinker::<V30X>::new(w, h)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
v30x_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
sink.rgb_scratch.len()
};
assert_eq!(
scratch_len, 0,
"V30X HSV-only must not grow the RGB scratch"
);
let mut rgb0 = std::vec![0u8; w * 3];
v30x_to_rgb_row(&buf[..w], &mut rgb0, w, KernelMatrix::Bt709, true, true);
let mut rh = std::vec![0u8; w];
let mut rs = std::vec![0u8; w];
let mut rv = std::vec![0u8; w];
rgb_to_hsv_row(&rgb0, &mut rh, &mut rs, &mut rv, w, true);
assert_eq!(&hh[..w], &rh[..], "row 0 H");
assert_eq!(&ss[..w], &rs[..], "row 0 S");
assert_eq!(&vv[..w], &rv[..], "row 0 V");
}
#[cfg(feature = "yuva")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v30x_rgb_scratch_alloc_failure_leaves_outputs_untouched() {
use crate::resample::ResampleError;
let buf = solid_v30x_frame(16, 8, 512, 512, 512);
let src = V30XFrame::new(&buf, 16, 8, 16);
let mut luma = std::vec![0xABu8; 16 * 8];
let mut luma_u16 = std::vec![0xABCDu16; 16 * 8];
let mut rgba = std::vec![0xCDu8; 16 * 8 * 4];
let (mut hh, mut ss, mut vv) = (
std::vec![0xCDu8; 16 * 8],
std::vec![0xCDu8; 16 * 8],
std::vec![0xCDu8; 16 * 8],
);
let mut sink = MixedSinker::<V30X>::new(16, 8)
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma_u16)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
super::super::arm_rgb_scratch_alloc_failure();
let err = v30x_to(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap_err();
drop(sink);
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"RGB-scratch refusal must surface as a recoverable AllocationFailed, got {err:?}"
);
assert!(
luma.iter().all(|&b| b == 0xAB),
"luma must be untouched on the rgb-scratch alloc-failure path"
);
assert!(
luma_u16.iter().all(|&b| b == 0xABCD),
"luma_u16 must be untouched on the rgb-scratch alloc-failure path"
);
}