use crate::{
KernelMatrix, PixelSink,
resample::{
AreaResampler, AveragingDomain, FilteredResampler, LinearMode, ResampleError, TransferFunction,
Triangle,
},
sinker::{MixedSinker, MixedSinkerError},
source::{
Yuv420p, Yuv420pRow, Yuv422p, Yuv440p, Yuv444p, yuv420p_to, yuv422p_to, yuv440p_to, yuv444p_to,
},
};
use mediaframe::frame::{Yuv420pFrame, Yuv422pFrame, Yuv440pFrame, Yuv444pFrame};
const SRC: usize = 8;
const OUT: usize = 4;
fn y_ramp() -> Vec<u8> {
let mut y = vec![0u8; SRC * SRC];
for (i, p) in y.iter_mut().enumerate() {
*p = 24 + (i as u8) % 200;
}
y
}
fn chroma(cw: usize, ch: usize, base: u8, step: u8) -> Vec<u8> {
let mut c = vec![0u8; cw * ch];
for (i, p) in c.iter_mut().enumerate() {
*p = base.wrapping_add(((i % cw) as u8).wrapping_mul(step));
}
c
}
struct Bt709Real {
y_off: f32,
y_scale: f32,
c_scale: f32,
r_v: f32,
g_u: f32,
g_v: f32,
b_u: f32,
}
impl Bt709Real {
fn new(full_range: bool) -> Self {
let q15 = 32768.0f32;
let (y_off, y_scale_q15, c_scale_q15) = if full_range {
(
0.0,
(((255i64 << 15) + 255 / 2) / 255) as f32,
(((255i64 << 15) + 255 / 2) / 255) as f32,
)
} else {
(
16.0,
(((255i64 << 15) + 219 / 2) / 219) as f32,
(((255i64 << 15) + 224 / 2) / 224) as f32,
)
};
Self {
y_off,
y_scale: y_scale_q15 / q15,
c_scale: c_scale_q15 / q15,
r_v: 51606.0 / q15,
g_u: -6136.0 / q15,
g_v: -15339.0 / q15,
b_u: 60808.0 / q15,
}
}
fn decode(&self, y: u8, u: u8, v: u8) -> [f32; 3] {
let yl = (y as f32 - self.y_off) * self.y_scale;
let u_d = (u as f32 - 128.0) * self.c_scale;
let v_d = (v as f32 - 128.0) * self.c_scale;
let r = yl + self.r_v * v_d;
let g = yl + self.g_u * u_d + self.g_v * v_d;
let b = yl + self.b_u * u_d;
[r / 255.0, g / 255.0, b / 255.0]
}
}
fn full_res_unclamped_rgb(
y_plane: &[u8],
chroma_at: impl Fn(usize, usize) -> (u8, u8),
) -> Vec<f32> {
let c = Bt709Real::new(true);
let mut rgb = vec![0.0f32; SRC * SRC * 3];
for py in 0..SRC {
for px in 0..SRC {
let (u, v) = chroma_at(px, py);
let [r, g, b] = c.decode(y_plane[py * SRC + px], u, v);
let i = (py * SRC + px) * 3;
rgb[i] = r;
rgb[i + 1] = g;
rgb[i + 2] = b;
}
}
rgb
}
fn scene_oracle(full_unclamped_rgb: &[f32], tf: TransferFunction) -> Vec<u8> {
let mut out = vec![0u8; OUT * OUT * 3];
for oy in 0..OUT {
for ox in 0..OUT {
for ch in 0..3 {
let mut acc = 0.0f32;
for dy in 0..2 {
for dx in 0..2 {
let sy = oy * 2 + dy;
let sx = ox * 2 + dx;
let e = full_unclamped_rgb[(sy * SRC + sx) * 3 + ch];
acc += tf.eotf(e);
}
}
let mean = acc / 4.0;
let enc = (tf.oetf(mean) * 255.0 + 0.5).clamp(0.0, 255.0) as u8;
out[(oy * OUT + ox) * 3 + ch] = enc;
}
}
}
out
}
fn max_abs_diff(a: &[u8], b: &[u8]) -> u8 {
a.iter()
.zip(b.iter())
.map(|(&x, &y)| x.abs_diff(y))
.max()
.unwrap_or(0)
}
fn at_420<'a>(u: &'a [u8], v: &'a [u8], cw: usize) -> impl Fn(usize, usize) -> (u8, u8) + 'a {
move |x, y| {
let cx = x / 2;
let cy = y / 2;
(u[cy * cw + cx], v[cy * cw + cx])
}
}
fn at_422<'a>(u: &'a [u8], v: &'a [u8], cw: usize) -> impl Fn(usize, usize) -> (u8, u8) + 'a {
move |x, y| {
let cx = x / 2;
(u[y * cw + cx], v[y * cw + cx])
}
}
fn at_444<'a>(u: &'a [u8], v: &'a [u8]) -> impl Fn(usize, usize) -> (u8, u8) + 'a {
move |x, y| (u[y * SRC + x], v[y * SRC + x])
}
fn at_440<'a>(u: &'a [u8], v: &'a [u8]) -> impl Fn(usize, usize) -> (u8, u8) + 'a {
move |x, y| {
let cy = y / 2;
(u[cy * SRC + x], v[cy * SRC + x])
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn yuv420p_scene_referred_equals_independent_unclamped_oracle() {
let matrix = KernelMatrix::Bt709;
let tf = TransferFunction::for_matrix(&crate::ColorMatrix::from(matrix));
let y = y_ramp();
let cw = SRC / 2;
let u = chroma(cw, cw, 200, 6);
let v = chroma(cw, cw, 40, 7);
let oracle = scene_oracle(&full_res_unclamped_rgb(&y, at_420(&u, &v, cw)), tf);
let mut rgb = vec![0u8; OUT * OUT * 3];
{
let src = Yuv420pFrame::new(
&y, &u, &v, SRC as u32, SRC as u32, SRC as u32, cw as u32, cw as u32,
);
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(LinearMode::SceneReferred)
.with_rgb(&mut rgb)
.unwrap();
yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"Yuv420p scene vs unclamped oracle: max diff {} (rgb={rgb:?} oracle={oracle:?})",
max_abs_diff(&rgb, &oracle),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn yuv422p_scene_referred_equals_independent_unclamped_oracle() {
let matrix = KernelMatrix::Bt709;
let tf = TransferFunction::for_matrix(&crate::ColorMatrix::from(matrix));
let y = y_ramp();
let cw = SRC / 2;
let u = chroma(cw, SRC, 200, 6);
let v = chroma(cw, SRC, 40, 7);
let oracle = scene_oracle(&full_res_unclamped_rgb(&y, at_422(&u, &v, cw)), tf);
let mut rgb = vec![0u8; OUT * OUT * 3];
{
let src = Yuv422pFrame::new(
&y, &u, &v, SRC as u32, SRC as u32, SRC as u32, cw as u32, cw as u32,
);
let mut sink =
MixedSinker::<Yuv422p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(LinearMode::SceneReferred)
.with_rgb(&mut rgb)
.unwrap();
yuv422p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"Yuv422p scene vs unclamped oracle: max diff {}",
max_abs_diff(&rgb, &oracle),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn yuv444p_scene_referred_equals_independent_unclamped_oracle() {
let matrix = KernelMatrix::Bt709;
let tf = TransferFunction::for_matrix(&crate::ColorMatrix::from(matrix));
let y = y_ramp();
let u = chroma(SRC, SRC, 200, 6);
let v = chroma(SRC, SRC, 40, 7);
let oracle = scene_oracle(&full_res_unclamped_rgb(&y, at_444(&u, &v)), tf);
let mut rgb = vec![0u8; OUT * OUT * 3];
{
let src = Yuv444pFrame::new(
&y, &u, &v, SRC as u32, SRC as u32, SRC as u32, SRC as u32, SRC as u32,
);
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(LinearMode::SceneReferred)
.with_rgb(&mut rgb)
.unwrap();
yuv444p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"Yuv444p scene vs unclamped oracle: max diff {}",
max_abs_diff(&rgb, &oracle),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn yuv440p_scene_referred_equals_independent_unclamped_oracle() {
let matrix = KernelMatrix::Bt709;
let tf = TransferFunction::for_matrix(&crate::ColorMatrix::from(matrix));
let y = y_ramp();
let ch = SRC / 2;
let u = chroma(SRC, ch, 200, 6);
let v = chroma(SRC, ch, 40, 7);
let oracle = scene_oracle(&full_res_unclamped_rgb(&y, at_440(&u, &v)), tf);
let mut rgb = vec![0u8; OUT * OUT * 3];
{
let src = Yuv440pFrame::new(
&y, &u, &v, SRC as u32, SRC as u32, SRC as u32, SRC as u32, SRC as u32,
);
let mut sink =
MixedSinker::<Yuv440p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(LinearMode::SceneReferred)
.with_rgb(&mut rgb)
.unwrap();
yuv440p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"Yuv440p scene vs unclamped oracle: max diff {}",
max_abs_diff(&rgb, &oracle),
);
}
fn run_420_mode(y: &[u8], u: &[u8], v: &[u8], matrix: KernelMatrix, mode: LinearMode) -> Vec<u8> {
let cw = SRC / 2;
let src = Yuv420pFrame::new(
y, u, v, SRC as u32, SRC as u32, SRC as u32, cw as u32, cw as u32,
);
let mut rgb = vec![0u8; OUT * OUT * 3];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(mode)
.with_native(false)
.with_rgb(&mut rgb)
.unwrap();
yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
rgb
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn scene_and_display_referred_differ_on_out_of_gamut() {
let matrix = KernelMatrix::Bt709;
let mut y = vec![0u8; SRC * SRC];
for (i, p) in y.iter_mut().enumerate() {
let (r, c) = (i / SRC, i % SRC);
*p = if (r + c) % 2 == 0 { 235 } else { 40 };
}
let cw = SRC / 2;
let mut u = vec![128u8; cw * cw];
let mut v = vec![128u8; cw * cw];
for cy in 0..cw {
for cx in 0..cw {
if (cx + cy) % 2 == 0 {
u[cy * cw + cx] = 255;
v[cy * cw + cx] = 0;
}
}
}
let display = run_420_mode(&y, &u, &v, matrix, LinearMode::DisplayReferred);
let scene = run_420_mode(&y, &u, &v, matrix, LinearMode::SceneReferred);
assert!(
max_abs_diff(&display, &scene) > 4,
"scene-referred must differ from display-referred on out-of-gamut content \
(max diff {}, display={display:?} scene={scene:?})",
max_abs_diff(&display, &scene),
);
let tf = TransferFunction::for_matrix(&crate::ColorMatrix::from(matrix));
let oracle = scene_oracle(&full_res_unclamped_rgb(&y, at_420(&u, &v, cw)), tf);
assert!(
max_abs_diff(&scene, &oracle) <= 1,
"scene-referred out-of-gamut output must match its unclamped oracle (max diff {})",
max_abs_diff(&scene, &oracle),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn scene_and_display_referred_coincide_in_gamut() {
let matrix = KernelMatrix::Bt709;
let mut y = vec![0u8; SRC * SRC];
for (i, p) in y.iter_mut().enumerate() {
let (r, c) = (i / SRC, i % SRC);
*p = if (r + c) % 2 == 0 { 90 } else { 160 };
}
let cw = SRC / 2;
let u = vec![128u8; cw * cw];
let v = vec![128u8; cw * cw];
let display = run_420_mode(&y, &u, &v, matrix, LinearMode::DisplayReferred);
let scene = run_420_mode(&y, &u, &v, matrix, LinearMode::SceneReferred);
assert!(
max_abs_diff(&display, &scene) <= 1,
"scene and display must coincide on in-gamut content (max diff {})",
max_abs_diff(&display, &scene),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn display_referred_default_is_byte_identical_to_explicit() {
let matrix = KernelMatrix::Bt709;
{
let y = y_ramp();
let cw = SRC / 2;
let u = chroma(cw, cw, 200, 6);
let v = chroma(cw, cw, 40, 7);
let render = |set_display: bool| {
let src = Yuv420pFrame::new(
&y, &u, &v, SRC as u32, SRC as u32, SRC as u32, cw as u32, cw as u32,
);
let mut rgba = vec![0u8; OUT * OUT * 4];
{
let base = MixedSinker::<Yuv420p, AreaResampler>::with_resampler(
SRC,
SRC,
AreaResampler::to(OUT, OUT),
)
.unwrap()
.with_averaging_domain(AveragingDomain::Linear);
let base = if set_display {
base.with_linear_mode(LinearMode::DisplayReferred)
} else {
base
};
let mut sink = base.with_rgba(&mut rgba).unwrap();
yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
rgba
};
assert_eq!(
render(false),
render(true),
"Yuv420p default (unset) LinearMode must equal explicit DisplayReferred",
);
}
{
let y = y_ramp();
let u = chroma(SRC, SRC, 200, 6);
let v = chroma(SRC, SRC, 40, 7);
let render = |set_display: bool| {
let src = Yuv444pFrame::new(
&y, &u, &v, SRC as u32, SRC as u32, SRC as u32, SRC as u32, SRC as u32,
);
let mut rgb = vec![0u8; OUT * OUT * 3];
{
let base = MixedSinker::<Yuv444p, AreaResampler>::with_resampler(
SRC,
SRC,
AreaResampler::to(OUT, OUT),
)
.unwrap()
.with_averaging_domain(AveragingDomain::Linear);
let base = if set_display {
base.with_linear_mode(LinearMode::DisplayReferred)
} else {
base
};
let mut sink = base.with_rgb(&mut rgb).unwrap();
yuv444p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
rgb
};
assert_eq!(
render(false),
render(true),
"Yuv444p default (unset) LinearMode must equal explicit DisplayReferred",
);
}
}
#[test]
fn linear_mode_default_and_round_trip() {
let sink = MixedSinker::<Yuv420p>::new(SRC, SRC);
assert_eq!(sink.linear_mode(), LinearMode::DisplayReferred);
assert_eq!(
sink
.with_linear_mode(LinearMode::SceneReferred)
.linear_mode(),
LinearMode::SceneReferred,
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn scene_mode_mid_frame_transfer_change_is_rejected() {
let y = y_ramp();
let cw = SRC / 2;
let u = chroma(cw, cw, 200, 6);
let v = chroma(cw, cw, 40, 7);
let mut rgb = vec![0u8; OUT * OUT * 3];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(LinearMode::SceneReferred)
.with_transfer_function(TransferFunction::Srgb)
.with_rgb(&mut rgb)
.unwrap();
sink.begin_frame(SRC as u32, SRC as u32).unwrap();
let yr = &y[0..SRC];
let ur = &u[0..cw];
let vr = &v[0..cw];
sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
0,
KernelMatrix::Bt709,
true,
))
.unwrap();
sink.set_transfer_function(TransferFunction::Bt1886);
let yr = &y[SRC..2 * SRC];
let ur = &u[cw..2 * cw];
let vr = &v[cw..2 * cw];
let err = sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
1,
KernelMatrix::Bt709,
true,
))
.unwrap_err();
assert!(
matches!(err, MixedSinkerError::TransferFunctionChanged(_)),
"mid-frame transfer change in scene mode must reject with TransferFunctionChanged, got {err:?}",
);
sink.set_transfer_function(TransferFunction::Srgb);
sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
1,
KernelMatrix::Bt709,
true,
))
.unwrap();
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn scene_mode_mid_frame_domain_change_is_rejected() {
let y = y_ramp();
let cw = SRC / 2;
let u = chroma(cw, cw, 200, 6);
let v = chroma(cw, cw, 40, 7);
let mut rgb = vec![0u8; OUT * OUT * 3];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(LinearMode::SceneReferred)
.with_rgb(&mut rgb)
.unwrap();
sink.begin_frame(SRC as u32, SRC as u32).unwrap();
let yr = &y[0..SRC];
let ur = &u[0..cw];
let vr = &v[0..cw];
sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
0,
KernelMatrix::Bt709,
true,
))
.unwrap();
sink.set_averaging_domain(AveragingDomain::Encoded);
let yr = &y[SRC..2 * SRC];
let ur = &u[cw..2 * cw];
let vr = &v[cw..2 * cw];
let err = sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
1,
KernelMatrix::Bt709,
true,
))
.unwrap_err();
assert!(
matches!(err, MixedSinkerError::AveragingDomainChanged(_)),
"mid-frame domain change in scene mode must reject with AveragingDomainChanged, got {err:?}",
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn scene_referred_mid_frame_mode_change_is_rejected() {
let y = y_ramp();
let cw = SRC / 2;
let u = chroma(cw, cw, 200, 6);
let v = chroma(cw, cw, 40, 7);
let row = |r: usize| {
let yr = &y[r * SRC..(r + 1) * SRC];
let cr = r / 2;
(yr, &u[cr * cw..(cr + 1) * cw], &v[cr * cw..(cr + 1) * cw])
};
for (frozen, flipped) in [
(LinearMode::SceneReferred, LinearMode::DisplayReferred),
(LinearMode::DisplayReferred, LinearMode::SceneReferred),
] {
const SENTINEL: u8 = 0xEF;
let mut rgb = vec![SENTINEL; OUT * OUT * 3];
{
let mut sink = MixedSinker::<Yuv420p, AreaResampler>::with_resampler(
SRC,
SRC,
AreaResampler::to(OUT, OUT),
)
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(frozen)
.with_rgb(&mut rgb)
.unwrap();
sink.begin_frame(SRC as u32, SRC as u32).unwrap();
let (yr, ur, vr) = row(0);
sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
0,
KernelMatrix::Bt709,
true,
))
.unwrap();
sink.set_linear_mode(flipped);
let (yr, ur, vr) = row(1);
let err = sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
1,
KernelMatrix::Bt709,
true,
))
.unwrap_err();
assert!(
matches!(err, MixedSinkerError::LinearModeChanged(_)),
"a mid-frame linear-mode change ({frozen:?} -> {flipped:?}) must reject \
with the specific LinearModeChanged, got {err:?}",
);
sink.set_linear_mode(frozen);
for r in 1..SRC {
let (yr, ur, vr) = row(r);
sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
r,
KernelMatrix::Bt709,
true,
))
.unwrap();
}
}
assert!(
rgb.iter().any(|&b| b != SENTINEL),
"the resumed frame ({frozen:?} frozen) must produce real output once completed",
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn scene_mode_final_row_alloc_failure_leaves_frame_retryable() {
let matrix = KernelMatrix::Bt709;
let tf = TransferFunction::for_matrix(&crate::ColorMatrix::from(matrix));
let y = y_ramp();
let cw = SRC / 2;
let u = chroma(cw, cw, 200, 6);
let v = chroma(cw, cw, 40, 7);
let expected = scene_oracle(&full_res_unclamped_rgb(&y, at_420(&u, &v, cw)), tf);
let mut rgb = vec![0u8; OUT * OUT * 3];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(LinearMode::SceneReferred)
.with_rgb(&mut rgb)
.unwrap();
sink.begin_frame(SRC as u32, SRC as u32).unwrap();
for r in 0..SRC - 1 {
let yr = &y[r * SRC..(r + 1) * SRC];
let cr = r / 2;
let ur = &u[cr * cw..(cr + 1) * cw];
let vr = &v[cr * cw..(cr + 1) * cw];
sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
r,
KernelMatrix::Bt709,
true,
))
.unwrap();
}
crate::sinker::mixed::linear_light::arm_linear_tail_alloc_failure();
let r = SRC - 1;
let yr = &y[r * SRC..(r + 1) * SRC];
let cr = r / 2;
let ur = &u[cr * cw..(cr + 1) * cw];
let vr = &v[cr * cw..(cr + 1) * cw];
let err = sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
r,
KernelMatrix::Bt709,
true,
))
.unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"scene-mode final-row alloc failure must surface AllocationFailed, got {err:?}",
);
sink
.process(Yuv420pRow::for_tests(
yr,
ur,
vr,
r,
KernelMatrix::Bt709,
true,
))
.unwrap();
}
assert!(
max_abs_diff(&rgb, &expected) <= 1,
"scene-mode retried final row must produce the correct binned result (max diff {})",
max_abs_diff(&rgb, &expected),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn scene_mode_rejects_filter_plan() {
const SENTINEL: u8 = 0x5A;
let matrix = KernelMatrix::Bt709;
let y = y_ramp();
let cw = SRC / 2;
let u = chroma(cw, cw, 200, 6);
let v = chroma(cw, cw, 40, 7);
let src = Yuv420pFrame::new(
&y, &u, &v, SRC as u32, SRC as u32, SRC as u32, cw as u32, cw as u32,
);
let mut rgb = vec![SENTINEL; OUT * OUT * 3];
{
let mut sink = MixedSinker::<Yuv420p, FilteredResampler<Triangle>>::with_resampler(
SRC,
SRC,
FilteredResampler::new(OUT, OUT, Triangle),
)
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_linear_mode(LinearMode::SceneReferred)
.with_rgb(&mut rgb)
.unwrap();
let err = yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::UnsupportedFilter(_))
),
"scene mode + a filter plan must reject with UnsupportedFilter, got {err:?}",
);
}
assert!(
rgb.iter().all(|&b| b == SENTINEL),
"a rejected filter plan must leave the output unmutated",
);
}