use crate::{
ChromaLocation, KernelMatrix, PixelSink,
resample::{AreaResampler, Bicublin, FilteredResampler, ResampleError, Triangle},
sinker::{AlphaMode, MixedSinker, MixedSinkerError},
source::{Yuv422p, Yuva422p, Yuva422pRow, Yuva444p, yuv422p_to, yuva422p_to, yuva444p_to},
};
use mediaframe::frame::{Yuv422pFrame, Yuva422pFrame, Yuva444pFrame};
const M: KernelMatrix = KernelMatrix::Bt601;
const FR: bool = true;
fn recon_full_row_u8(c: &[u8], cw: usize) -> Vec<u8> {
let mut out = vec![0u8; 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 u8;
out[2 * j + 1] = ((3 * m + r + 2) >> 2) as u8;
}
out
}
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<u8>, Vec<u8>, Vec<u8>),
Vec<u8>,
Vec<u16>,
);
type YuvOuts = (Vec<u8>, (Vec<u8>, Vec<u8>, Vec<u8>), Vec<u8>, Vec<u16>);
fn ramp(sw: usize, sh: usize) -> (Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let mut y = vec![0u8; sw * sh];
let mut u = vec![0u8; cw * sh];
let mut v = vec![0u8; cw * sh];
let mut a = vec![0u8; sw * sh];
for (i, p) in y.iter_mut().enumerate() {
*p = 40 + ((i as u32 * 3) % 160) as u8;
}
for r in 0..sh {
for c in 0..cw {
u[r * cw + c] = (30 + c * 44 + r * 4).min(240) as u8;
v[r * cw + c] = (230u32.saturating_sub((c * 44 + r * 4) as u32)).max(16) as u8;
}
}
for (i, p) in a.iter_mut().enumerate() {
*p = 20 + ((i as u32 * 11) % 220) as u8;
}
(y, u, v, a)
}
fn flat(sw: usize, sh: usize) -> (Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let mut y = vec![0u8; sw * sh];
let mut a = vec![0u8; sw * sh];
for (i, p) in y.iter_mut().enumerate() {
*p = 40 + ((i as u32 * 7) % 170) as u8;
}
for (i, p) in a.iter_mut().enumerate() {
*p = 30 + ((i as u32 * 13) % 200) as u8;
}
(y, vec![110u8; cw * sh], vec![140u8; cw * sh], a)
}
#[allow(clippy::too_many_arguments)]
fn run(
y: &[u8],
u: &[u8],
v: &[u8],
a: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
simd: bool,
) -> Outs {
let cw = sw / 2;
let mut rgb = vec![0u8; ow * oh * 3];
let mut rgba = vec![0u8; ow * oh * 4];
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 luma16 = vec![0u16; ow * oh];
{
let mut sink =
MixedSinker::<Yuva422p, 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_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma16)
.unwrap();
let f = Yuva422pFrame::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();
yuva422p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, (hh, ss, vv), luma, luma16)
}
#[allow(clippy::too_many_arguments)]
fn run_filter(
y: &[u8],
u: &[u8],
v: &[u8],
a: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
simd: bool,
) -> Outs {
let cw = sw / 2;
let mut rgb = vec![0u8; ow * oh * 3];
let mut rgba = vec![0u8; ow * oh * 4];
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 luma16 = vec![0u16; ow * oh];
{
let mut sink = MixedSinker::<Yuva422p, 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_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma16)
.unwrap();
let f = Yuva422pFrame::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();
yuva422p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, (hh, ss, vv), luma, luma16)
}
#[allow(clippy::too_many_arguments)]
fn rgba_oracle(
y: &[u8],
u: &[u8],
v: &[u8],
a: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
filter: bool,
) -> Vec<u8> {
let cw = sw / 2;
let mut uf = vec![0u8; sw * sh];
let mut vf = vec![0u8; sw * sh];
for r in 0..sh {
uf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row_u8(&u[r * cw..r * cw + cw], cw));
vf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row_u8(&v[r * cw..r * cw + cw], cw));
}
let mut rgba = vec![0u8; ow * oh * 4];
let f = Yuva444pFrame::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::<Yuva444p, 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();
yuva444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
} else {
let mut sink =
MixedSinker::<Yuva444p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_simd(simd)
.with_rgba(&mut rgba)
.unwrap();
yuva444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgba
}
#[allow(clippy::too_many_arguments)]
fn run_yuv(
y: &[u8],
u: &[u8],
v: &[u8],
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 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 luma16 = vec![0u16; ow * oh];
{
let mut sink =
MixedSinker::<Yuv422p, 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_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma16)
.unwrap();
let f = Yuv422pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv422p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, (hh, ss, vv), luma, luma16)
}
#[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::TopLeft,
ChromaLocation::BottomLeft,
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_oracle(&y, &u, &v, &a, sw, sh, ow, oh, true, false);
for loc in [ChromaLocation::Center, ChromaLocation::Top] {
let got = run(&y, &u, &v, &a, sw, sh, ow, oh, loc.clone(), true);
assert_eq!(
got.1, want,
"centered area rgba {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_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, "centered filter rgba ({sw}x{sh}->{ow}x{oh})");
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn centered_chroma_matches_yuv422p_centered() {
for (sw, sh, ow, oh) in GEOMS {
let (y, u, v, a) = ramp(sw, sh);
for loc in [ChromaLocation::Center, ChromaLocation::Top] {
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, "hsv {loc:?} ({sw}x{sh}->{ow}x{oh})");
assert_eq!(ya.3, yv.2, "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}"
);
}
}
}
}
#[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 α 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.1, cen.1,
"centered rgba 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.2, cen.2, "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"
);
}
fn flip_row1<R>(
mut sink: MixedSinker<'_, Yuva422p, R>,
y: &[u8],
u: &[u8],
v: &[u8],
a: &[u8],
loc1: ChromaLocation,
loc2: ChromaLocation,
) -> Result<(), MixedSinkerError> {
sink.set_chroma_location(loc1.clone());
PixelSink::begin_frame(&mut sink, 8, 8).unwrap();
let row0 = Yuva422pRow::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 = Yuva422pRow::for_tests(&y[8..16], &u[4..8], &v[4..8], &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::<Yuva422p, 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 hh, mut ss, mut vv) = (vec![0u8; 4 * 4], vec![0u8; 4 * 4], vec![0u8; 4 * 4]);
let sink =
MixedSinker::<Yuva422p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
let err = flip_row1(sink, &y, &u, &v, &a, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"hsv {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
let mut rgba = vec![0u8; 4 * 4 * 4];
let sink = MixedSinker::<Yuva422p, 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 out_of_sequence_centered_first_row_is_rejected_before_the_chroma_reserve() {
let (y, u, v, a) = ramp(8, 8);
let cw = 4usize;
let mut rgb = vec![0u8; 4 * 4 * 3];
let mut sink =
MixedSinker::<Yuva422p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_chroma_location(ChromaLocation::Center)
.with_rgb(&mut rgb)
.unwrap();
PixelSink::begin_frame(&mut sink, 8, 8).unwrap();
super::super::arm_chroma_full_alloc_failure();
let bad = Yuva422pRow::for_tests(
&y[5 * 8..6 * 8],
&u[5 * cw..6 * cw],
&v[5 * cw..6 * cw],
&a[5 * 8..6 * 8],
5,
M,
FR,
);
let err = PixelSink::process(&mut sink, bad).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::OutOfSequenceRow(_))
),
"out-of-sequence centered first row must be OutOfSequenceRow (reserve unreached), got {err:?}"
);
assert_eq!(
sink.chroma_full.len(),
0,
"a rejected row must allocate no chroma scratch"
);
let good = Yuva422pRow::for_tests(&y[0..8], &u[0..cw], &v[0..cw], &a[0..8], 0, M, FR);
let err0 = PixelSink::process(&mut sink, good).unwrap_err();
assert!(
matches!(
err0,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"a valid centered row reaches the reserve (failpoint fires), got {err0:?}"
);
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn luma_only_centered_area_does_not_reserve_chroma() {
let (y, u, v, a) = ramp(8, 8);
let cw = 4usize;
let mut luma = vec![0u8; 4 * 4];
{
let mut sink =
MixedSinker::<Yuva422p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_chroma_location(ChromaLocation::Center)
.with_luma(&mut luma)
.unwrap();
PixelSink::begin_frame(&mut sink, 8, 8).unwrap();
super::super::arm_chroma_full_alloc_failure();
for r in 0..8 {
let row = Yuva422pRow::for_tests(
&y[r * 8..r * 8 + 8],
&u[r * cw..r * cw + cw],
&v[r * cw..r * cw + cw],
&a[r * 8..r * 8 + 8],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
assert_eq!(
sink.chroma_full.len(),
0,
"luma-only centered resample must never reserve chroma scratch"
);
}
let mut rgb = vec![0u8; 4 * 4 * 3];
let mut sink =
MixedSinker::<Yuva422p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_chroma_location(ChromaLocation::Center)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuva422pFrame::try_new(&y, &u, &v, &a, 8, 8, 8, cw as u32, cw as u32, 8).unwrap();
let _ = yuva422p_to(&f, FR, sink.set_kernel_matrix(M));
}
#[test]
#[cfg_attr(miri, ignore = "SIMD row kernels use intrinsics unsupported by Miri")]
fn centered_filter_bicublin_rejected_before_the_chroma_reserve() {
let (y, u, v, a) = ramp(8, 8);
let cw = 4usize;
let mut rgba = vec![0u8; 4 * 4 * 4];
let mut sink = MixedSinker::<Yuva422p, Bicublin>::with_resampler(8, 8, Bicublin::to(4, 4))
.unwrap()
.with_alpha_mode(AlphaMode::Straight)
.with_chroma_location(ChromaLocation::Center)
.with_rgba(&mut rgba)
.unwrap();
let f = Yuva422pFrame::try_new(&y, &u, &v, &a, 8, 8, 8, cw as u32, cw as u32, 8).unwrap();
super::super::arm_chroma_full_alloc_failure();
let err = yuva422p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::UnsupportedFilter(_))
),
"a BICUBLIN filter plan must be UnsupportedFilter (reserve unreached), got {err:?}"
);
assert_eq!(
sink.chroma_full.len(),
0,
"a rejected filter plan allocates no chroma scratch"
);
let mut rgb = vec![0u8; 4 * 4 * 3];
let mut consume =
MixedSinker::<Yuva422p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_chroma_location(ChromaLocation::Center)
.with_rgb(&mut rgb)
.unwrap();
let cf = Yuva422pFrame::try_new(&y, &u, &v, &a, 8, 8, 8, cw as u32, cw as u32, 8).unwrap();
let _ = yuva422p_to(&cf, FR, consume.set_kernel_matrix(M));
}