use std::path::Path;
use crate::error::Error;
use crate::extras::to_half_float;
use crate::math::ColorSpace;
use crate::textures::{MinFilter, Texture, TextureFilter, TextureType, Wrapping};
fn srgb_to_linear_table() -> &'static [f64; 1024] {
use std::sync::OnceLock;
static TABLE: OnceLock<[f64; 1024]> = OnceLock::new();
TABLE.get_or_init(|| {
let mut table = [0.0; 1024];
for (i, entry) in table.iter_mut().enumerate() {
*entry = (i as f64 * 0.003717127 + 0.0521327014).powf(2.4);
}
table
})
}
pub(crate) fn srgb_to_linear(value: f64) -> f64 {
if value < 10.31475 {
return value * 0.000303527;
}
if value < 1024.0 {
return srgb_to_linear_table()[value as usize];
}
(value * 0.003717127 + 0.0521327014).powf(2.4)
}
#[derive(Debug, Clone, PartialEq)]
pub struct UltraHdrMetadata {
pub version: Option<String>,
pub base_rendition_is_hdr: bool,
pub gain_map_min: f64,
pub gain_map_max: f64,
pub gamma: f64,
pub offset_sdr: f64,
pub offset_hdr: f64,
pub hdr_capacity_min: f64,
pub hdr_capacity_max: f64,
}
impl Default for UltraHdrMetadata {
fn default() -> Self {
Self {
version: None,
base_rendition_is_hdr: false,
gain_map_min: 0.0,
gain_map_max: 0.0,
gamma: 0.0,
offset_sdr: 0.0,
offset_hdr: 0.0,
hdr_capacity_min: 0.0,
hdr_capacity_max: 0.0,
}
}
}
#[derive(Debug, Clone)]
pub struct UltraHdrTexData {
pub width: u32,
pub height: u32,
pub metadata: UltraHdrMetadata,
pub data: UltraHdrData,
}
#[derive(Debug, Clone)]
pub enum UltraHdrData {
HalfFloat(Vec<u16>),
Float(Vec<f32>),
}
impl UltraHdrData {
pub fn len(&self) -> usize {
match self {
UltraHdrData::HalfFloat(data) => data.len() / 4,
UltraHdrData::Float(data) => data.len() / 4,
}
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}
#[derive(Debug, Clone)]
pub struct UltraHdrLoader {
texture_type: TextureType,
}
impl Default for UltraHdrLoader {
fn default() -> Self {
Self::new()
}
}
impl UltraHdrLoader {
pub fn new() -> Self {
Self {
texture_type: TextureType::HalfFloat,
}
}
pub fn set_data_type(&mut self, texture_type: TextureType) -> Result<&mut Self, Error> {
if !matches!(texture_type, TextureType::HalfFloat | TextureType::Float) {
return Err(Error::UnsupportedTextureType {
what: "UltraHDR",
texture_type,
});
}
self.texture_type = texture_type;
Ok(self)
}
pub fn data_type(&self) -> TextureType {
self.texture_type
}
pub fn load<P: AsRef<Path>>(&self, url: P) -> Result<Texture, Error> {
let path = url.as_ref();
let bytes = crate::io::read(path)?;
let tex_data = self.parse(path, &bytes)?;
let texture = match &tex_data.data {
UltraHdrData::HalfFloat(data) => {
Texture::data_rgba16float(tex_data.width, tex_data.height, data)
}
UltraHdrData::Float(data) => {
Texture::data_rgba32float(tex_data.width, tex_data.height, data)
}
};
texture.set_wrapping(Wrapping::ClampToEdge, Wrapping::ClampToEdge);
texture.set_color_space(ColorSpace::LinearSrgb);
texture.set_mag_filter(TextureFilter::Linear);
texture.set_min_filter(MinFilter::LinearMipmapLinear);
texture.set_generate_mipmaps(true);
texture.set_flip_y(true);
Ok(texture)
}
pub fn parse(&self, path: &Path, buffer: &[u8]) -> Result<UltraHdrTexData, Error> {
let mut metadata = UltraHdrMetadata::default();
let mut images: Option<(std::ops::Range<usize>, std::ops::Range<usize>)> = None;
for section in scan_jpeg_sections(buffer) {
match section.marker {
0xe0 => {}
0xe1 => {
let text = String::from_utf8_lossy(&buffer[section.range.clone()]);
parse_xmp_metadata(&text, &mut metadata);
}
0xe2 => {
let section_bytes = &buffer[section.range.clone()];
let data = §ion_bytes[2.min(section_bytes.len())..];
const ISO_NAMESPACE: &[u8] = b"urn:iso:std:iso:ts:21496:-1\0";
if data.len() >= ISO_NAMESPACE.len()
&& &data[..ISO_NAMESPACE.len()] == ISO_NAMESPACE
{
parse_iso_metadata(&data[ISO_NAMESPACE.len()..], &mut metadata);
continue;
}
if read_u32_be(data, 2) == Some(0x4d50_4600) {
images = parse_mpf(data, section.data_offset, buffer.len());
}
}
_ => {}
}
}
if metadata.version.is_none() {
return Err(Error::image(path, "not a valid UltraHDR image"));
}
let Some((primary, gain_map)) = images else {
return Err(Error::image(path, "could not parse the UltraHDR images"));
};
let primary = super::texture_loader::decode_jpeg_bytes(path, &buffer[primary])?;
let gain_map = super::texture_loader::decode_jpeg_bytes(path, &buffer[gain_map])?;
if primary.width as f64 / primary.height as f64
!= gain_map.width as f64 / gain_map.height as f64
{
return Err(Error::image(
path,
"aspect ratio mismatch between the SDR and gain-map images",
));
}
let data = apply_gain_map(&metadata, &primary, &gain_map, self.texture_type);
Ok(UltraHdrTexData {
width: primary.width,
height: primary.height,
metadata,
data,
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct Section {
marker: u8,
range: std::ops::Range<usize>,
data_offset: usize,
}
fn scan_jpeg_sections(bytes: &[u8]) -> Vec<Section> {
let mut sections = Vec::new();
let mut offset = 0usize;
while offset + 1 < bytes.len() {
if bytes[offset] != 0xff {
offset += 1;
continue;
}
let marker = bytes[offset + 1];
if marker == 0xd8 {
sections.push(Section {
marker,
range: offset..(offset + 2).min(bytes.len()),
data_offset: offset + 2,
});
offset += 2;
continue;
}
let length = || {
read_u16_be(bytes, offset + 2)
.map(|length| (offset + 2 + length as usize).min(bytes.len()))
};
if marker == 0xe0 || marker == 0xe1 || marker == 0xe2 {
let Some(end) = length() else { break };
sections.push(Section {
marker,
range: offset..end,
data_offset: offset + 2,
});
offset = end;
continue;
}
if (0xc0..=0xfe).contains(&marker) && marker != 0xd9 && !(0xd0..=0xd7).contains(&marker) {
let Some(end) = length() else { break };
offset = end;
continue;
}
offset += 2;
}
sections
}
fn parse_mpf(
data: &[u8],
section_offset: usize,
file_len: usize,
) -> Option<(std::ops::Range<usize>, std::ops::Range<usize>)> {
let little_endian = read_u32_be(data, 6) == Some(0x4949_2a00);
let read = |offset: usize| {
if little_endian {
read_u32_le(data, offset)
} else {
read_u32_be(data, offset)
}
};
const MPF_BYTES_OFFSET: usize = 60;
let primary_size = read(MPF_BYTES_OFFSET)? as usize;
let primary_offset = read(MPF_BYTES_OFFSET + 4)? as usize;
let gain_map_size = read(MPF_BYTES_OFFSET + 16)? as usize;
let gain_map_offset = read(MPF_BYTES_OFFSET + 20)? as usize + section_offset + 6;
let primary = primary_offset..primary_offset.checked_add(primary_size)?;
let gain_map = gain_map_offset..gain_map_offset.checked_add(gain_map_size)?;
if primary.end > file_len || gain_map.end > file_len {
return None;
}
Some((primary, gain_map))
}
fn parse_xmp_metadata(text: &str, metadata: &mut UltraHdrMetadata) {
let (Some(start), Some(end)) = (text.find('<'), text.rfind('>')) else {
return;
};
let xml = &text[start..=end];
if find_element(xml, "Container:Directory").is_some() {
return;
}
let Some(attributes) = find_element(xml, "rdf:Description") else {
return;
};
let attribute = |name: &str| attribute_value(attributes, name);
let float_or = |name: &str, default: f64| match attribute(name) {
Some(value) if !value.is_empty() => js_parse_float(&value),
_ => default,
};
metadata.version = attribute("hdrgm:Version");
metadata.base_rendition_is_hdr =
attribute("hdrgm:BaseRenditionIsHDR").as_deref() == Some("True");
metadata.gain_map_min = float_or("hdrgm:GainMapMin", 0.0);
metadata.gain_map_max = float_or("hdrgm:GainMapMax", 1.0);
metadata.gamma = float_or("hdrgm:Gamma", 1.0);
metadata.offset_sdr =
attribute("hdrgm:OffsetSDR").map_or(0.0, |value| js_number(&value)) / (1.0 / 64.0);
metadata.offset_hdr =
attribute("hdrgm:OffsetHDR").map_or(0.0, |value| js_number(&value)) / (1.0 / 64.0);
metadata.hdr_capacity_min = float_or("hdrgm:HDRCapacityMin", 0.0);
metadata.hdr_capacity_max = float_or("hdrgm:HDRCapacityMax", 1.0);
}
fn find_element<'a>(xml: &'a str, name: &str) -> Option<&'a str> {
let mut search = 0;
while let Some(found) = xml[search..].find(name) {
let open = search + found;
search = open + name.len();
if open == 0 || !xml[..open].ends_with('<') {
continue;
}
let rest = &xml[search..];
if !rest.starts_with(|c: char| c.is_whitespace() || c == '/' || c == '>') {
continue;
}
let end = rest.find('>')?;
return Some(&rest[..end]);
}
None
}
fn attribute_value(attributes: &str, name: &str) -> Option<String> {
let mut search = 0;
while let Some(found) = attributes[search..].find(name) {
let at = search + found;
search = at + name.len();
if at != 0 && !attributes[..at].ends_with(char::is_whitespace) {
continue;
}
let rest = attributes[search..].trim_start();
let Some(rest) = rest.strip_prefix('=') else {
continue;
};
let rest = rest.trim_start();
let quote = rest.chars().next()?;
if quote != '"' && quote != '\'' {
continue;
}
let rest = &rest[quote.len_utf8()..];
let end = rest.find(quote)?;
return Some(rest[..end].to_string());
}
None
}
fn js_parse_float(text: &str) -> f64 {
let text = text.trim_start();
let mut end = 0;
let bytes = text.as_bytes();
if end < bytes.len() && (bytes[end] == b'+' || bytes[end] == b'-') {
end += 1;
}
while end < bytes.len() && bytes[end].is_ascii_digit() {
end += 1;
}
if end < bytes.len() && bytes[end] == b'.' {
end += 1;
while end < bytes.len() && bytes[end].is_ascii_digit() {
end += 1;
}
}
if end < bytes.len() && (bytes[end] == b'e' || bytes[end] == b'E') {
let mut exponent = end + 1;
if exponent < bytes.len() && (bytes[exponent] == b'+' || bytes[exponent] == b'-') {
exponent += 1;
}
let digits = exponent;
while exponent < bytes.len() && bytes[exponent].is_ascii_digit() {
exponent += 1;
}
if exponent > digits {
end = exponent;
}
}
text[..end].parse::<f64>().unwrap_or(f64::NAN)
}
fn js_number(text: &str) -> f64 {
let text = text.trim();
if text.is_empty() {
return 0.0;
}
text.parse::<f64>().unwrap_or(f64::NAN)
}
fn parse_iso_metadata(data: &[u8], metadata: &mut UltraHdrMetadata) {
let mut offset = 4usize;
let Some(flags) = data.get(offset).copied() else {
return;
};
offset += 1;
let backward_direction = flags & 0x4 != 0;
let use_common_denominator = flags & 0x8 != 0;
let unsigned = |offset: &mut usize| {
let value = read_u32_be(data, *offset).unwrap_or(0) as f64;
*offset += 4;
value
};
let (
gain_map_min,
gain_map_max,
gamma,
offset_sdr,
offset_hdr,
hdr_capacity_min,
hdr_capacity_max,
);
if use_common_denominator {
let denominator = unsigned(&mut offset);
hdr_capacity_min = (unsigned(&mut offset) / denominator).log2();
hdr_capacity_max = (unsigned(&mut offset) / denominator).log2();
gain_map_min = as_i32(unsigned(&mut offset)) / denominator;
gain_map_max = as_i32(unsigned(&mut offset)) / denominator;
gamma = unsigned(&mut offset) / denominator;
offset_sdr = as_i32(unsigned(&mut offset)) / denominator * 255.0;
offset_hdr = as_i32(unsigned(&mut offset)) / denominator * 255.0;
} else {
let rational = |offset: &mut usize, signed: bool| {
let numerator = read_u32_be(data, *offset).unwrap_or(0) as f64;
let numerator = if signed { as_i32(numerator) } else { numerator };
*offset += 4;
let denominator = read_u32_be(data, *offset).unwrap_or(0) as f64;
*offset += 4;
numerator / denominator
};
hdr_capacity_min = rational(&mut offset, false).log2();
hdr_capacity_max = rational(&mut offset, false).log2();
gain_map_min = rational(&mut offset, true);
gain_map_max = rational(&mut offset, true);
gamma = rational(&mut offset, false);
offset_sdr = rational(&mut offset, true) * 255.0;
offset_hdr = rational(&mut offset, true) * 255.0;
}
metadata.version = Some("1.0".to_string());
metadata.base_rendition_is_hdr = backward_direction;
metadata.gain_map_min = gain_map_min;
metadata.gain_map_max = gain_map_max;
metadata.gamma = gamma;
metadata.offset_sdr = offset_sdr;
metadata.offset_hdr = offset_hdr;
metadata.hdr_capacity_min = hdr_capacity_min;
metadata.hdr_capacity_max = hdr_capacity_max;
}
fn as_i32(value: f64) -> f64 {
(value as u32) as i32 as f64
}
fn read_u16_be(bytes: &[u8], offset: usize) -> Option<u16> {
Some(u16::from_be_bytes(
bytes.get(offset..offset + 2)?.try_into().ok()?,
))
}
fn read_u32_be(bytes: &[u8], offset: usize) -> Option<u32> {
Some(u32::from_be_bytes(
bytes.get(offset..offset + 4)?.try_into().ok()?,
))
}
fn read_u32_le(bytes: &[u8], offset: usize) -> Option<u32> {
Some(u32::from_le_bytes(
bytes.get(offset..offset + 4)?.try_into().ok()?,
))
}
pub(crate) fn apply_gain_map(
metadata: &UltraHdrMetadata,
sdr: &crate::textures::Image,
gain_map: &crate::textures::Image,
texture_type: TextureType,
) -> UltraHdrData {
let scaled;
let gain_map_data = if gain_map.width == sdr.width && gain_map.height == sdr.height {
&gain_map.data
} else {
scaled = resize_bilinear(gain_map, sdr.width, sdr.height);
&scaled
};
let max_display_boost = 1.8f64.powf(metadata.hdr_capacity_max * 0.5);
let unclamped_weight_factor = (max_display_boost.log2() - metadata.hdr_capacity_min)
/ (metadata.hdr_capacity_max - metadata.hdr_capacity_min);
let weight_factor = unclamped_weight_factor.clamp(0.0, 1.0);
let inv_gamma = 1.0 / metadata.gamma;
let use_gamma_one = metadata.gamma == 1.0;
let length = sdr.data.len();
let mut half = Vec::new();
let mut float = Vec::new();
match texture_type {
TextureType::Float => float = vec![1.0f32; length],
_ => half = vec![15360u16; length],
}
for i in (0..length).step_by(4) {
for c in 0..3 {
let index = i + c;
let sdr_value = sdr.data[index] as f64;
let gain_map_value = gain_map_data[index] as f64 * 0.003_921_568_627_450_98;
let log_recovery = if use_gamma_one {
gain_map_value
} else {
gain_map_value.powf(inv_gamma)
};
let log_boost = metadata.gain_map_min
+ (metadata.gain_map_max - metadata.gain_map_min) * log_recovery;
let boost = if log_boost * weight_factor == 0.0 {
1.0
} else {
2f64.powf(log_boost * weight_factor)
};
let hdr_value = (sdr_value + metadata.offset_sdr) * boost - metadata.offset_hdr;
let linear = srgb_to_linear(hdr_value).clamp(0.0, 65504.0);
match texture_type {
TextureType::Float => float[index] = linear as f32,
_ => half[index] = to_half_float(linear),
}
}
}
match texture_type {
TextureType::Float => UltraHdrData::Float(float),
_ => UltraHdrData::HalfFloat(half),
}
}
fn resize_bilinear(image: &crate::textures::Image, width: u32, height: u32) -> Vec<u8> {
let mut out = vec![0u8; (width as usize) * (height as usize) * 4];
let scale_x = image.width as f64 / width as f64;
let scale_y = image.height as f64 / height as f64;
for y in 0..height {
let source_y = ((y as f64 + 0.5) * scale_y - 0.5).max(0.0);
let y0 = source_y.floor() as u32;
let y1 = (y0 + 1).min(image.height - 1);
let ty = source_y - y0 as f64;
for x in 0..width {
let source_x = ((x as f64 + 0.5) * scale_x - 0.5).max(0.0);
let x0 = source_x.floor() as u32;
let x1 = (x0 + 1).min(image.width - 1);
let tx = source_x - x0 as f64;
for c in 0..4 {
let at = |x: u32, y: u32| {
image.data[((y as usize * image.width as usize) + x as usize) * 4 + c] as f64
};
let top = at(x0, y0) * (1.0 - tx) + at(x1, y0) * tx;
let bottom = at(x0, y1) * (1.0 - tx) + at(x1, y1) * tx;
let value = top * (1.0 - ty) + bottom * ty;
out[((y as usize * width as usize) + x as usize) * 4 + c] =
value.round().clamp(0.0, 255.0) as u8;
}
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
const GAIN_MAP_XMP: &str = concat!(
"http://ns.adobe.com/xap/1.0/\0<?xpacket begin=\"\" id=\"W5M0Mp\"?>\n",
"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\" x:xmptk=\"Adobe XMP Core 5.1.2\">\n",
" <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n",
" <rdf:Description\n",
" xmlns:hdrgm=\"http://ns.adobe.com/hdr-gain-map/1.0/\"\n",
" hdrgm:Version=\"1.0\"\n",
" hdrgm:GainMapMin=\"0\"\n",
" hdrgm:GainMapMax=\"15.999075124875333\"\n",
" hdrgm:Gamma=\"1\"\n",
" hdrgm:OffsetSDR=\"0.015625\"\n",
" hdrgm:OffsetHDR=\"0.015625\"\n",
" hdrgm:HDRCapacityMin=\"0\"\n",
" hdrgm:HDRCapacityMax=\"15.999075124875333\"\n",
" hdrgm:BaseRenditionIsHDR=\"False\"\n",
" rdf:about=\"\"/>\n",
" </rdf:RDF>\n",
"</x:xmpmeta>\n<?xpacket end=\"w\"?>",
);
const CONTAINER_XMP: &str = concat!(
"http://ns.adobe.com/xap/1.0/\0<x:xmpmeta xmlns:x=\"adobe:ns:meta/\">\n",
" <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n",
" <rdf:Description xmlns:Container=\"http://ns.google.com/photos/1.0/container/\"\n",
" hdrgm:Version=\"1.0\" rdf:about=\"\">\n",
" <Container:Directory>\n",
" <rdf:Seq>\n",
" <rdf:li rdf:parseType=\"Resource\">\n",
" <Container:Item Item:Semantic=\"Primary\" Item:Mime=\"image/jpeg\"/>\n",
" </rdf:li>\n",
" </rdf:Seq>\n",
" </Container:Directory>\n",
" </rdf:Description>\n",
" </rdf:RDF>\n",
"</x:xmpmeta>",
);
#[test]
fn xmp_gain_map_descriptor() {
let mut metadata = UltraHdrMetadata::default();
parse_xmp_metadata(GAIN_MAP_XMP, &mut metadata);
assert_eq!(metadata.version.as_deref(), Some("1.0"));
assert!(!metadata.base_rendition_is_hdr);
assert_eq!(metadata.gain_map_min, 0.0);
assert_eq!(metadata.gain_map_max, 15.999075124875333);
assert_eq!(metadata.gamma, 1.0);
assert_eq!(metadata.offset_sdr, 1.0);
assert_eq!(metadata.offset_hdr, 1.0);
assert_eq!(metadata.hdr_capacity_min, 0.0);
assert_eq!(metadata.hdr_capacity_max, 15.999075124875333);
}
#[test]
fn xmp_container_descriptor_is_ignored() {
let mut metadata = UltraHdrMetadata::default();
parse_xmp_metadata(CONTAINER_XMP, &mut metadata);
assert_eq!(metadata, UltraHdrMetadata::default());
}
#[test]
fn xmp_defaults_for_missing_attributes() {
let mut metadata = UltraHdrMetadata::default();
parse_xmp_metadata(
"<rdf:Description hdrgm:Version=\"1.0\" rdf:about=\"\"/>",
&mut metadata,
);
assert_eq!(metadata.version.as_deref(), Some("1.0"));
assert_eq!(metadata.gain_map_min, 0.0);
assert_eq!(metadata.gain_map_max, 1.0);
assert_eq!(metadata.gamma, 1.0);
assert_eq!(metadata.offset_sdr, 0.0);
assert_eq!(metadata.offset_hdr, 0.0);
assert_eq!(metadata.hdr_capacity_min, 0.0);
assert_eq!(metadata.hdr_capacity_max, 1.0);
}
#[test]
fn xmp_base_rendition_is_hdr_is_a_string_compare() {
for (value, expected) in [("True", true), ("true", false), ("1", false)] {
let mut metadata = UltraHdrMetadata::default();
parse_xmp_metadata(
&format!(
"<rdf:Description hdrgm:Version=\"1.0\" hdrgm:BaseRenditionIsHDR=\"{value}\"/>"
),
&mut metadata,
);
assert_eq!(metadata.base_rendition_is_hdr, expected, "{value}");
}
}
#[test]
fn iso_common_denominator() {
let denominator: u32 = 1_000_000;
let mut data = Vec::new();
data.extend_from_slice(&[0, 0, 0, 0]); data.push(0x8 | 0x4); data.extend_from_slice(&denominator.to_be_bytes());
data.extend_from_slice(&denominator.to_be_bytes());
data.extend_from_slice(&(4 * denominator).to_be_bytes());
data.extend_from_slice(&(-(denominator as i32)).to_be_bytes()); data.extend_from_slice(&(3 * denominator).to_be_bytes()); data.extend_from_slice(&(2 * denominator).to_be_bytes()); data.extend_from_slice(&((denominator / 64) as i32).to_be_bytes()); data.extend_from_slice(&((denominator / 64) as i32).to_be_bytes());
let mut metadata = UltraHdrMetadata::default();
parse_iso_metadata(&data, &mut metadata);
assert_eq!(metadata.version.as_deref(), Some("1.0"));
assert!(metadata.base_rendition_is_hdr);
assert_eq!(metadata.hdr_capacity_min, 0.0);
assert_eq!(metadata.hdr_capacity_max, 2.0);
assert_eq!(metadata.gain_map_min, -1.0);
assert_eq!(metadata.gain_map_max, 3.0);
assert_eq!(metadata.gamma, 2.0);
assert!((metadata.offset_sdr - 0.015625 * 255.0).abs() < 1e-9);
assert!((metadata.offset_hdr - 0.015625 * 255.0).abs() < 1e-9);
}
#[test]
fn iso_per_value_denominators() {
let mut data = Vec::new();
data.extend_from_slice(&[0, 0, 0, 0]);
data.push(0); let mut rational = |numerator: i32, denominator: u32| {
data.extend_from_slice(&numerator.to_be_bytes());
data.extend_from_slice(&denominator.to_be_bytes());
};
rational(1, 1); rational(4, 1); rational(-1, 1); rational(3, 1); rational(2, 1); rational(1, 64); rational(1, 64);
let mut metadata = UltraHdrMetadata::default();
parse_iso_metadata(&data, &mut metadata);
assert!(!metadata.base_rendition_is_hdr);
assert_eq!(metadata.hdr_capacity_min, 0.0);
assert_eq!(metadata.hdr_capacity_max, 2.0);
assert_eq!(metadata.gain_map_min, -1.0);
assert_eq!(metadata.gain_map_max, 3.0);
assert_eq!(metadata.gamma, 2.0);
assert_eq!(metadata.offset_sdr, 255.0 / 64.0);
assert_eq!(metadata.offset_hdr, 255.0 / 64.0);
}
#[test]
fn jpeg_section_scan() {
let mut bytes = vec![0xff, 0xd8]; bytes.extend_from_slice(&[0xff, 0xe1, 0x00, 0x06, b'x', b'm', b'p', b'!']);
bytes.extend_from_slice(&[0xff, 0xdb, 0x00, 0x04, 0x00, 0x00]); bytes.extend_from_slice(&[0xff, 0xda, 0x00, 0x04, 0x00, 0x00]); bytes.extend_from_slice(&[0x12, 0xff, 0x00, 0x34]); bytes.extend_from_slice(&[0xff, 0xd9]);
let sections = scan_jpeg_sections(&bytes);
assert_eq!(sections.len(), 2);
assert_eq!(sections[0].marker, 0xd8);
assert_eq!(sections[1].marker, 0xe1);
assert_eq!(sections[1].range, 2..10);
assert_eq!(sections[1].data_offset, 4);
}
#[test]
fn srgb_to_linear_truncates_in_the_table_range() {
assert_eq!(srgb_to_linear(10.0), 10.0 * 0.000303527);
assert_eq!(srgb_to_linear(20.9), srgb_to_linear(20.0));
assert_ne!(srgb_to_linear(21.0), srgb_to_linear(20.0));
assert_ne!(srgb_to_linear(1024.5), srgb_to_linear(1024.0));
}
#[test]
fn gain_map_recovery() {
let metadata = UltraHdrMetadata {
version: Some("1.0".to_string()),
base_rendition_is_hdr: false,
gain_map_min: 0.0,
gain_map_max: 4.0,
gamma: 1.0,
offset_sdr: 1.0,
offset_hdr: 1.0,
hdr_capacity_min: 0.0,
hdr_capacity_max: 4.0,
};
let sdr = crate::textures::Image {
width: 2,
height: 1,
data: vec![10, 128, 255, 7, 0, 64, 200, 7],
};
let gain_map = crate::textures::Image {
width: 2,
height: 1,
data: vec![0, 128, 255, 7, 255, 0, 128, 7],
};
let data = apply_gain_map(&metadata, &sdr, &gain_map, TextureType::Float);
let UltraHdrData::Float(values) = data else {
panic!("asked for FloatType");
};
let weight = (1.8f64.powf(2.0).log2() / 4.0).clamp(0.0, 1.0);
for i in [0usize, 4] {
for c in 0..3 {
let gain = gain_map.data[i + c] as f64 / 255.0;
let log_boost = 4.0 * gain;
let boost = if log_boost * weight == 0.0 {
1.0
} else {
2f64.powf(log_boost * weight)
};
let hdr = (sdr.data[i + c] as f64 + 1.0) * boost - 1.0;
let expected = srgb_to_linear(hdr).clamp(0.0, 65504.0) as f32;
assert_eq!(values[i + c], expected, "texel {i} channel {c}");
}
assert_eq!(values[i + 3], 1.0);
}
}
}