665bfac0b339
exr_golden.rs
//! OpenEXR pictures and aux channels pinned to exact hashes (#474).
//!
//! Synthetic files (single-layer, multi-layer with and without an unnamed RGB layer, multi-part,
//! data windows smaller and larger than the display window, half / float / uint channels, RLE,
//! ZIP, PIZ and DWAA) are decoded through the media pool as the renderer asks for them: the
//! picture in each alpha interpretation, and the channels EXtractoR and Cryptomatte read. The
//! hashes were taken before the picture and the channels started sharing one decode, so a change
//! to how either is decoded must leave every bit as it was. Only bit-exact float steps are
//! pinned (linear light, no `powf`), so the hashes hold on every platform; DWAA (whose decoder
//! uses `powf`) and the sRGB / gamma 2.4 curves are checked for agreement between the two ways a
//! frame can be decoded instead. Re-pin with `EXR_GOLDEN_PRINT=1` after an intended change.
use std::sync::Arc;
use effectcraft_media::{MediaPool, probe_bytes};
use effectcraft_project::{AlphaMode, Footage, ItemId};
use effectcraft_render::{FloatCurve, FootageSource};
use effectcraft_time::Tick;
use exr::prelude::*;
const W: usize = 37;
const H: usize = 23;
/// A deterministic value for pixel (x, y) of channel `c`: negative, in range and above 1.
fn value(x: usize, y: usize, c: usize) -> f32 {
((x * 7 + y * 13 + c * 29) % 97) as f32 / 40.0 - 0.3
}
/// A deterministic alpha in 0..=1 (0 included, for the premultiplied divide).
fn alpha(x: usize, y: usize) -> f32 {
((x * 3 + y * 5) % 11) as f32 / 10.0
}
#[derive(Clone, Copy)]
enum Kind {
Half,
Float,
Uint,
}
/// A channel `name` of `size` filled from [`value`] (or [`alpha`] for an `A` / `a` channel).
fn channel(name: &str, kind: Kind, size: (usize, usize), c: usize) -> AnyChannel<FlatSamples> {
let is_alpha = name.rsplit('.').next().is_some_and(|n| n.eq_ignore_ascii_case("a"));
let px = |i: usize| {
let (x, y) = (i % size.0, i / size.0);
if is_alpha { alpha(x, y) } else { value(x, y, c) }
};
let n = size.0 * size.1;
let samples = match kind {
Kind::Half => FlatSamples::F16((0..n).map(|i| f16::from_f32(px(i))).collect()),
Kind::Float => FlatSamples::F32((0..n).map(px).collect()),
Kind::Uint => FlatSamples::U32((0..n).map(|i| (i as u32).wrapping_mul(2_654_435_761) >> 8).collect()),
};
AnyChannel::new(name, samples)
}
fn channels(list: &[(&str, Kind)], size: (usize, usize)) -> AnyChannels<FlatSamples> {
AnyChannels::sort(list.iter().enumerate().map(|(c, (n, k))| channel(n, *k, size, c)).collect::<Vec<_>>().into())
}
fn encoding(compression: Compression) -> Encoding {
Encoding { compression, blocks: Blocks::ScanLines, line_order: LineOrder::Increasing }
}
fn with_manifest(mut attrs: LayerAttributes) -> LayerAttributes {
attrs.other.insert(Text::from("cryptomatte/abc1234/name"), AttributeValue::Text(Text::from("CryptoObject")));
attrs.other.insert(Text::from("cryptomatte/abc1234/manifest"), AttributeValue::Text(Text::from(r#"{"bunny":"13851a76","floor":"0a1b2c3d"}"#)));
attrs
}
/// One part: `list` channels over a data window of `size` at `pos`.
fn part(name: Option<&str>, list: &[(&str, Kind)], size: (usize, usize), pos: (i32, i32), compression: Compression) -> Layer<AnyChannels<FlatSamples>> {
part_with(name, list, size, pos, encoding(compression))
}
/// [`part`] with its own block layout (tiles) and line order.
fn part_with(name: Option<&str>, list: &[(&str, Kind)], size: (usize, usize), pos: (i32, i32), encoding: Encoding) -> Layer<AnyChannels<FlatSamples>> {
let mut attrs = name.map_or_else(LayerAttributes::default, LayerAttributes::named);
attrs.layer_position = Vec2(pos.0, pos.1);
Layer::new(size, with_manifest(attrs), encoding, channels(list, size))
}
/// A tiled single-part file of `list` with mip levels down to 1×1 (each level its own values);
/// the picture and the channels are its largest level.
fn mipmapped(list: &[(&str, Kind)], compression: Compression) -> Vec<u8> {
let levels = |name: &str, kind: Kind, c: usize| {
let (mut data, mut size) = (vec![], (W, H));
loop {
data.push(channel(name, kind, size, c + data.len()).sample_data);
if size == (1, 1) {
break;
}
size = ((size.0 / 2).max(1), (size.1 / 2).max(1));
}
AnyChannel::new(name, Levels::Mip { rounding_mode: exr::math::RoundingMode::Down, level_data: data })
};
let list: Vec<AnyChannel<Levels<FlatSamples>>> = list.iter().enumerate().map(|(c, (n, k))| levels(n, *k, c)).collect();
let encoding = Encoding { compression, blocks: Blocks::Tiles(Vec2(16, 16)), line_order: LineOrder::Increasing };
let layer = Layer::new((W, H), with_manifest(LayerAttributes::default()), encoding, AnyChannels::sort(list.into()));
let mut bytes = std::io::Cursor::new(Vec::new());
Image::from_layer(layer).write().non_parallel().to_buffered(&mut bytes).unwrap();
bytes.into_inner()
}
/// Encode `layers` with the display window `display` (position, size).
fn write(layers: Vec<Layer<AnyChannels<FlatSamples>>>, display: ((i32, i32), (usize, usize))) -> Vec<u8> {
let mut attrs = ImageAttributes::new(IntegerBounds::new(display.0, display.1));
attrs.pixel_aspect = 1.0;
let image = Image::from_layers(attrs, layers);
let mut bytes = std::io::Cursor::new(Vec::new());
image.write().non_parallel().to_buffered(&mut bytes).unwrap();
bytes.into_inner()
}
const RGBA_HALF: [(&str, Kind); 4] = [("R", Kind::Half), ("G", Kind::Half), ("B", Kind::Half), ("A", Kind::Half)];
const CRYPTO: [(&str, Kind); 4] =
[("CryptoObject00.r", Kind::Float), ("CryptoObject00.g", Kind::Float), ("CryptoObject00.b", Kind::Float), ("CryptoObject00.a", Kind::Float)];
/// The synthetic files: (name, bytes, whether the hashes are pinned).
fn files() -> Vec<(&'static str, Vec<u8>, bool)> {
let full = (W, H);
let origin = ((0, 0), full);
let cat = |a: &[(&'static str, Kind)], b: &[(&'static str, Kind)]| -> Vec<(&'static str, Kind)> { a.iter().chain(b).copied().collect() };
let layered: Vec<(&str, Kind)> = cat(
&[
("Image.R", Kind::Half),
("Image.G", Kind::Half),
("Image.B", Kind::Half),
("Image.A", Kind::Half),
("depth.Z", Kind::Float),
("ObjectID", Kind::Uint),
],
&CRYPTO,
);
let unnamed_plus: Vec<(&str, Kind)> =
cat(&cat(&RGBA_HALF, &[("Diffuse.R", Kind::Half), ("Diffuse.G", Kind::Half), ("Diffuse.B", Kind::Half), ("Z", Kind::Float)]), &CRYPTO);
let rgb_float = [("R", Kind::Float), ("G", Kind::Float), ("B", Kind::Float), ("depth.Z", Kind::Float)];
vec![
("rgba_half_zip16", write(vec![part(None, &RGBA_HALF, full, (0, 0), Compression::ZIP16)], origin), true),
(
"rgb_float_piz",
write(vec![part(None, &[("R", Kind::Float), ("G", Kind::Float), ("B", Kind::Float), ("Z", Kind::Float)], full, (0, 0), Compression::PIZ)], origin),
true,
),
("layered_rle", write(vec![part(None, &layered, full, (0, 0), Compression::RLE)], origin), true),
("unnamed_rgb_plus_layers_zip1", write(vec![part(None, &unnamed_plus, full, (0, 0), Compression::ZIP1)], origin), true),
(
"multipart_zip16",
write(
vec![
part(Some("Image"), &RGBA_HALF, full, (0, 0), Compression::ZIP16),
part(Some("depth"), &[("Z", Kind::Float)], full, (0, 0), Compression::ZIP16),
part(
Some("CryptoObject00"),
&[("r", Kind::Float), ("g", Kind::Float), ("b", Kind::Float), ("a", Kind::Float)],
full,
(0, 0),
Compression::ZIP16,
),
],
origin,
),
true,
),
(
// The first part with R, G and B is not the beauty pass.
"multipart_diffuse_then_beauty_zip1",
write(
vec![
part(Some("diffuse"), &[("R", Kind::Half), ("G", Kind::Half), ("B", Kind::Half)], full, (0, 0), Compression::ZIP1),
part(Some("beauty"), &RGBA_HALF, (20, 10), (5, 7), Compression::ZIP1),
part(Some("depth"), &[("Z", Kind::Float)], full, (0, 0), Compression::ZIP1),
],
origin,
),
true,
),
(
"multipart_blender5_rle",
write(
vec![
part(Some("ViewLayer.Depth"), &[("ViewLayer.Depth.Z", Kind::Float)], full, (0, 0), Compression::RLE),
part(
Some("ViewLayer.Combined"),
&[
("ViewLayer.Combined.R", Kind::Half),
("ViewLayer.Combined.G", Kind::Half),
("ViewLayer.Combined.B", Kind::Half),
("ViewLayer.Combined.A", Kind::Half),
],
full,
(0, 0),
Compression::RLE,
),
],
origin,
),
true,
),
("unnamed_rgb_window_smaller_zip16", write(vec![part(None, &unnamed_plus, (20, 10), (5, 7), Compression::ZIP16)], origin), true),
("rgb_float_window_larger_piz", write(vec![part(None, &rgb_float, (45, 30), (-1, -5), Compression::PIZ)], ((3, -2), full)), true),
("layered_window_smaller_zip16", write(vec![part(None, &layered, (20, 10), (5, 7), Compression::ZIP16)], origin), true),
("layered_window_larger_piz", write(vec![part(None, &layered, (45, 30), (-4, -3), Compression::PIZ)], origin), true),
("unnamed_rgb_plus_layers_dwaa", write(vec![part(None, &unnamed_plus, full, (0, 0), Compression::DWAA(None))], origin), false),
("layered_dwaa", write(vec![part(None, &layered, full, (0, 0), Compression::DWAA(None))], origin), false),
(
"unnamed_rgb_plus_layers_tiled_zip16",
write(
vec![part_with(None, &unnamed_plus, (30, 20), (3, 2), Encoding { blocks: Blocks::Tiles(Vec2(16, 8)), ..encoding(Compression::ZIP16) })],
origin,
),
true,
),
(
"layered_tiled_rle",
write(vec![part_with(None, &layered, full, (0, 0), Encoding { blocks: Blocks::Tiles(Vec2(8, 8)), ..encoding(Compression::RLE) })], origin),
true,
),
("unnamed_rgb_plus_layers_mipmapped_zip16", mipmapped(&unnamed_plus, Compression::ZIP16), true),
("layered_mipmapped_piz", mipmapped(&layered, Compression::PIZ), true),
(
"unnamed_rgb_plus_layers_decreasing_zip1",
write(
vec![part_with(None, &unnamed_plus, (20, 10), (5, 7), Encoding { line_order: LineOrder::Decreasing, ..encoding(Compression::ZIP1) })],
origin,
),
true,
),
(
"layered_decreasing_rle",
write(vec![part_with(None, &layered, full, (0, 0), Encoding { line_order: LineOrder::Decreasing, ..encoding(Compression::RLE) })], origin),
true,
),
("unnamed_rgb_plus_layers_uncompressed", write(vec![part(None, &unnamed_plus, (20, 10), (-3, 4), Compression::Uncompressed)], origin), true),
("layered_uncompressed", write(vec![part(None, &layered, full, (0, 0), Compression::Uncompressed)], origin), true),
(
"uint_rgb_zip16",
write(
vec![part(
None,
&[("R", Kind::Uint), ("G", Kind::Uint), ("B", Kind::Uint), ("A", Kind::Half), ("depth.Z", Kind::Float)],
full,
(0, 0),
Compression::ZIP16,
)],
origin,
),
true,
),
(
// The image crate shows the part "depth" (the first with R, G and B), whose planes are
// filled with the background depth outside its data window: decoded by the image crate.
"multipart_depth_named_rgb_zip16",
write(
vec![
part(Some("depth"), &[("R", Kind::Half), ("G", Kind::Half), ("B", Kind::Half)], (20, 10), (5, 7), Compression::ZIP16),
part(Some("beauty"), &RGBA_HALF, full, (0, 0), Compression::ZIP16),
],
origin,
),
true,
),
]
}
/// FNV-1a over 32-bit words.
fn fnv(words: impl IntoIterator<Item = u32>) -> u64 {
let mut h: u64 = 0xcbf2_9ce4_8422_2325;
for w in words {
for b in w.to_le_bytes() {
h ^= u64::from(b);
h = h.wrapping_mul(0x0100_0000_01b3);
}
}
h
}
fn picture_hash(pool: &MediaPool, f: &Footage, float: FloatCurve, size: Option<(u32, u32)>) -> u64 {
let img = pool.frame_with(ItemId(1), f, Tick::ZERO, size, float).expect("picture");
fnv([img.width, img.height].into_iter().chain(img.data.iter().flat_map(|p| p.map(f32::to_bits))))
}
fn aux_hash(pool: &MediaPool, f: &Footage) -> u64 {
let Some(aux) = pool.aux(ItemId(1), f, Tick::ZERO) else { return 0 };
let mut words = vec![aux.width, aux.height, aux.scale.to_bits() as u32];
for (name, plane) in &aux.channels {
words.extend(name.bytes().map(u32::from));
words.extend(plane.iter().map(|v| v.to_bits()));
}
for (name, objects) in &aux.manifests {
words.extend(name.bytes().map(u32::from));
for (o, h) in objects {
words.extend(o.bytes().map(u32::from));
words.push(*h);
}
}
fnv(words)
}
/// The interpretations a picture is decoded in: (label, footage, curve, size, pinned).
fn variants(f: &Footage) -> Vec<(String, Footage, FloatCurve, Option<(u32, u32)>, bool)> {
let mut out = vec![];
for (mode, label) in
[(None, "probed"), (Some(AlphaMode::Straight), "straight"), (Some(AlphaMode::Premultiplied), "premul"), (Some(AlphaMode::Ignore), "ignore")]
{
let mut g = f.clone();
if let Some(m) = mode {
g.alpha = m;
}
g.premul_color = [0.2, 0.4, 0.6];
out.push((format!("{label}/linear"), g.clone(), FloatCurve::Linear, None, true));
out.push((format!("{label}/srgb"), g.clone(), FloatCurve::Srgb, None, false));
out.push((format!("{label}/gamma24"), g.clone(), FloatCurve::Gamma24, None, false));
}
let preserve = Footage { preserve_rgb: true, ..f.clone() };
out.push(("preserve_rgb".into(), preserve, FloatCurve::Srgb, None, true));
out.push(("half_size/srgb".into(), f.clone(), FloatCurve::Srgb, Some((f.width.div_ceil(2), f.height.div_ceil(2))), false));
out
}
/// Every hash of `file`: the size and alpha import finds, each picture and the channels, decoded
/// picture first (the footage alone) or channels first (an effect reads them).
fn hashes(name: &str, bytes: &[u8], aux_first: bool) -> Vec<(String, u64, bool)> {
let order = if aux_first { "aux-first" } else { "picture-first" };
let path = format!("/exr-golden-474/{order}/{name}.exr");
let b: Arc<[u8]> = bytes.into();
let pool = MediaPool::new();
pool.add_bytes(&path, b.clone());
let f = probe_bytes(&path, b).expect("probe");
let mut out = vec![("probe".to_string(), fnv([f.width, f.height, f.alpha as u32]), true)];
let aux = if aux_first { Some(aux_hash(&pool, &f)) } else { None };
for (label, g, float, size, pinned) in variants(&f) {
out.push((label, picture_hash(&pool, &g, float, size), pinned));
}
out.push(("aux".into(), aux.unwrap_or_else(|| aux_hash(&pool, &f)), true));
out
}
/// Hashes taken on main before #474's shared decode (`EXR_GOLDEN_PRINT=1`).
const PINNED: &[(&str, &str, u64)] = &[
("rgba_half_zip16", "probe", 0x0a32e074a28c1f66),
("rgba_half_zip16", "probed/linear", 0xa84600283dce98f6),
("rgba_half_zip16", "straight/linear", 0xf028e1367a2fbb30),
("rgba_half_zip16", "premul/linear", 0xa84600283dce98f6),
("rgba_half_zip16", "ignore/linear", 0xa90a57f9a67f7468),
("rgba_half_zip16", "preserve_rgb", 0xc8e0050f5efe75b7),
("rgba_half_zip16", "aux", 0xdd555e6cf67d75f3),
("rgb_float_piz", "probe", 0x6a38346c4c5662d5),
("rgb_float_piz", "probed/linear", 0xa6e8fbbad371a2ae),
("rgb_float_piz", "straight/linear", 0xa6e8fbbad371a2ae),
("rgb_float_piz", "premul/linear", 0x515f476c176229c9),
("rgb_float_piz", "ignore/linear", 0xa6e8fbbad371a2ae),
("rgb_float_piz", "preserve_rgb", 0xa6e8fbbad371a2ae),
("rgb_float_piz", "aux", 0x554623d237c2e5ef),
("layered_rle", "probe", 0x0a32e074a28c1f66),
("layered_rle", "probed/linear", 0xa84600283dce98f6),
("layered_rle", "straight/linear", 0xf028e1367a2fbb30),
("layered_rle", "premul/linear", 0xa84600283dce98f6),
("layered_rle", "ignore/linear", 0xa90a57f9a67f7468),
("layered_rle", "preserve_rgb", 0xc8e0050f5efe75b7),
("layered_rle", "aux", 0xa6b9bd9f02c192ad),
("unnamed_rgb_plus_layers_zip1", "probe", 0x0a32e074a28c1f66),
("unnamed_rgb_plus_layers_zip1", "probed/linear", 0xa84600283dce98f6),
("unnamed_rgb_plus_layers_zip1", "straight/linear", 0xf028e1367a2fbb30),
("unnamed_rgb_plus_layers_zip1", "premul/linear", 0xa84600283dce98f6),
("unnamed_rgb_plus_layers_zip1", "ignore/linear", 0xa90a57f9a67f7468),
("unnamed_rgb_plus_layers_zip1", "preserve_rgb", 0xc8e0050f5efe75b7),
("unnamed_rgb_plus_layers_zip1", "aux", 0x27cc9b53d0862db1),
("multipart_zip16", "probe", 0x0a32e074a28c1f66),
("multipart_zip16", "probed/linear", 0xa84600283dce98f6),
("multipart_zip16", "straight/linear", 0xf028e1367a2fbb30),
("multipart_zip16", "premul/linear", 0xa84600283dce98f6),
("multipart_zip16", "ignore/linear", 0xa90a57f9a67f7468),
("multipart_zip16", "preserve_rgb", 0xc8e0050f5efe75b7),
("multipart_zip16", "aux", 0x567ad99a6690d03d),
("multipart_diffuse_then_beauty_zip1", "probe", 0x6a38346c4c5662d5),
("multipart_diffuse_then_beauty_zip1", "probed/linear", 0xa90a57f9a67f7468),
("multipart_diffuse_then_beauty_zip1", "straight/linear", 0xa90a57f9a67f7468),
("multipart_diffuse_then_beauty_zip1", "premul/linear", 0x7ab18932e25c5cc8),
("multipart_diffuse_then_beauty_zip1", "ignore/linear", 0xa90a57f9a67f7468),
("multipart_diffuse_then_beauty_zip1", "preserve_rgb", 0xa90a57f9a67f7468),
("multipart_diffuse_then_beauty_zip1", "aux", 0x6724d6dfd56a04cb),
("multipart_blender5_rle", "probe", 0x0a32e074a28c1f66),
("multipart_blender5_rle", "probed/linear", 0xa84600283dce98f6),
("multipart_blender5_rle", "straight/linear", 0xf028e1367a2fbb30),
("multipart_blender5_rle", "premul/linear", 0xa84600283dce98f6),
("multipart_blender5_rle", "ignore/linear", 0xa90a57f9a67f7468),
("multipart_blender5_rle", "preserve_rgb", 0xc8e0050f5efe75b7),
("multipart_blender5_rle", "aux", 0x522ae4819dd92e89),
("unnamed_rgb_window_smaller_zip16", "probe", 0x0a32e074a28c1f66),
("unnamed_rgb_window_smaller_zip16", "probed/linear", 0x19eb3b1a88d108a7),
("unnamed_rgb_window_smaller_zip16", "straight/linear", 0x2c73f9acaa936420),
("unnamed_rgb_window_smaller_zip16", "premul/linear", 0x19eb3b1a88d108a7),
("unnamed_rgb_window_smaller_zip16", "ignore/linear", 0x3b86057d18a16bf0),
("unnamed_rgb_window_smaller_zip16", "preserve_rgb", 0x5b999014e4a64bb2),
("unnamed_rgb_window_smaller_zip16", "aux", 0x8f78d3233450acf3),
("rgb_float_window_larger_piz", "probe", 0x6a38346c4c5662d5),
("rgb_float_window_larger_piz", "probed/linear", 0x8e3847d48f9967a6),
("rgb_float_window_larger_piz", "straight/linear", 0x8e3847d48f9967a6),
("rgb_float_window_larger_piz", "premul/linear", 0x0998eefc456dcdc9),
("rgb_float_window_larger_piz", "ignore/linear", 0x8e3847d48f9967a6),
("rgb_float_window_larger_piz", "preserve_rgb", 0x8e3847d48f9967a6),
("rgb_float_window_larger_piz", "aux", 0x7ccc9f86e6ff6140),
("layered_window_smaller_zip16", "probe", 0x0a32e074a28c1f66),
("layered_window_smaller_zip16", "probed/linear", 0x19eb3b1a88d108a7),
("layered_window_smaller_zip16", "straight/linear", 0x2c73f9acaa936420),
("layered_window_smaller_zip16", "premul/linear", 0x19eb3b1a88d108a7),
("layered_window_smaller_zip16", "ignore/linear", 0x3b86057d18a16bf0),
("layered_window_smaller_zip16", "preserve_rgb", 0x5b999014e4a64bb2),
("layered_window_smaller_zip16", "aux", 0x443480a1d789e63c),
("layered_window_larger_piz", "probe", 0x0a32e074a28c1f66),
("layered_window_larger_piz", "probed/linear", 0x443afe4029748836),
("layered_window_larger_piz", "straight/linear", 0xb32b44880f746826),
("layered_window_larger_piz", "premul/linear", 0x443afe4029748836),
("layered_window_larger_piz", "ignore/linear", 0xaa01706accce2cc4),
("layered_window_larger_piz", "preserve_rgb", 0xb2cbb40b10bc56b4),
("layered_window_larger_piz", "aux", 0xb7d91c8eea56a772),
("unnamed_rgb_plus_layers_tiled_zip16", "probe", 0x0a32e074a28c1f66),
("unnamed_rgb_plus_layers_tiled_zip16", "probed/linear", 0x7612f20634fe957e),
("unnamed_rgb_plus_layers_tiled_zip16", "straight/linear", 0xaa5f42cb6a31c78a),
("unnamed_rgb_plus_layers_tiled_zip16", "premul/linear", 0x7612f20634fe957e),
("unnamed_rgb_plus_layers_tiled_zip16", "ignore/linear", 0xbbf236635dcaac90),
("unnamed_rgb_plus_layers_tiled_zip16", "preserve_rgb", 0x15b555a243d79613),
("unnamed_rgb_plus_layers_tiled_zip16", "aux", 0x3d1439eed2202e41),
("layered_tiled_rle", "probe", 0x0a32e074a28c1f66),
("layered_tiled_rle", "probed/linear", 0xa84600283dce98f6),
("layered_tiled_rle", "straight/linear", 0xf028e1367a2fbb30),
("layered_tiled_rle", "premul/linear", 0xa84600283dce98f6),
("layered_tiled_rle", "ignore/linear", 0xa90a57f9a67f7468),
("layered_tiled_rle", "preserve_rgb", 0xc8e0050f5efe75b7),
("layered_tiled_rle", "aux", 0xa6b9bd9f02c192ad),
("unnamed_rgb_plus_layers_mipmapped_zip16", "probe", 0x0a32e074a28c1f66),
("unnamed_rgb_plus_layers_mipmapped_zip16", "probed/linear", 0xa84600283dce98f6),
("unnamed_rgb_plus_layers_mipmapped_zip16", "straight/linear", 0xf028e1367a2fbb30),
("unnamed_rgb_plus_layers_mipmapped_zip16", "premul/linear", 0xa84600283dce98f6),
("unnamed_rgb_plus_layers_mipmapped_zip16", "ignore/linear", 0xa90a57f9a67f7468),
("unnamed_rgb_plus_layers_mipmapped_zip16", "preserve_rgb", 0xc8e0050f5efe75b7),
("unnamed_rgb_plus_layers_mipmapped_zip16", "aux", 0x27cc9b53d0862db1),
("layered_mipmapped_piz", "probe", 0x0a32e074a28c1f66),
("layered_mipmapped_piz", "probed/linear", 0xa84600283dce98f6),
("layered_mipmapped_piz", "straight/linear", 0xf028e1367a2fbb30),
("layered_mipmapped_piz", "premul/linear", 0xa84600283dce98f6),
("layered_mipmapped_piz", "ignore/linear", 0xa90a57f9a67f7468),
("layered_mipmapped_piz", "preserve_rgb", 0xc8e0050f5efe75b7),
("layered_mipmapped_piz", "aux", 0xa6b9bd9f02c192ad),
("unnamed_rgb_plus_layers_decreasing_zip1", "probe", 0x0a32e074a28c1f66),
("unnamed_rgb_plus_layers_decreasing_zip1", "probed/linear", 0x19eb3b1a88d108a7),
("unnamed_rgb_plus_layers_decreasing_zip1", "straight/linear", 0x2c73f9acaa936420),
("unnamed_rgb_plus_layers_decreasing_zip1", "premul/linear", 0x19eb3b1a88d108a7),
("unnamed_rgb_plus_layers_decreasing_zip1", "ignore/linear", 0x3b86057d18a16bf0),
("unnamed_rgb_plus_layers_decreasing_zip1", "preserve_rgb", 0x5b999014e4a64bb2),
("unnamed_rgb_plus_layers_decreasing_zip1", "aux", 0x8f78d3233450acf3),
("layered_decreasing_rle", "probe", 0x0a32e074a28c1f66),
("layered_decreasing_rle", "probed/linear", 0xa84600283dce98f6),
("layered_decreasing_rle", "straight/linear", 0xf028e1367a2fbb30),
("layered_decreasing_rle", "premul/linear", 0xa84600283dce98f6),
("layered_decreasing_rle", "ignore/linear", 0xa90a57f9a67f7468),
("layered_decreasing_rle", "preserve_rgb", 0xc8e0050f5efe75b7),
("layered_decreasing_rle", "aux", 0xa6b9bd9f02c192ad),
("unnamed_rgb_plus_layers_uncompressed", "probe", 0x0a32e074a28c1f66),
("unnamed_rgb_plus_layers_uncompressed", "probed/linear", 0xa27668bf31d9426b),
("unnamed_rgb_plus_layers_uncompressed", "straight/linear", 0xfc73fe89457ce029),
("unnamed_rgb_plus_layers_uncompressed", "premul/linear", 0xa27668bf31d9426b),
("unnamed_rgb_plus_layers_uncompressed", "ignore/linear", 0xb3276cc5126776d4),
("unnamed_rgb_plus_layers_uncompressed", "preserve_rgb", 0xdee1105fa6e6822a),
("unnamed_rgb_plus_layers_uncompressed", "aux", 0x854a5e84e7aaa5c2),
("layered_uncompressed", "probe", 0x0a32e074a28c1f66),
("layered_uncompressed", "probed/linear", 0xa84600283dce98f6),
("layered_uncompressed", "straight/linear", 0xf028e1367a2fbb30),
("layered_uncompressed", "premul/linear", 0xa84600283dce98f6),
("layered_uncompressed", "ignore/linear", 0xa90a57f9a67f7468),
("layered_uncompressed", "preserve_rgb", 0xc8e0050f5efe75b7),
("layered_uncompressed", "aux", 0xa6b9bd9f02c192ad),
("uint_rgb_zip16", "probe", 0x0a32e074a28c1f66),
("uint_rgb_zip16", "probed/linear", 0xed89310ef0cdb9fd),
("uint_rgb_zip16", "straight/linear", 0xf9fe11ab8ed97cc8),
("uint_rgb_zip16", "premul/linear", 0xed89310ef0cdb9fd),
("uint_rgb_zip16", "ignore/linear", 0xf78cd263c0d74f12),
("uint_rgb_zip16", "preserve_rgb", 0x2a19d67b07cf4359),
("uint_rgb_zip16", "aux", 0x03e42411f8521856),
("multipart_depth_named_rgb_zip16", "probe", 0x6a38346c4c5662d5),
("multipart_depth_named_rgb_zip16", "probed/linear", 0x3b86057d18a16bf0),
("multipart_depth_named_rgb_zip16", "straight/linear", 0x3b86057d18a16bf0),
("multipart_depth_named_rgb_zip16", "premul/linear", 0x869374e9b0384cea),
("multipart_depth_named_rgb_zip16", "ignore/linear", 0x3b86057d18a16bf0),
("multipart_depth_named_rgb_zip16", "preserve_rgb", 0x3b86057d18a16bf0),
("multipart_depth_named_rgb_zip16", "aux", 0x0fa56884e83b4417),
];
#[test]
fn exr_pictures_and_channels_are_bit_identical() {
let print = std::env::var_os("EXR_GOLDEN_PRINT").is_some();
let mut failures = vec![];
for (name, bytes, pinned_file) in files() {
let first = hashes(name, &bytes, false);
let second = hashes(name, &bytes, true);
for ((label, h, pinned), (_, h2, _)) in first.iter().zip(&second) {
if h != h2 {
failures.push(format!("{name} {label}: picture first {h:#018x}, channels first {h2:#018x}"));
}
if print {
println!(" (\"{name}\", \"{label}\", {h:#018x}),{}", if *pinned && pinned_file { "" } else { " // not pinned" });
continue;
}
if !(*pinned && pinned_file) {
continue;
}
match PINNED.iter().find(|(n, l, _)| *n == name && l == label) {
Some((_, _, want)) if want == h => {}
Some((_, _, want)) => failures.push(format!("{name} {label}: {h:#018x}, pinned {want:#018x}")),
None => failures.push(format!("{name} {label}: {h:#018x} is not pinned")),
}
}
}
assert!(failures.is_empty(), "{}", failures.join("\n"));
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.