use crate::{
KernelMatrix,
resample::{AreaResampler, FilteredResampler, Resampler, Triangle},
sinker::{AlphaMode, MixedSinker, MixedSinkerError},
source::{Rgb48, rgb48_to},
};
use mediaframe::frame::Rgb48Frame;
const SRC: usize = 8;
const OUT: usize = 4;
fn as_le_u32(host: &[u32]) -> Vec<u32> {
host
.iter()
.map(|v| u32::from_ne_bytes(v.to_le_bytes()))
.collect()
}
fn as_be_u32(host: &[u32]) -> Vec<u32> {
host
.iter()
.map(|v| u32::from_ne_bytes(v.to_be_bytes()))
.collect()
}
fn plane_u32(seed: u32) -> Vec<u32> {
(0..SRC * SRC)
.map(|i| (i as u32).wrapping_mul(seed).wrapping_add(0xABCD))
.collect()
}
fn staged_rgba_u32(g: &[u32], b: &[u32], r: &[u32], a: &[u32], side: usize) -> Vec<u32> {
let mut out = vec![0u32; side * side * 4];
for i in 0..side * side {
out[i * 4] = r[i];
out[i * 4 + 1] = g[i];
out[i * 4 + 2] = b[i];
out[i * 4 + 3] = a[i];
}
out
}
fn area_u32_narrowed(staged: &[u32], ox: usize, oy: usize, c: usize, src_w: usize) -> u16 {
let mut acc = 0u64;
for dy in 0..2 {
for dx in 0..2 {
acc += staged[((oy * 2 + dy) * src_w + ox * 2 + dx) * 4 + c] as u64;
}
}
(((acc + 2) / 4) >> 16) as u16
}
fn separable_triangle_u32_narrowed(
staged: &[u32],
channels: usize,
sw: usize,
sh: usize,
ow: usize,
oh: usize,
) -> Vec<u16> {
let plan = FilteredResampler::new(ow, oh, Triangle)
.plan(sw, sh)
.expect("valid filter plan")
.expect("non-identity");
let fh = plan.filter_h().expect("h windows");
let fv = plan.filter_v().expect("v windows");
let mut h_inter = vec![0.0f64; sh * ow * channels];
for sy in 0..sh {
for ox in 0..ow {
let (start, coeffs) = fh.span(ox);
for ch in 0..channels {
let mut acc = 0.0f64;
for (k, &w) in coeffs.iter().enumerate() {
acc += f64::from(w) * staged[(sy * sw + start + k) * channels + ch] as f64;
}
h_inter[(sy * ow + ox) * channels + ch] = (acc + 0.5).floor();
}
}
}
let mut out = vec![0u16; oh * ow * channels];
for oy in 0..oh {
let (start, coeffs) = fv.span(oy);
for ox in 0..ow {
for ch in 0..channels {
let mut acc = 0.0f64;
for (k, &w) in coeffs.iter().enumerate() {
acc += f64::from(w) * h_inter[((start + k) * ow + ox) * channels + ch];
}
let v = (acc + 0.5).floor().clamp(0.0, u32::MAX as f64) as u32;
out[(oy * ow + ox) * channels + ch] = (v >> 16) as u16;
}
}
}
out
}
#[test]
fn gbrap32_downscale_rgba_u16_is_exact_u32_area_mean_incl_alpha() {
let g = plane_u32(0x0011_0007);
let b = plane_u32(0x0033_0009);
let r = plane_u32(0x0055_000B);
let a = plane_u32(0x0077_000D);
let staged = staged_rgba_u32(&g, &b, &r, &a, SRC);
let (gw, bw, rw, aw) = (as_le_u32(&g), as_le_u32(&b), as_le_u32(&r), as_le_u32(&a));
let src = crate::frame::Gbrap32LeFrame::try_new(
&gw, &bw, &rw, &aw, SRC as u32, SRC as u32, SRC as u32, SRC as u32, SRC as u32, SRC as u32,
)
.unwrap();
let mut rgba_u16 = vec![0u16; OUT * OUT * 4];
let mut luma_u16 = vec![0u16; OUT * OUT];
{
let mut sink = MixedSinker::<crate::source::Gbrap32, AreaResampler>::with_resampler(
SRC,
SRC,
AreaResampler::to(OUT, OUT),
)
.unwrap()
.with_rgba_u16(&mut rgba_u16)
.unwrap()
.with_luma_u16(&mut luma_u16)
.unwrap();
crate::source::gbrap32_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let mut oracle_rgba = vec![0u16; OUT * OUT * 4];
for oy in 0..OUT {
for ox in 0..OUT {
for c in 0..4 {
oracle_rgba[(oy * OUT + ox) * 4 + c] = area_u32_narrowed(&staged, ox, oy, c, SRC);
}
}
}
assert_eq!(
rgba_u16, oracle_rgba,
"rgba_u16 — exact u32 mean narrowed >> 16 (alpha is c3)"
);
let oracle_rgb = drop_alpha_u16(&oracle_rgba);
assert_eq!(
luma_u16,
gbrap32_native_luma_u16(&oracle_rgb, OUT, true),
"luma_u16 — native Q15 from the binned RGB"
);
}
#[test]
fn gbrap32_identity_plan_matches_new_sink() {
let g = plane_u32(0x0011_0007);
let b = plane_u32(0x0033_0009);
let r = plane_u32(0x0055_000B);
let a = plane_u32(0x0077_000D);
let src = crate::frame::Gbrap32LeFrame::try_new(
&g, &b, &r, &a, SRC as u32, SRC as u32, SRC as u32, SRC as u32, SRC as u32, SRC as u32,
)
.unwrap();
let mut direct = vec![0u16; SRC * SRC * 4];
{
let mut sink = MixedSinker::<crate::source::Gbrap32>::new(SRC, SRC)
.with_rgba_u16(&mut direct)
.unwrap();
crate::source::gbrap32_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let mut via_area = vec![0u16; SRC * SRC * 4];
{
let mut sink = MixedSinker::<crate::source::Gbrap32, AreaResampler>::with_resampler(
SRC,
SRC,
AreaResampler::to(SRC, SRC),
)
.unwrap()
.with_rgba_u16(&mut via_area)
.unwrap();
crate::source::gbrap32_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
assert_eq!(direct, via_area);
}
const FRP: usize = 4; const FRO: usize = 2;
fn frp_plane(seed: u32) -> Vec<u32> {
(0..FRP * FRP)
.map(|i| (i as u32).wrapping_mul(seed).wrapping_add(0xBEEF))
.collect()
}
#[test]
fn gbrap32_fr_false_area_rgba_u16_is_u32_domain_mean() {
let g = frp_plane(0x0123_4567);
let b = frp_plane(0x0246_8ACE);
let r = frp_plane(0x0FED_CBA9);
let a = frp_plane(0x0777_1333);
let staged = staged_rgba_u32(&g, &b, &r, &a, FRP);
let mut expected = vec![0u16; FRO * FRO * 4];
for oy in 0..FRO {
for ox in 0..FRO {
for c in 0..4 {
expected[(oy * FRO + ox) * 4 + c] = area_u32_narrowed(&staged, ox, oy, c, FRP);
}
}
}
let (gl, bl, rl, al) = (as_le_u32(&g), as_le_u32(&b), as_le_u32(&r), as_le_u32(&a));
let mut out_le = vec![0u16; FRO * FRO * 4];
{
let src = crate::frame::Gbrap32LeFrame::try_new(
&gl, &bl, &rl, &al, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
let mut sink = MixedSinker::<crate::source::Gbrap32, AreaResampler>::with_resampler(
FRP,
FRP,
AreaResampler::to(FRO, FRO),
)
.unwrap()
.with_rgba_u16(&mut out_le)
.unwrap();
crate::source::gbrap32_to(&src, false, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let (gb, bb, rb, ab) = (as_be_u32(&g), as_be_u32(&b), as_be_u32(&r), as_be_u32(&a));
let mut out_be = vec![0u16; FRO * FRO * 4];
{
let src = crate::frame::Gbrap32BeFrame::try_new(
&gb, &bb, &rb, &ab, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
let mut sink = MixedSinker::<crate::source::Gbrap32<true>, AreaResampler>::with_resampler(
FRP,
FRP,
AreaResampler::to(FRO, FRO),
)
.unwrap()
.with_rgba_u16(&mut out_be)
.unwrap();
crate::source::gbrap32_to_endian::<_, true>(
&src,
false,
sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
}
assert_eq!(
out_le, expected,
"Gbrap32 FR=false area rgba_u16 LE (0-ULP)"
);
assert_eq!(
out_be, expected,
"Gbrap32 FR=false area rgba_u16 BE (0-ULP)"
);
}
fn assert_gbrap32_4ch_filter(g: &[u32], b: &[u32], r: &[u32], a: &[u32], full_range: bool) {
let staged = staged_rgba_u32(g, b, r, a, FRP);
let oracle_rgba = separable_triangle_u32_narrowed(&staged, 4, FRP, FRP, FRO, FRO);
let oracle_rgb = drop_alpha_u16(&oracle_rgba);
let oracle_rgba_u8 = narrow_u16(&oracle_rgba);
let (ref_rgb, ref_luma, ref_h, ref_s, ref_v) = rgb48_rgb_luma_hsv(&oracle_rgb, FRO, full_range);
let ref_lu16 = gbrap32_native_luma_u16(&oracle_rgb, FRO, full_range);
for be in [false, true] {
let mut rgb = vec![0u8; FRO * FRO * 3];
let mut rgba = vec![0u8; FRO * FRO * 4];
let mut rgb_u16 = vec![0u16; FRO * FRO * 3];
let mut rgba_u16 = vec![0u16; FRO * FRO * 4];
let mut luma = vec![0u8; FRO * FRO];
let mut luma_u16 = vec![0u16; FRO * FRO];
let mut h = vec![0u8; FRO * FRO];
let mut s_ = vec![0u8; FRO * FRO];
let mut v_ = vec![0u8; FRO * FRO];
macro_rules! attach {
($sink:expr) => {
$sink
.with_rgb(&mut rgb)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_rgb_u16(&mut rgb_u16)
.unwrap()
.with_rgba_u16(&mut rgba_u16)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma_u16)
.unwrap()
.with_hsv(&mut h, &mut s_, &mut v_)
.unwrap()
};
}
if be {
let (gb, bb, rb, ab) = (as_be_u32(g), as_be_u32(b), as_be_u32(r), as_be_u32(a));
let src = crate::frame::Gbrap32BeFrame::try_new(
&gb, &bb, &rb, &ab, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
let sink =
MixedSinker::<crate::source::Gbrap32<true>, FilteredResampler<Triangle>>::with_resampler(
FRP,
FRP,
FilteredResampler::new(FRO, FRO, Triangle),
)
.unwrap();
let mut sink = attach!(sink);
crate::source::gbrap32_to_endian::<_, true>(
&src,
full_range,
sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
} else {
let (gl, bl, rl, al) = (as_le_u32(g), as_le_u32(b), as_le_u32(r), as_le_u32(a));
let src = crate::frame::Gbrap32LeFrame::try_new(
&gl, &bl, &rl, &al, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
let sink =
MixedSinker::<crate::source::Gbrap32, FilteredResampler<Triangle>>::with_resampler(
FRP,
FRP,
FilteredResampler::new(FRO, FRO, Triangle),
)
.unwrap();
let mut sink = attach!(sink);
crate::source::gbrap32_to(
&src,
full_range,
sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
}
let tag = if be { "BE" } else { "LE" };
assert_eq!(
rgba_u16, oracle_rgba,
"Gbrap32 4ch filter rgba_u16 {tag} (0-ULP)"
);
assert_eq!(rgb_u16, oracle_rgb, "Gbrap32 4ch filter rgb_u16 {tag}");
assert_eq!(rgba, oracle_rgba_u8, "Gbrap32 4ch filter rgba (u8) {tag}");
assert_eq!(rgb, ref_rgb, "Gbrap32 4ch filter rgb (u8) {tag}");
assert_eq!(luma, ref_luma, "Gbrap32 4ch filter luma {tag}");
assert_eq!(
luma_u16, ref_lu16,
"Gbrap32 4ch filter luma_u16 (native) {tag}"
);
assert_eq!(h, ref_h, "Gbrap32 4ch filter hsv-h {tag}");
assert_eq!(s_, ref_s, "Gbrap32 4ch filter hsv-s {tag}");
assert_eq!(v_, ref_v, "Gbrap32 4ch filter hsv-v {tag}");
}
}
#[test]
fn gbrap32_fr_false_filter_all_outputs_is_u32_domain() {
assert_gbrap32_4ch_filter(
&frp_plane(0x0123_4567),
&frp_plane(0x0246_8ACE),
&frp_plane(0x0FED_CBA9),
&frp_plane(0x0777_1333),
false,
);
}
fn gap_r_plane() -> Vec<u32> {
let mut p: Vec<u32> = (0..FRP * FRP)
.map(|i| (i as u32).wrapping_mul(0x00AB_1357).wrapping_add(0xABCD))
.collect();
p[0] = 0x0001_FFFF;
p[1] = 0x0000_FFFF;
p[FRP] = 0x0000_FFFF; p[FRP + 1] = 0x0000_FFFF; p
}
#[test]
fn gbrap32_fr_true_area_rgba_u16_is_u32_domain_mean() {
let r = gap_r_plane();
let g = frp_plane(0x0246_8ACE);
let b = frp_plane(0x0FED_CBA9);
let a = frp_plane(0x0777_1333);
let staged = staged_rgba_u32(&g, &b, &r, &a, FRP);
let mut expected = vec![0u16; FRO * FRO * 4];
for oy in 0..FRO {
for ox in 0..FRO {
for c in 0..4 {
expected[(oy * FRO + ox) * 4 + c] = area_u32_narrowed(&staged, ox, oy, c, FRP);
}
}
}
assert_eq!(expected[0], 1, "exact u32-domain R(0,0)");
let (gl, bl, rl, al) = (as_le_u32(&g), as_le_u32(&b), as_le_u32(&r), as_le_u32(&a));
let mut out_le = vec![0u16; FRO * FRO * 4];
{
let src = crate::frame::Gbrap32LeFrame::try_new(
&gl, &bl, &rl, &al, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
let mut sink = MixedSinker::<crate::source::Gbrap32, AreaResampler>::with_resampler(
FRP,
FRP,
AreaResampler::to(FRO, FRO),
)
.unwrap()
.with_rgba_u16(&mut out_le)
.unwrap();
crate::source::gbrap32_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let (gb, bb, rb, ab) = (as_be_u32(&g), as_be_u32(&b), as_be_u32(&r), as_be_u32(&a));
let mut out_be = vec![0u16; FRO * FRO * 4];
{
let src = crate::frame::Gbrap32BeFrame::try_new(
&gb, &bb, &rb, &ab, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
let mut sink = MixedSinker::<crate::source::Gbrap32<true>, AreaResampler>::with_resampler(
FRP,
FRP,
AreaResampler::to(FRO, FRO),
)
.unwrap()
.with_rgba_u16(&mut out_be)
.unwrap();
crate::source::gbrap32_to_endian::<_, true>(
&src,
true,
sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
}
assert_eq!(out_le, expected, "Gbrap32 FR=true area rgba_u16 LE (0-ULP)");
assert_eq!(out_be, expected, "Gbrap32 FR=true area rgba_u16 BE (0-ULP)");
}
#[test]
fn gbrap32_fr_true_filter_all_outputs_is_u32_domain() {
let mut r = std::vec![0x0000_FFFFu32; FRP * FRP];
r[0] = 0x0001_FFFF; r[1] = 0x0001_FFFF; let g = frp_plane(0x0123_4567);
let b = frp_plane(0x0246_8ACE);
let a = frp_plane(0x0777_1333);
let staged = staged_rgba_u32(&g, &b, &r, &a, FRP);
let oracle = separable_triangle_u32_narrowed(&staged, 4, FRP, FRP, FRO, FRO);
assert_eq!(oracle[0], 1, "independent u32-domain Triangle R(0,0)");
assert_gbrap32_4ch_filter(&g, &b, &r, &a, true);
}
const PMAX: u64 = u32::MAX as u64;
fn as_le_u16(host: &[u16]) -> Vec<u16> {
host
.iter()
.map(|v| u16::from_ne_bytes(v.to_le_bytes()))
.collect()
}
fn premult_area_rgba_u16(src: &[u32], src_w: usize, out_w: usize) -> Vec<u16> {
let n = src_w * src_w;
let mut pm = vec![0u64; n * 4];
for i in 0..n {
let a = src[i * 4 + 3] as u64;
for c in 0..3 {
pm[i * 4 + c] = (src[i * 4 + c] as u64 * a + PMAX / 2) / PMAX;
}
pm[i * 4 + 3] = a;
}
let mut out = vec![0u16; out_w * out_w * 4];
for oy in 0..out_w {
for ox in 0..out_w {
let mut binned = [0u64; 4];
for (c, b) in binned.iter_mut().enumerate() {
let mut acc = 0u64;
for dy in 0..2 {
for dx in 0..2 {
acc += pm[((oy * 2 + dy) * src_w + ox * 2 + dx) * 4 + c];
}
}
*b = (acc + 2) / 4;
}
let a = binned[3];
for c in 0..3 {
let straight = (binned[c] * PMAX + a / 2)
.checked_div(a)
.map_or(0, |q| q.min(PMAX));
out[(oy * out_w + ox) * 4 + c] = (straight >> 16) as u16;
}
out[(oy * out_w + ox) * 4 + 3] = (a >> 16) as u16;
}
}
out
}
fn drop_alpha_u16(rgba: &[u16]) -> Vec<u16> {
rgba
.chunks_exact(4)
.flat_map(|px| [px[0], px[1], px[2]])
.collect()
}
fn narrow_u16(v: &[u16]) -> Vec<u8> {
v.iter().map(|&x| (x >> 8) as u8).collect()
}
fn premult_gbrap_planes() -> (Vec<u32>, Vec<u32>, Vec<u32>, Vec<u32>) {
let g = frp_plane(0x0123_4567);
let b = frp_plane(0x0246_8ACE);
let r = frp_plane(0x0FED_CBA9);
let mut a = frp_plane(0x0777_1333);
for &(sx, sy) in &[(0usize, 0usize), (1, 0), (0, 1), (1, 1)] {
a[sy * FRP + sx] = 0;
}
(g, b, r, a)
}
#[test]
fn gbrap32_premult_area_matches_u32_premult_oracle() {
let (g, b, r, a) = premult_gbrap_planes();
let staged = staged_rgba_u32(&g, &b, &r, &a, FRP);
let oracle = premult_area_rgba_u16(&staged, FRP, FRO);
let straight_rgb = drop_alpha_u16(&oracle);
let rgb_wire = as_le_u16(&straight_rgb);
let mut ref_rgb = vec![0u8; FRO * FRO * 3];
let mut ref_luma = vec![0u8; FRO * FRO];
let mut ref_h = vec![0u8; FRO * FRO];
let mut ref_s = vec![0u8; FRO * FRO];
let mut ref_v = vec![0u8; FRO * FRO];
{
let binned = Rgb48Frame::new(&rgb_wire, FRO as u32, FRO as u32, (FRO * 3) as u32);
let mut sink = MixedSinker::<Rgb48>::new(FRO, FRO)
.with_rgb(&mut ref_rgb)
.unwrap()
.with_luma(&mut ref_luma)
.unwrap()
.with_hsv(&mut ref_h, &mut ref_s, &mut ref_v)
.unwrap();
rgb48_to(&binned, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
for be in [false, true] {
let mut rgba_u16 = vec![0u16; FRO * FRO * 4];
let mut rgb_u16 = vec![0u16; FRO * FRO * 3];
let mut rgba = vec![0u8; FRO * FRO * 4];
let mut rgb = vec![0u8; FRO * FRO * 3];
let mut luma = vec![0u8; FRO * FRO];
let mut h = vec![0u8; FRO * FRO];
let mut s_ = vec![0u8; FRO * FRO];
let mut v_ = vec![0u8; FRO * FRO];
if be {
let (gb, bb, rb, ab) = (as_be_u32(&g), as_be_u32(&b), as_be_u32(&r), as_be_u32(&a));
let src = crate::frame::Gbrap32BeFrame::try_new(
&gb, &bb, &rb, &ab, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
let mut sink = MixedSinker::<crate::source::Gbrap32<true>, AreaResampler>::with_resampler(
FRP,
FRP,
AreaResampler::to(FRO, FRO),
)
.unwrap()
.with_alpha_mode(AlphaMode::Premultiplied)
.with_rgba_u16(&mut rgba_u16)
.unwrap()
.with_rgb_u16(&mut rgb_u16)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_rgb(&mut rgb)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_hsv(&mut h, &mut s_, &mut v_)
.unwrap();
crate::source::gbrap32_to_endian::<_, true>(
&src,
true,
sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
} else {
let (gl, bl, rl, al) = (as_le_u32(&g), as_le_u32(&b), as_le_u32(&r), as_le_u32(&a));
let src = crate::frame::Gbrap32LeFrame::try_new(
&gl, &bl, &rl, &al, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
let mut sink = MixedSinker::<crate::source::Gbrap32, AreaResampler>::with_resampler(
FRP,
FRP,
AreaResampler::to(FRO, FRO),
)
.unwrap()
.with_alpha_mode(AlphaMode::Premultiplied)
.with_rgba_u16(&mut rgba_u16)
.unwrap()
.with_rgb_u16(&mut rgb_u16)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_rgb(&mut rgb)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_hsv(&mut h, &mut s_, &mut v_)
.unwrap();
crate::source::gbrap32_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let tag = if be { "BE" } else { "LE" };
assert_eq!(rgba_u16, oracle, "Gbrap32 premult rgba_u16 {tag}");
assert_eq!(rgb_u16, straight_rgb, "Gbrap32 premult rgb_u16 {tag}");
assert_eq!(rgba, narrow_u16(&oracle), "Gbrap32 premult rgba (u8) {tag}");
assert_eq!(
&rgba_u16[..4],
&[0, 0, 0, 0],
"Gbrap32 transparent bled {tag}"
);
assert_eq!(rgb, ref_rgb, "Gbrap32 premult rgb (u8) {tag}");
assert_eq!(luma, ref_luma, "Gbrap32 premult luma {tag}");
assert_eq!(h, ref_h, "Gbrap32 premult hsv-h {tag}");
assert_eq!(s_, ref_s, "Gbrap32 premult hsv-s {tag}");
assert_eq!(v_, ref_v, "Gbrap32 premult hsv-v {tag}");
}
}
fn area_rgb_u32_narrowed(staged: &[u32], ox: usize, oy: usize, c: usize, src_w: usize) -> u16 {
let mut acc = 0u64;
for dy in 0..2 {
for dx in 0..2 {
acc += staged[((oy * 2 + dy) * src_w + ox * 2 + dx) * 3 + c] as u64;
}
}
(((acc + 2) / 4) >> 16) as u16
}
fn gbrap32_drop_rgb_u32(g: &[u32], b: &[u32], r: &[u32], side: usize) -> Vec<u32> {
let mut out = vec![0u32; side * side * 3];
for i in 0..side * side {
out[i * 3] = r[i];
out[i * 3 + 1] = g[i];
out[i * 3 + 2] = b[i];
}
out
}
type RgbLumaHsv = (Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>);
fn rgb48_rgb_luma_hsv(rgb_u16: &[u16], n: usize, full_range: bool) -> RgbLumaHsv {
let wire = as_le_u16(rgb_u16);
let src = Rgb48Frame::new(&wire, n as u32, n as u32, (n * 3) as u32);
let mut rgb = vec![0u8; n * n * 3];
let mut luma = vec![0u8; n * n];
let mut h = vec![0u8; n * n];
let mut s = vec![0u8; n * n];
let mut v = vec![0u8; n * n];
{
let mut sink = MixedSinker::<Rgb48>::new(n, n)
.with_rgb(&mut rgb)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_hsv(&mut h, &mut s, &mut v)
.unwrap();
rgb48_to(
&src,
full_range,
sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
}
(rgb, luma, h, s, v)
}
fn gbrap32_native_luma_u16(rgb_u16: &[u16], n: usize, full_range: bool) -> Vec<u16> {
let px = n * n;
let mut g = vec![0u32; px];
let mut b = vec![0u32; px];
let mut r = vec![0u32; px];
let a = vec![0u32; px];
for i in 0..px {
r[i] = (rgb_u16[i * 3] as u32) << 16;
g[i] = (rgb_u16[i * 3 + 1] as u32) << 16;
b[i] = (rgb_u16[i * 3 + 2] as u32) << 16;
}
let (gl, bl, rl, al) = (as_le_u32(&g), as_le_u32(&b), as_le_u32(&r), as_le_u32(&a));
let src = crate::frame::Gbrap32LeFrame::try_new(
&gl, &bl, &rl, &al, n as u32, n as u32, n as u32, n as u32, n as u32, n as u32,
)
.unwrap();
let mut luma_u16 = vec![0u16; px];
{
let mut sink = MixedSinker::<crate::source::Gbrap32>::new(n, n)
.with_luma_u16(&mut luma_u16)
.unwrap();
crate::source::gbrap32_to(
&src,
full_range,
sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
}
luma_u16
}
#[test]
fn gbrap32_drop_alpha_area_route_is_u32_domain() {
let g = frp_plane(0x0123_4567);
let b = frp_plane(0x0246_8ACE);
let r = frp_plane(0x0FED_CBA9);
let a = frp_plane(0x0777_1333);
let rgb_src = gbrap32_drop_rgb_u32(&g, &b, &r, FRP);
let mut oracle = vec![0u16; FRO * FRO * 3];
for oy in 0..FRO {
for ox in 0..FRO {
for c in 0..3 {
oracle[(oy * FRO + ox) * 3 + c] = area_rgb_u32_narrowed(&rgb_src, ox, oy, c, FRP);
}
}
}
let (ref_rgb, ref_luma, ref_h, ref_s, ref_v) = rgb48_rgb_luma_hsv(&oracle, FRO, true);
let ref_lu16 = gbrap32_native_luma_u16(&oracle, FRO, true);
run_gbrap32_drop_route(
&g, &b, &r, &a, false, &oracle, &ref_rgb, &ref_luma, &ref_lu16, &ref_h, &ref_s, &ref_v, "area",
);
}
#[test]
fn gbrap32_drop_alpha_filter_route_is_u32_domain() {
let g = frp_plane(0x0123_4567);
let b = frp_plane(0x0246_8ACE);
let r = frp_plane(0x0FED_CBA9);
let a = frp_plane(0x0777_1333);
let rgb_src = gbrap32_drop_rgb_u32(&g, &b, &r, FRP);
let oracle = separable_triangle_u32_narrowed(&rgb_src, 3, FRP, FRP, FRO, FRO);
let (ref_rgb, ref_luma, ref_h, ref_s, ref_v) = rgb48_rgb_luma_hsv(&oracle, FRO, true);
let ref_lu16 = gbrap32_native_luma_u16(&oracle, FRO, true);
run_gbrap32_drop_route(
&g, &b, &r, &a, true, &oracle, &ref_rgb, &ref_luma, &ref_lu16, &ref_h, &ref_s, &ref_v, "filter",
);
}
#[allow(clippy::too_many_arguments)]
fn run_gbrap32_drop_route(
g: &[u32],
b: &[u32],
r: &[u32],
a: &[u32],
is_filter: bool,
oracle_rgb_u16: &[u16],
ref_rgb: &[u8],
ref_luma: &[u8],
ref_lu16: &[u16],
ref_h: &[u8],
ref_s: &[u8],
ref_v: &[u8],
kind: &str,
) {
for be in [false, true] {
let mut rgb_u16 = vec![0u16; FRO * FRO * 3];
let mut rgb = vec![0u8; FRO * FRO * 3];
let mut luma = vec![0u8; FRO * FRO];
let mut luma_u16 = vec![0u16; FRO * FRO];
let mut h = vec![0u8; FRO * FRO];
let mut s_ = vec![0u8; FRO * FRO];
let mut v_ = vec![0u8; FRO * FRO];
macro_rules! attach {
($sink:expr) => {
$sink
.with_rgb_u16(&mut rgb_u16)
.unwrap()
.with_rgb(&mut rgb)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma_u16)
.unwrap()
.with_hsv(&mut h, &mut s_, &mut v_)
.unwrap()
};
}
if be {
let (gb, bb, rb, ab) = (as_be_u32(g), as_be_u32(b), as_be_u32(r), as_be_u32(a));
let src = crate::frame::Gbrap32BeFrame::try_new(
&gb, &bb, &rb, &ab, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
if is_filter {
let sink =
MixedSinker::<crate::source::Gbrap32<true>, FilteredResampler<Triangle>>::with_resampler(
FRP,
FRP,
FilteredResampler::new(FRO, FRO, Triangle),
)
.unwrap();
let mut sink = attach!(sink);
crate::source::gbrap32_to_endian::<_, true>(
&src,
true,
sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
} else {
let sink = MixedSinker::<crate::source::Gbrap32<true>, AreaResampler>::with_resampler(
FRP,
FRP,
AreaResampler::to(FRO, FRO),
)
.unwrap();
let mut sink = attach!(sink);
crate::source::gbrap32_to_endian::<_, true>(
&src,
true,
sink.set_kernel_matrix(KernelMatrix::Bt709),
)
.unwrap();
}
} else {
let (gl, bl, rl, al) = (as_le_u32(g), as_le_u32(b), as_le_u32(r), as_le_u32(a));
let src = crate::frame::Gbrap32LeFrame::try_new(
&gl, &bl, &rl, &al, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
if is_filter {
let sink =
MixedSinker::<crate::source::Gbrap32, FilteredResampler<Triangle>>::with_resampler(
FRP,
FRP,
FilteredResampler::new(FRO, FRO, Triangle),
)
.unwrap();
let mut sink = attach!(sink);
crate::source::gbrap32_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
} else {
let sink = MixedSinker::<crate::source::Gbrap32, AreaResampler>::with_resampler(
FRP,
FRP,
AreaResampler::to(FRO, FRO),
)
.unwrap();
let mut sink = attach!(sink);
crate::source::gbrap32_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
}
let tag = if be { "BE" } else { "LE" };
assert_eq!(
rgb_u16, oracle_rgb_u16,
"Gbrap32 drop-α {kind} rgb_u16 {tag}"
);
assert_eq!(rgb, ref_rgb, "Gbrap32 drop-α {kind} rgb {tag}");
assert_eq!(luma, ref_luma, "Gbrap32 drop-α {kind} luma {tag}");
assert_eq!(
luma_u16, ref_lu16,
"Gbrap32 drop-α {kind} luma_u16 (native) {tag}"
);
assert_eq!(h, ref_h, "Gbrap32 drop-α {kind} hsv-h {tag}");
assert_eq!(s_, ref_s, "Gbrap32 drop-α {kind} hsv-s {tag}");
assert_eq!(v_, ref_v, "Gbrap32 drop-α {kind} hsv-v {tag}");
}
}
#[test]
fn gbrap32_premult_filter_rejects() {
let g = frp_plane(0x0123_4567);
let b = frp_plane(0x0246_8ACE);
let r = frp_plane(0x0FED_CBA9);
let a = frp_plane(0x0777_1333);
let (gl, bl, rl, al) = (as_le_u32(&g), as_le_u32(&b), as_le_u32(&r), as_le_u32(&a));
let src = crate::frame::Gbrap32LeFrame::try_new(
&gl, &bl, &rl, &al, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32, FRP as u32,
)
.unwrap();
let mut rgba_u16 = vec![0u16; FRO * FRO * 4];
let mut sink =
MixedSinker::<crate::source::Gbrap32, FilteredResampler<Triangle>>::with_resampler(
FRP,
FRP,
FilteredResampler::new(FRO, FRO, Triangle),
)
.unwrap()
.with_alpha_mode(AlphaMode::Premultiplied)
.with_rgba_u16(&mut rgba_u16)
.unwrap();
let err =
crate::source::gbrap32_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(crate::resample::ResampleError::UnsupportedFilter(_))
),
"Gbrap32 premult+filter must reject: {err:?}"
);
}