use crate::{
ChromaLocation, KernelMatrix, PixelSink,
frame::*,
resample::{AreaResampler, FilteredResampler, Triangle},
sinker::{AlphaMode, MixedSinker, MixedSinkerError},
source::*,
};
const M: KernelMatrix = KernelMatrix::Bt601;
const FR: bool = true;
fn recon_full_row_u16(c: &[u16], cw: usize) -> Vec<u16> {
let mut out = vec![0u16; 2 * cw];
for j in 0..cw {
let l = u32::from(c[j.saturating_sub(1)]);
let m = u32::from(c[j]);
let r = u32::from(c[if j + 1 < cw { j + 1 } else { j }]);
out[2 * j] = ((l + 3 * m + 2) >> 2) as u16;
out[2 * j + 1] = ((3 * m + r + 2) >> 2) as u16;
}
out
}
fn as_be(host: &[u16]) -> Vec<u16> {
host.iter().map(|v| v.to_be()).collect()
}
fn recon_full_bottom_u16(u: &[u16], v: &[u16], sw: usize, sh: usize) -> (Vec<u16>, Vec<u16>) {
let cw = sw / 2;
let vblend = |plane: &[u16], cr: usize, prev: usize| -> Vec<u16> {
(0..cw)
.map(|c| {
let a = u32::from(plane[prev * cw + c]);
let b = u32::from(plane[cr * cw + c]);
((a + b + 1) >> 1) as u16
})
.collect::<Vec<u16>>()
};
let mut uf = vec![0u16; sw * sh];
let mut vf = vec![0u16; sw * sh];
for r in 0..sh {
let cr = r / 2;
let (uh, vh) = if r & 1 == 0 {
let prev = cr.saturating_sub(1);
(vblend(u, cr, prev), vblend(v, cr, prev))
} else {
(
u[cr * cw..cr * cw + cw].to_vec(),
v[cr * cw..cr * cw + cw].to_vec(),
)
};
uf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row_u16(&uh, cw));
vf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row_u16(&vh, cw));
}
(uf, vf)
}
fn recon_full_top_u16(u: &[u16], v: &[u16], sw: usize, sh: usize) -> (Vec<u16>, Vec<u16>) {
let cw = sw / 2;
let ch = sh.div_ceil(2);
let vblend = |plane: &[u16], cr: usize, next: usize| -> Vec<u16> {
(0..cw)
.map(|c| {
let a = u32::from(plane[cr * cw + c]);
let b = u32::from(plane[next * cw + c]);
((a + b + 1) >> 1) as u16
})
.collect::<Vec<u16>>()
};
let mut uf = vec![0u16; sw * sh];
let mut vf = vec![0u16; sw * sh];
for r in 0..sh {
let cr = r / 2;
let (uh, vh) = if r & 1 == 1 {
let next = (cr + 1).min(ch - 1);
(vblend(u, cr, next), vblend(v, cr, next))
} else {
(
u[cr * cw..cr * cw + cw].to_vec(),
v[cr * cw..cr * cw + cw].to_vec(),
)
};
uf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row_u16(&uh, cw));
vf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row_u16(&vh, cw));
}
(uf, vf)
}
const GEOMS: [(usize, usize, usize, usize); 4] =
[(8, 8, 4, 4), (8, 8, 5, 3), (12, 8, 4, 4), (16, 8, 6, 5)];
type Outs = (
Vec<u8>,
Vec<u8>,
Vec<u16>,
Vec<u16>,
(Vec<u8>, Vec<u8>, Vec<u8>),
Vec<u8>,
Vec<u16>,
);
type YuvOuts = (Vec<u8>, Vec<u16>, (Vec<u8>, Vec<u8>, Vec<u8>), Vec<u8>);
macro_rules! hibit_420_yuva_resample_siting {
(
$mod:ident, $bits:expr,
$M420:ident, $F420le:ident, $w420:ident,
$M420be:ty, $F420be:ident, $w420be:ident, $Row:ident,
$M444:ident, $F444:ident, $w444:ident,
$MYuv:ident, $FYuv:ident, $wYuv:ident
) => {
mod $mod {
use super::*;
const MASK: u16 = ((1u32 << $bits) - 1) as u16;
const MID: u16 = 1u16 << ($bits - 1);
fn ramp(sw: usize, sh: usize) -> (Vec<u16>, Vec<u16>, Vec<u16>, Vec<u16>) {
let (cw, ch) = (sw / 2, sh / 2);
let step = (MASK as u32 / 16).max(1);
let mut y = vec![0u16; sw * sh];
let mut u = vec![0u16; cw * ch];
let mut v = vec![0u16; cw * ch];
let mut a = vec![0u16; sw * sh];
for (i, p) in y.iter_mut().enumerate() {
*p = ((40 + i as u32 * 37) & MASK as u32) as u16;
}
for r in 0..ch {
for c in 0..cw {
u[r * cw + c] = (step * c as u32 + step + r as u32 * 5).min(MASK as u32) as u16;
v[r * cw + c] = (MASK as u32).saturating_sub(step * c as u32).max(step) as u16;
}
}
for (i, p) in a.iter_mut().enumerate() {
*p = ((MASK as u32 / 5 + i as u32 * 23) & MASK as u32) as u16;
}
(y, u, v, a)
}
fn flat(sw: usize, sh: usize) -> (Vec<u16>, Vec<u16>, Vec<u16>, Vec<u16>) {
let (cw, ch) = (sw / 2, sh / 2);
let mut y = vec![0u16; sw * sh];
let mut a = vec![0u16; sw * sh];
for (i, p) in y.iter_mut().enumerate() {
*p = ((40 + i as u32 * 29) & MASK as u32) as u16;
}
for (i, p) in a.iter_mut().enumerate() {
*p = ((MASK as u32 / 3 + i as u32 * 17) & MASK as u32) as u16;
}
(y, vec![MID; cw * ch], vec![MID; cw * ch], a)
}
fn bufs(ow: usize, oh: usize) -> Outs {
(
vec![0u8; ow * oh * 3],
vec![0u8; ow * oh * 4],
vec![0u16; ow * oh * 3],
vec![0u16; ow * oh * 4],
(vec![0u8; ow * oh], vec![0u8; ow * oh], vec![0u8; ow * oh]),
vec![0u8; ow * oh],
vec![0u16; ow * oh],
)
}
#[allow(clippy::too_many_arguments)]
fn run(
y: &[u16],
u: &[u16],
v: &[u16],
a: &[u16],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
simd: bool,
) -> Outs {
let cw = sw / 2;
let (
mut rgb,
mut rgba,
mut rgb16,
mut rgba16,
(mut hh, mut ss, mut vv),
mut luma,
mut luma16,
) = bufs(ow, oh);
{
let mut sink =
MixedSinker::<$M420, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(loc.clone())
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_rgb_u16(&mut rgb16)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma16)
.unwrap();
let f = $F420le::try_new(
y, u, v, a, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32, sw as u32,
)
.unwrap();
$w420(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, rgb16, rgba16, (hh, ss, vv), luma, luma16)
}
#[allow(clippy::too_many_arguments)]
fn run_filter(
y: &[u16],
u: &[u16],
v: &[u16],
a: &[u16],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
simd: bool,
) -> Outs {
let cw = sw / 2;
let (
mut rgb,
mut rgba,
mut rgb16,
mut rgba16,
(mut hh, mut ss, mut vv),
mut luma,
mut luma16,
) = bufs(ow, oh);
{
let mut sink = MixedSinker::<$M420, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(loc.clone())
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_rgb_u16(&mut rgb16)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma16)
.unwrap();
let f = $F420le::try_new(
y, u, v, a, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32, sw as u32,
)
.unwrap();
$w420(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, rgb16, rgba16, (hh, ss, vv), luma, luma16)
}
#[allow(clippy::too_many_arguments)]
fn run_be(
y: &[u16],
u: &[u16],
v: &[u16],
a: &[u16],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
) -> Outs {
let cw = sw / 2;
let (yb, ub, vb, ab) = (as_be(y), as_be(u), as_be(v), as_be(a));
let (
mut rgb,
mut rgba,
mut rgb16,
mut rgba16,
(mut hh, mut ss, mut vv),
mut luma,
mut luma16,
) = bufs(ow, oh);
{
let mut sink = MixedSinker::<$M420be, AreaResampler>::with_resampler(
sw,
sh,
AreaResampler::to(ow, oh),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(loc.clone())
.with_rgb(&mut rgb)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_rgb_u16(&mut rgb16)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma16)
.unwrap();
let f = $F420be::try_new(
&yb, &ub, &vb, &ab, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32, sw as u32,
)
.unwrap();
$w420be(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, rgb16, rgba16, (hh, ss, vv), luma, luma16)
}
#[allow(clippy::too_many_arguments)]
fn rgba_oracle(
y: &[u16],
u: &[u16],
v: &[u16],
a: &[u16],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
filter: bool,
) -> (Vec<u8>, Vec<u16>) {
let cw = sw / 2;
let mut uf = vec![0u16; sw * sh];
let mut vf = vec![0u16; sw * sh];
for r in 0..sh {
let cr = r / 2;
uf[r * sw..r * sw + sw]
.copy_from_slice(&recon_full_row_u16(&u[cr * cw..cr * cw + cw], cw));
vf[r * sw..r * sw + sw]
.copy_from_slice(&recon_full_row_u16(&v[cr * cw..cr * cw + cw], cw));
}
let mut rgba = vec![0u8; ow * oh * 4];
let mut rgba16 = vec![0u16; ow * oh * 4];
let f = $F444::try_new(
y, &uf, &vf, a, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32, sw as u32,
)
.unwrap();
if filter {
let mut sink = MixedSinker::<$M444, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_simd(simd)
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap();
$w444(&f, FR, sink.set_kernel_matrix(M)).unwrap();
} else {
let mut sink =
MixedSinker::<$M444, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_simd(simd)
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap();
$w444(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgba, rgba16)
}
#[allow(clippy::too_many_arguments)]
fn run_yuv(
y: &[u16],
u: &[u16],
v: &[u16],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
simd: bool,
) -> YuvOuts {
let cw = sw / 2;
let mut rgb = vec![0u8; ow * oh * 3];
let mut rgb16 = vec![0u16; ow * oh * 3];
let (mut hh, mut ss, mut vv) = (vec![0u8; ow * oh], vec![0u8; ow * oh], vec![0u8; ow * oh]);
let mut luma = vec![0u8; ow * oh];
{
let mut sink =
MixedSinker::<$MYuv, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_chroma_location(loc.clone())
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap()
.with_rgb_u16(&mut rgb16)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap();
let f = $FYuv::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
$wYuv(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgb16, (hh, ss, vv), luma)
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn cosited_group_is_byte_identical_across_tiers() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
let base = run(
&y,
&u,
&v,
&a,
sw,
sh,
ow,
oh,
ChromaLocation::Unspecified,
true,
);
for loc in [
ChromaLocation::Left,
ChromaLocation::other("unassigned-7"),
] {
assert_eq!(
run(&y, &u, &v, &a, sw, sh, ow, oh, loc.clone(), true),
base,
"co-sited {loc:?} area must keep the byte-identical decode \
({sw}x{sh}->{ow}x{oh})"
);
}
let fbase = run_filter(
&y,
&u,
&v,
&a,
sw,
sh,
ow,
oh,
ChromaLocation::Unspecified,
true,
);
assert_eq!(
run_filter(&y, &u, &v, &a, sw, sh, ow, oh, ChromaLocation::Left, true),
fbase,
"co-sited filter must stay byte-identical ({sw}x{sh}->{ow}x{oh})"
);
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn centered_area_rgba_equals_rgb_domain_oracle() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
let (want_rgba, want_rgba16) = rgba_oracle(&y, &u, &v, &a, sw, sh, ow, oh, true, false);
for loc in [ChromaLocation::Center] {
let got = run(&y, &u, &v, &a, sw, sh, ow, oh, loc.clone(), true);
assert_eq!(
got.1, want_rgba,
"centered area rgba {loc:?} ({sw}x{sh}->{ow}x{oh})"
);
assert_eq!(
got.3, want_rgba16,
"centered area rgba_u16 {loc:?} ({sw}x{sh}->{ow}x{oh})"
);
}
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn centered_filter_rgba_equals_rgb_domain_oracle() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
let (want_rgba, want_rgba16) = rgba_oracle(&y, &u, &v, &a, sw, sh, ow, oh, true, true);
let got = run_filter(&y, &u, &v, &a, sw, sh, ow, oh, ChromaLocation::Center, true);
assert_eq!(
got.1, want_rgba,
"centered filter rgba ({sw}x{sh}->{ow}x{oh})"
);
assert_eq!(
got.3, want_rgba16,
"centered filter rgba_u16 ({sw}x{sh}->{ow}x{oh})"
);
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn centered_chroma_matches_yuv420p_centered() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
for loc in [ChromaLocation::Center, ChromaLocation::Top, ChromaLocation::TopLeft] {
let ya = run(&y, &u, &v, &a, sw, sh, ow, oh, loc.clone(), true);
let yv = run_yuv(&y, &u, &v, sw, sh, ow, oh, loc.clone(), true);
assert_eq!(ya.0, yv.0, "rgb {loc:?} ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.2, yv.1, "rgb_u16 {loc:?} ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.4, yv.2, "hsv {loc:?} ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.5, yv.3, "luma {loc:?} ({sw}x{sh}->{ow}x{oh})");
for px in 0..ow * oh {
assert_eq!(
&ya.1[px * 4..px * 4 + 3],
&ya.0[px * 3..px * 3 + 3],
"rgba colour vs rgb {loc:?} px {px}"
);
assert_eq!(
&ya.3[px * 4..px * 4 + 3],
&ya.2[px * 3..px * 3 + 3],
"rgba_u16 colour vs rgb_u16 {loc:?} px {px}"
);
}
}
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn alpha_is_identical_between_cosited_and_centered() {
for is_filter in [false, true] {
let (y, u, v, a) = ramp(8, 8);
let drive = |loc| {
if is_filter {
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, loc, true)
} else {
run(&y, &u, &v, &a, 8, 8, 4, 4, loc, true)
}
};
let cos = drive(ChromaLocation::Left);
let cen = drive(ChromaLocation::Center);
let cos_a: Vec<u8> = cos.1.iter().skip(3).step_by(4).copied().collect();
let cen_a: Vec<u8> = cen.1.iter().skip(3).step_by(4).copied().collect();
assert_eq!(
cen_a, cos_a,
"centered α (u8) must equal co-sited (filter={is_filter})"
);
let cos_a16: Vec<u16> = cos.3.iter().skip(3).step_by(4).copied().collect();
let cen_a16: Vec<u16> = cen.3.iter().skip(3).step_by(4).copied().collect();
assert_eq!(
cen_a16, cos_a16,
"centered α (u16) must equal co-sited (filter={is_filter})"
);
assert_ne!(
cen.0, cos.0,
"centered colour must differ (filter={is_filter})"
);
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn centered_differs_from_cosited_on_a_chroma_ramp() {
let (y, u, v, a) = ramp(8, 8);
let cos = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Left, true);
let cen = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, true);
assert_ne!(
cos.0, cen.0,
"centered rgb must differ from co-sited on a ramp"
);
assert_ne!(
cos.3, cen.3,
"centered rgba_u16 must differ from co-sited on a ramp"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn centered_equals_cosited_on_flat_chroma() {
let (y, u, v, a) = flat(8, 8);
let cos = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Left, true);
let cen = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, true);
assert_eq!(cos.1, cen.1, "flat-chroma rgba");
assert_eq!(cos.3, cen.3, "flat-chroma rgba_u16");
assert_eq!(cos.4, cen.4, "flat-chroma hsv");
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn centered_simd_matches_scalar() {
let (y, u, v, a) = ramp(8, 8);
assert_eq!(
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, true),
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, false),
"centered area SIMD vs scalar must agree"
);
assert_eq!(
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, true),
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, false),
"centered filter SIMD vs scalar must agree"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn be_centered_matches_le() {
let (y, u, v, a) = ramp(8, 8);
assert_eq!(
run_be(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center),
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, true),
"BE centered decode must equal LE for the same logical planes"
);
}
fn flip_row1<R>(
mut sink: MixedSinker<'_, $M420, R>,
y: &[u16],
u: &[u16],
v: &[u16],
a: &[u16],
loc1: ChromaLocation,
loc2: ChromaLocation,
) -> Result<(), MixedSinkerError> {
sink.set_chroma_location(loc1.clone());
PixelSink::begin_frame(&mut sink, 8, 8).unwrap();
let row0 = $Row::for_tests(&y[0..8], &u[0..4], &v[0..4], &a[0..8], 0, M, FR);
PixelSink::process(&mut sink, row0).unwrap();
sink.set_chroma_location(loc2.clone());
let row1 = $Row::for_tests(&y[8..16], &u[0..4], &v[0..4], &a[8..16], 1, M, FR);
PixelSink::process(&mut sink, row1)
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn mid_frame_siting_change_rejected() {
let (y, u, v, a) = ramp(8, 8);
for (loc1, loc2) in [
(ChromaLocation::Center, ChromaLocation::Left),
(ChromaLocation::Left, ChromaLocation::Center),
] {
let mut rgba = vec![0u8; 4 * 4 * 4];
let sink =
MixedSinker::<$M420, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_rgba(&mut rgba)
.unwrap();
let err = flip_row1(sink, &y, &u, &v, &a, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"area {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
let mut rgba16 = vec![0u16; 4 * 4 * 4];
let sink =
MixedSinker::<$M420, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_rgba_u16(&mut rgba16)
.unwrap();
let err = flip_row1(sink, &y, &u, &v, &a, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"u16 area {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
let mut rgba = vec![0u8; 4 * 4 * 4];
let sink = MixedSinker::<$M420, FilteredResampler<Triangle>>::with_resampler(
8,
8,
FilteredResampler::new(4, 4, Triangle),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_rgba(&mut rgba)
.unwrap();
let err = flip_row1(sink, &y, &u, &v, &a, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"filter {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
}
}
fn vramp(sw: usize, sh: usize) -> (Vec<u16>, Vec<u16>, Vec<u16>, Vec<u16>) {
let (cw, ch) = (sw / 2, sh / 2);
let step = (MASK as u32 / 8).max(1);
let y = vec![MID; sw * sh];
let mut u = vec![0u16; cw * ch];
let mut v = vec![0u16; cw * ch];
let mut a = vec![0u16; sw * sh];
for r in 0..ch {
for c in 0..cw {
u[r * cw + c] = (step + r as u32 * step).min(MASK as u32) as u16;
v[r * cw + c] = (MASK as u32).saturating_sub(r as u32 * step).max(step) as u16;
}
}
for (i, p) in a.iter_mut().enumerate() {
*p = ((MASK as u32 / 5 + i as u32 * 23) & MASK as u32) as u16;
}
(y, u, v, a)
}
#[allow(clippy::too_many_arguments)]
fn rgba_oracle_bottom(
y: &[u16],
u: &[u16],
v: &[u16],
a: &[u16],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
filter: bool,
) -> (Vec<u8>, Vec<u16>) {
let (uf, vf) = recon_full_bottom_u16(u, v, sw, sh);
let mut rgba = vec![0u8; ow * oh * 4];
let mut rgba16 = vec![0u16; ow * oh * 4];
let f = $F444::try_new(
y, &uf, &vf, a, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32, sw as u32,
)
.unwrap();
if filter {
let mut sink = MixedSinker::<$M444, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_simd(simd)
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap();
$w444(&f, FR, sink.set_kernel_matrix(M)).unwrap();
} else {
let mut sink =
MixedSinker::<$M444, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_simd(simd)
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap();
$w444(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgba, rgba16)
}
fn direct_bottom_yuva(
y: &[u16],
u: &[u16],
v: &[u16],
a: &[u16],
sw: usize,
sh: usize,
simd: bool,
) -> (Vec<u8>, Vec<u16>) {
let cw = sw / 2;
let mut rgba = vec![0u8; sw * sh * 4];
let mut rgba16 = vec![0u16; sw * sh * 4];
{
let mut sink = MixedSinker::<$M420>::new(sw, sh)
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(ChromaLocation::Bottom)
.with_simd(simd)
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap();
let f = $F420le::try_new(
y, u, v, a, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32, sw as u32,
)
.unwrap();
$w420(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgba, rgba16)
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_area_rgba_equals_rgb_domain_oracle() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
let (want_rgba, want_rgba16) =
rgba_oracle_bottom(&y, &u, &v, &a, sw, sh, ow, oh, true, false);
let got = run(&y, &u, &v, &a, sw, sh, ow, oh, ChromaLocation::Bottom, true);
assert_eq!(got.1, want_rgba, "bottom area rgba ({sw}x{sh}->{ow}x{oh})");
assert_eq!(
got.3, want_rgba16,
"bottom area rgba_u16 ({sw}x{sh}->{ow}x{oh})"
);
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_filter_rgba_equals_rgb_domain_oracle() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
let (want_rgba, want_rgba16) =
rgba_oracle_bottom(&y, &u, &v, &a, sw, sh, ow, oh, true, true);
let got = run_filter(&y, &u, &v, &a, sw, sh, ow, oh, ChromaLocation::Bottom, true);
assert_eq!(got.1, want_rgba, "bottom filter rgba ({sw}x{sh}->{ow}x{oh})");
assert_eq!(
got.3, want_rgba16,
"bottom filter rgba_u16 ({sw}x{sh}->{ow}x{oh})"
);
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_chroma_matches_yuv420p_bottom() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
let ya = run(&y, &u, &v, &a, sw, sh, ow, oh, ChromaLocation::Bottom, true);
let yv = run_yuv(&y, &u, &v, sw, sh, ow, oh, ChromaLocation::Bottom, true);
assert_eq!(ya.0, yv.0, "rgb ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.2, yv.1, "rgb_u16 ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.4, yv.2, "hsv ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.5, yv.3, "luma ({sw}x{sh}->{ow}x{oh})");
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_alpha_is_identical_to_cosited() {
for is_filter in [false, true] {
let (y, u, v, a) = vramp(8, 8);
let drive = |loc| {
if is_filter {
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, loc, true)
} else {
run(&y, &u, &v, &a, 8, 8, 4, 4, loc, true)
}
};
let cos = drive(ChromaLocation::Left);
let bot = drive(ChromaLocation::Bottom);
let cos_a: Vec<u8> = cos.1.iter().skip(3).step_by(4).copied().collect();
let bot_a: Vec<u8> = bot.1.iter().skip(3).step_by(4).copied().collect();
assert_eq!(
bot_a, cos_a,
"bottom α (u8) must equal co-sited (filter={is_filter})"
);
let cos_a16: Vec<u16> = cos.3.iter().skip(3).step_by(4).copied().collect();
let bot_a16: Vec<u16> = bot.3.iter().skip(3).step_by(4).copied().collect();
assert_eq!(
bot_a16, cos_a16,
"bottom α (u16) must equal co-sited (filter={is_filter})"
);
assert_ne!(
bot.0, cos.0,
"bottom colour must differ from co-sited (filter={is_filter})"
);
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_differs_from_center_on_a_vertical_chroma_ramp() {
let (y, u, v, a) = vramp(8, 8);
let cen = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, true);
let bot = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, true);
assert_ne!(bot.0, cen.0, "bottom area rgb must differ from center");
assert_ne!(bot.3, cen.3, "bottom area rgba_u16 must differ from center");
let cenf = run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, true);
let botf = run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, true);
assert_ne!(botf.1, cenf.1, "bottom filter rgba must differ from center");
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_equals_cosited_on_flat_chroma() {
let (y, u, v, a) = flat(8, 8);
let cos = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Left, true);
let bot = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, true);
assert_eq!(cos.1, bot.1, "flat-chroma bottom rgba");
assert_eq!(cos.3, bot.3, "flat-chroma bottom rgba_u16");
assert_eq!(cos.4, bot.4, "flat-chroma bottom hsv");
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_simd_matches_scalar() {
let (y, u, v, a) = ramp(8, 8);
assert_eq!(
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, true),
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, false),
"bottom area SIMD vs scalar must agree"
);
assert_eq!(
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, true),
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, false),
"bottom filter SIMD vs scalar must agree"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_be_matches_le() {
let (y, u, v, a) = ramp(8, 8);
assert_eq!(
run_be(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom),
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, true),
"BE bottom decode must equal LE for the same logical planes"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottomleft_chroma_matches_yuv420p_bottomleft() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
for native in [true, false] {
let ya = run(&y, &u, &v, &a, sw, sh, ow, oh, ChromaLocation::BottomLeft, native);
let yv = run_yuv(&y, &u, &v, sw, sh, ow, oh, ChromaLocation::BottomLeft, native);
assert_eq!(ya.0, yv.0, "rgb native={native} ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.2, yv.1, "rgb_u16 native={native} ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.4, yv.2, "hsv native={native} ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.5, yv.3, "luma native={native} ({sw}x{sh}->{ow}x{oh})");
}
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottomleft_alpha_is_identical_to_cosited_and_folds_the_phase() {
for is_filter in [false, true] {
let (y, u, v, a) = vramp(8, 8);
let drive = |loc| {
if is_filter {
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, loc, true)
} else {
run(&y, &u, &v, &a, 8, 8, 4, 4, loc, true)
}
};
let cos = drive(ChromaLocation::Left);
let bl = drive(ChromaLocation::BottomLeft);
let cos_a16: Vec<u16> = cos.3.iter().skip(3).step_by(4).copied().collect();
let bl_a16: Vec<u16> = bl.3.iter().skip(3).step_by(4).copied().collect();
assert_eq!(
bl_a16, cos_a16,
"bottom-left α (u16) must equal co-sited (filter={is_filter})"
);
assert_ne!(
bl.0, cos.0,
"bottom-left colour must differ from co-sited (filter={is_filter})"
);
}
let (y, u, v, a) = ramp(8, 8);
assert_ne!(
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::BottomLeft, true).0,
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, true).0,
"bottom-left (h=0) must differ from bottom (h=0.5) on a horizontal ramp"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottomleft_be_and_simd_agree() {
let (y, u, v, a) = ramp(8, 8);
assert_eq!(
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::BottomLeft, true),
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::BottomLeft, false),
"bottom-left area SIMD vs scalar must agree"
);
assert_eq!(
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::BottomLeft, true),
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::BottomLeft, false),
"bottom-left filter SIMD vs scalar must agree"
);
assert_eq!(
run_be(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::BottomLeft),
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::BottomLeft, true),
"BE bottom-left must equal LE"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottomleft_equals_cosited_on_flat_chroma() {
let (y, u, v, a) = flat(8, 8);
let cos = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Left, true);
let bl = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::BottomLeft, true);
assert_eq!(cos.3, bl.3, "flat-chroma bottom-left rgba_u16");
assert_eq!(cos.4, bl.4, "flat-chroma bottom-left hsv");
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_identity_resample_matches_direct_decode() {
let (y, u, v, a) = vramp(8, 8);
let res = run(&y, &u, &v, &a, 8, 8, 8, 8, ChromaLocation::Bottom, true);
let (drgba, drgba16) = direct_bottom_yuva(&y, &u, &v, &a, 8, 8, true);
assert_eq!(res.1, drgba, "identity resample bottom rgba == direct decode");
assert_eq!(
res.3, drgba16,
"identity resample bottom rgba_u16 == direct decode"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_final_even_row_reserve_alloc_failure_retries_with_blend() {
use crate::resample::ResampleError;
let (sw, sh, ow, oh) = (8usize, 7usize, 4usize, 3usize);
let cw = sw / 2;
let ch = sh.div_ceil(2);
let step = (MASK as u32 / 8).max(1);
let y = vec![MID; sw * sh];
let mut u = vec![0u16; cw * ch];
let mut v = vec![0u16; cw * ch];
for r in 0..ch {
for c in 0..cw {
u[r * cw + c] = (step + r as u32 * step).min(MASK as u32) as u16;
v[r * cw + c] = (MASK as u32).saturating_sub(r as u32 * step).max(step) as u16;
}
}
let mut a = vec![0u16; sw * sh];
for (i, p) in a.iter_mut().enumerate() {
*p = ((MASK as u32 / 5 + i as u32 * 23) & MASK as u32) as u16;
}
let run_frame = |arm_fail: bool, loc: ChromaLocation| -> (Vec<u8>, Vec<u16>) {
let mut rgba = vec![0u8; ow * oh * 4];
let mut rgba16 = vec![0u16; ow * oh * 4];
{
let mut sink = MixedSinker::<$M420, AreaResampler>::with_resampler(
sw,
sh,
AreaResampler::to(ow, oh),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(loc.clone())
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap();
sink.begin_frame(sw as u32, sh as u32).unwrap();
let feed = |sink: &mut MixedSinker<'_, $M420, AreaResampler>, r: usize| {
let yr = &y[r * sw..(r + 1) * sw];
let cr = r / 2;
let ur = &u[cr * cw..(cr + 1) * cw];
let vr = &v[cr * cw..(cr + 1) * cw];
let ar = &a[r * sw..(r + 1) * sw];
sink.process($Row::for_tests(yr, ur, vr, ar, r, M, FR))
};
for r in 0..sh - 1 {
feed(&mut sink, r).unwrap();
}
if arm_fail {
super::super::arm_chroma_prev_alloc_failure();
let err = feed(&mut sink, sh - 1).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"armed final-row lookback reserve must surface AllocationFailed, got {err:?}"
);
}
feed(&mut sink, sh - 1).unwrap();
}
(rgba, rgba16)
};
let reference = run_frame(false, ChromaLocation::Bottom);
let retried = run_frame(true, ChromaLocation::Bottom);
assert_eq!(
retried.0, reference.0,
"post-failure retry rgba must blend with the predecessor (not clamp)"
);
assert_eq!(
retried.1, reference.1,
"post-failure retry rgba_u16 (colour + α) must match the clean run"
);
assert_ne!(
reference.0,
run_frame(false, ChromaLocation::Center).0,
"the bottom vertical blend must move the final even row vs co-sited Center"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn mid_frame_center_bottom_flip_rejected() {
let (y, u, v, a) = vramp(8, 8);
for (loc1, loc2) in [
(ChromaLocation::Center, ChromaLocation::Bottom),
(ChromaLocation::Bottom, ChromaLocation::Center),
] {
let mut rgba = vec![0u8; 4 * 4 * 4];
let sink =
MixedSinker::<$M420, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_rgba(&mut rgba)
.unwrap();
let err = flip_row1(sink, &y, &u, &v, &a, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"area {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
let mut rgba16 = vec![0u16; 4 * 4 * 4];
let sink =
MixedSinker::<$M420, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_rgba_u16(&mut rgba16)
.unwrap();
let err = flip_row1(sink, &y, &u, &v, &a, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"u16 area {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
let mut rgba = vec![0u8; 4 * 4 * 4];
let sink = MixedSinker::<$M420, FilteredResampler<Triangle>>::with_resampler(
8,
8,
FilteredResampler::new(4, 4, Triangle),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_rgba(&mut rgba)
.unwrap();
let err = flip_row1(sink, &y, &u, &v, &a, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"filter {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_direct_luma_only_then_late_colour_attach_blends_not_clamps() {
let (y, u, v, a) = vramp(8, 8);
let (sw, sh, cw) = (8usize, 8usize, 4usize);
let row_at = |r: usize| {
let cr = r / 2;
$Row::for_tests(
&y[r * sw..r * sw + sw],
&u[cr * cw..cr * cw + cw],
&v[cr * cw..cr * cw + cw],
&a[r * sw..r * sw + sw],
r,
M,
FR,
)
};
let reference = direct_bottom_yuva(&y, &u, &v, &a, sw, sh, true).0;
let mut luma = vec![0u8; sw * sh];
let mut rgba = vec![0u8; sw * sh * 4];
{
let mut sink = MixedSinker::<$M420>::new(sw, sh)
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(ChromaLocation::Bottom)
.with_simd(true)
.with_luma(&mut luma)
.unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
for r in 0..2 {
PixelSink::process(&mut sink, row_at(r)).unwrap();
}
sink.set_rgba(&mut rgba).unwrap();
for r in 2..sh {
PixelSink::process(&mut sink, row_at(r)).unwrap();
}
}
let (row2, row3) = (2 * sw * 4, 3 * sw * 4);
assert_eq!(
&rgba[row2..row3],
&reference[row2..row3],
"late-colour-attach row 2 must box-blend the luma-only-staged chroma (colour + α), not clamp"
);
let mut rgba_clamp = vec![0u8; sw * sh * 4];
{
let mut sink = MixedSinker::<$M420>::new(sw, sh)
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(ChromaLocation::Bottom)
.with_simd(true)
.with_rgba(&mut rgba_clamp)
.unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
PixelSink::process(&mut sink, row_at(2)).unwrap();
}
assert_ne!(
&rgba_clamp[row2..row3],
&reference[row2..row3],
"control: a clamped row 2 (empty lookback) must differ from the blended reference"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn bottom_two_frames_no_cross_frame_stale_blend() {
let (y, u, v, a) = vramp(8, 8);
let (sw, sh, cw) = (8usize, 8usize, 4usize);
let row_at = |r: usize| {
let cr = r / 2;
$Row::for_tests(
&y[r * sw..r * sw + sw],
&u[cr * cw..cr * cw + cw],
&v[cr * cw..cr * cw + cw],
&a[r * sw..r * sw + sw],
r,
M,
FR,
)
};
let (row2, row3) = (2 * sw * 4, 3 * sw * 4);
let mut fresh = std::vec![0u8; sw * sh * 4];
{
let mut sink = MixedSinker::<$M420>::new(sw, sh)
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(ChromaLocation::Bottom)
.with_simd(true)
.with_rgba(&mut fresh)
.unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
PixelSink::process(&mut sink, row_at(2)).unwrap();
}
let mut full = std::vec![0u8; sw * sh * 4];
{
let mut sink = MixedSinker::<$M420>::new(sw, sh)
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(ChromaLocation::Bottom)
.with_simd(true)
.with_rgba(&mut full)
.unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
for r in 0..sh {
PixelSink::process(&mut sink, row_at(r)).unwrap();
}
}
assert_ne!(
&full[row2..row3],
&fresh[row2..row3],
"control: a full-frame row 2 blends its predecessor (differs from the clamped partial decode)"
);
let mut reused = std::vec![0u8; sw * sh * 4];
{
let mut sink = MixedSinker::<$M420>::new(sw, sh)
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(ChromaLocation::Bottom)
.with_simd(true)
.with_rgba(&mut reused)
.unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
PixelSink::process(&mut sink, row_at(0)).unwrap();
PixelSink::process(&mut sink, row_at(1)).unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
PixelSink::process(&mut sink, row_at(2)).unwrap();
}
assert_eq!(
&reused[row2..row3],
&fresh[row2..row3],
"begin_frame must invalidate the Bottom lookback: frame 2's first even row \
must clamp (== fresh sink), never box-blend the previous frame's stale chroma"
);
}
#[allow(clippy::too_many_arguments)]
fn rgba_oracle_top(
y: &[u16],
u: &[u16],
v: &[u16],
a: &[u16],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
filter: bool,
) -> (Vec<u8>, Vec<u16>) {
let (uf, vf) = recon_full_top_u16(u, v, sw, sh);
let mut rgba = vec![0u8; ow * oh * 4];
let mut rgba16 = vec![0u16; ow * oh * 4];
let f = $F444::try_new(
y, &uf, &vf, a, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32, sw as u32,
)
.unwrap();
if filter {
let mut sink = MixedSinker::<$M444, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_simd(simd)
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap();
$w444(&f, FR, sink.set_kernel_matrix(M)).unwrap();
} else {
let mut sink =
MixedSinker::<$M444, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_simd(simd)
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap();
$w444(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgba, rgba16)
}
fn direct_top_yuva(
y: &[u16],
u: &[u16],
v: &[u16],
a: &[u16],
sw: usize,
sh: usize,
simd: bool,
) -> (Vec<u8>, Vec<u16>) {
let cw = sw / 2;
let mut rgba = vec![0u8; sw * sh * 4];
let mut rgba16 = vec![0u16; sw * sh * 4];
{
let mut sink = MixedSinker::<$M420>::new(sw, sh)
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(ChromaLocation::Top)
.with_simd(simd)
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba16)
.unwrap();
let f = $F420le::try_new(
y, u, v, a, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32, sw as u32,
)
.unwrap();
$w420(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgba, rgba16)
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn top_area_rgba_equals_rgb_domain_oracle() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
let (want_rgba, want_rgba16) =
rgba_oracle_top(&y, &u, &v, &a, sw, sh, ow, oh, true, false);
let got = run(&y, &u, &v, &a, sw, sh, ow, oh, ChromaLocation::Top, true);
assert_eq!(got.1, want_rgba, "top area rgba ({sw}x{sh}->{ow}x{oh})");
assert_eq!(got.3, want_rgba16, "top area rgba_u16 ({sw}x{sh}->{ow}x{oh})");
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn top_filter_rgba_equals_rgb_domain_oracle() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
let (want_rgba, want_rgba16) =
rgba_oracle_top(&y, &u, &v, &a, sw, sh, ow, oh, true, true);
let got = run_filter(&y, &u, &v, &a, sw, sh, ow, oh, ChromaLocation::Top, true);
assert_eq!(got.1, want_rgba, "top filter rgba ({sw}x{sh}->{ow}x{oh})");
assert_eq!(got.3, want_rgba16, "top filter rgba_u16 ({sw}x{sh}->{ow}x{oh})");
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn top_alpha_is_identical_to_cosited() {
for is_filter in [false, true] {
let (y, u, v, a) = vramp(8, 8);
let drive = |loc| {
if is_filter {
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, loc, true)
} else {
run(&y, &u, &v, &a, 8, 8, 4, 4, loc, true)
}
};
let cos = drive(ChromaLocation::Left);
let top = drive(ChromaLocation::Top);
let cos_a: Vec<u8> = cos.1.iter().skip(3).step_by(4).copied().collect();
let top_a: Vec<u8> = top.1.iter().skip(3).step_by(4).copied().collect();
assert_eq!(top_a, cos_a, "top α (u8) must equal co-sited (filter={is_filter})");
let cos_a16: Vec<u16> = cos.3.iter().skip(3).step_by(4).copied().collect();
let top_a16: Vec<u16> = top.3.iter().skip(3).step_by(4).copied().collect();
assert_eq!(top_a16, cos_a16, "top α (u16) must equal co-sited (filter={is_filter})");
assert_ne!(top.0, cos.0, "top colour must differ from co-sited (filter={is_filter})");
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn top_differs_from_center_and_bottom_on_a_vertical_chroma_ramp() {
let (y, u, v, a) = vramp(8, 8);
let cen = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, true);
let bot = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Bottom, true);
let top = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Top, true);
assert_ne!(top.3, cen.3, "top area rgba_u16 must differ from center");
assert_ne!(top.3, bot.3, "top must fold opposite to bottom");
let topf = run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Top, true);
let cenf = run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Center, true);
assert_ne!(topf.1, cenf.1, "top filter rgba must differ from center");
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn top_equals_cosited_on_flat_chroma() {
let (y, u, v, a) = flat(8, 8);
let cos = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Left, true);
let top = run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Top, true);
assert_eq!(cos.1, top.1, "flat-chroma top rgba");
assert_eq!(cos.3, top.3, "flat-chroma top rgba_u16");
assert_eq!(cos.4, top.4, "flat-chroma top hsv");
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn top_simd_matches_scalar() {
let (y, u, v, a) = ramp(8, 8);
assert_eq!(
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Top, true),
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Top, false),
"top area SIMD vs scalar must agree"
);
assert_eq!(
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Top, true),
run_filter(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Top, false),
"top filter SIMD vs scalar must agree"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn top_be_matches_le() {
let (y, u, v, a) = ramp(8, 8);
assert_eq!(
run_be(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Top),
run(&y, &u, &v, &a, 8, 8, 4, 4, ChromaLocation::Top, true),
"BE top decode must equal LE for the same logical planes"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn top_identity_resample_matches_direct_decode() {
let (y, u, v, a) = vramp(8, 8);
let res = run(&y, &u, &v, &a, 8, 8, 8, 8, ChromaLocation::Top, true);
let (drgba, drgba16) = direct_top_yuva(&y, &u, &v, &a, 8, 8, true);
assert_eq!(res.1, drgba, "identity resample top rgba == direct decode");
assert_eq!(res.3, drgba16, "identity resample top rgba_u16 == direct decode");
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn mid_frame_center_top_flip_rejected() {
let (y, u, v, a) = vramp(8, 8);
for (loc1, loc2) in [
(ChromaLocation::Center, ChromaLocation::Top),
(ChromaLocation::Top, ChromaLocation::Center),
(ChromaLocation::Top, ChromaLocation::Bottom),
] {
let mut rgba = vec![0u8; 4 * 4 * 4];
let sink =
MixedSinker::<$M420, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_rgba(&mut rgba)
.unwrap();
let err = flip_row1(sink, &y, &u, &v, &a, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"area {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
let mut rgba = vec![0u8; 4 * 4 * 4];
let sink = MixedSinker::<$M420, FilteredResampler<Triangle>>::with_resampler(
8,
8,
FilteredResampler::new(4, 4, Triangle),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_rgba(&mut rgba)
.unwrap();
let err = flip_row1(sink, &y, &u, &v, &a, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"filter {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn top_begin_frame_after_held_odd_row_no_cross_frame_leak() {
let (y, u, v, a) = vramp(8, 8);
let (sw, sh, ow, oh, cw) = (8usize, 8usize, 4usize, 4usize, 4usize);
let row_at = |r: usize| {
let cr = r / 2;
$Row::for_tests(
&y[r * sw..r * sw + sw],
&u[cr * cw..cr * cw + cw],
&v[cr * cw..cr * cw + cw],
&a[r * sw..r * sw + sw],
r,
M,
FR,
)
};
let fresh = run(&y, &u, &v, &a, sw, sh, ow, oh, ChromaLocation::Top, true).1;
let mut reused = vec![0u8; ow * oh * 4];
{
let mut sink = MixedSinker::<$M420, AreaResampler>::with_resampler(
sw,
sh,
AreaResampler::to(ow, oh),
)
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(ChromaLocation::Top)
.with_rgba(&mut reused)
.unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
PixelSink::process(&mut sink, row_at(0)).unwrap();
PixelSink::process(&mut sink, row_at(1)).unwrap();
assert!(sink.chroma_top_pending.is_some(), "row 1 must be held pending");
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
assert!(
sink.chroma_top_pending.is_none(),
"begin_frame must drop the held Top odd row (Nv21 regression class)"
);
for r in 0..sh {
PixelSink::process(&mut sink, row_at(r)).unwrap();
}
}
assert_eq!(
reused, fresh,
"the post-clear frame 2 must equal a fresh single-frame Top resample"
);
}
}
};
}
hibit_420_yuva_resample_siting!(
p10,
10,
Yuva420p10,
Yuva420p10LeFrame,
yuva420p10_to,
Yuva420p10<true>,
Yuva420p10BeFrame,
yuva420p10_to_endian,
Yuva420p10Row,
Yuva444p10,
Yuva444p10Frame,
yuva444p10_to,
Yuv420p10,
Yuv420p10Frame,
yuv420p10_to
);
hibit_420_yuva_resample_siting!(
p12,
12,
Yuva420p12,
Yuva420p12LeFrame,
yuva420p12_to,
Yuva420p12<true>,
Yuva420p12BeFrame,
yuva420p12_to_endian,
Yuva420p12Row,
Yuva444p12,
Yuva444p12Frame,
yuva444p12_to,
Yuv420p12,
Yuv420p12Frame,
yuv420p12_to
);
hibit_420_yuva_resample_siting!(
p16,
16,
Yuva420p16,
Yuva420p16LeFrame,
yuva420p16_to,
Yuva420p16<true>,
Yuva420p16BeFrame,
yuva420p16_to_endian,
Yuva420p16Row,
Yuva444p16,
Yuva444p16Frame,
yuva444p16_to,
Yuv420p16,
Yuv420p16Frame,
yuv420p16_to
);