use crate::{
KernelMatrix,
resample::AreaResampler,
sinker::MixedSinker,
source::{Monoblack, Monowhite, monoblack_to, monowhite_to},
};
use mediaframe::frame::{MonoblackFrame, MonowhiteFrame};
const SRC_W: usize = 8;
const SRC_H: usize = 4;
const OUT_W: usize = 4;
const OUT_H: usize = 2;
const STRIDE: usize = SRC_W / 8;
const PATTERN: [u8; SRC_H * STRIDE] = [0b1111_0000, 0b1100_0000, 0b1010_1010, 0b0000_1111];
fn expand_luma(data: &[u8], invert: bool) -> Vec<u8> {
let mut out = vec![0u8; SRC_W * SRC_H];
for row in 0..SRC_H {
let byte = data[row * STRIDE];
for col in 0..SRC_W {
let raw = (byte >> (7 - col)) & 1;
let bit = if invert { 1 - raw } else { raw };
out[row * SRC_W + col] = bit * 255;
}
}
out
}
fn block_mean_2x2(plane: &[u8]) -> Vec<u8> {
let mut out = vec![0u8; OUT_W * OUT_H];
for oy in 0..OUT_H {
for ox in 0..OUT_W {
let mut s = 0u32;
for dy in 0..2 {
for dx in 0..2 {
s += plane[(oy * 2 + dy) * SRC_W + ox * 2 + dx] as u32;
}
}
out[oy * OUT_W + ox] = ((s + 2) / 4) as u8;
}
}
out
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monoblack_resample_luma_is_block_mean_of_expanded_bits() {
let src = MonoblackFrame::try_new(&PATTERN, SRC_W as u32, SRC_H as u32, STRIDE as u32).unwrap();
let mut luma = vec![0u8; OUT_W * OUT_H];
{
let mut sink = MixedSinker::<Monoblack, AreaResampler>::with_resampler(
SRC_W,
SRC_H,
AreaResampler::to(OUT_W, OUT_H),
)
.unwrap()
.with_luma(&mut luma)
.unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let expected = block_mean_2x2(&expand_luma(&PATTERN, false));
assert_eq!(expected, vec![255, 128, 0, 0, 64, 64, 191, 191]);
assert_eq!(
luma, expected,
"luma must be the 2x2 block mean of the expanded bits"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monoblack_resample_all_outputs_match_direct_mono_over_binned_luma() {
let src = MonoblackFrame::try_new(&PATTERN, SRC_W as u32, SRC_H as u32, STRIDE as u32).unwrap();
let mut luma = vec![0u8; OUT_W * OUT_H];
let mut luma_u16 = vec![0u16; OUT_W * OUT_H];
let mut rgb = vec![0u8; OUT_W * OUT_H * 3];
let mut rgba = vec![0u8; OUT_W * OUT_H * 4];
let mut rgb_u16 = vec![0u16; OUT_W * OUT_H * 3];
let mut rgba_u16 = vec![0u16; OUT_W * OUT_H * 4];
let mut hp = vec![0u8; OUT_W * OUT_H];
let mut sp = vec![0u8; OUT_W * OUT_H];
let mut vp = vec![0u8; OUT_W * OUT_H];
{
let mut sink = MixedSinker::<Monoblack, AreaResampler>::with_resampler(
SRC_W,
SRC_H,
AreaResampler::to(OUT_W, OUT_H),
)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_luma_u16(&mut luma_u16)
.unwrap()
.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_hsv(&mut hp, &mut sp, &mut vp)
.unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let y_ref = block_mean_2x2(&expand_luma(&PATTERN, false));
assert_eq!(luma, y_ref);
let y_ref_u16: Vec<u16> = y_ref.iter().map(|&y| y as u16).collect();
assert_eq!(luma_u16, y_ref_u16);
for (px, &y) in rgb.chunks_exact(3).zip(&y_ref) {
assert_eq!(px, [y, y, y]);
}
for (px, &y) in rgba.chunks_exact(4).zip(&y_ref) {
assert_eq!(px, [y, y, y, 0xFF]);
}
for (px, &y) in rgb_u16.chunks_exact(3).zip(&y_ref) {
let y16 = y as u16;
assert_eq!(px, [y16, y16, y16]);
}
for (px, &y) in rgba_u16.chunks_exact(4).zip(&y_ref) {
let y16 = y as u16;
assert_eq!(px, [y16, y16, y16, 0x00FF]);
}
assert_eq!(vp, y_ref, "HSV V must be the binned luma");
assert!(hp.iter().all(|&h| h == 0), "HSV H must be 0 (achromatic)");
assert!(sp.iter().all(|&s| s == 0), "HSV S must be 0 (achromatic)");
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monowhite_resample_all_outputs_match_direct_mono_over_binned_luma() {
let src = MonowhiteFrame::try_new(&PATTERN, SRC_W as u32, SRC_H as u32, STRIDE as u32).unwrap();
let mut luma = vec![0u8; OUT_W * OUT_H];
let mut rgb = vec![0u8; OUT_W * OUT_H * 3];
let mut rgba = vec![0u8; OUT_W * OUT_H * 4];
{
let mut sink = MixedSinker::<Monowhite, AreaResampler>::with_resampler(
SRC_W,
SRC_H,
AreaResampler::to(OUT_W, OUT_H),
)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_rgb(&mut rgb)
.unwrap()
.with_rgba(&mut rgba)
.unwrap();
monowhite_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let y_ref = block_mean_2x2(&expand_luma(&PATTERN, true));
assert_eq!(luma, y_ref);
for (px, &y) in rgb.chunks_exact(3).zip(&y_ref) {
assert_eq!(px, [y, y, y]);
}
for (px, &y) in rgba.chunks_exact(4).zip(&y_ref) {
assert_eq!(px, [y, y, y, 0xFF]);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monoblack_identity_plan_matches_new_sink() {
let src = MonoblackFrame::try_new(&PATTERN, SRC_W as u32, SRC_H as u32, STRIDE as u32).unwrap();
let mut direct_rgb = vec![0u8; SRC_W * SRC_H * 3];
let mut direct_rgba = vec![0u8; SRC_W * SRC_H * 4];
{
let mut sink = MixedSinker::<Monoblack>::new(SRC_W, SRC_H)
.with_rgb(&mut direct_rgb)
.unwrap()
.with_rgba(&mut direct_rgba)
.unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let mut area_rgb = vec![0u8; SRC_W * SRC_H * 3];
let mut area_rgba = vec![0u8; SRC_W * SRC_H * 4];
{
let mut sink = MixedSinker::<Monoblack, AreaResampler>::with_resampler(
SRC_W,
SRC_H,
AreaResampler::to(SRC_W, SRC_H),
)
.unwrap()
.with_rgb(&mut area_rgb)
.unwrap()
.with_rgba(&mut area_rgba)
.unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
assert_eq!(
direct_rgb, area_rgb,
"identity rgb must match the direct path"
);
assert_eq!(
direct_rgba, area_rgba,
"identity rgba must match the direct path"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monoblack_resample_reuses_luma_stream_across_frames() {
let frame1 = PATTERN;
let frame2: [u8; SRC_H * STRIDE] = [!PATTERN[0], !PATTERN[1], !PATTERN[2], !PATTERN[3]];
let mut luma = vec![0u8; OUT_W * OUT_H];
{
let mut sink = MixedSinker::<Monoblack, AreaResampler>::with_resampler(
SRC_W,
SRC_H,
AreaResampler::to(OUT_W, OUT_H),
)
.unwrap()
.with_luma(&mut luma)
.unwrap();
let f1 = MonoblackFrame::try_new(&frame1, SRC_W as u32, SRC_H as u32, STRIDE as u32).unwrap();
monoblack_to(&f1, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
let f2 = MonoblackFrame::try_new(&frame2, SRC_W as u32, SRC_H as u32, STRIDE as u32).unwrap();
monoblack_to(&f2, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let y2_ref = block_mean_2x2(&expand_luma(&frame2, false));
assert_eq!(
luma, y2_ref,
"frame 2 luma must area-downscale frame 2's bits"
);
}
#[test]
fn monoblack_resample_no_outputs_is_a_no_op() {
let src = MonoblackFrame::try_new(&PATTERN, SRC_W as u32, SRC_H as u32, STRIDE as u32).unwrap();
let mut sink = MixedSinker::<Monoblack, AreaResampler>::with_resampler(
SRC_W,
SRC_H,
AreaResampler::to(OUT_W, OUT_H),
)
.unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
assert!(
!sink.luma_stream_allocated(),
"a no-output frame must not allocate the luma stream"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monoblack_resample_begin_frame_resets_stream_sequencing() {
let f1 = MonoblackFrame::try_new(&PATTERN, SRC_W as u32, SRC_H as u32, STRIDE as u32).unwrap();
let mut luma = vec![0u8; OUT_W * OUT_H];
let mut sink = MixedSinker::<Monoblack, AreaResampler>::with_resampler(
SRC_W,
SRC_H,
AreaResampler::to(OUT_W, OUT_H),
)
.unwrap()
.with_luma(&mut luma)
.unwrap();
monoblack_to(&f1, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
assert!(
sink.luma_stream_allocated(),
"the first frame must have created the luma stream"
);
monoblack_to(&f1, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
let y_ref = block_mean_2x2(&expand_luma(&PATTERN, false));
assert_eq!(
luma, y_ref,
"frame 2 must re-bin after the begin_frame reset"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn mono_first_row_scratch_oom_leaves_stream_uncommitted_for_retry() {
let src = MonoblackFrame::try_new(&PATTERN, SRC_W as u32, SRC_H as u32, STRIDE as u32).unwrap();
let mut luma = vec![0u8; OUT_W * OUT_H];
let mut rgb = vec![0u8; OUT_W * OUT_H * 3];
{
let mut sink = MixedSinker::<Monoblack, AreaResampler>::with_resampler(
SRC_W,
SRC_H,
AreaResampler::to(OUT_W, OUT_H),
)
.unwrap()
.with_luma(&mut luma)
.unwrap();
crate::sinker::mixed::arm_source_luma_scratch_failure();
let err = monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap_err();
assert!(
matches!(
err,
crate::sinker::MixedSinkerError::Resample(
crate::resample::ResampleError::AllocationFailed(_)
)
),
"first-row scratch OOM must surface AllocationFailed, got {err:?}"
);
assert!(
!sink.luma_stream_allocated(),
"a scratch OOM must leave the luma stream field None (no partial commit)"
);
sink.set_rgb(&mut rgb).unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709))
.expect("re-walk after a first-row scratch OOM must succeed");
}
assert!(
luma.iter().any(|&b| b != 0),
"the recovered frame produced real luma output (scratch OOM was recoverable)"
);
assert!(
rgb.iter().any(|&b| b != 0),
"the newly-attached rgb output was driven on the accepted re-walk"
);
}
use crate::resample::{
CatmullRom, FilterKernel, FilterStream, FilteredResampler, Lanczos3, Resampler, Triangle,
};
const FW: usize = 8;
const FH: usize = 8;
const FSTRIDE: usize = FW / 8;
const FOUT_DOWN: usize = 4;
const FUP: usize = 7;
const FPATTERN: [u8; FH * FSTRIDE] = [
0b1111_0000,
0b1111_0000,
0b1111_0000,
0b1111_0000,
0b1100_1100,
0b1010_1010,
0b1111_0000,
0b1111_0000,
];
fn expand_luma_grid(data: &[u8], invert: bool) -> Vec<u8> {
let mut out = vec![0u8; FW * FH];
for row in 0..FH {
let byte = data[row * FSTRIDE];
for col in 0..FW {
let raw = (byte >> (7 - col)) & 1;
let bit = if invert { 1 - raw } else { raw };
out[row * FW + col] = bit * 255;
}
}
out
}
fn native_luma_filter<K: FilterKernel>(
kernel: K,
luma_plane: &[u8],
sw: usize,
sh: usize,
ow: usize,
oh: usize,
) -> Vec<u8> {
let plan = FilteredResampler::new(ow, oh, kernel)
.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 stream = FilterStream::<u8>::new(fh, fv, sw, sh, 1).expect("geometry");
let mut out = vec![0u8; ow * oh];
for row in 0..sh {
stream
.feed_row(
row,
&luma_plane[row * sw..(row + 1) * sw],
true,
|oy, fin| {
out[oy * ow..(oy + 1) * ow].copy_from_slice(fin);
},
)
.expect("rows in order");
}
out
}
struct MonoFilterOutputs {
luma: Vec<u8>,
luma_u16: Vec<u16>,
rgb: Vec<u8>,
rgba: Vec<u8>,
rgb_u16: Vec<u16>,
rgba_u16: Vec<u16>,
hp: Vec<u8>,
sp: Vec<u8>,
vp: Vec<u8>,
}
fn monoblack_filter_outputs<K: FilterKernel + Copy>(
ow: usize,
oh: usize,
kernel: K,
) -> MonoFilterOutputs {
let src = MonoblackFrame::try_new(&FPATTERN, FW as u32, FH as u32, FSTRIDE as u32).unwrap();
let mut o = MonoFilterOutputs {
luma: vec![0u8; ow * oh],
luma_u16: vec![0u16; ow * oh],
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],
hp: vec![0u8; ow * oh],
sp: vec![0u8; ow * oh],
vp: vec![0u8; ow * oh],
};
{
let mut sink = MixedSinker::<Monoblack, FilteredResampler<K>>::with_resampler(
FW,
FH,
FilteredResampler::new(ow, oh, kernel),
)
.unwrap()
.with_luma(&mut o.luma)
.unwrap()
.with_luma_u16(&mut o.luma_u16)
.unwrap()
.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_hsv(&mut o.hp, &mut o.sp, &mut o.vp)
.unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
o
}
fn assert_monoblack_filter_matches_oracle<K: FilterKernel + Copy>(
kernel: K,
ow: usize,
oh: usize,
ctx: &str,
) -> u8 {
let got = monoblack_filter_outputs(ow, oh, kernel);
let y_ref = native_luma_filter(kernel, &expand_luma_grid(&FPATTERN, false), FW, FH, ow, oh);
let mut max_diff = 0u8;
for (i, (&g, &w)) in got.luma.iter().zip(y_ref.iter()).enumerate() {
max_diff = max_diff.max(g.abs_diff(w));
assert_eq!(
g, w,
"{ctx} luma[{i}]: {g} vs single-channel native-luma filter {w}"
);
}
let y_ref_u16: Vec<u16> = y_ref.iter().map(|&y| y as u16).collect();
assert_eq!(
got.luma_u16, y_ref_u16,
"{ctx} luma_u16 = resampled luma zero-extended"
);
for (px, &y) in got.rgb.chunks_exact(3).zip(&y_ref) {
assert_eq!(px, [y, y, y], "{ctx} rgb = broadcast luma");
}
for (px, &y) in got.rgba.chunks_exact(4).zip(&y_ref) {
assert_eq!(px, [y, y, y, 0xFF], "{ctx} rgba = broadcast luma, opaque");
}
for (px, &y) in got.rgb_u16.chunks_exact(3).zip(&y_ref) {
let y16 = y as u16;
assert_eq!(px, [y16, y16, y16], "{ctx} rgb_u16 = broadcast luma");
}
for (px, &y) in got.rgba_u16.chunks_exact(4).zip(&y_ref) {
let y16 = y as u16;
assert_eq!(
px,
[y16, y16, y16, 0x00FF],
"{ctx} rgba_u16 = broadcast luma, opaque"
);
}
assert_eq!(got.vp, y_ref, "{ctx} HSV V = resampled luma");
assert!(
got.hp.iter().all(|&h| h == 0),
"{ctx} HSV H = 0 (achromatic)"
);
assert!(
got.sp.iter().all(|&s| s == 0),
"{ctx} HSV S = 0 (achromatic)"
);
max_diff
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monoblack_filter_luma_is_single_channel_native_luma() {
assert_eq!(
0,
assert_monoblack_filter_matches_oracle(
Triangle,
FOUT_DOWN,
FOUT_DOWN,
"monoblack triangle down"
)
);
assert_eq!(
0,
assert_monoblack_filter_matches_oracle(
CatmullRom,
FOUT_DOWN,
FOUT_DOWN,
"monoblack catmullrom down"
)
);
assert_eq!(
0,
assert_monoblack_filter_matches_oracle(
Lanczos3,
FOUT_DOWN,
FOUT_DOWN,
"monoblack lanczos3 down"
)
);
assert_eq!(
0,
assert_monoblack_filter_matches_oracle(Triangle, FUP, FUP, "monoblack triangle up")
);
assert_eq!(
0,
assert_monoblack_filter_matches_oracle(CatmullRom, FUP, FUP, "monoblack catmullrom up")
);
assert_eq!(
0,
assert_monoblack_filter_matches_oracle(Lanczos3, FUP, FUP, "monoblack lanczos3 up")
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monowhite_filter_luma_is_single_channel_native_luma() {
let src = MonowhiteFrame::try_new(&FPATTERN, FW as u32, FH as u32, FSTRIDE as u32).unwrap();
for (kernel_name, run) in [("triangle down", FOUT_DOWN), ("triangle up", FUP)] {
let (ow, oh) = (run, run);
let mut luma = vec![0u8; ow * oh];
let mut rgb = vec![0u8; ow * oh * 3];
let mut rgba = vec![0u8; ow * oh * 4];
{
let mut sink = MixedSinker::<Monowhite, FilteredResampler<Triangle>>::with_resampler(
FW,
FH,
FilteredResampler::new(ow, oh, Triangle),
)
.unwrap()
.with_luma(&mut luma)
.unwrap()
.with_rgb(&mut rgb)
.unwrap()
.with_rgba(&mut rgba)
.unwrap();
monowhite_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let y_ref = native_luma_filter(Triangle, &expand_luma_grid(&FPATTERN, true), FW, FH, ow, oh);
assert_eq!(
luma, y_ref,
"monowhite {kernel_name}: luma = native-luma filter of inverted plane"
);
for (px, &y) in rgb.chunks_exact(3).zip(&y_ref) {
assert_eq!(
px,
[y, y, y],
"monowhite {kernel_name}: rgb = broadcast luma"
);
}
for (px, &y) in rgba.chunks_exact(4).zip(&y_ref) {
assert_eq!(
px,
[y, y, y, 0xFF],
"monowhite {kernel_name}: rgba = broadcast luma, opaque"
);
}
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monoblack_filter_antialiases_bilevel_edge_to_intermediate_grays() {
let got = monoblack_filter_outputs(FOUT_DOWN, FOUT_DOWN, Triangle);
assert!(
got.luma.iter().any(|&y| y > 0 && y < 255),
"a filtered bilevel edge must yield intermediate grays (antialiasing); got {:?}",
got.luma
);
assert!(
got
.rgb
.chunks_exact(3)
.any(|px| px[0] > 0 && px[0] < 255 && px[0] == px[1] && px[1] == px[2]),
"intermediate grays must broadcast to R=G=B"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn mono_filter_plans_are_accepted() {
let got = monoblack_filter_outputs(FOUT_DOWN, FOUT_DOWN, Triangle);
assert!(
got.luma.iter().any(|&v| v != 0),
"monoblack: filter resample must populate luma (no UnsupportedFilter)"
);
assert!(
got.rgb.iter().any(|&v| v != 0),
"monoblack: filter resample must populate rgb (no UnsupportedFilter)"
);
let src = MonowhiteFrame::try_new(&FPATTERN, FW as u32, FH as u32, FSTRIDE as u32).unwrap();
let mut luma = vec![0u8; FOUT_DOWN * FOUT_DOWN];
{
let mut sink = MixedSinker::<Monowhite, FilteredResampler<Triangle>>::with_resampler(
FW,
FH,
FilteredResampler::new(FOUT_DOWN, FOUT_DOWN, Triangle),
)
.unwrap()
.with_luma(&mut luma)
.unwrap();
monowhite_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
assert!(
luma.iter().any(|&v| v != 0),
"monowhite: filter resample must populate luma (no UnsupportedFilter)"
);
}
#[test]
fn mono_filter_no_outputs_is_a_no_op_without_allocating() {
let src = MonoblackFrame::try_new(&FPATTERN, FW as u32, FH as u32, FSTRIDE as u32).unwrap();
let mut sink = MixedSinker::<Monoblack, FilteredResampler<Triangle>>::with_resampler(
FW,
FH,
FilteredResampler::new(FOUT_DOWN, FOUT_DOWN, Triangle),
)
.unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
assert!(
!sink.luma_filter_stream_allocated(),
"a no-output filter frame must not allocate the filter stream"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monoblack_filter_reuses_stream_across_frames() {
let frame1 = FPATTERN;
let frame2: [u8; FH * FSTRIDE] = {
let mut f = FPATTERN;
for b in f.iter_mut() {
*b = !*b;
}
f
};
let mut luma = vec![0u8; FOUT_DOWN * FOUT_DOWN];
{
let mut sink = MixedSinker::<Monoblack, FilteredResampler<Triangle>>::with_resampler(
FW,
FH,
FilteredResampler::new(FOUT_DOWN, FOUT_DOWN, Triangle),
)
.unwrap()
.with_luma(&mut luma)
.unwrap();
let f1 = MonoblackFrame::try_new(&frame1, FW as u32, FH as u32, FSTRIDE as u32).unwrap();
monoblack_to(&f1, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
let f2 = MonoblackFrame::try_new(&frame2, FW as u32, FH as u32, FSTRIDE as u32).unwrap();
monoblack_to(&f2, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let want = native_luma_filter(
Triangle,
&expand_luma_grid(&frame2, false),
FW,
FH,
FOUT_DOWN,
FOUT_DOWN,
);
assert_eq!(
luma, want,
"frame 2 luma must be the native-luma filter of frame 2's bits (stream reset each frame)"
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn monoblack_filter_identity_plan_matches_new_sink() {
let src = MonoblackFrame::try_new(&FPATTERN, FW as u32, FH as u32, FSTRIDE as u32).unwrap();
let mut direct_rgb = vec![0u8; FW * FH * 3];
{
let mut sink = MixedSinker::<Monoblack>::new(FW, FH)
.with_rgb(&mut direct_rgb)
.unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
let mut filt_rgb = vec![0u8; FW * FH * 3];
{
let mut sink = MixedSinker::<Monoblack, FilteredResampler<Triangle>>::with_resampler(
FW,
FH,
FilteredResampler::new(FW, FH, Triangle),
)
.unwrap()
.with_rgb(&mut filt_rgb)
.unwrap();
monoblack_to(&src, true, sink.set_kernel_matrix(KernelMatrix::Bt709)).unwrap();
}
assert_eq!(
direct_rgb, filt_rgb,
"identity filter rgb must match the direct path"
);
}