Initial vendor packages

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

1 files changed, 257 insertions, 0 deletions

diff --git a/vendor/exr/src/block/mod.rs b/vendor/exr/src/block/mod.rs
new file mode 100644
index 0000000..1d20aa8
--- /dev/null
+++ b/vendor/exr/src/block/mod.rs
@@ -0,0 +1,257 @@
+//! This is the low-level interface for the raw blocks of an image.
+//! See `exr::image` module for a high-level interface.
+//!
+//! Handle compressed and uncompressed pixel byte blocks. Includes compression and decompression,
+//! and reading a complete image into blocks.
+//!
+//! Start with the `block::read(...)`
+//! and `block::write(...)` functions.
+
+
+pub mod writer;
+pub mod reader;
+
+pub mod lines;
+pub mod samples;
+pub mod chunk;
+
+
+use std::io::{Read, Seek, Write};
+use crate::error::{Result, UnitResult, Error, usize_to_i32};
+use crate::meta::{Headers, MetaData, BlockDescription};
+use crate::math::Vec2;
+use crate::compression::ByteVec;
+use crate::block::chunk::{CompressedBlock, CompressedTileBlock, CompressedScanLineBlock, Chunk, TileCoordinates};
+use crate::meta::header::Header;
+use crate::block::lines::{LineIndex, LineRef, LineSlice, LineRefMut};
+use crate::meta::attribute::ChannelList;
+
+
+/// Specifies where a block of pixel data should be placed in the actual image.
+/// This is a globally unique identifier which
+/// includes the layer, level index, and pixel location.
+#[derive(Clone, Copy, Eq, Hash, PartialEq, Debug)]
+pub struct BlockIndex {
+
+    /// Index of the layer.
+    pub layer: usize,
+
+    /// Index of the top left pixel from the block within the data window.
+    pub pixel_position: Vec2<usize>,
+
+    /// Number of pixels in this block, extending to the right and downwards.
+    /// Stays the same across all resolution levels.
+    pub pixel_size: Vec2<usize>,
+
+    /// Index of the mip or rip level in the image.
+    pub level: Vec2<usize>,
+}
+
+/// Contains a block of pixel data and where that data should be placed in the actual image.
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct UncompressedBlock {
+
+    /// Location of the data inside the image.
+    pub index: BlockIndex,
+
+    /// Uncompressed pixel values of the whole block.
+    /// One or more scan lines may be stored together as a scan line block.
+    /// This byte vector contains all pixel rows, one after another.
+    /// For each line in the tile, for each channel, the row values are contiguous.
+    /// Stores all samples of the first channel, then all samples of the second channel, and so on.
+    pub data: ByteVec,
+}
+
+/// Immediately reads the meta data from the file.
+/// Then, returns a reader that can be used to read all pixel blocks.
+/// From the reader, you can pull each compressed chunk from the file.
+/// Alternatively, you can create a decompressor, and pull the uncompressed data from it.
+/// The reader is assumed to be buffered.
+pub fn read<R: Read + Seek>(buffered_read: R, pedantic: bool) -> Result<self::reader::Reader<R>> {
+    self::reader::Reader::read_from_buffered(buffered_read, pedantic)
+}
+
+/// Immediately writes the meta data to the file.
+/// Then, calls a closure with a writer that can be used to write all pixel blocks.
+/// In the closure, you can push compressed chunks directly into the writer.
+/// Alternatively, you can create a compressor, wrapping the writer, and push the uncompressed data to it.
+/// The writer is assumed to be buffered.
+pub fn write<W: Write + Seek>(
+    buffered_write: W, headers: Headers, compatibility_checks: bool,
+    write_chunks: impl FnOnce(MetaData, &mut self::writer::ChunkWriter<W>) -> UnitResult
+) -> UnitResult {
+    self::writer::write_chunks_with(buffered_write, headers, compatibility_checks, write_chunks)
+}
+
+
+
+
+/// This iterator tells you the block indices of all blocks that must be in the image.
+/// The order of the blocks depends on the `LineOrder` attribute
+/// (unspecified line order is treated the same as increasing line order).
+/// The blocks written to the file must be exactly in this order,
+/// except for when the `LineOrder` is unspecified.
+/// The index represents the block index, in increasing line order, within the header.
+pub fn enumerate_ordered_header_block_indices(headers: &[Header]) -> impl '_ + Iterator<Item=(usize, BlockIndex)> {
+    headers.iter().enumerate().flat_map(|(layer_index, header)|{
+        header.enumerate_ordered_blocks().map(move |(index_in_header, tile)|{
+            let data_indices = header.get_absolute_block_pixel_coordinates(tile.location).expect("tile coordinate bug");
+
+            let block = BlockIndex {
+                layer: layer_index,
+                level: tile.location.level_index,
+                pixel_position: data_indices.position.to_usize("data indices start").expect("data index bug"),
+                pixel_size: data_indices.size,
+            };
+
+            (index_in_header, block)
+        })
+    })
+}
+
+
+impl UncompressedBlock {
+
+    /// Decompress the possibly compressed chunk and returns an `UncompressedBlock`.
+    // for uncompressed data, the ByteVec in the chunk is moved all the way
+    #[inline]
+    #[must_use]
+    pub fn decompress_chunk(chunk: Chunk, meta_data: &MetaData, pedantic: bool) -> Result<Self> {
+        let header: &Header = meta_data.headers.get(chunk.layer_index)
+            .ok_or(Error::invalid("chunk layer index"))?;
+
+        let tile_data_indices = header.get_block_data_indices(&chunk.compressed_block)?;
+        let absolute_indices = header.get_absolute_block_pixel_coordinates(tile_data_indices)?;
+
+        absolute_indices.validate(Some(header.layer_size))?;
+
+        match chunk.compressed_block {
+            CompressedBlock::Tile(CompressedTileBlock { compressed_pixels, .. }) |
+            CompressedBlock::ScanLine(CompressedScanLineBlock { compressed_pixels, .. }) => {
+                Ok(UncompressedBlock {
+                    data: header.compression.decompress_image_section(header, compressed_pixels, absolute_indices, pedantic)?,
+                    index: BlockIndex {
+                        layer: chunk.layer_index,
+                        pixel_position: absolute_indices.position.to_usize("data indices start")?,
+                        level: tile_data_indices.level_index,
+                        pixel_size: absolute_indices.size,
+                    }
+                })
+            },
+
+            _ => return Err(Error::unsupported("deep data not supported yet"))
+        }
+    }
+
+    /// Consume this block by compressing it, returning a `Chunk`.
+    // for uncompressed data, the ByteVec in the chunk is moved all the way
+    #[inline]
+    #[must_use]
+    pub fn compress_to_chunk(self, headers: &[Header]) -> Result<Chunk> {
+        let UncompressedBlock { data, index } = self;
+
+        let header: &Header = headers.get(index.layer)
+            .expect("block layer index bug");
+
+        let expected_byte_size = header.channels.bytes_per_pixel * self.index.pixel_size.area(); // TODO sampling??
+        if expected_byte_size != data.len() {
+            panic!("get_line byte size should be {} but was {}", expected_byte_size, data.len());
+        }
+
+        let tile_coordinates = TileCoordinates {
+            // FIXME this calculation should not be made here but elsewhere instead (in meta::header?)
+            tile_index: index.pixel_position / header.max_block_pixel_size(), // TODO sampling??
+            level_index: index.level,
+        };
+
+        let absolute_indices = header.get_absolute_block_pixel_coordinates(tile_coordinates)?;
+        absolute_indices.validate(Some(header.layer_size))?;
+
+        if !header.compression.may_loose_data() { debug_assert_eq!(
+            &header.compression.decompress_image_section(
+                header,
+                header.compression.compress_image_section(header, data.clone(), absolute_indices)?,
+                absolute_indices,
+                true
+            ).unwrap(),
+            &data,
+            "compression method not round trippin'"
+        ); }
+
+        let compressed_data = header.compression.compress_image_section(header, data, absolute_indices)?;
+
+        Ok(Chunk {
+            layer_index: index.layer,
+            compressed_block : match header.blocks {
+                BlockDescription::ScanLines => CompressedBlock::ScanLine(CompressedScanLineBlock {
+                    compressed_pixels: compressed_data,
+
+                    // FIXME this calculation should not be made here but elsewhere instead (in meta::header?)
+                    y_coordinate: usize_to_i32(index.pixel_position.y()) + header.own_attributes.layer_position.y(), // TODO sampling??
+                }),
+
+                BlockDescription::Tiles(_) => CompressedBlock::Tile(CompressedTileBlock {
+                    compressed_pixels: compressed_data,
+                    coordinates: tile_coordinates,
+                }),
+            }
+        })
+    }
+
+    /// Iterate all the lines in this block.
+    /// Each line contains the all samples for one of the channels.
+    pub fn lines(&self, channels: &ChannelList) -> impl Iterator<Item=LineRef<'_>> {
+        LineIndex::lines_in_block(self.index, channels)
+            .map(move |(bytes, line)| LineSlice { location: line, value: &self.data[bytes] })
+    }
+
+    /* TODO pub fn lines_mut<'s>(&'s mut self, header: &Header) -> impl 's + Iterator<Item=LineRefMut<'s>> {
+        LineIndex::lines_in_block(self.index, &header.channels)
+            .map(move |(bytes, line)| LineSlice { location: line, value: &mut self.data[bytes] })
+    }*/
+
+    /*// TODO make iterator
+    /// Call a closure for each line of samples in this uncompressed block.
+    pub fn for_lines(
+        &self, header: &Header,
+        mut accept_line: impl FnMut(LineRef<'_>) -> UnitResult
+    ) -> UnitResult {
+        for (bytes, line) in LineIndex::lines_in_block(self.index, &header.channels) {
+            let line_ref = LineSlice { location: line, value: &self.data[bytes] };
+            accept_line(line_ref)?;
+        }
+
+        Ok(())
+    }*/
+
+    // TODO from iterator??
+    /// Create an uncompressed block byte vector by requesting one line of samples after another.
+    pub fn collect_block_data_from_lines(
+        channels: &ChannelList, block_index: BlockIndex,
+        mut extract_line: impl FnMut(LineRefMut<'_>)
+    ) -> Vec<u8>
+    {
+        let byte_count = block_index.pixel_size.area() * channels.bytes_per_pixel;
+        let mut block_bytes = vec![0_u8; byte_count];
+
+        for (byte_range, line_index) in LineIndex::lines_in_block(block_index, channels) {
+            extract_line(LineRefMut { // TODO subsampling
+                value: &mut block_bytes[byte_range],
+                location: line_index,
+            });
+        }
+
+        block_bytes
+    }
+
+    /// Create an uncompressed block by requesting one line of samples after another.
+    pub fn from_lines(
+        channels: &ChannelList, block_index: BlockIndex,
+        extract_line: impl FnMut(LineRefMut<'_>)
+    ) -> Self {
+        Self {
+            index: block_index,
+            data: Self::collect_block_data_from_lines(channels, block_index, extract_line)
+        }
+    }
+}
\ No newline at end of file