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