| 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 |
} |