use super::*;
fn le_wire_u16(v: u16) -> u16 {
u16::from_ne_bytes(v.to_le_bytes())
}
const RGB_TO_LMS: [[f32; 3]; 3] = [
[1747.0 / 4096.0, 2169.0 / 4096.0, 180.0 / 4096.0],
[673.0 / 4096.0, 3029.0 / 4096.0, 394.0 / 4096.0],
[50.0 / 4096.0, 207.0 / 4096.0, 3839.0 / 4096.0],
];
const LMSP_TO_IPT: [[f32; 3]; 3] = [
[1638.0 / 4096.0, 1638.0 / 4096.0, 820.0 / 4096.0],
[18248.0 / 4096.0, -19870.0 / 4096.0, 1622.0 / 4096.0],
[3300.0 / 4096.0, 1463.0 / 4096.0, -4763.0 / 4096.0],
];
fn matmul_mm(a: &[[f32; 3]; 3], b: &[[f32; 3]; 3]) -> [[f32; 3]; 3] {
let mut out = [[0.0_f32; 3]; 3];
for (i, row) in out.iter_mut().enumerate() {
for (j, cell) in row.iter_mut().enumerate() {
*cell = (0..3).map(|k| a[i][k] * b[k][j]).sum();
}
}
out
}
fn assert_identity(m: &[[f32; 3]; 3], tol: f32, what: &str) {
for (i, row) in m.iter().enumerate() {
for (j, &cell) in row.iter().enumerate() {
let want = if i == j { 1.0 } else { 0.0 };
assert!(
(cell - want).abs() <= tol,
"{what}: M[{i}][{j}] = {cell} (want {want})"
);
}
}
}
#[test]
fn decode_matrices_are_exact_inverses() {
assert_identity(
&matmul_mm(&RGB_TO_LMS, &IPTC2_LMS_TO_RGB),
1e-4,
"RGB→LMS · LMS→RGB",
);
assert_identity(
&matmul_mm(&LMSP_TO_IPT, &IPTC2_IPT_TO_LMSP),
1e-4,
"L'M'S'→IPT · IPT→L'M'S'",
);
}
#[test]
fn for_transfer_selects_pq_only() {
use crate::Transfer;
assert_eq!(
IptC2Transfer::for_transfer(&Transfer::SmpteSt2084Pq),
Some(IptC2Transfer::Pq)
);
for t in [
Transfer::Unspecified,
Transfer::Bt709,
Transfer::Bt2020_10Bit,
Transfer::AribStdB67Hlg,
Transfer::SmpteSt428,
Transfer::other("unassigned-99"),
] {
assert_eq!(
IptC2Transfer::for_transfer(&t),
None,
"{t:?} must not select the IPT-C2 transfer"
);
}
assert_eq!(IptC2Transfer::Pq.as_str(), "pq");
}
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 equal_lmsp_maps_to_i_only() {
for v in [0.1_f32, 0.3, 0.5, 0.75, 0.9] {
let ipt = matmul3(&LMSP_TO_IPT, [v, v, v]);
assert_close(ipt, [v, 0.0, 0.0], 2e-4, "equal L'M'S' → [I,0,0]");
}
}
#[test]
fn neutral_ipt_decodes_to_neutral_grey() {
for v in [0.1_f32, 0.3, 0.5, 0.75, 0.9] {
let rgb = iptc2_norm_to_rgb_prime([v, 0.0, 0.0]);
assert_close(rgb, [v, v, v], 2e-4, "neutral grey");
}
}
#[test]
fn grey_rgb_encodes_to_zero_chroma() {
for g in [0.1_f32, 0.35, 0.6, 0.85] {
let ipt = encode_ipt_norm([g, g, g]);
assert!(ipt[1].abs() <= 2e-4, "grey P = {} (want 0)", ipt[1]);
assert!(ipt[2].abs() <= 2e-4, "grey T = {} (want 0)", ipt[2]);
}
}
#[test]
fn dequant_matches_h273_convention() {
let n = dequant_iptc2::<12>(2048, 2148, 2248, true);
assert!((n[0] - 2048.0 / 4095.0).abs() <= 1e-6);
assert!((n[1] - 100.0 / 4095.0).abs() <= 1e-6);
assert!((n[2] - 200.0 / 4095.0).abs() <= 1e-6);
let n = dequant_iptc2::<12>(1800, 2048, 2148, false);
assert!((n[0] - (1800.0 - 256.0) / (219.0 * 16.0)).abs() <= 1e-6);
assert!((n[1] - 0.0).abs() <= 1e-6);
assert!((n[2] - (2148.0 - 2048.0) / (224.0 * 16.0)).abs() <= 1e-6);
}
fn encode_ipt_norm(rgb_prime: [f32; 3]) -> [f32; 3] {
let lin = [
crate::hdr::pq_eotf(rgb_prime[0]),
crate::hdr::pq_eotf(rgb_prime[1]),
crate::hdr::pq_eotf(rgb_prime[2]),
];
let lms = matmul3(&RGB_TO_LMS, lin);
let lms_p = [
crate::hdr::pq_inverse_eotf(lms[0]),
crate::hdr::pq_inverse_eotf(lms[1]),
crate::hdr::pq_inverse_eotf(lms[2]),
];
matmul3(&LMSP_TO_IPT, lms_p)
}
fn encode_wire<const BITS: u32>(rgb_prime: [f32; 3], full_range: bool) -> [u16; 3] {
let ipt = encode_ipt_norm(rgb_prime);
let k: i32 = 1 << (BITS - 8);
let chroma_bias = (128 * k) as f32;
let (y_off, y_range, c_range): (f32, f32, f32) = if full_range {
let in_max = ((1u32 << BITS) - 1) as f32;
(0.0, in_max, in_max)
} else {
((16 * k) as f32, (219 * k) as f32, (224 * k) as f32)
};
let max = ((1u32 << BITS) - 1) as i32;
let q = |val: f32| -> u16 { (val.round() as i32).clamp(0, max) as u16 };
[
q(ipt[0] * y_range + y_off),
q(ipt[1] * c_range + chroma_bias),
q(ipt[2] * c_range + chroma_bias),
]
}
#[cfg_attr(miri, ignore)]
#[test]
fn iptc2_roundtrip_recovers_rgb_prime() {
let cases: &[([f32; 3], bool)] = &[
([0.5, 0.4, 0.45], true),
([0.6, 0.2, 0.3], true),
([0.3, 0.35, 0.5], false),
([0.7, 0.6, 0.55], false),
];
for &(rgb_prime, full) in cases {
let [i, p, t] = encode_wire::<12>(rgb_prime, full);
let dec = iptc2_norm_to_rgb_prime(dequant_iptc2::<12>(i, p, t, full));
assert_close(dec, rgb_prime, 1e-3, "IPT-C2 R'G'B' round-trip");
}
}
#[cfg_attr(miri, ignore)]
#[test]
fn iptc2_444p12_to_rgb_u8_roundtrip() {
let cases: &[([f32; 3], bool)] = &[
([0.5, 0.4, 0.45], true),
([0.6, 0.2, 0.3], true),
([0.3, 0.35, 0.5], false),
([0.7, 0.6, 0.55], false),
];
for &(rgb_prime, full) in cases {
let [i, p, t] = encode_wire::<12>(rgb_prime, full);
let want = [
narrow_unit_to_u8(rgb_prime[0]),
narrow_unit_to_u8(rgb_prime[1]),
narrow_unit_to_u8(rgb_prime[2]),
];
let (y, u, v) = (
[le_wire_u16(i); 2],
[le_wire_u16(p); 2],
[le_wire_u16(t); 2],
);
let mut out = [0_u8; 6];
iptc2_444p_n_to_rgb_row::<12, false>(&y, &u, &v, &mut out, 2, full);
for px in 0..2 {
for c in 0..3 {
let g = out[px * 3 + c] as i32;
assert!(
(g - want[c] as i32).abs() <= 1,
"{rgb_prime:?} full={full}: px{px} ch{c} = {g} (want {})",
want[c]
);
}
}
}
}
#[cfg_attr(miri, ignore)]
#[test]
fn iptc2_444p12_to_rgb_u16_roundtrip() {
let cases: &[([f32; 3], bool)] = &[
([0.5, 0.4, 0.45], true),
([0.6, 0.2, 0.3], true),
([0.3, 0.35, 0.5], false),
([0.7, 0.6, 0.55], false),
];
for &(rgb_prime, full) in cases {
let [i, p, t] = encode_wire::<12>(rgb_prime, full);
let want = [
narrow_unit_to_u16_native::<12>(rgb_prime[0]),
narrow_unit_to_u16_native::<12>(rgb_prime[1]),
narrow_unit_to_u16_native::<12>(rgb_prime[2]),
];
let (y, u, v) = ([le_wire_u16(i)], [le_wire_u16(p)], [le_wire_u16(t)]);
let mut out = [0_u16; 3];
iptc2_444p_n_to_rgb_u16_row::<12, false>(&y, &u, &v, &mut out, 1, full);
for c in 0..3 {
let g = out[c] as i32;
assert!(
g <= 4095,
"{rgb_prime:?}: ch{c} = {g} over native 12-bit range"
);
assert!(
(g - want[c] as i32).abs() <= 2,
"{rgb_prime:?} full={full}: ch{c} = {g} (want {})",
want[c]
);
}
}
}
#[cfg_attr(miri, ignore)]
#[test]
fn rgba_kernels_match_rgb_plus_opaque_alpha() {
let (y, u, v) = ([2048_u16], [2148_u16], [2248_u16]);
let mut rgb = [0_u8; 3];
let mut rgba = [0_u8; 4];
iptc2_444p_n_to_rgb_row::<12, false>(&y, &u, &v, &mut rgb, 1, true);
iptc2_444p_n_to_rgba_row::<12, false>(&y, &u, &v, &mut rgba, 1, true);
assert_eq!(&rgba[..3], &rgb[..]);
assert_eq!(rgba[3], 0xFF);
let mut rgb16 = [0_u16; 3];
let mut rgba16 = [0_u16; 4];
iptc2_444p_n_to_rgb_u16_row::<12, false>(&y, &u, &v, &mut rgb16, 1, true);
iptc2_444p_n_to_rgba_u16_row::<12, false>(&y, &u, &v, &mut rgba16, 1, true);
assert_eq!(&rgba16[..3], &rgb16[..]);
assert_eq!(
rgba16[3], 4095,
"native 12-bit opaque alpha = (1 << BITS) - 1"
);
assert!(
rgb16.iter().all(|&c| c <= 4095),
"u16 RGB must be native 12-bit [0, 4095], got {rgb16:?}"
);
}
#[test]
fn big_endian_matches_swapped_little_endian() {
let le = ([2048_u16], [2148_u16], [2248_u16]);
let be = (
[2048_u16.swap_bytes()],
[2148_u16.swap_bytes()],
[2248_u16.swap_bytes()],
);
let mut out_le = [0_u8; 3];
let mut out_be = [0_u8; 3];
iptc2_444p_n_to_rgb_row::<12, false>(&le.0, &le.1, &le.2, &mut out_le, 1, true);
iptc2_444p_n_to_rgb_row::<12, true>(&be.0, &be.1, &be.2, &mut out_be, 1, true);
assert_eq!(out_le, out_be);
}