use crate::{KernelMatrix, sinker::MixedSinker};
const MATRIX: KernelMatrix = KernelMatrix::Bt709;
fn samples<const BITS: u32>(seed: u64, n: usize) -> std::vec::Vec<u16> {
let mask = (1u32 << BITS) - 1;
let mut s = seed;
(0..n)
.map(|_| {
s = s
.wrapping_mul(6364136223846793005)
.wrapping_add(1442695040888963407);
((s >> 33) as u32 & mask) as u16
})
.collect()
}
fn msb_align<const BITS: u32>(low: &[u16]) -> std::vec::Vec<u16> {
low.iter().map(|&s| s << (16 - BITS)).collect()
}
fn to_be_storage(le: &[u16]) -> std::vec::Vec<u16> {
le.iter()
.map(|&v| u16::from_ne_bytes(v.to_be_bytes()))
.collect()
}
struct AllOutputs {
rgb: std::vec::Vec<u8>,
rgb_u16: std::vec::Vec<u16>,
rgba: std::vec::Vec<u8>,
rgba_u16: std::vec::Vec<u16>,
luma: std::vec::Vec<u8>,
luma_u16: std::vec::Vec<u16>,
h: std::vec::Vec<u8>,
s: std::vec::Vec<u8>,
v: std::vec::Vec<u8>,
}
impl AllOutputs {
fn alloc(n: usize) -> Self {
Self {
rgb: std::vec![0u8; n * 3],
rgb_u16: std::vec![0u16; n * 3],
rgba: std::vec![0u8; n * 4],
rgba_u16: std::vec![0u16; n * 4],
luma: std::vec![0u8; n],
luma_u16: std::vec![0u16; n],
h: std::vec![0u8; n],
s: std::vec![0u8; n],
v: std::vec![0u8; n],
}
}
}
macro_rules! msb_parity_suite {
($mod:ident, $bits:literal, $msb_marker:ident, $msb_walker:ident, $msb_endian:ident, $lo_marker:ident, $lo_walker:ident) => {
mod $mod {
use super::*;
#[test]
#[cfg_attr(miri, ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri")]
fn direct_all_outputs_match_low_bit() {
let w = 37usize;
let h = 5usize;
let n = w * h;
for full_range in [true, false] {
let g = samples::<$bits>(0x1111, n);
let b = samples::<$bits>(0x2222, n);
let r = samples::<$bits>(0x3333, n);
let (gm, bm, rm) = (msb_align::<$bits>(&g), msb_align::<$bits>(&b), msb_align::<$bits>(&r));
let mut o_msb = AllOutputs::alloc(n);
{
let src = crate::frame::GbrpMsbFrame::<$bits>::new(
&gm, &bm, &rm, w as u32, h as u32, w as u32, w as u32, w as u32,
);
let mut sink = MixedSinker::<crate::source::$msb_marker>::new(w, h)
.with_rgb(&mut o_msb.rgb).unwrap()
.with_rgb_u16(&mut o_msb.rgb_u16).unwrap()
.with_rgba(&mut o_msb.rgba).unwrap()
.with_rgba_u16(&mut o_msb.rgba_u16).unwrap()
.with_luma(&mut o_msb.luma).unwrap()
.with_luma_u16(&mut o_msb.luma_u16).unwrap()
.with_hsv(&mut o_msb.h, &mut o_msb.s, &mut o_msb.v).unwrap();
crate::source::$msb_walker(&src, full_range, sink.set_kernel_matrix(MATRIX)).unwrap();
}
let mut o_lo = AllOutputs::alloc(n);
{
let src = crate::frame::GbrpHighBitFrame::<$bits>::new(
&g, &b, &r, w as u32, h as u32, w as u32, w as u32, w as u32,
);
let mut sink = MixedSinker::<crate::source::$lo_marker>::new(w, h)
.with_rgb(&mut o_lo.rgb).unwrap()
.with_rgb_u16(&mut o_lo.rgb_u16).unwrap()
.with_rgba(&mut o_lo.rgba).unwrap()
.with_rgba_u16(&mut o_lo.rgba_u16).unwrap()
.with_luma(&mut o_lo.luma).unwrap()
.with_luma_u16(&mut o_lo.luma_u16).unwrap()
.with_hsv(&mut o_lo.h, &mut o_lo.s, &mut o_lo.v).unwrap();
crate::source::$lo_walker(&src, full_range, sink.set_kernel_matrix(MATRIX)).unwrap();
}
assert_eq!(o_msb.rgb, o_lo.rgb, "rgb full_range={full_range}");
assert_eq!(o_msb.rgb_u16, o_lo.rgb_u16, "rgb_u16 full_range={full_range}");
assert_eq!(o_msb.rgba, o_lo.rgba, "rgba full_range={full_range}");
assert_eq!(o_msb.rgba_u16, o_lo.rgba_u16, "rgba_u16 full_range={full_range}");
assert_eq!(o_msb.luma, o_lo.luma, "luma full_range={full_range}");
assert_eq!(o_msb.luma_u16, o_lo.luma_u16, "luma_u16 full_range={full_range}");
assert_eq!(o_msb.h, o_lo.h, "hsv.h full_range={full_range}");
assert_eq!(o_msb.s, o_lo.s, "hsv.s full_range={full_range}");
assert_eq!(o_msb.v, o_lo.v, "hsv.v full_range={full_range}");
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri")]
fn be_matches_le() {
let w = 20usize;
let h = 3usize;
let n = w * h;
let g = msb_align::<$bits>(&samples::<$bits>(0xAA, n));
let b = msb_align::<$bits>(&samples::<$bits>(0xBB, n));
let r = msb_align::<$bits>(&samples::<$bits>(0xCC, n));
let (gb, bb, rb) = (to_be_storage(&g), to_be_storage(&b), to_be_storage(&r));
let mut le = std::vec![0u16; n * 3];
{
let src = crate::frame::GbrpMsbFrame::<$bits, false>::new(
&g, &b, &r, w as u32, h as u32, w as u32, w as u32, w as u32,
);
let mut sink = MixedSinker::<crate::source::$msb_marker<false>>::new(w, h)
.with_rgb_u16(&mut le).unwrap();
crate::source::$msb_walker(&src, true, sink.set_kernel_matrix(MATRIX)).unwrap();
}
let mut be = std::vec![0u16; n * 3];
{
let src = crate::frame::GbrpMsbFrame::<$bits, true>::new(
&gb, &bb, &rb, w as u32, h as u32, w as u32, w as u32, w as u32,
);
let mut sink = MixedSinker::<crate::source::$msb_marker<true>>::new(w, h)
.with_rgb_u16(&mut be).unwrap();
crate::source::$msb_endian::<_, true>(&src, true, sink.set_kernel_matrix(MATRIX)).unwrap();
}
assert_eq!(le, be, "BE storage must recover the same logical RGB as LE");
}
#[test]
#[cfg_attr(miri, ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri")]
fn simd_matches_scalar() {
for w in [128usize, 130usize] {
let h = 4usize;
let n = w * h;
let g = msb_align::<$bits>(&samples::<$bits>(0x51, n));
let b = msb_align::<$bits>(&samples::<$bits>(0x52, n));
let r = msb_align::<$bits>(&samples::<$bits>(0x53, n));
let mut s_out = AllOutputs::alloc(n);
let mut c_out = AllOutputs::alloc(n);
for (simd, o) in [(true, &mut s_out), (false, &mut c_out)] {
let src = crate::frame::GbrpMsbFrame::<$bits>::new(
&g, &b, &r, w as u32, h as u32, w as u32, w as u32, w as u32,
);
let mut sink = MixedSinker::<crate::source::$msb_marker>::new(w, h)
.with_simd(simd)
.with_rgb(&mut o.rgb).unwrap()
.with_rgb_u16(&mut o.rgb_u16).unwrap()
.with_rgba(&mut o.rgba).unwrap()
.with_rgba_u16(&mut o.rgba_u16).unwrap()
.with_luma_u16(&mut o.luma_u16).unwrap();
crate::source::$msb_walker(&src, true, sink.set_kernel_matrix(MATRIX)).unwrap();
}
assert_eq!(s_out.rgb, c_out.rgb, "rgb simd≠scalar w={w}");
assert_eq!(s_out.rgb_u16, c_out.rgb_u16, "rgb_u16 simd≠scalar w={w}");
assert_eq!(s_out.rgba, c_out.rgba, "rgba simd≠scalar w={w}");
assert_eq!(s_out.rgba_u16, c_out.rgba_u16, "rgba_u16 simd≠scalar w={w}");
assert_eq!(s_out.luma_u16, c_out.luma_u16, "luma_u16 simd≠scalar w={w}");
}
}
#[test]
#[cfg_attr(miri, ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri")]
fn downscale_all_outputs_match_low_bit() {
let src_w = 8usize;
let src_h = 8usize;
let out_w = 4usize;
let out_h = 4usize;
let n = src_w * src_h;
let g = samples::<$bits>(0x71, n);
let b = samples::<$bits>(0x72, n);
let r = samples::<$bits>(0x73, n);
let (gm, bm, rm) = (msb_align::<$bits>(&g), msb_align::<$bits>(&b), msb_align::<$bits>(&r));
let mut o_msb = AllOutputs::alloc(out_w * out_h);
{
let src = crate::frame::GbrpMsbFrame::<$bits>::new(
&gm, &bm, &rm, src_w as u32, src_h as u32, src_w as u32, src_w as u32, src_w as u32,
);
let mut sink = MixedSinker::<crate::source::$msb_marker, crate::resample::AreaResampler>::with_resampler(
src_w, src_h, crate::resample::AreaResampler::to(out_w, out_h),
)
.unwrap()
.with_rgb(&mut o_msb.rgb).unwrap()
.with_rgb_u16(&mut o_msb.rgb_u16).unwrap()
.with_rgba(&mut o_msb.rgba).unwrap()
.with_rgba_u16(&mut o_msb.rgba_u16).unwrap()
.with_luma(&mut o_msb.luma).unwrap()
.with_luma_u16(&mut o_msb.luma_u16).unwrap()
.with_hsv(&mut o_msb.h, &mut o_msb.s, &mut o_msb.v).unwrap();
crate::source::$msb_walker(&src, true, sink.set_kernel_matrix(MATRIX)).unwrap();
}
let mut o_lo = AllOutputs::alloc(out_w * out_h);
{
let src = crate::frame::GbrpHighBitFrame::<$bits>::new(
&g, &b, &r, src_w as u32, src_h as u32, src_w as u32, src_w as u32, src_w as u32,
);
let mut sink = MixedSinker::<crate::source::$lo_marker, crate::resample::AreaResampler>::with_resampler(
src_w, src_h, crate::resample::AreaResampler::to(out_w, out_h),
)
.unwrap()
.with_rgb(&mut o_lo.rgb).unwrap()
.with_rgb_u16(&mut o_lo.rgb_u16).unwrap()
.with_rgba(&mut o_lo.rgba).unwrap()
.with_rgba_u16(&mut o_lo.rgba_u16).unwrap()
.with_luma(&mut o_lo.luma).unwrap()
.with_luma_u16(&mut o_lo.luma_u16).unwrap()
.with_hsv(&mut o_lo.h, &mut o_lo.s, &mut o_lo.v).unwrap();
crate::source::$lo_walker(&src, true, sink.set_kernel_matrix(MATRIX)).unwrap();
}
assert_eq!(o_msb.rgb, o_lo.rgb, "resampled rgb");
assert_eq!(o_msb.rgb_u16, o_lo.rgb_u16, "resampled rgb_u16");
assert_eq!(o_msb.rgba, o_lo.rgba, "resampled rgba");
assert_eq!(o_msb.rgba_u16, o_lo.rgba_u16, "resampled rgba_u16");
assert_eq!(o_msb.luma, o_lo.luma, "resampled luma");
assert_eq!(o_msb.luma_u16, o_lo.luma_u16, "resampled luma_u16");
assert_eq!(o_msb.h, o_lo.h, "resampled hsv.h");
assert_eq!(o_msb.s, o_lo.s, "resampled hsv.s");
assert_eq!(o_msb.v, o_lo.v, "resampled hsv.v");
}
}
};
}
msb_parity_suite!(
bits10,
10,
Gbrp10Msb,
gbrp10_msb_to,
gbrp10_msb_to_endian,
Gbrp10,
gbrp10_to
);
msb_parity_suite!(
bits12,
12,
Gbrp12Msb,
gbrp12_msb_to,
gbrp12_msb_to_endian,
Gbrp12,
gbrp12_to
);