use super::*;
use crate::{
resample::AreaResampler,
sinker::{AlphaMode, MixedSinker},
source::{Gbrapf32, gbrapf32_to},
};
const SRC: usize = 8;
const OUT: usize = 4;
fn as_le_f32(host: &[f32]) -> Vec<f32> {
host
.iter()
.map(|&v| f32::from_bits(v.to_bits().to_le()))
.collect()
}
fn as_be_f32(host: &[f32]) -> Vec<f32> {
host
.iter()
.map(|&v| f32::from_bits(v.to_bits().to_be()))
.collect()
}
fn gbra_planes() -> (Vec<f32>, Vec<f32>, Vec<f32>, Vec<f32>) {
let n = SRC * SRC;
let mut g = std::vec![0.0f32; n];
let mut b = std::vec![0.0f32; n];
let mut r = std::vec![0.0f32; n];
let mut a = std::vec![0.0f32; n];
for i in 0..n {
let ii = i as i32;
r[i] = (ii % 5) as f32;
g[i] = (100 - ii) as f32;
b[i] = -((ii % 7) as f32);
a[i] = (ii % 4) as f32;
}
(g, b, r, a)
}
fn frame<'a>(
g: &'a [f32],
b: &'a [f32],
r: &'a [f32],
a: &'a [f32],
w: usize,
h: usize,
) -> crate::frame::Gbrapf32Frame<'a> {
crate::frame::Gbrapf32Frame::try_new(
g, b, r, a, w as u32, h as u32, w as u32, w as u32, w as u32, w as u32,
)
.unwrap()
}
fn block_mean_plane(plane: &[f32], ox: usize, oy: usize) -> f32 {
let mut acc = 0.0f64;
for dy in 0..2 {
for dx in 0..2 {
acc += plane[(oy * 2 + dy) * SRC + ox * 2 + dx] as f64;
}
}
(acc / 4.0) as f32
}
fn planes_from_packed_rgba(rgba: &[f32], n: usize) -> (Vec<f32>, Vec<f32>, Vec<f32>, Vec<f32>) {
let (mut g, mut b, mut r, mut a) = (
std::vec![0.0f32; n],
std::vec![0.0f32; n],
std::vec![0.0f32; n],
std::vec![0.0f32; n],
);
for i in 0..n {
r[i] = rgba[i * 4];
g[i] = rgba[i * 4 + 1];
b[i] = rgba[i * 4 + 2];
a[i] = rgba[i * 4 + 3];
}
(g, b, r, a)
}
fn planes_from_packed_rgb(rgb: &[f32], n: usize) -> (Vec<f32>, Vec<f32>, Vec<f32>) {
let (mut g, mut b, mut r) = (
std::vec![0.0f32; n],
std::vec![0.0f32; n],
std::vec![0.0f32; n],
);
for i in 0..n {
r[i] = rgb[i * 3];
g[i] = rgb[i * 3 + 1];
b[i] = rgb[i * 3 + 2];
}
(g, b, r)
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_downscale_rgba_f32_is_exact_area_mean() {
let (g, b, r, a) = gbra_planes();
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut rgba_f32 = std::vec![0.0f32; OUT * OUT * 4];
{
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_rgba_f32(&mut rgba_f32)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
for oy in 0..OUT {
for ox in 0..OUT {
let base = (oy * OUT + ox) * 4;
assert_eq!(
rgba_f32[base],
block_mean_plane(&r, ox, oy),
"R ({ox},{oy})"
);
assert_eq!(
rgba_f32[base + 1],
block_mean_plane(&g, ox, oy),
"G ({ox},{oy})"
);
assert_eq!(
rgba_f32[base + 2],
block_mean_plane(&b, ox, oy),
"B ({ox},{oy})"
);
assert_eq!(
rgba_f32[base + 3],
block_mean_plane(&a, ox, oy),
"A ({ox},{oy})"
);
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_straight_alpha_is_averaged_not_forced_opaque() {
let (g, b, r, a) = gbra_planes();
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut rgba_f32 = std::vec![0.0f32; OUT * OUT * 4];
{
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_rgba_f32(&mut rgba_f32)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
assert!(
rgba_f32
.chunks_exact(4)
.any(|px| px[3] != 0.0 && px[3] != 1.0),
"resampled α was forced to a constant — area-mean α lost"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_all_outputs_match_direct_conversion_of_prebinned_frame() {
let (g, b, r, a) = gbra_planes();
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut rgb = std::vec![0u8; OUT * OUT * 3];
let mut rgb_u16 = std::vec![0u16; OUT * OUT * 3];
let mut rgb_f32 = std::vec![0.0f32; OUT * OUT * 3];
let mut rgba = std::vec![0u8; OUT * OUT * 4];
let mut rgba_u16 = std::vec![0u16; OUT * OUT * 4];
let mut rgba_f32 = std::vec![0.0f32; OUT * OUT * 4];
let mut rgb_f16 = std::vec![half::f16::ZERO; OUT * OUT * 3];
let mut rgba_f16 = std::vec![half::f16::ZERO; OUT * OUT * 4];
let mut luma = std::vec![0u8; OUT * OUT];
let mut luma_u16 = std::vec![0u16; OUT * OUT];
let mut h = std::vec![0u8; OUT * OUT];
let mut s_ = std::vec![0u8; OUT * OUT];
let mut v_ = std::vec![0u8; OUT * OUT];
{
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_rgb(&mut rgb)
.unwrap()
.with_rgb_u16(&mut rgb_u16)
.unwrap()
.with_rgb_f32(&mut rgb_f32)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba_u16)
.unwrap()
.with_rgba_f32(&mut rgba_f32)
.unwrap()
.with_rgb_f16(&mut rgb_f16)
.unwrap()
.with_rgba_f16(&mut rgba_f16)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma_u16)
.unwrap()
.with_hsv(&mut h, &mut s_, &mut v_)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
let (bg, bb, br, ba) = planes_from_packed_rgba(&rgba_f32, OUT * OUT);
let (bgw, bbw, brw, baw) = (
as_le_f32(&bg),
as_le_f32(&bb),
as_le_f32(&br),
as_le_f32(&ba),
);
let mut ref_rgb = std::vec![0u8; OUT * OUT * 3];
let mut ref_rgb_u16 = std::vec![0u16; OUT * OUT * 3];
let mut ref_rgb_f32 = std::vec![0.0f32; OUT * OUT * 3];
let mut ref_rgba = std::vec![0u8; OUT * OUT * 4];
let mut ref_rgba_u16 = std::vec![0u16; OUT * OUT * 4];
let mut ref_rgb_f16 = std::vec![half::f16::ZERO; OUT * OUT * 3];
let mut ref_rgba_f16 = std::vec![half::f16::ZERO; OUT * OUT * 4];
let mut ref_luma = std::vec![0u8; OUT * OUT];
let mut ref_luma_u16 = std::vec![0u16; OUT * OUT];
let mut ref_h = std::vec![0u8; OUT * OUT];
let mut ref_s = std::vec![0u8; OUT * OUT];
let mut ref_v = std::vec![0u8; OUT * OUT];
{
let binned = frame(&bgw, &bbw, &brw, &baw, OUT, OUT);
let mut sink = MixedSinker::<Gbrapf32>::new(OUT, OUT)
.with_rgb(&mut ref_rgb)
.unwrap()
.with_rgb_u16(&mut ref_rgb_u16)
.unwrap()
.with_rgb_f32(&mut ref_rgb_f32)
.unwrap()
.with_rgba(&mut ref_rgba)
.unwrap()
.with_rgba_u16(&mut ref_rgba_u16)
.unwrap()
.with_rgb_f16(&mut ref_rgb_f16)
.unwrap()
.with_rgba_f16(&mut ref_rgba_f16)
.unwrap()
.with_luma(&mut ref_luma)
.unwrap()
.with_luma_u16(&mut ref_luma_u16)
.unwrap()
.with_hsv(&mut ref_h, &mut ref_s, &mut ref_v)
.unwrap();
gbrapf32_to(&binned, &mut sink).unwrap();
}
assert_eq!(rgb, ref_rgb, "rgb");
assert_eq!(rgb_u16, ref_rgb_u16, "rgb_u16");
assert_eq!(
rgb_f32, ref_rgb_f32,
"rgb_f32 (lossless drop-α, full parity)"
);
assert_eq!(rgba, ref_rgba, "rgba");
assert_eq!(rgba_u16, ref_rgba_u16, "rgba_u16");
assert_eq!(rgb_f16, ref_rgb_f16, "rgb_f16");
assert_eq!(rgba_f16, ref_rgba_f16, "rgba_f16");
assert_eq!(luma, ref_luma, "luma");
assert_eq!(luma_u16, ref_luma_u16, "luma_u16 (narrowed, full parity)");
assert_eq!(h, ref_h, "hsv H");
assert_eq!(s_, ref_s, "hsv S");
assert_eq!(v_, ref_v, "hsv V");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_premultiplied_matches_premult_bin_unpremult_oracle() {
let (g, b, r, a) = gbra_planes();
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut rgba_f32 = std::vec![0.0f32; OUT * OUT * 4];
let mut rgb_f32 = std::vec![0.0f32; OUT * OUT * 3];
{
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_alpha_mode(AlphaMode::Premultiplied)
.with_rgba_f32(&mut rgba_f32)
.unwrap()
.with_rgb_f32(&mut rgb_f32)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
for oy in 0..OUT {
for ox in 0..OUT {
let mean_a = block_mean_plane(&a, ox, oy);
let mut prem = [0.0f32; 3]; let chans = [&r, &g, &b];
for (c, plane) in chans.iter().enumerate() {
let mut acc = 0.0f64;
for dy in 0..2 {
for dx in 0..2 {
let idx = (oy * 2 + dy) * SRC + ox * 2 + dx;
acc += (plane[idx] * a[idx]) as f64;
}
}
prem[c] = (acc / 4.0) as f32;
}
let straight = |pm: f32| if mean_a == 0.0 { 0.0 } else { pm / mean_a };
let base = (oy * OUT + ox) * 4;
assert_eq!(rgba_f32[base], straight(prem[0]), "premult R ({ox},{oy})");
assert_eq!(
rgba_f32[base + 1],
straight(prem[1]),
"premult G ({ox},{oy})"
);
assert_eq!(
rgba_f32[base + 2],
straight(prem[2]),
"premult B ({ox},{oy})"
);
assert_eq!(rgba_f32[base + 3], mean_a, "premult A ({ox},{oy})");
let rbase = (oy * OUT + ox) * 3;
assert_eq!(
rgb_f32[rbase],
straight(prem[0]),
"premult rgb R ({ox},{oy})"
);
assert_eq!(
rgb_f32[rbase + 1],
straight(prem[1]),
"premult rgb G ({ox},{oy})"
);
assert_eq!(
rgb_f32[rbase + 2],
straight(prem[2]),
"premult rgb B ({ox},{oy})"
);
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_premultiplied_transparent_block_does_not_bleed() {
let (mut g, mut b, mut r, mut a) = gbra_planes();
for off in [(0usize, 0usize), (1, 0), (0, 1), (1, 1)] {
let i = off.1 * SRC + off.0;
r[i] = 999.0;
g[i] = -999.0;
b[i] = 999.0;
a[i] = 0.0;
}
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut rgba_f32 = std::vec![0.0f32; OUT * OUT * 4];
{
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_alpha_mode(AlphaMode::Premultiplied)
.with_rgba_f32(&mut rgba_f32)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
assert_eq!(
&rgba_f32[..4],
&[0.0, 0.0, 0.0, 0.0],
"transparent block bled color"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_rgb_only_straight_drops_alpha_via_3channel_path() {
let (g, b, r, a) = gbra_planes();
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut rgb_f32 = std::vec![0.0f32; OUT * OUT * 3];
let mut luma = std::vec![0u8; OUT * OUT];
{
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_rgb_f32(&mut rgb_f32)
.unwrap()
.with_luma(&mut luma)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
for oy in 0..OUT {
for ox in 0..OUT {
let base = (oy * OUT + ox) * 3;
assert_eq!(rgb_f32[base], block_mean_plane(&r, ox, oy), "R ({ox},{oy})");
assert_eq!(
rgb_f32[base + 1],
block_mean_plane(&g, ox, oy),
"G ({ox},{oy})"
);
assert_eq!(
rgb_f32[base + 2],
block_mean_plane(&b, ox, oy),
"B ({ox},{oy})"
);
}
}
let (bg, bb, br) = planes_from_packed_rgb(&rgb_f32, OUT * OUT);
let (bgw, bbw, brw) = (as_le_f32(&bg), as_le_f32(&bb), as_le_f32(&br));
let mut luma_ref = std::vec![0u8; OUT * OUT];
{
let binned = crate::frame::Gbrpf32Frame::try_new(
&bgw, &bbw, &brw, OUT as u32, OUT as u32, OUT as u32, OUT as u32, OUT as u32,
)
.unwrap();
let mut sink = MixedSinker::<crate::source::Gbrpf32>::new(OUT, OUT)
.with_luma(&mut luma_ref)
.unwrap();
crate::source::gbrpf32_to(&binned, &mut sink).unwrap();
}
assert_eq!(luma, luma_ref, "luma (drop-α == 3-channel path)");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_fractional_ratio_matches_convert_then_bin() {
const FOUT: usize = 3;
let (g, b, r, a) = gbra_planes();
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut rgba_u16 = std::vec![0u16; FOUT * FOUT * 4];
let mut rgba_f32 = std::vec![0.0f32; FOUT * FOUT * 4];
{
let mut sink = MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(
SRC,
SRC,
AreaResampler::to(FOUT, FOUT),
)
.unwrap()
.with_rgba_u16(&mut rgba_u16)
.unwrap()
.with_rgba_f32(&mut rgba_f32)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
let (bg, bb, br, ba) = planes_from_packed_rgba(&rgba_f32, FOUT * FOUT);
let (bgw, bbw, brw, baw) = (
as_le_f32(&bg),
as_le_f32(&bb),
as_le_f32(&br),
as_le_f32(&ba),
);
let mut ref_rgba_u16 = std::vec![0u16; FOUT * FOUT * 4];
{
let binned = frame(&bgw, &bbw, &brw, &baw, FOUT, FOUT);
let mut sink = MixedSinker::<Gbrapf32>::new(FOUT, FOUT)
.with_rgba_u16(&mut ref_rgba_u16)
.unwrap();
gbrapf32_to(&binned, &mut sink).unwrap();
}
assert_eq!(
rgba_u16, ref_rgba_u16,
"fractional rgba_u16 == convert-then-bin"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_le_be_parity() {
let (g, b, r, a) = gbra_planes();
let render = |be: bool| {
let (gw, bw, rw, aw) = if be {
(as_be_f32(&g), as_be_f32(&b), as_be_f32(&r), as_be_f32(&a))
} else {
(as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a))
};
let mut rgba = std::vec![0u8; OUT * OUT * 4];
let mut rgba_u16 = std::vec![0u16; OUT * OUT * 4];
let mut rgba_f32 = std::vec![0.0f32; OUT * OUT * 4];
let mut rgba_f16 = std::vec![half::f16::ZERO; OUT * OUT * 4];
let mut luma_u16 = std::vec![0u16; OUT * OUT];
if be {
let src = crate::frame::Gbrapf32BeFrame::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 sink = MixedSinker::<crate::source::Gbrapf32<true>, AreaResampler>::with_resampler(
SRC,
SRC,
AreaResampler::to(OUT, OUT),
)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba_u16)
.unwrap()
.with_rgba_f32(&mut rgba_f32)
.unwrap()
.with_rgba_f16(&mut rgba_f16)
.unwrap()
.with_luma_u16(&mut luma_u16)
.unwrap();
crate::source::gbrapf32_to_endian(&src, &mut sink).unwrap();
} else {
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut sink = MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(
SRC,
SRC,
AreaResampler::to(OUT, OUT),
)
.unwrap()
.with_rgba(&mut rgba)
.unwrap()
.with_rgba_u16(&mut rgba_u16)
.unwrap()
.with_rgba_f32(&mut rgba_f32)
.unwrap()
.with_rgba_f16(&mut rgba_f16)
.unwrap()
.with_luma_u16(&mut luma_u16)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
(rgba, rgba_u16, rgba_f32, rgba_f16, luma_u16)
};
assert_eq!(render(false), render(true), "LE/BE outputs diverge");
}
#[test]
fn gbrapf32_default_alpha_mode_is_straight() {
let sink = MixedSinker::<Gbrapf32>::new(SRC, SRC);
assert_eq!(sink.alpha_mode(), AlphaMode::Straight);
assert!(sink.alpha_mode().is_straight());
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_identity_plan_matches_new_sink() {
let (g, b, r, a) = gbra_planes();
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut direct = std::vec![0.0f32; SRC * SRC * 4];
{
let mut sink = MixedSinker::<Gbrapf32>::new(SRC, SRC)
.with_rgba_f32(&mut direct)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
let mut via_area = std::vec![0.0f32; SRC * SRC * 4];
{
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(SRC, SRC))
.unwrap()
.with_rgba_f32(&mut via_area)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
}
assert_eq!(direct, via_area, "identity-plan resample == direct sink");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_no_output_sink_is_a_noop() {
let (g, b, r, a) = gbra_planes();
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
assert!(
!sink.rgba_stream_f32_allocated(),
"no-output sink allocated the 4-channel f32 stream"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_resample_reuses_stream_across_frames() {
let (g1, b1, r1, a1) = gbra_planes();
let g2: Vec<f32> = g1.iter().map(|&v| -v).collect();
let b2: Vec<f32> = b1.iter().map(|&v| -v).collect();
let r2: Vec<f32> = r1.iter().map(|&v| -v).collect();
let a2 = a1.clone();
let (g1w, b1w, r1w, a1w) = (
as_le_f32(&g1),
as_le_f32(&b1),
as_le_f32(&r1),
as_le_f32(&a1),
);
let (g2w, b2w, r2w, a2w) = (
as_le_f32(&g2),
as_le_f32(&b2),
as_le_f32(&r2),
as_le_f32(&a2),
);
let mut out = std::vec![0.0f32; OUT * OUT * 4];
{
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_rgba_f32(&mut out)
.unwrap();
gbrapf32_to(&frame(&g1w, &b1w, &r1w, &a1w, SRC, SRC), &mut sink).unwrap();
gbrapf32_to(&frame(&g2w, &b2w, &r2w, &a2w, SRC, SRC), &mut sink).unwrap();
}
for oy in 0..OUT {
for ox in 0..OUT {
let base = (oy * OUT + ox) * 4;
assert_eq!(out[base], block_mean_plane(&r2, ox, oy), "frame2 R");
assert_eq!(out[base + 1], block_mean_plane(&g2, ox, oy), "frame2 G");
assert_eq!(out[base + 2], block_mean_plane(&b2, ox, oy), "frame2 B");
assert_eq!(out[base + 3], block_mean_plane(&a2, ox, oy), "frame2 A");
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn gbrapf32_accepts_alpha_mode_change_across_frames() {
let (g, b, r, a) = gbra_planes();
let (gw, bw, rw, aw) = (as_le_f32(&g), as_le_f32(&b), as_le_f32(&r), as_le_f32(&a));
let src = frame(&gw, &bw, &rw, &aw, SRC, SRC);
let mut rgba_f32 = std::vec![0.0f32; OUT * OUT * 4];
{
let mut sink =
MixedSinker::<Gbrapf32, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_rgba_f32(&mut rgba_f32)
.unwrap();
gbrapf32_to(&src, &mut sink).unwrap();
sink.set_alpha_mode(AlphaMode::Premultiplied);
gbrapf32_to(&src, &mut sink).expect("a fresh frame must accept a different alpha mode");
}
let mean_a = block_mean_plane(&a, 0, 0);
let straight = |plane: &[f32]| {
let mut acc = 0.0f64;
for dy in 0..2 {
for dx in 0..2 {
let idx = dy * SRC + dx;
acc += (plane[idx] * a[idx]) as f64;
}
}
let pm = (acc / 4.0) as f32;
if mean_a == 0.0 { 0.0 } else { pm / mean_a }
};
assert_eq!(rgba_f32[0], straight(&r), "premult frame2 R");
assert_eq!(rgba_f32[3], mean_a, "premult frame2 A");
}