Debian Codegraph @

.cargo/vendor/delharc/src/decode/lz5.rs

raw
1 use core::slice;
2 use core::num::NonZeroU16;
3 #[cfg(not(feature = "std"))]
4 use alloc::boxed::Box;
5 use crate::error::{LhaResult, LhaError};
6 use crate::stub_io::Read;
7 use crate::decode::Decoder;
8 use crate::ringbuf::*;
9
10 const RING_BUFFER_SIZE: usize = 4096;
11 const START_OFFSET: isize = -18;
12
13 /// A decoder for `-lz5-` compression method.
14 #[derive(Debug)]
15 pub struct Lz5Decoder<R> {
16 reader: R,
17 bitmap: u16,
18 copy_progress: Option<(u16, NonZeroU16)>,
19 ringbuf: Box<RingArrayBuf<RING_BUFFER_SIZE>>,
20 }
21
22 impl<R: Read> Lz5Decoder<R> {
23 pub fn new(reader: R) -> Lz5Decoder<R> {
24 let mut ringbuf: Box<RingArrayBuf<RING_BUFFER_SIZE>> = Box::default();
25
26 // fill 13 times with each byte value (3328)
27 for i in 0..=255 {
28 for _ in 0..13 {
29 ringbuf.push(i);
30 }
31 }
32 // 256 ascending values (3584)
33 for i in 0..=255 {
34 ringbuf.push(i);
35 }
36 // 256 descending values (3840)
37 for i in (0..=255).rev() {
38 ringbuf.push(i);
39 }
40 // 128 zeroes (3968)
41 for _ in 0..128 {
42 ringbuf.push(0);
43 }
44 // leave a gap of 110 default spaces (4078)
45 ringbuf.set_cursor(START_OFFSET);
46 // a margin of zeroes (4096)
47 while ringbuf.cursor() != 0 {
48 ringbuf.push(0);
49 }
50 // set the start offset
51 ringbuf.set_cursor(START_OFFSET);
52
53 Lz5Decoder {
54 reader,
55 ringbuf,
56 bitmap: 1,
57 copy_progress: None
58 }
59 }
60
61 fn copy_from_history<'a, I: Iterator<Item=&'a mut u8> + ExactSizeIterator>(
62 &mut self,
63 target: I,
64 pos: usize,
65 count: usize
66 ) -> LhaResult<(), R>
67 {
68 let history_iter = self.ringbuf.iter_from_pos(pos);
69 let real_count = target.len().min(count);
70 for (t, s) in target.zip(history_iter).take(real_count) {
71 *t = s;
72 }
73 self.copy_progress = NonZeroU16::new((count - real_count) as u16)
74 .map(|count| ((pos + real_count) as u16, count));
75 Ok(())
76 }
77 }
78
79 impl<R: Read> Decoder<R> for Lz5Decoder<R> where R::Error: core::fmt::Debug {
80 type Error = R::Error;
81
82 fn into_inner(self) -> R {
83 self.reader
84 }
85
86 fn fill_buffer(&mut self, buf: &mut[u8]) -> LhaResult<(), R> {
87 let buflen = buf.len();
88 let mut target = buf.iter_mut();
89 if let Some((pos, count)) = self.copy_progress {
90 self.copy_from_history(&mut target,
91 pos as usize,
92 count.get() as usize)?;
93 }
94
95 let mut bitmap = self.bitmap;
96
97 while let Some(dst) = target.next() {
98 if bitmap == 1 {
99 let mut byte = 0u8;
100 self.reader.read_exact(slice::from_mut(&mut byte))
101 .map_err(LhaError::Io)?;
102 bitmap = byte as u16 | 0x0100;
103 }
104
105 if bitmap & 1 == 1 {
106 let mut value = 0u8;
107 self.reader.read_exact(slice::from_mut(&mut value))
108 .map_err(LhaError::Io)?;
109 *dst = value;
110 self.ringbuf.push(value);
111 }
112 else {
113 let mut cmd = [0u8;2];
114 self.reader.read_exact(&mut cmd)
115 .map_err(LhaError::Io)?;
116 let [lo, hi] = cmd;
117 let pos = (((hi & 0xf0) as usize) << 4) | lo as usize;
118 let count = (hi & 0x0f) as usize;
119 let index = buflen - target.len() - 1;
120 target = buf[index..].iter_mut();
121 self.copy_from_history(&mut target, pos, count + 3)?;
122 }
123
124 bitmap >>= 1;
125 }
126 self.bitmap = bitmap;
127 Ok(())
128 }
129 }