Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

16 files changed, 5205 insertions, 0 deletions

diff --git a/vendor/exr/src/image/channel_groups.rs b/vendor/exr/src/image/channel_groups.rs
new file mode 100644
index 0000000..7d74375
--- /dev/null
+++ b/vendor/exr/src/image/channel_groups.rs
@@ -0,0 +1,267 @@
+
+use std::collections::HashMap;
+use crate::image::write::channels::{WritableChannels, ChannelsWriter};
+use crate::meta::attribute::{LevelMode, ChannelList, Text, TextSlice, ChannelInfo};
+use crate::meta::header::Header;
+use crate::image::read::layers::{ReadChannels, ChannelsReader};
+use crate::block::{BlockIndex, UncompressedBlock};
+use crate::block::lines::{collect_uncompressed_block_from_lines, LineIndex};
+use std::io::{Cursor, Read};
+use crate::error::{Result, UnitResult};
+use crate::block::chunk::TileCoordinates;
+use crate::prelude::SmallVec;
+
+
+
+
+
+pub struct ChannelGroups<ChannelGroup> {
+    channel_group: Option<ChannelGroup>,
+    children: HashMap<Text, Self>
+}
+
+
+impl<ChannelGroup> ChannelGroups<ChannelGroup>  {
+
+
+    // pub fn visit_groups_mut(&mut self, visitor: impl Fn(&mut Channels)) {
+    // }
+
+
+
+    pub fn groups(&self) -> SmallVec<[&ChannelGroup; 12]> {
+        let children = self.children.iter().flat_map(|group| group.groups());
+        self.channel_group.iter().chain(children).collect()
+    }
+
+    pub fn lookup_group(&self, group_name: &TextSlice) -> Option<&ChannelGroup> {
+        let dot_index = group_name.iter().position('.');
+        if let Some(dot_index) = dot_index {
+            let group_name = &group_name[.. dot_index];
+            let child_name = &group_name[dot_index + 1 ..];
+            self.children.get(group_name)
+                .and_then(|child| child.lookup(child_name))
+        }
+        else {
+            self.channel_group.lookup(name)
+        }
+    }
+
+
+    /*pub fn insert_group(&mut self, full_name: &TextSlice, value: ChannelGroup) {
+        let dot_index = full_name.iter().position('.');
+        if let Some(dot_index) = dot_index {
+            let group_name = &group_name[.. dot_index];
+            let name_rest = &group_name[dot_index + 1 ..];
+
+            self.children.entry(Text::from_slice_unchecked(group_name))
+                .or_insert(|| );
+
+            // self.children.insert(Text::from_slice_unchecked(group_name), value)
+            //     .and_then(|child| child.lookup(name_rest));
+        }
+        else {
+            self.channel_group.lookup(name);
+        }
+    }*/
+
+    pub fn map<T>(self, mapper: impl FnMut(ChannelGroup) -> T) -> ChannelGroups<T> {
+        ChannelGroups {
+            children: self.channel_group.iter().map(&mapper).collect(),
+            channel_group: self.channel_group.map(mapper),
+        }
+    }
+}
+
+
+pub fn parse_channel_list_groups<T>(channels: impl Iterator<Item=(Text, T)>)
+    -> ChannelGroups<SmallVec<(Text, T)>>
+{
+    fn insert_into_groups(groups: &mut ChannelGroups<SmallVec<(Text, T)>>, name: Text, value: T) {
+        let dot_index = name.as_slice().iter().position('.');
+
+        if let Some(dot_index) = dot_index {
+            // insert into child group
+
+            let group_name = Text::from_slice_unchecked(&name.as_slice()[.. dot_index]);
+            let child_channel = Text::from_slice_unchecked(&name.as_slice()[dot_index + 1 ..]);
+
+            let child_group = groups.children.entry(group_name)
+                .or_insert(ChannelGroups { channel_group: None, children: Default::default() });
+
+            insert_into_groups(child_group, child_channel, value);
+        }
+
+        else {
+            // insert directly into group
+
+            if groups.channel_group.is_none() {
+                groups.channel_group = Some(SmallVec::new());
+            }
+
+            groups.channel_group.unwrap().push(value);
+        }
+    }
+
+    let mut result = ChannelGroups { channel_group: None, children: HashMap::default() };
+    for (name, value) in channels { insert_into_groups(&mut result, name, value); }
+    result
+}
+
+
+impl<'slf, ChannelGroup> WritableChannels<'slf> for ChannelGroups<ChannelGroup>
+    where ChannelGroup: WritableChannels<'slf>
+{
+    fn infer_channel_list(&self) -> ChannelList {
+        // TODO what about empty groups with NO channels??
+
+        let child_channels = self.children.iter().flat_map(|(group_name, child)| {
+            let mut child_channels = child.infer_channel_list().list;
+            for channel in &mut child_channels { channel.name.push_front(group_name) };
+            child_channels
+        });
+
+        let mut own_channels = self.channel_group
+            .map(|chans| chans.infer_channel_list().list)
+            .unwrap_or_default();
+
+        own_channels.extend(child_channels);
+        own_channels.sort_unstable(); // TODO only once at end
+        ChannelList::new(own_channels) // might be empty, but will be checked in MetaData::validate()
+    }
+
+    fn level_mode(&self) -> LevelMode {
+        fn find_mode_or_none(channels: &Self) -> Option<LevelMode> {
+            channels.channel_group.map(WritableChannels::level_mode).or_else(|| {
+                channels.children.iter().map(find_mode_or_none).next()
+            })
+        }
+
+        let mode = find_mode_or_none(self)
+            .expect("empty channel groups (check failed)"); // TODO only happens for empty channels, right? panic maybe?
+
+        if let Some(chans) = self.channel_group.as_ref() {
+            debug_assert_eq!(chans.level_mode(), mode, "level mode must be equal for all legacy channel groups")
+        }
+
+        debug_assert!(
+            self.children.values()
+                .flat_map(find_mode_or_none)
+                .all(|child_mode| child_mode == mode),
+
+            "level mode must be equal for all legacy channel groups"
+        );
+
+        mode
+    }
+
+    type Writer = GroupChannelsWriter<'slf, ChannelGroup>;
+
+    fn create_writer(&'slf self, header: &Header) -> Self::Writer {
+        let channels = header.channels.list.iter()
+            .map(|channel_info|{
+                // hashmap order is not guaranteed? so look up each channel group manually instead of generating new
+                let channels = self.lookup_group(channel_info.name.as_slice())
+                    .expect("channels not found bug");
+
+                channels.create_writer(header) // channel_info.name.clone()
+            })
+            .collect();
+
+        GroupChannelsWriter { channels_list: channels }
+    }
+}
+
+struct GroupChannelsWriter<'c, ChannelGroupWriter> {
+    channels_list: Vec<&'c ChannelGroupWriter>,
+}
+
+impl<'c, Channels> ChannelsWriter for GroupChannelsWriter<'c, Channels> where Channels: ChannelsWriter {
+    fn extract_uncompressed_block(&self, header: &Header, block: BlockIndex) -> Vec<u8> {
+        let mut blocks_per_channel: Vec<Cursor<Vec<u8>>> = self
+            .channels_list.iter()
+            .map(|channels| Cursor::new(channels.extract_uncompressed_block(header, block)))
+            .collect();
+
+        UncompressedBlock::uncompressed_block_from_lines(header, block, |line|{
+            let channel_reader = &mut blocks_per_channel[line.location.channel]; // TODO subsampling
+
+            // read from specific channel into total byte block
+            // this assumes that the lines in the callback are iterated in strictly increasing order
+            // because each channel reader is consumed
+            channel_reader.read_exact(line.value)
+                .expect("collecting grouped channel byte block failed");
+        })
+    }
+}
+
+
+struct ReadChannelGroups<ReadChannelGroup> {
+    read_channels: ReadChannelGroup
+}
+
+struct ChannelGroupsReader<ChannelGroupReader> {
+    channels: ChannelGroups<usize>,
+    indexed_channels: Vec<ChannelGroupReader>,
+}
+
+impl<'s, ReadChannelGroup> ReadChannels<'s> for ReadChannelGroups<ReadChannelGroup>
+    where ReadChannelGroup: ReadChannels<'s>
+{
+    type Reader = ChannelGroupsReader<ReadChannelGroup::Reader>;
+
+    fn create_channels_reader(&'s self, header: &Header) -> Result<Self::Reader> {
+        let swap = |(a,b)| (b,a);
+        let channel_groups = parse_channel_list_groups(
+            header.channels.list.iter().enumerate().map(swap)
+        );
+
+        let mut indexed_channels = Vec::new();
+        let channel_groups = channel_groups.map(|channels| {
+
+            let mut channels_header = header.clone(); // TODO no clone?
+            channels_header.channels = ChannelList::new(channels.iter().map(|(name, index)|{
+                let mut channel_info = header.channels.list[index].clone();
+                channel_info.name = name;
+                channel_info
+            }).collect()); // FIXME does not comply to `header.chunk_count` and that stuff?? change ReadChannels fn signature?
+
+            indexed_channels.push(self.read_channels.create_channels_reader(&channels_header));
+
+            // FIXME this is not the original order indexed_channels.len() - 1
+            indexed_channels[]
+        });
+
+        Ok(ChannelGroupsReader {
+            channels: channel_groups,
+            indexed_channels,
+        })
+
+        /*Ok(ChannelGroupsReader {
+            channels: header.channels.list.iter().map(|channel| {
+                let mut channels_header = header.clone();
+
+                let reader = self.read_channels.create_channels_reader(&channels_header);
+                (channels_header, reader)
+            }).collect(),
+        })*/
+    }
+}
+
+impl<ChannelGroupReader> ChannelsReader for ChannelGroupsReader<ChannelGroupReader> where ChannelGroupReader: ChannelsReader {
+    type Channels = ChannelGroups<ChannelGroupReader::Channels>;
+
+    fn filter_block(&self, tile: (usize, &TileCoordinates)) -> bool {
+        self.indexed_channels.iter().any(|channel| channel.filter_block(tile))
+    }
+
+    fn read_block(&mut self, header: &Header, block: UncompressedBlock) -> UnitResult {
+        block.for_lines(|line|{
+
+        })
+    }
+
+    fn into_channels(self) -> Self::Channels {
+
+    }
+}
\ No newline at end of file
diff --git a/vendor/exr/src/image/crop.rs b/vendor/exr/src/image/crop.rs
new file mode 100644
index 0000000..63aadbf
--- /dev/null
+++ b/vendor/exr/src/image/crop.rs
@@ -0,0 +1,801 @@
+//! Crop away unwanted pixels. Includes automatic detection of bounding rectangle.
+//! Currently does not support deep data and resolution levels.
+
+use crate::meta::attribute::{IntegerBounds, LevelMode, ChannelList};
+use crate::math::{Vec2, RoundingMode};
+use crate::image::{Layer, FlatSamples, SpecificChannels, AnyChannels, FlatSamplesPixel, AnyChannel};
+use crate::image::write::channels::{GetPixel, WritableChannels, ChannelsWriter};
+use crate::meta::header::{LayerAttributes, Header};
+use crate::block::BlockIndex;
+
+/// Something that has a two-dimensional rectangular shape
+pub trait GetBounds {
+
+    /// The bounding rectangle of this pixel grid.
+    fn bounds(&self) -> IntegerBounds;
+}
+
+/// Inspect the pixels in this image to determine where to crop some away
+pub trait InspectSample: GetBounds {
+
+    /// The type of pixel in this pixel grid.
+    type Sample;
+
+    /// Index is not in world coordinates, but within the data window.
+    /// Position `(0,0)` always represents the top left pixel.
+    fn inspect_sample(&self, local_index: Vec2<usize>) -> Self::Sample;
+}
+
+/// Crop some pixels ways when specifying a smaller rectangle
+pub trait Crop: Sized {
+
+    /// The type of  this image after cropping (probably the same as before)
+    type Cropped;
+
+    /// Crop the image to exclude unwanted pixels.
+    /// Panics for invalid (larger than previously) bounds.
+    /// The bounds are specified in absolute coordinates.
+    /// Does not reduce allocation size of the current image, but instead only adjust a few boundary numbers.
+    /// Use `reallocate_cropped()` on the return value to actually reduce the memory footprint.
+    fn crop(self, bounds: IntegerBounds) -> Self::Cropped;
+
+    /// Reduce your image to a smaller part, usually to save memory.
+    /// Crop if bounds are specified, return the original if no bounds are specified.
+    /// Does not reduce allocation size of the current image, but instead only adjust a few boundary numbers.
+    /// Use `reallocate_cropped()` on the return value to actually reduce the memory footprint.
+    fn try_crop(self, bounds: Option<IntegerBounds>) -> CropResult<Self::Cropped, Self> {
+        match bounds {
+            Some(bounds) => CropResult::Cropped(self.crop(bounds)),
+            None => CropResult::Empty { original: self },
+        }
+    }
+}
+
+/// Cropping an image fails if the image is fully transparent.
+/// Use [`or_crop_to_1x1_if_empty`] or [`or_none_if_empty`] to obtain a normal image again.
+#[must_use]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum CropResult<Cropped, Old> {
+
+    /// The image contained some pixels and has been cropped or left untouched
+    Cropped (Cropped),
+
+    /// All pixels in the image would be discarded, removing the whole image
+    Empty {
+
+        /// The fully discarded image which caused the cropping to fail
+        original: Old
+    }
+}
+
+/// Crop away unwanted pixels from the border if they match the specified rule.
+pub trait CropWhere<Sample>: Sized {
+
+    /// The type of the cropped image (probably the same as the original image).
+    type Cropped;
+
+    /// Crop away unwanted pixels from the border if they match the specified rule.
+    /// Does not reduce allocation size of the current image, but instead only adjust a few boundary numbers.
+    /// Use `reallocate_cropped()` on the return value to actually reduce the memory footprint.
+    fn crop_where(self, discard_if: impl Fn(Sample) -> bool) -> CropResult<Self::Cropped, Self>;
+
+    /// Crop away unwanted pixels from the border if they match the specified color.
+    /// If you want discard based on a rule, use `crop_where` with a closure instead.
+    /// Does not reduce allocation size of the current image, but instead only adjust a few boundary numbers.
+    /// Use `reallocate_cropped()` on the return value to actually reduce the memory footprint.
+    fn crop_where_eq(self, discard_color: impl Into<Sample>) -> CropResult<Self::Cropped, Self> where Sample: PartialEq;
+
+    /// Convert this data to cropped data without discarding any pixels.
+    fn crop_nowhere(self) -> Self::Cropped;
+}
+
+impl<Channels> Crop for Layer<Channels> {
+    type Cropped = Layer<CroppedChannels<Channels>>;
+
+    fn crop(self, bounds: IntegerBounds) -> Self::Cropped {
+        CroppedChannels::crop_layer(bounds, self)
+    }
+}
+
+impl<T> CropWhere<T::Sample> for T where T: Crop + InspectSample {
+    type Cropped = <Self as Crop>::Cropped;
+
+    fn crop_where(self, discard_if: impl Fn(T::Sample) -> bool) -> CropResult<Self::Cropped, Self> {
+        let smaller_bounds = {
+            let keep_if = |position| !discard_if(self.inspect_sample(position));
+            try_find_smaller_bounds(self.bounds(), keep_if)
+        };
+
+        self.try_crop(smaller_bounds)
+    }
+
+    fn crop_where_eq(self, discard_color: impl Into<T::Sample>) -> CropResult<Self::Cropped, Self> where T::Sample: PartialEq {
+        let discard_color: T::Sample = discard_color.into();
+        self.crop_where(|sample| sample == discard_color)
+    }
+
+    fn crop_nowhere(self) -> Self::Cropped {
+        let current_bounds = self.bounds();
+        self.crop(current_bounds)
+    }
+}
+
+/// A smaller window into an existing pixel storage
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct CroppedChannels<Channels> {
+
+    /// The uncropped pixel storage
+    pub full_channels: Channels,
+
+    /// The uncropped pixel storage bounds
+    pub full_bounds: IntegerBounds,
+
+    /// The cropped pixel storage bounds
+    pub cropped_bounds: IntegerBounds,
+}
+
+impl<Channels> CroppedChannels<Channels> {
+
+    /// Wrap a layer in a cropped view with adjusted bounds, but without reallocating your pixels
+    pub fn crop_layer(new_bounds: IntegerBounds, layer: Layer<Channels>) -> Layer<CroppedChannels<Channels>> {
+        Layer {
+            channel_data: CroppedChannels {
+                cropped_bounds: new_bounds,
+                full_bounds: layer.absolute_bounds(),
+                full_channels: layer.channel_data,
+            },
+
+            size: new_bounds.size,
+
+            attributes: LayerAttributes {
+                layer_position: new_bounds.position,
+                .. layer.attributes
+            },
+
+            encoding: layer.encoding
+        }
+    }
+}
+
+// TODO make cropped view readable if you only need a specific section of the image?
+
+// make cropped view writable:
+
+impl<'slf, Channels:'slf> WritableChannels<'slf> for CroppedChannels<Channels> where Channels: WritableChannels<'slf> {
+    fn infer_channel_list(&self) -> ChannelList {
+        self.full_channels.infer_channel_list() // no need for adjustments, as the layer content already reflects the changes
+    }
+
+    fn infer_level_modes(&self) -> (LevelMode, RoundingMode) {
+        self.full_channels.infer_level_modes()
+    }
+
+    type Writer = CroppedWriter<Channels::Writer>;
+
+    fn create_writer(&'slf self, header: &Header) -> Self::Writer {
+        let offset = (self.cropped_bounds.position - self.full_bounds.position)
+            .to_usize("invalid cropping bounds for cropped view").unwrap();
+
+        CroppedWriter { channels: self.full_channels.create_writer(header), offset }
+    }
+}
+
+/// A writer for the cropped view layer
+#[derive(Debug, Clone, PartialEq)]
+pub struct CroppedWriter<ChannelsWriter> {
+    channels: ChannelsWriter,
+    offset: Vec2<usize>
+}
+
+impl<'c, Channels> ChannelsWriter for CroppedWriter<Channels> where Channels: ChannelsWriter {
+    fn extract_uncompressed_block(&self, header: &Header, block: BlockIndex) -> Vec<u8> {
+        let block = BlockIndex {
+            pixel_position: block.pixel_position + self.offset,
+            .. block
+        };
+
+        self.channels.extract_uncompressed_block(header, block)
+    }
+}
+
+impl<Samples, Channels> InspectSample for Layer<SpecificChannels<Samples, Channels>> where Samples: GetPixel {
+    type Sample = Samples::Pixel;
+    fn inspect_sample(&self, local_index: Vec2<usize>) -> Samples::Pixel {
+        self.channel_data.pixels.get_pixel(local_index)
+    }
+}
+
+impl InspectSample for Layer<AnyChannels<FlatSamples>> {
+    type Sample = FlatSamplesPixel;
+
+    fn inspect_sample(&self, local_index: Vec2<usize>) -> FlatSamplesPixel {
+        self.sample_vec_at(local_index)
+    }
+}
+
+// ALGORITHM IDEA: for arbitrary channels, find the most desired channel,
+// and process that first, keeping the processed bounds as starting point for the other layers
+
+/// Realize a cropped view of the original data,
+/// by actually removing the unwanted original pixels,
+/// reducing the memory consumption.
+/// Currently not supported for `SpecificChannels`.
+pub trait ApplyCroppedView {
+
+    /// The simpler type after cropping is realized
+    type Reallocated;
+
+    /// Make the cropping real by reallocating the underlying storage,
+    /// with the goal of reducing total memory usage.
+    /// Currently not supported for `SpecificChannels`.
+    fn reallocate_cropped(self) -> Self::Reallocated;
+}
+
+impl ApplyCroppedView for Layer<CroppedChannels<AnyChannels<FlatSamples>>> {
+    type Reallocated = Layer<AnyChannels<FlatSamples>>;
+
+    fn reallocate_cropped(self) -> Self::Reallocated {
+        let cropped_absolute_bounds = self.channel_data.cropped_bounds;
+        let cropped_relative_bounds = cropped_absolute_bounds.with_origin(-self.channel_data.full_bounds.position);
+
+        assert!(self.absolute_bounds().contains(cropped_absolute_bounds), "bounds not valid for layer dimensions");
+        assert!(cropped_relative_bounds.size.area() > 0, "the cropped image would be empty");
+
+        Layer {
+            channel_data: if cropped_relative_bounds.size == self.channel_data.full_bounds.size {
+                assert_eq!(cropped_absolute_bounds.position, self.channel_data.full_bounds.position, "crop bounds size equals, but position does not");
+
+                // the cropping would not remove any pixels
+                self.channel_data.full_channels
+            }
+            else {
+                let start_x = cropped_relative_bounds.position.x() as usize; // safe, because just checked above
+                let start_y = cropped_relative_bounds.position.y() as usize; // safe, because just checked above
+                let x_range = start_x .. start_x + cropped_relative_bounds.size.width();
+                let old_width = self.channel_data.full_bounds.size.width();
+                let new_height = cropped_relative_bounds.size.height();
+
+                let channels = self.channel_data.full_channels.list.into_iter().map(|channel: AnyChannel<FlatSamples>| {
+                    fn crop_samples<T:Copy>(samples: Vec<T>, old_width: usize, new_height: usize, x_range: std::ops::Range<usize>, y_start: usize) -> Vec<T> {
+                        let filtered_lines = samples.chunks_exact(old_width).skip(y_start).take(new_height);
+                        let trimmed_lines = filtered_lines.map(|line| &line[x_range.clone()]);
+                        trimmed_lines.flatten().map(|x|*x).collect() // TODO does this use memcpy?
+                    }
+
+                    let samples = match channel.sample_data {
+                        FlatSamples::F16(samples) => FlatSamples::F16(crop_samples(
+                            samples, old_width, new_height, x_range.clone(), start_y
+                        )),
+
+                        FlatSamples::F32(samples) => FlatSamples::F32(crop_samples(
+                            samples, old_width, new_height, x_range.clone(), start_y
+                        )),
+
+                        FlatSamples::U32(samples) => FlatSamples::U32(crop_samples(
+                            samples, old_width, new_height, x_range.clone(), start_y
+                        )),
+                    };
+
+                    AnyChannel { sample_data: samples, ..channel }
+                }).collect();
+
+                AnyChannels { list: channels }
+            },
+
+            attributes: self.attributes,
+            encoding: self.encoding,
+            size: self.size,
+        }
+    }
+}
+
+
+
+/// Return the smallest bounding rectangle including all pixels that satisfy the predicate.
+/// Worst case: Fully transparent image, visits each pixel once.
+/// Best case: Fully opaque image, visits two pixels.
+/// Returns `None` if the image is fully transparent.
+/// Returns `[(0,0), size]` if the image is fully opaque.
+/// Designed to be cache-friendly linear search. Optimized for row-major image vectors.
+pub fn try_find_smaller_bounds(current_bounds: IntegerBounds, pixel_at: impl Fn(Vec2<usize>) -> bool) -> Option<IntegerBounds> {
+    assert_ne!(current_bounds.size.area(), 0, "cannot find smaller bounds of an image with zero width or height");
+    let Vec2(width, height) = current_bounds.size;
+
+    // scans top to bottom (left to right)
+    let first_top_left_pixel = (0 .. height)
+        .flat_map(|y| (0 .. width).map(move |x| Vec2(x,y)))
+        .find(|&position| pixel_at(position))?; // return none if no pixel should be kept
+
+    // scans bottom to top (right to left)
+    let first_bottom_right_pixel = (first_top_left_pixel.y() + 1 .. height) // excluding the top line
+        .flat_map(|y| (0 .. width).map(move |x| Vec2(x, y))) // x search cannot start at first_top.x, because this must catch all bottom pixels
+        .rev().find(|&position| pixel_at(position))
+        .unwrap_or(first_top_left_pixel); // did not find any at bottom, but we know top has some pixel
+
+    // now we know exactly how much we can throw away top and bottom,
+    // but we don't know exactly about left or right
+    let top = first_top_left_pixel.y();
+    let bottom = first_bottom_right_pixel.y();
+
+    // we only now some arbitrary left and right bounds which we need to refine.
+    // because the actual image contents might be wider than the corner points.
+    // we know that we do not need to look in the center between min x and max x,
+    // as these must be included in any case.
+    let mut min_left_x = first_top_left_pixel.x().min(first_bottom_right_pixel.x());
+    let mut max_right_x = first_bottom_right_pixel.x().max(first_top_left_pixel.x());
+
+    // requires for loop, because bounds change while searching
+    for y in top ..= bottom {
+
+        // escape the loop if there is nothing left to crop
+        if min_left_x == 0 && max_right_x == width - 1 { break; }
+
+        // search from right image edge towards image center, until known max x, for existing pixels,
+        // possibly including some pixels that would have been cropped otherwise
+        if max_right_x != width - 1 {
+            max_right_x = (max_right_x + 1 .. width).rev() // excluding current max
+                .find(|&x| pixel_at(Vec2(x, y)))
+                .unwrap_or(max_right_x);
+        }
+
+        // search from left image edge towards image center, until known min x, for existing pixels,
+        // possibly including some pixels that would have been cropped otherwise
+        if min_left_x != 0 {
+            min_left_x = (0 .. min_left_x) // excluding current min
+                .find(|&x| pixel_at(Vec2(x, y)))
+                .unwrap_or(min_left_x);
+        }
+    }
+
+    // TODO add 1px margin to avoid interpolation issues?
+    let local_start = Vec2(min_left_x, top);
+    let local_end = Vec2(max_right_x + 1, bottom + 1);
+    Some(IntegerBounds::new(
+        current_bounds.position + local_start.to_i32(),
+        local_end - local_start
+    ))
+}
+
+impl<S> GetBounds for Layer<S> {
+    fn bounds(&self) -> IntegerBounds {
+        self.absolute_bounds()
+    }
+}
+
+impl<Cropped, Original> CropResult<Cropped, Original> {
+
+    /// If the image was fully empty, return `None`, otherwise return `Some(cropped_image)`.
+    pub fn or_none_if_empty(self) -> Option<Cropped> {
+        match self {
+            CropResult::Cropped (cropped) => Some(cropped),
+            CropResult::Empty { .. } => None,
+        }
+    }
+
+    /// If the image was fully empty, crop to one single pixel of all the transparent pixels instead,
+    /// leaving the layer intact while reducing memory usage.
+    pub fn or_crop_to_1x1_if_empty(self) -> Cropped where Original: Crop<Cropped=Cropped> + GetBounds {
+        match self {
+            CropResult::Cropped (cropped) => cropped,
+            CropResult::Empty { original } => {
+                let bounds = original.bounds();
+                if bounds.size == Vec2(0,0) { panic!("layer has width and height of zero") }
+                original.crop(IntegerBounds::new(bounds.position, Vec2(1,1)))
+            },
+        }
+    }
+}
+
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn find_bounds() {
+        fn find_bounds(offset: Vec2<i32>, lines: &Vec<Vec<i32>>) -> IntegerBounds {
+            if let Some(first_line) = lines.first() {
+                assert!(lines.iter().all(|line| line.len() == first_line.len()), "invalid test input");
+                IntegerBounds::new(offset, (first_line.len(), lines.len()))
+            }
+            else {
+                IntegerBounds::new(offset, (0,0))
+            }
+        }
+
+        fn assert_found_smaller_bounds(offset: Vec2<i32>, uncropped_lines: Vec<Vec<i32>>, expected_cropped_lines: Vec<Vec<i32>>) {
+            let old_bounds = find_bounds(offset, &uncropped_lines);
+
+            let found_bounds = try_find_smaller_bounds(
+                old_bounds,
+                |position| uncropped_lines[position.y()][position.x()] != 0
+            ).unwrap();
+
+            let found_bounds = found_bounds.with_origin(-offset); // make indices local
+
+            let cropped_lines: Vec<Vec<i32>> =
+                uncropped_lines[found_bounds.position.y() as usize .. found_bounds.end().y() as usize]
+                .iter().map(|uncropped_line|{
+                    uncropped_line[found_bounds.position.x() as usize .. found_bounds.end().x() as usize].to_vec()
+                }).collect();
+
+            assert_eq!(cropped_lines, expected_cropped_lines);
+        }
+
+        assert_found_smaller_bounds(
+            Vec2(-3,-3),
+
+            vec![
+                vec![ 2, 3, 4 ],
+                vec![ 2, 3, 4 ],
+            ],
+
+            vec![
+                vec![ 2, 3, 4 ],
+                vec![ 2, 3, 4 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-3,-3),
+
+            vec![
+                vec![ 2 ],
+            ],
+
+            vec![
+                vec![ 2 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-3,-3),
+
+            vec![
+                vec![ 0 ],
+                vec![ 2 ],
+                vec![ 0 ],
+                vec![ 0 ],
+            ],
+
+            vec![
+                vec![ 2 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-3,-3),
+
+            vec![
+                vec![ 0, 0, 0, 3, 0 ],
+            ],
+
+            vec![
+                vec![ 3 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(3,3),
+
+            vec![
+                vec![ 0, 1, 1, 2, 1, 0 ],
+                vec![ 0, 1, 3, 1, 1, 0 ],
+                vec![ 0, 1, 1, 1, 1, 0 ],
+            ],
+
+            vec![
+                vec![ 1, 1, 2, 1 ],
+                vec![ 1, 3, 1, 1 ],
+                vec![ 1, 1, 1, 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(3,3),
+
+            vec![
+                vec![ 0, 0, 0, 0 ],
+                vec![ 1, 1, 2, 1 ],
+                vec![ 1, 3, 1, 1 ],
+                vec![ 1, 1, 1, 1 ],
+                vec![ 0, 0, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 1, 1, 2, 1 ],
+                vec![ 1, 3, 1, 1 ],
+                vec![ 1, 1, 1, 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(3,3),
+
+            vec![
+                vec![ 0, 1, 1, 2, 1, 0 ],
+                vec![ 0, 0, 3, 1, 0, 0 ],
+                vec![ 0, 1, 1, 1, 1, 0 ],
+            ],
+
+            vec![
+                vec![ 1, 1, 2, 1 ],
+                vec![ 0, 3, 1, 0 ],
+                vec![ 1, 1, 1, 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(3,3),
+
+            vec![
+                vec![ 0, 0, 1, 2, 0, 0 ],
+                vec![ 0, 1, 3, 1, 1, 0 ],
+                vec![ 0, 0, 1, 1, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 0, 1, 2, 0 ],
+                vec![ 1, 3, 1, 1 ],
+                vec![ 0, 1, 1, 0 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(1,3),
+
+            vec![
+                vec![ 1, 0, 0, 0, ],
+                vec![ 0, 0, 0, 0, ],
+                vec![ 0, 0, 0, 0, ],
+            ],
+
+            vec![
+                vec![ 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(1,3),
+
+            vec![
+                vec![ 0, 0, 0, 0, ],
+                vec![ 0, 1, 0, 0, ],
+                vec![ 0, 0, 0, 0, ],
+            ],
+
+            vec![
+                vec![ 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-1,-3),
+
+            vec![
+                vec![ 0, 0, 0, 0, ],
+                vec![ 0, 0, 0, 1, ],
+                vec![ 0, 0, 0, 0, ],
+            ],
+
+            vec![
+                vec![ 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-1,-3),
+
+            vec![
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 1, 1, 1, 0, 0 ],
+                vec![ 0, 0, 1, 1, 1, 0, 0 ],
+                vec![ 0, 0, 1, 1, 1, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 1, 1, 1 ],
+                vec![ 1, 1, 1 ],
+                vec![ 1, 1, 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(1000,-300),
+
+            vec![
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 1, 1, 1, 0, 0 ],
+                vec![ 0, 1, 1, 1, 1, 1, 0 ],
+                vec![ 0, 0, 1, 1, 1, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 0, 1, 1, 1, 0 ],
+                vec![ 1, 1, 1, 1, 1 ],
+                vec![ 0, 1, 1, 1, 0 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-10,-300),
+
+            vec![
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 1, 0, 1, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 1, 0, 1, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 1, 0, 1 ],
+                vec![ 0, 0, 0 ],
+                vec![ 1, 0, 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-10,-300),
+
+            vec![
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 1, 0, 1, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 1, 0, 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-10,-300),
+
+            vec![
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 1, 0, 0, 0 ],
+                vec![ 0, 0, 0, 2, 0, 0, 0 ],
+                vec![ 0, 0, 3, 3, 3, 0, 0 ],
+                vec![ 0, 0, 0, 4, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 0, 1, 0 ],
+                vec![ 0, 2, 0 ],
+                vec![ 3, 3, 3 ],
+                vec![ 0, 4, 0 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-10,-300),
+
+            vec![
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 1, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 1, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 0, 0, 1 ],
+                vec![ 0, 0, 0 ],
+                vec![ 0, 0, 0 ],
+                vec![ 1, 0, 0 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-10,-300),
+
+            vec![
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 1, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 1, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 1, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 1 ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-10,-300),
+
+            vec![
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 1, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+                vec![ 0, 0, 1, 0, 0, 0, 0 ],
+                vec![ 0, 0, 0, 0, 0, 0, 0 ],
+            ],
+
+            vec![
+                vec![ 1 ],
+                vec![ 0 ],
+                vec![ 0 ],
+                vec![ 1 ],
+            ]
+        );
+
+
+        assert_found_smaller_bounds(
+            Vec2(-1,-3),
+
+            vec![
+                vec![ 0, 0, 1, 0, ],
+                vec![ 0, 0, 0, 1, ],
+                vec![ 0, 0, 0, 0, ],
+            ],
+
+            vec![
+                vec![ 1, 0, ],
+                vec![ 0, 1, ],
+            ]
+        );
+
+        assert_found_smaller_bounds(
+            Vec2(-1,-3),
+
+            vec![
+                vec![ 1, 0, 0, 0, ],
+                vec![ 0, 1, 0, 0, ],
+                vec![ 0, 0, 0, 0, ],
+                vec![ 0, 0, 0, 0, ],
+            ],
+
+            vec![
+                vec![ 1, 0, ],
+                vec![ 0, 1, ],
+            ]
+        );
+    }
+
+
+    #[test]
+    fn find_no_bounds() {
+        let pixels = vec![
+            vec![ 0, 0, 0, 0 ],
+            vec![ 0, 0, 0, 0 ],
+            vec![ 0, 0, 0, 0 ],
+        ];
+
+        let bounds = try_find_smaller_bounds(
+            IntegerBounds::new((0,0), (4,3)),
+            |position| pixels[position.y()][position.x()] != 0
+        );
+
+        assert_eq!(bounds, None)
+    }
+
+}
+
+
+
+
diff --git a/vendor/exr/src/image/mod.rs b/vendor/exr/src/image/mod.rs
new file mode 100644
index 0000000..db75050
--- /dev/null
+++ b/vendor/exr/src/image/mod.rs
@@ -0,0 +1,1326 @@
+
+//! Data structures that represent a complete exr image.
+//! Contains generic structs that must be nested to obtain a complete image type.
+//!
+//!
+//! For example, an rgba image containing multiple layers
+//! can be represented using `Image<Layers<SpecificChannels<MyPixelStorage>>>`.
+//! An image containing a single layer with arbitrary channels and no deep data
+//! can be represented using `Image<Layer<AnyChannels<FlatSamples>>>`.
+//!
+//!
+//! These and other predefined types are included in this module as
+//! 1. `PixelImage`: A single layer, fixed set of arbitrary channels.
+//! 1. `PixelLayersImage`: Multiple layers, fixed set of arbitrary channels.
+//! 1. `RgbaImage`: A single layer, fixed set of channels: rgb, optional a.
+//! 1. `RgbaLayersImage`: Multiple layers, fixed set of channels: rgb, optional a.
+//! 1. `FlatImage`: Multiple layers, any channels, no deep data.
+//! 1. `AnyImage`: All supported data (multiple layers, arbitrary channels, no deep data yet)
+//!
+//! You can also use your own types inside an image,
+//! for example if you want to use a custom sample storage.
+//!
+//! This is the high-level interface for the pixels of an image.
+//! See `exr::blocks` module for a low-level interface.
+
+pub mod read;
+pub mod write;
+pub mod crop;
+pub mod pixel_vec;
+pub mod recursive;
+// pub mod channel_groups;
+
+
+use crate::meta::header::{ImageAttributes, LayerAttributes};
+use crate::meta::attribute::{Text, LineOrder};
+use half::f16;
+use crate::math::{Vec2, RoundingMode};
+use crate::compression::Compression;
+use smallvec::{SmallVec};
+use crate::error::Error;
+
+/// Don't do anything
+pub(crate) fn ignore_progress(_progress: f64){}
+
+/// This image type contains all supported exr features and can represent almost any image.
+/// It currently does not support deep data yet.
+pub type AnyImage = Image<Layers<AnyChannels<Levels<FlatSamples>>>>;
+
+/// This image type contains the most common exr features and can represent almost any plain image.
+/// Does not contain resolution levels. Does not support deep data.
+pub type FlatImage = Image<Layers<AnyChannels<FlatSamples>>>;
+
+/// This image type contains multiple layers, with each layer containing a user-defined type of pixels.
+pub type PixelLayersImage<Storage, Channels> = Image<Layers<SpecificChannels<Storage, Channels>>>;
+
+/// This image type contains a single layer containing a user-defined type of pixels.
+pub type PixelImage<Storage, Channels> = Image<Layer<SpecificChannels<Storage, Channels>>>;
+
+/// This image type contains multiple layers, with each layer containing a user-defined type of rgba pixels.
+pub type RgbaLayersImage<Storage> = PixelLayersImage<Storage, RgbaChannels>;
+
+/// This image type contains a single layer containing a user-defined type of rgba pixels.
+pub type RgbaImage<Storage> = PixelImage<Storage, RgbaChannels>;
+
+/// Contains information about the channels in an rgba image, in the order `(red, green, blue, alpha)`.
+/// The alpha channel is not required. May be `None` if the image did not contain an alpha channel.
+pub type RgbaChannels = (ChannelDescription, ChannelDescription, ChannelDescription, Option<ChannelDescription>);
+
+/// Contains information about the channels in an rgb image, in the order `(red, green, blue)`.
+pub type RgbChannels = (ChannelDescription, ChannelDescription, ChannelDescription);
+
+/// The complete exr image.
+/// `Layers` can be either a single `Layer` or `Layers`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Image<Layers> {
+
+    /// Attributes that apply to the whole image file.
+    /// These attributes appear in each layer of the file.
+    /// Excludes technical meta data.
+    /// Each layer in this image also has its own attributes.
+    pub attributes: ImageAttributes,
+
+    /// The layers contained in the image file.
+    /// Can be either a single `Layer` or a list of layers.
+    pub layer_data: Layers,
+}
+
+/// A list of layers. `Channels` can be `SpecificChannels` or `AnyChannels`.
+pub type Layers<Channels> = SmallVec<[Layer<Channels>; 2]>;
+
+/// A single Layer, including fancy attributes and compression settings.
+/// `Channels` can be either `SpecificChannels` or `AnyChannels`
+#[derive(Debug, Clone, PartialEq)]
+pub struct Layer<Channels> {
+
+    /// The actual pixel data. Either `SpecificChannels` or `AnyChannels`
+    pub channel_data: Channels,
+
+    /// Attributes that apply to this layer.
+    /// May still contain attributes that should be considered global for an image file.
+    /// Excludes technical meta data: Does not contain data window size, line order, tiling, or compression attributes.
+    /// The image also has attributes, which do not differ per layer.
+    pub attributes: LayerAttributes,
+
+    /// The pixel resolution of this layer.
+    /// See `layer.attributes` for more attributes, like for example layer position.
+    pub size: Vec2<usize>,
+
+    /// How the pixels are split up and compressed.
+    pub encoding: Encoding
+}
+
+/// How the pixels are split up and compressed.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct Encoding {
+
+    /// How the pixel data of all channels in this layer is compressed. May be `Compression::Uncompressed`.
+    /// See `layer.attributes` for more attributes.
+    pub compression: Compression,
+
+    /// Describes how the pixels of this layer are divided into smaller blocks.
+    /// Either splits the image into its scan lines or splits the image into tiles of the specified size.
+    /// A single block can be loaded without processing all bytes of a file.
+    pub blocks: Blocks,
+
+    /// In what order the tiles of this header occur in the file.
+    /// Does not change any actual image orientation.
+    /// See `layer.attributes` for more attributes.
+    pub line_order: LineOrder,
+}
+
+/// How the image pixels are split up into separate blocks.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum Blocks {
+
+    /// The image is divided into scan line blocks.
+    /// The number of scan lines in a block depends on the compression method.
+    ScanLines,
+
+    /// The image is divided into tile blocks.
+    /// Also specifies the size of each tile in the image
+    /// and whether this image contains multiple resolution levels.
+    ///
+    /// The inner `Vec2` describes the size of each tile.
+    /// Stays the same number of pixels across all levels.
+    Tiles (Vec2<usize>)
+}
+
+
+/// A grid of pixels. The pixels are written to your custom pixel storage.
+/// `PixelStorage` can be anything, from a flat `Vec<f16>` to `Vec<Vec<AnySample>>`, as desired.
+/// In order to write this image to a file, your `PixelStorage` must implement [`GetPixel`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SpecificChannels<Pixels, ChannelsDescription> {
+
+    /// A description of the channels in the file, as opposed to the channels in memory.
+    /// Should always be a tuple containing `ChannelDescription`s, one description for each channel.
+    pub channels: ChannelsDescription, // TODO this is awkward. can this be not a type parameter please? maybe vec<option<chan_info>> ??
+
+    /// Your custom pixel storage
+    // TODO should also support `Levels<YourStorage>`, where levels are desired!
+    pub pixels: Pixels, // TODO rename to "pixels"?
+}
+
+
+/// A dynamic list of arbitrary channels.
+/// `Samples` can currently only be `FlatSamples` or `Levels<FlatSamples>`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct AnyChannels<Samples> {
+
+    /// This list must be sorted alphabetically, by channel name.
+    /// Use `AnyChannels::sorted` for automatic sorting.
+    pub list: SmallVec<[AnyChannel<Samples>; 4]>
+}
+
+/// A single arbitrary channel.
+/// `Samples` can currently only be `FlatSamples` or `Levels<FlatSamples>`
+#[derive(Debug, Clone, PartialEq)]
+pub struct AnyChannel<Samples> {
+
+    /// One of "R", "G", or "B" most of the time.
+    pub name: Text,
+
+    /// The actual pixel data.
+    /// Can be `FlatSamples` or `Levels<FlatSamples>`.
+    pub sample_data: Samples,
+
+    /// This attribute only tells lossy compression methods
+    /// whether this value should be quantized exponentially or linearly.
+    ///
+    /// Should be `false` for red, green, blue and luma channels, as they are not perceived linearly.
+    /// Should be `true` for hue, chroma, saturation, and alpha channels.
+    pub quantize_linearly: bool,
+
+    /// How many of the samples are skipped compared to the other channels in this layer.
+    ///
+    /// Can be used for chroma subsampling for manual lossy data compression.
+    /// Values other than 1 are allowed only in flat, scan-line based images.
+    /// If an image is deep or tiled, the sampling rates for all of its channels must be 1.
+    pub sampling: Vec2<usize>,
+}
+
+/// One or multiple resolution levels of the same image.
+/// `Samples` can be `FlatSamples`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Levels<Samples> {
+
+    /// A single image without smaller versions of itself.
+    /// If you only want to handle exclusively this case, use `Samples` directly, and not `Levels<Samples>`.
+    Singular(Samples),
+
+    /// Contains uniformly scaled smaller versions of the original.
+    Mip
+    {
+        /// Whether to round up or down when calculating Mip/Rip levels.
+        rounding_mode: RoundingMode,
+
+        /// The smaller versions of the original.
+        level_data: LevelMaps<Samples>
+    },
+
+    /// Contains any possible combination of smaller versions of the original.
+    Rip
+    {
+        /// Whether to round up or down when calculating Mip/Rip levels.
+        rounding_mode: RoundingMode,
+
+        /// The smaller versions of the original.
+        level_data: RipMaps<Samples>
+    },
+}
+
+/// A list of resolution levels. `Samples` can currently only be `FlatSamples`.
+// or `DeepAndFlatSamples` (not yet implemented).
+pub type LevelMaps<Samples> = Vec<Samples>;
+
+/// In addition to the full resolution image,
+/// this layer also contains smaller versions,
+/// and each smaller version has further versions with varying aspect ratios.
+/// `Samples` can currently only be `FlatSamples`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RipMaps<Samples> {
+
+    /// A flattened list containing the individual levels
+    pub map_data: LevelMaps<Samples>,
+
+    /// The number of levels that were generated along the x-axis and y-axis.
+    pub level_count: Vec2<usize>,
+}
+
+
+// TODO deep data
+/*#[derive(Clone, PartialEq)]
+pub enum DeepAndFlatSamples {
+    Deep(DeepSamples),
+    Flat(FlatSamples)
+}*/
+
+/// A vector of non-deep values (one value per pixel per channel).
+/// Stores row after row in a single vector.
+/// The precision of all values is either `f16`, `f32` or `u32`.
+///
+/// Since this is close to the pixel layout in the byte file,
+/// this will most likely be the fastest storage.
+/// Using a different storage, for example `SpecificChannels`,
+/// will probably be slower.
+#[derive(Clone, PartialEq)] // debug is implemented manually
+pub enum FlatSamples {
+
+    /// A vector of non-deep `f16` values.
+    F16(Vec<f16>),
+
+    /// A vector of non-deep `f32` values.
+    F32(Vec<f32>),
+
+    /// A vector of non-deep `u32` values.
+    U32(Vec<u32>),
+}
+
+
+/*#[derive(Clone, PartialEq)]
+pub enum DeepSamples {
+    F16(Vec<Vec<f16>>),
+    F32(Vec<Vec<f32>>),
+    U32(Vec<Vec<u32>>),
+}*/
+
+use crate::block::samples::*;
+use crate::meta::attribute::*;
+use crate::error::Result;
+use crate::block::samples::Sample;
+use crate::image::write::channels::*;
+use crate::image::write::layers::WritableLayers;
+use crate::image::write::samples::{WritableSamples};
+use crate::meta::{mip_map_levels, rip_map_levels};
+use crate::io::Data;
+use crate::image::recursive::{NoneMore, Recursive, IntoRecursive};
+use std::marker::PhantomData;
+use std::ops::Not;
+use crate::image::validate_results::{ValidationOptions};
+
+
+impl<Channels> Layer<Channels> {
+    /// Sometimes called "data window"
+    pub fn absolute_bounds(&self) -> IntegerBounds {
+        IntegerBounds::new(self.attributes.layer_position, self.size)
+    }
+}
+
+
+impl<SampleStorage, Channels> SpecificChannels<SampleStorage, Channels> {
+    /// Create some pixels with channel information.
+    /// The `Channels` must be a tuple containing either `ChannelDescription` or `Option<ChannelDescription>`.
+    /// The length of the tuple dictates the number of channels in the sample storage.
+    pub fn new(channels: Channels, source_samples: SampleStorage) -> Self
+        where
+            SampleStorage: GetPixel,
+            SampleStorage::Pixel: IntoRecursive,
+            Channels: Sync + Clone + IntoRecursive,
+            <Channels as IntoRecursive>::Recursive: WritableChannelsDescription<<SampleStorage::Pixel as IntoRecursive>::Recursive>,
+    {
+        SpecificChannels { channels, pixels: source_samples }
+    }
+}
+
+/// Convert this type into one of the known sample types.
+/// Also specify the preferred native type, which dictates the default sample type in the image.
+pub trait IntoSample: IntoNativeSample {
+
+    /// The native sample types that this type should be converted to.
+    const PREFERRED_SAMPLE_TYPE: SampleType;
+}
+
+impl IntoSample for f16 { const PREFERRED_SAMPLE_TYPE: SampleType = SampleType::F16; }
+impl IntoSample for f32 { const PREFERRED_SAMPLE_TYPE: SampleType = SampleType::F32; }
+impl IntoSample for u32 { const PREFERRED_SAMPLE_TYPE: SampleType = SampleType::U32; }
+
+/// Used to construct a `SpecificChannels`.
+/// Call `with_named_channel` as many times as desired,
+/// and then call `with_pixels` to define the colors.
+#[derive(Debug)]
+pub struct SpecificChannelsBuilder<RecursiveChannels, RecursivePixel> {
+    channels: RecursiveChannels,
+    px: PhantomData<RecursivePixel>
+}
+
+/// This check can be executed at compile time
+/// if the channel names are `&'static str` and the compiler is smart enough.
+pub trait CheckDuplicates {
+
+    /// Check for duplicate channel names.
+    fn already_contains(&self, name: &Text) -> bool;
+}
+
+impl CheckDuplicates for NoneMore {
+    fn already_contains(&self, _: &Text) -> bool { false }
+}
+
+impl<Inner: CheckDuplicates> CheckDuplicates for Recursive<Inner, ChannelDescription> {
+    fn already_contains(&self, name: &Text) -> bool {
+        &self.value.name == name || self.inner.already_contains(name)
+    }
+}
+
+impl SpecificChannels<(),()>
+{
+    /// Start building some specific channels. On the result of this function,
+    /// call `with_named_channel` as many times as desired,
+    /// and then call `with_pixels` to define the colors.
+    pub fn build() -> SpecificChannelsBuilder<NoneMore, NoneMore> {
+        SpecificChannelsBuilder { channels: NoneMore, px: Default::default() }
+    }
+}
+
+impl<RecursiveChannels: CheckDuplicates, RecursivePixel> SpecificChannelsBuilder<RecursiveChannels, RecursivePixel>
+{
+    /// Add another channel to this image. Does not add the actual pixels,
+    /// but instead only declares the presence of the channel.
+    /// Panics if the name contains unsupported characters.
+    /// Panics if a channel with the same name already exists.
+    /// Use `Text::new_or_none()` to manually handle these cases.
+    /// Use `with_channel_details` instead if you want to specify more options than just the name of the channel.
+    /// The generic parameter can usually be inferred from the closure in `with_pixels`.
+    pub fn with_channel<Sample: IntoSample>(self, name: impl Into<Text>)
+                                            -> SpecificChannelsBuilder<Recursive<RecursiveChannels, ChannelDescription>, Recursive<RecursivePixel, Sample>>
+    {
+        self.with_channel_details::<Sample>(ChannelDescription::named(name, Sample::PREFERRED_SAMPLE_TYPE))
+    }
+
+    /// Add another channel to this image. Does not add the actual pixels,
+    /// but instead only declares the presence of the channel.
+    /// Use `with_channel` instead if you only want to specify the name of the channel.
+    /// Panics if a channel with the same name already exists.
+    /// The generic parameter can usually be inferred from the closure in `with_pixels`.
+    pub fn with_channel_details<Sample: Into<Sample>>(self, channel: ChannelDescription)
+        -> SpecificChannelsBuilder<Recursive<RecursiveChannels, ChannelDescription>, Recursive<RecursivePixel, Sample>>
+    {
+        // duplicate channel names are checked later, but also check now to make sure there are no problems with the `SpecificChannelsWriter`
+        assert!(self.channels.already_contains(&channel.name).not(), "channel name `{}` is duplicate", channel.name);
+
+        SpecificChannelsBuilder {
+            channels: Recursive::new(self.channels, channel),
+            px: PhantomData::default()
+        }
+    }
+
+    /// Specify the actual pixel contents of the image.
+    /// You can pass a closure that returns a color for each pixel (`Fn(Vec2<usize>) -> Pixel`),
+    /// or you can pass your own image if it implements `GetPixel`.
+    /// The pixel type must be a tuple with the correct number of entries, depending on the number of channels.
+    /// The tuple entries can be either `f16`, `f32`, `u32` or `Sample`.
+    /// Use `with_pixel_fn` instead of this function, to get extra type safety for your pixel closure.
+    pub fn with_pixels<Pixels>(self, get_pixel: Pixels) -> SpecificChannels<Pixels, RecursiveChannels>
+        where Pixels: GetPixel, <Pixels as GetPixel>::Pixel: IntoRecursive<Recursive=RecursivePixel>,
+    {
+        SpecificChannels {
+            channels: self.channels,
+            pixels: get_pixel
+        }
+    }
+
+    /// Specify the contents of the image.
+    /// The pixel type must be a tuple with the correct number of entries, depending on the number of channels.
+    /// The tuple entries can be either `f16`, `f32`, `u32` or `Sample`.
+    /// Use `with_pixels` instead of this function, if you want to pass an object that is not a closure.
+    ///
+    /// Usually, the compiler can infer the type of the pixel (for example, `f16,f32,f32`) from the closure.
+    /// If that's not possible, you can specify the type of the channels
+    /// when declaring the channel (for example, `with_named_channel::<f32>("R")`).
+    pub fn with_pixel_fn<Pixel, Pixels>(self, get_pixel: Pixels) -> SpecificChannels<Pixels, RecursiveChannels>
+        where Pixels: Sync + Fn(Vec2<usize>) -> Pixel, Pixel: IntoRecursive<Recursive=RecursivePixel>,
+    {
+        SpecificChannels {
+            channels: self.channels,
+            pixels: get_pixel
+        }
+    }
+}
+
+impl<SampleStorage> SpecificChannels<
+    SampleStorage, (ChannelDescription, ChannelDescription, ChannelDescription, ChannelDescription)
+>
+{
+
+    /// Create an image with red, green, blue, and alpha channels.
+    /// You can pass a closure that returns a color for each pixel (`Fn(Vec2<usize>) -> (R,G,B,A)`),
+    /// or you can pass your own image if it implements `GetPixel<Pixel=(R,G,B,A)>`.
+    /// Each of `R`, `G`, `B` and `A` can be either `f16`, `f32`, `u32`, or `Sample`.
+    pub fn rgba<R, G, B, A>(source_samples: SampleStorage) -> Self
+        where R: IntoSample, G: IntoSample,
+              B: IntoSample, A: IntoSample,
+              SampleStorage: GetPixel<Pixel=(R, G, B, A)>
+    {
+        SpecificChannels {
+            channels: (
+                ChannelDescription::named("R", R::PREFERRED_SAMPLE_TYPE),
+                ChannelDescription::named("G", G::PREFERRED_SAMPLE_TYPE),
+                ChannelDescription::named("B", B::PREFERRED_SAMPLE_TYPE),
+                ChannelDescription::named("A", A::PREFERRED_SAMPLE_TYPE),
+            ),
+            pixels: source_samples
+        }
+    }
+}
+
+impl<SampleStorage> SpecificChannels<
+    SampleStorage, (ChannelDescription, ChannelDescription, ChannelDescription)
+>
+{
+
+    /// Create an image with red, green, and blue channels.
+    /// You can pass a closure that returns a color for each pixel (`Fn(Vec2<usize>) -> (R,G,B)`),
+    /// or you can pass your own image if it implements `GetPixel<Pixel=(R,G,B)>`.
+    /// Each of `R`, `G` and `B` can be either `f16`, `f32`, `u32`, or `Sample`.
+    pub fn rgb<R, G, B>(source_samples: SampleStorage) -> Self
+        where R: IntoSample, G: IntoSample, B: IntoSample,
+              SampleStorage: GetPixel<Pixel=(R, G, B)>
+    {
+        SpecificChannels {
+            channels: (
+                ChannelDescription::named("R", R::PREFERRED_SAMPLE_TYPE),
+                ChannelDescription::named("G", G::PREFERRED_SAMPLE_TYPE),
+                ChannelDescription::named("B", B::PREFERRED_SAMPLE_TYPE),
+            ),
+            pixels: source_samples
+        }
+    }
+}
+
+
+/// A list of samples representing a single pixel.
+/// Does not heap allocate for images with 8 or fewer channels.
+pub type FlatSamplesPixel = SmallVec<[Sample; 8]>;
+
+// TODO also deep samples?
+impl Layer<AnyChannels<FlatSamples>> {
+
+    /// Use `samples_at` if you can borrow from this layer
+    pub fn sample_vec_at(&self, position: Vec2<usize>) -> FlatSamplesPixel {
+        self.samples_at(position).collect()
+    }
+
+    /// Lookup all channels of a single pixel in the image
+    pub fn samples_at(&self, position: Vec2<usize>) -> FlatSampleIterator<'_> {
+        FlatSampleIterator {
+            layer: self,
+            channel_index: 0,
+            position
+        }
+    }
+}
+
+/// Iterate over all channels of a single pixel in the image
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct FlatSampleIterator<'s> {
+    layer: &'s Layer<AnyChannels<FlatSamples>>,
+    channel_index: usize,
+    position: Vec2<usize>,
+}
+
+impl Iterator for FlatSampleIterator<'_> {
+    type Item = Sample;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.channel_index < self.layer.channel_data.list.len() {
+            let channel = &self.layer.channel_data.list[self.channel_index];
+            let sample = channel.sample_data.value_by_flat_index(self.position.flat_index_for_size(self.layer.size));
+            self.channel_index += 1;
+            Some(sample)
+        }
+        else { None }
+    }
+
+    fn nth(&mut self, pos: usize) -> Option<Self::Item> {
+        self.channel_index += pos;
+        self.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.layer.channel_data.list.len().saturating_sub(self.channel_index);
+        (remaining, Some(remaining))
+    }
+}
+
+impl ExactSizeIterator for FlatSampleIterator<'_> {}
+
+impl<SampleData> AnyChannels<SampleData>{
+
+    /// A new list of arbitrary channels. Sorts the list to make it alphabetically stable.
+    pub fn sort(mut list: SmallVec<[AnyChannel<SampleData>; 4]>) -> Self {
+        list.sort_unstable_by_key(|channel| channel.name.clone()); // TODO no clone?
+        Self { list }
+    }
+}
+
+// FIXME check content size of layer somewhere??? before writing?
+impl<LevelSamples> Levels<LevelSamples> {
+
+    /// Get a resolution level by index, sorted by size, decreasing.
+    pub fn get_level(&self, level: Vec2<usize>) -> Result<&LevelSamples> {
+        match self {
+            Levels::Singular(block) => {
+                debug_assert_eq!(level, Vec2(0,0), "singular image cannot write leveled blocks bug");
+                Ok(block)
+            },
+
+            Levels::Mip { level_data, .. } => {
+                debug_assert_eq!(level.x(), level.y(), "mip map levels must be equal on x and y bug");
+                level_data.get(level.x()).ok_or(Error::invalid("block mip level index"))
+            },
+
+            Levels::Rip { level_data, .. } => {
+                level_data.get_by_level(level).ok_or(Error::invalid("block rip level index"))
+            }
+        }
+    }
+
+    /// Get a resolution level by index, sorted by size, decreasing.
+    // TODO storage order for RIP maps?
+    pub fn get_level_mut(&mut self, level: Vec2<usize>) -> Result<&mut LevelSamples> {
+        match self {
+            Levels::Singular(ref mut block) => {
+                debug_assert_eq!(level, Vec2(0,0), "singular image cannot write leveled blocks bug");
+                Ok(block)
+            },
+
+            Levels::Mip { level_data, .. } => {
+                debug_assert_eq!(level.x(), level.y(), "mip map levels must be equal on x and y bug");
+                level_data.get_mut(level.x()).ok_or(Error::invalid("block mip level index"))
+            },
+
+            Levels::Rip { level_data, .. } => {
+                level_data.get_by_level_mut(level).ok_or(Error::invalid("block rip level index"))
+            }
+        }
+    }
+
+    /// Get a slice of all resolution levels, sorted by size, decreasing.
+    pub fn levels_as_slice(&self) -> &[LevelSamples] {
+        match self {
+            Levels::Singular(data) => std::slice::from_ref(data),
+            Levels::Mip { level_data, .. } => level_data,
+            Levels::Rip { level_data, .. } => &level_data.map_data,
+        }
+    }
+
+    /// Get a mutable slice of all resolution levels, sorted by size, decreasing.
+    pub fn levels_as_slice_mut(&mut self) -> &mut [LevelSamples] {
+        match self {
+            Levels::Singular(data) => std::slice::from_mut(data),
+            Levels::Mip { level_data, .. } => level_data,
+            Levels::Rip { level_data, .. } => &mut level_data.map_data,
+        }
+    }
+
+    // TODO simplify working with levels in general! like level_size_by_index and such
+
+    /*pub fn levels_with_size(&self, rounding: RoundingMode, max_resolution: Vec2<usize>) -> Vec<(Vec2<usize>, &S)> {
+        match self {
+            Levels::Singular(ref data) => vec![ (max_resolution, data) ],
+            Levels::Mip(ref maps) => mip_map_levels(rounding, max_resolution).map(|(_index, size)| size).zip(maps).collect(),
+            Levels::Rip(ref rip_maps) => rip_map_levels(rounding, max_resolution).map(|(_index, size)| size).zip(&rip_maps.map_data).collect(),
+        }
+    }*/
+
+    /// Whether this stores multiple resolution levels.
+    pub fn level_mode(&self) -> LevelMode {
+        match self {
+            Levels::Singular(_) => LevelMode::Singular,
+            Levels::Mip { .. } => LevelMode::MipMap,
+            Levels::Rip { .. } => LevelMode::RipMap,
+        }
+    }
+}
+
+impl<Samples> RipMaps<Samples> {
+
+    /// Flatten the 2D level index to a one dimensional index.
+    pub fn get_level_index(&self, level: Vec2<usize>) -> usize {
+        level.flat_index_for_size(self.level_count)
+    }
+
+    /// Return a level by level index. Level `0` has the largest resolution.
+    pub fn get_by_level(&self, level: Vec2<usize>) -> Option<&Samples> {
+        self.map_data.get(self.get_level_index(level))
+    }
+
+    /// Return a mutable level reference by level index. Level `0` has the largest resolution.
+    pub fn get_by_level_mut(&mut self, level: Vec2<usize>) -> Option<&mut Samples> {
+        let index = self.get_level_index(level);
+        self.map_data.get_mut(index)
+    }
+}
+
+impl FlatSamples {
+
+    /// The number of samples in the image. Should be the width times the height.
+    /// Might vary when subsampling is used.
+    pub fn len(&self) -> usize {
+        match self {
+            FlatSamples::F16(vec) => vec.len(),
+            FlatSamples::F32(vec) => vec.len(),
+            FlatSamples::U32(vec) => vec.len(),
+        }
+    }
+
+    /// Views all samples in this storage as f32.
+    /// Matches the underlying sample type again for every sample,
+    /// match yourself if performance is critical! Does not allocate.
+    pub fn values_as_f32<'s>(&'s self) -> impl 's + Iterator<Item = f32> {
+        self.values().map(|sample| sample.to_f32())
+    }
+
+    /// All samples in this storage as iterator.
+    /// Matches the underlying sample type again for every sample,
+    /// match yourself if performance is critical! Does not allocate.
+    pub fn values<'s>(&'s self) -> impl 's + Iterator<Item = Sample> {
+        (0..self.len()).map(move |index| self.value_by_flat_index(index))
+    }
+
+    /// Lookup a single value, by flat index.
+    /// The flat index can be obtained using `Vec2::flatten_for_width`
+    /// which computes the index in a flattened array of pixel rows.
+    pub fn value_by_flat_index(&self, index: usize) -> Sample {
+        match self {
+            FlatSamples::F16(vec) => Sample::F16(vec[index]),
+            FlatSamples::F32(vec) => Sample::F32(vec[index]),
+            FlatSamples::U32(vec) => Sample::U32(vec[index]),
+        }
+    }
+}
+
+
+impl<'s, ChannelData:'s> Layer<ChannelData> {
+
+    /// Create a layer with the specified size, attributes, encoding and channels.
+    /// The channels can be either `SpecificChannels` or `AnyChannels`.
+    pub fn new(
+        dimensions: impl Into<Vec2<usize>>,
+        attributes: LayerAttributes,
+        encoding: Encoding,
+        channels: ChannelData
+    ) -> Self
+        where ChannelData: WritableChannels<'s>
+    {
+        Layer { channel_data: channels, attributes, size: dimensions.into(), encoding }
+    }
+
+    // TODO test pls wtf
+    /// Panics for images with Scanline encoding.
+    pub fn levels_with_resolution<'l, L>(&self, levels: &'l Levels<L>) -> Box<dyn 'l + Iterator<Item=(&'l L, Vec2<usize>)>> {
+        match levels {
+            Levels::Singular(level) => Box::new(std::iter::once((level, self.size))),
+
+            Levels::Mip { rounding_mode, level_data } => Box::new(level_data.iter().zip(
+                mip_map_levels(*rounding_mode, self.size)
+                    .map(|(_index, size)| size)
+            )),
+
+            Levels::Rip { rounding_mode, level_data } => Box::new(level_data.map_data.iter().zip(
+                rip_map_levels(*rounding_mode, self.size)
+                    .map(|(_index, size)| size)
+            )),
+        }
+    }
+}
+
+impl Encoding {
+
+    /// No compression. Massive space requirements.
+    /// Fast, because it minimizes data shuffling and reallocation.
+    pub const UNCOMPRESSED: Encoding = Encoding {
+        compression: Compression::Uncompressed,
+        blocks: Blocks::ScanLines, // longest lines, faster memcpy
+        line_order: LineOrder::Increasing // presumably fastest?
+    };
+
+    /// Run-length encoding with tiles of 64x64 pixels. This is the recommended default encoding.
+    /// Almost as fast as uncompressed data, but optimizes single-colored areas such as mattes and masks.
+    pub const FAST_LOSSLESS: Encoding = Encoding {
+        compression: Compression::RLE,
+        blocks: Blocks::Tiles(Vec2(64, 64)), // optimize for RLE compression
+        line_order: LineOrder::Unspecified
+    };
+
+    /// ZIP compression with blocks of 16 lines. Slow, but produces small files without visible artefacts.
+    pub const SMALL_LOSSLESS: Encoding = Encoding {
+        compression: Compression::ZIP16,
+        blocks: Blocks::ScanLines, // largest possible, but also with high probability of parallel workers
+        line_order: LineOrder::Increasing
+    };
+
+    /// PIZ compression with tiles of 256x256 pixels. Small images, not too slow.
+    pub const SMALL_FAST_LOSSLESS: Encoding = Encoding {
+        compression: Compression::PIZ,
+        blocks: Blocks::Tiles(Vec2(256, 256)),
+        line_order: LineOrder::Unspecified
+    };
+}
+
+impl Default for Encoding {
+    fn default() -> Self { Encoding::FAST_LOSSLESS }
+}
+
+impl<'s, LayerData: 's> Image<LayerData> where LayerData: WritableLayers<'s> {
+    /// Create an image with one or multiple layers. The layer can be a `Layer`, or `Layers` small vector, or `Vec<Layer>` or `&[Layer]`.
+    pub fn new(image_attributes: ImageAttributes, layer_data: LayerData) -> Self {
+        Image { attributes: image_attributes, layer_data }
+    }
+}
+
+// explorable constructor alias
+impl<'s, Channels: 's> Image<Layers<Channels>> where Channels: WritableChannels<'s> {
+    /// Create an image with multiple layers. The layer can be a `Vec<Layer>` or `Layers` (a small vector).
+    pub fn from_layers(image_attributes: ImageAttributes, layer_data: impl Into<Layers<Channels>>) -> Self {
+        Self::new(image_attributes, layer_data.into())
+    }
+}
+
+
+impl<'s, ChannelData:'s> Image<Layer<ChannelData>> where ChannelData: WritableChannels<'s> {
+
+    /// Uses the display position and size to the channel position and size of the layer.
+    pub fn from_layer(layer: Layer<ChannelData>) -> Self {
+        let bounds = IntegerBounds::new(layer.attributes.layer_position, layer.size);
+        Self::new(ImageAttributes::new(bounds), layer)
+    }
+
+    /// Uses empty attributes.
+    pub fn from_encoded_channels(size: impl Into<Vec2<usize>>, encoding: Encoding, channels: ChannelData) -> Self {
+        // layer name is not required for single-layer images
+        Self::from_layer(Layer::new(size, LayerAttributes::default(), encoding, channels))
+    }
+
+    /// Uses empty attributes and fast compression.
+    pub fn from_channels(size: impl Into<Vec2<usize>>, channels: ChannelData) -> Self {
+        Self::from_encoded_channels(size, Encoding::default(), channels)
+    }
+}
+
+
+impl Image<NoneMore> {
+
+    /// Create an empty image, to be filled with layers later on. Add at least one layer to obtain a valid image.
+    /// Call `with_layer(another_layer)` for each layer you want to add to this image.
+    pub fn empty(attributes: ImageAttributes) -> Self { Self { attributes, layer_data: NoneMore } }
+}
+
+impl<'s, InnerLayers: 's> Image<InnerLayers> where
+    InnerLayers: WritableLayers<'s>,
+{
+    /// Add another layer to this image. The layer type does
+    /// not have to equal the existing layers in this image.
+    pub fn with_layer<NewChannels>(self, layer: Layer<NewChannels>)
+        -> Image<Recursive<InnerLayers, Layer<NewChannels>>>
+        where NewChannels: 's + WritableChannels<'s>
+    {
+        Image {
+            attributes: self.attributes,
+            layer_data: Recursive::new(self.layer_data, layer)
+        }
+    }
+}
+
+
+impl<'s, SampleData: 's> AnyChannel<SampleData> {
+
+    /// Create a new channel without subsampling.
+    ///
+    /// Automatically flags this channel for specialized compression
+    /// if the name is "R", "G", "B", "Y", or "L",
+    /// as they typically encode values that are perceived non-linearly.
+    /// Construct the value yourself using `AnyChannel { .. }`, if you want to control this flag.
+    pub fn new(name: impl Into<Text>, sample_data: SampleData) -> Self where SampleData: WritableSamples<'s> {
+        let name: Text = name.into();
+
+        AnyChannel {
+            quantize_linearly: ChannelDescription::guess_quantization_linearity(&name),
+            name, sample_data,
+            sampling: Vec2(1, 1),
+        }
+    }
+
+    /*/// This is the same as `AnyChannel::new()`, but additionally ensures that the closure type is correct.
+    pub fn from_closure<V>(name: Text, sample_data: S) -> Self
+        where S: Sync + Fn(Vec2<usize>) -> V, V: InferSampleType + Data
+    {
+        Self::new(name, sample_data)
+    }*/
+}
+
+impl std::fmt::Debug for FlatSamples {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.len() <= 6 {
+            match self {
+                FlatSamples::F16(vec) => vec.fmt(formatter),
+                FlatSamples::F32(vec) => vec.fmt(formatter),
+                FlatSamples::U32(vec) => vec.fmt(formatter),
+            }
+        }
+        else {
+            match self {
+                FlatSamples::F16(vec) => write!(formatter, "[f16; {}]", vec.len()),
+                FlatSamples::F32(vec) => write!(formatter, "[f32; {}]", vec.len()),
+                FlatSamples::U32(vec) => write!(formatter, "[u32; {}]", vec.len()),
+            }
+        }
+    }
+}
+
+
+
+/// Compare the result of a round trip test with the original method.
+/// Supports lossy compression methods.
+// #[cfg(test)] TODO do not ship this code
+pub mod validate_results {
+    use crate::prelude::*;
+    use smallvec::Array;
+    use crate::prelude::recursive::*;
+    use crate::image::write::samples::WritableSamples;
+    use std::ops::Not;
+    use crate::block::samples::IntoNativeSample;
+
+
+    /// Compare two objects, but with a few special quirks.
+    /// Intended mainly for unit testing.
+    pub trait ValidateResult {
+
+        /// Compare self with the other. Panics if not equal.
+        ///
+        /// Exceptional behaviour:
+        /// This does not work the other way around! This method is not symmetrical!
+        /// Returns whether the result is correct for this image.
+        /// For lossy compression methods, uses approximate equality.
+        /// Intended for unit testing.
+        ///
+        /// Warning: If you use `SpecificChannels`, the comparison might be inaccurate
+        /// for images with mixed compression methods. This is to be used with `AnyChannels` mainly.
+        fn assert_equals_result(&self, result: &Self) {
+            self.validate_result(result, ValidationOptions::default(), || String::new()).unwrap();
+        }
+
+        /// Compare self with the other.
+        /// Exceptional behaviour:
+        /// - Any two NaN values are considered equal, regardless of bit representation.
+        /// - If a `lossy` is specified, any two values that differ only by a small amount will be considered equal.
+        /// - If `nan_to_zero` is true, and __self is NaN/Infinite and the other value is zero, they are considered equal__
+        ///   (because some compression methods replace nan with zero)
+        ///
+        /// This does not work the other way around! This method is not symmetrical!
+        fn validate_result(
+            &self, lossy_result: &Self,
+            options: ValidationOptions,
+            // this is a lazy string, because constructing a string is only necessary in the case of an error,
+            // but eats up memory and allocation time every time. this was measured.
+            context: impl Fn() -> String
+        ) -> ValidationResult;
+    }
+
+    /// Whether to do accurate or approximate comparison.
+    #[derive(Default, Debug, Eq, PartialEq, Hash, Copy, Clone)]
+    pub struct ValidationOptions {
+        allow_lossy: bool,
+        nan_converted_to_zero: bool,
+    }
+
+    /// If invalid, contains the error message.
+    pub type ValidationResult = std::result::Result<(), String>;
+
+
+    impl<C> ValidateResult for Image<C> where C: ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            if self.attributes != other.attributes { Err(location() + "| image > attributes") }
+            else { self.layer_data.validate_result(&other.layer_data, options, || location() + "| image > layer data") }
+        }
+    }
+
+    impl<S> ValidateResult for Layer<AnyChannels<S>>
+        where AnyChannel<S>: ValidateResult, S: for<'a> WritableSamples<'a>
+    {
+        fn validate_result(&self, other: &Self, _overridden: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            let location = || format!("{} (layer `{:?}`)", location(), self.attributes.layer_name);
+            if self.attributes != other.attributes { Err(location() + " > attributes") }
+            else if self.encoding != other.encoding { Err(location() + " > encoding") }
+            else if self.size != other.size { Err(location() + " > size") }
+            else if self.channel_data.list.len() != other.channel_data.list.len() { Err(location() + " > channel count") }
+            else {
+                for (own_chan, other_chan) in self.channel_data.list.iter().zip(other.channel_data.list.iter()) {
+                    own_chan.validate_result(
+                        other_chan,
+
+                        ValidationOptions {
+                            // no tolerance for lossless channels
+                            allow_lossy: other.encoding.compression
+                                .is_lossless_for(other_chan.sample_data.sample_type()).not(),
+
+                            // consider nan and zero equal if the compression method does not support nan
+                            nan_converted_to_zero: other.encoding.compression.supports_nan().not()
+                        },
+
+                        || format!("{} > channel `{}`", location(), own_chan.name)
+                    )?;
+                }
+                Ok(())
+            }
+        }
+    }
+
+    impl<Px, Desc> ValidateResult for Layer<SpecificChannels<Px, Desc>>
+        where SpecificChannels<Px, Desc>: ValidateResult
+    {
+        /// This does an approximate comparison for all channels,
+        /// even if some channels can be compressed without loss.
+        fn validate_result(&self, other: &Self, _overridden: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            let location = || format!("{} (layer `{:?}`)", location(), self.attributes.layer_name);
+
+            // TODO dedup with above
+            if self.attributes != other.attributes { Err(location() + " > attributes") }
+            else if self.encoding != other.encoding { Err(location() + " > encoding") }
+            else if self.size != other.size { Err(location() + " > size") }
+            else {
+                let options = ValidationOptions {
+                    // no tolerance for lossless channels
+                    // pxr only looses data for f32 values, B44 only for f16, not other any other types
+                    allow_lossy: other.encoding.compression.may_loose_data(),// TODO check specific channels sample types
+
+                    // consider nan and zero equal if the compression method does not support nan
+                    nan_converted_to_zero: other.encoding.compression.supports_nan().not()
+                };
+
+                self.channel_data.validate_result(&other.channel_data, options, || location() + " > channel_data")?;
+                Ok(())
+            }
+        }
+    }
+
+    impl<S> ValidateResult for AnyChannels<S> where S: ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            self.list.validate_result(&other.list, options, location)
+        }
+    }
+
+    impl<S> ValidateResult for AnyChannel<S> where S: ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            if self.name != other.name { Err(location() + " > name") }
+            else if self.quantize_linearly != other.quantize_linearly { Err(location() + " > quantize_linearly") }
+            else if self.sampling != other.sampling { Err(location() + " > sampling") }
+            else {
+                self.sample_data.validate_result(&other.sample_data, options, || location() + " > sample_data")
+            }
+        }
+    }
+
+    impl<Pxs, Chans> ValidateResult for SpecificChannels<Pxs, Chans> where Pxs: ValidateResult, Chans: Eq {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            if self.channels != other.channels { Err(location() + " > specific channels") }
+            else { self.pixels.validate_result(&other.pixels, options, || location() + " > specific pixels") }
+        }
+    }
+
+    impl<S> ValidateResult for Levels<S> where S: ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            self.levels_as_slice().validate_result(&other.levels_as_slice(), options, || location() + " > levels")
+        }
+    }
+
+    impl ValidateResult for FlatSamples {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            use FlatSamples::*;
+            match (self, other) {
+                (F16(values), F16(other_values)) => values.as_slice().validate_result(&other_values.as_slice(), options, ||location() + " > f16 samples"),
+                (F32(values), F32(other_values)) => values.as_slice().validate_result(&other_values.as_slice(), options, ||location() + " > f32 samples"),
+                (U32(values), U32(other_values)) => values.as_slice().validate_result(&other_values.as_slice(), options, ||location() + " > u32 samples"),
+                (own, other) => Err(format!("{}: samples type mismatch. expected {:?}, found {:?}", location(), own.sample_type(), other.sample_type()))
+            }
+        }
+    }
+
+    impl<T> ValidateResult for &[T] where T: ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            if self.len() != other.len() { Err(location() + " count") }
+            else {
+                for (index, (slf, other)) in self.iter().zip(other.iter()).enumerate() {
+                    slf.validate_result(other, options, ||format!("{} element [{}] of {}", location(), index, self.len()))?;
+                }
+                Ok(())
+            }
+        }
+    }
+
+    impl<A: Array> ValidateResult for SmallVec<A> where A::Item: ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            self.as_slice().validate_result(&other.as_slice(), options, location)
+        }
+    }
+
+    impl<A> ValidateResult for Vec<A> where A: ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            self.as_slice().validate_result(&other.as_slice(), options, location)
+        }
+    }
+
+    impl<A,B,C,D> ValidateResult for (A, B, C, D) where A: Clone+ ValidateResult, B: Clone+ ValidateResult, C: Clone+ ValidateResult, D: Clone+ ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            self.clone().into_recursive().validate_result(&other.clone().into_recursive(), options, location)
+        }
+    }
+
+    impl<A,B,C> ValidateResult for (A, B, C) where A: Clone+ ValidateResult, B: Clone+ ValidateResult, C: Clone+ ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            self.clone().into_recursive().validate_result(&other.clone().into_recursive(), options, location)
+        }
+    }
+
+    // // (low priority because it is only used in the tests)
+    /*TODO
+    impl<Tuple> SimilarToLossy for Tuple where
+        Tuple: Clone + IntoRecursive,
+        <Tuple as IntoRecursive>::Recursive: SimilarToLossy,
+    {
+        fn similar_to_lossy(&self, other: &Self, max_difference: f32) -> bool {
+            self.clone().into_recursive().similar_to_lossy(&other.clone().into_recursive(), max_difference)
+        } // TODO no clone?
+    }*/
+
+
+    // implement for recursive types
+    impl ValidateResult for NoneMore {
+        fn validate_result(&self, _: &Self, _: ValidationOptions, _: impl Fn()->String) -> ValidationResult { Ok(()) }
+    }
+
+    impl<Inner, T> ValidateResult for Recursive<Inner, T> where Inner: ValidateResult, T: ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            self.value.validate_result(&other.value, options, &location).and_then(|()|
+                self.inner.validate_result(&other.inner, options, &location)
+            )
+        }
+    }
+
+    impl<S> ValidateResult for Option<S> where S: ValidateResult {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            match (self, other) {
+                (None, None) => Ok(()),
+                (Some(value), Some(other)) => value.validate_result(other, options, location),
+                _ => Err(location() + ": option mismatch")
+            }
+        }
+    }
+
+    impl ValidateResult for f32 {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            if self == other || (self.is_nan() && other.is_nan()) || (options.nan_converted_to_zero && !self.is_normal() && *other == 0.0) {
+                return Ok(());
+            }
+
+            if options.allow_lossy {
+                let epsilon = 0.06;
+                let max_difference = 0.1;
+
+                let adaptive_threshold = epsilon * (self.abs() + other.abs());
+                let tolerance = adaptive_threshold.max(max_difference);
+                let difference = (self - other).abs();
+
+                return if difference <= tolerance { Ok(()) }
+                else { Err(format!("{}: expected ~{}, found {} (adaptive tolerance {})", location(), self, other, tolerance)) };
+            }
+
+            Err(format!("{}: expected exactly {}, found {}", location(), self, other))
+        }
+    }
+
+    impl ValidateResult for f16 {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            if self.to_bits() == other.to_bits() { Ok(()) } else {
+                self.to_f32().validate_result(&other.to_f32(), options, location)
+            }
+        }
+    }
+
+    impl ValidateResult for u32 {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            if self == other { Ok(()) } else { // todo to float conversion resulting in nan/infinity?
+                self.to_f32().validate_result(&other.to_f32(), options, location)
+            }
+        }
+    }
+
+    impl ValidateResult for Sample {
+        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
+            use Sample::*;
+            match (self, other) {
+                (F16(a), F16(b)) => a.validate_result(b, options, ||location() + " (f16)"),
+                (F32(a), F32(b)) => a.validate_result(b, options, ||location() + " (f32)"),
+                (U32(a), U32(b)) => a.validate_result(b, options, ||location() + " (u32)"),
+                (_,_) => Err(location() + ": sample type mismatch")
+            }
+        }
+    }
+
+
+    #[cfg(test)]
+    mod test_value_result {
+        use std::f32::consts::*;
+        use std::io::Cursor;
+        use crate::image::pixel_vec::PixelVec;
+        use crate::image::validate_results::{ValidateResult, ValidationOptions};
+        use crate::meta::attribute::LineOrder::Increasing;
+        use crate::image::{FlatSamples};
+
+        fn expect_valid<T>(original: &T, result: &T, allow_lossy: bool, nan_converted_to_zero: bool) where T: ValidateResult {
+            original.validate_result(
+                result,
+                ValidationOptions { allow_lossy, nan_converted_to_zero },
+                || String::new()
+            ).unwrap();
+        }
+
+        fn expect_invalid<T>(original: &T, result: &T, allow_lossy: bool, nan_converted_to_zero: bool) where T: ValidateResult {
+            assert!(original.validate_result(
+                result,
+                ValidationOptions { allow_lossy, nan_converted_to_zero },
+                || String::new()
+            ).is_err());
+        }
+
+        #[test]
+        fn test_f32(){
+            let original:&[f32] = &[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, -20.4, f32::NAN];
+            let lossy:&[f32] = &[0.0, 0.2, 0.2, 0.3, 0.4, 0.5, -20.5, f32::NAN];
+
+            expect_valid(&original, &original, true, true);
+            expect_valid(&original, &original, true, false);
+            expect_valid(&original, &original, false, true);
+            expect_valid(&original, &original, false, false);
+
+            expect_invalid(&original, &lossy, false, false);
+            expect_valid(&original, &lossy, true, false);
+
+            expect_invalid(&original, &&original[..original.len()-2], true, true);
+
+            // test relative comparison with some large values
+            expect_valid(&1_000_f32, &1_001_f32, true, false);
+            expect_invalid(&1_000_f32, &1_200_f32, true, false);
+
+            expect_valid(&10_000_f32, &10_100_f32, true, false);
+            expect_invalid(&10_000_f32, &12_000_f32, true, false);
+
+            expect_valid(&33_120_f32, &30_120_f32, true, false);
+            expect_invalid(&33_120_f32, &20_120_f32, true, false);
+        }
+
+        #[test]
+        fn test_nan(){
+            let original:&[f32] = &[ 0.0, f32::NAN, f32::NAN ];
+            let lossy:&[f32] = &[ 0.0, f32::NAN, 0.0 ];
+
+            expect_valid(&original, &lossy, true, true);
+            expect_invalid(&lossy, &original, true, true);
+
+            expect_valid(&lossy, &lossy, true, true);
+            expect_valid(&lossy, &lossy, false, true);
+        }
+
+        #[test]
+        fn test_error(){
+
+            fn print_error<T: ValidateResult>(original: &T, lossy: &T, allow_lossy: bool){
+                let message = original
+                    .validate_result(
+                        &lossy,
+                        ValidationOptions { allow_lossy, .. Default::default() },
+                        || String::new() // type_name::<T>().to_string()
+                    )
+                    .unwrap_err();
+
+                println!("message: {}", message);
+            }
+
+            let original:&[f32] = &[ 0.0, f32::NAN, f32::NAN ];
+            let lossy:&[f32] = &[ 0.0, f32::NAN, 0.0 ];
+            print_error(&original, &lossy, false);
+
+            print_error(&2.0, &1.0, true);
+            print_error(&2.0, &1.0, false);
+
+            print_error(&FlatSamples::F32(vec![0.1,0.1]), &FlatSamples::F32(vec![0.1,0.2]), false);
+            print_error(&FlatSamples::U32(vec![0,0]), &FlatSamples::F32(vec![0.1,0.2]), false);
+
+            {
+                let image = crate::prelude::read_all_data_from_file("tests/images/valid/openexr/MultiResolution/Kapaa.exr").unwrap();
+
+                let mut mutated = image.clone();
+                let samples = mutated.layer_data.first_mut().unwrap()
+                    .channel_data.list.first_mut().unwrap().sample_data.levels_as_slice_mut().first_mut().unwrap();
+
+                match samples {
+                    FlatSamples::F16(vals) => vals[100] = vals[1],
+                    FlatSamples::F32(vals) => vals[100] = vals[1],
+                    FlatSamples::U32(vals) => vals[100] = vals[1],
+                }
+
+                print_error(&image, &mutated, false);
+            }
+
+            // TODO check out more nested behaviour!
+        }
+
+        #[test]
+        fn test_uncompressed(){
+            use crate::prelude::*;
+
+            let original_pixels: [(f32,f32,f32); 4] = [
+                (0.0, -1.1, PI),
+                (0.0, -1.1, TAU),
+                (0.0, -1.1, f32::EPSILON),
+                (f32::NAN, 10000.1, -1024.009),
+            ];
+
+            let mut file_bytes = Vec::new();
+            let original_image = Image::from_encoded_channels(
+                (2,2),
+                Encoding {
+                    compression: Compression::Uncompressed,
+                    line_order: Increasing, // FIXME unspecified may be optimized to increasing, which destroys test eq
+                    .. Encoding::default()
+                },
+                SpecificChannels::rgb(PixelVec::new(Vec2(2,2), original_pixels.to_vec()))
+            );
+
+            original_image.write().to_buffered(Cursor::new(&mut file_bytes)).unwrap();
+
+            let lossy_image = read().no_deep_data().largest_resolution_level()
+                .rgb_channels(PixelVec::<(f32,f32,f32)>::constructor, PixelVec::set_pixel)
+                .first_valid_layer().all_attributes().from_buffered(Cursor::new(&file_bytes)).unwrap();
+
+            original_image.assert_equals_result(&original_image);
+            lossy_image.assert_equals_result(&lossy_image);
+            original_image.assert_equals_result(&lossy_image);
+            lossy_image.assert_equals_result(&original_image);
+        }
+
+        #[test]
+        fn test_compiles(){
+            use crate::prelude::*;
+
+            fn accepts_validatable_value(_: &impl ValidateResult){}
+
+            let object: Levels<FlatSamples> = Levels::Singular(FlatSamples::F32(Vec::default()));
+            accepts_validatable_value(&object);
+
+            let object: AnyChannels<Levels<FlatSamples>> = AnyChannels::sort(SmallVec::default());
+            accepts_validatable_value(&object);
+
+            let layer: Layer<AnyChannels<Levels<FlatSamples>>> = Layer::new((0,0), Default::default(), Default::default(), object);
+            accepts_validatable_value(&layer);
+
+            let layers: Layers<AnyChannels<Levels<FlatSamples>>> = Default::default();
+            accepts_validatable_value(&layers);
+
+            let object: Image<Layer<AnyChannels<Levels<FlatSamples>>>> = Image::from_layer(layer);
+            object.assert_equals_result(&object);
+        }
+    }
+}
+
+
diff --git a/vendor/exr/src/image/pixel_vec.rs b/vendor/exr/src/image/pixel_vec.rs
new file mode 100644
index 0000000..3447bf2
--- /dev/null
+++ b/vendor/exr/src/image/pixel_vec.rs
@@ -0,0 +1,97 @@
+
+//! Provides a predefined pixel storage.
+//! Currently only contains a simple flattened vector storage.
+//! Use the functions `create_pixel_vec::<YourPixelTuple>` and
+//! `set_pixel_in_vec::<YourPixelTuple>` for reading a predefined pixel vector.
+//! Use the function `PixelVec::new` to create a pixel vector which can be written to a file.
+
+use super::*;
+
+/// Store all samples in a single array.
+/// All samples will be converted to the type `T`.
+/// This supports all the sample types, `f16`, `f32`, and `u32`.
+///
+/// The flattened vector contains all rows one after another.
+/// In each row, for each pixel, its red, green, blue, and then alpha
+/// samples are stored one after another.
+///
+/// Use `PixelVec.compute_pixel_index(position)`
+/// to compute the flat index of a specific pixel.
+#[derive(Eq, PartialEq, Clone)]
+pub struct PixelVec<T> {
+
+    /// The resolution of this layer.
+    pub resolution: Vec2<usize>,
+
+    /// The flattened vector contains all rows one after another.
+    /// In each row, for each pixel, its red, green, blue, and then alpha
+    /// samples are stored one after another.
+    ///
+    /// Use `Flattened::compute_pixel_index(image, position)`
+    /// to compute the flat index of a specific pixel.
+    pub pixels: Vec<T>,
+}
+
+impl<Pixel> PixelVec<Pixel> {
+
+    /// Create a new flattened pixel storage, filled with default pixels.
+    /// Accepts a `Channels` parameter, which is not used, so that it can be passed as a function pointer instead of calling it.
+    pub fn constructor<Channels>(resolution: Vec2<usize>, _: &Channels) -> Self where Pixel: Default + Clone {
+        PixelVec { resolution, pixels: vec![Pixel::default(); resolution.area()] }
+    }
+
+    /// Examine a pixel of a `PixelVec<T>` image.
+    /// Can usually be used as a function reference instead of calling it directly.
+    #[inline]
+    pub fn get_pixel(&self, position: Vec2<usize>) -> &Pixel where Pixel: Sync {
+        &self.pixels[self.compute_pixel_index(position)]
+    }
+
+    /// Update a pixel of a `PixelVec<T>` image.
+    /// Can usually be used as a function reference instead of calling it directly.
+    #[inline]
+    pub fn set_pixel(&mut self, position: Vec2<usize>, pixel: Pixel) {
+        let index = self.compute_pixel_index(position);
+        self.pixels[index] = pixel;
+    }
+
+    /// Create a new flattened pixel storage, checking the length of the provided pixels vector.
+    pub fn new(resolution: impl Into<Vec2<usize>>, pixels: Vec<Pixel>) -> Self {
+        let size = resolution.into();
+        assert_eq!(size.area(), pixels.len(), "expected {} samples, but vector length is {}", size.area(), pixels.len());
+        Self { resolution: size, pixels }
+    }
+
+    /// Compute the flat index of a specific pixel. Returns a range of either 3 or 4 samples.
+    /// The computed index can be used with `PixelVec.samples[index]`.
+    /// Panics for invalid sample coordinates.
+    #[inline]
+    pub fn compute_pixel_index(&self, position: Vec2<usize>) -> usize {
+        position.flat_index_for_size(self.resolution)
+    }
+}
+
+use crate::image::validate_results::{ValidateResult, ValidationResult};
+
+impl<Px> ValidateResult for PixelVec<Px> where Px: ValidateResult {
+    fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn() -> String) -> ValidationResult {
+        if self.resolution != other.resolution { Err(location() + " > resolution") }
+        else { self.pixels.as_slice().validate_result(&other.pixels.as_slice(), options, || location() + " > pixels") }
+    }
+}
+
+impl<Px> GetPixel for PixelVec<Px> where Px: Clone + Sync {
+    type Pixel = Px;
+    fn get_pixel(&self, position: Vec2<usize>) -> Self::Pixel {
+        self.get_pixel(position).clone()
+    }
+}
+
+use std::fmt::*;
+
+impl<T> Debug for PixelVec<T> {
+    #[inline] fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(formatter, "[{}; {}]", std::any::type_name::<T>(), self.pixels.len())
+    }
+}
+
diff --git a/vendor/exr/src/image/read/any_channels.rs b/vendor/exr/src/image/read/any_channels.rs
new file mode 100644
index 0000000..054a7c3
--- /dev/null
+++ b/vendor/exr/src/image/read/any_channels.rs
@@ -0,0 +1,128 @@
+//! How to read arbitrary channels.
+
+use crate::image::*;
+use crate::meta::header::{Header};
+use crate::error::{Result, UnitResult};
+use crate::block::UncompressedBlock;
+use crate::block::lines::{LineRef};
+use crate::math::Vec2;
+use crate::meta::attribute::{Text, ChannelDescription};
+use crate::image::read::layers::{ReadChannels, ChannelsReader};
+use crate::block::chunk::TileCoordinates;
+
+/// A template that creates an [AnyChannelsReader] for each layer in the image.
+/// This loads all channels for each layer.
+/// The `ReadSamples` can, for example, be [ReadFlatSamples] or [ReadAllLevels<ReadFlatSamples>].
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ReadAnyChannels<ReadSamples> {
+
+    /// The sample reading specification
+    pub read_samples: ReadSamples
+}
+
+/// A template that creates a new [`SampleReader`] for each channel in each layer.
+pub trait ReadSamples {
+
+    /// The type of the temporary samples reader
+    type Reader: SamplesReader;
+
+    /// Create a single reader for a single channel of a layer
+    fn create_sample_reader(&self, header: &Header, channel: &ChannelDescription) -> Result<Self::Reader>;
+}
+
+/// Processes pixel blocks from a file and accumulates them into a collection of arbitrary channels.
+/// Loads all channels for each layer.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct AnyChannelsReader<SamplesReader> {
+
+    /// Stores a separate sample reader per channel in the layer
+    sample_channels_reader: SmallVec<[AnyChannelReader<SamplesReader>; 4]>,
+}
+
+/// Processes pixel blocks from a file and accumulates them into a single arbitrary channel.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct AnyChannelReader<SamplesReader> {
+
+    /// The custom reader that accumulates the pixel data for a single channel
+    samples: SamplesReader,
+
+    /// Temporarily accumulated meta data.
+    name: Text,
+
+    /// Temporarily accumulated meta data.
+    sampling_rate: Vec2<usize>,
+
+    /// Temporarily accumulated meta data.
+    quantize_linearly: bool,
+}
+
+/// Processes pixel blocks from a file and accumulates them into a single pixel channel.
+/// For example, stores thousands of "Red" pixel values for a single layer.
+pub trait SamplesReader {
+
+    /// The type of resulting sample storage
+    type Samples;
+
+    /// Specify whether a single block of pixels should be loaded from the file
+    fn filter_block(&self, tile: TileCoordinates) -> bool;
+
+    /// Load a single pixel line, which has not been filtered, into the reader, accumulating the sample data
+    fn read_line(&mut self, line: LineRef<'_>) -> UnitResult;
+
+    /// Deliver the final accumulated sample storage for the image
+    fn into_samples(self) -> Self::Samples;
+}
+
+
+impl<'s, S: 's + ReadSamples> ReadChannels<'s> for ReadAnyChannels<S> {
+    type Reader = AnyChannelsReader<S::Reader>;
+
+    fn create_channels_reader(&self, header: &Header) -> Result<Self::Reader> {
+        let samples: Result<_> = header.channels.list.iter()
+            .map(|channel: &ChannelDescription| Ok(AnyChannelReader {
+                samples: self.read_samples.create_sample_reader(header, channel)?,
+                name: channel.name.clone(),
+                sampling_rate: channel.sampling,
+                quantize_linearly: channel.quantize_linearly
+            }))
+            .collect();
+
+        Ok(AnyChannelsReader { sample_channels_reader: samples? })
+    }
+}
+
+impl<S: SamplesReader> ChannelsReader for AnyChannelsReader<S> {
+    type Channels = AnyChannels<S::Samples>;
+
+    fn filter_block(&self, tile: TileCoordinates) -> bool {
+        self.sample_channels_reader.iter().any(|channel| channel.samples.filter_block(tile))
+    }
+
+    fn read_block(&mut self, header: &Header, decompressed: UncompressedBlock) -> UnitResult {
+        /*for (bytes, line) in LineIndex::lines_in_block(decompressed.index, header) {
+            let channel = self.sample_channels_reader.get_mut(line.channel).unwrap();
+            channel.samples.read_line(LineSlice { location: line, value: &decompressed.data[bytes] })?;
+        }
+
+        Ok(())*/
+        for line in decompressed.lines(&header.channels) {
+            self.sample_channels_reader[line.location.channel].samples.read_line(line)?;
+        }
+
+        Ok(())
+    }
+
+    fn into_channels(self) -> Self::Channels {
+        AnyChannels { // not using `new()` as the channels are already sorted
+            list: self.sample_channels_reader.into_iter()
+                .map(|channel| AnyChannel {
+                    sample_data: channel.samples.into_samples(),
+
+                    name: channel.name,
+                    quantize_linearly: channel.quantize_linearly,
+                    sampling: channel.sampling_rate
+                })
+                .collect()
+        }
+    }
+}
diff --git a/vendor/exr/src/image/read/image.rs b/vendor/exr/src/image/read/image.rs
new file mode 100644
index 0000000..fce2f52
--- /dev/null
+++ b/vendor/exr/src/image/read/image.rs
@@ -0,0 +1,209 @@
+//! The last wrapper of image readers, finally containing the [`from_file(path)`] method.
+//! This completes the builder and reads a complete image.
+
+use crate::image::*;
+use crate::meta::header::{Header, ImageAttributes};
+use crate::error::{Result, UnitResult};
+use crate::block::{UncompressedBlock, BlockIndex};
+use crate::block::chunk::TileCoordinates;
+use std::path::Path;
+use std::io::{Read, BufReader};
+use std::io::Seek;
+use crate::meta::MetaData;
+use crate::block::reader::ChunksReader;
+
+/// Specify whether to read the image in parallel,
+/// whether to use pedantic error handling,
+/// and a callback for the reading progress.
+#[derive(Debug, Clone)]
+pub struct ReadImage<OnProgress, ReadLayers> {
+    on_progress: OnProgress,
+    read_layers: ReadLayers,
+    pedantic: bool,
+    parallel: bool,
+}
+
+impl<F, L> ReadImage<F, L> where F: FnMut(f64)
+{
+    /// Uses relaxed error handling and parallel decompression.
+    pub fn new(read_layers: L, on_progress: F) -> Self {
+        Self {
+            on_progress, read_layers,
+            pedantic: false, parallel: true,
+        }
+    }
+
+    /// Specify that any missing or unusual information should result in an error.
+    /// Otherwise, `exrs` will try to compute or ignore missing information.
+    ///
+    /// If pedantic is true, then an error will be returned as soon as anything is missing in the file,
+    /// or two values in the image contradict each other. If pedantic is false,
+    /// then only fatal errors will be thrown. By default, reading an image is not pedantic,
+    /// which means that slightly invalid files might still be readable.
+    /// For example, if some attribute is missing but can be recomputed, this flag decides whether an error is thrown.
+    /// Or if the pedantic flag is true and there are still bytes left after the decompression algorithm finished,
+    /// an error is thrown, because this should not happen and something might be wrong with the file.
+    /// Or if your application is a target of attacks, or if you want to emulate the original C++ library,
+    /// you might want to switch to pedantic reading.
+    pub fn pedantic(self) -> Self { Self { pedantic: true, ..self } }
+
+    /// Specify that multiple pixel blocks should never be decompressed using multiple threads at once.
+    /// This might be slower but uses less memory and less synchronization.
+    pub fn non_parallel(self) -> Self { Self { parallel: false, ..self } }
+
+    /// Specify a function to be called regularly throughout the loading process.
+    /// Replaces all previously specified progress functions in this reader.
+    pub fn on_progress<OnProgress>(self, on_progress: OnProgress) -> ReadImage<OnProgress, L>
+        where OnProgress: FnMut(f64)
+    {
+        ReadImage {
+            on_progress,
+            read_layers: self.read_layers,
+            pedantic: self.pedantic,
+            parallel: self.parallel
+        }
+    }
+
+
+    /// Read the exr image from a file.
+    /// Use [`ReadImage::read_from_unbuffered`] instead, if you do not have a file.
+    #[inline]
+    #[must_use]
+    pub fn from_file<Layers>(self, path: impl AsRef<Path>) -> Result<Image<Layers>>
+        where for<'s> L: ReadLayers<'s, Layers = Layers>
+    {
+        self.from_unbuffered(std::fs::File::open(path)?)
+    }
+
+    /// Buffer the reader and then read the exr image from it.
+    /// Use [`ReadImage::read_from_buffered`] instead, if your reader is an in-memory reader.
+    /// Use [`ReadImage::read_from_file`] instead, if you have a file path.
+    #[inline]
+    #[must_use]
+    pub fn from_unbuffered<Layers>(self, unbuffered: impl Read + Seek) -> Result<Image<Layers>>
+        where for<'s> L: ReadLayers<'s, Layers = Layers>
+    {
+        self.from_buffered(BufReader::new(unbuffered))
+    }
+
+    /// Read the exr image from a buffered reader.
+    /// Use [`ReadImage::read_from_file`] instead, if you have a file path.
+    /// Use [`ReadImage::read_from_unbuffered`] instead, if this is not an in-memory reader.
+    // TODO Use Parallel<> Wrapper to only require sendable byte source where parallel decompression is required
+    #[must_use]
+    pub fn from_buffered<Layers>(self, buffered: impl Read + Seek) -> Result<Image<Layers>>
+        where for<'s> L: ReadLayers<'s, Layers = Layers>
+    {
+        let chunks = crate::block::read(buffered, self.pedantic)?;
+        self.from_chunks(chunks)
+    }
+
+    /// Read the exr image from an initialized chunks reader
+    /// that has already extracted the meta data from the file.
+    /// Use [`ReadImage::read_from_file`] instead, if you have a file path.
+    /// Use [`ReadImage::read_from_buffered`] instead, if this is an in-memory reader.
+    // TODO Use Parallel<> Wrapper to only require sendable byte source where parallel decompression is required
+    #[must_use]
+    pub fn from_chunks<Layers>(mut self, chunks_reader: crate::block::reader::Reader<impl Read + Seek>) -> Result<Image<Layers>>
+        where for<'s> L: ReadLayers<'s, Layers = Layers>
+    {
+        let Self { pedantic, parallel, ref mut on_progress, ref mut read_layers } = self;
+
+        let layers_reader = read_layers.create_layers_reader(chunks_reader.headers())?;
+        let mut image_collector = ImageWithAttributesReader::new(chunks_reader.headers(), layers_reader)?;
+
+        let block_reader = chunks_reader
+            .filter_chunks(pedantic, |meta, tile, block| {
+                image_collector.filter_block(meta, tile, block)
+            })?
+            .on_progress(on_progress);
+
+        // TODO propagate send requirement further upwards
+        if parallel {
+            block_reader.decompress_parallel(pedantic, |meta_data, block|{
+                image_collector.read_block(&meta_data.headers, block)
+            })?;
+        }
+        else {
+            block_reader.decompress_sequential(pedantic, |meta_data, block|{
+                image_collector.read_block(&meta_data.headers, block)
+            })?;
+        }
+
+        Ok(image_collector.into_image())
+    }
+}
+
+/// Processes blocks from a file and collects them into a complete `Image`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ImageWithAttributesReader<L> {
+    image_attributes: ImageAttributes,
+    layers_reader: L,
+}
+
+impl<L> ImageWithAttributesReader<L> where L: LayersReader {
+
+    /// A new image reader with image attributes.
+    pub fn new(headers: &[Header], layers_reader: L) -> Result<Self>
+    {
+        Ok(ImageWithAttributesReader {
+            image_attributes: headers.first().as_ref().expect("invalid headers").shared_attributes.clone(),
+            layers_reader,
+        })
+    }
+
+    /// Specify whether a single block of pixels should be loaded from the file
+    fn filter_block(&self, meta: &MetaData, tile: TileCoordinates, block: BlockIndex) -> bool {
+        self.layers_reader.filter_block(meta, tile, block)
+    }
+
+    /// Load a single pixel block, which has not been filtered, into the reader, accumulating the image
+    fn read_block(&mut self, headers: &[Header], block: UncompressedBlock) -> UnitResult {
+        self.layers_reader.read_block(headers, block)
+    }
+
+    /// Deliver the complete accumulated image
+    fn into_image(self) -> Image<L::Layers> {
+        Image {
+            attributes: self.image_attributes,
+            layer_data: self.layers_reader.into_layers()
+        }
+    }
+}
+
+
+/// A template that creates a `LayerReader` for each layer in the file.
+pub trait ReadLayers<'s> {
+
+    /// The type of the resulting Layers
+    type Layers;
+
+    /// The type of the temporary layer reader
+    type Reader: LayersReader<Layers = Self::Layers>;
+
+    /// Create a single reader for a single layer
+    fn create_layers_reader(&'s self, headers: &[Header]) -> Result<Self::Reader>;
+
+    /// Specify that all attributes should be read from an image.
+    /// Use `from_file(path)` on the return value of this method to actually decode an image.
+    fn all_attributes(self) -> ReadImage<fn(f64), Self> where Self: Sized {
+        ReadImage::new(self, ignore_progress)
+    }
+}
+
+/// Processes pixel blocks from a file and accumulates them into a single image layer.
+pub trait LayersReader {
+
+    /// The type of resulting layers
+    type Layers;
+
+    /// Specify whether a single block of pixels should be loaded from the file
+    fn filter_block(&self, meta: &MetaData, tile: TileCoordinates, block: BlockIndex) -> bool;
+
+    /// Load a single pixel block, which has not been filtered, into the reader, accumulating the layer
+    fn read_block(&mut self, headers: &[Header], block: UncompressedBlock) -> UnitResult;
+
+    /// Deliver the final accumulated layers for the image
+    fn into_layers(self) -> Self::Layers;
+}
+
diff --git a/vendor/exr/src/image/read/layers.rs b/vendor/exr/src/image/read/layers.rs
new file mode 100644
index 0000000..75159c2
--- /dev/null
+++ b/vendor/exr/src/image/read/layers.rs
@@ -0,0 +1,204 @@
+//! How to read either a single or a list of layers.
+
+use crate::image::*;
+use crate::meta::header::{Header, LayerAttributes};
+use crate::error::{Result, UnitResult, Error};
+use crate::block::{UncompressedBlock, BlockIndex};
+use crate::math::Vec2;
+use crate::image::read::image::{ReadLayers, LayersReader};
+use crate::block::chunk::TileCoordinates;
+use crate::meta::MetaData;
+
+/// Specify to read all channels, aborting if any one is invalid.
+/// [`ReadRgbaChannels`] or [`ReadAnyChannels<ReadFlatSamples>`].
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ReadAllLayers<ReadChannels> {
+
+    /// The channel reading specification
+    pub read_channels: ReadChannels,
+}
+
+/// Specify to read only the first layer which meets the previously specified requirements
+// FIXME do not throw error on deep data but just skip it!
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ReadFirstValidLayer<ReadChannels> {
+
+    /// The channel reading specification
+    pub read_channels: ReadChannels,
+}
+
+/// A template that creates a [`ChannelsReader`] once for all channels per layer.
+pub trait ReadChannels<'s> {
+
+    /// The type of the temporary channels reader
+    type Reader: ChannelsReader;
+
+    /// Create a single reader for all channels of a specific layer
+    fn create_channels_reader(&'s self, header: &Header) -> Result<Self::Reader>;
+
+
+    /// Read only the first layer which meets the previously specified requirements
+    /// For example, skips layers with deep data, if specified earlier.
+    /// Aborts if the image contains no layers.
+    // TODO test if this filters non-deep layers while ignoring deep data layers!
+    fn first_valid_layer(self) -> ReadFirstValidLayer<Self> where Self:Sized { ReadFirstValidLayer { read_channels: self } }
+
+// FIXME do not throw error on deep data but just skip it!
+
+
+    /// Reads all layers, including an empty list. Aborts if any of the layers are invalid,
+    /// even if only one of the layers contains unexpected data.
+    fn all_layers(self) -> ReadAllLayers<Self> where Self:Sized { ReadAllLayers { read_channels: self } }
+
+    // TODO pub fn all_valid_layers(self) -> ReadAllValidLayers<Self> { ReadAllValidLayers { read_channels: self } }
+}
+
+
+/// Processes pixel blocks from a file and accumulates them into a list of layers.
+/// For example, `ChannelsReader` can be
+/// [`SpecificChannelsReader`] or [`AnyChannelsReader<FlatSamplesReader>`].
+#[derive(Debug, Clone, PartialEq)]
+pub struct AllLayersReader<ChannelsReader> {
+    layer_readers: SmallVec<[LayerReader<ChannelsReader>; 2]>, // TODO unpack struct?
+}
+
+/// Processes pixel blocks from a file and accumulates them into a single layers, using only the first.
+/// For example, `ChannelsReader` can be
+/// `SpecificChannelsReader` or `AnyChannelsReader<FlatSamplesReader>`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct FirstValidLayerReader<ChannelsReader> {
+    layer_reader: LayerReader<ChannelsReader>,
+    layer_index: usize,
+}
+
+/// Processes pixel blocks from a file and accumulates them into a single layers.
+/// For example, `ChannelsReader` can be
+/// `SpecificChannelsReader` or `AnyChannelsReader<FlatSamplesReader>`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct LayerReader<ChannelsReader> {
+    channels_reader: ChannelsReader,
+    attributes: LayerAttributes,
+    size: Vec2<usize>,
+    encoding: Encoding
+}
+
+/// Processes pixel blocks from a file and accumulates them into multiple channels per layer.
+pub trait ChannelsReader {
+
+    /// The type of the resulting channel collection
+    type Channels;
+
+    /// Specify whether a single block of pixels should be loaded from the file
+    fn filter_block(&self, tile: TileCoordinates) -> bool;
+
+    /// Load a single pixel block, which has not been filtered, into the reader, accumulating the channel data
+    fn read_block(&mut self, header: &Header, block: UncompressedBlock) -> UnitResult;
+
+    /// Deliver the final accumulated channel collection for the image
+    fn into_channels(self) -> Self::Channels;
+}
+
+
+impl<C> LayerReader<C> {
+    fn new(header: &Header, channels_reader: C) -> Result<Self> {
+        Ok(LayerReader {
+            channels_reader,
+            attributes: header.own_attributes.clone(),
+            size: header.layer_size,
+            encoding: Encoding {
+                compression: header.compression,
+                line_order: header.line_order,
+                blocks: match header.blocks {
+                    crate::meta::BlockDescription::ScanLines => Blocks::ScanLines,
+                    crate::meta::BlockDescription::Tiles(TileDescription { tile_size, .. }) => Blocks::Tiles(tile_size)
+                },
+            },
+        })
+    }
+}
+
+impl<'s, C> ReadLayers<'s> for ReadAllLayers<C> where C: ReadChannels<'s> {
+    type Layers = Layers<<C::Reader as ChannelsReader>::Channels>;
+    type Reader = AllLayersReader<C::Reader>;
+
+    fn create_layers_reader(&'s self, headers: &[Header]) -> Result<Self::Reader> {
+        let readers: Result<_> = headers.iter()
+            .map(|header| LayerReader::new(header, self.read_channels.create_channels_reader(header)?))
+            .collect();
+
+        Ok(AllLayersReader {
+            layer_readers: readers?
+        })
+    }
+}
+
+impl<C> LayersReader for AllLayersReader<C> where C: ChannelsReader {
+    type Layers = Layers<C::Channels>;
+
+    fn filter_block(&self, _: &MetaData, tile: TileCoordinates, block: BlockIndex) -> bool {
+        let layer = self.layer_readers.get(block.layer).expect("invalid layer index argument");
+        layer.channels_reader.filter_block(tile)
+    }
+
+    fn read_block(&mut self, headers: &[Header], block: UncompressedBlock) -> UnitResult {
+        self.layer_readers
+            .get_mut(block.index.layer).expect("invalid layer index argument")
+            .channels_reader.read_block(headers.get(block.index.layer).expect("invalid header index in block"), block)
+    }
+
+    fn into_layers(self) -> Self::Layers {
+        self.layer_readers
+            .into_iter()
+            .map(|layer| Layer {
+                channel_data: layer.channels_reader.into_channels(),
+                attributes: layer.attributes,
+                size: layer.size,
+                encoding: layer.encoding
+            })
+            .collect()
+    }
+}
+
+
+impl<'s, C> ReadLayers<'s> for ReadFirstValidLayer<C> where C: ReadChannels<'s> {
+    type Layers = Layer<<C::Reader as ChannelsReader>::Channels>;
+    type Reader = FirstValidLayerReader<C::Reader>;
+
+    fn create_layers_reader(&'s self, headers: &[Header]) -> Result<Self::Reader> {
+        headers.iter().enumerate()
+            .flat_map(|(index, header)|
+                self.read_channels.create_channels_reader(header)
+                    .and_then(|reader| Ok(FirstValidLayerReader {
+                        layer_reader: LayerReader::new(header, reader)?,
+                        layer_index: index
+                    }))
+                    .ok()
+            )
+            .next()
+            .ok_or(Error::invalid("no layer in the image matched your specified requirements"))
+    }
+}
+
+
+impl<C> LayersReader for FirstValidLayerReader<C> where C: ChannelsReader {
+    type Layers = Layer<C::Channels>;
+
+    fn filter_block(&self, _: &MetaData, tile: TileCoordinates, block: BlockIndex) -> bool {
+        block.layer == self.layer_index && self.layer_reader.channels_reader.filter_block(tile)
+    }
+
+    fn read_block(&mut self, headers: &[Header], block: UncompressedBlock) -> UnitResult {
+        debug_assert_eq!(block.index.layer, self.layer_index, "block should have been filtered out");
+        self.layer_reader.channels_reader.read_block(&headers[self.layer_index], block)
+    }
+
+    fn into_layers(self) -> Self::Layers {
+        Layer {
+            channel_data: self.layer_reader.channels_reader.into_channels(),
+            attributes: self.layer_reader.attributes,
+            size: self.layer_reader.size,
+            encoding: self.layer_reader.encoding
+        }
+    }
+}
+
diff --git a/vendor/exr/src/image/read/levels.rs b/vendor/exr/src/image/read/levels.rs
new file mode 100644
index 0000000..5705903
--- /dev/null
+++ b/vendor/exr/src/image/read/levels.rs
@@ -0,0 +1,219 @@
+//! How to read a set of resolution levels.
+
+use crate::meta::*;
+use crate::image::*;
+use crate::error::*;
+use crate::meta::attribute::*;
+use crate::image::read::any_channels::*;
+use crate::block::chunk::TileCoordinates;
+use crate::image::read::specific_channels::*;
+use crate::image::recursive::*;
+use crate::math::Vec2;
+use crate::block::lines::LineRef;
+use crate::block::samples::*;
+use crate::meta::header::{Header};
+
+
+// Note: In the resulting image, the `FlatSamples` are placed
+// directly inside the channels, without `LargestLevel<>` indirection
+/// Specify to read only the highest resolution level, skipping all smaller variations.
+/// The sample storage can be [`ReadFlatSamples`].
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ReadLargestLevel<DeepOrFlatSamples> {
+
+    /// The sample reading specification
+    pub read_samples: DeepOrFlatSamples
+}
+
+
+// FIXME rgba levels???
+
+// Read the largest level, directly, without intermediate structs
+impl<DeepOrFlatSamples> ReadLargestLevel<DeepOrFlatSamples> {
+
+    /// Read all arbitrary channels in each layer.
+    pub fn all_channels(self) -> ReadAnyChannels<DeepOrFlatSamples> { ReadAnyChannels { read_samples: self.read_samples } } // Instead of Self, the `FlatSamples` are used directly
+
+    /// Read only layers that contain rgba channels. Skips any other channels in the layer.
+    /// The alpha channel will contain the value `1.0` if no alpha channel can be found in the image.
+    ///
+    /// Using two closures, define how to store the pixels.
+    /// The first closure creates an image, and the second closure inserts a single pixel.
+    /// The type of the pixel can be defined by the second closure;
+    /// it must be a tuple containing four values, each being either `f16`, `f32`, `u32` or `Sample`.
+    ///
+    /// Throws an error for images with deep data or subsampling.
+    /// Use `specific_channels` or `all_channels` if you want to read something other than rgba.
+    pub fn rgba_channels<R,G,B,A, Create, Set, Pixels>(
+        self, create_pixels: Create, set_pixel: Set
+    ) -> CollectPixels<
+        ReadOptionalChannel<ReadRequiredChannel<ReadRequiredChannel<ReadRequiredChannel<NoneMore, R>, G>, B>, A>,
+        (R, G, B, A), Pixels, Create, Set
+    >
+        where
+            R: FromNativeSample, G: FromNativeSample, B: FromNativeSample, A: FromNativeSample,
+            Create: Fn(Vec2<usize>, &RgbaChannels) -> Pixels,
+            Set: Fn(&mut Pixels, Vec2<usize>, (R,G,B,A)),
+    {
+        self.specific_channels()
+            .required("R").required("G").required("B")
+            .optional("A", A::from_f32(1.0))
+            .collect_pixels(create_pixels, set_pixel)
+    }
+
+    /// Read only layers that contain rgb channels. Skips any other channels in the layer.
+    ///
+    /// Using two closures, define how to store the pixels.
+    /// The first closure creates an image, and the second closure inserts a single pixel.
+    /// The type of the pixel can be defined by the second closure;
+    /// it must be a tuple containing three values, each being either `f16`, `f32`, `u32` or `Sample`.
+    ///
+    /// Throws an error for images with deep data or subsampling.
+    /// Use `specific_channels` or `all_channels` if you want to read something other than rgb.
+    pub fn rgb_channels<R,G,B, Create, Set, Pixels>(
+        self, create_pixels: Create, set_pixel: Set
+    ) -> CollectPixels<
+        ReadRequiredChannel<ReadRequiredChannel<ReadRequiredChannel<NoneMore, R>, G>, B>,
+        (R, G, B), Pixels, Create, Set
+    >
+        where
+            R: FromNativeSample, G: FromNativeSample, B: FromNativeSample,
+            Create: Fn(Vec2<usize>, &RgbChannels) -> Pixels,
+            Set: Fn(&mut Pixels, Vec2<usize>, (R,G,B)),
+    {
+        self.specific_channels()
+            .required("R").required("G").required("B")
+            .collect_pixels(create_pixels, set_pixel)
+    }
+
+    /// Read only layers that contain the specified channels, skipping any other channels in the layer.
+    /// Further specify which channels should be included by calling `.required("ChannelName")`
+    /// or `.optional("ChannelName", default_value)` on the result of this function.
+    /// Call `collect_pixels` afterwards to define the pixel container for your set of channels.
+    ///
+    /// Throws an error for images with deep data or subsampling.
+    pub fn specific_channels(self) -> ReadZeroChannels {
+        ReadZeroChannels { }
+    }
+}
+
+/// Specify to read all contained resolution levels from the image, if any.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ReadAllLevels<DeepOrFlatSamples> {
+
+    /// The sample reading specification
+    pub read_samples: DeepOrFlatSamples
+}
+
+impl<ReadDeepOrFlatSamples> ReadAllLevels<ReadDeepOrFlatSamples> {
+
+    /// Read all arbitrary channels in each layer.
+    pub fn all_channels(self) -> ReadAnyChannels<Self> { ReadAnyChannels { read_samples: self } }
+
+    // TODO specific channels for multiple resolution levels
+
+}
+
+/*pub struct ReadLevels<S> {
+    read_samples: S,
+}*/
+
+/// Processes pixel blocks from a file and accumulates them into multiple levels per channel.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct AllLevelsReader<SamplesReader> {
+    levels: Levels<SamplesReader>,
+}
+
+/// A template that creates a [`SamplesReader`] once for each resolution level.
+pub trait ReadSamplesLevel {
+
+    /// The type of the temporary level reader
+    type Reader: SamplesReader;
+
+    /// Create a single reader for a single resolution level
+    fn create_samples_level_reader(&self, header: &Header, channel: &ChannelDescription, level: Vec2<usize>, resolution: Vec2<usize>) -> Result<Self::Reader>;
+}
+
+
+impl<S: ReadSamplesLevel> ReadSamples for ReadAllLevels<S> {
+    type Reader = AllLevelsReader<S::Reader>;
+
+    fn create_sample_reader(&self, header: &Header, channel: &ChannelDescription) -> Result<Self::Reader> {
+        let data_size = header.layer_size / channel.sampling;
+
+        let levels = {
+            if let crate::meta::BlockDescription::Tiles(tiles) = &header.blocks {
+                match tiles.level_mode {
+                    LevelMode::Singular => Levels::Singular(self.read_samples.create_samples_level_reader(header, channel, Vec2(0,0), header.layer_size)?),
+
+                    LevelMode::MipMap => Levels::Mip {
+                        rounding_mode: tiles.rounding_mode,
+                        level_data: {
+                            let round = tiles.rounding_mode;
+                            let maps: Result<LevelMaps<S::Reader>> = mip_map_levels(round, data_size)
+                                .map(|(index, level_size)| self.read_samples.create_samples_level_reader(header, channel, Vec2(index, index), level_size))
+                                .collect();
+
+                            maps?
+                        },
+                    },
+
+                    // TODO put this into Levels::new(..) ?
+                    LevelMode::RipMap => Levels::Rip {
+                        rounding_mode: tiles.rounding_mode,
+                        level_data: {
+                            let round = tiles.rounding_mode;
+                            let level_count_x = compute_level_count(round, data_size.width());
+                            let level_count_y = compute_level_count(round, data_size.height());
+                            let maps: Result<LevelMaps<S::Reader>> = rip_map_levels(round, data_size)
+                                .map(|(index, level_size)| self.read_samples.create_samples_level_reader(header, channel, index, level_size))
+                                .collect();
+
+                            RipMaps {
+                                map_data: maps?,
+                                level_count: Vec2(level_count_x, level_count_y)
+                            }
+                        },
+                    },
+                }
+            }
+
+            // scan line blocks never have mip maps
+            else {
+                Levels::Singular(self.read_samples.create_samples_level_reader(header, channel, Vec2(0, 0), data_size)?)
+            }
+        };
+
+        Ok(AllLevelsReader { levels })
+    }
+}
+
+
+impl<S: SamplesReader> SamplesReader for AllLevelsReader<S> {
+    type Samples = Levels<S::Samples>;
+
+    fn filter_block(&self, _: TileCoordinates) -> bool {
+        true
+    }
+
+    fn read_line(&mut self, line: LineRef<'_>) -> UnitResult {
+        self.levels.get_level_mut(line.location.level)?.read_line(line)
+    }
+
+    fn into_samples(self) -> Self::Samples {
+        match self.levels {
+            Levels::Singular(level) => Levels::Singular(level.into_samples()),
+            Levels::Mip { rounding_mode, level_data } => Levels::Mip {
+                rounding_mode, level_data: level_data.into_iter().map(|s| s.into_samples()).collect(),
+            },
+
+            Levels::Rip { rounding_mode, level_data } => Levels::Rip {
+                rounding_mode,
+                level_data: RipMaps {
+                    level_count: level_data.level_count,
+                    map_data: level_data.map_data.into_iter().map(|s| s.into_samples()).collect(),
+                }
+            },
+        }
+    }
+}
diff --git a/vendor/exr/src/image/read/mod.rs b/vendor/exr/src/image/read/mod.rs
new file mode 100644
index 0000000..c03fc90
--- /dev/null
+++ b/vendor/exr/src/image/read/mod.rs
@@ -0,0 +1,207 @@
+
+//! Read an exr image.
+//!
+//! For great flexibility and customization, use the `read()` function.
+//! The return value of the `read()` function must be further customized before reading a file.
+
+//!
+//! For very simple applications, you can alternatively use one of these functions:
+//!
+//! 1. `read_first_rgba_layer_from_file(path, your_constructor, your_pixel_setter)`:
+//!     You specify how to store the pixels.
+//!     The first layer containing rgba channels is then loaded from the file.
+//!     Fails if no rgba layer can be found.
+//!
+//! 1. `read_all_rgba_layers_from_file(path, your_constructor, your_pixel_setter)`:
+//!     You specify how to store the pixels.
+//!     All layers containing rgba channels are then loaded from the file.
+//!     Fails if any layer in the image does not contain rgba channels.
+//!
+//! 1. `read_first_flat_layer_from_file(path)`:
+//!     The first layer containing non-deep data with arbitrary channels is loaded from the file.
+//!     Fails if no non-deep layer can be found.
+//!
+//! 1. `read_all_flat_layers_from_file(path)`:
+//!     All layers containing non-deep data with arbitrary channels are loaded from the file.
+//!     Fails if any layer in the image contains deep data.
+//!
+//! 1. `read_all_data_from_file(path)`:
+//!     All layers with arbitrary channels and all resolution levels are extracted from the file.
+//!
+//!     Note: Currently does not support deep data, and currently fails
+//!     if any layer in the image contains deep data.
+//!
+
+// The following three stages are internally used to read an image.
+// 1. `ReadImage` - The specification. Contains everything the user wants to tell us about loading an image.
+//    The data in this structure will be instantiated and might be borrowed.
+// 2. `ImageReader` - The temporary reader. Based on the specification of the blueprint,
+//    a reader is instantiated, once for each layer.
+//    This data structure accumulates the image data from the file.
+//    It also owns temporary data and references the blueprint.
+// 3. `Image` - The clean image. The accumulated data from the Reader
+//    is converted to the clean image structure, without temporary data.
+
+pub mod image;
+pub mod layers;
+pub mod any_channels;
+pub mod levels;
+pub mod samples;
+pub mod specific_channels;
+
+use crate::error::{Result};
+use crate::image::read::samples::{ReadFlatSamples};
+use std::path::Path;
+use crate::image::{AnyImage, AnyChannels, FlatSamples, Image, Layer, FlatImage, PixelLayersImage, RgbaChannels};
+use crate::image::read::image::ReadLayers;
+use crate::image::read::layers::ReadChannels;
+use crate::math::Vec2;
+use crate::prelude::{PixelImage};
+use crate::block::samples::FromNativeSample;
+
+
+/// All resolution levels, all channels, all layers.
+/// Does not support deep data yet. Uses parallel decompression and relaxed error handling.
+/// Inspect the source code of this function if you need customization.
+pub fn read_all_data_from_file(path: impl AsRef<Path>) -> Result<AnyImage> {
+    read()
+        .no_deep_data() // TODO deep data
+        .all_resolution_levels()
+        .all_channels()
+        .all_layers()
+        .all_attributes()
+        .from_file(path)
+}
+
+// FIXME do not throw error on deep data but just skip it!
+/// No deep data, no resolution levels, all channels, all layers.
+/// Uses parallel decompression and relaxed error handling.
+/// Inspect the source code of this function if you need customization.
+pub fn read_all_flat_layers_from_file(path: impl AsRef<Path>) -> Result<FlatImage> {
+    read()
+        .no_deep_data()
+        .largest_resolution_level()
+        .all_channels()
+        .all_layers()
+        .all_attributes()
+        .from_file(path)
+}
+
+/// No deep data, no resolution levels, all channels, first layer.
+/// Uses parallel decompression and relaxed error handling.
+/// Inspect the source code of this function if you need customization.
+pub fn read_first_flat_layer_from_file(path: impl AsRef<Path>) -> Result<Image<Layer<AnyChannels<FlatSamples>>>> {
+    read()
+        .no_deep_data()
+        .largest_resolution_level()
+        .all_channels()
+        .first_valid_layer()
+        .all_attributes()
+        .from_file(path)
+}
+
+/// No deep data, no resolution levels, rgba channels, all layers.
+/// If a single layer does not contain rgba data, this method returns an error.
+/// Uses parallel decompression and relaxed error handling.
+/// `Create` and `Set` can be closures, see the examples for more information.
+/// Inspect the source code of this function if you need customization.
+/// The alpha channel will contain the value `1.0` if no alpha channel can be found in the image.
+///
+/// Using two closures, define how to store the pixels.
+/// The first closure creates an image, and the second closure inserts a single pixel.
+/// The type of the pixel can be defined by the second closure;
+/// it must be a tuple containing four values, each being either `f16`, `f32`, `u32` or `Sample`.
+// FIXME Set and Create should not need to be static
+pub fn read_all_rgba_layers_from_file<R,G,B,A, Set:'static, Create:'static, Pixels: 'static>(
+    path: impl AsRef<Path>, create: Create, set_pixel: Set
+)
+    -> Result<PixelLayersImage<Pixels, RgbaChannels>>
+    where
+        R: FromNativeSample, G: FromNativeSample, B: FromNativeSample, A: FromNativeSample,
+        Create: Fn(Vec2<usize>, &RgbaChannels) -> Pixels, // TODO type alias? CreateRgbaPixels<Pixels=Pixels>,
+        Set: Fn(&mut Pixels, Vec2<usize>, (R,G,B,A)),
+{
+    read()
+        .no_deep_data()
+        .largest_resolution_level()
+        .rgba_channels(create, set_pixel)
+        .all_layers()
+        .all_attributes()
+        .from_file(path)
+}
+
+/// No deep data, no resolution levels, rgba channels, choosing the first layer with rgba channels.
+/// Uses parallel decompression and relaxed error handling.
+/// `Create` and `Set` can be closures, see the examples for more information.
+/// Inspect the source code of this function if you need customization.
+/// The alpha channel will contain the value `1.0` if no alpha channel can be found in the image.
+///
+/// Using two closures, define how to store the pixels.
+/// The first closure creates an image, and the second closure inserts a single pixel.
+/// The type of the pixel can be defined by the second closure;
+/// it must be a tuple containing four values, each being either `f16`, `f32`, `u32` or `Sample`.
+// FIXME Set and Create should not need to be static
+pub fn read_first_rgba_layer_from_file<R,G,B,A, Set:'static, Create:'static, Pixels: 'static>(
+    path: impl AsRef<Path>, create: Create, set_pixel: Set
+)
+    -> Result<PixelImage<Pixels, RgbaChannels>>
+    where
+        R: FromNativeSample, G: FromNativeSample, B: FromNativeSample, A: FromNativeSample,
+        Create: Fn(Vec2<usize>, &RgbaChannels) -> Pixels, // TODO type alias? CreateRgbaPixels<Pixels=Pixels>,
+        Set: Fn(&mut Pixels, Vec2<usize>, (R,G,B,A)),
+{
+    read()
+        .no_deep_data()
+        .largest_resolution_level()
+        .rgba_channels(create, set_pixel)
+        .first_valid_layer()
+        .all_attributes()
+        .from_file(path)
+}
+
+
+/// Utilizes the builder pattern to configure an image reader. This is the initial struct.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct ReadBuilder;
+
+/// Create a reader which can be used to load an exr image.
+/// Allows you to exactly specify how to load the image, for example:
+///
+/// ```no_run
+///     use exr::prelude::*;
+///
+///     // the type of the this image depends on the chosen options
+///     let image = read()
+///         .no_deep_data() // (currently required)
+///         .largest_resolution_level() // or `all_resolution_levels()`
+///         .all_channels() // or `rgba_channels(constructor, setter)`
+///         .all_layers() // or `first_valid_layer()`
+///         .all_attributes() // (currently required)
+///         .on_progress(|progress| println!("progress: {:.1}", progress*100.0)) // optional
+///         .from_file("image.exr").unwrap(); // or `from_buffered(my_byte_slice)`
+/// ```
+///
+/// You can alternatively use one of the following simpler functions:
+/// 1. `read_first_flat_layer_from_file`
+/// 1. `read_all_rgba_layers_from_file`
+/// 1. `read_all_flat_layers_from_file`
+/// 1. `read_all_data_from_file`
+///
+// TODO not panic but skip deep layers!
+pub fn read() -> ReadBuilder { ReadBuilder }
+
+impl ReadBuilder {
+
+    /// Specify to handle only one sample per channel, disabling "deep data".
+    // TODO not panic but skip deep layers!
+    pub fn no_deep_data(self) -> ReadFlatSamples { ReadFlatSamples }
+
+    // pub fn any_resolution_levels() -> ReadBuilder<> {}
+
+    // TODO
+    // e. g. `let sum = reader.any_channels_with(|sample, sum| sum += sample)`
+    // e. g. `let floats = reader.any_channels_with(|sample, f32_samples| f32_samples[index] = sample as f32)`
+    // pub fn no_deep_data_with <S> (self, storage: S) -> FlatSamplesWith<S> {  }
+
+    // pub fn flat_and_deep_data(self) -> ReadAnySamples { ReadAnySamples }
+}
diff --git a/vendor/exr/src/image/read/samples.rs b/vendor/exr/src/image/read/samples.rs
new file mode 100644
index 0000000..e03c3cc
--- /dev/null
+++ b/vendor/exr/src/image/read/samples.rs
@@ -0,0 +1,122 @@
+//! How to read samples (a grid of `f32`, `f16` or `u32` values).
+
+use crate::image::*;
+use crate::meta::header::{Header};
+use crate::error::{Result, UnitResult};
+use crate::block::lines::LineRef;
+use crate::math::Vec2;
+use crate::meta::attribute::{ChannelDescription, SampleType};
+use crate::image::read::any_channels::{SamplesReader, ReadSamples};
+use crate::image::read::levels::{ReadSamplesLevel, ReadAllLevels, ReadLargestLevel};
+use crate::block::chunk::TileCoordinates;
+// use crate::image::read::layers::ReadChannels;
+
+/// Specify to read only flat samples and no "deep data"
+// FIXME do not throw error on deep data but just skip it!
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct ReadFlatSamples;
+// pub struct ReadAnySamples;
+
+impl ReadFlatSamples {
+
+    // TODO
+    // e. g. `let sum = reader.any_channels_with(|sample, sum| sum += sample)`
+    // pub fn any_channels_with <S> (self, storage: S) -> {  }
+
+    /// Specify to read only the highest resolution level, skipping all smaller variations.
+    pub fn largest_resolution_level(self) -> ReadLargestLevel<Self> { ReadLargestLevel { read_samples: self } }
+
+    /// Specify to read all contained resolution levels from the image, if any.
+    pub fn all_resolution_levels(self) -> ReadAllLevels<Self> { ReadAllLevels { read_samples: self } }
+
+    // TODO pub fn specific_resolution_level<F: Fn(&[Vec2<usize>])->usize >(self, select_level: F) -> ReadLevelBy<Self> { ReadAllLevels { read_samples: self } }
+}
+
+
+/*pub struct AnySamplesReader { TODO
+    resolution: Vec2<usize>,
+    samples: DeepAndFlatSamples
+}*/
+
+/// Processes pixel blocks from a file and accumulates them into a grid of samples, for example "Red" or "Alpha".
+#[derive(Debug, Clone, PartialEq)]
+pub struct FlatSamplesReader {
+    level: Vec2<usize>,
+    resolution: Vec2<usize>,
+    samples: FlatSamples
+}
+
+
+// only used when samples is directly inside a channel, without levels
+impl ReadSamples for ReadFlatSamples {
+    type Reader = FlatSamplesReader;
+
+    fn create_sample_reader(&self, header: &Header, channel: &ChannelDescription) -> Result<Self::Reader> {
+        self.create_samples_level_reader(header, channel, Vec2(0, 0), header.layer_size)
+    }
+}
+
+impl ReadSamplesLevel for ReadFlatSamples {
+    type Reader = FlatSamplesReader;
+
+    fn create_samples_level_reader(&self, _header: &Header, channel: &ChannelDescription, level: Vec2<usize>, resolution: Vec2<usize>) -> Result<Self::Reader> {
+        Ok(FlatSamplesReader {
+            level, resolution, // TODO sampling
+            samples: match channel.sample_type {
+                SampleType::F16 => FlatSamples::F16(vec![f16::ZERO; resolution.area()]),
+                SampleType::F32 => FlatSamples::F32(vec![0.0; resolution.area()]),
+                SampleType::U32 => FlatSamples::U32(vec![0; resolution.area()]),
+            }
+        })
+    }
+}
+
+
+impl SamplesReader for FlatSamplesReader {
+    type Samples = FlatSamples;
+
+    fn filter_block(&self, tile: TileCoordinates) -> bool {
+        tile.level_index == self.level
+    }
+
+    fn read_line(&mut self, line: LineRef<'_>) -> UnitResult {
+        let index = line.location;
+        let resolution = self.resolution;
+
+        // the index is generated by ourselves and must always be correct
+        debug_assert_eq!(index.level, self.level, "line should have been filtered");
+        debug_assert!(index.position.x() + index.sample_count <= resolution.width(), "line index calculation bug");
+        debug_assert!(index.position.y() < resolution.height(), "line index calculation bug");
+        debug_assert_ne!(resolution.0, 0, "sample size bug");
+
+        let start_index = index.position.y() * resolution.width() + index.position.x();
+        let end_index = start_index + index.sample_count;
+
+        debug_assert!(
+            start_index < end_index && end_index <= self.samples.len(),
+            "for resolution {:?}, this is an invalid line: {:?}",
+            self.resolution, line.location
+        );
+
+        match &mut self.samples {
+            FlatSamples::F16(samples) =>
+                line.read_samples_into_slice(&mut samples[start_index .. end_index])
+                    .expect("writing line bytes failed"),
+
+            FlatSamples::F32(samples) =>
+                line.read_samples_into_slice(&mut samples[start_index .. end_index])
+                    .expect("writing line bytes failed"),
+
+            FlatSamples::U32(samples) =>
+                line.read_samples_into_slice(&mut samples[start_index .. end_index])
+                    .expect("writing line bytes failed"),
+        }
+
+        Ok(())
+    }
+
+    fn into_samples(self) -> FlatSamples {
+        self.samples
+    }
+}
+
diff --git a/vendor/exr/src/image/read/specific_channels.rs b/vendor/exr/src/image/read/specific_channels.rs
new file mode 100644
index 0000000..375691c
--- /dev/null
+++ b/vendor/exr/src/image/read/specific_channels.rs
@@ -0,0 +1,463 @@
+//! How to read arbitrary but specific selection of arbitrary channels.
+//! This is not a zero-cost abstraction.
+
+use crate::image::recursive::*;
+use crate::block::samples::*;
+use crate::image::*;
+use crate::math::*;
+use crate::meta::header::*;
+use crate::error::*;
+use crate::block::UncompressedBlock;
+use crate::image::read::layers::{ChannelsReader, ReadChannels};
+use crate::block::chunk::TileCoordinates;
+
+use std::marker::PhantomData;
+use crate::io::Read;
+
+
+/// Can be attached one more channel reader.
+/// Call `required` or `optional` on this object to declare another channel to be read from the file.
+/// Call `collect_pixels` at last to define how the previously declared pixels should be stored.
+pub trait ReadSpecificChannel: Sized + CheckDuplicates {
+
+    /// A separate internal reader for the pixels. Will be of type `Recursive<_, SampleReader<_>>`,
+    /// depending on the pixels of the specific channel combination.
+    type RecursivePixelReader: RecursivePixelReader;
+
+    /// Create a separate internal reader for the pixels of the specific channel combination.
+    fn create_recursive_reader(&self, channels: &ChannelList) -> Result<Self::RecursivePixelReader>;
+
+    /// Plan to read an additional channel from the image, with the specified name.
+    /// If the channel cannot be found in the image when the image is read, the image will not be loaded.
+    /// The generic parameter can usually be inferred from the closure in `collect_pixels`.
+    fn required<Sample>(self, channel_name: impl Into<Text>) -> ReadRequiredChannel<Self, Sample> {
+        let channel_name = channel_name.into();
+        assert!(self.already_contains(&channel_name).not(), "a channel with the name `{}` is already defined", channel_name);
+        ReadRequiredChannel { channel_name, previous_channels: self, px: Default::default() }
+    }
+
+    /// Plan to read an additional channel from the image, with the specified name.
+    /// If the file does not contain this channel, the specified default sample will be returned instead.
+    /// You can check whether the channel has been loaded by
+    /// checking the presence of the optional channel description before instantiating your own image.
+    /// The generic parameter can usually be inferred from the closure in `collect_pixels`.
+    fn optional<Sample>(self, channel_name: impl Into<Text>, default_sample: Sample)
+        -> ReadOptionalChannel<Self, Sample>
+    {
+        let channel_name = channel_name.into();
+        assert!(self.already_contains(&channel_name).not(), "a channel with the name `{}` is already defined", channel_name);
+        ReadOptionalChannel { channel_name, previous_channels: self, default_sample }
+    }
+
+    /// Using two closures, define how to store the pixels.
+    /// The first closure creates an image, and the second closure inserts a single pixel.
+    /// The type of the pixel can be defined by the second closure;
+    /// it must be a tuple containing `f16`, `f32`, `u32` or `Sample` values.
+    /// See the examples for more information.
+    fn collect_pixels<Pixel, PixelStorage, CreatePixels, SetPixel>(
+        self, create_pixels: CreatePixels, set_pixel: SetPixel
+    ) -> CollectPixels<Self, Pixel, PixelStorage, CreatePixels, SetPixel>
+        where
+            <Self::RecursivePixelReader as RecursivePixelReader>::RecursivePixel: IntoTuple<Pixel>,
+            <Self::RecursivePixelReader as RecursivePixelReader>::RecursiveChannelDescriptions: IntoNonRecursive,
+            CreatePixels: Fn(
+                Vec2<usize>,
+                &<<Self::RecursivePixelReader as RecursivePixelReader>::RecursiveChannelDescriptions as IntoNonRecursive>::NonRecursive
+            ) -> PixelStorage,
+            SetPixel: Fn(&mut PixelStorage, Vec2<usize>, Pixel),
+    {
+        CollectPixels { read_channels: self, set_pixel, create_pixels, px: Default::default() }
+    }
+}
+
+/// A reader containing sub-readers for reading the pixel content of an image.
+pub trait RecursivePixelReader {
+
+    /// The channel descriptions from the image.
+    /// Will be converted to a tuple before being stored in `SpecificChannels<_, ChannelDescriptions>`.
+    type RecursiveChannelDescriptions;
+
+    /// Returns the channel descriptions based on the channels in the file.
+    fn get_descriptions(&self) -> Self::RecursiveChannelDescriptions;
+
+    /// The pixel type. Will be converted to a tuple at the end of the process.
+    type RecursivePixel: Copy + Default + 'static;
+
+    /// Read the line of pixels.
+    fn read_pixels<'s, FullPixel>(
+        &self, bytes: &'s[u8], pixels: &mut [FullPixel],
+        get_pixel: impl Fn(&mut FullPixel) -> &mut Self::RecursivePixel
+    );
+}
+
+// does not use the generic `Recursive` struct to reduce the number of angle brackets in the public api
+/// Used to read another specific channel from an image.
+/// Contains the previous `ReadChannels` objects.
+#[derive(Clone, Debug)]
+pub struct ReadOptionalChannel<ReadChannels, Sample> {
+    previous_channels: ReadChannels,
+    channel_name: Text,
+    default_sample: Sample,
+}
+
+// does not use the generic `Recursive` struct to reduce the number of angle brackets in the public api
+/// Used to read another specific channel from an image.
+/// Contains the previous `ReadChannels` objects.
+#[derive(Clone, Debug)]
+pub struct ReadRequiredChannel<ReadChannels, Sample> {
+    previous_channels: ReadChannels,
+    channel_name: Text,
+    px: PhantomData<Sample>,
+}
+
+/// Specifies how to collect all the specified channels into a number of individual pixels.
+#[derive(Copy, Clone, Debug)]
+pub struct CollectPixels<ReadChannels, Pixel, PixelStorage, CreatePixels, SetPixel> {
+    read_channels: ReadChannels,
+    create_pixels: CreatePixels,
+    set_pixel: SetPixel,
+    px: PhantomData<(Pixel, PixelStorage)>,
+}
+
+impl<Inner: CheckDuplicates, Sample> CheckDuplicates for ReadRequiredChannel<Inner, Sample> {
+    fn already_contains(&self, name: &Text) -> bool {
+        &self.channel_name == name || self.previous_channels.already_contains(name)
+    }
+}
+
+impl<Inner: CheckDuplicates, Sample> CheckDuplicates for ReadOptionalChannel<Inner, Sample> {
+    fn already_contains(&self, name: &Text) -> bool {
+        &self.channel_name == name || self.previous_channels.already_contains(name)
+    }
+}
+
+impl<'s, InnerChannels, Pixel, PixelStorage, CreatePixels, SetPixel: 's>
+ReadChannels<'s> for CollectPixels<InnerChannels, Pixel, PixelStorage, CreatePixels, SetPixel>
+    where
+        InnerChannels: ReadSpecificChannel,
+        <InnerChannels::RecursivePixelReader as RecursivePixelReader>::RecursivePixel: IntoTuple<Pixel>,
+        <InnerChannels::RecursivePixelReader as RecursivePixelReader>::RecursiveChannelDescriptions: IntoNonRecursive,
+        CreatePixels: Fn(Vec2<usize>, &<<InnerChannels::RecursivePixelReader as RecursivePixelReader>::RecursiveChannelDescriptions as IntoNonRecursive>::NonRecursive) -> PixelStorage,
+        SetPixel: Fn(&mut PixelStorage, Vec2<usize>, Pixel),
+{
+    type Reader = SpecificChannelsReader<
+        PixelStorage, &'s SetPixel,
+        InnerChannels::RecursivePixelReader,
+        Pixel,
+    >;
+
+    fn create_channels_reader(&'s self, header: &Header) -> Result<Self::Reader> {
+        if header.deep { return Err(Error::invalid("`SpecificChannels` does not support deep data yet")) }
+
+        let pixel_reader = self.read_channels.create_recursive_reader(&header.channels)?;
+        let channel_descriptions = pixel_reader.get_descriptions().into_non_recursive();// TODO not call this twice
+
+        let create = &self.create_pixels;
+        let pixel_storage = create(header.layer_size, &channel_descriptions);
+
+        Ok(SpecificChannelsReader {
+            set_pixel: &self.set_pixel,
+            pixel_storage,
+            pixel_reader,
+            px: Default::default()
+        })
+    }
+}
+
+/// The reader that holds the temporary data that is required to read some specified channels.
+#[derive(Copy, Clone, Debug)]
+pub struct SpecificChannelsReader<PixelStorage, SetPixel, PixelReader, Pixel> {
+    set_pixel: SetPixel,
+    pixel_storage: PixelStorage,
+    pixel_reader: PixelReader,
+    px: PhantomData<Pixel>
+}
+
+impl<PixelStorage, SetPixel, PxReader, Pixel>
+ChannelsReader for SpecificChannelsReader<PixelStorage, SetPixel, PxReader, Pixel>
+    where PxReader: RecursivePixelReader,
+          PxReader::RecursivePixel: IntoTuple<Pixel>,
+          PxReader::RecursiveChannelDescriptions: IntoNonRecursive,
+          SetPixel: Fn(&mut PixelStorage, Vec2<usize>, Pixel),
+{
+    type Channels = SpecificChannels<PixelStorage, <PxReader::RecursiveChannelDescriptions as IntoNonRecursive>::NonRecursive>;
+
+    fn filter_block(&self, tile: TileCoordinates) -> bool { tile.is_largest_resolution_level() } // TODO all levels
+
+    fn read_block(&mut self, header: &Header, block: UncompressedBlock) -> UnitResult {
+        let mut pixels = vec![PxReader::RecursivePixel::default(); block.index.pixel_size.width()]; // TODO allocate once in self
+
+        let byte_lines = block.data.chunks_exact(header.channels.bytes_per_pixel * block.index.pixel_size.width());
+        debug_assert_eq!(byte_lines.len(), block.index.pixel_size.height(), "invalid block lines split");
+
+        for (y_offset, line_bytes) in byte_lines.enumerate() { // TODO sampling
+            // this two-step copy method should be very cache friendly in theory, and also reduce sample_type lookup count
+            self.pixel_reader.read_pixels(line_bytes, &mut pixels, |px| px);
+
+            for (x_offset, pixel) in pixels.iter().enumerate() {
+                let set_pixel = &self.set_pixel;
+                set_pixel(&mut self.pixel_storage, block.index.pixel_position + Vec2(x_offset, y_offset), pixel.into_tuple());
+            }
+        }
+
+        Ok(())
+    }
+
+    fn into_channels(self) -> Self::Channels {
+        SpecificChannels { channels: self.pixel_reader.get_descriptions().into_non_recursive(), pixels: self.pixel_storage }
+    }
+}
+
+
+/// Read zero channels from an image. Call `with_named_channel` on this object
+/// to read as many channels as desired.
+pub type ReadZeroChannels = NoneMore;
+
+impl ReadSpecificChannel for NoneMore {
+    type RecursivePixelReader = NoneMore;
+    fn create_recursive_reader(&self, _: &ChannelList) -> Result<Self::RecursivePixelReader> { Ok(NoneMore) }
+}
+
+impl<DefaultSample, ReadChannels> ReadSpecificChannel for ReadOptionalChannel<ReadChannels, DefaultSample>
+    where ReadChannels: ReadSpecificChannel, DefaultSample: FromNativeSample + 'static,
+{
+    type RecursivePixelReader = Recursive<ReadChannels::RecursivePixelReader, OptionalSampleReader<DefaultSample>>;
+
+    fn create_recursive_reader(&self, channels: &ChannelList) -> Result<Self::RecursivePixelReader> {
+        debug_assert!(self.previous_channels.already_contains(&self.channel_name).not(), "duplicate channel name: {}", self.channel_name);
+
+        let inner_samples_reader = self.previous_channels.create_recursive_reader(channels)?;
+        let reader = channels.channels_with_byte_offset()
+            .find(|(_, channel)| channel.name == self.channel_name)
+            .map(|(channel_byte_offset, channel)| SampleReader {
+                channel_byte_offset, channel: channel.clone(),
+                px: Default::default()
+            });
+
+        Ok(Recursive::new(inner_samples_reader, OptionalSampleReader {
+            reader, default_sample: self.default_sample,
+        }))
+    }
+}
+
+impl<Sample, ReadChannels> ReadSpecificChannel for ReadRequiredChannel<ReadChannels, Sample>
+    where ReadChannels: ReadSpecificChannel, Sample: FromNativeSample + 'static
+{
+    type RecursivePixelReader = Recursive<ReadChannels::RecursivePixelReader, SampleReader<Sample>>;
+
+    fn create_recursive_reader(&self, channels: &ChannelList) -> Result<Self::RecursivePixelReader> {
+        let previous_samples_reader = self.previous_channels.create_recursive_reader(channels)?;
+        let (channel_byte_offset, channel) = channels.channels_with_byte_offset()
+                .find(|(_, channel)| channel.name == self.channel_name)
+                .ok_or_else(|| Error::invalid(format!(
+                    "layer does not contain all of your specified channels (`{}` is missing)",
+                    self.channel_name
+                )))?;
+
+        Ok(Recursive::new(previous_samples_reader, SampleReader { channel_byte_offset, channel: channel.clone(), px: Default::default() }))
+    }
+}
+
+/// Reader for a single channel. Generic over the concrete sample type (f16, f32, u32).
+#[derive(Clone, Debug)]
+pub struct SampleReader<Sample> {
+
+    /// to be multiplied with line width!
+    channel_byte_offset: usize,
+
+    channel: ChannelDescription,
+    px: PhantomData<Sample>
+}
+
+/// Reader for a single channel. Generic over the concrete sample type (f16, f32, u32).
+/// Can also skip reading a channel if it could not be found in the image.
+#[derive(Clone, Debug)]
+pub struct OptionalSampleReader<DefaultSample> {
+    reader: Option<SampleReader<DefaultSample>>,
+    default_sample: DefaultSample,
+}
+
+impl<Sample: FromNativeSample> SampleReader<Sample> {
+    fn read_own_samples<'s, FullPixel>(
+        &self, bytes: &'s[u8], pixels: &mut [FullPixel],
+        get_sample: impl Fn(&mut FullPixel) -> &mut Sample
+    ){
+        let start_index = pixels.len() * self.channel_byte_offset;
+        let byte_count = pixels.len() * self.channel.sample_type.bytes_per_sample();
+        let mut own_bytes_reader = &mut &bytes[start_index .. start_index + byte_count]; // TODO check block size somewhere
+        let mut samples_out = pixels.iter_mut().map(|pixel| get_sample(pixel));
+
+        // match the type once for the whole line, not on every single sample
+        match self.channel.sample_type {
+            SampleType::F16 => read_and_convert_all_samples_batched(
+                &mut own_bytes_reader, &mut samples_out,
+                Sample::from_f16s
+            ),
+
+            SampleType::F32 => read_and_convert_all_samples_batched(
+                &mut own_bytes_reader, &mut samples_out,
+                Sample::from_f32s
+            ),
+
+            SampleType::U32 => read_and_convert_all_samples_batched(
+                &mut own_bytes_reader, &mut samples_out,
+                Sample::from_u32s
+            ),
+        }
+
+        debug_assert!(samples_out.next().is_none(), "not all samples have been converted");
+        debug_assert!(own_bytes_reader.is_empty(), "bytes left after reading all samples");
+    }
+}
+
+
+/// Does the same as `convert_batch(in_bytes.chunks().map(From::from_bytes))`, but vectorized.
+/// Reads the samples for one line, using the sample type specified in the file,
+/// and then converts those to the desired sample types.
+/// Uses batches to allow vectorization, converting multiple values with one instruction.
+fn read_and_convert_all_samples_batched<'t, From, To>(
+    mut in_bytes: impl Read,
+    out_samples: &mut impl ExactSizeIterator<Item=&'t mut To>,
+    convert_batch: fn(&[From], &mut [To])
+) where From: Data + Default + Copy, To: 't + Default + Copy
+{
+    // this is not a global! why is this warning triggered?
+    #[allow(non_upper_case_globals)]
+    const batch_size: usize = 16;
+
+    let total_sample_count = out_samples.len();
+    let batch_count = total_sample_count / batch_size;
+    let remaining_samples_count = total_sample_count % batch_size;
+
+    let len_error_msg = "sample count was miscalculated";
+    let byte_error_msg = "error when reading from in-memory slice";
+
+    // write samples from a given slice to the output iterator. should be inlined.
+    let output_n_samples = &mut move |samples: &[To]| {
+        for converted_sample in samples {
+            *out_samples.next().expect(len_error_msg) = *converted_sample;
+        }
+    };
+
+    // read samples from the byte source into a given slice. should be inlined.
+    // todo: use #[inline] when available
+    // error[E0658]: attributes on expressions are experimental,
+    // see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+    let read_n_samples = &mut move |samples: &mut [From]| {
+        Data::read_slice(&mut in_bytes, samples).expect(byte_error_msg);
+    };
+
+    // temporary arrays with fixed size, operations should be vectorized within these arrays
+    let mut source_samples_batch: [From; batch_size] = Default::default();
+    let mut desired_samples_batch: [To; batch_size] = Default::default();
+
+    // first convert all whole batches, size statically known to be 16 element arrays
+    for _ in 0 .. batch_count {
+        read_n_samples(&mut source_samples_batch);
+        convert_batch(source_samples_batch.as_slice(), desired_samples_batch.as_mut_slice());
+        output_n_samples(&desired_samples_batch);
+    }
+
+    // then convert a partial remaining batch, size known only at runtime
+    if remaining_samples_count != 0 {
+        let source_samples_batch = &mut source_samples_batch[..remaining_samples_count];
+        let desired_samples_batch = &mut desired_samples_batch[..remaining_samples_count];
+
+        read_n_samples(source_samples_batch);
+        convert_batch(source_samples_batch, desired_samples_batch);
+        output_n_samples(desired_samples_batch);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn equals_naive_f32(){
+        for total_array_size in [3, 7, 30, 41, 120, 10_423] {
+            let input_f32s = (0..total_array_size).map(|_| rand::random::<f32>()).collect::<Vec<f32>>();
+            let in_f32s_bytes = input_f32s.iter().cloned().flat_map(f32::to_le_bytes).collect::<Vec<u8>>();
+
+            let mut out_f16_samples_batched = vec![
+                f16::from_f32(rand::random::<f32>());
+                total_array_size
+            ];
+
+            read_and_convert_all_samples_batched(
+                &mut in_f32s_bytes.as_slice(),
+                &mut out_f16_samples_batched.iter_mut(),
+                f16::from_f32s
+            );
+
+            let out_f16_samples_naive = input_f32s.iter()
+                .cloned().map(f16::from_f32);
+
+            assert!(out_f16_samples_naive.eq(out_f16_samples_batched));
+        }
+    }
+}
+
+
+impl RecursivePixelReader for NoneMore {
+    type RecursiveChannelDescriptions = NoneMore;
+    fn get_descriptions(&self) -> Self::RecursiveChannelDescriptions { NoneMore }
+
+    type RecursivePixel = NoneMore;
+
+    fn read_pixels<'s, FullPixel>(
+        &self, _: &'s[u8], _: &mut [FullPixel],
+        _: impl Fn(&mut FullPixel) -> &mut NoneMore
+    ){}
+}
+
+impl<Sample, InnerReader: RecursivePixelReader>
+    RecursivePixelReader
+    for Recursive<InnerReader, SampleReader<Sample>>
+    where Sample: FromNativeSample + 'static
+{
+    type RecursiveChannelDescriptions = Recursive<InnerReader::RecursiveChannelDescriptions, ChannelDescription>;
+    fn get_descriptions(&self) -> Self::RecursiveChannelDescriptions { Recursive::new(self.inner.get_descriptions(), self.value.channel.clone()) }
+
+    type RecursivePixel = Recursive<InnerReader::RecursivePixel, Sample>;
+
+    fn read_pixels<'s, FullPixel>(
+        &self, bytes: &'s[u8], pixels: &mut [FullPixel],
+        get_pixel: impl Fn(&mut FullPixel) -> &mut Self::RecursivePixel
+    ) {
+        self.value.read_own_samples(bytes, pixels, |px| &mut get_pixel(px).value);
+        self.inner.read_pixels(bytes, pixels, |px| &mut get_pixel(px).inner);
+    }
+}
+
+impl<Sample, InnerReader: RecursivePixelReader>
+RecursivePixelReader
+for Recursive<InnerReader, OptionalSampleReader<Sample>>
+    where Sample: FromNativeSample + 'static
+{
+    type RecursiveChannelDescriptions = Recursive<InnerReader::RecursiveChannelDescriptions, Option<ChannelDescription>>;
+    fn get_descriptions(&self) -> Self::RecursiveChannelDescriptions { Recursive::new(
+        self.inner.get_descriptions(), self.value.reader.as_ref().map(|reader| reader.channel.clone())
+    ) }
+
+    type RecursivePixel = Recursive<InnerReader::RecursivePixel, Sample>;
+
+    fn read_pixels<'s, FullPixel>(
+        &self, bytes: &'s[u8], pixels: &mut [FullPixel],
+        get_pixel: impl Fn(&mut FullPixel) -> &mut Self::RecursivePixel
+    ) {
+        if let Some(reader) = &self.value.reader {
+            reader.read_own_samples(bytes, pixels, |px| &mut get_pixel(px).value);
+        }
+        else {
+            // if this channel is optional and was not found in the file, fill the default sample
+            for pixel in pixels.iter_mut() {
+                get_pixel(pixel).value = self.value.default_sample;
+            }
+        }
+
+        self.inner.read_pixels(bytes, pixels, |px| &mut get_pixel(px).inner);
+    }
+}
+
+
diff --git a/vendor/exr/src/image/recursive.rs b/vendor/exr/src/image/recursive.rs
new file mode 100644
index 0000000..25a980f
--- /dev/null
+++ b/vendor/exr/src/image/recursive.rs
@@ -0,0 +1,178 @@
+//! A generic wrapper which can be used to represent recursive types.
+//! Supports conversion from and to tuples of the same size.
+
+/// No more recursion. Can be used within any `Recursive<NoneMore, YourValue>` type.
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+pub struct NoneMore;
+
+/// A recursive type-level linked list of `Value` entries.
+/// Mainly used to represent an arbitrary number of channels.
+/// The recursive architecture removes the need to implement traits for many different tuples.
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+pub struct Recursive<Inner, Value> {
+    /// The remaining values of this linked list,
+    /// probably either `NoneMore` or another instance of the same `Recursive<Inner - 1, Value>`.
+    pub inner: Inner,
+
+    /// The next item in this linked list.
+    pub value: Value,
+}
+
+impl<Inner, Value> Recursive<Inner, Value> {
+    /// Create a new recursive type. Equivalent to the manual constructor, but less verbose.
+    pub fn new(inner: Inner, value: Value) -> Self { Self { inner, value } }
+}
+
+/// Convert this recursive type into a tuple.
+/// This is nice as it will require less typing for the same type.
+/// A type might or might not be convertible to the specified `Tuple` type.
+pub trait IntoTuple<Tuple> {
+    /// Convert this recursive type to a nice tuple.
+    fn into_tuple(self) -> Tuple;
+}
+
+/// Convert this recursive type into a tuple.
+/// This is nice as it will require less typing for the same type.
+/// A type will be converted to the specified `Self::NonRecursive` type.
+pub trait IntoNonRecursive {
+    /// The resulting tuple type.
+    type NonRecursive;
+
+    /// Convert this recursive type to a nice tuple.
+    fn into_non_recursive(self) -> Self::NonRecursive;
+}
+
+/// Create a recursive type from this tuple.
+pub trait IntoRecursive {
+    /// The recursive type resulting from this tuple.
+    type Recursive;
+
+    /// Create a recursive type from this tuple.
+    fn into_recursive(self) -> Self::Recursive;
+}
+
+impl IntoRecursive for NoneMore {
+    type Recursive = Self;
+    fn into_recursive(self) -> Self::Recursive { self }
+}
+
+impl<Inner: IntoRecursive, Value> IntoRecursive for Recursive<Inner, Value> {
+    type Recursive = Recursive<Inner::Recursive, Value>;
+    fn into_recursive(self) -> Self::Recursive { Recursive::new(self.inner.into_recursive(), self.value) }
+}
+
+// Automatically implement IntoTuple so we have to generate less code in the macros
+impl<I: IntoNonRecursive> IntoTuple<I::NonRecursive> for I {
+    fn into_tuple(self) -> <I as IntoNonRecursive>::NonRecursive {
+        self.into_non_recursive()
+    }
+}
+
+//Implement traits for the empty tuple, the macro doesn't handle that
+impl IntoRecursive for () {
+    type Recursive = NoneMore;
+    fn into_recursive(self) -> Self::Recursive { NoneMore }
+}
+
+impl IntoNonRecursive for NoneMore {
+    type NonRecursive = ();
+
+    fn into_non_recursive(self) -> Self::NonRecursive {
+        ()
+    }
+}
+
+/// Generates the recursive type corresponding to this tuple:
+/// ```nocheck
+/// gen_recursive_type!(A, B, C)
+/// => Recursive<Recursive<Recursive<NoneMore, A>, B>, C>
+/// ```
+macro_rules! gen_recursive_type {
+    () => { NoneMore };
+    ($last:ident $(,$not_last:ident)*) => {
+        Recursive<gen_recursive_type!($($not_last),*), $last>
+    };
+}
+
+/// Generates the recursive value corresponding to the given indices:
+/// ```nocheck
+/// gen_recursive_value(self; 1, 0)
+/// => Recursive { inner: Recursive {  inner: NoneMore, value: self.0 }, value: self.1 }
+/// ```
+macro_rules! gen_recursive_value {
+    ($self:ident;) => { NoneMore };
+    ($self:ident; $last:tt $(,$not_last:tt)*) => {
+        Recursive { inner: gen_recursive_value!($self; $($not_last),*), value: $self.$last }
+    };
+}
+
+/// Generates the into_tuple value corresponding to the given type names:
+/// ```nocheck
+/// gen_tuple_value(self; A, B, C)
+/// => (self.inner.inner.value, self.inner.value, self.value)
+/// ```
+macro_rules! gen_tuple_value {
+    ($self:ident; $($all:ident),* ) => {
+        gen_tuple_value!(@ $self; (); $($all),*  )
+    };
+
+    (@ $self:ident; ($($state:expr),*);) => { ($($state .value,)*) };
+    (@ $self:ident; ($($state:expr),*); $last:ident $(,$not_last:ident)* ) => {
+        gen_tuple_value!(@ $self; ($($state .inner,)* $self); $($not_last),*  )
+    };
+}
+
+/// Generate the trait implementations given a sequence of type names in both directions and the indices backwards:
+/// ```nocheck
+/// generate_single(A, B, C; C, B, A; 2, 1, 0)
+/// ```
+macro_rules! generate_single {
+    ( $($name_fwd:ident),* ; $($name_back:ident),* ; $($index_back:tt),*) => {
+        impl<$($name_fwd),*> IntoNonRecursive for gen_recursive_type!($($name_back),*) {
+            type NonRecursive = ($($name_fwd,)*);
+            fn into_non_recursive(self) -> Self::NonRecursive {
+                gen_tuple_value!(self; $($name_fwd),*)
+            }
+        }
+
+        impl<$($name_fwd),*> IntoRecursive for ($($name_fwd,)*) {
+            type Recursive = gen_recursive_type!($($name_back),*);
+            fn into_recursive(self) -> Self::Recursive {
+                gen_recursive_value!(self; $($index_back),*)
+            }
+        }
+    };
+}
+
+generate_single!(A; A; 0);
+generate_single!(A,B; B,A; 1,0);
+generate_single!(A,B,C; C,B,A; 2,1,0);
+generate_single!(A,B,C,D; D,C,B,A; 3,2,1,0);
+generate_single!(A,B,C,D,E; E,D,C,B,A; 4,3,2,1,0);
+generate_single!(A,B,C,D,E,F; F,E,D,C,B,A; 5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G; G,F,E,D,C,B,A; 6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H; H,G,F,E,D,C,B,A; 7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I; I,H,G,F,E,D,C,B,A; 8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J; J,I,H,G,F,E,D,C,B,A; 9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K; K,J,I,H,G,F,E,D,C,B,A; 10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L; L,K,J,I,H,G,F,E,D,C,B,A; 11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M; M,L,K,J,I,H,G,F,E,D,C,B,A; 12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N; N,M,L,K,J,I,H,G,F,E,D,C,B,A; 13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O; O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P; P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q; Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R; R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S; S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T; T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U; U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V; V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W; W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X; X,W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y; Y,X,W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z; Z,Y,X,W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1; A1,Z,Y,X,W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1; B1,A1,Z,Y,X,W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1; C1,B1,A1,Z,Y,X,W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1; D1,C1,B1,A1,Z,Y,X,W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1; E1,D1,C1,B1,A1,Z,Y,X,W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
+generate_single!(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,A1,B1,C1,D1,E1,F1; F1,E1,D1,C1,B1,A1,Z,Y,X,W,V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A; 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
diff --git a/vendor/exr/src/image/write/channels.rs b/vendor/exr/src/image/write/channels.rs
new file mode 100644
index 0000000..2450f09
--- /dev/null
+++ b/vendor/exr/src/image/write/channels.rs
@@ -0,0 +1,407 @@
+//! How to read arbitrary channels and rgb channels.
+
+use crate::prelude::*;
+use crate::io::*;
+use crate::math::*;
+use crate::meta::{header::*, attribute::*};
+use crate::block::*;
+use crate::image::recursive::*;
+use crate::block::samples::*;
+use crate::image::write::samples::*;
+
+use std::marker::PhantomData;
+
+
+/// Enables an image containing this list of channels to be written to a file.
+pub trait WritableChannels<'slf> {
+
+    /// Generate the file meta data for this list of channel
+    fn infer_channel_list(&self) -> ChannelList;
+
+    ///  Generate the file meta data of whether and how resolution levels should be stored in the file
+    fn infer_level_modes(&self) -> (LevelMode, RoundingMode);
+
+    /// The type of temporary writer
+    type Writer: ChannelsWriter;
+
+    /// Create a temporary writer for this list of channels
+    fn create_writer(&'slf self, header: &Header) -> Self::Writer;
+}
+
+/// A temporary writer for a list of channels
+pub trait ChannelsWriter: Sync {
+
+    /// Deliver a block of pixels, containing all channel data, to be stored in the file
+    fn extract_uncompressed_block(&self, header: &Header, block: BlockIndex) -> Vec<u8>; // TODO return uncompressed block?
+}
+
+
+/// Define how to get a pixel from your custom pixel storage.
+/// Can be a closure of type [`Sync + Fn(Vec2<usize>) -> YourPixel`].
+pub trait GetPixel: Sync {
+
+    /// The pixel tuple containing `f32`, `f16`, `u32` and `Sample` values.
+    /// The length of the tuple must match the number of channels in the image.
+    type Pixel;
+
+    /// Inspect a single pixel at the requested position.
+    /// Will be called exactly once for each pixel in the image.
+    /// The position will not exceed the image dimensions.
+    /// Might be called from multiple threads at the same time.
+    fn get_pixel(&self, position: Vec2<usize>) -> Self::Pixel;
+}
+
+impl<F, P> GetPixel for F where F: Sync + Fn(Vec2<usize>) -> P {
+    type Pixel = P;
+    fn get_pixel(&self, position: Vec2<usize>) -> P { self(position) }
+}
+
+impl<'samples, Samples> WritableChannels<'samples> for AnyChannels<Samples>
+    where Samples: 'samples + WritableSamples<'samples>
+{
+    fn infer_channel_list(&self) -> ChannelList {
+        ChannelList::new(self.list.iter().map(|channel| ChannelDescription {
+            name: channel.name.clone(),
+            sample_type: channel.sample_data.sample_type(),
+            quantize_linearly: channel.quantize_linearly,
+            sampling: channel.sampling
+        }).collect())
+    }
+
+    fn infer_level_modes(&self) -> (LevelMode, RoundingMode) {
+        let mode = self.list.iter().next().expect("zero channels in list").sample_data.infer_level_modes();
+
+        debug_assert!(
+            std::iter::repeat(mode).zip(self.list.iter().skip(1))
+                .all(|(first, other)| other.sample_data.infer_level_modes() == first),
+
+            "level mode must be the same across all levels (do not nest resolution levels!)"
+        );
+
+        mode
+    }
+
+    type Writer = AnyChannelsWriter<Samples::Writer>;
+    fn create_writer(&'samples self, header: &Header) -> Self::Writer {
+        let channels = self.list.iter()
+            .map(|chan| chan.sample_data.create_samples_writer(header))
+            .collect();
+
+        AnyChannelsWriter { channels }
+    }
+}
+
+/// A temporary writer for an arbitrary list of channels
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct AnyChannelsWriter<SamplesWriter> {
+    channels: SmallVec<[SamplesWriter; 4]>
+}
+
+impl<Samples> ChannelsWriter for AnyChannelsWriter<Samples> where Samples: SamplesWriter {
+    fn extract_uncompressed_block(&self, header: &Header, block_index: BlockIndex) -> Vec<u8> {
+        UncompressedBlock::collect_block_data_from_lines(&header.channels, block_index, |line_ref| {
+            self.channels[line_ref.location.channel].extract_line(line_ref)
+        })
+    }
+}
+
+
+
+
+
+
+impl<'c, Channels, Storage>
+WritableChannels<'c> for SpecificChannels<Storage, Channels>
+where
+    Storage: 'c + GetPixel,
+    Storage::Pixel: IntoRecursive,
+    Channels: 'c + Sync + Clone + IntoRecursive,
+    <Channels as IntoRecursive>::Recursive: WritableChannelsDescription<<Storage::Pixel as IntoRecursive>::Recursive>,
+{
+    fn infer_channel_list(&self) -> ChannelList {
+        let mut vec = self.channels.clone().into_recursive().channel_descriptions_list();
+        vec.sort_unstable_by_key(|channel:&ChannelDescription| channel.name.clone()); // TODO no clone?
+
+        debug_assert!(
+            // check for equal neighbors in sorted vec
+            vec.iter().zip(vec.iter().skip(1)).all(|(prev, next)| prev.name != next.name),
+            "specific channels contain duplicate channel names"
+        );
+
+        ChannelList::new(vec)
+    }
+
+    fn infer_level_modes(&self) -> (LevelMode, RoundingMode) {
+        (LevelMode::Singular, RoundingMode::Down) // TODO
+    }
+
+    type Writer = SpecificChannelsWriter<
+        'c,
+        <<Channels as IntoRecursive>::Recursive as WritableChannelsDescription<<Storage::Pixel as IntoRecursive>::Recursive>>::RecursiveWriter,
+        Storage,
+        Channels
+    >;
+
+    fn create_writer(&'c self, header: &Header) -> Self::Writer {
+        SpecificChannelsWriter {
+            channels: self,
+            recursive_channel_writer: self.channels.clone().into_recursive().create_recursive_writer(&header.channels),
+        }
+    }
+}
+
+
+
+/// A temporary writer for a layer of channels, alpha being optional
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct SpecificChannelsWriter<'channels, PixelWriter, Storage, Channels> {
+    channels: &'channels SpecificChannels<Storage, Channels>, // TODO this need not be a reference?? impl writer for specific_channels directly?
+    recursive_channel_writer: PixelWriter,
+}
+
+
+impl<'channels, PxWriter, Storage, Channels> ChannelsWriter
+for SpecificChannelsWriter<'channels, PxWriter, Storage, Channels>
+    where
+        Channels: Sync,
+        Storage: GetPixel,
+        Storage::Pixel: IntoRecursive,
+        PxWriter: Sync + RecursivePixelWriter<<Storage::Pixel as IntoRecursive>::Recursive>,
+{
+    fn extract_uncompressed_block(&self, header: &Header, block_index: BlockIndex) -> Vec<u8> {
+        let block_bytes = block_index.pixel_size.area() * header.channels.bytes_per_pixel;
+        let mut block_bytes = vec![0_u8; block_bytes];
+
+        let width = block_index.pixel_size.0;
+        let line_bytes = width * header.channels.bytes_per_pixel;
+        let byte_lines = block_bytes.chunks_exact_mut(line_bytes);
+        assert_eq!(byte_lines.len(), block_index.pixel_size.height(), "invalid block line splits");
+
+        //dbg!(width, line_bytes, header.channels.bytes_per_pixel, byte_lines.len());
+
+        let mut pixel_line = Vec::with_capacity(width);
+
+        for (y, line_bytes) in byte_lines.enumerate() {
+            pixel_line.clear();
+            pixel_line.extend((0 .. width).map(|x|
+                self.channels.pixels.get_pixel(block_index.pixel_position + Vec2(x, y)).into_recursive()
+            ));
+
+            self.recursive_channel_writer.write_pixels(line_bytes, pixel_line.as_slice(), |px| px);
+        }
+
+        block_bytes
+    }
+}
+
+/// A tuple containing either `ChannelsDescription` or `Option<ChannelsDescription>` entries.
+/// Use an `Option` if you want to dynamically omit a single channel (probably only for roundtrip tests).
+/// The number of entries must match the number of channels.
+pub trait WritableChannelsDescription<Pixel>: Sync {
+
+    /// A type that has a recursive entry for each channel in the image,
+    /// which must accept the desired pixel type.
+    type RecursiveWriter: RecursivePixelWriter<Pixel>;
+
+    /// Create the temporary writer, accepting the sorted list of channels from `channel_descriptions_list`.
+    fn create_recursive_writer(&self, channels: &ChannelList) -> Self::RecursiveWriter;
+
+    /// Return all the channels that should actually end up in the image, in any order.
+    fn channel_descriptions_list(&self) -> SmallVec<[ChannelDescription; 5]>;
+}
+
+impl WritableChannelsDescription<NoneMore> for NoneMore {
+    type RecursiveWriter = NoneMore;
+    fn create_recursive_writer(&self, _: &ChannelList) -> Self::RecursiveWriter { NoneMore }
+    fn channel_descriptions_list(&self) -> SmallVec<[ChannelDescription; 5]> { SmallVec::new() }
+}
+
+impl<InnerDescriptions, InnerPixel, Sample: IntoNativeSample>
+    WritableChannelsDescription<Recursive<InnerPixel, Sample>>
+    for Recursive<InnerDescriptions, ChannelDescription>
+    where InnerDescriptions: WritableChannelsDescription<InnerPixel>
+{
+    type RecursiveWriter = RecursiveWriter<InnerDescriptions::RecursiveWriter, Sample>;
+
+    fn create_recursive_writer(&self, channels: &ChannelList) -> Self::RecursiveWriter {
+        // this linear lookup is required because the order of the channels changed, due to alphabetical sorting
+        let (start_byte_offset, target_sample_type) = channels.channels_with_byte_offset()
+            .find(|(_offset, channel)| channel.name == self.value.name)
+            .map(|(offset, channel)| (offset, channel.sample_type))
+            .expect("a channel has not been put into channel list");
+
+        Recursive::new(self.inner.create_recursive_writer(channels), SampleWriter {
+            start_byte_offset, target_sample_type,
+            px: PhantomData::default()
+        })
+    }
+
+    fn channel_descriptions_list(&self) -> SmallVec<[ChannelDescription; 5]> {
+        let mut inner_list = self.inner.channel_descriptions_list();
+        inner_list.push(self.value.clone());
+        inner_list
+    }
+}
+
+impl<InnerDescriptions, InnerPixel, Sample: IntoNativeSample>
+WritableChannelsDescription<Recursive<InnerPixel, Sample>>
+for Recursive<InnerDescriptions, Option<ChannelDescription>>
+    where InnerDescriptions: WritableChannelsDescription<InnerPixel>
+{
+    type RecursiveWriter = OptionalRecursiveWriter<InnerDescriptions::RecursiveWriter, Sample>;
+
+    fn create_recursive_writer(&self, channels: &ChannelList) -> Self::RecursiveWriter {
+        // this linear lookup is required because the order of the channels changed, due to alphabetical sorting
+
+        let channel = self.value.as_ref().map(|required_channel|
+            channels.channels_with_byte_offset()
+                .find(|(_offset, channel)| channel == &required_channel)
+                .map(|(offset, channel)| (offset, channel.sample_type))
+                .expect("a channel has not been put into channel list")
+        );
+
+        Recursive::new(
+            self.inner.create_recursive_writer(channels),
+            channel.map(|(start_byte_offset, target_sample_type)| SampleWriter {
+                start_byte_offset, target_sample_type,
+                px: PhantomData::default(),
+            })
+        )
+    }
+
+    fn channel_descriptions_list(&self) -> SmallVec<[ChannelDescription; 5]> {
+        let mut inner_list = self.inner.channel_descriptions_list();
+        if let Some(value) = &self.value { inner_list.push(value.clone()); }
+        inner_list
+    }
+}
+
+/// Write pixels to a slice of bytes. The top level writer contains all the other channels,
+/// the most inner channel is `NoneMore`.
+pub trait RecursivePixelWriter<Pixel>: Sync {
+
+    /// Write pixels to a slice of bytes. Recursively do this for all channels.
+    fn write_pixels<FullPixel>(&self, bytes: &mut [u8], pixels: &[FullPixel], get_pixel: impl Fn(&FullPixel) -> &Pixel);
+}
+
+type RecursiveWriter<Inner, Sample> = Recursive<Inner, SampleWriter<Sample>>;
+type OptionalRecursiveWriter<Inner, Sample> = Recursive<Inner, Option<SampleWriter<Sample>>>;
+
+/// Write the pixels of a single channel, unconditionally. Generic over the concrete sample type (f16, f32, u32).
+#[derive(Debug, Clone)]
+pub struct SampleWriter<Sample> {
+    target_sample_type: SampleType,
+    start_byte_offset: usize,
+    px: PhantomData<Sample>,
+}
+
+impl<Sample> SampleWriter<Sample> where Sample: IntoNativeSample {
+    fn write_own_samples(&self, bytes: &mut [u8], samples: impl ExactSizeIterator<Item=Sample>) {
+        let byte_start_index = samples.len() * self.start_byte_offset;
+        let byte_count = samples.len() * self.target_sample_type.bytes_per_sample();
+        let ref mut byte_writer = &mut bytes[byte_start_index..byte_start_index + byte_count];
+
+        let write_error_msg = "invalid memory buffer length when writing";
+
+        // match outside the loop to avoid matching on every single sample
+        match self.target_sample_type {
+            // TODO does this boil down to a `memcpy` where the sample type equals the type parameter?
+            SampleType::F16 => for sample in samples { sample.to_f16().write(byte_writer).expect(write_error_msg); },
+            SampleType::F32 => for sample in samples { sample.to_f32().write(byte_writer).expect(write_error_msg); },
+            SampleType::U32 => for sample in samples { sample.to_u32().write(byte_writer).expect(write_error_msg); },
+        };
+
+        debug_assert!(byte_writer.is_empty(), "all samples are written, but more were expected");
+    }
+}
+
+impl RecursivePixelWriter<NoneMore> for NoneMore {
+    fn write_pixels<FullPixel>(&self, _: &mut [u8], _: &[FullPixel], _: impl Fn(&FullPixel) -> &NoneMore) {}
+}
+
+impl<Inner, InnerPixel, Sample: IntoNativeSample>
+    RecursivePixelWriter<Recursive<InnerPixel, Sample>>
+    for RecursiveWriter<Inner, Sample>
+    where Inner: RecursivePixelWriter<InnerPixel>
+{
+    // TODO impl exact size iterator <item = Self::Pixel>
+    fn write_pixels<FullPixel>(&self, bytes: &mut [u8], pixels: &[FullPixel], get_pixel: impl Fn(&FullPixel) -> &Recursive<InnerPixel, Sample>){
+        self.value.write_own_samples(bytes, pixels.iter().map(|px| get_pixel(px).value));
+        self.inner.write_pixels(bytes, pixels, |px| &get_pixel(px).inner);
+    }
+}
+
+impl<Inner, InnerPixel, Sample> RecursivePixelWriter<Recursive<InnerPixel, Sample>>
+    for OptionalRecursiveWriter<Inner, Sample>
+    where Inner: RecursivePixelWriter<InnerPixel>,
+        Sample: IntoNativeSample
+{
+    fn write_pixels<FullPixel>(&self, bytes: &mut [u8], pixels: &[FullPixel], get_pixel: impl Fn(&FullPixel) -> &Recursive<InnerPixel, Sample>) {
+        if let Some(writer) = &self.value {
+            writer.write_own_samples(bytes, pixels.iter().map(|px| get_pixel(px).value));
+        }
+
+        self.inner.write_pixels(bytes, pixels, |px| &get_pixel(px).inner);
+    }
+}
+
+
+
+
+
+
+
+#[cfg(test)]
+pub mod test {
+    use crate::image::write::channels::WritableChannels;
+    use crate::image::SpecificChannels;
+    use crate::prelude::{f16};
+    use crate::meta::attribute::{ChannelDescription, SampleType};
+    use crate::image::pixel_vec::PixelVec;
+
+    #[test]
+    fn compiles(){
+        let x = 3_f32;
+        let y = f16::from_f32(4.0);
+        let z = 2_u32;
+        let s = 1.3_f32;
+        let px = (x,y,z,s);
+
+        assert_is_writable_channels(
+            SpecificChannels::rgba(|_pos| px)
+        );
+
+        assert_is_writable_channels(SpecificChannels::rgba(
+            PixelVec::new((3, 2), vec![px, px, px, px, px, px])
+        ));
+
+        let px = (2333_u32, 4_f32);
+        assert_is_writable_channels(
+            SpecificChannels::build()
+                .with_channel("A")
+                .with_channel("C")
+                .with_pixels(PixelVec::new((3, 2), vec![px, px, px, px, px, px]))
+        );
+
+        let px = (3_f32, f16::ONE, 2333_u32, 4_f32);
+        assert_is_writable_channels(SpecificChannels::new(
+            (
+                ChannelDescription::named("x", SampleType::F32),
+                ChannelDescription::named("y", SampleType::F16),
+                Some(ChannelDescription::named("z", SampleType::U32)),
+                Some(ChannelDescription::named("p", SampleType::F32)),
+            ),
+
+            PixelVec::new((3, 2), vec![px, px, px, px, px, px])
+        ));
+
+
+
+        fn assert_is_writable_channels<'s>(_channels: impl WritableChannels<'s>){}
+
+    }
+}
+
+
+
+
diff --git a/vendor/exr/src/image/write/layers.rs b/vendor/exr/src/image/write/layers.rs
new file mode 100644
index 0000000..85648ff
--- /dev/null
+++ b/vendor/exr/src/image/write/layers.rs
@@ -0,0 +1,188 @@
+//! How to write either a single or a list of layers.
+
+use crate::meta::header::{ImageAttributes, Header};
+use crate::meta::{Headers, compute_chunk_count};
+use crate::block::BlockIndex;
+use crate::image::{Layers, Layer};
+use crate::meta::attribute::{TileDescription};
+use crate::prelude::{SmallVec};
+use crate::image::write::channels::{WritableChannels, ChannelsWriter};
+use crate::image::recursive::{Recursive, NoneMore};
+
+/// Enables an image containing this list of layers to be written to a file.
+pub trait WritableLayers<'slf> {
+
+    /// Generate the file meta data for this list of layers
+    fn infer_headers(&self, image_attributes: &ImageAttributes) -> Headers;
+
+    /// The type of temporary writer
+    type Writer: LayersWriter;
+
+    /// Create a temporary writer for this list of layers
+    fn create_writer(&'slf self, headers: &[Header]) -> Self::Writer;
+}
+
+/// A temporary writer for a list of channels
+pub trait LayersWriter: Sync {
+
+    /// Deliver a block of pixels from a single layer to be stored in the file
+    fn extract_uncompressed_block(&self, headers: &[Header], block: BlockIndex) -> Vec<u8>;
+}
+
+/// A temporary writer for an arbitrary list of layers
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct AllLayersWriter<ChannelsWriter> {
+    layers: SmallVec<[LayerWriter<ChannelsWriter>; 2]>
+}
+
+/// A temporary writer for a single layer
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct LayerWriter<ChannelsWriter> {
+    channels: ChannelsWriter, // impl ChannelsWriter
+}
+
+// impl for smallvec
+impl<'slf, Channels: 'slf> WritableLayers<'slf> for Layers<Channels> where Channels: WritableChannels<'slf> {
+    fn infer_headers(&self, image_attributes: &ImageAttributes) -> Headers {
+        slice_infer_headers(self.as_slice(), image_attributes)
+    }
+
+    type Writer = AllLayersWriter<Channels::Writer>;
+    fn create_writer(&'slf self, headers: &[Header]) -> Self::Writer {
+        slice_create_writer(self.as_slice(), headers)
+    }
+}
+
+fn slice_infer_headers<'slf, Channels:'slf + WritableChannels<'slf>>(
+    slice: &[Layer<Channels>], image_attributes: &ImageAttributes
+) -> Headers
+{
+    slice.iter().map(|layer| layer.infer_headers(image_attributes).remove(0)).collect() // TODO no array-vs-first
+}
+
+fn slice_create_writer<'slf, Channels:'slf + WritableChannels<'slf>>(
+    slice: &'slf [Layer<Channels>], headers: &[Header]
+) -> AllLayersWriter<Channels::Writer>
+{
+    AllLayersWriter {
+        layers: slice.iter().zip(headers.chunks_exact(1)) // TODO no array-vs-first
+            .map(|(layer, header)| layer.create_writer(header))
+            .collect()
+    }
+}
+
+
+impl<'slf, Channels: WritableChannels<'slf>> WritableLayers<'slf> for Layer<Channels> {
+    fn infer_headers(&self, image_attributes: &ImageAttributes) -> Headers {
+        let blocks = match self.encoding.blocks {
+            crate::image::Blocks::ScanLines => crate::meta::BlockDescription::ScanLines,
+            crate::image::Blocks::Tiles(tile_size) => {
+                let (level_mode, rounding_mode) = self.channel_data.infer_level_modes();
+                crate::meta::BlockDescription::Tiles(TileDescription { level_mode, rounding_mode, tile_size, })
+            },
+        };
+
+        let chunk_count = compute_chunk_count(
+            self.encoding.compression, self.size, blocks
+        );
+
+        let header = Header {
+            channels: self.channel_data.infer_channel_list(),
+            compression: self.encoding.compression,
+
+            blocks,
+            chunk_count,
+
+            line_order: self.encoding.line_order,
+            layer_size: self.size,
+            shared_attributes: image_attributes.clone(),
+            own_attributes: self.attributes.clone(),
+
+
+            deep: false, // TODO deep data
+            deep_data_version: None,
+            max_samples_per_pixel: None,
+        };
+
+        smallvec![ header ]// TODO no array-vs-first
+    }
+
+    type Writer = LayerWriter</*'l,*/ Channels::Writer>;
+    fn create_writer(&'slf self, headers: &[Header]) -> Self::Writer {
+        let channels = self.channel_data
+            .create_writer(headers.first().expect("inferred header error")); // TODO no array-vs-first
+
+        LayerWriter { channels }
+    }
+}
+
+impl<C> LayersWriter for AllLayersWriter<C> where C: ChannelsWriter {
+    fn extract_uncompressed_block(&self, headers: &[Header], block: BlockIndex) -> Vec<u8> {
+        self.layers[block.layer].extract_uncompressed_block(std::slice::from_ref(&headers[block.layer]), block) // TODO no array-vs-first
+    }
+}
+
+impl<C> LayersWriter for LayerWriter<C> where C: ChannelsWriter {
+    fn extract_uncompressed_block(&self, headers: &[Header], block: BlockIndex) -> Vec<u8> {
+        self.channels.extract_uncompressed_block(headers.first().expect("invalid inferred header"), block) // TODO no array-vs-first
+    }
+}
+
+
+
+
+
+impl<'slf> WritableLayers<'slf> for NoneMore {
+    fn infer_headers(&self, _: &ImageAttributes) -> Headers { SmallVec::new() }
+
+    type Writer = NoneMore;
+    fn create_writer(&'slf self, _: &[Header]) -> Self::Writer { NoneMore }
+}
+
+impl<'slf, InnerLayers, Channels> WritableLayers<'slf> for Recursive<InnerLayers, Layer<Channels>>
+    where InnerLayers: WritableLayers<'slf>, Channels: WritableChannels<'slf>
+{
+    fn infer_headers(&self, image_attributes: &ImageAttributes) -> Headers {
+        let mut headers = self.inner.infer_headers(image_attributes);
+        headers.push(self.value.infer_headers(image_attributes).remove(0)); // TODO no unwrap
+        headers
+    }
+
+    type Writer = RecursiveLayersWriter<InnerLayers::Writer, Channels::Writer>;
+
+    fn create_writer(&'slf self, headers: &[Header]) -> Self::Writer {
+        let (own_header, inner_headers) = headers.split_last()
+            .expect("header has not been inferred correctly");
+
+        let layer_index = inner_headers.len();
+        RecursiveLayersWriter {
+            inner: self.inner.create_writer(inner_headers),
+            value: (layer_index, self.value.create_writer(std::slice::from_ref(own_header))) // TODO no slice
+        }
+    }
+}
+
+type RecursiveLayersWriter<InnerLayersWriter, ChannelsWriter> = Recursive<InnerLayersWriter, (usize, LayerWriter<ChannelsWriter>)>;
+
+impl LayersWriter for NoneMore {
+    fn extract_uncompressed_block(&self, _: &[Header], _: BlockIndex) -> Vec<u8> {
+        panic!("recursive length mismatch bug");
+    }
+}
+
+impl<InnerLayersWriter, Channels> LayersWriter for RecursiveLayersWriter<InnerLayersWriter, Channels>
+    where InnerLayersWriter: LayersWriter, Channels: ChannelsWriter
+{
+    fn extract_uncompressed_block(&self, headers: &[Header], block: BlockIndex) -> Vec<u8> {
+        let (layer_index, layer) = &self.value;
+        if *layer_index == block.layer {
+            let header = headers.get(*layer_index).expect("layer index bug");
+            layer.extract_uncompressed_block(std::slice::from_ref(header), block) // TODO no slice?
+        }
+        else {
+            self.inner.extract_uncompressed_block(headers, block)
+        }
+    }
+}
+
+
diff --git a/vendor/exr/src/image/write/mod.rs b/vendor/exr/src/image/write/mod.rs
new file mode 100644
index 0000000..3c20060
--- /dev/null
+++ b/vendor/exr/src/image/write/mod.rs
@@ -0,0 +1,184 @@
+
+//! Write an exr image to a file.
+//!
+//! First, call `my_image.write()`. The resulting value can be customized, like this:
+//! ```no_run
+//!     use exr::prelude::*;
+//! #   let my_image: FlatImage = unimplemented!();
+//!
+//!     my_image.write()
+//!            .on_progress(|progress| println!("progress: {:.1}", progress*100.0))
+//!            .to_file("image.exr").unwrap();
+//! ```
+//!
+
+pub mod layers;
+pub mod samples;
+pub mod channels;
+
+
+
+use crate::meta::Headers;
+use crate::error::UnitResult;
+use std::io::{Seek, BufWriter};
+use crate::io::Write;
+use crate::image::{Image, ignore_progress, SpecificChannels, IntoSample};
+use crate::image::write::layers::{WritableLayers, LayersWriter};
+use crate::math::Vec2;
+use crate::block::writer::ChunksWriter;
+
+/// An oversimplified function for "just write the damn file already" use cases.
+/// Have a look at the examples to see how you can write an image with more flexibility (it's not that hard).
+/// Use `write_rgb_file` if you do not need an alpha channel.
+///
+/// Each of `R`, `G`, `B` and `A` can be either `f16`, `f32`, `u32`, or `Sample`.
+// TODO explain pixel tuple f32,f16,u32
+pub fn write_rgba_file<R,G,B,A>(
+    path: impl AsRef<std::path::Path>, width: usize, height: usize,
+    colors: impl Sync + Fn(usize, usize) -> (R, G, B, A)
+) -> UnitResult
+    where R: IntoSample, G: IntoSample, B: IntoSample, A: IntoSample,
+{
+    let channels = SpecificChannels::rgba(|Vec2(x,y)| colors(x,y));
+    Image::from_channels((width, height), channels).write().to_file(path)
+}
+
+/// An oversimplified function for "just write the damn file already" use cases.
+/// Have a look at the examples to see how you can write an image with more flexibility (it's not that hard).
+/// Use `write_rgb_file` if you do not need an alpha channel.
+///
+/// Each of `R`, `G`, and `B` can be either `f16`, `f32`, `u32`, or `Sample`.
+// TODO explain pixel tuple f32,f16,u32
+pub fn write_rgb_file<R,G,B>(
+    path: impl AsRef<std::path::Path>, width: usize, height: usize,
+    colors: impl Sync + Fn(usize, usize) -> (R, G, B)
+) -> UnitResult
+    where R: IntoSample, G: IntoSample, B: IntoSample
+{
+    let channels = SpecificChannels::rgb(|Vec2(x,y)| colors(x,y));
+    Image::from_channels((width, height), channels).write().to_file(path)
+}
+
+
+
+/// Enables an image to be written to a file. Call `image.write()` where this trait is implemented.
+pub trait WritableImage<'img, WritableLayers>: Sized {
+
+    /// Create a temporary writer which can be configured and used to write the image to a file.
+    fn write(self) -> WriteImageWithOptions<'img, WritableLayers, fn(f64)>;
+}
+
+impl<'img, WritableLayers> WritableImage<'img, WritableLayers> for &'img Image<WritableLayers> {
+    fn write(self) -> WriteImageWithOptions<'img, WritableLayers, fn(f64)> {
+        WriteImageWithOptions {
+            image: self,
+            check_compatibility: true,
+            parallel: true,
+            on_progress: ignore_progress
+        }
+    }
+}
+
+/// A temporary writer which can be configured and used to write an image to a file.
+// temporary writer with options
+#[derive(Debug, Clone, PartialEq)]
+pub struct WriteImageWithOptions<'img, Layers, OnProgress> {
+    image: &'img Image<Layers>,
+    on_progress: OnProgress,
+    check_compatibility: bool,
+    parallel: bool,
+}
+
+
+impl<'img, L, F> WriteImageWithOptions<'img, L, F>
+    where L: WritableLayers<'img>, F: FnMut(f64)
+{
+    /// Generate file meta data for this image. The meta data structure is close to the data in the file.
+    pub fn infer_meta_data(&self) -> Headers { // TODO this should perform all validity checks? and none after that?
+        self.image.layer_data.infer_headers(&self.image.attributes)
+    }
+
+    /// Do not compress multiple pixel blocks on multiple threads at once.
+    /// Might use less memory and synchronization, but will be slower in most situations.
+    pub fn non_parallel(self) -> Self { Self { parallel: false, ..self } }
+
+    /// Skip some checks that ensure a file can be opened by other exr software.
+    /// For example, it is no longer checked that no two headers or two attributes have the same name,
+    /// which might be an expensive check for images with an exorbitant number of headers.
+    ///
+    /// If you write an uncompressed file and need maximum speed, it might save a millisecond to disable the checks,
+    /// if you know that your file is not invalid any ways. I do not recommend this though,
+    /// as the file might not be readably by any other exr library after that.
+    /// __You must care for not producing an invalid file yourself.__
+    pub fn skip_compatibility_checks(self) -> Self { Self { check_compatibility: false, ..self } }
+
+    /// Specify a function to be called regularly throughout the writing process.
+    /// Replaces all previously specified progress functions in this reader.
+    pub fn on_progress<OnProgress>(self, on_progress: OnProgress) -> WriteImageWithOptions<'img, L, OnProgress>
+        where OnProgress: FnMut(f64)
+    {
+        WriteImageWithOptions {
+            on_progress,
+            image: self.image,
+            check_compatibility: self.check_compatibility,
+            parallel: self.parallel
+        }
+    }
+
+    /// Write the exr image to a file.
+    /// Use `to_unbuffered` instead, if you do not have a file.
+    /// If an error occurs, attempts to delete the partially written file.
+    #[inline]
+    #[must_use]
+    pub fn to_file(self, path: impl AsRef<std::path::Path>) -> UnitResult {
+        crate::io::attempt_delete_file_on_write_error(path.as_ref(), move |write|
+            self.to_unbuffered(write)
+        )
+    }
+
+    /// Buffer the writer and then write the exr image to it.
+    /// Use `to_buffered` instead, if your writer is an in-memory buffer.
+    /// Use `to_file` instead, if you have a file path.
+    /// If your writer cannot seek, you can write to an in-memory vector of bytes first, using `to_buffered`.
+    #[inline]
+    #[must_use]
+    pub fn to_unbuffered(self, unbuffered: impl Write + Seek) -> UnitResult {
+        self.to_buffered(BufWriter::new(unbuffered))
+    }
+
+    /// Write the exr image to a writer.
+    /// Use `to_file` instead, if you have a file path.
+    /// Use `to_unbuffered` instead, if this is not an in-memory writer.
+    /// If your writer cannot seek, you can write to an in-memory vector of bytes first.
+    #[must_use]
+    pub fn to_buffered(self, write: impl Write + Seek) -> UnitResult {
+        let headers = self.infer_meta_data();
+        let layers = self.image.layer_data.create_writer(&headers);
+
+        crate::block::write(
+            write, headers, self.check_compatibility,
+            move |meta, chunk_writer|{
+
+                let blocks = meta.collect_ordered_block_data(|block_index|
+                     layers.extract_uncompressed_block(&meta.headers, block_index)
+                );
+
+                let chunk_writer = chunk_writer.on_progress(self.on_progress);
+                if self.parallel { chunk_writer.compress_all_blocks_parallel(&meta, blocks)?; }
+                else { chunk_writer.compress_all_blocks_sequential(&meta, blocks)?; }
+                /*let blocks_writer = chunk_writer.as_blocks_writer(&meta);
+
+                // TODO propagate send requirement further upwards
+                if self.parallel {
+                    blocks_writer.compress_all_blocks_parallel(blocks)?;
+                }
+                else {
+                    blocks_writer.compress_all_blocks_sequential(blocks)?;
+                }*/
+
+                Ok(())
+            }
+        )
+    }
+}
+
diff --git a/vendor/exr/src/image/write/samples.rs b/vendor/exr/src/image/write/samples.rs
new file mode 100644
index 0000000..e74105b
--- /dev/null
+++ b/vendor/exr/src/image/write/samples.rs
@@ -0,0 +1,205 @@
+//! How to write samples (a grid of `f32`, `f16` or `u32` values).
+
+use crate::meta::attribute::{LevelMode, SampleType, TileDescription};
+use crate::meta::header::Header;
+use crate::block::lines::LineRefMut;
+use crate::image::{FlatSamples, Levels, RipMaps};
+use crate::math::{Vec2, RoundingMode};
+use crate::meta::{rip_map_levels, mip_map_levels, rip_map_indices, mip_map_indices, BlockDescription};
+
+/// Enable an image with this sample grid to be written to a file.
+/// Also can contain multiple resolution levels.
+/// Usually contained within `Channels`.
+pub trait WritableSamples<'slf> {
+    // fn is_deep(&self) -> bool;
+
+    /// Generate the file meta data regarding the number type of this storage
+    fn sample_type(&self) -> SampleType;
+
+    /// Generate the file meta data regarding resolution levels
+    fn infer_level_modes(&self) -> (LevelMode, RoundingMode);
+
+    /// The type of the temporary writer for this sample storage
+    type Writer: SamplesWriter;
+
+    /// Create a temporary writer for this sample storage
+    fn create_samples_writer(&'slf self, header: &Header) -> Self::Writer;
+}
+
+/// Enable an image with this single level sample grid to be written to a file.
+/// Only contained within `Levels`.
+pub trait WritableLevel<'slf> {
+
+    /// Generate the file meta data regarding the number type of these samples
+    fn sample_type(&self) -> SampleType;
+
+    /// The type of the temporary writer for this single level of samples
+    type Writer: SamplesWriter;
+
+    /// Create a temporary writer for this single level of samples
+    fn create_level_writer(&'slf self, size: Vec2<usize>) -> Self::Writer;
+}
+
+/// A temporary writer for one or more resolution levels containing samples
+pub trait SamplesWriter: Sync {
+
+    /// Deliver a single short horizontal list of samples for a specific channel.
+    fn extract_line(&self, line: LineRefMut<'_>);
+}
+
+/// A temporary writer for a predefined non-deep sample storage
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct FlatSamplesWriter<'samples> {
+    resolution: Vec2<usize>, // respects resolution level
+    samples: &'samples FlatSamples
+}
+
+
+
+// used if no layers are used and the flat samples are directly inside the channels
+impl<'samples> WritableSamples<'samples> for FlatSamples {
+    fn sample_type(&self) -> SampleType {
+        match self {
+            FlatSamples::F16(_) => SampleType::F16,
+            FlatSamples::F32(_) => SampleType::F32,
+            FlatSamples::U32(_) => SampleType::U32,
+        }
+    }
+
+    fn infer_level_modes(&self) -> (LevelMode, RoundingMode) { (LevelMode::Singular, RoundingMode::Down) }
+
+    type Writer = FlatSamplesWriter<'samples>; //&'s FlatSamples;
+    fn create_samples_writer(&'samples self, header: &Header) -> Self::Writer {
+        FlatSamplesWriter {
+            resolution: header.layer_size,
+            samples: self
+        }
+    }
+}
+
+// used if layers are used and the flat samples are inside the levels
+impl<'samples> WritableLevel<'samples> for FlatSamples {
+    fn sample_type(&self) -> SampleType {
+        match self {
+            FlatSamples::F16(_) => SampleType::F16,
+            FlatSamples::F32(_) => SampleType::F32,
+            FlatSamples::U32(_) => SampleType::U32,
+        }
+    }
+
+    type Writer = FlatSamplesWriter<'samples>;
+    fn create_level_writer(&'samples self, size: Vec2<usize>) -> Self::Writer {
+        FlatSamplesWriter {
+            resolution: size,
+            samples: self
+        }
+    }
+}
+
+impl<'samples> SamplesWriter for FlatSamplesWriter<'samples> {
+    fn extract_line(&self, line: LineRefMut<'_>) {
+        let image_width = self.resolution.width(); // header.layer_size.width();
+        debug_assert_ne!(image_width, 0, "image width calculation bug");
+
+        let start_index = line.location.position.y() * image_width + line.location.position.x();
+        let end_index = start_index + line.location.sample_count;
+
+        debug_assert!(
+            start_index < end_index && end_index <= self.samples.len(),
+            "for resolution {:?}, this is an invalid line: {:?}",
+            self.resolution, line.location
+        );
+
+        match self.samples {
+            FlatSamples::F16(samples) => line.write_samples_from_slice(&samples[start_index .. end_index]),
+            FlatSamples::F32(samples) => line.write_samples_from_slice(&samples[start_index .. end_index]),
+            FlatSamples::U32(samples) => line.write_samples_from_slice(&samples[start_index .. end_index]),
+        }.expect("writing line bytes failed");
+    }
+}
+
+
+impl<'samples, LevelSamples> WritableSamples<'samples> for Levels<LevelSamples>
+    where LevelSamples: WritableLevel<'samples>
+{
+    fn sample_type(&self) -> SampleType {
+        let sample_type = self.levels_as_slice().first().expect("no levels found").sample_type();
+
+        debug_assert!(
+            self.levels_as_slice().iter().skip(1).all(|ty| ty.sample_type() == sample_type),
+            "sample types must be the same across all levels"
+        );
+
+        sample_type
+    }
+
+    fn infer_level_modes(&self) -> (LevelMode, RoundingMode) {
+        match self {
+            Levels::Singular(_) => (LevelMode::Singular, RoundingMode::Down),
+            Levels::Mip { rounding_mode, .. } => (LevelMode::MipMap, *rounding_mode),
+            Levels::Rip { rounding_mode, .. } => (LevelMode::RipMap, *rounding_mode),
+        }
+    }
+
+    type Writer = LevelsWriter<LevelSamples::Writer>;
+    fn create_samples_writer(&'samples self, header: &Header) -> Self::Writer {
+        let rounding = match header.blocks {
+            BlockDescription::Tiles(TileDescription { rounding_mode, .. }) => Some(rounding_mode),
+            BlockDescription::ScanLines => None,
+        };
+
+        LevelsWriter {
+            levels: match self {
+                Levels::Singular(level) => Levels::Singular(level.create_level_writer(header.layer_size)),
+                Levels::Mip { level_data, rounding_mode } => {
+                    debug_assert_eq!(
+                        level_data.len(),
+                        mip_map_indices(rounding.expect("mip maps only with tiles"), header.layer_size).count(),
+                        "invalid mip map count"
+                    );
+
+                    Levels::Mip { // TODO store level size in image??
+                        rounding_mode: *rounding_mode,
+                        level_data: level_data.iter()
+                            .zip(mip_map_levels(rounding.expect("mip maps only with tiles"), header.layer_size))
+                            // .map(|level| level.create_samples_writer(header))
+                            .map(|(level, (_level_index, level_size))| level.create_level_writer(level_size))
+                            .collect()
+                    }
+                },
+                Levels::Rip { level_data, rounding_mode } => {
+                    debug_assert_eq!(level_data.map_data.len(), level_data.level_count.area(), "invalid rip level count");
+                    debug_assert_eq!(
+                        level_data.map_data.len(),
+                        rip_map_indices(rounding.expect("rip maps only with tiles"), header.layer_size).count(),
+                        "invalid rip map count"
+                    );
+
+                    Levels::Rip {
+                        rounding_mode: *rounding_mode,
+                        level_data: RipMaps {
+                            level_count: level_data.level_count,
+                            map_data: level_data.map_data.iter()
+                                .zip(rip_map_levels(rounding.expect("rip maps only with tiles"), header.layer_size))
+                                .map(|(level, (_level_index, level_size))| level.create_level_writer(level_size))
+                                .collect(),
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// A temporary writer for multiple resolution levels
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct LevelsWriter<SamplesWriter> {
+    levels: Levels<SamplesWriter>,
+}
+
+impl<Samples> SamplesWriter for LevelsWriter<Samples> where Samples: SamplesWriter {
+    fn extract_line(&self, line: LineRefMut<'_>) {
+        self.levels.get_level(line.location.level).expect("invalid level index") // TODO compute level size from line index??
+            .extract_line(line)
+    }
+}