libribzip2 0.5.0

a bzip2 library written in pure rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use crate::{
    bitwise::{
        bitreader::BitReader,
        bitwriter::{convert_to_code_pad_to_n_bits, convert_to_number},
    },
    {bitwise::Bit, block::delta::DeltaSymbol},
};

use super::{
    delta::{encode_delta, DeltaEncoded},
    huffman::CanonicalCodeTable,
};

pub(crate) fn encode_code_table<T>(table: CanonicalCodeTable<T>) -> Vec<Bit> {
    let code_lengths = table
        .0
        .iter()
        .map(|entry| entry.code.len() as u8)
        .collect::<Vec<_>>();
    encode_bit_lengths(&code_lengths)
}

fn encode_bit_lengths(code_lengths: &[u8]) -> Vec<Bit> {
    let mut out = Vec::<Bit>::new();

    let delta = encode_delta(code_lengths.to_vec());
    match delta {
        DeltaEncoded::Empty => {}
        DeltaEncoded::NonEmpty(enc) => {
            out.append(&mut convert_to_code_pad_to_n_bits(
                enc.start_value as usize,
                5,
            ));
            out.append(
                &mut enc
                    .deltas
                    .iter()
                    .flat_map(|d| match d {
                        DeltaSymbol::Decrease => {
                            vec![Bit::One, Bit::One]
                        }
                        DeltaSymbol::Increase => {
                            vec![Bit::One, Bit::Zero]
                        }
                        DeltaSymbol::Stop => vec![Bit::Zero],
                    })
                    .collect::<Vec<Bit>>(),
            );
        }
    }
    out
}

pub(crate) trait ReadDelta {
    fn read_delta(&mut self, amount: usize) -> Result<Vec<u8>, ()>;
}

impl<T> ReadDelta for T
where
    T: BitReader,
{
    fn read_delta(&mut self, amount: usize) -> Result<Vec<u8>, ()> {
        let mut out = vec![];
        let mut read = 0;

        let mut start = convert_to_number(&self.read_bits(5)?);
        loop {
            match &self.read_bits(1)?[..] {
                [Bit::One] => match &self.read_bits(1)?[..] {
                    [Bit::Zero] => start += 1,
                    _ => start -= 1,
                },
                _ => {
                    out.push(start as u8);
                    read += 1;
                }
            }
            if read == amount {
                break;
            }
        }
        Ok(out)
    }
}

#[cfg(test)]
mod test {
    use std::io::Cursor;

    use crate::bitwise::{
        bitreader::BitReaderImpl,
        bitwriter::{BitWriter, BitWriterImpl},
    };

    use super::*;

    #[test]
    pub fn reads_table() {
        let lengths = vec![1, 2, 3, 4];
        let mut buf = vec![];
        {
            let mut writer = BitWriterImpl::from_writer(&mut buf);
            writer.write_bits(&encode_bit_lengths(&lengths)).unwrap();
            writer.finalize().unwrap();
        }
        let mut cursor = Cursor::new(&buf);
        let mut bit_reader = BitReaderImpl::from_reader(&mut cursor);
        let read = bit_reader.read_delta(4);

        assert_eq!(lengths, read.unwrap());
    }
}