Debian Codegraph @

.cargo/vendor/image/src/utils/mod.rs

raw
1 //! Utilities
2
3 use std::collections::TryReserveError;
4 use std::iter::repeat;
5
6 #[inline(always)]
7 pub(crate) fn expand_packed<F>(buf: &mut [u8], channels: usize, bit_depth: u8, mut func: F)
8 where
9 F: FnMut(u8, &mut [u8]),
10 {
11 let pixels = buf.len() / channels * bit_depth as usize;
12 let extra = pixels % 8;
13 let entries = pixels / 8
14 + match extra {
15 0 => 0,
16 _ => 1,
17 };
18 let mask = ((1u16 << bit_depth) - 1) as u8;
19 let i = (0..entries)
20 .rev() // Reverse iterator
21 .flat_map(|idx|
22 // This has to be reversed to
23 (0..8/bit_depth).map(|i| i*bit_depth).zip(repeat(idx)))
24 .skip(extra);
25 let buf_len = buf.len();
26 let j_inv = (channels..buf_len).step_by(channels);
27 for ((shift, i), j_inv) in i.zip(j_inv) {
28 let j = buf_len - j_inv;
29 let pixel = (buf[i] & (mask << shift)) >> shift;
30 func(pixel, &mut buf[j..(j + channels)]);
31 }
32 }
33
34 /// Expand a buffer of packed 1, 2, or 4 bits integers into u8's. Assumes that
35 /// every `row_size` entries there are padding bits up to the next byte boundary.
36 #[allow(dead_code)]
37 // When no image formats that use it are enabled
38 pub(crate) fn expand_bits(bit_depth: u8, row_size: u32, buf: &[u8]) -> Vec<u8> {
39 // Note: this conversion assumes that the scanlines begin on byte boundaries
40 let mask = (1u8 << bit_depth as usize) - 1;
41 let scaling_factor = 255 / ((1 << bit_depth as usize) - 1);
42 let bit_width = row_size * u32::from(bit_depth);
43 let skip = if bit_width % 8 == 0 {
44 0
45 } else {
46 (8 - bit_width % 8) / u32::from(bit_depth)
47 };
48 let row_len = row_size + skip;
49 let mut p = Vec::new();
50 let mut i = 0;
51 for v in buf {
52 for shift_inv in 1..=8 / bit_depth {
53 let shift = 8 - bit_depth * shift_inv;
54 // skip the pixels that can be neglected because scanlines should
55 // start at byte boundaries
56 if i % (row_len as usize) < (row_size as usize) {
57 let pixel = (v & (mask << shift as usize)) >> shift as usize;
58 p.push(pixel * scaling_factor);
59 }
60 i += 1;
61 }
62 }
63 p
64 }
65
66 /// Checks if the provided dimensions would cause an overflow.
67 #[allow(dead_code)]
68 // When no image formats that use it are enabled
69 pub(crate) fn check_dimension_overflow(width: u32, height: u32, bytes_per_pixel: u8) -> bool {
70 u64::from(width) * u64::from(height) > u64::MAX / u64::from(bytes_per_pixel)
71 }
72
73 #[allow(dead_code)]
74 // When no image formats that use it are enabled
75 pub(crate) fn vec_copy_to_u8<T>(vec: &[T]) -> Vec<u8>
76 where
77 T: bytemuck::Pod,
78 {
79 bytemuck::cast_slice(vec).to_owned()
80 }
81
82 #[inline]
83 pub(crate) fn clamp<N>(a: N, min: N, max: N) -> N
84 where
85 N: PartialOrd,
86 {
87 if a < min {
88 min
89 } else if a > max {
90 max
91 } else {
92 a
93 }
94 }
95
96 #[inline]
97 pub(crate) fn vec_try_with_capacity<T>(capacity: usize) -> Result<Vec<T>, TryReserveError> {
98 let mut vec = Vec::new();
99 vec.try_reserve_exact(capacity)?;
100 Ok(vec)
101 }
102
103 #[cfg(test)]
104 mod test {
105 #[test]
106 fn gray_to_luma8_skip() {
107 let check = |bit_depth, w, from, to| {
108 assert_eq!(super::expand_bits(bit_depth, w, from), to);
109 };
110 // Bit depth 1, skip is more than half a byte
111 check(
112 1,
113 10,
114 &[0b11110000, 0b11000000, 0b00001111, 0b11000000],
115 vec![
116 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255,
117 ],
118 );
119 // Bit depth 2, skip is more than half a byte
120 check(
121 2,
122 5,
123 &[0b11110000, 0b11000000, 0b00001111, 0b11000000],
124 vec![255, 255, 0, 0, 255, 0, 0, 255, 255, 255],
125 );
126 // Bit depth 2, skip is 0
127 check(
128 2,
129 4,
130 &[0b11110000, 0b00001111],
131 vec![255, 255, 0, 0, 0, 0, 255, 255],
132 );
133 // Bit depth 4, skip is half a byte
134 check(4, 1, &[0b11110011, 0b00001100], vec![255, 0]);
135 }
136 }