use super::*;
use crate::{ChromaLocation, ColorMatrix};
const W: u32 = 16;
const H: u32 = 8;
fn ramp_planes_n(maxv: u32) -> (Vec<u16>, Vec<u16>, Vec<u16>) {
let w = W as usize;
let h = H as usize;
let cw = w / 2;
let step = (maxv / 16).max(1);
let y = std::vec![(maxv / 2) as u16; w * h];
let mut u = std::vec![0u16; cw * h];
let mut v = std::vec![0u16; cw * h];
for r in 0..h {
for c in 0..cw {
u[r * cw + c] = (step * c as u32 + step + r as u32 * 5).min(maxv) as u16;
v[r * cw + c] = maxv.saturating_sub(step * c as u32).max(step) as u16;
}
}
(y, u, v)
}
fn ref_upsample_center_h_u16(c_half: &[u16], width: usize) -> Vec<u16> {
let half = width / 2;
let mut out = std::vec![0u16; width];
for j in 0..half {
let l = c_half[j.saturating_sub(1)] as u32;
let m = c_half[j] as u32;
let r = c_half[if j + 1 < half { j + 1 } else { j }] as u32;
out[2 * j] = ((l + 3 * m + 2) >> 2) as u16;
out[2 * j + 1] = ((3 * m + r + 2) >> 2) as u16;
}
out
}
fn ref_full_chroma_u16(u422: &[u16], v422: &[u16]) -> (Vec<u16>, Vec<u16>) {
let w = W as usize;
let h = H as usize;
let cw = w / 2;
let mut u444 = std::vec![0u16; w * h];
let mut v444 = std::vec![0u16; w * h];
for r in 0..h {
let urow = ref_upsample_center_h_u16(&u422[r * cw..r * cw + cw], w);
let vrow = ref_upsample_center_h_u16(&v422[r * cw..r * cw + cw], w);
u444[r * w..r * w + w].copy_from_slice(&urow);
v444[r * w..r * w + w].copy_from_slice(&vrow);
}
(u444, v444)
}
macro_rules! hibit_422_chroma_tests {
($mod:ident, $bits:expr, $Marker:ident, $Frame:ident, $walker:ident, $Ref:ident, $RefFrame:ident, $ref_walker:ident, $MarkerBe:ty, $FrameBe:ident, $walker_be:ident, $Row:ident) => {
mod $mod {
use super::*;
const MAXV: u32 = (1u32 << $bits) - 1;
fn convert_rgb(loc: ChromaLocation, simd: bool) -> Vec<u8> {
let (yp, up, vp) = ramp_planes_n(MAXV);
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let mut rgb = std::vec![0u8; (W * H * 3) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_rgb(&mut rgb)
.unwrap()
.with_chroma_location(loc.clone())
.with_simd(simd);
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
rgb
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn default_and_cosited_sitings_are_byte_identical() {
let baseline = convert_rgb(ChromaLocation::Unspecified, true);
for loc in [
ChromaLocation::Unspecified,
ChromaLocation::other("unassigned-99"),
ChromaLocation::Left,
ChromaLocation::TopLeft,
ChromaLocation::BottomLeft,
] {
assert_eq!(
convert_rgb(loc.clone(), true),
baseline,
"siting {loc:?} must keep the byte-identical default decode"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn default_path_does_not_allocate_chroma_scratch() {
let (yp, up, vp) = ramp_planes_n(MAXV);
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let mut rgb = std::vec![0u8; (W * H * 3) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_rgb(&mut rgb)
.unwrap()
.with_chroma_location(ChromaLocation::Left);
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
let chroma_len = sink.chroma_full_u16.len();
drop(sink);
assert_eq!(chroma_len, 0, "co-sited path must not grow the u16 chroma scratch");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn center_grows_chroma_scratch_to_full_width() {
let (yp, up, vp) = ramp_planes_n(MAXV);
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let mut rgb = std::vec![0u8; (W * H * 3) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_rgb(&mut rgb)
.unwrap()
.with_chroma_location(ChromaLocation::Center);
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
let chroma_len = sink.chroma_full_u16.len();
drop(sink);
assert_eq!(
chroma_len,
2 * W as usize,
"centered path stages U+V at full width"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn center_rgb_matches_upsample_then_444_reference() {
let (yp, up, vp) = ramp_planes_n(MAXV);
let (u444, v444) = ref_full_chroma_u16(&up, &vp);
let ref_src = $RefFrame::new(&yp, &u444, &v444, W, H, W, W, W);
let mut rgb_ref = std::vec![0u8; (W * H * 3) as usize];
let mut ref_sink = MixedSinker::<$Ref>::new(W as usize, H as usize)
.with_rgb(&mut rgb_ref)
.unwrap();
$ref_walker(&ref_src, false, ref_sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert_eq!(
convert_rgb(ChromaLocation::Center, true),
rgb_ref,
"centered high-bit 4:2:2 RGB must equal upsample-then-4:4:4"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn center_rgb_u16_matches_upsample_then_444_reference() {
let (yp, up, vp) = ramp_planes_n(MAXV);
let (u444, v444) = ref_full_chroma_u16(&up, &vp);
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let mut rgb16 = std::vec![0u16; (W * H * 3) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_rgb_u16(&mut rgb16)
.unwrap()
.with_chroma_location(ChromaLocation::Center);
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
let ref_src = $RefFrame::new(&yp, &u444, &v444, W, H, W, W, W);
let mut rgb16_ref = std::vec![0u16; (W * H * 3) as usize];
let mut ref_sink = MixedSinker::<$Ref>::new(W as usize, H as usize)
.with_rgb_u16(&mut rgb16_ref)
.unwrap();
$ref_walker(&ref_src, false, ref_sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert_eq!(
rgb16, rgb16_ref,
"centered high-bit 4:2:2 RGB(u16) must equal upsample-then-4:4:4"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn center_rgba_rgba_u16_and_hsv_match_444_reference() {
let (yp, up, vp) = ramp_planes_n(MAXV);
let (u444, v444) = ref_full_chroma_u16(&up, &vp);
{
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let mut rgba = std::vec![0u8; (W * H * 4) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_rgba(&mut rgba)
.unwrap()
.with_chroma_location(ChromaLocation::Center);
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
let ref_src = $RefFrame::new(&yp, &u444, &v444, W, H, W, W, W);
let mut rgba_ref = std::vec![0u8; (W * H * 4) as usize];
let mut ref_sink = MixedSinker::<$Ref>::new(W as usize, H as usize)
.with_rgba(&mut rgba_ref)
.unwrap();
$ref_walker(&ref_src, false, ref_sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert_eq!(rgba, rgba_ref, "centered RGBA must equal upsample-then-4:4:4");
}
{
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let mut rgba16 = std::vec![0u16; (W * H * 4) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_rgba_u16(&mut rgba16)
.unwrap()
.with_chroma_location(ChromaLocation::Center);
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
let ref_src = $RefFrame::new(&yp, &u444, &v444, W, H, W, W, W);
let mut rgba16_ref = std::vec![0u16; (W * H * 4) as usize];
let mut ref_sink = MixedSinker::<$Ref>::new(W as usize, H as usize)
.with_rgba_u16(&mut rgba16_ref)
.unwrap();
$ref_walker(&ref_src, false, ref_sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert_eq!(
rgba16, rgba16_ref,
"centered RGBA(u16) must equal upsample-then-4:4:4"
);
}
{
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let (mut h, mut s, mut v) = (
std::vec![0u8; (W * H) as usize],
std::vec![0u8; (W * H) as usize],
std::vec![0u8; (W * H) as usize],
);
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_hsv(&mut h, &mut s, &mut v)
.unwrap()
.with_chroma_location(ChromaLocation::Center);
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
let ref_src = $RefFrame::new(&yp, &u444, &v444, W, H, W, W, W);
let (mut hr, mut sr, mut vr) = (
std::vec![0u8; (W * H) as usize],
std::vec![0u8; (W * H) as usize],
std::vec![0u8; (W * H) as usize],
);
let mut ref_sink = MixedSinker::<$Ref>::new(W as usize, H as usize)
.with_hsv(&mut hr, &mut sr, &mut vr)
.unwrap();
$ref_walker(&ref_src, false, ref_sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
assert_eq!(
(h, s, v),
(hr, sr, vr),
"centered HSV must equal upsample-then-4:4:4"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn every_centered_siting_agrees_horizontally() {
let center = convert_rgb(ChromaLocation::Center, true);
assert_eq!(convert_rgb(ChromaLocation::Top, true), center);
assert_eq!(convert_rgb(ChromaLocation::Bottom, true), center);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_phase_differs_from_default() {
assert_ne!(
convert_rgb(ChromaLocation::Center, true),
convert_rgb(ChromaLocation::Left, true),
"centered siting must shift chroma vs the co-sited default"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_path_simd_matches_scalar() {
assert_eq!(
convert_rgb(ChromaLocation::Center, true),
convert_rgb(ChromaLocation::Center, false),
"centered path must be bit-identical across the SIMD and scalar tiers"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_sanitizes_dirty_upper_bits_le() {
let upper = !(MAXV as u16);
let (yp, up, vp) = ramp_planes_n(MAXV);
let decode = |u: &[u16], v: &[u16]| -> Vec<u8> {
let src = $Frame::new(&yp, u, v, W, H, W, W / 2, W / 2);
let mut rgb = std::vec![0u8; (W * H * 3) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_rgb(&mut rgb)
.unwrap()
.with_chroma_location(ChromaLocation::Center);
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
rgb
};
let up_dirty: Vec<u16> = up.iter().map(|&x| x | upper).collect();
let vp_dirty: Vec<u16> = vp.iter().map(|&x| x | upper).collect();
assert_eq!(
decode(&up_dirty, &vp_dirty),
decode(&up, &vp),
"centered LE decode must sanitize dirty upper bits (mask before blend)"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_sanitizes_dirty_upper_bits_be() {
let upper = !(MAXV as u16);
let (yp, up, vp) = ramp_planes_n(MAXV);
let y_be: Vec<u16> = yp.iter().map(|&x| x.to_be()).collect();
let decode = |u_logical: &[u16], v_logical: &[u16]| -> Vec<u8> {
let u_be: Vec<u16> = u_logical.iter().map(|&x| x.to_be()).collect();
let v_be: Vec<u16> = v_logical.iter().map(|&x| x.to_be()).collect();
let src = $FrameBe::try_new(&y_be, &u_be, &v_be, W, H, W, W / 2, W / 2).unwrap();
let mut rgb = std::vec![0u8; (W * H * 3) as usize];
let mut sink = MixedSinker::<$MarkerBe>::new(W as usize, H as usize)
.with_rgb(&mut rgb)
.unwrap()
.with_chroma_location(ChromaLocation::Center);
$walker_be(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap();
rgb
};
let up_dirty: Vec<u16> = up.iter().map(|&x| x | upper).collect();
let vp_dirty: Vec<u16> = vp.iter().map(|&x| x | upper).collect();
assert_eq!(
decode(&up_dirty, &vp_dirty),
decode(&up, &vp),
"centered BE decode must sanitize dirty upper bits (mask before blend)"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_alloc_failure_leaves_outputs_untouched() {
use crate::resample::ResampleError;
let (yp, up, vp) = ramp_planes_n(MAXV);
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let mut luma = std::vec![0xABu8; (W * H) as usize];
let mut rgb = std::vec![0xCDu8; (W * H * 3) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_luma(&mut luma)
.unwrap()
.with_rgb(&mut rgb)
.unwrap()
.with_chroma_location(ChromaLocation::Center);
super::super::super::arm_chroma_full_alloc_failure();
let err = $walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt601)).unwrap_err();
drop(sink);
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"centered chroma-scratch refusal must surface as a recoverable AllocationFailed, got {err:?}"
);
assert!(
luma.iter().all(|&b| b == 0xAB),
"luma must be untouched on the centered alloc-failure path"
);
assert!(
rgb.iter().all(|&b| b == 0xCD),
"rgb must be untouched on the centered alloc-failure path"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_chroma_derived_ncl_uses_matrix_tag_fallback() {
use crate::{ColorInfo, ColorSpec, DynamicRange, PixelFormat, Primaries, Transfer};
let (yp, up, vp) = ramp_planes_n(MAXV);
let spec = |loc: ChromaLocation| {
ColorSpec::from_info(
PixelFormat::Yuv422p,
ColorInfo::new(
Primaries::Bt2020,
Transfer::Bt709,
ColorMatrix::ChromaDerivedNcl,
DynamicRange::Limited,
loc,
),
)
};
let decode_cdn = |loc: ChromaLocation| -> Vec<u8> {
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let mut rgb = std::vec![0u8; (W * H * 3) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_rgb(&mut rgb)
.unwrap()
.with_color_spec(&spec(loc)).unwrap();
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::ChromaDerivedNcl)).unwrap();
rgb
};
let decode_bt709 = |loc: ChromaLocation| -> Vec<u8> {
let src = $Frame::new(&yp, &up, &vp, W, H, W, W / 2, W / 2);
let mut rgb = std::vec![0u8; (W * H * 3) as usize];
let mut sink = MixedSinker::<$Marker>::new(W as usize, H as usize)
.with_rgb(&mut rgb)
.unwrap()
.with_chroma_location(loc.clone());
$walker(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
rgb
};
assert_eq!(
decode_cdn(ChromaLocation::Center),
decode_bt709(ChromaLocation::Center),
"centered high-bit ChromaDerivedNcl must resolve via the BT.709 matrix-tag fallback"
);
assert_eq!(
decode_cdn(ChromaLocation::Left),
decode_bt709(ChromaLocation::Left),
"default high-bit ChromaDerivedNcl must resolve via the same BT.709 fallback"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "constructs an absurd geometry; the no-op contract is the point, not Miri"
)]
fn no_output_row_large_geometry_does_not_overflow() {
let w: usize = 4;
let idx: usize = 1 << 30;
let h: usize = idx + 1; assert!(
(idx as u64) * (w as u64) > u32::MAX as u64,
"test geometry must exceed u32::MAX to exercise the 32-bit offset overflow"
);
let y = std::vec![(MAXV / 2) as u16; w];
let c = std::vec![(MAXV / 2) as u16; w / 2];
let mut sink =
MixedSinker::<$Marker>::new(w, h).with_chroma_location(ChromaLocation::Center);
let row = $Row::for_tests(&y, &c, &c, idx, KernelMatrix::Bt601, false);
crate::PixelSink::process(&mut sink, row).unwrap();
let chroma_len = sink.chroma_full_u16.len();
drop(sink);
assert_eq!(
chroma_len, 0,
"a no-output large-geometry high-bit row must allocate nothing"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn direct_path_mid_frame_siting_flip_is_rejected() {
let (yp, up, vp) = ramp_planes_n(MAXV);
let w = W as usize;
let h = H as usize;
let cw = w / 2;
for (loc1, loc2) in [
(ChromaLocation::Left, ChromaLocation::Center),
(ChromaLocation::Center, ChromaLocation::Left),
] {
let want = convert_rgb(loc1.clone(), true);
let mut rgb = std::vec![0u8; w * h * 3];
let mut sink = MixedSinker::<$Marker>::new(w, h)
.with_rgb(&mut rgb)
.unwrap()
.with_chroma_location(loc1.clone())
.with_simd(true);
crate::PixelSink::begin_frame(&mut sink, W, H).unwrap();
let row0 = $Row::for_tests(&yp[0..w], &up[0..cw], &vp[0..cw], 0, KernelMatrix::Bt601, false);
crate::PixelSink::process(&mut sink, row0).unwrap();
let scratch_len = sink.chroma_full_u16.len();
sink.set_chroma_location(loc2.clone());
let row1 = $Row::for_tests(
&yp[w..2 * w],
&up[cw..2 * cw],
&vp[cw..2 * cw],
1,
KernelMatrix::Bt601,
false,
);
let err = crate::PixelSink::process(&mut sink, row1).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"direct path {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
assert_eq!(
sink.chroma_full_u16.len(),
scratch_len,
"{loc1:?}->{loc2:?}: a rejected flip must not grow the chroma scratch"
);
sink.set_chroma_location(loc1.clone());
for r in 1..h {
let row = $Row::for_tests(
&yp[r * w..(r + 1) * w],
&up[r * cw..(r + 1) * cw],
&vp[r * cw..(r + 1) * cw],
r,
KernelMatrix::Bt601,
false,
);
crate::PixelSink::process(&mut sink, row).unwrap();
}
drop(sink);
assert_eq!(
rgb, want,
"{loc1:?}: retry after a rejected flip must match a clean in-order decode"
);
}
}
}
};
}
hibit_422_chroma_tests!(
p9,
9,
Yuv422p9,
Yuv422p9Frame,
yuv422p9_to,
Yuv444p9,
Yuv444p9Frame,
yuv444p9_to,
Yuv422p9<true>,
Yuv422p9BeFrame,
yuv422p9_to_endian,
Yuv422p9Row
);
hibit_422_chroma_tests!(
p10,
10,
Yuv422p10,
Yuv422p10Frame,
yuv422p10_to,
Yuv444p10,
Yuv444p10Frame,
yuv444p10_to,
Yuv422p10<true>,
Yuv422p10BeFrame,
yuv422p10_to_endian,
Yuv422p10Row
);
hibit_422_chroma_tests!(
p12,
12,
Yuv422p12,
Yuv422p12Frame,
yuv422p12_to,
Yuv444p12,
Yuv444p12Frame,
yuv444p12_to,
Yuv422p12<true>,
Yuv422p12BeFrame,
yuv422p12_to_endian,
Yuv422p12Row
);
hibit_422_chroma_tests!(
p14,
14,
Yuv422p14,
Yuv422p14Frame,
yuv422p14_to,
Yuv444p14,
Yuv444p14Frame,
yuv444p14_to,
Yuv422p14<true>,
Yuv422p14BeFrame,
yuv422p14_to_endian,
Yuv422p14Row
);
hibit_422_chroma_tests!(
p16,
16,
Yuv422p16,
Yuv422p16Frame,
yuv422p16_to,
Yuv444p16,
Yuv444p16Frame,
yuv444p16_to,
Yuv422p16<true>,
Yuv422p16BeFrame,
yuv422p16_to_endian,
Yuv422p16Row
);