use super::*;
use crate::resample::bt2020_oetf;
fn le_wire_u16(v: u16) -> u16 {
u16::from_ne_bytes(v.to_le_bytes())
}
const LIN_TOL: f32 = 5e-6;
fn decode_linear<const BITS: u32>(
yc: u16,
cbc: u16,
crc: u16,
full_range: bool,
system: ClSystem,
) -> [f32; 3] {
cl_norm_to_rgb_linear(dequant_cl::<BITS>(yc, cbc, crc, full_range), system)
}
fn assert_close(got: [f32; 3], want: [f32; 3], tol: f32, what: &str) {
for i in 0..3 {
assert!(
(got[i] - want[i]).abs() <= tol,
"{what}: channel {i} = {} (want {}, |Δ| = {})",
got[i],
want[i],
(got[i] - want[i]).abs()
);
}
}
#[test]
fn decode_matches_colour_science_12bit_studio_midcode() {
let system = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_12Bit).unwrap();
let got = decode_linear::<12>(2048, 2148, 1948, false, system);
assert_close(
got,
[0.225_844, 0.284_305, 0.316_264],
LIN_TOL,
"12-bit studio mid-code",
);
}
#[test]
fn decode_matches_colour_science_12bit_studio_saturated() {
let system = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_12Bit).unwrap();
let got = decode_linear::<12>(3000, 2600, 1500, false, system);
assert_close(
got,
[0.279_735, 0.704_389, 1.054_776],
LIN_TOL,
"12-bit studio saturated",
);
}
#[test]
fn decode_matches_colour_science_10bit_studio_midcode() {
let system = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_10Bit).unwrap();
assert!(!system.is_12_bit(), "Bt2020_10Bit must select 10-bit OETF");
let got = decode_linear::<10>(512, 540, 480, false, system);
assert_close(
got,
[0.213_916, 0.288_245, 0.321_845],
LIN_TOL,
"10-bit studio mid-code",
);
}
#[test]
fn gray_axis_is_neutral_full_range() {
let system = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_12Bit).unwrap();
for yc in [0u16, 1024, 2048, 3072, 4095] {
let [r, g, b] = decode_linear::<12>(yc, 2048, 2048, true, system);
assert!(
(r - g).abs() <= 1e-6 && (g - b).abs() <= 1e-6,
"gray axis Yc={yc}: linear ({r}, {g}, {b}) not neutral"
);
}
}
#[test]
fn gray_axis_full_range_round_trips_to_native_code() {
let system = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_12Bit).unwrap();
let lin = decode_linear::<12>(3760, 2048, 2048, true, system);
assert_close(
lin,
[0.842_107, 0.842_107, 0.842_107],
LIN_TOL,
"gray linear",
);
let mut out = [0u16; 3];
cl_444p_n_to_rgb_u16_row::<12, false>(
&[le_wire_u16(3760)],
&[le_wire_u16(2048)],
&[le_wire_u16(2048)],
&mut out,
1,
true,
system,
);
assert_eq!(
out,
[3760, 3760, 3760],
"neutral Y'c must round-trip its code"
);
}
#[cfg_attr(miri, ignore)]
#[test]
fn bt2020_oetf_round_trips() {
for &e in &[0.0_f32, 0.005, 0.018, 0.0181, 0.25, 0.5, 0.9, 1.0] {
let back = bt2020_oetf::oetf_inverse(bt2020_oetf::oetf(e, false), false);
assert!(
(back - e).abs() <= 5e-7,
"10-bit oetf round-trip e={e}: got {back} (|Δ|={})",
(back - e).abs()
);
}
for &e in &[0.0_f32, 0.005, 0.018, 0.25, 0.5, 0.9, 1.0] {
let back = bt2020_oetf::oetf_inverse(bt2020_oetf::oetf(e, true), true);
assert!(
(back - e).abs() <= 5e-7,
"12-bit oetf round-trip e={e}: got {back} (|Δ|={})",
(back - e).abs()
);
}
}
#[cfg_attr(miri, ignore)]
#[test]
fn bt2020_inverse_oetf_12bit_four_interval_partition() {
let inv = |ep: f32| bt2020_oetf::oetf_inverse(ep, true);
let toe = |ep: f32| ep / 4.5;
let power = |ep: f32| ((ep + (1.0993_f32 - 1.0)) / 1.0993_f32).powf(1.0 / 0.45);
let e1 = 0.045_f32;
assert!(
(inv(e1) - 0.01).abs() <= 2e-7,
"I1 toe-exact: {} ≠ 0.01",
inv(e1)
);
assert!(
(inv(e1) - toe(e1)).abs() <= 2e-7,
"I1 must be the toe branch"
);
assert!(
(bt2020_oetf::oetf_inverse(bt2020_oetf::oetf(0.01, true), true) - 0.01).abs() <= 2e-7,
"I1 round-trips: oetf_inverse(oetf(0.01)) = 0.01"
);
let e2 = bt2020_oetf::oetf(0.0181, true); assert!(
(e2 - 0.081_447_18).abs() <= 1e-6,
"oetf(β12) ≈ 0.08144718, got {e2}"
);
assert!(
(inv(e2) - 0.018_099_38).abs() <= 2e-7,
"I2: colour toe ≈ 0.01809938, got {}",
inv(e2)
);
assert!(
(inv(e2) - toe(e2)).abs() <= 2e-7,
"I2 must be the toe branch"
);
assert!(
(inv(e2) - 0.0181).abs() > 5e-7,
"I2 lower endpoint β12 must NOT round-trip — it is the inclusive divergence start"
);
let e3_lo = 4.5 * 0.0181_f32; assert!(
e3_lo > e2,
"4.5·β12 must be above oetf(β12) (the overlap→quirk boundary)"
);
assert!(
(inv(e3_lo) - 0.0181).abs() <= 2e-7,
"I3 lower (4.5·β12): colour toe = 0.0181, got {}",
inv(e3_lo)
);
assert!(
(inv(e3_lo) - toe(e3_lo)).abs() <= 2e-7,
"I3 lower must be the toe branch"
);
assert!(
(inv(e3_lo) - power(e3_lo)).abs() > 5e-7,
"I3 lower must NOT be the power preimage {} (the standard round-trip is intentionally not taken)",
power(e3_lo)
);
let e3_mid = 0.081_573_95_f32; assert!(
e3_mid > e3_lo && e3_mid < 0.081_697_9,
"mid point must be inside the quirk band"
);
assert!(
(inv(e3_mid) - 0.018_127_54).abs() <= 3e-7,
"I3 mid: colour toe ≈ 0.01812754, got {}",
inv(e3_mid)
);
assert!(
(inv(e3_mid) - power(e3_mid)).abs() > 5e-7,
"I3 mid must NOT be the power preimage — the divergence is the deliberate colour-compat choice"
);
let t = 0.081_697_9_f32; assert!(
(inv(t) - 0.018_155_84).abs() <= 1e-6,
"I4 at T: colour power ≈ 0.01815584, got {}",
inv(t)
);
assert!(
(inv(t) - power(t)).abs() < (inv(t) - toe(t)).abs(),
"I4 at T must take the power branch, not the toe"
);
let e4 = 0.091_697_89_f32; assert!(
(inv(e4) - 0.020_460_51).abs() <= 2e-7,
"I4 power-exact ≈ 0.02046051, got {}",
inv(e4)
);
let rt = bt2020_oetf::oetf(inv(e4), true);
assert!(
(rt - e4).abs() <= 2e-6,
"I4 round-trips: oetf(inv(E')) ≈ E', got {rt}"
);
}
#[cfg_attr(miri, ignore)]
#[test]
fn bt2020_inverse_oetf_10bit_two_interval_partition() {
let inv = |ep: f32| bt2020_oetf::oetf_inverse(ep, false);
let back = bt2020_oetf::oetf_inverse(bt2020_oetf::oetf(0.018, false), false);
assert!(
(back - 0.018).abs() <= 2e-7,
"10-bit β10 must round-trip, got {back}"
);
assert!((inv(0.045) - 0.01).abs() <= 2e-7, "10-bit toe-exact");
for &ep in &[0.0810_f32, 0.0811, 0.081_2, 0.081_24] {
assert!(
(inv(ep) - ep / 4.5).abs() <= 1e-7,
"10-bit gap E'={ep}: must take the toe inverse E'/4.5 (breakpoint is oetf(β10), not 4.5·β10)"
);
}
let e = 0.3_f32;
let rt = bt2020_oetf::oetf_inverse(bt2020_oetf::oetf(e, false), false);
assert!(
(rt - e).abs() <= 2e-7,
"10-bit power-exact round-trip, got {rt}"
);
}
#[test]
fn bt2020_oetf_matches_colour_science_anchors() {
assert!((bt2020_oetf::oetf(0.0, false) - 0.0).abs() <= 1e-7);
assert!((bt2020_oetf::oetf(0.001, false) - 0.004_5).abs() <= 1e-6); assert!((bt2020_oetf::oetf(0.018, false) - 0.081_247_94).abs() <= 1e-6);
assert!((bt2020_oetf::oetf(0.5, false) - 0.705_515_1).abs() <= 1e-5);
assert!((bt2020_oetf::oetf(1.0, false) - 1.0).abs() <= 1e-6);
assert!((bt2020_oetf::oetf(0.0181, true) - 0.081_447_2).abs() <= 1e-6);
assert!((bt2020_oetf::oetf(0.5, true) - 0.705_434_7).abs() <= 1e-5);
assert!((bt2020_oetf::oetf(1.0, true) - 1.0).abs() <= 1e-6);
}
#[cfg_attr(miri, ignore)]
#[test]
fn bt2020_oetf_is_odd_extended() {
for &is12 in &[false, true] {
for &e in &[0.005_f32, 0.1, 0.7, 1.2] {
assert!((bt2020_oetf::oetf(-e, is12) + bt2020_oetf::oetf(e, is12)).abs() <= 1e-6);
assert!(
(bt2020_oetf::oetf_inverse(-e, is12) + bt2020_oetf::oetf_inverse(e, is12)).abs() <= 1e-6
);
}
}
}
#[test]
fn published_weights_match_chromaticity_derivation() {
let (kr, kg, kb) = crate::row::scalar::chroma_derived_luma_weights(&Primaries::Bt2020)
.expect("Bt2020 carries chromaticities");
assert!((kr as f32 - KR).abs() <= 5e-4, "Kr {kr} vs {KR}");
assert!((kg as f32 - KG).abs() <= 5e-4, "Kg {kg} vs {KG}");
assert!((kb as f32 - KB).abs() <= 5e-4, "Kb {kb} vs {KB}");
assert!(
((kr + kg + kb) - 1.0).abs() <= 1e-9,
"weights must sum to 1"
);
}
#[test]
fn chroma_normalisers_derive_from_the_oetf() {
let pb = 1.0 - bt2020_oetf::oetf(KB, false);
let nb = -bt2020_oetf::oetf(1.0 - KB, false);
let pr = 1.0 - bt2020_oetf::oetf(KR, false);
let nr = -bt2020_oetf::oetf(1.0 - KR, false);
assert!(
(-2.0 * nb - NEG_2NB).abs() <= 1e-3,
"-2Nb {} vs {NEG_2NB}",
-2.0 * nb
);
assert!(
(2.0 * pb - POS_2PB).abs() <= 1e-3,
"2Pb {} vs {POS_2PB}",
2.0 * pb
);
assert!(
(-2.0 * nr - NEG_2NR).abs() <= 1e-3,
"-2Nr {} vs {NEG_2NR}",
-2.0 * nr
);
assert!(
(2.0 * pr - POS_2PR).abs() <= 1e-3,
"2Pr {} vs {POS_2PR}",
2.0 * pr
);
}
#[test]
fn cl_system_resolves_bt2020_only() {
assert_eq!(
ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_10Bit).map(|s| s.is_12_bit()),
Some(false)
);
assert_eq!(
ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_12Bit).map(|s| s.is_12_bit()),
Some(true)
);
assert!(ClSystem::resolve(&Primaries::Bt2020, &Transfer::Unspecified).is_none());
assert!(ClSystem::resolve(&Primaries::Bt2020, &Transfer::SmpteSt2084Pq).is_none());
assert!(ClSystem::resolve(&Primaries::Bt2020, &Transfer::AribStdB67Hlg).is_none());
assert!(ClSystem::resolve(&Primaries::Bt709, &Transfer::Bt2020_10Bit).is_none());
assert!(ClSystem::resolve(&Primaries::Unspecified, &Transfer::Bt2020_12Bit).is_none());
let s10 = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_10Bit).unwrap();
let s12 = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_12Bit).unwrap();
assert_eq!(s10.as_str(), "bt2020-cl-10");
assert_eq!(s12.as_str(), "bt2020-cl-12");
}
#[test]
fn kernels_narrow_and_alpha_are_consistent() {
let system = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_12Bit).unwrap();
let (y, u, v) = (
[le_wire_u16(2048)],
[le_wire_u16(2148)],
[le_wire_u16(1948)],
);
let mut rgb_u8 = [0u8; 3];
let mut rgba_u8 = [0u8; 4];
cl_444p_n_to_rgb_row::<12, false>(&y, &u, &v, &mut rgb_u8, 1, false, system);
cl_444p_n_to_rgba_row::<12, false>(&y, &u, &v, &mut rgba_u8, 1, false, system);
assert_eq!(&rgba_u8[..3], &rgb_u8[..], "u8 RGB vs RGBA colour channels");
assert_eq!(rgba_u8[3], 0xFF, "u8 opaque alpha");
assert_eq!(
rgb_u8,
[118, 134, 142],
"u8 R'G'B' narrow (colour-science pinned)"
);
let mut rgb_u16 = [0u16; 3];
let mut rgba_u16 = [0u16; 4];
cl_444p_n_to_rgb_u16_row::<12, false>(&y, &u, &v, &mut rgb_u16, 1, false, system);
cl_444p_n_to_rgba_u16_row::<12, false>(&y, &u, &v, &mut rgba_u16, 1, false, system);
assert_eq!(
&rgba_u16[..3],
&rgb_u16[..],
"u16 RGB vs RGBA colour channels"
);
assert_eq!(rgba_u16[3], 4095, "u16 native-depth opaque alpha");
assert_eq!(
rgb_u16,
[1898, 2149, 2275],
"u16 native R'G'B' narrow (colour-science pinned)"
);
}
#[test]
fn toe_region_10bit_matches_colour_science_reference() {
let system = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_10Bit).unwrap();
assert!(!system.is_12_bit());
let mut rgb_u16 = [0u16; 3];
cl_444p_n_to_rgb_u16_row::<10, false>(
&[le_wire_u16(135)],
&[le_wire_u16(500)],
&[le_wire_u16(520)],
&mut rgb_u16,
1,
false,
system,
);
assert_eq!(
rgb_u16,
[92, 82, 56],
"10-bit toe-region decode (colour-science pinned; pre-fix green was 81)"
);
}
#[test]
fn big_endian_matches_swapped_little_endian() {
let system = ClSystem::resolve(&Primaries::Bt2020, &Transfer::Bt2020_12Bit).unwrap();
let (y, u, v) = (2048u16, 2148u16, 1948u16);
let mut le = [0u16; 3];
let mut be = [0u16; 3];
cl_444p_n_to_rgb_u16_row::<12, false>(&[y], &[u], &[v], &mut le, 1, false, system);
cl_444p_n_to_rgb_u16_row::<12, true>(
&[y.swap_bytes()],
&[u.swap_bytes()],
&[v.swap_bytes()],
&mut be,
1,
false,
system,
);
assert_eq!(le, be, "BE load must match swapped LE");
}