diff options
Diffstat (limited to 'vendor/exr/src/block/mod.rs')
| -rw-r--r-- | vendor/exr/src/block/mod.rs | 257 |
1 files changed, 0 insertions, 257 deletions
diff --git a/vendor/exr/src/block/mod.rs b/vendor/exr/src/block/mod.rs deleted file mode 100644 index 1d20aa8..0000000 --- a/vendor/exr/src/block/mod.rs +++ /dev/null @@ -1,257 +0,0 @@ -//! 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 |