use crate::{
KernelMatrix, PixelSink,
resample::{
AreaResampler, AveragingDomain, FilteredResampler, ResampleError, TransferFunction, Triangle,
},
sinker::{MixedSinker, MixedSinkerError},
source::{
Yuv420p, Yuv420pRow, Yuv422p, Yuv440p, Yuv444p, Yuv444pRow, 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
}
fn full_res_rgb_420(y: &[u8], u: &[u8], v: &[u8], matrix: KernelMatrix) -> 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; SRC * SRC * 3];
{
let mut sink = MixedSinker::<Yuv420p>::new(SRC, SRC)
.with_rgb(&mut rgb)
.unwrap();
yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
rgb
}
fn full_res_rgb_422(y: &[u8], u: &[u8], v: &[u8], matrix: KernelMatrix) -> Vec<u8> {
let cw = SRC / 2;
let src = Yuv422pFrame::new(
y, u, v, SRC as u32, SRC as u32, SRC as u32, cw as u32, cw as u32,
);
let mut rgb = vec![0u8; SRC * SRC * 3];
{
let mut sink = MixedSinker::<Yuv422p>::new(SRC, SRC)
.with_rgb(&mut rgb)
.unwrap();
yuv422p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
rgb
}
fn full_res_rgb_444(y: &[u8], u: &[u8], v: &[u8], matrix: KernelMatrix) -> Vec<u8> {
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; SRC * SRC * 3];
{
let mut sink = MixedSinker::<Yuv444p>::new(SRC, SRC)
.with_rgb(&mut rgb)
.unwrap();
yuv444p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
rgb
}
fn full_res_rgb_440(y: &[u8], u: &[u8], v: &[u8], matrix: KernelMatrix) -> Vec<u8> {
let src = Yuv440pFrame::new(
y, u, v, SRC as u32, SRC as u32, SRC as u32, SRC as u32, SRC as u32,
);
let mut rgb = vec![0u8; SRC * SRC * 3];
{
let mut sink = MixedSinker::<Yuv440p>::new(SRC, SRC)
.with_rgb(&mut rgb)
.unwrap();
yuv440p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
rgb
}
fn linear_light_oracle(full_rgb: &[u8], tf: TransferFunction) -> Vec<u8> {
let mut out = vec![0u8; OUT * OUT * 3];
for oy in 0..OUT {
for ox in 0..OUT {
for c 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_rgb[(sy * SRC + sx) * 3 + c] as f32 / 255.0;
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 + c] = 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)
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn yuv420p_linear_domain_equals_independent_linear_light_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 = linear_light_oracle(&full_res_rgb_420(&y, &u, &v, matrix), 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_rgb(&mut rgb)
.unwrap();
yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"Yuv420p linear vs 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_linear_domain_equals_independent_linear_light_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 = linear_light_oracle(&full_res_rgb_422(&y, &u, &v, matrix), 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_rgb(&mut rgb)
.unwrap();
yuv422p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"Yuv422p linear vs oracle: max diff {}",
max_abs_diff(&rgb, &oracle),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn yuv444p_linear_domain_equals_independent_linear_light_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 = linear_light_oracle(&full_res_rgb_444(&y, &u, &v, matrix), 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_rgb(&mut rgb)
.unwrap();
yuv444p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"Yuv444p linear vs oracle: max diff {}",
max_abs_diff(&rgb, &oracle),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn yuv440p_linear_domain_equals_independent_linear_light_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 = linear_light_oracle(&full_res_rgb_440(&y, &u, &v, matrix), 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_rgb(&mut rgb)
.unwrap();
yuv440p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"Yuv440p linear vs oracle: max diff {}",
max_abs_diff(&rgb, &oracle),
);
}
fn run_420(y: &[u8], u: &[u8], v: &[u8], matrix: KernelMatrix, domain: AveragingDomain) -> 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(domain)
.with_native(false)
.with_rgb(&mut rgb)
.unwrap();
yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
rgb
}
fn y_checker() -> Vec<u8> {
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 { 16 } else { 235 };
}
y
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_and_encoded_domains_differ() {
let matrix = KernelMatrix::Bt709;
let y = y_checker();
let cw = SRC / 2;
let u = vec![128u8; cw * cw];
let v = vec![128u8; cw * cw];
let encoded = run_420(&y, &u, &v, matrix, AveragingDomain::Encoded);
let linear = run_420(&y, &u, &v, matrix, AveragingDomain::Linear);
assert!(
max_abs_diff(&encoded, &linear) > 10,
"linear must differ materially from encoded (max diff {}, encoded={encoded:?} linear={linear:?})",
max_abs_diff(&encoded, &linear),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn transfer_function_caller_override_changes_output() {
let matrix = KernelMatrix::Bt709;
let y = y_checker();
let cw = SRC / 2;
let u = vec![128u8; cw * cw];
let v = vec![128u8; cw * cw];
let run = |tf: TransferFunction| {
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_transfer_function(tf)
.with_rgb(&mut rgb)
.unwrap();
yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
rgb
};
let srgb = run(TransferFunction::Srgb);
let bt1886 = run(TransferFunction::Bt1886);
assert!(
max_abs_diff(&srgb, &bt1886) > 1,
"Srgb vs Bt1886 override must change the Linear output (max diff {})",
max_abs_diff(&srgb, &bt1886),
);
for tf in [TransferFunction::Srgb, TransferFunction::Bt1886] {
let oracle = linear_light_oracle(&full_res_rgb_420(&y, &u, &v, matrix), tf);
let got = run(tf);
assert!(
max_abs_diff(&got, &oracle) <= 1,
"override {} must match its oracle (max diff {})",
tf.as_str(),
max_abs_diff(&got, &oracle),
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn per_color_matrix_default_transfer_resolves() {
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 default = run_420(&y, &u, &v, matrix, AveragingDomain::Linear);
let mut overridden = 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_transfer_function(TransferFunction::Bt1886)
.with_native(false)
.with_rgb(&mut overridden)
.unwrap();
yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap();
}
assert_eq!(
default, overridden,
"a video-matrix sink with no override must resolve to BT.1886",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn encoded_default_is_byte_identical_to_unset() {
let matrix = KernelMatrix::Bt601;
let y = y_ramp();
let cw = SRC / 2;
let u = chroma(cw, cw, 110, 6);
let v = chroma(cw, cw, 150, 7);
for native in [true, false] {
let render = |set_encoded: 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_native(native);
let base = if set_encoded {
base.with_averaging_domain(AveragingDomain::Encoded)
} 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),
"default (unset) domain must be byte-identical to explicit Encoded (native={native})",
);
}
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_domain_rejects_filter_plan() {
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,
);
const SENTINEL: u8 = 0xAB;
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_rgb(&mut rgb)
.unwrap();
let err = yuv420p_to(&src, true, sink.set_kernel_matrix(matrix)).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::UnsupportedFilter(_))
),
"Linear + filter plan must reject with UnsupportedFilter, got {err:?}",
);
}
assert!(
rgb.iter().all(|&b| b == SENTINEL),
"rejected Linear filter plan must NOT write the output (silent encoded result leaked)",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_domain_out_of_sequence_row_is_atomic() {
const SENTINEL: u8 = 0xCD;
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_rgb(&mut rgb)
.unwrap();
sink.begin_frame(SRC as u32, SRC as u32).unwrap();
let y = [50u8; SRC];
let u = [128u8; SRC / 2];
let v = [128u8; SRC / 2];
let err = sink
.process(Yuv420pRow::for_tests(
&y,
&u,
&v,
3,
KernelMatrix::Bt709,
true,
))
.unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::OutOfSequenceRow(_))
),
"out-of-sequence Linear row must reject with OutOfSequenceRow (not AllocationFailed), got {err:?}",
);
}
assert!(
rgb.iter().all(|&b| b == SENTINEL),
"a rejected Linear row must leave the output unmutated",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_domain_final_row_output_change_is_atomic() {
const SENTINEL: u8 = 0xEF;
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 luma = vec![SENTINEL; OUT * OUT];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.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();
}
sink.set_luma(&mut luma).unwrap();
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::ResampleOutputsChanged(_)),
"mid-frame output-set change on the final Linear row must reject with \
ResampleOutputsChanged (not AllocationFailed), got {err:?}",
);
}
assert!(
luma.iter().all(|&b| b == SENTINEL),
"a rejected final-row output change must leave the new output unmutated",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_domain_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 oracle = linear_light_oracle(&full_res_rgb_420(&y, &u, &v, matrix), tf);
const SENTINEL: u8 = 0x5A;
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_rgb(&mut rgb)
.unwrap();
sink.begin_frame(SRC as u32, SRC as u32).unwrap();
let feed = |sink: &mut MixedSinker<'_, Yuv420p, AreaResampler>, r: usize| {
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,
))
};
for r in 0..SRC - 1 {
feed(&mut sink, r).unwrap();
}
crate::sinker::mixed::linear_light::arm_linear_tail_alloc_failure();
let err = feed(&mut sink, SRC - 1).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"armed final-row tail alloc must surface AllocationFailed (an allocator \
refusal is not a GeometryOverflow), got {err:?}",
);
feed(&mut sink, SRC - 1).unwrap();
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"the post-failure retry must produce the correct binned result (max diff {})",
max_abs_diff(&rgb, &oracle),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_domain_premultiplied_on_non_alpha_rejects() {
const SENTINEL: u8 = 0x9E;
let matrix = KernelMatrix::Bt709;
let y = y_ramp();
let cw = SRC / 2;
fn assert_rejected(format: &str, run: impl FnOnce(&mut [u8]) -> Result<(), MixedSinkerError>) {
let mut rgb = vec![SENTINEL; OUT * OUT * 3];
let err = run(&mut rgb).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::PremultipliedDomainUnsupported(_))
),
"{format} + Premultiplied must reject with PremultipliedDomainUnsupported, got {err:?}",
);
assert!(
rgb.iter().all(|&b| b == SENTINEL),
"{format} rejected Premultiplied row must NOT write the output (silent encoded result leaked)",
);
}
let u420 = chroma(cw, cw, 200, 6);
let v420 = chroma(cw, cw, 40, 7);
for native in [true, false] {
assert_rejected("Yuv420p", |rgb| {
let src = Yuv420pFrame::new(
&y, &u420, &v420, 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_native(native)
.with_averaging_domain(AveragingDomain::Premultiplied)
.with_rgb(rgb)
.unwrap();
yuv420p_to(&src, true, sink.set_kernel_matrix(matrix))
});
}
let u422 = chroma(cw, SRC, 200, 6);
let v422 = chroma(cw, SRC, 40, 7);
assert_rejected("Yuv422p", |rgb| {
let src = Yuv422pFrame::new(
&y, &u422, &v422, 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::Premultiplied)
.with_rgb(rgb)
.unwrap();
yuv422p_to(&src, true, sink.set_kernel_matrix(matrix))
});
let u444 = chroma(SRC, SRC, 200, 6);
let v444 = chroma(SRC, SRC, 40, 7);
assert_rejected("Yuv444p", |rgb| {
let src = Yuv444pFrame::new(
&y, &u444, &v444, 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::Premultiplied)
.with_rgb(rgb)
.unwrap();
yuv444p_to(&src, true, sink.set_kernel_matrix(matrix))
});
let ch = SRC / 2;
let u440 = chroma(SRC, ch, 200, 6);
let v440 = chroma(SRC, ch, 40, 7);
assert_rejected("Yuv440p", |rgb| {
let src = Yuv440pFrame::new(
&y, &u440, &v440, 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::Premultiplied)
.with_rgb(rgb)
.unwrap();
yuv440p_to(&src, true, sink.set_kernel_matrix(matrix))
});
}
#[test]
fn linear_domain_mid_frame_transfer_change_is_rejected_and_retryable() {
const SENTINEL: u8 = 0xEF;
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])
};
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_transfer_function(TransferFunction::Srgb)
.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_transfer_function(TransferFunction::Bt1886);
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::TransferFunctionChanged(_)),
"a mid-frame transfer-function change must reject with \
TransferFunctionChanged, got {err:?}",
);
sink.set_transfer_function(TransferFunction::Srgb);
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 must produce real output once completed",
);
}
#[test]
fn linear_domain_mid_frame_domain_change_is_rejected() {
const SENTINEL: u8 = 0xEF;
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])
};
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_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_averaging_domain(AveragingDomain::Encoded);
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::AveragingDomainChanged(_)),
"a mid-frame averaging-domain change must reject with the specific \
AveragingDomainChanged, got {err:?}",
);
assert!(
!matches!(
err,
MixedSinkerError::Resample(ResampleError::OutOfSequenceRow(_))
),
"the domain-change rejection must be AveragingDomainChanged, never the \
incidental OutOfSequenceRow, got {err:?}",
);
sink.set_averaging_domain(AveragingDomain::Linear);
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 must produce real output once completed",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_domain_filter_reject_does_not_poison_domain_freeze() {
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;
Yuv420pRow::for_tests(
yr,
&u[cr * cw..(cr + 1) * cw],
&v[cr * cw..(cr + 1) * cw],
r,
KernelMatrix::Bt709,
true,
)
};
const SENTINEL: u8 = 0x3C;
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_rgb(&mut rgb)
.unwrap();
sink.begin_frame(SRC as u32, SRC as u32).unwrap();
let err = sink.process(row(0)).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::UnsupportedFilter(_))
),
"Linear + filter plan must reject with UnsupportedFilter, got {err:?}",
);
sink.set_averaging_domain(AveragingDomain::Encoded);
sink.process(row(0)).expect(
"after a rejected row the corrected-domain retry of the SAME row must \
succeed — the rejected row must not have committed the domain freeze",
);
for r in 1..SRC {
sink.process(row(r)).unwrap();
}
}
assert!(
rgb.iter().any(|&b| b != SENTINEL),
"the corrected-domain retry must produce real output",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_domain_first_row_scratch_failure_leaves_frame_unset() {
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 oracle = linear_light_oracle(
&full_res_rgb_420(&y, &u, &v, matrix),
TransferFunction::Bt1886,
);
const SENTINEL: u8 = 0x6B;
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_transfer_function(TransferFunction::Srgb)
.with_rgb(&mut rgb)
.unwrap();
sink.begin_frame(SRC as u32, SRC as u32).unwrap();
let feed = |sink: &mut MixedSinker<'_, Yuv420p, AreaResampler>, r: usize| {
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,
))
};
crate::sinker::mixed::linear_light::arm_linear_scratch_failure();
let err = feed(&mut sink, 0).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"armed first-row scratch reserve must surface AllocationFailed, got {err:?}",
);
sink.set_transfer_function(TransferFunction::Bt1886);
feed(&mut sink, 0).expect(
"after a first-row scratch failure the corrected-transfer retry of the \
SAME row 0 must succeed — the failed row must not have committed the frame \
(which would have frozen the stale transfer)",
);
for r in 1..SRC {
feed(&mut sink, r).unwrap();
}
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"the post-failure retry must bin under the corrected (Bt1886) transfer \
(max diff {})",
max_abs_diff(&rgb, &oracle),
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_domain_first_row_failure_allows_output_set_retry() {
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 = linear_light_oracle(&full_res_rgb_420(&y, &u, &v, matrix), tf);
const SENTINEL: u8 = 0x4D;
let mut rgb = vec![SENTINEL; OUT * OUT * 3];
let mut luma = vec![SENTINEL; OUT * OUT];
{
let mut sink =
MixedSinker::<Yuv420p, AreaResampler>::with_resampler(SRC, SRC, AreaResampler::to(OUT, OUT))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_rgb(&mut rgb)
.unwrap();
sink.begin_frame(SRC as u32, SRC as u32).unwrap();
let row = |r: usize| {
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];
Yuv420pRow::for_tests(yr, ur, vr, r, KernelMatrix::Bt709, true)
};
crate::sinker::mixed::linear_light::arm_linear_scratch_failure();
let err = sink.process(row(0)).unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"armed first-row scratch reserve must surface AllocationFailed, got {err:?}",
);
sink.set_luma(&mut luma).unwrap();
sink.process(row(0)).expect(
"after a first-row scratch failure the changed-output-set retry of the \
SAME row 0 must succeed — the failed row must not have committed the \
output freeze (which would have frozen the stale rgb-only set)",
);
for r in 1..SRC {
sink.process(row(r)).unwrap();
}
}
assert!(
max_abs_diff(&rgb, &oracle) <= 1,
"the post-failure retry must bin the rgb output correctly under the changed \
output set (max diff {})",
max_abs_diff(&rgb, &oracle),
);
assert!(
luma.iter().any(|&b| b != SENTINEL),
"the newly-attached luma output must be written on the retry — proving the \
changed output set was honoured (not rejected against a poisoned freeze)",
);
}
#[test]
#[cfg_attr(
miri,
ignore = "SIMD-dispatched row kernels use intrinsics unsupported by Miri"
)]
fn linear_domain_single_row_frame_tail_failure_leaves_frame_unset() {
const W: usize = 2;
let y = [80u8, 200u8];
let u = [150u8, 90u8];
let v = [60u8, 170u8];
const SENTINEL: u8 = 0x71;
let mut rgb = vec![SENTINEL; 3];
{
let mut sink =
MixedSinker::<Yuv444p, AreaResampler>::with_resampler(W, 1, AreaResampler::to(1, 1))
.unwrap()
.with_averaging_domain(AveragingDomain::Linear)
.with_transfer_function(TransferFunction::Srgb)
.with_rgb(&mut rgb)
.unwrap();
sink.begin_frame(W as u32, 1).unwrap();
crate::sinker::mixed::linear_light::arm_linear_tail_alloc_failure();
let err = sink
.process(Yuv444pRow::for_tests(
&y,
&u,
&v,
0,
KernelMatrix::Bt709,
true,
))
.unwrap_err();
assert!(
matches!(
err,
MixedSinkerError::Resample(ResampleError::AllocationFailed(_))
),
"armed single-row tail alloc must surface AllocationFailed, got {err:?}",
);
sink.set_transfer_function(TransferFunction::Bt1886);
sink
.process(Yuv444pRow::for_tests(
&y,
&u,
&v,
0,
KernelMatrix::Bt709,
true,
))
.expect(
"after a single-row tail failure the corrected-transfer retry of row 0 \
must succeed — the failed row must not have committed the frame",
);
}
assert!(
rgb.iter().any(|&b| b != SENTINEL),
"the post-failure single-row retry must produce real output",
);
}