use super::{
HLG_NOMINAL_PEAK_NITS, HdrTransfer, KNEE_START, MapError, PQ_PEAK_NITS, REFERENCE_WHITE_NITS,
SdrMapping, expf32, hlg_inverse_oetf, hlg_oetf, hlg_ootf, hlg_system_gamma, mapping::knee,
powf32, pq_eotf, pq_inverse_eotf,
};
use crate::{Primaries, Transfer};
const BT2020_LUMINANCE: [f32; 3] = [0.2627, 0.6780, 0.0593];
const STATED_KNEE: f32 = 0.75;
fn stated_knee(light: f32) -> f32 {
if light <= STATED_KNEE {
light
} else {
let room = 1.0 - STATED_KNEE;
STATED_KNEE + room * (1.0 - expf32(-(light - STATED_KNEE) / room))
}
}
fn code(signal: f32) -> u8 {
(signal * 255.0 + 0.5) as u8
}
const HDR: [Transfer; 2] = [Transfer::SmpteSt2084Pq, Transfer::AribStdB67Hlg];
const MIRI_RELATIVE: f32 = 1e-2;
fn miri_slack(a: f32, b: f32) -> f32 {
if cfg!(miri) {
MIRI_RELATIVE * a.abs().max(b.abs())
} else {
0.0
}
}
fn near(a: f32, b: f32, native: f32) -> bool {
(a - b).abs() <= native.max(miri_slack(a, b))
}
fn below(a: f32, b: f32) -> bool {
a < b + miri_slack(a, b)
}
fn at_most(a: f32, b: f32) -> bool {
a <= b + miri_slack(a, b)
}
fn same_codes(a: [u8; 3], b: [u8; 3]) -> bool {
let codes = if cfg!(miri) {
1 + (MIRI_RELATIVE * 255.0) as u8
} else {
0
};
a.iter().zip(b).all(|(x, y)| x.abs_diff(y) <= codes)
}
#[test]
fn pq_matches_st2084_reference() {
assert!(near(pq_eotf(1.0), 1.0, 1e-6), "eotf(1.0)={}", pq_eotf(1.0));
assert!(near(pq_eotf(0.0), 0.0, 1e-9), "eotf(0.0)={}", pq_eotf(0.0));
assert!(
near(pq_inverse_eotf(1.0), 1.0, 1e-5),
"oetf(1.0)={}",
pq_inverse_eotf(1.0)
);
const SIGNAL_100_NITS: f32 = 0.508_078_4;
assert!(
near(pq_inverse_eotf(0.01), SIGNAL_100_NITS, 5e-4),
"oetf(0.01)={} want {SIGNAL_100_NITS}",
pq_inverse_eotf(0.01),
);
assert!(
near(pq_eotf(SIGNAL_100_NITS), 0.01, 1e-4),
"eotf({SIGNAL_100_NITS})={} want 0.01",
pq_eotf(SIGNAL_100_NITS),
);
assert!(
near(pq_inverse_eotf(0.0), 0.0, 1e-5),
"oetf(0.0)={}",
pq_inverse_eotf(0.0)
);
}
#[test]
fn a_super_white_saturates_at_the_peak() {
for &c in &[1.0_f32, 1.5, 1.99, 2.0, 10.0] {
let y = pq_eotf(c);
assert!(y.is_finite(), "pq_eotf({c})={y} must be finite");
assert!(
near(y, 1.0, 1e-6),
"pq_eotf({c})={y} must saturate at 1.0 (not inf/black)"
);
}
assert!(
near(pq_eotf(-2.0), -1.0, 1e-6),
"pq_eotf(-2.0)={}",
pq_eotf(-2.0)
);
let hlg_peak = hlg_inverse_oetf(1.0);
for &c in &[1.0_f32, 2.0, 10.0] {
let e = hlg_inverse_oetf(c);
assert!(
e.is_finite() && near(e, hlg_peak, 1e-6),
"hlg_inverse_oetf({c})={e} must saturate at hlg_inverse_oetf(1.0)={hlg_peak}"
);
}
}
#[test]
fn hlg_matches_bt2100_reference() {
assert!(
near(hlg_oetf(1.0 / 12.0), 0.5, 1e-6),
"oetf(1/12)={}",
hlg_oetf(1.0 / 12.0),
);
assert!(
near(hlg_inverse_oetf(0.5), 1.0 / 12.0, 1e-6),
"eotf(0.5)={}",
hlg_inverse_oetf(0.5),
);
assert!(
near(hlg_oetf(0.015), 0.212_132, 1e-5),
"oetf(0.015)={}",
hlg_oetf(0.015),
);
assert!(
near(hlg_inverse_oetf(0.212_132), 0.015, 1e-5),
"eotf(0.2121320)={}",
hlg_inverse_oetf(0.212_132),
);
assert!(
near(hlg_oetf(1.0), 1.0, 1e-4),
"oetf(1.0)={}",
hlg_oetf(1.0)
);
assert!(
near(hlg_inverse_oetf(1.0), 1.0, 1e-4),
"eotf(1.0)={}",
hlg_inverse_oetf(1.0)
);
assert!(
near(hlg_oetf(0.0), 0.0, 1e-9),
"oetf(0.0)={}",
hlg_oetf(0.0)
);
assert!(
near(hlg_inverse_oetf(0.0), 0.0, 1e-9),
"eotf(0.0)={}",
hlg_inverse_oetf(0.0)
);
}
#[test]
fn each_curve_inverts_its_pair() {
for i in 0..=256 {
let c = i as f32 / 256.0;
let pq = pq_inverse_eotf(pq_eotf(c));
assert!(near(pq, c, 2e-3), "pq oetf(eotf({c}))={pq}");
let pq2 = pq_eotf(pq_inverse_eotf(c));
assert!(near(pq2, c, 2e-3), "pq eotf(oetf({c}))={pq2}");
let hlg = hlg_oetf(hlg_inverse_oetf(c));
assert!(near(hlg, c, 1e-3), "hlg oetf(eotf({c}))={hlg}");
let hlg2 = hlg_inverse_oetf(hlg_oetf(c));
assert!(near(hlg2, c, 1e-3), "hlg eotf(oetf({c}))={hlg2}");
}
}
#[test]
fn each_curve_is_odd() {
for &c in &[0.05_f32, 0.25, 0.6, 0.9] {
assert!(near(pq_eotf(-c), -pq_eotf(c), 1e-6), "pq eotf odd at {c}");
assert!(
near(pq_inverse_eotf(-c), -pq_inverse_eotf(c), 1e-6),
"pq oetf odd at {c}"
);
assert!(
near(hlg_inverse_oetf(-c), -hlg_inverse_oetf(c), 1e-6),
"hlg eotf odd at {c}"
);
assert!(
near(hlg_oetf(-c), -hlg_oetf(c), 1e-6),
"hlg oetf odd at {c}"
);
}
}
#[test]
fn the_hdr_curves_differ_from_sdr() {
let c = 0.5_f32;
let bt1886 = crate::resample::TransferFunction::Bt1886.eotf(c);
let pq = pq_eotf(c);
let hlg = hlg_inverse_oetf(c);
assert!(
below(1e-3, (pq - bt1886).abs()),
"PQ vs BT.1886 must differ"
);
assert!(
below(1e-3, (hlg - bt1886).abs()),
"HLG vs BT.1886 must differ"
);
assert!(below(1e-3, (pq - hlg).abs()), "PQ vs HLG must differ");
}
#[test]
fn pq_places_reference_white_at_58_percent() {
let white = pq_inverse_eotf(REFERENCE_WHITE_NITS / PQ_PEAK_NITS);
assert!(near(white, 0.5806, 1e-3), "PQ(203 cd/m²) = {white}");
let thousand = pq_inverse_eotf(1000.0 / PQ_PEAK_NITS);
assert!(near(thousand, 0.7518, 1e-3), "PQ(1000 cd/m²) = {thousand}");
}
#[test]
fn hlg_places_reference_white_at_75_percent() {
let white = hlg_ootf(
[hlg_inverse_oetf(0.75); 3],
BT2020_LUMINANCE,
HLG_NOMINAL_PEAK_NITS,
);
assert!(near(white[1], 203.0, 1.0), "HLG 75% = {} cd/m²", white[1]);
let grey = hlg_ootf(
[hlg_inverse_oetf(0.38); 3],
BT2020_LUMINANCE,
HLG_NOMINAL_PEAK_NITS,
);
assert!(near(grey[1], 26.0, 0.5), "HLG 38% = {} cd/m²", grey[1]);
assert_eq!(
hlg_ootf([0.0; 3], BT2020_LUMINANCE, HLG_NOMINAL_PEAK_NITS),
[0.0; 3],
"black is black on any display"
);
}
#[test]
fn the_hlg_system_gamma_is_bt2100s() {
assert!(near(hlg_system_gamma(1000.0), 1.2, 0.0));
assert!(near(hlg_system_gamma(2000.0), 1.326_433, 1e-5));
assert!(near(hlg_system_gamma(400.0), 1.032_867, 1e-5));
}
#[test]
fn the_gamut_matrix_from_bt2020_is_bt2087s() {
const BT2087: [[f32; 3]; 3] = [
[1.6605, -0.5876, -0.0728],
[-0.1246, 1.1329, -0.0083],
[-0.0182, -0.1006, 1.1187],
];
let mapping = SdrMapping::for_picture(&Transfer::SmpteSt2084Pq, &Primaries::Bt2020)
.expect("BT.2020 converts");
let hdr = mapping.hdr.as_ref().expect("PQ maps");
for (row, (got, want)) in hdr.to_bt709.iter().zip(BT2087).enumerate() {
for column in 0..3 {
assert!(
near(got[column], want[column], 2e-4),
"[{row}][{column}] = {} want {}",
got[column],
want[column],
);
}
}
for (got, want) in hdr.luminance.iter().zip(BT2020_LUMINANCE) {
assert!(near(*got, want, 1e-4), "luminance {got} want {want}");
}
}
#[test]
fn the_knee_starts_where_stated() {
for step in 0..=75 {
let light = step as f32 / 100.0;
assert_eq!(
knee(light),
light,
"below the knee, {light} passes unchanged"
);
}
let slope = (knee(STATED_KNEE + 1e-3) - knee(STATED_KNEE)) / 1e-3;
assert!(near(slope, 1.0, 1e-2), "slope at the knee {slope}");
let mut previous = knee(STATED_KNEE);
for step in 1..=400 {
let light = STATED_KNEE + step as f32 / 50.0;
let rolled = knee(light);
if light <= 2.0 {
assert!(below(previous, rolled), "rising at {light}: {rolled}");
} else {
assert!(
at_most(previous, rolled),
"never falling at {light}: {rolled}"
);
}
assert!(
below(rolled, light) && at_most(rolled, 1.0),
"compressed at {light}: {rolled}"
);
previous = rolled;
}
assert!(
below(knee(2.0), 1.0),
"two whites still below white: {}",
knee(2.0)
);
}
#[test]
fn a_pq_and_an_hlg_ramp_map_into_sdr_with_the_stated_knee() {
for transfer in HDR {
let mapping = SdrMapping::for_picture(&transfer, &Primaries::Bt2020).expect("BT.2020 converts");
let mut previous = 0.0f32;
for step in 0..=1023 {
let signal = step as f32 / 1023.0;
let out = mapping.map_signal([signal; 3]);
for channel in out {
assert!(
(0.0..=1.0).contains(&channel),
"{transfer:?} {signal}: {out:?}"
);
assert!(near(channel, out[1], 1e-5), "grey stays grey: {out:?}");
}
assert!(
at_most(previous, out[1] + 1e-6),
"{transfer:?} rising at {signal}"
);
previous = out[1];
let light = match transfer {
Transfer::SmpteSt2084Pq => pq_eotf(signal) * 10_000.0 / 203.0,
_ => 1000.0 * powf32(hlg_inverse_oetf(signal), 1.2) / 203.0,
};
let shown = powf32(out[1], 2.4);
let want = stated_knee(light);
assert!(
near(shown, want, 2e-4 + 2e-4 * want),
"{transfer:?} {signal}: shown {shown} want {want} from light {light}",
);
if light > STATED_KNEE {
assert!(
below(shown, light),
"above the knee the light is compressed: {shown} from {light}"
);
}
}
}
}
#[test]
fn reference_white_and_grey_land_where_stated() {
let pq = SdrMapping::for_picture(&Transfer::SmpteSt2084Pq, &Primaries::Bt2020).expect("PQ");
let hlg = SdrMapping::for_picture(&Transfer::AribStdB67Hlg, &Primaries::Bt2020).expect("HLG");
let white = pq.map_signal([pq_inverse_eotf(203.0 / 10_000.0); 3])[1];
assert!(near(white, 0.9606, 1e-3), "PQ reference white {white}");
let white = hlg.map_signal([0.75; 3])[1];
assert!(near(white, 0.9606, 2e-3), "HLG reference white {white}");
let grey = pq.map_signal([pq_inverse_eotf(26.0 / 10_000.0); 3])[1];
assert!(near(grey, 0.4247, 1e-3), "PQ 18% grey {grey}");
let grey = hlg.map_signal([0.38; 3])[1];
assert!(near(grey, 0.4264, 2e-3), "HLG 18% grey {grey}");
}
#[test]
fn the_declared_gamut_is_converted_to_bt709() {
for transfer in HDR {
let wide = SdrMapping::for_picture(&transfer, &Primaries::Bt2020).expect("BT.2020");
let narrow = SdrMapping::for_picture(&transfer, &Primaries::Bt709).expect("BT.709");
let green = [0.3, 0.6, 0.3];
let (from_wide, from_narrow) = (wide.map_signal(green), narrow.map_signal(green));
assert!(
below(from_wide[0] + 0.05, from_narrow[0]),
"{transfer:?}: BT.2020 green loses red in BT.709 ({from_wide:?} vs {from_narrow:?})",
);
let grey = [0.5; 3];
let (a, b) = (wide.map_signal(grey), narrow.map_signal(grey));
for channel in 0..3 {
assert!(near(a[channel], b[channel], 1e-5), "grey: {a:?} vs {b:?}");
}
let unstated =
SdrMapping::for_picture(&transfer, &Primaries::Unspecified).expect("unspecified");
if cfg!(miri) {
assert_eq!(unstated.transfer(), wide.transfer());
let (a, b) = (
unstated.hdr.as_ref().expect("maps"),
wide.hdr.as_ref().expect("maps"),
);
for (x, y) in a.to_bt709.iter().flatten().zip(b.to_bt709.iter().flatten()) {
assert!(
near(*x, *y, 0.0),
"an unspecified gamut is BT.2020: {x} vs {y}"
);
}
for (x, y) in a.luminance.iter().zip(&b.luminance) {
assert!(near(*x, *y, 0.0), "and so is its luminance: {x} vs {y}");
}
for probe in [[0.1, 0.4, 0.9], [0.5; 3], [0.75, 0.2, 0.3], [1.0, 1.0, 0.0]] {
let (x, y) = (unstated.map_signal(probe), wide.map_signal(probe));
for channel in 0..3 {
assert!(
near(x[channel], y[channel], 0.0),
"{probe:?}: {x:?} vs {y:?}"
);
}
}
} else {
assert_eq!(unstated, wide, "an unspecified gamut is BT.2020");
}
let identity = narrow.hdr.as_ref().expect("maps").to_bt709;
for (row, line) in identity.iter().enumerate() {
for (column, value) in line.iter().enumerate() {
let want = if row == column { 1.0 } else { 0.0 };
assert!(
near(*value, want, 1e-6),
"BT.709 to BT.709 [{row}][{column}] {value}"
);
}
}
}
}
#[test]
fn a_bt709_picture_passes_through_unchanged() {
for transfer in [
Transfer::Bt709,
Transfer::Unspecified,
Transfer::Smpte170M,
Transfer::Bt2020_10Bit,
Transfer::Iec6196621,
Transfer::Linear,
] {
let mapping = SdrMapping::for_picture(&transfer, &Primaries::Bt709).expect("SDR");
assert!(mapping.is_passthrough(), "{transfer:?}");
assert_eq!(mapping.transfer(), None);
let original: [u8; 768] = core::array::from_fn(|i| (i * 7 % 256) as u8);
let mut rgb = original;
mapping.map_rgb8(&mut rgb);
assert_eq!(
rgb, original,
"{transfer:?}: the 8-bit face changed nothing"
);
assert_eq!(mapping.map_signal([0.1, 0.5, 0.9]), [0.1, 0.5, 0.9]);
let mut narrowed = [0u8; 6];
mapping
.map_rgb16(&[0, 512, 1023, 1023, 0, 256], 10, &mut narrowed)
.expect("whole pixels");
assert_eq!(
narrowed,
[0, 128, 255, 255, 0, 64],
"only the depth narrows"
);
}
assert!(
SdrMapping::for_picture(&Transfer::Bt709, &Primaries::Film)
.expect("an SDR picture is never refused")
.is_passthrough()
);
assert!(SdrMapping::passthrough().is_passthrough());
}
#[test]
fn a_gamut_with_no_conversion_is_refused_by_name() {
for primaries in [
Primaries::Film,
Primaries::Bt470M,
Primaries::SmpteRp431,
Primaries::SmpteSt428,
Primaries::other("vendor-gamut"),
] {
for transfer in HDR {
let refused = SdrMapping::for_picture(&transfer, &primaries).expect_err("refused");
assert_eq!(refused.primaries(), &primaries);
assert_eq!(Some(refused.transfer()), HdrTransfer::of(&transfer));
let said = std::format!("{refused}");
assert!(said.contains(primaries.as_str()), "{said}");
assert!(said.contains(refused.transfer().as_str()), "{said}");
}
}
for primaries in [
Primaries::Bt709,
Primaries::Bt2020,
Primaries::SmpteEg432,
Primaries::Bt470Bg,
Primaries::Smpte170M,
Primaries::Smpte240M,
Primaries::Ebu3213E,
Primaries::Unspecified,
] {
for transfer in HDR {
assert!(
SdrMapping::for_picture(&transfer, &primaries).is_ok(),
"{primaries:?} has a D65 white and converts",
);
}
}
}
#[test]
fn the_8_bit_face_is_the_signal_face_quantised() {
for transfer in HDR {
for primaries in [Primaries::Bt2020, Primaries::Bt709] {
let mapping = SdrMapping::for_picture(&transfer, &primaries).expect("converts");
for value in 0..=255u8 {
for pixel in [
[value, value, value],
[value, 255 - value, value / 2],
[255, value, 0],
] {
let mut mapped = pixel;
mapping.map_rgb8(&mut mapped);
let want = mapping
.map_signal(pixel.map(|c| c as f32 / 255.0))
.map(code);
assert!(
same_codes(mapped, want),
"{transfer:?} over {primaries:?}: {pixel:?} gave {mapped:?}, want {want:?}"
);
}
}
let mut partial = [200u8, 100, 50, 25];
mapping.map_rgb8(&mut partial);
assert_eq!(partial[3], 25, "a trailing partial pixel is left alone");
}
}
}
#[test]
fn the_16_bit_face_maps_at_its_native_depth() {
let mapping = SdrMapping::for_picture(&Transfer::AribStdB67Hlg, &Primaries::Bt2020).expect("HLG");
let rgb: [u16; 6] = [0, 600, 1023, 512, 512, 512];
let mut out = [0u8; 6];
mapping.map_rgb16(&rgb, 10, &mut out).expect("whole pixels");
for (pixel, mapped) in rgb.as_chunks::<3>().0.iter().zip(out.as_chunks::<3>().0) {
let want = mapping
.map_signal([0, 1, 2].map(|i| f32::from(pixel[i]) / 1023.0))
.map(code);
assert!(
same_codes(*mapped, want),
"{pixel:?} gave {mapped:?}, want {want:?}"
);
}
let (mut over, mut full) = ([0u8; 3], [0u8; 3]);
mapping.map_rgb16(&[2000; 3], 10, &mut over).expect("whole");
mapping.map_rgb16(&[1023; 3], 10, &mut full).expect("whole");
assert!(
same_codes(over, full),
"above full scale reads as full scale"
);
assert_eq!(
mapping.map_rgb16(&rgb, 0, &mut out),
Err(MapError::Depth { bits: 0 })
);
assert_eq!(
mapping.map_rgb16(&rgb, 17, &mut out),
Err(MapError::Depth { bits: 17 })
);
assert_eq!(
mapping.map_rgb16(&rgb, 10, &mut out[..3]),
Err(MapError::LengthMismatch {
samples: 6,
bytes: 3
}),
);
assert_eq!(
mapping.map_rgb16(&rgb[..5], 10, &mut out[..5]),
Err(MapError::LengthMismatch {
samples: 5,
bytes: 5
}),
);
}
#[test]
fn every_output_is_a_signal() {
for transfer in HDR {
let mapping = SdrMapping::for_picture(&transfer, &Primaries::Bt2020).expect("converts");
for input in [
[-1.0, 0.5, 2.0],
[f32::NAN, 0.25, 0.75],
[f32::INFINITY, f32::NEG_INFINITY, 0.0],
[1.0, 0.0, 0.0],
[0.0, 0.0, 1.0],
] {
for channel in mapping.map_signal(input) {
assert!(
(0.0..=1.0).contains(&channel),
"{transfer:?} {input:?}: {channel}"
);
}
}
}
}
#[test]
fn the_stated_constants() {
assert_eq!(KNEE_START, STATED_KNEE);
assert_eq!(REFERENCE_WHITE_NITS, 203.0);
assert_eq!(HLG_NOMINAL_PEAK_NITS, 1000.0);
assert_eq!(PQ_PEAK_NITS, 10_000.0);
assert!(near(hlg_oetf(1.0 / 12.0), 0.5, 1e-6));
}