Debian Codegraph @

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

raw
1 use core::num::NonZeroU16;
2 #[cfg(not(feature = "std"))]
3 use alloc::boxed::Box;
4 use crate::error::LhaResult;
5 use crate::stub_io::Read;
6 use crate::decode::Decoder;
7 use crate::ringbuf::*;
8 use crate::bitstream::*;
9
10 mod dyntree;
11 use dyntree::*;
12
13 const RING_BUFFER_SIZE: usize = 4096;
14
15 /// A decoder for `-lh1-` compression method.
16 #[derive(Debug)]
17 pub struct Lh1Decoder<R> {
18 bit_reader: BitStream<R>,
19 command_tree: Box<DynHuffTree>,
20 copy_progress: Option<(u16, NonZeroU16)>,
21 ringbuf: Box<RingArrayBuf<RING_BUFFER_SIZE>>,
22 }
23
24 impl<R: Read> Lh1Decoder<R> {
25 pub fn new(rd: R) -> Lh1Decoder<R> {
26 let bit_reader = BitStream::new(rd);
27 let ringbuf = Default::default();
28 let command_tree = Box::new(DynHuffTree::new());
29 Lh1Decoder {
30 bit_reader,
31 ringbuf,
32 command_tree,
33 copy_progress: None
34 }
35 }
36
37 #[inline]
38 fn read_command(&mut self) -> LhaResult<u16, R> {
39 self.command_tree.read_entry(&mut self.bit_reader)
40 }
41
42 #[inline]
43 fn read_offset(&mut self) -> LhaResult<u16, R> {
44 let bits9 = self.bit_reader.read_bits(9)?;
45 let (mut offset, bits) = decode_offset(bits9);
46 offset |= self.bit_reader.read_bits::<u16>(bits)?;
47 Ok(offset)
48 }
49
50 fn copy_from_history<'a, I: Iterator<Item=&'a mut u8> + ExactSizeIterator>(
51 &mut self,
52 target: I,
53 offset: usize,
54 count: usize
55 ) -> LhaResult<(), R>
56 {
57 let history_iter = self.ringbuf.iter_from_offset(offset);
58 let count_after = count - target.len().min(count);
59 for (t, s) in target.zip(history_iter).take(count) {
60 *t = s;
61 }
62 self.copy_progress = NonZeroU16::new(count_after as u16)
63 .map(|count| (offset as u16, count));
64 Ok(())
65 }
66 }
67
68 impl<R: Read> Decoder<R> for Lh1Decoder<R> where R::Error: core::fmt::Debug {
69 type Error = R::Error;
70
71 fn into_inner(self) -> R {
72 self.bit_reader.into_inner()
73 }
74
75 fn fill_buffer(&mut self, buf: &mut[u8]) -> LhaResult<(), R> {
76 let buflen = buf.len();
77 let mut target = buf.iter_mut();
78 if let Some((offset, count)) = self.copy_progress {
79 self.copy_from_history(&mut target,
80 offset as usize,
81 count.get() as usize)?;
82 }
83
84 while let Some(dst) = target.next() {
85 match self.read_command()? {
86 code @ 0..=0xff => {
87 let value = code as u8;
88 *dst = value;
89 self.ringbuf.push(value);
90 }
91 count => {
92 let offset = self.read_offset()?;
93 let index = buflen - target.len() - 1;
94 target = buf[index..].iter_mut();
95 self.copy_from_history(&mut target,
96 offset as usize,
97 (count - 0x100 + 3).into())?;
98 }
99 }
100 }
101 Ok(())
102 }
103 }
104
105 /// Returns (incomplete offset, additional bits to read)
106 #[inline(always)]
107 fn decode_offset(bits9: u16) -> (u16, u32) {
108 match bits9 & 0b111100000 {
109 /* 000xxxxxx -> 000000 xxxxxx */
110 0b000000000..=0b000111111 => (bits9, 0),
111 /* 0010xxxxx -> 000001 xxxxxy */
112 /* 0100xxxxx -> 000011 xxxxxy */
113 0b001000000..=0b010011111 => ((bits9 - 0b000100000) << 1, 1),
114 /* 01010xxxx -> 000100 xxxxyy */
115 /* 10001xxxx -> 001011 xxxxyy */
116 0b010100000..=0b100011111 => ((bits9 - 0b001100000) << 2, 2),
117 /* 100100xxx -> 001100 xxxyyy */
118 /* 101111xxx -> 010111 xxxyyy */
119 0b100100000..=0b101111111 => ((bits9 - 0b011000000) << 3, 3),
120 /* 1100000xx -> 011000 xxyyyy */
121 /* 1110111xx -> 101111 xxyyyy */
122 0b110000000..=0b111011111 => ((bits9 - 0b100100000) << 4, 4),
123 /* 11110000x -> 110000 xyyyyy */
124 /* 11111111x -> 111111 xyyyyy */
125 0b111100000..=0b111111111 => ((bits9 - 0b110000000) << 5, 5),
126 _ => unreachable!()
127 }
128 }
129
130 #[cfg(feature = "std")]
131 #[cfg(test)]
132 mod tests {
133 use super::*;
134 use std::io;
135 use std::fs;
136
137 #[test]
138 fn lhav1_works() {
139 println!("Lh1Decoder<Empty> {}", core::mem::size_of::<Lh1Decoder<io::Empty>>());
140 println!("Lh1Decoder<File> {}", core::mem::size_of::<Lh1Decoder<fs::File>>());
141 println!("DynHuffTree {}", core::mem::size_of::<DynHuffTree>());
142 }
143 }