Debian Codegraph @

.cargo/vendor/exr/src/compression/rle.rs

raw
1 use super::*;
2 use super::optimize_bytes::*;
3 use super::Error;
4 use super::Result;
5
6 // inspired by https://github.com/openexr/openexr/blob/master/OpenEXR/IlmImf/ImfRle.cpp
7
8 const MIN_RUN_LENGTH : usize = 3;
9 const MAX_RUN_LENGTH : usize = 127;
10
11
12 pub fn decompress_bytes(
13 channels: &ChannelList,
14 compressed_le: ByteVec,
15 rectangle: IntegerBounds,
16 expected_byte_size: usize,
17 pedantic: bool,
18 ) -> Result<ByteVec> {
19 let mut remaining_le = compressed_le.as_slice();
20 let mut decompressed_le = Vec::with_capacity(expected_byte_size.min(8*2048));
21
22 while !remaining_le.is_empty() && decompressed_le.len() != expected_byte_size {
23 let count = take_1(&mut remaining_le)? as i8 as i32;
24
25 if count < 0 {
26 // take the next '-count' bytes as-is
27 let values = take_n(&mut remaining_le, (-count) as usize)?;
28 decompressed_le.extend_from_slice(values);
29 }
30 else {
31 // repeat the next value 'count + 1' times
32 let value = take_1(&mut remaining_le)?;
33 decompressed_le.resize(decompressed_le.len() + count as usize + 1, value);
34 }
35 }
36
37 if pedantic && !remaining_le.is_empty() {
38 return Err(Error::invalid("data amount"));
39 }
40
41 differences_to_samples(&mut decompressed_le);
42 interleave_byte_blocks(&mut decompressed_le);
43 super::convert_little_endian_to_current(decompressed_le, channels, rectangle) // TODO no alloc
44 }
45
46 pub fn compress_bytes(channels: &ChannelList, uncompressed_ne: ByteVec, rectangle: IntegerBounds) -> Result<ByteVec> {
47 // see https://github.com/AcademySoftwareFoundation/openexr/blob/3bd93f85bcb74c77255f28cdbb913fdbfbb39dfe/OpenEXR/IlmImf/ImfTiledOutputFile.cpp#L750-L842
48 let mut data_le = super::convert_current_to_little_endian(uncompressed_ne, channels, rectangle)?;// TODO no alloc
49
50 separate_bytes_fragments(&mut data_le);
51 samples_to_differences(&mut data_le);
52
53 let mut compressed_le = Vec::with_capacity(data_le.len());
54 let mut run_start = 0;
55 let mut run_end = 1;
56
57 while run_start < data_le.len() {
58 while
59 run_end < data_le.len()
60 && data_le[run_start] == data_le[run_end]
61 && (run_end - run_start) as i32 - 1 < MAX_RUN_LENGTH as i32
62 {
63 run_end += 1;
64 }
65
66 if run_end - run_start >= MIN_RUN_LENGTH {
67 compressed_le.push(((run_end - run_start) as i32 - 1) as u8);
68 compressed_le.push(data_le[run_start]);
69 run_start = run_end;
70
71 } else {
72 while
73 run_end < data_le.len() && (
74 (run_end + 1 >= data_le.len() || data_le[run_end] != data_le[run_end + 1])
75 || (run_end + 2 >= data_le.len() || data_le[run_end + 1] != data_le[run_end + 2])
76 ) && run_end - run_start < MAX_RUN_LENGTH
77 {
78 run_end += 1;
79 }
80
81 compressed_le.push((run_start as i32 - run_end as i32) as u8);
82 compressed_le.extend_from_slice(&data_le[run_start .. run_end]);
83
84 run_start = run_end;
85 run_end += 1;
86 }
87 }
88
89 Ok(compressed_le)
90 }
91
92 fn take_1(slice: &mut &[u8]) -> Result<u8> {
93 if !slice.is_empty() {
94 let result = slice[0];
95 *slice = &slice[1..];
96 Ok(result)
97
98 } else {
99 Err(Error::invalid("compressed data"))
100 }
101 }
102
103 fn take_n<'s>(slice: &mut &'s [u8], n: usize) -> Result<&'s [u8]> {
104 if n <= slice.len() {
105 let (front, back) = slice.split_at(n);
106 *slice = back;
107 Ok(front)
108
109 } else {
110 Err(Error::invalid("compressed data"))
111 }
112 }