use crate::{
KernelMatrix,
frame::{Nv20Frame, PnFrame422},
resample::{AreaResampler, CatmullRom, FilteredResampler, Lanczos3, Triangle},
sinker::MixedSinker,
source::{Nv20, P210, nv20_to_endian, p210_to_endian},
};
const M: KernelMatrix = KernelMatrix::Bt601;
const FR: bool = true;
const BITS: u32 = 10;
const MASK: u16 = ((1u32 << BITS) - 1) as u16;
fn enc(v: u16, be: bool) -> u16 {
if be {
u16::from_ne_bytes(v.to_be_bytes())
} else {
u16::from_ne_bytes(v.to_le_bytes())
}
}
fn logical_ramp(sw: usize, sh: usize) -> (Vec<u16>, Vec<u16>) {
let cw = sw / 2;
let mut y = vec![0u16; sw * sh];
let mut uv = vec![0u16; cw * sh * 2];
for (i, yi) in y.iter_mut().enumerate() {
*yi = ((40u32 + i as u32 * 37) & MASK as u32) as u16;
}
for i in 0..cw * sh {
let u = ((300u32 + i as u32 * 53) & MASK as u32) as u16;
let v = ((MASK as u32).wrapping_sub(i as u32 * 41) as u16) & MASK;
uv[2 * i] = u;
uv[2 * i + 1] = v;
}
(y, uv)
}
const HIGH_MASK: u16 = (1u16 << (16 - BITS)) - 1; fn stray_high(i: usize) -> u16 {
(((i as u16).wrapping_mul(37).wrapping_add(1) & HIGH_MASK) | 0b00_0001) << BITS
}
fn nv20_planes(y_log: &[u16], uv_log: &[u16], be: bool) -> (Vec<u16>, Vec<u16>) {
(
y_log
.iter()
.enumerate()
.map(|(i, &v)| enc((v & MASK) | stray_high(i), be))
.collect(),
uv_log
.iter()
.enumerate()
.map(|(i, &v)| enc((v & MASK) | stray_high(i), be))
.collect(),
)
}
fn p210_planes(y_log: &[u16], uv_log: &[u16], be: bool) -> (Vec<u16>, Vec<u16>) {
let shift = 16 - BITS;
(
y_log
.iter()
.map(|&v| enc((v & MASK) << shift, be))
.collect(),
uv_log
.iter()
.map(|&v| enc((v & MASK) << shift, be))
.collect(),
)
}
struct Outputs {
rgb: Vec<u8>,
rgba: Vec<u8>,
rgb_u16: Vec<u16>,
rgba_u16: Vec<u16>,
luma: Vec<u8>,
hsv: (Vec<u8>, Vec<u8>, Vec<u8>),
}
#[derive(Clone, Copy)]
enum Tier {
Area { native: bool },
Filter(Kernel),
}
#[derive(Clone, Copy)]
enum Kernel {
Triangle,
CatmullRom,
Lanczos3,
}
#[allow(clippy::too_many_arguments)]
fn run_nv20<const BE: bool>(
yp: &[u16],
uvp: &[u16],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
tier: Tier,
loc: crate::ChromaLocation,
) -> Outputs {
let src = Nv20Frame::<BE>::new(yp, uvp, sw as u32, sh as u32, sw as u32, sw as u32);
let mut o = blank_outputs(ow, oh);
macro_rules! drive {
($sink:expr) => {{
let mut sink = $sink
.with_chroma_location(loc.clone())
.with_rgb(&mut o.rgb)
.unwrap()
.with_rgba(&mut o.rgba)
.unwrap()
.with_rgb_u16(&mut o.rgb_u16)
.unwrap()
.with_rgba_u16(&mut o.rgba_u16)
.unwrap()
.with_luma(&mut o.luma)
.unwrap()
.with_hsv(&mut o.hsv.0, &mut o.hsv.1, &mut o.hsv.2)
.unwrap();
nv20_to_endian::<_, BE>(&src, FR, sink.set_kernel_matrix(M)).unwrap();
}};
}
match tier {
Tier::Area { native } => {
drive!(
MixedSinker::<Nv20<BE>, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(native)
);
}
Tier::Filter(k) => match k {
Kernel::Triangle => drive!(
MixedSinker::<Nv20<BE>, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
),
Kernel::CatmullRom => drive!(
MixedSinker::<Nv20<BE>, FilteredResampler<CatmullRom>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, CatmullRom),
)
.unwrap()
),
Kernel::Lanczos3 => drive!(
MixedSinker::<Nv20<BE>, FilteredResampler<Lanczos3>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Lanczos3),
)
.unwrap()
),
},
}
o
}
#[allow(clippy::too_many_arguments)]
fn run_p210<const BE: bool>(
yp: &[u16],
uvp: &[u16],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
tier: Tier,
loc: crate::ChromaLocation,
) -> Outputs {
let src = PnFrame422::<10, BE>::new(yp, uvp, sw as u32, sh as u32, sw as u32, sw as u32);
let mut o = blank_outputs(ow, oh);
macro_rules! drive {
($sink:expr) => {{
let mut sink = $sink
.with_chroma_location(loc.clone())
.with_rgb(&mut o.rgb)
.unwrap()
.with_rgba(&mut o.rgba)
.unwrap()
.with_rgb_u16(&mut o.rgb_u16)
.unwrap()
.with_rgba_u16(&mut o.rgba_u16)
.unwrap()
.with_luma(&mut o.luma)
.unwrap()
.with_hsv(&mut o.hsv.0, &mut o.hsv.1, &mut o.hsv.2)
.unwrap();
p210_to_endian::<_, BE>(&src, FR, sink.set_kernel_matrix(M)).unwrap();
}};
}
match tier {
Tier::Area { native } => {
drive!(
MixedSinker::<P210<BE>, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(native)
);
}
Tier::Filter(k) => match k {
Kernel::Triangle => drive!(
MixedSinker::<P210<BE>, FilteredResampler<Triangle>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
),
Kernel::CatmullRom => drive!(
MixedSinker::<P210<BE>, FilteredResampler<CatmullRom>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, CatmullRom),
)
.unwrap()
),
Kernel::Lanczos3 => drive!(
MixedSinker::<P210<BE>, FilteredResampler<Lanczos3>>::with_resampler(
sw,
sh,
FilteredResampler::new(ow, oh, Lanczos3),
)
.unwrap()
),
},
}
o
}
fn blank_outputs(ow: usize, oh: usize) -> Outputs {
Outputs {
rgb: vec![0u8; ow * oh * 3],
rgba: vec![0u8; ow * oh * 4],
rgb_u16: vec![0u16; ow * oh * 3],
rgba_u16: vec![0u16; ow * oh * 4],
luma: vec![0u8; ow * oh],
hsv: (vec![0u8; ow * oh], vec![0u8; ow * oh], vec![0u8; ow * oh]),
}
}
fn assert_outputs_eq(got: &Outputs, want: &Outputs, ctx: &str) {
assert_eq!(got.rgb, want.rgb, "{ctx}: rgb");
assert_eq!(got.rgba, want.rgba, "{ctx}: rgba");
assert_eq!(got.rgb_u16, want.rgb_u16, "{ctx}: rgb_u16");
assert_eq!(got.rgba_u16, want.rgba_u16, "{ctx}: rgba_u16");
assert_eq!(got.luma, want.luma, "{ctx}: luma");
assert_eq!(got.hsv.0, want.hsv.0, "{ctx}: hsv H");
assert_eq!(got.hsv.1, want.hsv.1, "{ctx}: hsv S");
assert_eq!(got.hsv.2, want.hsv.2, "{ctx}: hsv V");
}
fn block_mean_2x2_u8(src: &[u8], sw: usize, sh: usize, ch: usize) -> Vec<u8> {
let (ow, oh) = (sw / 2, sh / 2);
let mut out = vec![0u8; ow * oh * ch];
for oy in 0..oh {
for ox in 0..ow {
for c in 0..ch {
let mut s = 0u32;
for dy in 0..2 {
for dx in 0..2 {
s += src[((oy * 2 + dy) * sw + ox * 2 + dx) * ch + c] as u32;
}
}
out[(oy * ow + ox) * ch + c] = ((s + 2) / 4) as u8;
}
}
}
out
}
fn block_mean_2x2_u16(src: &[u16], sw: usize, sh: usize, ch: usize) -> Vec<u16> {
let (ow, oh) = (sw / 2, sh / 2);
let mut out = vec![0u16; ow * oh * ch];
for oy in 0..oh {
for ox in 0..ow {
for c in 0..ch {
let mut s = 0u32;
for dy in 0..2 {
for dx in 0..2 {
s += src[((oy * 2 + dy) * sw + ox * 2 + dx) * ch + c] as u32;
}
}
out[(oy * ow + ox) * ch + c] = ((s + 2) / 4) as u16;
}
}
}
out
}
fn direct_nv20<const BE: bool>(yp: &[u16], uvp: &[u16], sw: usize, sh: usize) -> Outputs {
let src = Nv20Frame::<BE>::new(yp, uvp, sw as u32, sh as u32, sw as u32, sw as u32);
let mut o = blank_outputs(sw, sh);
let mut sink = MixedSinker::<Nv20<BE>>::new(sw, sh)
.with_rgb(&mut o.rgb)
.unwrap()
.with_rgba(&mut o.rgba)
.unwrap()
.with_rgb_u16(&mut o.rgb_u16)
.unwrap()
.with_rgba_u16(&mut o.rgba_u16)
.unwrap()
.with_luma(&mut o.luma)
.unwrap()
.with_hsv(&mut o.hsv.0, &mut o.hsv.1, &mut o.hsv.2)
.unwrap();
nv20_to_endian::<_, BE>(&src, FR, sink.set_kernel_matrix(M)).unwrap();
o
}
fn area_bin_of_direct<const BE: bool>(
yp_log: &[u16],
yp_wire: &[u16],
uvp_wire: &[u16],
sw: usize,
sh: usize,
) -> Outputs {
let d = direct_nv20::<BE>(yp_wire, uvp_wire, sw, sh);
let (ow, oh) = (sw / 2, sh / 2);
let rgb = block_mean_2x2_u8(&d.rgb, sw, sh, 3);
let logical_y: Vec<u16> = yp_log.iter().map(|&v| v & MASK).collect();
let y_binned = block_mean_2x2_u16(&logical_y, sw, sh, 1);
let luma: Vec<u8> = y_binned.iter().map(|&v| (v >> (BITS - 8)) as u8).collect();
let (mut hh, mut ss, mut vv) = (vec![0u8; ow * oh], vec![0u8; ow * oh], vec![0u8; ow * oh]);
crate::row::rgb_to_hsv_row(&rgb, &mut hh, &mut ss, &mut vv, ow * oh, false);
Outputs {
rgb,
rgba: block_mean_2x2_u8(&d.rgba, sw, sh, 4),
rgb_u16: block_mean_2x2_u16(&d.rgb_u16, sw, sh, 3),
rgba_u16: block_mean_2x2_u16(&d.rgba_u16, sw, sh, 4),
luma,
hsv: (hh, ss, vv),
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_rowstage_matches_area_bin_of_direct_le() {
let (sw, sh) = (8, 8);
let (y_log, uv_log) = logical_ramp(sw, sh);
let (yp, uvp) = nv20_planes(&y_log, &uv_log, false);
let got = run_nv20::<false>(
&yp,
&uvp,
sw,
sh,
sw / 2,
sh / 2,
Tier::Area { native: false },
crate::ChromaLocation::Left,
);
let want = area_bin_of_direct::<false>(&y_log, &yp, &uvp, sw, sh);
assert_eq!(got.rgb, want.rgb, "LE rowstage area rgb");
assert_eq!(got.rgba, want.rgba, "LE rowstage area rgba");
assert_eq!(got.rgb_u16, want.rgb_u16, "LE rowstage area rgb_u16");
assert_eq!(got.rgba_u16, want.rgba_u16, "LE rowstage area rgba_u16");
assert_eq!(got.luma, want.luma, "LE rowstage area luma");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_rowstage_matches_area_bin_of_direct_be() {
let (sw, sh) = (8, 8);
let (y_log, uv_log) = logical_ramp(sw, sh);
let (yp, uvp) = nv20_planes(&y_log, &uv_log, true);
let got = run_nv20::<true>(
&yp,
&uvp,
sw,
sh,
sw / 2,
sh / 2,
Tier::Area { native: false },
crate::ChromaLocation::Left,
);
let want = area_bin_of_direct::<true>(&y_log, &yp, &uvp, sw, sh);
assert_eq!(got.rgb, want.rgb, "BE rowstage area rgb");
assert_eq!(got.rgba, want.rgba, "BE rowstage area rgba");
assert_eq!(got.rgb_u16, want.rgb_u16, "BE rowstage area rgb_u16");
assert_eq!(got.rgba_u16, want.rgba_u16, "BE rowstage area rgba_u16");
assert_eq!(got.luma, want.luma, "BE rowstage area luma");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn native_luma_is_inter_area_bin_of_depacked_y() {
let (sw, sh) = (8, 8);
let (y_log, uv_log) = logical_ramp(sw, sh);
for &be in &[false, true] {
let (luma, want) = if be {
let (yp, uvp) = nv20_planes(&y_log, &uv_log, true);
let got = run_nv20::<true>(
&yp,
&uvp,
sw,
sh,
sw / 2,
sh / 2,
Tier::Area { native: true },
crate::ChromaLocation::Left,
);
let want = area_bin_of_direct::<true>(&y_log, &yp, &uvp, sw, sh).luma;
(got.luma, want)
} else {
let (yp, uvp) = nv20_planes(&y_log, &uv_log, false);
let got = run_nv20::<false>(
&yp,
&uvp,
sw,
sh,
sw / 2,
sh / 2,
Tier::Area { native: true },
crate::ChromaLocation::Left,
);
let want = area_bin_of_direct::<false>(&y_log, &yp, &uvp, sw, sh).luma;
(got.luma, want)
};
assert_eq!(
luma, want,
"native luma must be the INTER_AREA bin of the de-packed Y (be={be})"
);
}
}
fn assert_nv20_equals_p210<const BE: bool>(
sw: usize,
sh: usize,
ow: usize,
oh: usize,
tier: Tier,
loc: crate::ChromaLocation,
ctx: &str,
) {
let (y_log, uv_log) = logical_ramp(sw, sh);
let (nv_y, nv_uv) = nv20_planes(&y_log, &uv_log, BE);
let (p_y, p_uv) = p210_planes(&y_log, &uv_log, BE);
let nv = run_nv20::<BE>(&nv_y, &nv_uv, sw, sh, ow, oh, tier, loc.clone());
let p = run_p210::<BE>(&p_y, &p_uv, sw, sh, ow, oh, tier, loc);
assert_outputs_eq(&nv, &p, ctx);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_rowstage_nv20_equals_p210_le() {
assert_nv20_equals_p210::<false>(
8,
8,
4,
4,
Tier::Area { native: false },
crate::ChromaLocation::Left,
"LE area row-stage",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_rowstage_nv20_equals_p210_be() {
assert_nv20_equals_p210::<true>(
8,
8,
4,
4,
Tier::Area { native: false },
crate::ChromaLocation::Left,
"BE area row-stage",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_native_nv20_equals_p210_le() {
assert_nv20_equals_p210::<false>(
8,
8,
4,
4,
Tier::Area { native: true },
crate::ChromaLocation::Left,
"LE area native",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_native_nv20_equals_p210_be() {
assert_nv20_equals_p210::<true>(
8,
8,
4,
4,
Tier::Area { native: true },
crate::ChromaLocation::Left,
"BE area native",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn filter_nv20_equals_p210_le() {
for k in [Kernel::Triangle, Kernel::CatmullRom, Kernel::Lanczos3] {
assert_nv20_equals_p210::<false>(
8,
8,
4,
4,
Tier::Filter(k),
crate::ChromaLocation::Left,
"LE filter",
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn filter_nv20_equals_p210_be() {
for k in [Kernel::Triangle, Kernel::CatmullRom, Kernel::Lanczos3] {
assert_nv20_equals_p210::<true>(
8,
8,
4,
4,
Tier::Filter(k),
crate::ChromaLocation::Left,
"BE filter",
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn native_and_rowstage_color_differ_on_ramp() {
let (sw, sh) = (8, 8);
let (y_log, uv_log) = logical_ramp(sw, sh);
let (yp, uvp) = nv20_planes(&y_log, &uv_log, false);
let native = run_nv20::<false>(
&yp,
&uvp,
sw,
sh,
4,
4,
Tier::Area { native: true },
crate::ChromaLocation::Left,
);
let rowstage = run_nv20::<false>(
&yp,
&uvp,
sw,
sh,
4,
4,
Tier::Area { native: false },
crate::ChromaLocation::Left,
);
assert_eq!(
native.luma, rowstage.luma,
"luma is bit-identical across tiers"
);
assert_ne!(
native.rgb_u16, rowstage.rgb_u16,
"native (average-in-YUV) and row-stage (convert-then-average) colour must differ on the ramp"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_tail_geometry_nv20_equals_p210_le() {
assert_nv20_equals_p210::<false>(
6,
6,
4,
4,
Tier::Area { native: false },
crate::ChromaLocation::Left,
"LE area tail 6->4",
);
assert_nv20_equals_p210::<false>(
6,
6,
4,
4,
Tier::Area { native: true },
crate::ChromaLocation::Left,
"LE area tail native 6->4",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_tail_geometry_nv20_equals_p210_be() {
assert_nv20_equals_p210::<true>(
6,
6,
4,
4,
Tier::Area { native: false },
crate::ChromaLocation::Left,
"BE area tail 6->4",
);
assert_nv20_equals_p210::<true>(
6,
6,
4,
4,
Tier::Area { native: true },
crate::ChromaLocation::Left,
"BE area tail native 6->4",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn filter_tail_geometry_nv20_equals_p210() {
for k in [Kernel::Triangle, Kernel::CatmullRom, Kernel::Lanczos3] {
assert_nv20_equals_p210::<false>(
6,
6,
5,
5,
Tier::Filter(k),
crate::ChromaLocation::Left,
"LE filter tail 6->5",
);
assert_nv20_equals_p210::<true>(
6,
6,
5,
5,
Tier::Filter(k),
crate::ChromaLocation::Left,
"BE filter tail 6->5",
);
assert_nv20_equals_p210::<false>(
4,
4,
7,
7,
Tier::Filter(k),
crate::ChromaLocation::Left,
"LE filter upscale 4->7",
);
}
}
#[cfg(feature = "yuv-planar")]
fn direct_nv20_sited<const BE: bool>(
yp: &[u16],
uvp: &[u16],
sw: usize,
sh: usize,
loc: crate::ChromaLocation,
) -> Outputs {
let src = Nv20Frame::<BE>::new(yp, uvp, sw as u32, sh as u32, sw as u32, sw as u32);
let mut o = blank_outputs(sw, sh);
let mut sink = MixedSinker::<Nv20<BE>>::new(sw, sh)
.with_chroma_location(loc.clone())
.with_rgb(&mut o.rgb)
.unwrap()
.with_rgba(&mut o.rgba)
.unwrap()
.with_rgb_u16(&mut o.rgb_u16)
.unwrap()
.with_rgba_u16(&mut o.rgba_u16)
.unwrap()
.with_luma(&mut o.luma)
.unwrap()
.with_hsv(&mut o.hsv.0, &mut o.hsv.1, &mut o.hsv.2)
.unwrap();
nv20_to_endian::<_, BE>(&src, FR, sink.set_kernel_matrix(M)).unwrap();
o
}
#[cfg(feature = "yuv-planar")]
fn direct_p210_sited<const BE: bool>(
yp: &[u16],
uvp: &[u16],
sw: usize,
sh: usize,
loc: crate::ChromaLocation,
) -> Outputs {
let src = PnFrame422::<10, BE>::new(yp, uvp, sw as u32, sh as u32, sw as u32, sw as u32);
let mut o = blank_outputs(sw, sh);
let mut sink = MixedSinker::<P210<BE>>::new(sw, sh)
.with_chroma_location(loc.clone())
.with_rgb(&mut o.rgb)
.unwrap()
.with_rgba(&mut o.rgba)
.unwrap()
.with_rgb_u16(&mut o.rgb_u16)
.unwrap()
.with_rgba_u16(&mut o.rgba_u16)
.unwrap()
.with_luma(&mut o.luma)
.unwrap()
.with_hsv(&mut o.hsv.0, &mut o.hsv.1, &mut o.hsv.2)
.unwrap();
p210_to_endian::<_, BE>(&src, FR, sink.set_kernel_matrix(M)).unwrap();
o
}
#[cfg(feature = "yuv-planar")]
fn logical_flat_chroma(sw: usize, sh: usize) -> (Vec<u16>, Vec<u16>) {
let cw = sw / 2;
let mut y = vec![0u16; sw * sh];
for (i, yi) in y.iter_mut().enumerate() {
*yi = ((40u32 + i as u32 * 37) & MASK as u32) as u16;
}
let mut uv = vec![0u16; cw * sh * 2];
for i in 0..cw * sh {
uv[2 * i] = 500 & MASK;
uv[2 * i + 1] = 520 & MASK;
}
(y, uv)
}
#[cfg(feature = "yuv-planar")]
fn assert_identity_center_nv20_equals_p210<const BE: bool>(sw: usize, sh: usize, ctx: &str) {
let (y_log, uv_log) = logical_ramp(sw, sh);
let (nv_y, nv_uv) = nv20_planes(&y_log, &uv_log, BE); let (p_y, p_uv) = p210_planes(&y_log, &uv_log, BE); let center = crate::ChromaLocation::Center;
let nv = direct_nv20_sited::<BE>(&nv_y, &nv_uv, sw, sh, center.clone());
let p = direct_p210_sited::<BE>(&p_y, &p_uv, sw, sh, center);
assert_outputs_eq(&nv, &p, ctx);
}
#[cfg(feature = "yuv-planar")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn identity_center_nv20_equals_p210_le() {
assert_identity_center_nv20_equals_p210::<false>(8, 4, "LE identity centered NV20==P210");
}
#[cfg(feature = "yuv-planar")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn identity_center_nv20_equals_p210_be() {
assert_identity_center_nv20_equals_p210::<true>(8, 4, "BE identity centered NV20==P210");
}
#[cfg(feature = "yuv-planar")]
fn assert_identity_center_differs_from_cosited<const BE: bool>(sw: usize, sh: usize) {
let (y_log, uv_log) = logical_ramp(sw, sh);
let (nv_y, nv_uv) = nv20_planes(&y_log, &uv_log, BE);
let centered = direct_nv20_sited::<BE>(&nv_y, &nv_uv, sw, sh, crate::ChromaLocation::Center);
let cosited = direct_nv20_sited::<BE>(&nv_y, &nv_uv, sw, sh, crate::ChromaLocation::Left);
assert_ne!(
centered.rgb, cosited.rgb,
"centered chroma siting must differ from co-sited on a horizontal ramp (be={BE})"
);
}
#[cfg(feature = "yuv-planar")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn identity_center_differs_from_cosited_on_ramp_le() {
assert_identity_center_differs_from_cosited::<false>(8, 4);
}
#[cfg(feature = "yuv-planar")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn identity_center_differs_from_cosited_on_ramp_be() {
assert_identity_center_differs_from_cosited::<true>(8, 4);
}
#[cfg(feature = "yuv-planar")]
fn assert_identity_center_equals_cosited_on_flat<const BE: bool>(sw: usize, sh: usize, ctx: &str) {
let (y_log, uv_log) = logical_flat_chroma(sw, sh);
let (nv_y, nv_uv) = nv20_planes(&y_log, &uv_log, BE);
let centered = direct_nv20_sited::<BE>(&nv_y, &nv_uv, sw, sh, crate::ChromaLocation::Center);
let cosited = direct_nv20_sited::<BE>(&nv_y, &nv_uv, sw, sh, crate::ChromaLocation::Left);
assert_outputs_eq(¢ered, &cosited, ctx);
}
#[cfg(feature = "yuv-planar")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn identity_center_equals_cosited_on_flat_le() {
assert_identity_center_equals_cosited_on_flat::<false>(8, 4, "LE flat centered==cosited");
}
#[cfg(feature = "yuv-planar")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn identity_center_equals_cosited_on_flat_be() {
assert_identity_center_equals_cosited_on_flat::<true>(8, 4, "BE flat centered==cosited");
}
#[cfg(feature = "yuv-planar")]
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn identity_mid_frame_siting_flip_rejected() {
use crate::{ChromaLocation, PixelSink, sinker::MixedSinkerError, source::Nv20Row};
let (sw, sh) = (8usize, 4usize);
let cw = sw / 2;
let (y_log, uv_log) = logical_ramp(sw, sh);
let (yp, uvp) = nv20_planes(&y_log, &uv_log, false); for (loc1, loc2) in [
(ChromaLocation::Center, ChromaLocation::Left),
(ChromaLocation::Left, ChromaLocation::Center),
] {
let mut rgb = vec![0u8; sw * sh * 3];
let mut sink = MixedSinker::<Nv20>::new(sw, sh)
.with_chroma_location(loc1.clone())
.with_rgb(&mut rgb)
.unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
let row0 = Nv20Row::for_tests(&yp[0..sw], &uvp[0..2 * cw], 0, M, FR);
PixelSink::process(&mut sink, row0).unwrap();
sink.set_chroma_location(loc2.clone());
let row1 = Nv20Row::for_tests(&yp[sw..2 * sw], &uvp[2 * cw..4 * cw], 1, M, FR);
let err = PixelSink::process(&mut sink, row1).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"identity {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_center_nv20_equals_p210_le() {
for native in [false, true] {
assert_nv20_equals_p210::<false>(
8,
8,
4,
4,
Tier::Area { native },
crate::ChromaLocation::Center,
"LE area centered",
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn area_center_nv20_equals_p210_be() {
for native in [false, true] {
assert_nv20_equals_p210::<true>(
8,
8,
4,
4,
Tier::Area { native },
crate::ChromaLocation::Center,
"BE area centered",
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn filter_center_nv20_equals_p210_le() {
for k in [Kernel::Triangle, Kernel::CatmullRom, Kernel::Lanczos3] {
assert_nv20_equals_p210::<false>(
8,
8,
4,
4,
Tier::Filter(k),
crate::ChromaLocation::Center,
"LE filter centered",
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn filter_center_nv20_equals_p210_be() {
for k in [Kernel::Triangle, Kernel::CatmullRom, Kernel::Lanczos3] {
assert_nv20_equals_p210::<true>(
8,
8,
4,
4,
Tier::Filter(k),
crate::ChromaLocation::Center,
"BE filter centered",
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn resample_centered_differs_from_cosited_on_ramp() {
let (sw, sh) = (8, 8);
let (ow, oh) = (4, 4);
let (y_log, uv_log) = logical_ramp(sw, sh);
let (yp, uvp) = nv20_planes(&y_log, &uv_log, false);
for tier in [
Tier::Area { native: false },
Tier::Area { native: true },
Tier::Filter(Kernel::Triangle),
Tier::Filter(Kernel::CatmullRom),
Tier::Filter(Kernel::Lanczos3),
] {
let centered = run_nv20::<false>(
&yp,
&uvp,
sw,
sh,
ow,
oh,
tier,
crate::ChromaLocation::Center,
);
let cosited = run_nv20::<false>(&yp, &uvp, sw, sh, ow, oh, tier, crate::ChromaLocation::Left);
assert_ne!(
centered.rgb_u16, cosited.rgb_u16,
"centered chroma siting must differ from co-sited on a horizontal ramp"
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn resample_mid_frame_siting_flip_rejected() {
use crate::{ChromaLocation, PixelSink, sinker::MixedSinkerError, source::Nv20Row};
let (sw, sh) = (8usize, 4usize);
let (ow, oh) = (4usize, 2usize);
let cw = sw / 2;
let (y_log, uv_log) = logical_ramp(sw, sh);
let (yp, uvp) = nv20_planes(&y_log, &uv_log, false); for (loc1, loc2) in [
(ChromaLocation::Center, ChromaLocation::Left),
(ChromaLocation::Left, ChromaLocation::Center),
] {
let mut rgb = vec![0u8; ow * oh * 3];
let mut sink =
MixedSinker::<Nv20, AreaResampler>::with_resampler(sw, sh, AreaResampler::to(ow, oh))
.unwrap()
.with_native(false)
.with_chroma_location(loc1.clone())
.with_rgb(&mut rgb)
.unwrap();
PixelSink::begin_frame(&mut sink, sw as u32, sh as u32).unwrap();
let row0 = Nv20Row::for_tests(&yp[0..sw], &uvp[0..2 * cw], 0, M, FR);
PixelSink::process(&mut sink, row0).unwrap();
sink.set_chroma_location(loc2.clone());
let row1 = Nv20Row::for_tests(&yp[sw..2 * sw], &uvp[2 * cw..4 * cw], 1, M, FR);
let err = PixelSink::process(&mut sink, row1).unwrap_err();
assert!(
matches!(err, MixedSinkerError::ChromaSitingChanged(_)),
"resample {loc1:?}->{loc2:?}: want ChromaSitingChanged, got {err:?}"
);
}
}