use super::*;
pub(super) fn solid_v210_frame(width: u32, height: u32, y: u16, u: u16, v: u16) -> Vec<u8> {
let words_per_row = width.div_ceil(6) as usize;
let mut buf = std::vec![0u8; words_per_row * 16 * height as usize];
let samples: [u16; 12] = [u, y, v, y, u, y, v, y, u, y, v, y];
let word = pack_v210_word_for_test(samples);
for row in 0..height as usize {
for w in 0..words_per_row {
let off = (row * words_per_row + w) * 16;
buf[off..off + 16].copy_from_slice(&word);
}
}
buf
}
fn pack_v210_word_for_test(samples: [u16; 12]) -> [u8; 16] {
let mut out = [0u8; 16];
let pack = |a: u16, b: u16, c: u16| -> u32 {
(a as u32 & 0x3FF) | ((b as u32 & 0x3FF) << 10) | ((c as u32 & 0x3FF) << 20)
};
out[0..4].copy_from_slice(&pack(samples[0], samples[1], samples[2]).to_le_bytes());
out[4..8].copy_from_slice(&pack(samples[3], samples[4], samples[5]).to_le_bytes());
out[8..12].copy_from_slice(&pack(samples[6], samples[7], samples[8]).to_le_bytes());
out[12..16].copy_from_slice(&pack(samples[9], samples[10], samples[11]).to_le_bytes());
out
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_luma_only_extracts_y_bytes() {
let buf = solid_v210_frame(6, 8, 200, 512, 512); let src = V210Frame::new(&buf, 6, 8, 16);
let mut luma = std::vec![0u8; 6 * 8];
let mut sink = MixedSinker::<V210>::new(6, 8).with_luma(&mut luma).unwrap();
v210_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert!(luma.iter().all(|&y| y == 50), "luma {luma:?}");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_luma_u16_only_extracts_y_native_depth() {
let buf = solid_v210_frame(6, 8, 200, 512, 512);
let src = V210Frame::new(&buf, 6, 8, 16);
let mut luma = std::vec![0u16; 6 * 8];
let mut sink = MixedSinker::<V210>::new(6, 8)
.with_luma_u16(&mut luma)
.unwrap();
v210_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert!(luma.iter().all(|&y| y == 200), "luma_u16 {:?}", &luma[..16]);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_rgb_only_converts_gray_to_gray() {
let buf = solid_v210_frame(12, 4, 512, 512, 512);
let src = V210Frame::new(&buf, 12, 4, 32);
let mut rgb = std::vec![0u8; 12 * 4 * 3];
let mut sink = MixedSinker::<V210>::new(12, 4).with_rgb(&mut rgb).unwrap();
v210_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for px in rgb.chunks(3) {
assert!(px[0].abs_diff(128) <= 1);
assert_eq!(px[0], px[1]);
assert_eq!(px[1], px[2]);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_rgba_only_converts_gray_to_gray_with_opaque_alpha() {
let buf = solid_v210_frame(12, 4, 512, 512, 512);
let src = V210Frame::new(&buf, 12, 4, 32);
let mut rgba = std::vec![0u8; 12 * 4 * 4];
let mut sink = MixedSinker::<V210>::new(12, 4)
.with_rgba(&mut rgba)
.unwrap();
v210_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for px in rgba.chunks(4) {
assert_eq!(px[3], 0xFF);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_rgb_u16_only_converts_gray_to_gray_native_depth() {
let buf = solid_v210_frame(12, 4, 512, 512, 512);
let src = V210Frame::new(&buf, 12, 4, 32);
let mut rgb = std::vec![0u16; 12 * 4 * 3];
let mut sink = MixedSinker::<V210>::new(12, 4)
.with_rgb_u16(&mut rgb)
.unwrap();
v210_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for px in rgb.chunks(3) {
assert!(px[0].abs_diff(512) <= 2, "expected ~512, got {}", px[0]);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_rgba_u16_alpha_is_max() {
let buf = solid_v210_frame(12, 4, 512, 512, 512);
let src = V210Frame::new(&buf, 12, 4, 32);
let mut rgba = std::vec![0u16; 12 * 4 * 4];
let mut sink = MixedSinker::<V210>::new(12, 4)
.with_rgba_u16(&mut rgba)
.unwrap();
v210_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
for px in rgba.chunks(4) {
assert_eq!(px[3], 1023);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_with_rgb_and_with_rgba_byte_identical_u8() {
let w = 12u32;
let h = 4u32;
let buf = solid_v210_frame(w, h, 700, 400, 600);
let src = V210Frame::new(&buf, w, h, (w / 6) * 16);
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::<V210>::new(w as usize, h as usize)
.with_rgb(&mut rgb)
.unwrap()
.with_rgba(&mut rgba)
.unwrap();
v210_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_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_with_rgb_u16_and_with_rgba_u16_byte_identical() {
let w = 12u32;
let h = 4u32;
let buf = solid_v210_frame(w, h, 700, 400, 600);
let src = V210Frame::new(&buf, w, h, (w / 6) * 16);
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::<V210>::new(w as usize, h as usize)
.with_rgb_u16(&mut rgb)
.unwrap()
.with_rgba_u16(&mut rgba)
.unwrap();
v210_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], 1023);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_with_simd_false_matches_with_simd_true() {
for w in [
2usize, 4, 6, 8, 10, 12, 14, 18, 24, 30, 1280, 1920, 1922, 1926,
] {
let h = 2usize;
let mut buf = std::vec![0u8; w.div_ceil(6) * 16 * h];
pseudo_random_u8(&mut buf, 0xC0FFEE);
for i in (0..buf.len()).step_by(4) {
buf[i + 3] &= 0x3F;
}
let src = V210Frame::new(&buf, w as u32, h as u32, (w.div_ceil(6) * 16) 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::<V210>::new(w, h)
.with_rgb(&mut rgb_simd)
.unwrap();
let mut sink_scalar = MixedSinker::<V210>::new(w, h)
.with_rgb(&mut rgb_scalar)
.unwrap()
.with_simd(false);
v210_to(
&src,
false,
sink_simd.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
v210_to(
&src,
false,
sink_scalar.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
assert_eq!(rgb_simd, rgb_scalar, "V210 SIMD≠scalar at width {w}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_partial_word_width_works_end_to_end() {
let buf = solid_v210_frame(1280, 1, 512, 512, 512);
let stride = 1280u32.div_ceil(6) * 16;
let src = V210Frame::new(&buf, 1280, 1, stride);
let mut rgb = std::vec![0u8; 1280 * 3];
let mut sink = MixedSinker::<V210>::new(1280, 1)
.with_rgb(&mut rgb)
.unwrap();
v210_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
for px in rgb.chunks(3) {
assert!(
px[0].abs_diff(128) <= 1,
"partial-word RGB diverged: {px:?}"
);
assert_eq!(px[0], px[1]);
assert_eq!(px[1], px[2]);
}
}
#[test]
fn v210_luma_u16_buffer_too_short_returns_err() {
let mut luma = std::vec![0u16; 6 * 7];
let result = MixedSinker::<V210>::new(6, 8).with_luma_u16(&mut luma);
let Err(err) = result else {
panic!("expected InsufficientLumaU16Buffer");
};
assert_eq!(
err,
MixedSinkerError::InsufficientLumaU16Buffer(InsufficientBuffer::new(48, 42))
);
}
#[cfg(any(feature = "yuv-planar", feature = "y2xx"))]
pub(super) fn pack_yuv422p10_to_v210(
y: &[u16],
u: &[u16],
v: &[u16],
width: usize,
height: usize,
) -> Vec<u8> {
let cw = width / 2;
let words_per_row = width / 6;
let mut out = std::vec![0u8; words_per_row * 16 * height];
for row in 0..height {
for w in 0..words_per_row {
let px = w * 6;
let cu = px / 2;
let samples: [u16; 12] = [
u[row * cw + cu],
y[row * width + px],
v[row * cw + cu],
y[row * width + px + 1],
u[row * cw + cu + 1],
y[row * width + px + 2],
v[row * cw + cu + 1],
y[row * width + px + 3],
u[row * cw + cu + 2],
y[row * width + px + 4],
v[row * cw + cu + 2],
y[row * width + px + 5],
];
let bytes = pack_v210_word_for_test(samples);
let off = (row * words_per_row + w) * 16;
out[off..off + 16].copy_from_slice(&bytes);
}
}
out
}
#[cfg(feature = "yuv-planar")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_reconstructed_from_yuv422p10_matches_yuv422p10_to_rgb() {
let w = 12usize;
let h = 4usize;
let mut y_plane = std::vec![0u16; w * h];
let mut u_plane = std::vec![0u16; (w / 2) * h];
let mut v_plane = std::vec![0u16; (w / 2) * h];
pseudo_random_u16_low_n_bits(&mut y_plane, 0xC0FFEE, 10);
pseudo_random_u16_low_n_bits(&mut u_plane, 0xBADF00D, 10);
pseudo_random_u16_low_n_bits(&mut v_plane, 0xFEEDFACE, 10);
let planar = Yuv422p10Frame::new(
&y_plane,
&u_plane,
&v_plane,
w as u32,
h as u32,
w as u32,
(w / 2) as u32,
(w / 2) as u32,
);
let packed = pack_yuv422p10_to_v210(&y_plane, &u_plane, &v_plane, w, h);
let v210 = V210Frame::new(&packed, w as u32, h as u32, ((w / 6) * 16) as u32);
let mut rgb_planar = std::vec![0u8; w * h * 3];
let mut rgb_packed = std::vec![0u8; w * h * 3];
let mut s_planar = MixedSinker::<Yuv422p10>::new(w, h)
.with_rgb(&mut rgb_planar)
.unwrap();
let mut s_packed = MixedSinker::<V210>::new(w, h)
.with_rgb(&mut rgb_packed)
.unwrap();
yuv422p10_to(
&planar,
false,
s_planar.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
v210_to(
&v210,
false,
s_packed.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
assert_eq!(rgb_planar, rgb_packed);
}
fn v210_as_be(plane_le: &[u8]) -> Vec<u8> {
assert_eq!(
plane_le.len() % 4,
0,
"v210 plane length must be word-aligned"
);
let mut out = Vec::with_capacity(plane_le.len());
for chunk in plane_le.chunks_exact(4) {
let w = u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
out.extend_from_slice(&w.to_be_bytes());
}
out
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_le_be_roundtrip_byte_identical() {
let intended = solid_v210_frame(12, 4, 600, 400, 700);
let pix_le = intended.clone();
let pix_be = v210_as_be(&intended);
let stride: u32 = 32;
let frame_le = V210LeFrame::try_new(&pix_le, 12, 4, stride).unwrap();
let mut out_le_rgba = std::vec![0u8; 12 * 4 * 4];
let mut out_le_luma_u16 = std::vec![0u16; 12 * 4];
let mut sink_le = MixedSinker::<V210>::new(12, 4)
.with_simd(false)
.with_rgba(&mut out_le_rgba)
.unwrap()
.with_luma_u16(&mut out_le_luma_u16)
.unwrap();
v210_to(
&frame_le,
true,
sink_le.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
let frame_be = V210BeFrame::try_new(&pix_be, 12, 4, stride).unwrap();
let mut out_be_rgba = std::vec![0u8; 12 * 4 * 4];
let mut out_be_luma_u16 = std::vec![0u16; 12 * 4];
let mut sink_be = MixedSinker::<V210<true>>::new(12, 4)
.with_simd(false)
.with_rgba(&mut out_be_rgba)
.unwrap()
.with_luma_u16(&mut out_be_luma_u16)
.unwrap();
v210_to_endian(
&frame_be,
true,
sink_be.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
assert_eq!(
out_le_rgba, out_be_rgba,
"V210 RGBA u8 LE/BE outputs diverge — `<const BE>` propagation broken"
);
assert_eq!(
out_le_luma_u16, out_be_luma_u16,
"V210 luma u16 LE/BE outputs diverge — `<const BE>` propagation broken"
);
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_hsv_row_matches_rgb_then_hsv() {
use crate::row::{rgb_to_hsv_row, v210_to_hsv_row_endian, v210_to_rgb_row_endian};
for &w in &[2usize, 4, 6, 8, 10, 12, 14, 60, 62, 66] {
let mut buf = std::vec![0u8; w.div_ceil(6) * 16];
pseudo_random_u8(&mut buf, 0x51A7_F00D);
for &matrix in &[
KernelMatrix::Bt601,
KernelMatrix::Bt709,
KernelMatrix::Bt2020Ncl,
] {
for &full in &[true, false] {
for &use_simd in &[false, true] {
for &be in &[false, true] {
let mut rgb = std::vec![0u8; w * 3];
v210_to_rgb_row_endian(&buf, &mut rgb, w, matrix, full, use_simd, be);
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];
v210_to_hsv_row_endian(&buf, &mut h, &mut s, &mut v, w, matrix, full, use_simd, be);
assert_eq!(
(h, s, v),
(rh, rs, rv),
"v210 HSV≠RGB→HSV (w={w} {matrix:?} full={full} simd={use_simd} be={be})"
);
}
}
}
}
}
}
#[test]
#[cfg(all(test, feature = "std"))]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn v210_hsv_only_is_rgb_free_and_matches_reference() {
use crate::row::{rgb_to_hsv_row, v210_to_rgb_row};
let (w, h) = (16usize, 8usize);
let stride = w.div_ceil(6) * 16;
let mut buf = std::vec![0u8; stride * h];
pseudo_random_u8(&mut buf, 0xBEEF_2210);
let src = V210Frame::new(&buf, w as u32, h as u32, stride 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::<V210>::new(w, h)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
v210_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
sink.rgb_scratch.len()
};
assert_eq!(
scratch_len, 0,
"V210 HSV-only must not grow the RGB scratch"
);
let mut rgb0 = std::vec![0u8; w * 3];
v210_to_rgb_row(
&buf[..stride],
&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 v210_rgb_scratch_alloc_failure_leaves_outputs_untouched() {
use crate::resample::ResampleError;
let buf = solid_v210_frame(16, 8, 512, 512, 512);
let src = V210Frame::new(&buf, 16, 8, 48);
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::<V210>::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 = v210_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"
);
}