Debian Codegraph @

.cargo/vendor/qoi/tests/test_gen.rs

raw
1 mod common;
2
3 use bytemuck::cast_slice;
4 use std::borrow::Cow;
5 use std::fmt::Debug;
6
7 use cfg_if::cfg_if;
8 use rand::{
9 distributions::{Distribution, Standard},
10 rngs::StdRng,
11 Rng, SeedableRng,
12 };
13
14 use libqoi::{qoi_decode, qoi_encode};
15 use qoi::consts::{
16 QOI_HEADER_SIZE, QOI_MASK_2, QOI_OP_DIFF, QOI_OP_INDEX, QOI_OP_LUMA, QOI_OP_RGB, QOI_OP_RGBA,
17 QOI_OP_RUN, QOI_PADDING_SIZE,
18 };
19 use qoi::{decode_header, decode_to_vec, encode_to_vec};
20
21 use self::common::hash;
22
23 struct GenState<const N: usize> {
24 index: [[u8; N]; 64],
25 pixels: Vec<u8>,
26 prev: [u8; N],
27 len: usize,
28 }
29
30 impl<const N: usize> GenState<N> {
31 pub fn with_capacity(capacity: usize) -> Self {
32 Self {
33 index: [[0; N]; 64],
34 pixels: Vec::with_capacity(capacity * N),
35 prev: Self::zero(),
36 len: 0,
37 }
38 }
39 pub fn write(&mut self, px: [u8; N]) {
40 self.index[hash(px) as usize] = px;
41 for i in 0..N {
42 self.pixels.push(px[i]);
43 }
44 self.prev = px;
45 self.len += 1;
46 }
47
48 pub fn pick_from_index(&self, rng: &mut impl Rng) -> [u8; N] {
49 self.index[rng.gen_range(0_usize..64)]
50 }
51
52 pub fn zero() -> [u8; N] {
53 let mut px = [0; N];
54 if N >= 4 {
55 px[3] = 0xff;
56 }
57 px
58 }
59 }
60
61 struct ImageGen {
62 p_new: f64,
63 p_index: f64,
64 p_repeat: f64,
65 p_diff: f64,
66 p_luma: f64,
67 }
68
69 impl ImageGen {
70 pub fn new_random(rng: &mut impl Rng) -> Self {
71 let p: [f64; 6] = rng.gen();
72 let t = p.iter().sum::<f64>();
73 Self {
74 p_new: p[0] / t,
75 p_index: p[1] / t,
76 p_repeat: p[2] / t,
77 p_diff: p[3] / t,
78 p_luma: p[4] / t,
79 }
80 }
81
82 pub fn generate(&self, rng: &mut impl Rng, channels: usize, min_len: usize) -> Vec<u8> {
83 match channels {
84 3 => self.generate_const::<_, 3>(rng, min_len),
85 4 => self.generate_const::<_, 4>(rng, min_len),
86 _ => panic!(),
87 }
88 }
89
90 fn generate_const<R: Rng, const N: usize>(&self, rng: &mut R, min_len: usize) -> Vec<u8>
91 where
92 Standard: Distribution<[u8; N]>,
93 {
94 let mut s = GenState::<N>::with_capacity(min_len);
95 let zero = GenState::<N>::zero();
96
97 while s.len < min_len {
98 let mut p = rng.gen_range(0.0..1.0);
99
100 if p < self.p_new {
101 s.write(rng.gen());
102 continue;
103 }
104 p -= self.p_new;
105
106 if p < self.p_index {
107 let px = s.pick_from_index(rng);
108 s.write(px);
109 continue;
110 }
111 p -= self.p_index;
112
113 if p < self.p_repeat {
114 let px = s.prev;
115 let n_repeat = rng.gen_range(1_usize..=70);
116 for _ in 0..n_repeat {
117 s.write(px);
118 }
119 continue;
120 }
121 p -= self.p_repeat;
122
123 if p < self.p_diff {
124 let mut px = s.prev;
125 px[0] = px[0].wrapping_add(rng.gen_range(0_u8..4).wrapping_sub(2));
126 px[1] = px[1].wrapping_add(rng.gen_range(0_u8..4).wrapping_sub(2));
127 px[2] = px[2].wrapping_add(rng.gen_range(0_u8..4).wrapping_sub(2));
128 s.write(px);
129 continue;
130 }
131 p -= self.p_diff;
132
133 if p < self.p_luma {
134 let mut px = s.prev;
135 let vg = rng.gen_range(0_u8..64).wrapping_sub(32);
136 let vr = rng.gen_range(0_u8..16).wrapping_sub(8).wrapping_add(vg);
137 let vb = rng.gen_range(0_u8..16).wrapping_sub(8).wrapping_add(vg);
138 px[0] = px[0].wrapping_add(vr);
139 px[1] = px[1].wrapping_add(vg);
140 px[2] = px[2].wrapping_add(vb);
141 s.write(px);
142 continue;
143 }
144
145 s.write(zero);
146 }
147
148 s.pixels
149 }
150 }
151
152 fn format_encoded(encoded: &[u8]) -> String {
153 let header = decode_header(encoded).unwrap();
154 let mut data = &encoded[QOI_HEADER_SIZE..encoded.len() - QOI_PADDING_SIZE];
155 let mut s = format!("{}x{}:{} = [", header.width, header.height, header.channels.as_u8());
156 while !data.is_empty() {
157 let b1 = data[0];
158 data = &data[1..];
159 match b1 {
160 QOI_OP_RGB => {
161 s.push_str(&format!("rgb({},{},{})", data[0], data[1], data[2]));
162 data = &data[3..];
163 }
164 QOI_OP_RGBA => {
165 s.push_str(&format!("rgba({},{},{},{})", data[0], data[1], data[2], data[3]));
166 data = &data[4..];
167 }
168 _ => match b1 & QOI_MASK_2 {
169 QOI_OP_INDEX => s.push_str(&format!("index({})", b1 & 0x3f)),
170 QOI_OP_RUN => s.push_str(&format!("run({})", b1 & 0x3f)),
171 QOI_OP_DIFF => s.push_str(&format!(
172 "diff({},{},{})",
173 (b1 >> 4) & 0x03,
174 (b1 >> 2) & 0x03,
175 b1 & 0x03
176 )),
177 QOI_OP_LUMA => {
178 let b2 = data[0];
179 data = &data[1..];
180 s.push_str(&format!("luma({},{},{})", (b2 >> 4) & 0x0f, b1 & 0x3f, b2 & 0x0f))
181 }
182 _ => {}
183 },
184 }
185 s.push_str(", ");
186 }
187 s.pop().unwrap();
188 s.pop().unwrap();
189 s.push(']');
190 s
191 }
192
193 fn check_roundtrip<E, D, VE, VD, EE, ED>(
194 msg: &str, mut data: &[u8], channels: usize, encode: E, decode: D,
195 ) where
196 E: Fn(&[u8], u32) -> Result<VE, EE>,
197 D: Fn(&[u8]) -> Result<VD, ED>,
198 VE: AsRef<[u8]>,
199 VD: AsRef<[u8]>,
200 EE: Debug,
201 ED: Debug,
202 {
203 macro_rules! rt {
204 ($data:expr, $n:expr) => {
205 decode(encode($data, $n as _).unwrap().as_ref()).unwrap()
206 };
207 }
208 macro_rules! fail {
209 ($msg:expr, $data:expr, $decoded:expr, $encoded:expr, $channels:expr) => {
210 assert!(
211 false,
212 "{} roundtrip failed\n\n image: {:?}\ndecoded: {:?}\nencoded: {}",
213 $msg,
214 cast_slice::<_, [u8; $channels]>($data.as_ref()),
215 cast_slice::<_, [u8; $channels]>($decoded.as_ref()),
216 format_encoded($encoded.as_ref()),
217 );
218 };
219 }
220
221 let mut n_pixels = data.len() / channels;
222 assert_eq!(n_pixels * channels, data.len());
223
224 // if all ok, return
225 // ... but if roundtrip check fails, try to reduce the example to the smallest we can find
226 if rt!(data, n_pixels).as_ref() == data {
227 return;
228 }
229
230 // try removing pixels from the beginning
231 while n_pixels > 1 {
232 let slice = &data[..data.len() - channels];
233 if rt!(slice, n_pixels - 1).as_ref() != slice {
234 data = slice;
235 n_pixels -= 1;
236 } else {
237 break;
238 }
239 }
240
241 // try removing pixels from the end
242 while n_pixels > 1 {
243 let slice = &data[channels..];
244 if rt!(slice, n_pixels - 1).as_ref() != slice {
245 data = slice;
246 n_pixels -= 1;
247 } else {
248 break;
249 }
250 }
251
252 // try removing pixels from the middle
253 let mut data = Cow::from(data);
254 let mut pos = 1;
255 while n_pixels > 1 && pos < n_pixels - 1 {
256 let mut vec = data.to_vec();
257 for _ in 0..channels {
258 vec.remove(pos * channels);
259 }
260 if rt!(vec.as_slice(), n_pixels - 1).as_ref() != vec.as_slice() {
261 data = Cow::from(vec);
262 n_pixels -= 1;
263 } else {
264 pos += 1;
265 }
266 }
267
268 let encoded = encode(data.as_ref(), n_pixels as _).unwrap();
269 let decoded = decode(encoded.as_ref()).unwrap();
270 assert_ne!(decoded.as_ref(), data.as_ref());
271 if channels == 3 {
272 fail!(msg, data, decoded, encoded, 3);
273 } else {
274 fail!(msg, data, decoded, encoded, 4);
275 }
276 }
277
278 #[test]
279 fn test_generated() {
280 let mut rng = StdRng::seed_from_u64(0);
281
282 let mut n_pixels = 0;
283 while n_pixels < 20_000_000 {
284 let min_len = rng.gen_range(1..=5000);
285 let channels = rng.gen_range(3..=4);
286 let gen = ImageGen::new_random(&mut rng);
287 let img = gen.generate(&mut rng, channels, min_len);
288
289 let encode = |data: &[u8], size| encode_to_vec(data, size, 1);
290 let decode = |data: &[u8]| decode_to_vec(data).map(|r| r.1);
291 let encode_c = |data: &[u8], size| qoi_encode(data, size, 1, channels as _);
292 let decode_c = |data: &[u8]| qoi_decode(data, channels as _).map(|r| r.1);
293
294 check_roundtrip("qoi-rust -> qoi-rust", &img, channels as _, encode, decode);
295 check_roundtrip("qoi-rust -> qoi.h", &img, channels as _, encode, decode_c);
296 check_roundtrip("qoi.h -> qoi-rust", &img, channels as _, encode_c, decode);
297
298 let size = (img.len() / channels) as u32;
299 let encoded = encode(&img, size).unwrap();
300 let encoded_c = encode_c(&img, size).unwrap();
301 cfg_if! {
302 if #[cfg(feature = "reference")] {
303 let eq = encoded.as_slice() == encoded_c.as_ref();
304 assert!(eq, "qoi-rust [reference mode] doesn't match qoi.h");
305 } else {
306 let eq = encoded.len() == encoded_c.len();
307 assert!(eq, "qoi-rust [non-reference mode] length doesn't match qoi.h");
308 }
309 }
310
311 n_pixels += size;
312 }
313 }