use crate::{
ChromaLocation, KernelMatrix, PixelSink,
resample::AreaResampler,
sinker::{MixedSinker, MixedSinkerError},
source::{
Uyyvyy411, Uyyvyy411Row, Yuv410p, Yuv410pRow, Yuv411p, Yuv411pRow, Yuv444p, uyyvyy411_to,
yuv410p_to, yuv411p_to, yuv444p_to,
},
};
use mediaframe::frame::{Uyyvyy411Frame, Yuv410pFrame, Yuv411pFrame, Yuv444pFrame};
const M: KernelMatrix = KernelMatrix::Bt601;
const FR: bool = true;
fn rdhu(a: u64, d: u64) -> u64 {
let q = a / d;
let r = a % d;
q + u64::from(r >= d - d / 2)
}
fn area_weights(src: usize, out: usize) -> Vec<(usize, Vec<u64>)> {
let (src64, out64) = (src as u64, out as u64);
(0..out)
.map(|o| {
let lo = o as u64 * src64;
let hi = lo + src64;
let start = (lo / out64) as usize;
let mut w = Vec::new();
let mut i = start as u64;
loop {
let clo = i * out64;
if clo >= hi {
break;
}
let chi = clo + out64;
let ov = chi.min(hi) - clo.max(lo);
if ov == 0 {
break;
}
w.push(ov);
if chi >= hi {
break;
}
i += 1;
}
(start, w)
})
.collect()
}
fn area_subsampled_weights(src_full: usize, out: usize, f: usize) -> Vec<(usize, Vec<u64>)> {
let (src64, out64, f64_) = (src_full as u64, out as u64, f as u64);
let cells = src_full.div_ceil(f);
(0..out)
.map(|o| {
let lo = o as u64 * src64;
let hi = lo + src64;
let start = ((lo / out64) / f64_) as usize;
let mut w = Vec::new();
let mut c = start as u64;
loop {
let clo = (f64_ * c) * out64;
let chi = ((f64_ * c + f64_).min(src64)) * out64;
if clo >= hi {
break;
}
let ov = chi.min(hi) - clo.max(lo);
if ov == 0 {
break;
}
w.push(ov);
if chi >= hi || c as usize + 1 >= cells {
break;
}
c += 1;
}
(start, w)
})
.collect()
}
fn bin_cosited(plane: &[u8], sw: usize, sh: usize, ow: usize, oh: usize) -> Vec<u8> {
let hw = area_weights(sw, ow);
let vw = area_weights(sh, oh);
let denom = (sw * sh) as u64;
let mut out = vec![0u8; ow * oh];
for (oy, (vs, vwin)) in vw.iter().enumerate() {
for (ox, (hs, hwin)) in hw.iter().enumerate() {
let mut s = 0u64;
for (dy, &vwt) in vwin.iter().enumerate() {
let mut hsum = 0u64;
for (dx, &hwt) in hwin.iter().enumerate() {
hsum += hwt * u64::from(plane[(vs + dy) * sw + hs + dx]);
}
s += vwt * hsum;
}
out[oy * ow + ox] = rdhu(s, denom) as u8;
}
}
out
}
fn ref_upsample_4to1_center_h(cq: &[u8], width: usize) -> Vec<u8> {
let quarter = width.div_ceil(4);
let mut out = vec![0u8; width];
for j in 0..quarter {
let l = i32::from(cq[j.saturating_sub(1)]);
let m = i32::from(cq[j]);
let r = i32::from(cq[if j + 1 < quarter { j + 1 } else { j }]);
let base = 4 * j;
if base < width {
out[base] = ((3 * l + 5 * m + 4) >> 3) as u8;
}
if base + 1 < width {
out[base + 1] = ((l + 7 * m + 4) >> 3) as u8;
}
if base + 2 < width {
out[base + 2] = ((7 * m + r + 4) >> 3) as u8;
}
if base + 3 < width {
out[base + 3] = ((5 * m + 3 * r + 4) >> 3) as u8;
}
}
out
}
fn bin_chroma_411x_centered(
cq: &[u8],
luma_w: usize,
ch: usize,
vw: &[(usize, Vec<u64>)],
v_denom: usize,
ow: usize,
oh: usize,
) -> Vec<u8> {
let cw = luma_w.div_ceil(4);
let mut r8 = vec![0u32; luma_w * ch];
for r in 0..ch {
let row = &cq[r * cw..r * cw + cw];
for j in 0..cw {
let l = u32::from(row[j.saturating_sub(1)]);
let m = u32::from(row[j]);
let rt = u32::from(row[if j + 1 < cw { j + 1 } else { j }]);
let base = 4 * j;
if base < luma_w {
r8[r * luma_w + base] = 3 * l + 5 * m;
}
if base + 1 < luma_w {
r8[r * luma_w + base + 1] = l + 7 * m;
}
if base + 2 < luma_w {
r8[r * luma_w + base + 2] = 7 * m + rt;
}
if base + 3 < luma_w {
r8[r * luma_w + base + 3] = 5 * m + 3 * rt;
}
}
}
let hw = area_weights(luma_w, ow);
let denom = (8 * luma_w * v_denom) as u64;
let mut out = vec![0u8; ow * oh];
for (oy, (vs, vwin)) in vw.iter().enumerate() {
for (ox, (hs, hwin)) in hw.iter().enumerate() {
let mut s = 0u64;
for (dy, &vwt) in vwin.iter().enumerate() {
let mut hsum = 0u64;
for (dx, &hwt) in hwin.iter().enumerate() {
hsum += hwt * u64::from(r8[(vs + dy) * luma_w + hs + dx]);
}
s += vwt * hsum;
}
out[oy * ow + ox] = rdhu(s, denom) as u8;
}
}
out
}
fn bin_rgb(rgb: &[u8], sw: usize, sh: usize, ow: usize, oh: usize) -> Vec<u8> {
let hw = area_weights(sw, ow);
let vw = area_weights(sh, oh);
let denom = (sw * sh) as u64;
let mut out = vec![0u8; ow * oh * 3];
for (oy, (vs, vwin)) in vw.iter().enumerate() {
for (ox, (hs, hwin)) in hw.iter().enumerate() {
for ch in 0..3 {
let mut s = 0u64;
for (dy, &vwt) in vwin.iter().enumerate() {
let mut hsum = 0u64;
for (dx, &hwt) in hwin.iter().enumerate() {
hsum += hwt * u64::from(rgb[((vs + dy) * sw + hs + dx) * 3 + ch]);
}
s += vwt * hsum;
}
out[(oy * ow + ox) * 3 + ch] = rdhu(s, denom) as u8;
}
}
}
out
}
fn ramp_411(w: usize, h: usize) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = w.div_ceil(4);
let mut y = vec![0u8; w * h];
for (i, p) in y.iter_mut().enumerate() {
*p = (32 + (i % 96)) as u8;
}
let mut u = vec![0u8; cw * h];
let mut v = vec![0u8; cw * h];
for r in 0..h {
for c in 0..cw {
u[r * cw + c] = (16 + c * 40 + r * 5).min(240) as u8;
v[r * cw + c] = (240 - c * 40).max(16) as u8;
}
}
(y, u, v)
}
fn id_411(w: usize, h: usize, loc: ChromaLocation, simd: bool) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = w.div_ceil(4);
let (yp, up, vp) = ramp_411(w, h);
let mut rgb = vec![0u8; w * h * 3];
let (mut hh, mut ss, mut vv) = (vec![0u8; w * h], vec![0u8; w * h], vec![0u8; w * h]);
let mut luma = vec![0u8; w * h];
{
let f = Yuv411pFrame::new(
&yp, &up, &vp, w as u32, h as u32, w as u32, cw as u32, cw as u32,
);
let mut sink = MixedSinker::<Yuv411p>::new(w, h)
.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();
yuv411p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
let hsv: Vec<u8> = hh.iter().chain(&ss).chain(&vv).copied().collect();
(rgb, hsv, luma)
}
#[allow(clippy::too_many_arguments)]
fn rs_411(
w: usize,
h: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
simd: bool,
color: bool,
) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = w.div_ceil(4);
let (yp, up, vp) = ramp_411(w, h);
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 f = Yuv411pFrame::new(
&yp, &up, &vp, w as u32, h as u32, w as u32, cw as u32, cw as u32,
);
let mut sink =
MixedSinker::<Yuv411p, AreaResampler>::with_resampler(w, h, AreaResampler::to(ow, oh))
.unwrap()
.with_chroma_location(loc.clone())
.with_simd(simd);
if color {
sink = sink.with_rgb(&mut rgb).unwrap();
}
let mut sink = sink
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap();
yuv411p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
let hsv: Vec<u8> = hh.iter().chain(&ss).chain(&vv).copied().collect();
(rgb, hsv, luma)
}
fn id_411_oracle(w: usize, h: usize) -> (Vec<u8>, Vec<u8>) {
let cw = w.div_ceil(4);
let (yp, up, vp) = ramp_411(w, h);
let mut u444 = vec![0u8; w * h];
let mut v444 = vec![0u8; w * h];
for r in 0..h {
let ur = ref_upsample_4to1_center_h(&up[r * cw..r * cw + cw], w);
let vr = ref_upsample_4to1_center_h(&vp[r * cw..r * cw + cw], w);
u444[r * w..r * w + w].copy_from_slice(&ur);
v444[r * w..r * w + w].copy_from_slice(&vr);
}
yuv444_decode(&yp, &u444, &v444, w, h)
}
fn yuv444_decode(y: &[u8], u: &[u8], v: &[u8], w: usize, h: usize) -> (Vec<u8>, Vec<u8>) {
let mut rgb = vec![0u8; w * h * 3];
let (mut hh, mut ss, mut vv) = (vec![0u8; w * h], vec![0u8; w * h], vec![0u8; w * h]);
{
let f = Yuv444pFrame::new(y, u, v, w as u32, h as u32, w as u32, w as u32, w as u32);
let mut sink = MixedSinker::<Yuv444p>::new(w, h)
.with_rgb(&mut rgb)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
let hsv: Vec<u8> = hh.iter().chain(&ss).chain(&vv).copied().collect();
(rgb, hsv)
}
const CENTERED: [ChromaLocation; 3] = [
ChromaLocation::Center,
ChromaLocation::Top,
ChromaLocation::Bottom,
];
fn cosited() -> [ChromaLocation; 5] {
[
ChromaLocation::Unspecified,
ChromaLocation::Left,
ChromaLocation::TopLeft,
ChromaLocation::BottomLeft,
ChromaLocation::other("unassigned-99"),
]
}
#[test]
fn kernel_4to1_matches_hand_computed() {
let cq = [0u8, 0, 100, 100];
let mut out = [0u8; 16];
crate::row::scalar::chroma_upsample_4to1_center_h(&cq, &mut out, 16);
assert_eq!(
out,
[
0, 0, 0, 0, 0, 0, 13, 38, 63, 88, 100, 100, 100, 100, 100, 100
]
);
}
#[test]
fn kernel_4to1_flat_input_is_flat() {
let cq = [77u8; 5];
let mut out = [0u8; 20];
crate::row::scalar::chroma_upsample_4to1_center_h(&cq, &mut out, 20);
assert!(out.iter().all(|&x| x == 77));
}
#[test]
fn kernel_4to1_non_multiple_of_4_width_writes_only_real_columns() {
let cq = [10u8, 200];
let mut out = [255u8; 6];
crate::row::scalar::chroma_upsample_4to1_center_h(&cq, &mut out, 6);
assert_eq!(out[4], ((3 * 10 + 5 * 200 + 4) >> 3) as u8);
assert_eq!(out[5], ((10 + 7 * 200 + 4) >> 3) as u8);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_411_cosited_is_byte_identical() {
let base = id_411(16, 6, ChromaLocation::Unspecified, true);
for loc in cosited() {
assert_eq!(id_411(16, 6, loc.clone(), true), base, "siting {loc:?}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_411_centered_differs_from_cosited() {
let cos = id_411(16, 6, ChromaLocation::Left, true);
for loc in CENTERED {
let cen = id_411(16, 6, loc.clone(), true);
assert_ne!(
cen.0, cos.0,
"centered rgb {loc:?} must differ from co-sited"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_411_centered_equals_reconstruct_444_oracle() {
for (w, h) in [(16usize, 6usize), (12, 4), (20, 5)] {
let (rgb_o, hsv_o) = id_411_oracle(w, h);
for loc in CENTERED {
let (rgb, hsv, _) = id_411(w, h, loc.clone(), true);
assert_eq!(rgb, rgb_o, "rgb {loc:?} {w}x{h}");
assert_eq!(hsv, hsv_o, "hsv {loc:?} {w}x{h}");
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_411_centered_simd_matches_scalar() {
let s = id_411(16, 6, ChromaLocation::Center, false);
let d = id_411(16, 6, ChromaLocation::Center, true);
assert_eq!(s.0, d.0, "rgb simd vs scalar");
assert_eq!(s.2, d.2, "luma simd vs scalar");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_411_cosited_is_byte_identical() {
let base = rs_411(16, 8, 4, 4, ChromaLocation::Unspecified, true, true);
for loc in cosited() {
assert_eq!(
rs_411(16, 8, 4, 4, loc.clone(), true, true),
base,
"resample siting {loc:?}"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_411_centered_differs_from_cosited() {
let cos = rs_411(16, 8, 4, 4, ChromaLocation::Left, true, true);
let cen = rs_411(16, 8, 4, 4, ChromaLocation::Center, true, true);
assert_ne!(cen.0, cos.0, "centered resample rgb must differ");
assert_eq!(cen.2, cos.2, "luma must be siting-independent");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_411_hsv_direct_centered_equals_folded_oracle() {
for (w, h, ow, oh) in [(16usize, 8usize, 4usize, 4usize), (16, 10, 7, 6)] {
let cw = w.div_ceil(4);
let (yp, up, vp) = ramp_411(w, h);
let (_, hsv, luma) = rs_411(w, h, ow, oh, ChromaLocation::Center, true, false);
let vw = area_weights(h, oh);
let yb = bin_cosited(&yp, w, h, ow, oh);
let ub = bin_chroma_411x_centered(&up, w, h, &vw, h, ow, oh);
let vb = bin_chroma_411x_centered(&vp, w, h, &vw, h, ow, oh);
let (_, hsv_o) = yuv444_decode(&yb, &ub, &vb, ow, oh);
assert_eq!(luma, yb, "luma {w}x{h}->{ow}x{oh}");
assert_eq!(hsv, hsv_o, "hsv-direct {w}x{h}->{ow}x{oh}");
let _ = cw;
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_411_centered_rgb_equals_reconstruct_then_bin() {
for (w, h, ow, oh) in [(16usize, 8usize, 4usize, 4usize), (16, 10, 7, 6)] {
let full = id_411(w, h, ChromaLocation::Center, true).0;
let oracle = bin_rgb(&full, w, h, ow, oh);
let rgb = rs_411(w, h, ow, oh, ChromaLocation::Center, true, true).0;
assert_eq!(
rgb, oracle,
"row-stage rgb == reconstruct-then-bin {w}x{h}->{ow}x{oh}"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_411_centered_simd_matches_scalar() {
let s = rs_411(16, 8, 4, 4, ChromaLocation::Center, false, true);
let d = rs_411(16, 8, 4, 4, ChromaLocation::Center, true, true);
assert_eq!(s.0, d.0, "rgb simd vs scalar");
assert_eq!(s.1, d.1, "hsv simd vs scalar");
assert_eq!(s.2, d.2, "luma simd vs scalar");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_411_mid_frame_siting_flip_is_rejected() {
let (yp, up, vp) = ramp_411(16, 8);
let cw = 4usize;
let (mut hh, mut ss, mut vv) = (vec![0u8; 16], vec![0u8; 16], vec![0u8; 16]);
let mut sink =
MixedSinker::<Yuv411p, AreaResampler>::with_resampler(16, 8, AreaResampler::to(4, 4))
.unwrap()
.with_chroma_location(ChromaLocation::Center)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
PixelSink::begin_frame(&mut sink, 16, 8).unwrap();
for r in 0..2 {
let row = Yuv411pRow::for_tests(
&yp[r * 16..r * 16 + 16],
&up[r * cw..r * cw + cw],
&vp[r * cw..r * cw + cw],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
sink.set_chroma_location(ChromaLocation::Left);
let bad = Yuv411pRow::for_tests(
&yp[2 * 16..3 * 16],
&up[2 * cw..3 * cw],
&vp[2 * cw..3 * cw],
2,
M,
FR,
);
let err = PixelSink::process(&mut sink, bad).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"mid-frame siting flip must be ChromaSitingChanged, got {err:?}"
);
PixelSink::begin_frame(&mut sink, 16, 8).unwrap();
for r in 0..8 {
let row = Yuv411pRow::for_tests(
&yp[r * 16..r * 16 + 16],
&up[r * cw..r * cw + cw],
&vp[r * cw..r * cw + cw],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_411_mid_frame_siting_flip_is_rejected() {
let (w, h) = (16usize, 8usize);
let cw = w.div_ceil(4);
let (yp, up, vp) = ramp_411(w, h);
let mut rgb = vec![0u8; w * h * 3];
let (mut hh, mut ss, mut vv) = (vec![0u8; w * h], vec![0u8; w * h], vec![0u8; w * h]);
let mut luma = vec![0u8; w * h];
{
let mut sink = MixedSinker::<Yuv411p>::new(w, h)
.with_chroma_location(ChromaLocation::Center)
.with_simd(true)
.with_rgb(&mut rgb)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap();
PixelSink::begin_frame(&mut sink, w as u32, h as u32).unwrap();
for r in 0..2 {
let row = Yuv411pRow::for_tests(
&yp[r * w..r * w + w],
&up[r * cw..r * cw + cw],
&vp[r * cw..r * cw + cw],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
sink.set_chroma_location(ChromaLocation::Left);
let bad = Yuv411pRow::for_tests(
&yp[2 * w..3 * w],
&up[2 * cw..3 * cw],
&vp[2 * cw..3 * cw],
2,
M,
FR,
);
let err = PixelSink::process(&mut sink, bad).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"411 identity mid-frame flip must be ChromaSitingChanged, got {err:?}"
);
sink.set_chroma_location(ChromaLocation::Center);
for r in 2..h {
let row = Yuv411pRow::for_tests(
&yp[r * w..r * w + w],
&up[r * cw..r * cw + cw],
&vp[r * cw..r * cw + cw],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
}
let hsv: Vec<u8> = hh.iter().chain(&ss).chain(&vv).copied().collect();
let (want_rgb, want_hsv, want_luma) = id_411(w, h, ChromaLocation::Center, true);
assert_eq!(rgb, want_rgb, "411 identity rgb after rejected flip");
assert_eq!(hsv, want_hsv, "411 identity hsv after rejected flip");
assert_eq!(luma, want_luma, "411 identity luma after rejected flip");
}
fn ramp_410(w: usize, h: usize) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = w / 4;
let ch = h.div_ceil(4);
let mut y = vec![0u8; w * h];
for (i, p) in y.iter_mut().enumerate() {
*p = (40 + (i % 100)) as u8;
}
let mut u = vec![0u8; cw * ch];
let mut v = vec![0u8; cw * ch];
for r in 0..ch {
for c in 0..cw {
u[r * cw + c] = (20 + c * 44 + r * 7).min(240) as u8;
v[r * cw + c] = (230 - c * 44).max(16) as u8;
}
}
(y, u, v)
}
fn id_410(w: usize, h: usize, loc: ChromaLocation, simd: bool) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = (w / 4) as u32;
let (yp, up, vp) = ramp_410(w, h);
let mut rgb = vec![0u8; w * h * 3];
let (mut hh, mut ss, mut vv) = (vec![0u8; w * h], vec![0u8; w * h], vec![0u8; w * h]);
let mut luma = vec![0u8; w * h];
{
let f = Yuv410pFrame::new(&yp, &up, &vp, w as u32, h as u32, w as u32, cw, cw);
let mut sink = MixedSinker::<Yuv410p>::new(w, h)
.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();
yuv410p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
let hsv: Vec<u8> = hh.iter().chain(&ss).chain(&vv).copied().collect();
(rgb, hsv, luma)
}
fn id_410_oracle(w: usize, h: usize) -> (Vec<u8>, Vec<u8>) {
let cw = w / 4;
let (yp, up, vp) = ramp_410(w, h);
let mut u444 = vec![0u8; w * h];
let mut v444 = vec![0u8; w * h];
for r in 0..h {
let cr = r / 4;
let ur = ref_upsample_4to1_center_h(&up[cr * cw..cr * cw + cw], w);
let vr = ref_upsample_4to1_center_h(&vp[cr * cw..cr * cw + cw], w);
u444[r * w..r * w + w].copy_from_slice(&ur);
v444[r * w..r * w + w].copy_from_slice(&vr);
}
yuv444_decode(&yp, &u444, &v444, w, h)
}
#[allow(clippy::too_many_arguments)]
fn rs_410(
w: usize,
h: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
simd: bool,
color: bool,
) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = (w / 4) as u32;
let (yp, up, vp) = ramp_410(w, h);
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 f = Yuv410pFrame::new(&yp, &up, &vp, w as u32, h as u32, w as u32, cw, cw);
let mut sink =
MixedSinker::<Yuv410p, AreaResampler>::with_resampler(w, h, AreaResampler::to(ow, oh))
.unwrap()
.with_chroma_location(loc.clone())
.with_simd(simd);
if color {
sink = sink.with_rgb(&mut rgb).unwrap();
}
let mut sink = sink
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap();
yuv410p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
let hsv: Vec<u8> = hh.iter().chain(&ss).chain(&vv).copied().collect();
(rgb, hsv, luma)
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_410_cosited_is_byte_identical() {
let base = id_410(16, 8, ChromaLocation::Unspecified, true);
for loc in cosited() {
assert_eq!(id_410(16, 8, loc.clone(), true), base, "410 siting {loc:?}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_410_centered_equals_reconstruct_444_oracle() {
for (w, h) in [(16usize, 8usize), (12, 8), (20, 12)] {
let (rgb_o, hsv_o) = id_410_oracle(w, h);
for loc in CENTERED {
let (rgb, hsv, _) = id_410(w, h, loc.clone(), true);
assert_eq!(rgb, rgb_o, "410 rgb {loc:?} {w}x{h}");
assert_eq!(hsv, hsv_o, "410 hsv {loc:?} {w}x{h}");
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_410_centered_simd_matches_scalar() {
let s = id_410(16, 8, ChromaLocation::Center, false);
let d = id_410(16, 8, ChromaLocation::Center, true);
assert_eq!(s.0, d.0, "410 rgb simd vs scalar");
assert_eq!(s.2, d.2, "410 luma simd vs scalar");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_410_cosited_is_byte_identical() {
let base = rs_410(16, 8, 4, 2, ChromaLocation::Unspecified, true, true);
for loc in cosited() {
assert_eq!(
rs_410(16, 8, 4, 2, loc.clone(), true, true),
base,
"410 resample siting {loc:?}"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_410_hsv_direct_centered_equals_folded_oracle() {
for (w, h, ow, oh) in [(16usize, 8usize, 4usize, 2usize), (16, 12, 3, 2)] {
let (yp, up, vp) = ramp_410(w, h);
let ch = h.div_ceil(4);
let (_, hsv, luma) = rs_410(w, h, ow, oh, ChromaLocation::Center, true, false);
let vw = area_subsampled_weights(h, oh, 4);
let yb = bin_cosited(&yp, w, h, ow, oh);
let ub = bin_chroma_411x_centered(&up, w, ch, &vw, h, ow, oh);
let vb = bin_chroma_411x_centered(&vp, w, ch, &vw, h, ow, oh);
let (_, hsv_o) = yuv444_decode(&yb, &ub, &vb, ow, oh);
assert_eq!(luma, yb, "410 luma {w}x{h}->{ow}x{oh}");
assert_eq!(hsv, hsv_o, "410 hsv-direct {w}x{h}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_410_centered_differs_and_simd_matches_scalar() {
let cos = rs_410(16, 8, 4, 2, ChromaLocation::Left, true, true);
let cen = rs_410(16, 8, 4, 2, ChromaLocation::Center, true, true);
assert_ne!(cen.0, cos.0, "410 centered resample must differ");
let cen_s = rs_410(16, 8, 4, 2, ChromaLocation::Center, false, true);
assert_eq!(cen.0, cen_s.0, "410 centered resample simd vs scalar");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn rs_410_mid_frame_siting_flip_is_rejected() {
let (yp, up, vp) = ramp_410(16, 8);
let cw = 4usize;
let (mut hh, mut ss, mut vv) = (vec![0u8; 8], vec![0u8; 8], vec![0u8; 8]);
let mut sink =
MixedSinker::<Yuv410p, AreaResampler>::with_resampler(16, 8, AreaResampler::to(4, 2))
.unwrap()
.with_chroma_location(ChromaLocation::Center)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
PixelSink::begin_frame(&mut sink, 16, 8).unwrap();
for r in 0..2 {
let cr = r / 4;
let row = Yuv410pRow::for_tests(
&yp[r * 16..r * 16 + 16],
&up[cr * cw..cr * cw + cw],
&vp[cr * cw..cr * cw + cw],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
sink.set_chroma_location(ChromaLocation::Left);
let bad = Yuv410pRow::for_tests(&yp[2 * 16..3 * 16], &up[0..cw], &vp[0..cw], 2, M, FR);
let err = PixelSink::process(&mut sink, bad).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"410 mid-frame flip must be ChromaSitingChanged, got {err:?}"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_410_mid_frame_siting_flip_is_rejected() {
let (w, h) = (16usize, 8usize);
let cw = w / 4;
let (yp, up, vp) = ramp_410(w, h);
let mut rgb = vec![0u8; w * h * 3];
let (mut hh, mut ss, mut vv) = (vec![0u8; w * h], vec![0u8; w * h], vec![0u8; w * h]);
let mut luma = vec![0u8; w * h];
{
let mut sink = MixedSinker::<Yuv410p>::new(w, h)
.with_chroma_location(ChromaLocation::Center)
.with_simd(true)
.with_rgb(&mut rgb)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap();
PixelSink::begin_frame(&mut sink, w as u32, h as u32).unwrap();
for r in 0..2 {
let cr = r / 4;
let row = Yuv410pRow::for_tests(
&yp[r * w..r * w + w],
&up[cr * cw..cr * cw + cw],
&vp[cr * cw..cr * cw + cw],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
sink.set_chroma_location(ChromaLocation::Left);
let bad = Yuv410pRow::for_tests(&yp[2 * w..3 * w], &up[0..cw], &vp[0..cw], 2, M, FR);
let err = PixelSink::process(&mut sink, bad).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"410 identity mid-frame flip must be ChromaSitingChanged, got {err:?}"
);
sink.set_chroma_location(ChromaLocation::Center);
for r in 2..h {
let cr = r / 4;
let row = Yuv410pRow::for_tests(
&yp[r * w..r * w + w],
&up[cr * cw..cr * cw + cw],
&vp[cr * cw..cr * cw + cw],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
}
let hsv: Vec<u8> = hh.iter().chain(&ss).chain(&vv).copied().collect();
let (want_rgb, want_hsv, want_luma) = id_410(w, h, ChromaLocation::Center, true);
assert_eq!(rgb, want_rgb, "410 identity rgb after rejected flip");
assert_eq!(hsv, want_hsv, "410 identity hsv after rejected flip");
assert_eq!(luma, want_luma, "410 identity luma after rejected flip");
}
fn uyyvyy411_from(y: &[u8], u: &[u8], v: &[u8], w: usize, h: usize) -> Vec<u8> {
assert_eq!(w & 3, 0, "uyyvyy411 width must be a multiple of 4");
let cw = w / 4;
let mut buf = vec![0u8; w * 3 / 2 * h];
for row in 0..h {
let base = row * w * 3 / 2;
for cx in 0..cw {
let blk = base + cx * 6;
buf[blk] = u[row * cw + cx];
buf[blk + 1] = y[row * w + cx * 4];
buf[blk + 2] = y[row * w + cx * 4 + 1];
buf[blk + 3] = v[row * cw + cx];
buf[blk + 4] = y[row * w + cx * 4 + 2];
buf[blk + 5] = y[row * w + cx * 4 + 3];
}
}
buf
}
fn id_packed(w: usize, h: usize, loc: ChromaLocation, simd: bool) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let (yp, up, vp) = ramp_411(w, h);
let packed = uyyvyy411_from(&yp, &up, &vp, w, h);
let mut rgb = vec![0u8; w * h * 3];
let (mut hh, mut ss, mut vv) = (vec![0u8; w * h], vec![0u8; w * h], vec![0u8; w * h]);
let mut luma = vec![0u8; w * h];
{
let f = Uyyvyy411Frame::new(&packed, w as u32, h as u32, (w * 3 / 2) as u32);
let mut sink = MixedSinker::<Uyyvyy411>::new(w, h)
.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();
uyyvyy411_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
let hsv: Vec<u8> = hh.iter().chain(&ss).chain(&vv).copied().collect();
(rgb, hsv, luma)
}
#[allow(clippy::too_many_arguments)]
fn rs_packed(
w: usize,
h: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
native: bool,
simd: bool,
) -> (Vec<u8>, Vec<u8>) {
let (yp, up, vp) = ramp_411(w, h);
let packed = uyyvyy411_from(&yp, &up, &vp, w, h);
let mut rgb = vec![0u8; ow * oh * 3];
let mut luma = vec![0u8; ow * oh];
{
let f = Uyyvyy411Frame::new(&packed, w as u32, h as u32, (w * 3 / 2) as u32);
let mut sink =
MixedSinker::<Uyyvyy411, AreaResampler>::with_resampler(w, h, AreaResampler::to(ow, oh))
.unwrap()
.with_native(native)
.with_chroma_location(loc.clone())
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap()
.with_luma(&mut luma)
.unwrap();
uyyvyy411_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, luma)
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn packed_cosited_is_byte_identical() {
let base = id_packed(16, 6, ChromaLocation::Unspecified, true);
for loc in cosited() {
assert_eq!(
id_packed(16, 6, loc.clone(), true),
base,
"packed siting {loc:?}"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn packed_centered_equals_planar_411_decode() {
for loc in CENTERED {
let packed = id_packed(16, 6, loc.clone(), true);
let planar = id_411(16, 6, loc.clone(), true);
assert_eq!(packed, planar, "packed vs planar {loc:?}");
}
let cos = id_packed(16, 6, ChromaLocation::Left, true);
let cen = id_packed(16, 6, ChromaLocation::Center, true);
assert_ne!(cen.0, cos.0, "packed centered must differ from co-sited");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn packed_centered_simd_matches_scalar() {
let s = id_packed(16, 6, ChromaLocation::Center, false);
let d = id_packed(16, 6, ChromaLocation::Center, true);
assert_eq!(s.0, d.0, "packed rgb simd vs scalar");
assert_eq!(s.2, d.2, "packed luma simd vs scalar");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn packed_resample_cosited_is_byte_identical() {
for native in [true, false] {
let base = rs_packed(16, 8, 4, 4, ChromaLocation::Unspecified, native, true);
for loc in cosited() {
assert_eq!(
rs_packed(16, 8, 4, 4, loc.clone(), native, true),
base,
"packed resample siting {loc:?} native={native}"
);
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn packed_native_centered_equals_planar_411_resample() {
let (_, _, planar_luma) = rs_411(16, 8, 4, 4, ChromaLocation::Center, true, false);
let (_, native_luma) = rs_packed(16, 8, 4, 4, ChromaLocation::Center, true, true);
assert_eq!(
native_luma, planar_luma,
"packed native luma vs planar folded"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn packed_native_centered_equals_folded_rgb_oracle() {
let w = 16;
let h = 8;
let (ow, oh) = (4, 4);
let (yp, up, vp) = ramp_411(w, h);
let vw = area_weights(h, oh);
let yb = bin_cosited(&yp, w, h, ow, oh);
let ub = bin_chroma_411x_centered(&up, w, h, &vw, h, ow, oh);
let vb = bin_chroma_411x_centered(&vp, w, h, &vw, h, ow, oh);
let (rgb_o, _) = yuv444_decode(&yb, &ub, &vb, ow, oh);
let native = rs_packed(w, h, ow, oh, ChromaLocation::Center, true, true);
let row_stage = rs_packed(w, h, ow, oh, ChromaLocation::Center, false, true);
assert_eq!(native.1, yb, "native luma equals the co-sited binned Y");
assert_eq!(
native.0, rgb_o,
"packed native rgb equals the folded oracle"
);
assert_eq!(native.1, row_stage.1, "native / row-stage luma identical");
let full = id_packed(w, h, ChromaLocation::Center, true).0;
assert_eq!(
row_stage.0,
bin_rgb(&full, w, h, ow, oh),
"packed row-stage rgb == reconstruct-then-bin"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn packed_resample_mid_frame_flip_is_rejected() {
let (yp, up, vp) = ramp_411(16, 8);
let packed = uyyvyy411_from(&yp, &up, &vp, 16, 8);
let stride = 16 * 3 / 2;
let mut rgb = vec![0u8; 4 * 4 * 3];
let mut sink =
MixedSinker::<Uyyvyy411, AreaResampler>::with_resampler(16, 8, AreaResampler::to(4, 4))
.unwrap()
.with_native(true)
.with_chroma_location(ChromaLocation::Center)
.with_rgb(&mut rgb)
.unwrap();
PixelSink::begin_frame(&mut sink, 16, 8).unwrap();
for r in 0..2 {
let row = Uyyvyy411Row::for_tests(&packed[r * stride..r * stride + stride], r, M, FR);
PixelSink::process(&mut sink, row).unwrap();
}
sink.set_chroma_location(ChromaLocation::Left);
let bad = Uyyvyy411Row::for_tests(&packed[2 * stride..3 * stride], 2, M, FR);
let err = PixelSink::process(&mut sink, bad).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"packed mid-frame flip must be ChromaSitingChanged, got {err:?}"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn id_packed_mid_frame_siting_flip_is_rejected() {
let (w, h) = (16usize, 8usize);
let stride = w * 3 / 2;
let (yp, up, vp) = ramp_411(w, h);
let packed = uyyvyy411_from(&yp, &up, &vp, w, h);
let mut rgb = vec![0u8; w * h * 3];
let (mut hh, mut ss, mut vv) = (vec![0u8; w * h], vec![0u8; w * h], vec![0u8; w * h]);
let mut luma = vec![0u8; w * h];
{
let mut sink = MixedSinker::<Uyyvyy411>::new(w, h)
.with_chroma_location(ChromaLocation::Center)
.with_simd(true)
.with_rgb(&mut rgb)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_luma(&mut luma)
.unwrap();
PixelSink::begin_frame(&mut sink, w as u32, h as u32).unwrap();
for r in 0..2 {
let row = Uyyvyy411Row::for_tests(&packed[r * stride..r * stride + stride], r, M, FR);
PixelSink::process(&mut sink, row).unwrap();
}
sink.set_chroma_location(ChromaLocation::Left);
let bad = Uyyvyy411Row::for_tests(&packed[2 * stride..3 * stride], 2, M, FR);
let err = PixelSink::process(&mut sink, bad).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"packed identity mid-frame flip must be ChromaSitingChanged, got {err:?}"
);
sink.set_chroma_location(ChromaLocation::Center);
for r in 2..h {
let row = Uyyvyy411Row::for_tests(&packed[r * stride..r * stride + stride], r, M, FR);
PixelSink::process(&mut sink, row).unwrap();
}
}
let hsv: Vec<u8> = hh.iter().chain(&ss).chain(&vv).copied().collect();
let (want_rgb, want_hsv, want_luma) = id_packed(w, h, ChromaLocation::Center, true);
assert_eq!(rgb, want_rgb, "packed identity rgb after rejected flip");
assert_eq!(hsv, want_hsv, "packed identity hsv after rejected flip");
assert_eq!(luma, want_luma, "packed identity luma after rejected flip");
}