use super::*;
use crate::{
Walker,
frame::Nv20Frame,
row::{nv20_to_hsv_row_endian, nv20_to_rgb_row_endian, rgb_to_hsv_row},
source::{Nv20, P210, nv20_to, nv20_to_endian, p210_to},
walker::YuvOptions,
};
fn nv20_solid(
width: u32,
height: u32,
y_value: u16,
u_value: u16,
v_value: u16,
be: bool,
) -> (Vec<u16>, Vec<u16>) {
let w = width as usize;
let h = height as usize;
let cw = w / 2;
let enc = |v: u16| -> u16 {
let logical = v & 0x03FF;
if be {
u16::from_ne_bytes(logical.to_be_bytes())
} else {
u16::from_ne_bytes(logical.to_le_bytes())
}
};
let y = std::vec![enc(y_value); w * h];
let uv: Vec<u16> = (0..cw * h)
.flat_map(|_| [enc(u_value), enc(v_value)])
.collect();
(y, uv)
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn nv20_gray_to_gray_real_low_bits() {
let (yp, uvp) = nv20_solid(16, 8, 512, 512, 512, false);
assert_eq!(yp[0], 0x0200, "low-bit-packed Y word must be 0x0200, not 0");
let src = Nv20Frame::new(&yp, &uvp, 16, 8, 16, 16);
let mut rgb = std::vec![0u8; 16 * 8 * 3];
let mut sink = MixedSinker::<Nv20>::new(16, 8).with_rgb(&mut rgb).unwrap();
nv20_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
for px in rgb.chunks(3) {
assert!(px[0].abs_diff(128) <= 1, "got {px:?}");
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 nv20_low_bit_decodes_same_as_p210_with_equal_logical_sample() {
let w = 64u32;
let h = 4u32;
let (yl, ul, vl) = (650u16, 300u16, 720u16);
let (nv_y, nv_uv) = nv20_solid(w, h, yl, ul, vl, false);
let nv_src = Nv20Frame::new(&nv_y, &nv_uv, w, h, w, w);
let cw = (w / 2) as usize;
let p_y = std::vec![yl << 6; (w * h) as usize];
let p_uv: Vec<u16> = (0..cw * h as usize)
.flat_map(|_| [ul << 6, vl << 6])
.collect();
let p_src = crate::frame::P210Frame::new(&p_y, &p_uv, w, h, w, w);
for &(fr, m) in &[
(true, KernelMatrix::Bt709),
(false, KernelMatrix::Bt709),
(true, KernelMatrix::Bt601),
(false, KernelMatrix::Bt601),
] {
let mut nv_rgb = std::vec![0u8; (w * h * 3) as usize];
let mut nv_sink = MixedSinker::<Nv20>::new(w as usize, h as usize)
.with_rgb(&mut nv_rgb)
.unwrap();
nv20_to(&nv_src, fr, nv_sink.set_kernel_matrix(m)).unwrap();
let mut p_rgb = std::vec![0u8; (w * h * 3) as usize];
let mut p_sink = MixedSinker::<P210>::new(w as usize, h as usize)
.with_rgb(&mut p_rgb)
.unwrap();
p210_to(&p_src, fr, p_sink.set_kernel_matrix(m)).unwrap();
assert_eq!(
nv_rgb, p_rgb,
"NV20(low-packed L) must decode == P210(high-packed L) for fr={fr} {m:?}"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn nv20_and_p210_disagree_on_identical_wire_bytes() {
let w = 16u32;
let h = 4u32;
let word = 0x1234u16;
let cw = (w / 2) as usize;
let y = std::vec![word; (w * h) as usize];
let uv: Vec<u16> = (0..cw * h as usize).flat_map(|_| [word, word]).collect();
let nv_src = Nv20Frame::new(&y, &uv, w, h, w, w);
let p_src = crate::frame::P210Frame::new(&y, &uv, w, h, w, w);
let mut nv_rgb = std::vec![0u8; (w * h * 3) as usize];
let mut nv_sink = MixedSinker::<Nv20>::new(w as usize, h as usize)
.with_rgb(&mut nv_rgb)
.unwrap();
nv20_to(
&nv_src,
true,
nv_sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
let mut p_rgb = std::vec![0u8; (w * h * 3) as usize];
let mut p_sink = MixedSinker::<P210>::new(w as usize, h as usize)
.with_rgb(&mut p_rgb)
.unwrap();
p210_to(&p_src, true, p_sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
assert_ne!(
nv_rgb, p_rgb,
"NV20 (low de-pack) and P210 (high de-pack) must differ on identical wire bytes"
);
}
fn nv20_random<const BE: bool>(w: u32, h: u32, seed: u32) -> (Vec<u16>, Vec<u16>) {
let mut yp = std::vec![0u16; (w * h) as usize];
let mut uvp = std::vec![0u16; (w * h) as usize];
let mut state = seed;
let enc = |logical: u16| -> u16 {
if BE {
u16::from_ne_bytes(logical.to_be_bytes())
} else {
u16::from_ne_bytes(logical.to_le_bytes())
}
};
for s in yp.iter_mut().chain(uvp.iter_mut()) {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*s = enc((state >> 13) as u16 & 0x03FF);
}
(yp, uvp)
}
#[allow(clippy::type_complexity)]
fn nv20_run_all<const BE: bool>(
yp: &[u16],
uvp: &[u16],
w: u32,
h: u32,
matrix: KernelMatrix,
full_range: bool,
simd: bool,
) -> (
Vec<u8>,
Vec<u16>,
Vec<u8>,
Vec<u16>,
Vec<u8>,
(Vec<u8>, Vec<u8>, Vec<u8>),
) {
let wz = w as usize;
let hz = h as usize;
let src = Nv20Frame::<BE>::new(yp, uvp, w, h, w, w);
let mut rgb = std::vec![0u8; wz * hz * 3];
let mut rgb_u16 = std::vec![0u16; wz * hz * 3];
let mut rgba = std::vec![0u8; wz * hz * 4];
let mut rgba_u16 = std::vec![0u16; wz * hz * 4];
let mut luma = std::vec![0u8; wz * hz];
let mut hh = std::vec![0u8; wz * hz];
let mut ss = std::vec![0u8; wz * hz];
let mut vv = std::vec![0u8; wz * hz];
{
let mut sink = MixedSinker::<Nv20<BE>>::new(wz, hz)
.with_rgb(&mut rgb)
.unwrap()
.with_rgb_u16(&mut rgb_u16)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
sink.set_simd(simd);
nv20_to_endian::<_, BE>(&src, full_range, sink.set_kernel_matrix(matrix)).unwrap();
}
{
let mut sink = MixedSinker::<Nv20<BE>>::new(wz, hz)
.with_rgba(&mut rgba)
.unwrap();
sink.set_simd(simd);
nv20_to_endian::<_, BE>(&src, full_range, sink.set_kernel_matrix(matrix)).unwrap();
}
{
let mut sink = MixedSinker::<Nv20<BE>>::new(wz, hz)
.with_rgba_u16(&mut rgba_u16)
.unwrap();
sink.set_simd(simd);
nv20_to_endian::<_, BE>(&src, full_range, sink.set_kernel_matrix(matrix)).unwrap();
}
(rgb, rgb_u16, rgba, rgba_u16, luma, (hh, ss, vv))
}
fn nv20_assert_simd_eq_scalar<const BE: bool>(w: u32, h: u32, matrix: KernelMatrix, fr: bool) {
let (yp, uvp) = nv20_random::<BE>(w, h, 0x9E37_79B9 ^ ((BE as u32) << 16) ^ (fr as u32));
let simd = nv20_run_all::<BE>(&yp, &uvp, w, h, matrix, fr, true);
let scal = nv20_run_all::<BE>(&yp, &uvp, w, h, matrix, fr, false);
assert_eq!(
simd.0, scal.0,
"rgb SIMD != scalar (BE={BE} fr={fr} {matrix:?})"
);
assert_eq!(simd.1, scal.1, "rgb_u16 SIMD != scalar (BE={BE} fr={fr})");
assert_eq!(simd.2, scal.2, "rgba SIMD != scalar (BE={BE} fr={fr})");
assert_eq!(simd.3, scal.3, "rgba_u16 SIMD != scalar (BE={BE} fr={fr})");
assert_eq!(simd.4, scal.4, "luma SIMD != scalar (BE={BE} fr={fr})");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn nv20_simd_matches_scalar_all_outputs() {
let (w, h) = (1922u32, 3u32);
for &(fr, m) in &[
(true, KernelMatrix::Bt709),
(false, KernelMatrix::Bt709),
(true, KernelMatrix::Bt601),
(false, KernelMatrix::Bt601),
] {
nv20_assert_simd_eq_scalar::<false>(w, h, m, fr);
nv20_assert_simd_eq_scalar::<true>(w, h, m, fr);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn nv20_hsv_within_tier_equals_rgb_then_hsv() {
let (w, h) = (66u32, 3u32);
fn check<const BE: bool>(w: u32, h: u32, m: KernelMatrix, fr: bool, use_simd: bool) {
let (yp, uvp) = nv20_random::<BE>(w, h, 0x0BAD_F00D ^ (use_simd as u32));
let wz = w as usize;
let hz = h as usize;
let src = Nv20Frame::<BE>::new(&yp, &uvp, w, h, w, w);
let mut sh = std::vec![0u8; wz * hz];
let mut ss = std::vec![0u8; wz * hz];
let mut sv = std::vec![0u8; wz * hz];
{
let mut sink = MixedSinker::<Nv20<BE>>::new(wz, hz)
.with_hsv(&mut sh, &mut ss, &mut sv)
.unwrap();
sink.set_simd(use_simd);
nv20_to_endian::<_, BE>(&src, fr, sink.set_kernel_matrix(m)).unwrap();
}
let mut dh = std::vec![0u8; wz * hz];
let mut ds = std::vec![0u8; wz * hz];
let mut dv = std::vec![0u8; wz * hz];
let mut rh = std::vec![0u8; wz * hz];
let mut rs = std::vec![0u8; wz * hz];
let mut rv = std::vec![0u8; wz * hz];
for r in 0..hz {
let yr = &yp[r * wz..r * wz + wz];
let uvr = &uvp[r * wz..r * wz + wz];
nv20_to_hsv_row_endian(
yr,
uvr,
&mut dh[r * wz..r * wz + wz],
&mut ds[r * wz..r * wz + wz],
&mut dv[r * wz..r * wz + wz],
wz,
m,
fr,
use_simd,
BE,
);
let mut rgb = std::vec![0u8; wz * 3];
nv20_to_rgb_row_endian(yr, uvr, &mut rgb, wz, m, fr, use_simd, BE);
rgb_to_hsv_row(
&rgb,
&mut rh[r * wz..r * wz + wz],
&mut rs[r * wz..r * wz + wz],
&mut rv[r * wz..r * wz + wz],
wz,
use_simd,
);
}
assert_eq!(
sh, dh,
"sink H != direct H (BE={BE} simd={use_simd} fr={fr} {m:?})"
);
assert_eq!(ss, ds, "sink S != direct S");
assert_eq!(sv, dv, "sink V != direct V");
assert_eq!(dh, rh, "direct H != rgb_to_hsv H");
assert_eq!(ds, rs, "direct S != rgb_to_hsv S");
assert_eq!(dv, rv, "direct V != rgb_to_hsv V");
}
for &(fr, m) in &[(true, KernelMatrix::Bt709), (false, KernelMatrix::Bt601)] {
for &simd in &[false, true] {
check::<false>(w, h, m, fr, simd);
check::<true>(w, h, m, fr, simd);
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn nv20_be_equals_le_on_matching_logical_samples() {
let (w, h) = (40u32, 4u32);
let (yl, uvl) = nv20_random::<false>(w, h, 0xABCD_1234);
let (yb, uvb) = nv20_random::<true>(w, h, 0xABCD_1234);
for &(fr, m) in &[(true, KernelMatrix::Bt601), (false, KernelMatrix::Bt709)] {
let le = nv20_run_all::<false>(&yl, &uvl, w, h, m, fr, true);
let be = nv20_run_all::<true>(&yb, &uvb, w, h, m, fr, true);
assert_eq!(le.0, be.0, "rgb LE != BE (fr={fr} {m:?})");
assert_eq!(le.1, be.1, "rgb_u16 LE != BE");
assert_eq!(le.4, be.4, "luma LE != BE");
assert_eq!(le.5, be.5, "hsv LE != BE");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn nv20_rgba_u16_only_native_depth_gray_with_opaque_alpha() {
let (yp, uvp) = nv20_solid(16, 8, 512, 512, 512, false);
let src = Nv20Frame::new(&yp, &uvp, 16, 8, 16, 16);
let mut rgba = std::vec![0u16; 16 * 8 * 4];
let mut sink = MixedSinker::<Nv20>::new(16, 8)
.with_rgba_u16(&mut rgba)
.unwrap();
nv20_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
for px in rgba.chunks(4) {
assert!(px[0].abs_diff(512) <= 1, "got {px:?}");
assert_eq!(px[0], px[1]);
assert_eq!(px[1], px[2]);
assert_eq!(px[3], 1023, "alpha must equal (1 << 10) - 1");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn nv20_luma_is_depacked_y_narrowed_to_8bit() {
let (yp, uvp) = nv20_solid(16, 8, 700, 512, 512, false);
let src = Nv20Frame::new(&yp, &uvp, 16, 8, 16, 16);
let mut luma = std::vec![0u8; 16 * 8];
let mut sink = MixedSinker::<Nv20>::new(16, 8)
.with_luma(&mut luma)
.unwrap();
nv20_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
assert!(luma.iter().all(|&l| l == 175), "luma must be 700>>2 = 175");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn nv20_with_rgb_and_rgba_produce_byte_identical_rgb_bytes() {
let (yp, uvp) = nv20_random::<false>(48, 8, 0x55AA_33CC);
let src = Nv20Frame::new(&yp, &uvp, 48, 8, 48, 48);
let mut rgb_solo = std::vec![0u8; 48 * 8 * 3];
let mut s_solo = MixedSinker::<Nv20>::new(48, 8)
.with_rgb(&mut rgb_solo)
.unwrap();
nv20_to(&src, true, s_solo.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
let mut rgb_combined = std::vec![0u8; 48 * 8 * 3];
let mut rgba = std::vec![0u8; 48 * 8 * 4];
let mut s_combined = MixedSinker::<Nv20>::new(48, 8)
.with_rgb(&mut rgb_combined)
.unwrap()
.with_rgba(&mut rgba)
.unwrap();
nv20_to(
&src,
true,
s_combined.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
assert_eq!(rgb_solo, rgb_combined, "RGB bytes must match across runs");
for (rgb_px, rgba_px) in rgb_combined.chunks(3).zip(rgba.chunks(4)) {
assert_eq!(rgb_px[0], rgba_px[0]);
assert_eq!(rgb_px[1], rgba_px[1]);
assert_eq!(rgb_px[2], rgba_px[2]);
assert_eq!(rgba_px[3], 0xFF);
}
}
#[test]
fn nv20_rgba_too_short_returns_err() {
let mut rgba = std::vec![0u8; 10];
let err = MixedSinker::<Nv20>::new(16, 8)
.with_rgba(&mut rgba)
.err()
.expect("expected InsufficientRgbaBuffer");
assert!(matches!(err, MixedSinkerError::InsufficientRgbaBuffer(_)));
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
#[allow(deprecated)]
fn nv20_walker_matches_direct_le_and_be() {
let (w, h) = (40u32, 4u32);
let opts = YuvOptions::from_color_spec(&crate::ColorSpec::of_matrix(KernelMatrix::Bt601))
.with_full_range();
{
let (yp, uvp) = nv20_random::<false>(w, h, 0x1357_9BDF);
let src = Nv20Frame::<false>::new(&yp, &uvp, w, h, w, w);
let mut rgb_w = std::vec![0u8; (w * h * 3) as usize];
let mut sink_w = MixedSinker::<Nv20<false>>::new(w as usize, h as usize)
.with_rgb(&mut rgb_w)
.unwrap();
<Nv20<false> as Walker<_>>::walk(&src, &opts, sink_w.set_kernel_matrix(KernelMatrix::Bt601))
.unwrap();
let mut rgb_d = std::vec![0u8; (w * h * 3) as usize];
let mut sink_d = MixedSinker::<Nv20<false>>::new(w as usize, h as usize)
.with_rgb(&mut rgb_d)
.unwrap();
nv20_to(
&src,
opts.full_range(),
sink_d.set_kernel_matrix(KernelMatrix::Bt601),
)
.unwrap();
assert_eq!(rgb_w, rgb_d, "LE Walker::walk != nv20_to");
}
{
let (yp, uvp) = nv20_random::<true>(w, h, 0x2468_ACE0);
let src = Nv20Frame::<true>::new(&yp, &uvp, w, h, w, w);
let mut rgb_w = std::vec![0u8; (w * h * 3) as usize];
let mut sink_w = MixedSinker::<Nv20<true>>::new(w as usize, h as usize)
.with_rgb(&mut rgb_w)
.unwrap();
<Nv20<true> as Walker<_>>::walk(&src, &opts, sink_w.set_kernel_matrix(KernelMatrix::Bt601))
.unwrap();
let mut rgb_d = std::vec![0u8; (w * h * 3) as usize];
let mut sink_d = MixedSinker::<Nv20<true>>::new(w as usize, h as usize)
.with_rgb(&mut rgb_d)
.unwrap();
nv20_to_endian::<_, true>(
&src,
opts.full_range(),
sink_d.set_kernel_matrix(KernelMatrix::Bt601),
)
.unwrap();
assert_eq!(rgb_w, rgb_d, "BE Walker::walk != nv20_to_endian");
}
}
#[cfg(feature = "yuva")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn nv20_rgb_scratch_alloc_failure_leaves_outputs_untouched() {
use crate::resample::ResampleError;
let (yp, uvp) = nv20_solid(16, 8, 512, 512, 512, false);
let src = Nv20Frame::new(&yp, &uvp, 16, 8, 16, 16);
let mut luma = std::vec![0xABu8; 16 * 8];
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::<Nv20>::new(16, 8)
.with_luma(&mut luma)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
super::super::arm_rgb_scratch_alloc_failure();
let err = nv20_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"
);
}