use crate::{
ChromaLocation, ColorInfo, ColorSpec, DynamicRange, KernelMatrix, PixelFormat, PixelSink,
Primaries, Transfer,
resample::{AreaResampler, AveragingDomain, LinearMode},
sinker::MixedSinker,
source::{Yuv420p, Yuv420pRow, Yuv444p, yuv420p_to, yuv444p_to},
};
use mediaframe::frame::{Yuv420pFrame, 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 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 bin_chroma_centered(c: &[u8], cw: usize, ch: usize, ow: usize, oh: usize) -> Vec<u8> {
let full = 2 * cw;
let mut r4 = vec![0u32; full * ch];
for r in 0..ch {
let row = &c[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 }]);
r4[r * full + 2 * j] = l + 3 * m; r4[r * full + 2 * j + 1] = 3 * m + rt; }
}
let hw = area_weights(full, ow);
let vw = area_weights(ch, oh);
let denom = (4 * full * ch) 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(r4[(vs + dy) * full + hs + dx]);
}
s += vwt * hsum;
}
out[oy * ow + ox] = rdhu(s, denom) as u8;
}
}
out
}
fn recon_full_row(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
}
fn ramp(sw: usize, sh: usize) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let ch = sh / 2;
let mut y = vec![0u8; sw * sh];
let mut u = vec![0u8; cw * ch];
let mut v = vec![0u8; cw * ch];
for (i, p) in y.iter_mut().enumerate() {
*p = 40 + ((i as u32 * 3) % 160) as u8;
}
for r in 0..ch {
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;
}
}
(y, u, v)
}
fn flat_chroma(sw: usize, sh: usize) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let ch = sh / 2;
let mut y = vec![0u8; sw * sh];
for (i, p) in y.iter_mut().enumerate() {
*p = 40 + ((i as u32 * 7) % 170) as u8;
}
(y, vec![110u8; cw * ch], vec![140u8; cw * ch])
}
type Outs = (
Vec<u8>,
Vec<u8>,
(Vec<u8>, Vec<u8>, Vec<u8>),
Vec<u8>,
Vec<u16>,
);
#[allow(clippy::too_many_arguments)]
fn run(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
native: bool,
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 luma_u16 = vec![0u16; ow * oh];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(native)
.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 luma_u16)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, (hh, ss, vv), luma, luma_u16)
}
#[allow(clippy::too_many_arguments)]
fn native_oracle(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
) -> Outs {
let cw = sw / 2;
let ch = sh / 2;
let yb = bin_cosited(y, sw, sh, ow, oh);
let ub = bin_chroma_centered(u, cw, ch, ow, oh);
let vb = bin_chroma_centered(v, cw, ch, ow, oh);
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 luma_u16 = vec![0u16; ow * oh];
{
let mut sink = MixedSinker::<Yuv444p>::new(ow, oh)
.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 luma_u16)
.unwrap();
let f = Yuv444pFrame::new(
&yb, &ub, &vb, ow as u32, oh as u32, ow as u32, ow as u32, ow as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, (hh, ss, vv), luma, luma_u16)
}
#[allow(clippy::too_many_arguments)]
fn encoded_oracle_rgb(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: 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 {
let cr = r / 2;
uf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row(&u[cr * cw..cr * cw + cw], cw));
vf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row(&v[cr * cw..cr * cw + cw], cw));
}
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv444pFrame::new(
y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
fn bin_chroma_bottom(c: &[u8], cw: usize, ch: usize, ow: usize, oh: usize) -> Vec<u8> {
let full = 2 * cw;
let sh = 2 * ch;
let mut r8 = vec![0u64; full * sh];
for r in 0..sh {
let cr = r / 2;
let prev = cr.saturating_sub(1);
let vrow: Vec<u32> = (0..cw)
.map(|j| {
if r & 1 == 0 {
u32::from(c[prev * cw + j]) + u32::from(c[cr * cw + j]) } else {
2 * u32::from(c[cr * cw + j]) }
})
.collect();
for j in 0..cw {
let l = vrow[j.saturating_sub(1)];
let m = vrow[j];
let rt = vrow[if j + 1 < cw { j + 1 } else { j }];
r8[r * full + 2 * j] = u64::from(l + 3 * m); r8[r * full + 2 * j + 1] = u64::from(3 * m + rt); }
}
let hw = area_weights(full, ow);
let vw = area_weights(sh, oh);
let denom = (8 * full * 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 * r8[(vs + dy) * full + hs + dx];
}
s += vwt * hsum;
}
out[oy * ow + ox] = rdhu(s, denom) as u8;
}
}
out
}
#[allow(clippy::too_many_arguments)]
fn bottom_native_oracle(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
) -> Outs {
let cw = sw / 2;
let ch = sh / 2;
let yb = bin_cosited(y, sw, sh, ow, oh);
let ub = bin_chroma_bottom(u, cw, ch, ow, oh);
let vb = bin_chroma_bottom(v, cw, ch, ow, oh);
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 luma_u16 = vec![0u16; ow * oh];
{
let mut sink = MixedSinker::<Yuv444p>::new(ow, oh)
.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 luma_u16)
.unwrap();
let f = Yuv444pFrame::new(
&yb, &ub, &vb, ow as u32, oh as u32, ow as u32, ow as u32, ow as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, (hh, ss, vv), luma, luma_u16)
}
fn recon_full_bottom(u: &[u8], v: &[u8], sw: usize, sh: usize) -> (Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let vblend = |plane: &[u8], cr: usize, prev: usize| -> Vec<u8> {
(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 u8
})
.collect::<Vec<u8>>()
};
let mut uf = vec![0u8; sw * sh];
let mut vf = vec![0u8; 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(&uh, cw));
vf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row(&vh, cw));
}
(uf, vf)
}
#[allow(clippy::too_many_arguments)]
fn encoded_oracle_rgb_bottom(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
) -> Vec<u8> {
let (uf, vf) = recon_full_bottom(u, v, sw, sh);
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv444pFrame::new(
y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
fn direct_bottom_rgb(y: &[u8], u: &[u8], v: &[u8], sw: usize, sh: usize, simd: bool) -> Vec<u8> {
let cw = sw / 2;
let mut rgb = vec![0u8; sw * sh * 3];
{
let mut sink = MixedSinker::<Yuv420p>::new(sw, sh)
.with_chroma_location(ChromaLocation::Bottom)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
fn vramp(sw: usize, sh: usize) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let ch = sh / 2;
let y = vec![128u8; sw * sh];
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 + r * 40).min(240) as u8;
v[r * cw + c] = (220u32.saturating_sub((r * 40) as u32)).max(16) as u8;
}
}
(y, u, v)
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn cosited_group_is_byte_identical_across_tiers() {
let (y, u, v) = ramp(8, 8);
for native in [true, false] {
let base = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::Unspecified,
native,
true,
);
for loc in [ChromaLocation::Left, ChromaLocation::other("unassigned-7")] {
let got = run(&y, &u, &v, 8, 8, 4, 4, loc.clone(), native, true);
assert_eq!(got.0, base.0, "rgb {loc:?} native={native}");
assert_eq!(got.1, base.1, "rgba {loc:?} native={native}");
assert_eq!(got.2, base.2, "hsv {loc:?} native={native}");
assert_eq!(got.3, base.3, "luma {loc:?} native={native}");
assert_eq!(got.4, base.4, "luma_u16 {loc:?} native={native}");
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_native_equals_code_domain_oracle() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (12, 8, 4, 4), (16, 8, 6, 5)] {
let (y, u, v) = ramp(sw, sh);
let o = native_oracle(&y, &u, &v, sw, sh, ow, oh, true);
let loc = ChromaLocation::Center;
let n = run(&y, &u, &v, sw, sh, ow, oh, loc.clone(), true, true);
assert_eq!(n.0, o.0, "rgb {loc:?} {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.1, o.1, "rgba {loc:?} {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.2, o.2, "hsv {loc:?} {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.3, o.3, "luma {loc:?} {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.4, o.4, "luma_u16 {loc:?} {sw}x{sh}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_native_simd_matches_scalar() {
let (y, u, v) = ramp(8, 8);
let s = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Center, true, false);
let d = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Center, true, true);
assert_eq!(s.0, d.0, "rgb scalar vs simd");
assert_eq!(s.2, d.2, "hsv scalar vs simd");
assert_eq!(s.3, d.3, "luma scalar vs simd");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_encoded_output_equals_rgb_reconstruct_then_bin() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (12, 8, 6, 4)] {
let (y, u, v) = ramp(sw, sh);
let oracle = encoded_oracle_rgb(&y, &u, &v, sw, sh, ow, oh, true);
let loc = ChromaLocation::Center;
let got = run(&y, &u, &v, sw, sh, ow, oh, loc.clone(), false, true);
assert_eq!(got.0, oracle, "rgb {loc:?} {sw}x{sh}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_differs_from_cosited_on_a_chroma_ramp() {
let (y, u, v) = ramp(8, 8);
for native in [true, false] {
let cos = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::Unspecified,
native,
true,
);
let cen = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Center, native, true);
assert_ne!(
cen.0, cos.0,
"centered rgb must differ from co-sited (native={native})"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_equals_cosited_on_flat_chroma() {
let (y, u, v) = flat_chroma(8, 8);
for native in [true, false] {
let cos = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Left, native, true);
let cen = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Center, native, true);
assert_eq!(cen.0, cos.0, "flat-chroma rgb (native={native})");
assert_eq!(cen.2, cos.2, "flat-chroma hsv (native={native})");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottom_native_equals_code_domain_oracle() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (12, 8, 4, 4), (16, 8, 6, 5)] {
let (y, u, v) = ramp(sw, sh);
let o = bottom_native_oracle(&y, &u, &v, sw, sh, ow, oh, true);
let n = run(
&y,
&u,
&v,
sw,
sh,
ow,
oh,
ChromaLocation::Bottom,
true,
true,
);
assert_eq!(n.0, o.0, "rgb {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.1, o.1, "rgba {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.2, o.2, "hsv {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.3, o.3, "luma {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.4, o.4, "luma_u16 {sw}x{sh}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottom_native_simd_matches_scalar() {
let (y, u, v) = ramp(8, 8);
let s = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Bottom, true, false);
let d = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Bottom, true, true);
assert_eq!(s.0, d.0, "rgb scalar vs simd");
assert_eq!(s.2, d.2, "hsv scalar vs simd");
assert_eq!(s.3, d.3, "luma scalar vs simd");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottom_encoded_output_equals_rgb_reconstruct_then_bin() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (12, 8, 6, 4)] {
let (y, u, v) = ramp(sw, sh);
let oracle = encoded_oracle_rgb_bottom(&y, &u, &v, sw, sh, ow, oh, true);
let got = run(
&y,
&u,
&v,
sw,
sh,
ow,
oh,
ChromaLocation::Bottom,
false,
true,
);
assert_eq!(got.0, oracle, "rgb {sw}x{sh}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottom_differs_from_center_on_a_vertical_chroma_ramp() {
let (y, u, v) = vramp(8, 8);
for native in [true, false] {
let cen = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Center, native, true);
let bot = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Bottom, native, true);
assert_ne!(
bot.0, cen.0,
"bottom rgb must differ from center (native={native})"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottom_equals_cosited_on_flat_chroma() {
let (y, u, v) = flat_chroma(8, 8);
for native in [true, false] {
let cos = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Left, native, true);
let bot = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Bottom, native, true);
assert_eq!(bot.0, cos.0, "flat-chroma bottom rgb (native={native})");
assert_eq!(bot.2, cos.2, "flat-chroma bottom hsv (native={native})");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottom_encoded_identity_matches_direct_decode() {
let (y, u, v) = vramp(8, 8);
let res = run(&y, &u, &v, 8, 8, 8, 8, ChromaLocation::Bottom, false, true);
let direct = direct_bottom_rgb(&y, &u, &v, 8, 8, true);
assert_eq!(
res.0, direct,
"identity encoded resample bottom == direct decode"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottom_linear_final_even_row_tail_alloc_failure_retries_with_blend() {
use super::super::MixedSinkerError;
use crate::resample::ResampleError;
let (sw, sh, ow, oh) = (8usize, 7usize, 4usize, 3usize);
let cw = sw / 2;
let ch = sh.div_ceil(2);
let y = vec![128u8; sw * sh];
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 + r * 40).min(240) as u8;
v[r * cw + c] = (220u32.saturating_sub((r * 40) as u32)).max(16) as u8;
}
}
let run_frame = |arm_fail: bool, loc: ChromaLocation| -> Vec<u8> {
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_chroma_location(loc.clone())
.with_rgb(&mut rgb)
.unwrap();
sink.begin_frame(sw as u32, sh as u32).unwrap();
let feed = |sink: &mut MixedSinker<'_, Yuv420p, 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];
sink.process(Yuv420pRow::for_tests(yr, ur, vr, r, M, FR))
};
for r in 0..sh - 1 {
feed(&mut sink, r).unwrap();
}
if arm_fail {
crate::sinker::mixed::linear_light::arm_linear_tail_alloc_failure();
let err = feed(&mut sink, sh - 1).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"armed final-row tail alloc must surface AllocationFailed, got {err:?}"
);
}
feed(&mut sink, sh - 1).unwrap();
}
rgb
};
let reference = run_frame(false, ChromaLocation::Bottom);
let retried = run_frame(true, ChromaLocation::Bottom);
assert_eq!(
retried, reference,
"the post-failure retry of the final EVEN row must blend with the predecessor (not clamp)"
);
assert_ne!(
reference,
run_frame(false, ChromaLocation::Center),
"the bottom vertical blend must move the final even row vs co-sited Center"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_native_is_within_1_lsb_of_reconstruct_then_bin() {
let (cw, ch, ow, oh) = (4usize, 2usize, 4usize, 2usize);
let u: Vec<u8> = (0..cw * ch)
.map(|i| if i.is_multiple_of(2) { 0 } else { 2 })
.collect();
let folded = bin_chroma_centered(&u, cw, ch, ow, oh);
let mut recon = vec![0u8; 2 * cw * ch];
for r in 0..ch {
recon[r * 2 * cw..r * 2 * cw + 2 * cw]
.copy_from_slice(&recon_full_row(&u[r * cw..r * cw + cw], cw));
}
let double = bin_cosited(&recon, 2 * cw, ch, ow, oh);
let maxd = folded
.iter()
.zip(&double)
.map(|(&a, &b)| a.abs_diff(b))
.max()
.unwrap();
assert!(
maxd <= 1,
"folded vs reconstruct-then-bin max delta {maxd} must be ≤ 1 LSB"
);
assert_ne!(folded, double, "the ≤1 LSB gap must be exercised");
}
#[allow(clippy::too_many_arguments)]
fn run_reuse_native(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc1: ChromaLocation,
loc2: 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 luma_u16 = vec![0u16; ow * oh];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(true)
.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 luma_u16)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
sink.set_chroma_location(loc1.clone());
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
sink.set_chroma_location(loc2.clone());
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, (hh, ss, vv), luma, luma_u16)
}
#[allow(clippy::too_many_arguments)]
fn run_hsv_only(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
simd: bool,
) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let (mut hh, mut ss, mut vv) = (vec![0u8; ow * oh], vec![0u8; ow * oh], vec![0u8; ow * oh]);
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_chroma_location(loc.clone())
.with_simd(simd)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(hh, ss, vv)
}
#[allow(clippy::too_many_arguments)]
fn run_reuse_hsv_only(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc1: ChromaLocation,
loc2: ChromaLocation,
simd: bool,
) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let (mut hh, mut ss, mut vv) = (vec![0u8; ow * oh], vec![0u8; ow * oh], vec![0u8; ow * oh]);
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_simd(simd)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
sink.set_chroma_location(loc1.clone());
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
sink.set_chroma_location(loc2.clone());
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(hh, ss, vv)
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn native_join_rebuilds_on_siting_change_across_frames() {
let (y, u, v) = ramp(8, 8);
for (a, b) in [
(ChromaLocation::Left, ChromaLocation::Center),
(ChromaLocation::Center, ChromaLocation::Left),
(ChromaLocation::Center, ChromaLocation::Top),
(ChromaLocation::Top, ChromaLocation::Center),
(ChromaLocation::Top, ChromaLocation::Bottom),
(ChromaLocation::Bottom, ChromaLocation::Top),
] {
let reused = run_reuse_native(&y, &u, &v, 8, 8, 4, 4, a.clone(), b.clone(), true);
let fresh = run(&y, &u, &v, 8, 8, 4, 4, b.clone(), true, true);
assert_eq!(
reused.0, fresh.0,
"native rgb {a:?}->{b:?} stale-phase carryover"
);
assert_eq!(reused.1, fresh.1, "native rgba {a:?}->{b:?}");
assert_eq!(reused.2, fresh.2, "native hsv {a:?}->{b:?}");
let stale = run(&y, &u, &v, 8, 8, 4, 4, a.clone(), true, true);
assert_ne!(
fresh.0, stale.0,
"sitings {a:?} vs {b:?} must differ (non-vacuous)"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn hsv_only_join_rebuilds_on_siting_change_across_frames() {
let (y, u, v) = ramp(8, 8);
for (a, b) in [
(ChromaLocation::Left, ChromaLocation::Center),
(ChromaLocation::Center, ChromaLocation::Left),
] {
let reused = run_reuse_hsv_only(&y, &u, &v, 8, 8, 4, 4, a.clone(), b.clone(), true);
let fresh = run_hsv_only(&y, &u, &v, 8, 8, 4, 4, b.clone(), true);
assert_eq!(reused, fresh, "hsv-only {a:?}->{b:?} stale-phase carryover");
let stale = run_hsv_only(&y, &u, &v, 8, 8, 4, 4, a.clone(), true);
assert_ne!(
fresh, stale,
"sitings {a:?} vs {b:?} must differ (non-vacuous)"
);
}
}
fn apply_siting<R>(
sink: &mut MixedSinker<'_, Yuv420p, R>,
loc: ChromaLocation,
via_color_spec: bool,
) {
if via_color_spec {
let spec = ColorSpec::from_info(
PixelFormat::Yuv420p,
ColorInfo::new(
Primaries::Unspecified,
Transfer::Unspecified,
crate::ColorMatrix::from(M),
DynamicRange::Limited,
loc,
),
);
sink.set_color_spec(&spec).unwrap();
} else {
sink.set_chroma_location(loc.clone());
}
}
fn feed_all(
sink: &mut MixedSinker<'_, Yuv420p, AreaResampler>,
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
) {
let cw = sw / 2;
for r in 0..sh {
let cr = r / 2;
let row = Yuv420pRow::for_tests(
&y[r * sw..r * sw + sw],
&u[cr * cw..cr * cw + cw],
&v[cr * cw..cr * cw + cw],
r,
M,
FR,
);
PixelSink::process(sink, row).unwrap();
}
}
#[allow(clippy::too_many_arguments)]
fn run_reuse_native_setter_after(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc1: ChromaLocation,
loc2: ChromaLocation,
via_color_spec: bool,
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 luma_u16 = vec![0u16; ow * oh];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(true)
.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 luma_u16)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
sink.set_chroma_location(loc1.clone());
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
apply_siting(&mut sink, loc2, via_color_spec); feed_all(&mut sink, y, u, v, sw, sh);
}
(rgb, rgba, (hh, ss, vv), luma, luma_u16)
}
#[allow(clippy::too_many_arguments)]
fn run_reuse_hsv_setter_after(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc1: ChromaLocation,
loc2: ChromaLocation,
via_color_spec: bool,
simd: bool,
) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let (mut hh, mut ss, mut vv) = (vec![0u8; ow * oh], vec![0u8; ow * oh], vec![0u8; ow * oh]);
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_simd(simd)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
sink.set_chroma_location(loc1.clone());
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
apply_siting(&mut sink, loc2, via_color_spec);
feed_all(&mut sink, y, u, v, sw, sh);
}
(hh, ss, vv)
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn native_join_rebuilds_on_siting_change_after_begin_frame() {
let (y, u, v) = ramp(8, 8);
for via_color_spec in [false, true] {
for (a, b) in [
(ChromaLocation::Left, ChromaLocation::Center),
(ChromaLocation::Center, ChromaLocation::Left),
] {
let reused = run_reuse_native_setter_after(
&y,
&u,
&v,
8,
8,
4,
4,
a.clone(),
b.clone(),
via_color_spec,
true,
);
let fresh = run(&y, &u, &v, 8, 8, 4, 4, b.clone(), true, true);
assert_eq!(
reused.0, fresh.0,
"native rgb {a:?}->{b:?} color_spec={via_color_spec}: stale after begin_frame"
);
assert_eq!(
reused.2, fresh.2,
"native hsv {a:?}->{b:?} color_spec={via_color_spec}"
);
let stale = run(&y, &u, &v, 8, 8, 4, 4, a, true, true);
assert_ne!(fresh.0, stale.0, "sitings must differ (non-vacuous)");
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn hsv_only_join_rebuilds_on_siting_change_after_begin_frame() {
let (y, u, v) = ramp(8, 8);
for via_color_spec in [false, true] {
for (a, b) in [
(ChromaLocation::Left, ChromaLocation::Center),
(ChromaLocation::Center, ChromaLocation::Left),
] {
let reused = run_reuse_hsv_setter_after(
&y,
&u,
&v,
8,
8,
4,
4,
a.clone(),
b.clone(),
via_color_spec,
true,
);
let fresh = run_hsv_only(&y, &u, &v, 8, 8, 4, 4, b.clone(), true);
assert_eq!(
reused, fresh,
"hsv-only {a:?}->{b:?} color_spec={via_color_spec}: stale after begin_frame"
);
let stale = run_hsv_only(&y, &u, &v, 8, 8, 4, 4, a, true);
assert_ne!(fresh, stale, "sitings must differ (non-vacuous)");
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn out_of_sequence_centered_first_row_is_rejected_before_the_chroma_reserve() {
use super::super::MixedSinkerError;
use crate::resample::ResampleError;
let (y, u, v) = ramp(8, 8);
let cw = 4usize;
let mut rgb = vec![0u8; 4 * 4 * 3];
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_native(false)
.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 = Yuv420pRow::for_tests(
&y[5 * 8..6 * 8],
&u[2 * cw..3 * cw],
&v[2 * cw..3 * cw],
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 = Yuv420pRow::for_tests(&y[0..8], &u[0..cw], &v[0..cw], 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-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn luma_only_centered_area_does_not_reserve_chroma() {
let (y, u, v) = ramp(8, 8);
let cw = 4usize;
let mut luma = vec![0u8; 4 * 4];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_native(false)
.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();
feed_all(&mut sink, &y, &u, &v, 8, 8);
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::<Yuv420p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_native(false)
.with_chroma_location(ChromaLocation::Center)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv420pFrame::new(&y, &u, &v, 8, 8, 8, cw as u32, cw as u32);
let _ = yuv420p_to(&f, FR, sink.set_kernel_matrix(M));
}
fn run_linear_420(
y: &[u8],
u: &[u8],
v: &[u8],
loc: ChromaLocation,
mode: LinearMode,
simd: bool,
) -> Vec<u8> {
let (sw, sh, ow, oh, cw) = (8usize, 8usize, 4usize, 4usize, 4usize);
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_native(false)
.with_linear_mode(mode)
.with_chroma_location(loc.clone())
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
fn oracle_linear_reconstruct(
y: &[u8],
u: &[u8],
v: &[u8],
mode: LinearMode,
simd: bool,
) -> Vec<u8> {
let (sw, sh, ow, oh, cw) = (8usize, 8usize, 4usize, 4usize, 4usize);
let mut uf = vec![0u8; sw * sh];
let mut vf = vec![0u8; sw * sh];
for r in 0..sh {
let cr = r / 2;
uf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row(&u[cr * cw..cr * cw + cw], cw));
vf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row(&v[cr * cw..cr * cw + cw], cw));
}
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_native(false)
.with_linear_mode(mode)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv444pFrame::new(
y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn centered_linear_folds_the_phase_for_both_decodes() {
let (y, u, v) = ramp(8, 8);
for mode in [LinearMode::DisplayReferred, LinearMode::SceneReferred] {
let centered = run_linear_420(&y, &u, &v, ChromaLocation::Center, mode, true);
let oracle = oracle_linear_reconstruct(&y, &u, &v, mode, true);
assert_eq!(
centered, oracle,
"centered Linear ({mode:?}) must equal reconstruct-then-linear-average"
);
let cosited = run_linear_420(&y, &u, &v, ChromaLocation::Left, mode, true);
assert_ne!(
centered, cosited,
"centered Linear ({mode:?}) must differ from co-sited (non-vacuous)"
);
}
}
fn oracle_linear_reconstruct_bottom(
y: &[u8],
u: &[u8],
v: &[u8],
mode: LinearMode,
simd: bool,
) -> Vec<u8> {
let (sw, sh, ow, oh) = (8usize, 8usize, 4usize, 4usize);
let (uf, vf) = recon_full_bottom(u, v, sw, sh);
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_native(false)
.with_linear_mode(mode)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv444pFrame::new(
y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottom_linear_folds_the_vertical_phase() {
let (y, u, v) = vramp(8, 8);
for mode in [LinearMode::DisplayReferred, LinearMode::SceneReferred] {
let bottom = run_linear_420(&y, &u, &v, ChromaLocation::Bottom, mode, true);
let oracle = oracle_linear_reconstruct_bottom(&y, &u, &v, mode, true);
assert_eq!(
bottom, oracle,
"bottom Linear ({mode:?}) must equal reconstruct-then-linear-average"
);
let centered = run_linear_420(&y, &u, &v, ChromaLocation::Center, mode, true);
assert_ne!(
bottom, centered,
"bottom Linear ({mode:?}) must differ from center on a vertical ramp"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottom_filter_equals_reconstruct_then_filter() {
use crate::resample::{FilteredResampler, Triangle};
let (sw, sh, ow, oh, cw) = (8usize, 8usize, 4usize, 4usize, 4usize);
let (y, u, v) = vramp(sw, sh);
let filter_420 = |loc: ChromaLocation| -> Vec<u8> {
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink = MixedSinker::<Yuv420p, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_chroma_location(loc.clone())
.with_simd(true)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv420pFrame::new(
&y, &u, &v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
};
let got = filter_420(ChromaLocation::Bottom);
let (uf, vf) = recon_full_bottom(&u, &v, sw, sh);
let mut oracle = vec![0u8; ow * oh * 3];
{
let mut sink = MixedSinker::<Yuv444p, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_simd(true)
.with_rgb(&mut oracle)
.unwrap();
let f = Yuv444pFrame::new(
&y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
assert_eq!(got, oracle, "filter-tier bottom == reconstruct-then-filter");
assert_ne!(
got,
filter_420(ChromaLocation::Center),
"filter-tier bottom must differ from center on a vertical ramp"
);
}
fn in_sequence_flip_row1<R>(
mut sink: MixedSinker<'_, Yuv420p, R>,
y: &[u8],
u: &[u8],
v: &[u8],
loc1: ChromaLocation,
loc2: ChromaLocation,
) -> Result<(), super::super::MixedSinkerError> {
let cw = 4usize;
sink.set_chroma_location(loc1.clone());
PixelSink::begin_frame(&mut sink, 8, 8).unwrap();
let row0 = Yuv420pRow::for_tests(&y[0..8], &u[0..cw], &v[0..cw], 0, M, FR);
PixelSink::process(&mut sink, row0).unwrap();
sink.set_chroma_location(loc2.clone());
let row1 = Yuv420pRow::for_tests(&y[8..16], &u[0..cw], &v[0..cw], 1, M, FR);
PixelSink::process(&mut sink, row1)
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn in_sequence_mid_frame_phase_change_rejected_across_tiers() {
use super::super::MixedSinkerError;
let (y, u, v) = ramp(8, 8);
for (loc1, loc2) in [
(ChromaLocation::Center, ChromaLocation::Left),
(ChromaLocation::Left, ChromaLocation::Center),
(ChromaLocation::Center, ChromaLocation::Bottom),
(ChromaLocation::Bottom, ChromaLocation::Center),
(ChromaLocation::Left, ChromaLocation::BottomLeft),
(ChromaLocation::BottomLeft, ChromaLocation::Left),
(ChromaLocation::BottomLeft, ChromaLocation::Bottom),
(ChromaLocation::Bottom, ChromaLocation::BottomLeft),
(ChromaLocation::Center, ChromaLocation::Top),
(ChromaLocation::Top, ChromaLocation::Center),
(ChromaLocation::Top, ChromaLocation::Bottom),
(ChromaLocation::Bottom, ChromaLocation::Top),
(ChromaLocation::Left, ChromaLocation::TopLeft),
(ChromaLocation::TopLeft, ChromaLocation::Left),
(ChromaLocation::TopLeft, ChromaLocation::Top),
(ChromaLocation::Top, ChromaLocation::TopLeft),
] {
let mut rgb = vec![0u8; 4 * 4 * 3];
let sink = MixedSinker::<Yuv420p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_native(true)
.with_rgb(&mut rgb)
.unwrap();
let err = in_sequence_flip_row1(sink, &y, &u, &v, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"native {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
let mut rgb = vec![0u8; 4 * 4 * 3];
let sink = MixedSinker::<Yuv420p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_native(false)
.with_rgb(&mut rgb)
.unwrap();
let err = in_sequence_flip_row1(sink, &y, &u, &v, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"encoded-rgb {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::<Yuv420p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_native(false)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
let err = in_sequence_flip_row1(sink, &y, &u, &v, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"hsv {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
let mut rgb = vec![0u8; 4 * 4 * 3];
let sink = MixedSinker::<Yuv420p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_native(false)
.with_rgb(&mut rgb)
.unwrap();
let err = in_sequence_flip_row1(sink, &y, &u, &v, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"linear {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
let mut rgb = vec![0u8; 4 * 4 * 3];
let sink =
MixedSinker::<Yuv420p, crate::resample::FilteredResampler<crate::resample::Triangle>>::with_resampler(
8,
8,
crate::resample::FilteredResampler::new(4, 4, crate::resample::Triangle),
)
.unwrap()
.with_rgb(&mut rgb)
.unwrap();
let err = in_sequence_flip_row1(sink, &y, &u, &v, loc1.clone(), loc2.clone()).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"filter {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn native_mid_frame_phase_change_rejection_keeps_the_stream_retryable() {
use super::super::MixedSinkerError;
let (y, u, v) = ramp(8, 8);
let cw = 4usize;
let mut rgb = vec![0u8; 4 * 4 * 3];
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_native(true)
.with_chroma_location(ChromaLocation::Center)
.with_rgb(&mut rgb)
.unwrap();
PixelSink::begin_frame(&mut sink, 8, 8).unwrap();
for r in 0..2 {
let row = Yuv420pRow::for_tests(
&y[r * 8..r * 8 + 8],
&u[(r / 2) * cw..(r / 2) * cw + cw],
&v[(r / 2) * cw..(r / 2) * cw + cw],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
sink.set_chroma_location(ChromaLocation::Left);
let bad = Yuv420pRow::for_tests(
&y[5 * 8..6 * 8],
&u[2 * cw..3 * cw],
&v[2 * cw..3 * cw],
5,
M,
FR,
);
let err = PixelSink::process(&mut sink, bad).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"mid-frame siting change must be ChromaSitingChanged, got {err:?}"
);
PixelSink::begin_frame(&mut sink, 8, 8).unwrap();
feed_all(&mut sink, &y, &u, &v, 8, 8);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn hsv_mid_frame_phase_change_rejection_keeps_the_stream_retryable() {
use super::super::MixedSinkerError;
let (y, u, v) = ramp(8, 8);
let cw = 4usize;
let (mut hh, mut ss, mut vv) = (vec![0u8; 4 * 4], vec![0u8; 4 * 4], vec![0u8; 4 * 4]);
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(8, 8, AreaResampler::to(4, 4))
.unwrap()
.with_native(false)
.with_chroma_location(ChromaLocation::Center)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap();
PixelSink::begin_frame(&mut sink, 8, 8).unwrap();
for r in 0..2 {
let row = Yuv420pRow::for_tests(
&y[r * 8..r * 8 + 8],
&u[(r / 2) * cw..(r / 2) * cw + cw],
&v[(r / 2) * cw..(r / 2) * cw + cw],
r,
M,
FR,
);
PixelSink::process(&mut sink, row).unwrap();
}
sink.set_chroma_location(ChromaLocation::Left);
let bad = Yuv420pRow::for_tests(
&y[5 * 8..6 * 8],
&u[2 * cw..3 * cw],
&v[2 * cw..3 * cw],
5,
M,
FR,
);
let err = PixelSink::process(&mut sink, bad).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"mid-frame siting change (HSV) must be ChromaSitingChanged, got {err:?}"
);
PixelSink::begin_frame(&mut sink, 8, 8).unwrap();
feed_all(&mut sink, &y, &u, &v, 8, 8);
}
fn bin_chroma_bottomleft(c: &[u8], cw: usize, ch: usize, ow: usize, oh: usize) -> Vec<u8> {
let sh = 2 * ch;
let mut r2 = vec![0u64; cw * sh];
for r in 0..sh {
let cr = r / 2;
let prev = cr.saturating_sub(1);
for j in 0..cw {
r2[r * cw + j] = if r & 1 == 0 {
u64::from(c[prev * cw + j]) + u64::from(c[cr * cw + j]) } else {
2 * u64::from(c[cr * cw + j]) };
}
}
let hw = area_weights(cw, ow);
let vw = area_weights(sh, oh);
let denom = (2 * cw * 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 * r2[(vs + dy) * cw + hs + dx];
}
s += vwt * hsum;
}
out[oy * ow + ox] = rdhu(s, denom) as u8;
}
}
out
}
#[allow(clippy::too_many_arguments)]
fn bottomleft_native_oracle(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
) -> Outs {
let cw = sw / 2;
let ch = sh / 2;
let yb = bin_cosited(y, sw, sh, ow, oh);
let ub = bin_chroma_bottomleft(u, cw, ch, ow, oh);
let vb = bin_chroma_bottomleft(v, cw, ch, ow, oh);
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 luma_u16 = vec![0u16; ow * oh];
{
let mut sink = MixedSinker::<Yuv444p>::new(ow, oh)
.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 luma_u16)
.unwrap();
let f = Yuv444pFrame::new(
&yb, &ub, &vb, ow as u32, oh as u32, ow as u32, ow as u32, ow as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, (hh, ss, vv), luma, luma_u16)
}
fn recon_full_row_cosited(c: &[u8], cw: usize) -> Vec<u8> {
let mut out = vec![0u8; 2 * cw];
for j in 0..cw {
out[2 * j] = c[j];
out[2 * j + 1] = c[j];
}
out
}
fn recon_full_bottomleft(u: &[u8], v: &[u8], sw: usize, sh: usize) -> (Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let vblend = |plane: &[u8], cr: usize, prev: usize| -> Vec<u8> {
(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 u8
})
.collect::<Vec<u8>>()
};
let mut uf = vec![0u8; sw * sh];
let mut vf = vec![0u8; 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_cosited(&uh, cw));
vf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row_cosited(&vh, cw));
}
(uf, vf)
}
#[allow(clippy::too_many_arguments)]
fn encoded_oracle_rgb_bottomleft(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
) -> Vec<u8> {
let (uf, vf) = recon_full_bottomleft(u, v, sw, sh);
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv444pFrame::new(
y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
fn direct_bottomleft_rgb(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
simd: bool,
) -> Vec<u8> {
let cw = sw / 2;
let mut rgb = vec![0u8; sw * sh * 3];
{
let mut sink = MixedSinker::<Yuv420p>::new(sw, sh)
.with_chroma_location(ChromaLocation::BottomLeft)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottomleft_native_equals_code_domain_oracle() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (12, 8, 4, 4), (16, 8, 6, 5)] {
let (y, u, v) = ramp(sw, sh);
let o = bottomleft_native_oracle(&y, &u, &v, sw, sh, ow, oh, true);
let n = run(
&y,
&u,
&v,
sw,
sh,
ow,
oh,
ChromaLocation::BottomLeft,
true,
true,
);
assert_eq!(n.0, o.0, "rgb {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.1, o.1, "rgba {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.2, o.2, "hsv {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.3, o.3, "luma {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.4, o.4, "luma_u16 {sw}x{sh}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottomleft_native_simd_matches_scalar() {
let (y, u, v) = ramp(8, 8);
let s = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::BottomLeft,
true,
false,
);
let d = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::BottomLeft,
true,
true,
);
assert_eq!(
s, d,
"bottom-left native SIMD must be 0-ULP identical to scalar"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottomleft_encoded_output_equals_rgb_reconstruct_then_bin() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (16, 8, 6, 5)] {
let (y, u, v) = ramp(sw, sh);
let got = run(
&y,
&u,
&v,
sw,
sh,
ow,
oh,
ChromaLocation::BottomLeft,
false,
true,
);
let oracle = encoded_oracle_rgb_bottomleft(&y, &u, &v, sw, sh, ow, oh, true);
assert_eq!(
got.0, oracle,
"encoded-rgb bottom-left {sw}x{sh}->{ow}x{oh}"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottomleft_encoded_identity_matches_direct_decode() {
let (y, u, v) = vramp(8, 8);
let res = run(
&y,
&u,
&v,
8,
8,
8,
8,
ChromaLocation::BottomLeft,
false,
true,
);
let direct = direct_bottomleft_rgb(&y, &u, &v, 8, 8, true);
assert_eq!(
res.0, direct,
"encoded-identity bottom-left == direct decode"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottomleft_differs_from_bottom_and_cosited() {
for native in [true, false] {
let (y, u, v) = ramp(8, 8);
let bl = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::BottomLeft,
native,
true,
);
let bot = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Bottom, native, true);
assert_ne!(
bl.0, bot.0,
"bottom-left rgb must differ from bottom (native={native})"
);
let (y, u, v) = vramp(8, 8);
let bl = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::BottomLeft,
native,
true,
);
let cos = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Left, native, true);
assert_ne!(
bl.0, cos.0,
"bottom-left rgb must differ from co-sited (native={native})"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottomleft_equals_cosited_on_flat_chroma() {
for native in [true, false] {
let (y, u, v) = flat_chroma(8, 8);
let bl = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::BottomLeft,
native,
true,
);
let cos = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::Unspecified,
native,
true,
);
assert_eq!(bl.0, cos.0, "flat-chroma bottom-left rgb (native={native})");
assert_eq!(bl.2, cos.2, "flat-chroma bottom-left hsv (native={native})");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn bottomleft_filter_equals_reconstruct_then_filter() {
use crate::resample::{FilteredResampler, Triangle};
let (sw, sh, ow, oh, cw) = (8usize, 8usize, 4usize, 4usize, 4usize);
let (y, u, v) = vramp(sw, sh);
let mut got = vec![0u8; ow * oh * 3];
{
let mut sink = MixedSinker::<Yuv420p, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_chroma_location(ChromaLocation::BottomLeft)
.with_simd(true)
.with_rgb(&mut got)
.unwrap();
let f = Yuv420pFrame::new(
&y, &u, &v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
let (uf, vf) = recon_full_bottomleft(&u, &v, sw, sh);
let mut oracle = vec![0u8; ow * oh * 3];
{
let mut sink = MixedSinker::<Yuv444p, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_simd(true)
.with_rgb(&mut oracle)
.unwrap();
let f = Yuv444pFrame::new(
&y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
assert_eq!(
got, oracle,
"filter-tier bottom-left == reconstruct-then-filter"
);
}
fn bin_chroma_top(c: &[u8], cw: usize, ch: usize, ow: usize, oh: usize) -> Vec<u8> {
let full = 2 * cw;
let sh = 2 * ch;
let mut r8 = vec![0u64; full * sh];
for r in 0..sh {
let cr = r / 2;
let next = if cr + 1 < ch { cr + 1 } else { cr }; let vrow: Vec<u32> = (0..cw)
.map(|j| {
if r & 1 == 0 {
2 * u32::from(c[cr * cw + j]) } else {
u32::from(c[cr * cw + j]) + u32::from(c[next * cw + j]) }
})
.collect();
for j in 0..cw {
let l = vrow[j.saturating_sub(1)];
let m = vrow[j];
let rt = vrow[if j + 1 < cw { j + 1 } else { j }];
r8[r * full + 2 * j] = u64::from(l + 3 * m);
r8[r * full + 2 * j + 1] = u64::from(3 * m + rt);
}
}
let hw = area_weights(full, ow);
let vw = area_weights(sh, oh);
let denom = (8 * full * 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 * r8[(vs + dy) * full + hs + dx];
}
s += vwt * hsum;
}
out[oy * ow + ox] = rdhu(s, denom) as u8;
}
}
out
}
#[allow(clippy::too_many_arguments)]
fn top_native_oracle(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
) -> Outs {
let cw = sw / 2;
let ch = sh / 2;
let yb = bin_cosited(y, sw, sh, ow, oh);
let ub = bin_chroma_top(u, cw, ch, ow, oh);
let vb = bin_chroma_top(v, cw, ch, ow, oh);
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 luma_u16 = vec![0u16; ow * oh];
{
let mut sink = MixedSinker::<Yuv444p>::new(ow, oh)
.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 luma_u16)
.unwrap();
let f = Yuv444pFrame::new(
&yb, &ub, &vb, ow as u32, oh as u32, ow as u32, ow as u32, ow as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, (hh, ss, vv), luma, luma_u16)
}
fn recon_full_top(u: &[u8], v: &[u8], sw: usize, sh: usize) -> (Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let ch = sh.div_ceil(2);
let vblend = |plane: &[u8], a: usize, b: usize| -> Vec<u8> {
(0..cw)
.map(|c| {
let x = u32::from(plane[a * cw + c]);
let z = u32::from(plane[b * cw + c]);
((x + z + 1) >> 1) as u8
})
.collect::<Vec<u8>>()
};
let mut uf = vec![0u8; sw * sh];
let mut vf = vec![0u8; sw * sh];
for r in 0..sh {
let cr = r / 2;
let (uh, vh) = if r & 1 == 0 {
(
u[cr * cw..cr * cw + cw].to_vec(),
v[cr * cw..cr * cw + cw].to_vec(),
)
} else {
let next = if cr + 1 < ch { cr + 1 } else { cr };
(vblend(u, cr, next), vblend(v, cr, next))
};
uf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row(&uh, cw));
vf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row(&vh, cw));
}
(uf, vf)
}
#[allow(clippy::too_many_arguments)]
fn encoded_oracle_rgb_top(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
) -> Vec<u8> {
let (uf, vf) = recon_full_top(u, v, sw, sh);
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv444pFrame::new(
y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
fn direct_top_rgb(y: &[u8], u: &[u8], v: &[u8], sw: usize, sh: usize, simd: bool) -> Vec<u8> {
let cw = sw / 2;
let mut rgb = vec![0u8; sw * sh * 3];
{
let mut sink = MixedSinker::<Yuv420p>::new(sw, sh)
.with_chroma_location(ChromaLocation::Top)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_native_equals_code_domain_oracle() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (12, 8, 4, 4), (16, 8, 6, 5)] {
let (y, u, v) = ramp(sw, sh);
let o = top_native_oracle(&y, &u, &v, sw, sh, ow, oh, true);
let n = run(&y, &u, &v, sw, sh, ow, oh, ChromaLocation::Top, true, true);
assert_eq!(n.0, o.0, "rgb {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.1, o.1, "rgba {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.2, o.2, "hsv {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.3, o.3, "luma {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.4, o.4, "luma_u16 {sw}x{sh}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_native_simd_matches_scalar() {
let (y, u, v) = ramp(8, 8);
let s = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Top, true, false);
let d = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Top, true, true);
assert_eq!(s.0, d.0, "rgb scalar vs simd");
assert_eq!(s.2, d.2, "hsv scalar vs simd");
assert_eq!(s.3, d.3, "luma scalar vs simd");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_encoded_output_equals_rgb_reconstruct_then_bin() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (12, 8, 6, 4)] {
let (y, u, v) = ramp(sw, sh);
let oracle = encoded_oracle_rgb_top(&y, &u, &v, sw, sh, ow, oh, true);
let got = run(&y, &u, &v, sw, sh, ow, oh, ChromaLocation::Top, false, true);
assert_eq!(got.0, oracle, "rgb {sw}x{sh}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_encoded_identity_matches_direct_decode() {
let (y, u, v) = vramp(8, 8);
let res = run(&y, &u, &v, 8, 8, 8, 8, ChromaLocation::Top, false, true);
let direct = direct_top_rgb(&y, &u, &v, 8, 8, true);
assert_eq!(
res.0, direct,
"identity encoded resample top == direct decode"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_two_row_final_flush_odd_height_matches_direct_decode() {
for sh in [5usize, 7] {
let (sw, cw, ch) = (8usize, 4usize, sh.div_ceil(2));
let y = vec![128u8; sw * sh];
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 + r * 40).min(240) as u8;
v[r * cw + c] = (220u32.saturating_sub((r * 40) as u32)).max(16) as u8;
}
}
let res = run(&y, &u, &v, sw, sh, sw, sh, ChromaLocation::Top, false, true);
let direct = direct_top_rgb(&y, &u, &v, sw, sh, true);
assert_eq!(res.0, direct, "odd-height two-row final flush sh={sh}");
let center = run(
&y,
&u,
&v,
sw,
sh,
sw,
sh,
ChromaLocation::Center,
false,
true,
);
assert_ne!(res.0, center.0, "top must differ from center sh={sh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_differs_from_center_and_bottom_on_a_vertical_ramp() {
let (y, u, v) = vramp(8, 8);
for native in [true, false] {
let top = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Top, native, true);
let cen = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Center, native, true);
let bot = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Bottom, native, true);
assert_ne!(top.0, cen.0, "top != center (native={native})");
assert_ne!(top.0, bot.0, "top != bottom (native={native})");
assert_ne!(cen.0, bot.0, "center != bottom (native={native})");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_equals_cosited_on_flat_chroma() {
let (y, u, v) = flat_chroma(8, 8);
for native in [true, false] {
let cos = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Left, native, true);
let top = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Top, native, true);
assert_eq!(top.0, cos.0, "flat-chroma top rgb (native={native})");
assert_eq!(top.2, cos.2, "flat-chroma top hsv (native={native})");
}
}
#[allow(clippy::too_many_arguments)]
fn oracle_linear_reconstruct_top(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
mode: LinearMode,
simd: bool,
) -> Vec<u8> {
let (uf, vf) = recon_full_top(u, v, sw, sh);
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_native(false)
.with_linear_mode(mode)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv444pFrame::new(
y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
#[allow(clippy::too_many_arguments)]
fn run_linear_420_top(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
loc: ChromaLocation,
mode: LinearMode,
simd: bool,
) -> Vec<u8> {
let cw = sw / 2;
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_native(false)
.with_linear_mode(mode)
.with_chroma_location(loc.clone())
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_linear_folds_the_vertical_phase() {
for (sw, sh, ow, oh) in [(8usize, 8usize, 4usize, 4usize), (8, 6, 4, 3)] {
let (y, u, v) = vramp(sw, sh);
for mode in [LinearMode::DisplayReferred, LinearMode::SceneReferred] {
let top = run_linear_420_top(&y, &u, &v, sw, sh, ow, oh, ChromaLocation::Top, mode, true);
let oracle = oracle_linear_reconstruct_top(&y, &u, &v, sw, sh, ow, oh, mode, true);
assert_eq!(
top, oracle,
"top Linear ({mode:?}) {sw}x{sh}->{ow}x{oh} must equal reconstruct-then-linear-average"
);
let center = run_linear_420_top(
&y,
&u,
&v,
sw,
sh,
ow,
oh,
ChromaLocation::Center,
mode,
true,
);
assert_ne!(top, center, "top Linear ({mode:?}) must differ from center");
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_linear_final_even_row_tail_alloc_failure_retries_atomically() {
use super::super::MixedSinkerError;
use crate::resample::ResampleError;
let (sw, sh, ow, oh) = (8usize, 7usize, 4usize, 3usize);
let cw = sw / 2;
let ch = sh.div_ceil(2);
let y = vec![128u8; sw * sh];
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 + r * 40).min(240) as u8;
v[r * cw + c] = (220u32.saturating_sub((r * 40) as u32)).max(16) as u8;
}
}
let run_frame = |arm_fail: bool, loc: ChromaLocation| -> Vec<u8> {
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_native(false)
.with_chroma_location(loc.clone())
.with_rgb(&mut rgb)
.unwrap();
sink.begin_frame(sw as u32, sh as u32).unwrap();
let feed = |sink: &mut MixedSinker<'_, Yuv420p, 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];
sink.process(Yuv420pRow::for_tests(yr, ur, vr, r, M, FR))
};
for r in 0..sh - 1 {
feed(&mut sink, r).unwrap();
}
if arm_fail {
crate::sinker::mixed::linear_light::arm_linear_tail_alloc_failure();
let err = feed(&mut sink, sh - 1).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"armed final-row tail alloc must surface AllocationFailed, got {err:?}"
);
}
feed(&mut sink, sh - 1).unwrap();
}
rgb
};
let reference = run_frame(false, ChromaLocation::Top);
let retried = run_frame(true, ChromaLocation::Top);
assert_eq!(
retried, reference,
"the post-failure retry of the two-row FINAL flush must reproduce the reference"
);
assert_ne!(
reference,
run_frame(false, ChromaLocation::Center),
"the top forward fold must move the final even row vs co-sited Center"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn top_filter_equals_reconstruct_then_filter() {
use crate::resample::{FilteredResampler, Triangle};
let (sw, sh, ow, oh, cw) = (8usize, 8usize, 4usize, 4usize, 4usize);
let (y, u, v) = vramp(sw, sh);
let filter_420 = |loc: ChromaLocation| -> Vec<u8> {
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink = MixedSinker::<Yuv420p, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_chroma_location(loc.clone())
.with_simd(true)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv420pFrame::new(
&y, &u, &v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
};
let got = filter_420(ChromaLocation::Top);
let (uf, vf) = recon_full_top(&u, &v, sw, sh);
let mut oracle = vec![0u8; ow * oh * 3];
{
let mut sink = MixedSinker::<Yuv444p, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_simd(true)
.with_rgb(&mut oracle)
.unwrap();
let f = Yuv444pFrame::new(
&y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
assert_eq!(got, oracle, "filter-tier top == reconstruct-then-filter");
assert_ne!(
got,
filter_420(ChromaLocation::Center),
"filter-tier top must differ from center on a vertical ramp"
);
}
fn bin_chroma_topleft(c: &[u8], cw: usize, ch: usize, ow: usize, oh: usize) -> Vec<u8> {
let sh = 2 * ch;
let mut r2 = vec![0u64; cw * sh];
for r in 0..sh {
let cr = r / 2;
let next = if cr + 1 < ch { cr + 1 } else { cr };
for j in 0..cw {
r2[r * cw + j] = if r & 1 == 0 {
2 * u64::from(c[cr * cw + j]) } else {
u64::from(c[cr * cw + j]) + u64::from(c[next * cw + j]) };
}
}
let hw = area_weights(cw, ow);
let vw = area_weights(sh, oh);
let denom = (2 * cw * 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 * r2[(vs + dy) * cw + hs + dx];
}
s += vwt * hsum;
}
out[oy * ow + ox] = rdhu(s, denom) as u8;
}
}
out
}
#[allow(clippy::too_many_arguments)]
fn topleft_native_oracle(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
) -> Outs {
let cw = sw / 2;
let ch = sh / 2;
let yb = bin_cosited(y, sw, sh, ow, oh);
let ub = bin_chroma_topleft(u, cw, ch, ow, oh);
let vb = bin_chroma_topleft(v, cw, ch, ow, oh);
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 luma_u16 = vec![0u16; ow * oh];
{
let mut sink = MixedSinker::<Yuv444p>::new(ow, oh)
.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 luma_u16)
.unwrap();
let f = Yuv444pFrame::new(
&yb, &ub, &vb, ow as u32, oh as u32, ow as u32, ow as u32, ow as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
(rgb, rgba, (hh, ss, vv), luma, luma_u16)
}
fn recon_full_topleft(u: &[u8], v: &[u8], sw: usize, sh: usize) -> (Vec<u8>, Vec<u8>) {
let cw = sw / 2;
let ch = sh.div_ceil(2);
let vblend = |plane: &[u8], a: usize, b: usize| -> Vec<u8> {
(0..cw)
.map(|c| {
let x = u32::from(plane[a * cw + c]);
let z = u32::from(plane[b * cw + c]);
((x + z + 1) >> 1) as u8
})
.collect::<Vec<u8>>()
};
let mut uf = vec![0u8; sw * sh];
let mut vf = vec![0u8; sw * sh];
for r in 0..sh {
let cr = r / 2;
let (uh, vh) = if r & 1 == 0 {
(
u[cr * cw..cr * cw + cw].to_vec(),
v[cr * cw..cr * cw + cw].to_vec(),
)
} else {
let next = if cr + 1 < ch { cr + 1 } else { cr };
(vblend(u, cr, next), vblend(v, cr, next))
};
uf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row_cosited(&uh, cw));
vf[r * sw..r * sw + sw].copy_from_slice(&recon_full_row_cosited(&vh, cw));
}
(uf, vf)
}
#[allow(clippy::too_many_arguments)]
fn encoded_oracle_rgb_topleft(
y: &[u8],
u: &[u8],
v: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
simd: bool,
) -> Vec<u8> {
let (uf, vf) = recon_full_topleft(u, v, sw, sh);
let mut rgb = vec![0u8; ow * oh * 3];
{
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv444pFrame::new(
y, &uf, &vf, sw as u32, sh as u32, sw as u32, sw as u32, sw as u32,
);
yuv444p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
fn direct_topleft_rgb(y: &[u8], u: &[u8], v: &[u8], sw: usize, sh: usize, simd: bool) -> Vec<u8> {
let cw = sw / 2;
let mut rgb = vec![0u8; sw * sh * 3];
{
let mut sink = MixedSinker::<Yuv420p>::new(sw, sh)
.with_chroma_location(ChromaLocation::TopLeft)
.with_simd(simd)
.with_rgb(&mut rgb)
.unwrap();
let f = Yuv420pFrame::new(
y, u, v, sw as u32, sh as u32, sw as u32, cw as u32, cw as u32,
);
yuv420p_to(&f, FR, sink.set_kernel_matrix(M)).unwrap();
}
rgb
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn topleft_native_equals_code_domain_oracle() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (12, 8, 4, 4), (16, 8, 6, 5)] {
let (y, u, v) = ramp(sw, sh);
let o = topleft_native_oracle(&y, &u, &v, sw, sh, ow, oh, true);
let n = run(
&y,
&u,
&v,
sw,
sh,
ow,
oh,
ChromaLocation::TopLeft,
true,
true,
);
assert_eq!(n.0, o.0, "rgb {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.1, o.1, "rgba {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.2, o.2, "hsv {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.3, o.3, "luma {sw}x{sh}->{ow}x{oh}");
assert_eq!(n.4, o.4, "luma_u16 {sw}x{sh}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn topleft_native_simd_matches_scalar() {
let (y, u, v) = ramp(8, 8);
let s = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::TopLeft, true, false);
let d = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::TopLeft, true, true);
assert_eq!(
s, d,
"top-left native SIMD must be 0-ULP identical to scalar"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn topleft_encoded_output_equals_rgb_reconstruct_then_bin() {
for (sw, sh, ow, oh) in [(8, 8, 4, 4), (8, 8, 5, 3), (16, 8, 6, 5)] {
let (y, u, v) = ramp(sw, sh);
let got = run(
&y,
&u,
&v,
sw,
sh,
ow,
oh,
ChromaLocation::TopLeft,
false,
true,
);
let oracle = encoded_oracle_rgb_topleft(&y, &u, &v, sw, sh, ow, oh, true);
assert_eq!(got.0, oracle, "encoded-rgb top-left {sw}x{sh}->{ow}x{oh}");
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn topleft_encoded_identity_matches_direct_decode() {
let (y, u, v) = vramp(8, 8);
let res = run(&y, &u, &v, 8, 8, 8, 8, ChromaLocation::TopLeft, false, true);
let direct = direct_topleft_rgb(&y, &u, &v, 8, 8, true);
assert_eq!(res.0, direct, "encoded-identity top-left == direct decode");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn topleft_differs_from_top_and_bottomleft() {
for native in [true, false] {
let (y, u, v) = ramp(8, 8);
let tl = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::TopLeft,
native,
true,
);
let tp = run(&y, &u, &v, 8, 8, 4, 4, ChromaLocation::Top, native, true);
assert_ne!(tl.0, tp.0, "top-left != top (native={native})");
let (y, u, v) = vramp(8, 8);
let tl = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::TopLeft,
native,
true,
);
let bl = run(
&y,
&u,
&v,
8,
8,
4,
4,
ChromaLocation::BottomLeft,
native,
true,
);
assert_ne!(tl.0, bl.0, "top-left != bottom-left (native={native})");
}
}