use crate::{
ChromaLocation, ColorInfo, ColorMatrix, ColorSpec, DynamicRange, PixelFormat, Primaries,
Transfer, sinker::MixedSinker,
};
fn le_wire_u16(v: u16) -> u16 {
u16::from_ne_bytes(v.to_le_bytes())
}
fn reference_rgb_u8(y: u16, dz: u16, dx: u16, full: bool) -> [u8; 3] {
let (yy, u, v) = ([le_wire_u16(y)], [le_wire_u16(dz)], [le_wire_u16(dx)]);
let mut out = [0u8; 3];
crate::row::scalar::smpte2085::smpte2085_444p_n_to_rgb_row::<12, false>(
&yy, &u, &v, &mut out, 1, full,
);
out
}
fn reference_rgb_u16(y: u16, dz: u16, dx: u16, full: bool) -> [u16; 3] {
let (yy, u, v) = ([le_wire_u16(y)], [le_wire_u16(dz)], [le_wire_u16(dx)]);
let mut out = [0u16; 3];
crate::row::scalar::smpte2085::smpte2085_444p_n_to_rgb_u16_row::<12, false>(
&yy, &u, &v, &mut out, 1, full,
);
out
}
fn decode_rgb(
y: u16,
dz: u16,
dx: u16,
full_range: bool,
matrix: ColorMatrix,
transfer: Transfer,
) -> std::vec::Vec<u8> {
let (w, h) = (4usize, 2usize);
let n = w * h;
let (yy, u, v) = (
std::vec![le_wire_u16(y); n],
std::vec![le_wire_u16(dz); n],
std::vec![le_wire_u16(dx); n],
);
let src = crate::frame::Yuv444pFrame16::<12>::new(
&yy, &u, &v, w as u32, h as u32, w as u32, w as u32, w as u32,
);
let mut rgb = std::vec![0u8; n * 3];
let range = if full_range {
DynamicRange::Full
} else {
DynamicRange::Limited
};
let spec = ColorSpec::from_info(
PixelFormat::Yuv444p12Le,
ColorInfo::new(
Primaries::Bt2020,
transfer,
matrix,
range,
ChromaLocation::Left,
),
);
{
let mut sink = MixedSinker::<crate::source::Yuv444p12>::new(w, h)
.with_rgb(&mut rgb)
.unwrap()
.with_color_spec(&spec)
.unwrap();
crate::source::yuv444p12_to(
&src,
full_range,
sink.set_kernel_matrix(spec.kernel_matrix().unwrap()),
)
.unwrap();
}
rgb
}
fn decode_rgb_u16(
y: u16,
dz: u16,
dx: u16,
full_range: bool,
matrix: ColorMatrix,
transfer: Transfer,
) -> std::vec::Vec<u16> {
let (w, h) = (4usize, 2usize);
let n = w * h;
let (yy, u, v) = (
std::vec![le_wire_u16(y); n],
std::vec![le_wire_u16(dz); n],
std::vec![le_wire_u16(dx); n],
);
let src = crate::frame::Yuv444pFrame16::<12>::new(
&yy, &u, &v, w as u32, h as u32, w as u32, w as u32, w as u32,
);
let mut rgb = std::vec![0u16; n * 3];
let range = if full_range {
DynamicRange::Full
} else {
DynamicRange::Limited
};
let spec = ColorSpec::from_info(
PixelFormat::Yuv444p12Le,
ColorInfo::new(
Primaries::Bt2020,
transfer,
matrix,
range,
ChromaLocation::Left,
),
);
{
let mut sink = MixedSinker::<crate::source::Yuv444p12>::new(w, h)
.with_rgb_u16(&mut rgb)
.unwrap()
.with_color_spec(&spec)
.unwrap();
crate::source::yuv444p12_to(
&src,
full_range,
sink.set_kernel_matrix(spec.kernel_matrix().unwrap()),
)
.unwrap();
}
rgb
}
fn decode_rgba_u16(
y: u16,
dz: u16,
dx: u16,
full_range: bool,
transfer: Transfer,
also_rgb_u16: bool,
) -> std::vec::Vec<u16> {
let (w, h) = (4usize, 2usize);
let n = w * h;
let (yy, u, v) = (
std::vec![le_wire_u16(y); n],
std::vec![le_wire_u16(dz); n],
std::vec![le_wire_u16(dx); n],
);
let src = crate::frame::Yuv444pFrame16::<12>::new(
&yy, &u, &v, w as u32, h as u32, w as u32, w as u32, w as u32,
);
let range = if full_range {
DynamicRange::Full
} else {
DynamicRange::Limited
};
let spec = ColorSpec::from_info(
PixelFormat::Yuv444p12Le,
ColorInfo::new(
Primaries::Bt2020,
transfer,
ColorMatrix::Smpte2085,
range,
ChromaLocation::Left,
),
);
let mut rgba = std::vec![0u16; n * 4];
let mut rgb = std::vec![0u16; n * 3];
if also_rgb_u16 {
let mut sink = MixedSinker::<crate::source::Yuv444p12>::new(w, h)
.with_rgba_u16(&mut rgba)
.unwrap()
.with_rgb_u16(&mut rgb)
.unwrap()
.with_color_spec(&spec)
.unwrap();
crate::source::yuv444p12_to(
&src,
full_range,
sink.set_kernel_matrix(spec.kernel_matrix().unwrap()),
)
.unwrap();
} else {
let mut sink = MixedSinker::<crate::source::Yuv444p12>::new(w, h)
.with_rgba_u16(&mut rgba)
.unwrap()
.with_color_spec(&spec)
.unwrap();
crate::source::yuv444p12_to(
&src,
full_range,
sink.set_kernel_matrix(spec.kernel_matrix().unwrap()),
)
.unwrap();
}
rgba
}
#[test]
fn sink_routes_pq_smpte2085_through_non_affine_decode() {
for &full in &[true, false] {
let want = reference_rgb_u8(2048, 2148, 2248, full);
let rgb = decode_rgb(
2048,
2148,
2248,
full,
ColorMatrix::Smpte2085,
Transfer::SmpteSt2084Pq,
);
for (px, chunk) in rgb.chunks_exact(3).enumerate() {
assert_eq!(
chunk,
&want[..],
"PQ SMPTE 2085 sink RGB px{px} (full={full})"
);
}
}
}
#[test]
fn sink_routes_pq_smpte2085_u16() {
let want = reference_rgb_u16(2048, 2148, 2248, true);
let rgb = decode_rgb_u16(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
Transfer::SmpteSt2084Pq,
);
for (px, chunk) in rgb.chunks_exact(3).enumerate() {
assert!(
chunk.iter().all(|&c| c <= 4095),
"PQ SMPTE 2085 sink u16 px{px} over native 12-bit range: {chunk:?}"
);
assert_eq!(chunk, &want[..], "PQ SMPTE 2085 sink u16 px{px}");
}
}
#[test]
fn smpte2085_without_pq_transfer_falls_back_to_affine() {
let unspecified = decode_rgb(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
Transfer::Unspecified,
);
let pq = decode_rgb(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
Transfer::SmpteSt2084Pq,
);
assert_ne!(
unspecified, pq,
"SMPTE 2085 + Unspecified transfer must fall back to affine (≠ PQ decode)"
);
}
#[test]
fn smpte2085_hlg_transfer_falls_back_to_affine() {
let hlg = decode_rgb(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
Transfer::AribStdB67Hlg,
);
let unspecified = decode_rgb(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
Transfer::Unspecified,
);
let pq = decode_rgb(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
Transfer::SmpteSt2084Pq,
);
assert_eq!(
hlg, unspecified,
"SMPTE 2085 + HLG must fall back to affine"
);
assert_ne!(
hlg, pq,
"SMPTE 2085 + HLG must NOT take the PQ non-affine decode"
);
}
#[test]
fn non_smpte2085_matrix_ignores_transfer() {
let bt709_pq = decode_rgb(
2048,
2148,
2248,
true,
ColorMatrix::Bt709,
Transfer::SmpteSt2084Pq,
);
let bt709_unspec = decode_rgb(
2048,
2148,
2248,
true,
ColorMatrix::Bt709,
Transfer::Unspecified,
);
assert_eq!(
bt709_pq, bt709_unspec,
"non-SMPTE 2085 matrix must not route on transfer"
);
}
#[cfg_attr(miri, ignore)]
#[test]
fn smpte2085_u16_rgba_route_consistent_and_native_depth() {
for &full in &[true, false] {
let only = decode_rgba_u16(2048, 2148, 2248, full, Transfer::SmpteSt2084Pq, false);
let with_rgb = decode_rgba_u16(2048, 2148, 2248, full, Transfer::SmpteSt2084Pq, true);
assert_eq!(
only, with_rgb,
"rgba_u16-only must equal rgb_u16+rgba_u16 (full={full})"
);
for px in only.chunks_exact(4) {
assert!(
px[..3].iter().all(|&c| c <= 4095),
"rgba_u16 RGB over native 12-bit range: {px:?}"
);
assert_eq!(
px[3], 4095,
"native 12-bit opaque alpha must be (1<<12)-1 = 4095, got {}",
px[3]
);
}
}
}
#[derive(Clone, Copy)]
enum HsvCo {
None,
RgbU8,
RgbU16,
}
fn decode_hsv(
y: u16,
dz: u16,
dx: u16,
full_range: bool,
matrix: ColorMatrix,
transfer: Transfer,
co: HsvCo,
) -> (std::vec::Vec<u8>, std::vec::Vec<u8>, std::vec::Vec<u8>) {
let (w, h) = (4usize, 2usize);
let n = w * h;
let (yy, u, v) = (
std::vec![le_wire_u16(y); n],
std::vec![le_wire_u16(dz); n],
std::vec![le_wire_u16(dx); n],
);
let src = crate::frame::Yuv444pFrame16::<12>::new(
&yy, &u, &v, w as u32, h as u32, w as u32, w as u32, w as u32,
);
let range = if full_range {
DynamicRange::Full
} else {
DynamicRange::Limited
};
let spec = ColorSpec::from_info(
PixelFormat::Yuv444p12Le,
ColorInfo::new(
Primaries::Bt2020,
transfer,
matrix,
range,
ChromaLocation::Left,
),
);
let (mut hh, mut ss, mut vv) = (std::vec![0u8; n], std::vec![0u8; n], std::vec![0u8; n]);
let mut rgb = std::vec![0u8; n * 3];
let mut rgb16 = std::vec![0u16; n * 3];
match co {
HsvCo::None => {
let mut sink = MixedSinker::<crate::source::Yuv444p12>::new(w, h)
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_color_spec(&spec)
.unwrap();
crate::source::yuv444p12_to(
&src,
full_range,
sink.set_kernel_matrix(spec.kernel_matrix().unwrap()),
)
.unwrap();
}
HsvCo::RgbU8 => {
let mut sink = MixedSinker::<crate::source::Yuv444p12>::new(w, h)
.with_rgb(&mut rgb)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_color_spec(&spec)
.unwrap();
crate::source::yuv444p12_to(
&src,
full_range,
sink.set_kernel_matrix(spec.kernel_matrix().unwrap()),
)
.unwrap();
}
HsvCo::RgbU16 => {
let mut sink = MixedSinker::<crate::source::Yuv444p12>::new(w, h)
.with_rgb_u16(&mut rgb16)
.unwrap()
.with_hsv(&mut hh, &mut ss, &mut vv)
.unwrap()
.with_color_spec(&spec)
.unwrap();
crate::source::yuv444p12_to(
&src,
full_range,
sink.set_kernel_matrix(spec.kernel_matrix().unwrap()),
)
.unwrap();
}
}
(hh, ss, vv)
}
#[test]
fn smpte2085_hsv_only_uses_non_affine_decode() {
let tf = Transfer::SmpteSt2084Pq;
let only = decode_hsv(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
tf.clone(),
HsvCo::None,
);
let via_rgb = decode_hsv(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
tf.clone(),
HsvCo::RgbU8,
);
let via_rgb16 = decode_hsv(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
tf,
HsvCo::RgbU16,
);
let affine = decode_hsv(
2048,
2148,
2248,
true,
ColorMatrix::Smpte2085,
Transfer::Unspecified,
HsvCo::None,
);
assert_eq!(
only, via_rgb,
"SMPTE 2085 HSV-only must equal the RGB+HSV route"
);
assert_eq!(
only, via_rgb16,
"SMPTE 2085 HSV-only must equal the rgb_u16+HSV route"
);
assert_ne!(
only, affine,
"SMPTE 2085 HSV must differ from the affine-fallback HSV"
);
}
fn resample_rgb(
y: u16,
dz: u16,
dx: u16,
transfer: Transfer,
) -> Result<(), crate::sinker::MixedSinkerError> {
use crate::resample::AreaResampler;
const SRC: usize = 4;
const OUT: usize = 2;
let n = SRC * SRC;
let (yy, u, v) = (
std::vec![le_wire_u16(y); n],
std::vec![le_wire_u16(dz); n],
std::vec![le_wire_u16(dx); n],
);
let src = crate::frame::Yuv444pFrame16::<12>::new(
&yy, &u, &v, SRC as u32, SRC as u32, SRC as u32, SRC as u32, SRC as u32,
);
let spec = ColorSpec::from_info(
PixelFormat::Yuv444p12Le,
ColorInfo::new(
Primaries::Bt2020,
transfer,
ColorMatrix::Smpte2085,
DynamicRange::Full,
ChromaLocation::Left,
),
);
let mut rgb = std::vec![0u8; OUT * OUT * 3];
let mut sink = MixedSinker::<crate::source::Yuv444p12, AreaResampler>::with_resampler(
SRC,
SRC,
AreaResampler::to(OUT, OUT),
)
.unwrap()
.with_rgb(&mut rgb)
.unwrap()
.with_color_spec(&spec)
.unwrap();
crate::source::yuv444p12_to(
&src,
true,
sink.set_kernel_matrix(spec.kernel_matrix().unwrap()),
)
}
#[test]
fn smpte2085_pq_resample_returns_typed_error() {
let err = resample_rgb(2048, 2148, 2248, Transfer::SmpteSt2084Pq)
.expect_err("SMPTE 2085 + PQ + resample must be rejected");
match err {
crate::sinker::MixedSinkerError::UnsupportedMatrixResample(e) => {
assert_eq!(e.matrix(), "Smpte2085", "error names the offending matrix");
}
other => panic!("expected UnsupportedMatrixResample, got {other:?}"),
}
}
#[test]
fn smpte2085_unresolved_resample_is_affine_ok() {
resample_rgb(2048, 2148, 2248, Transfer::Unspecified)
.expect("unresolved SMPTE 2085 (no PQ) must resample affinely, no error");
}