simple-arithmetic-coding 0.2.2

Arithmetic coding, directly derived from the well-known CACM87 C-language implementation.
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::io::{BufRead, Write};

use crate::bitvec::BitVec;

pub struct Input <I>
where I: BufRead
{
    input_handle: I,
    input_bits: BitVec,
    idx: usize
}

impl<I> Input<I>
where I: BufRead
{
    pub fn new (mut input_handle: I) -> Result<Input<I>, std::io::Error> {
        let b = input_handle.fill_buf()?;
        let input_bits = BitVec::from_bytes(b);
        let len = b.len();
        input_handle.consume(len);
        Ok(Input {
            input_handle,
            input_bits,
            idx: 0
        })
    }
}

pub trait Next {
    fn next_bit (&mut self) -> Result<Option<bool>, std::io::Error>;
    fn next_byte (&mut self) -> Result<Option<u8>, std::io::Error>;
}

impl<I> Next for Input<I>
where I: BufRead
{
    fn next_bit (&mut self) -> Result<Option<bool>, std::io::Error> {
        if self.idx >= self.input_bits.len() {
            let b = self.input_handle.fill_buf()?;
            self.input_bits = BitVec::from_bytes(b);
            let len = b.len();
            self.input_handle.consume(len);
            self.idx = 0;
        }
        if let Some(o) = self.input_bits.get(self.idx) {
            self.idx += 1;
            Ok(Some(o))
        } else {
            Ok(None)
        }
    }

    fn next_byte (&mut self) -> Result<Option<u8>, std::io::Error>
    {
        let mut byte: u8 = 0;
        for shft in (0..8).rev() {
            if let Some(b) = self.next_bit()? {
                byte |= (b as u8) << shft;
            } else {
                return Ok(None);
            }
        }
        Ok(Some(byte))
    }
}


pub struct Output<'a, O>
where O: Write
{
    output_handle: &'a mut O,
    output_bits: BitVec
}

impl <'a, O> Output <'a, O>
where O: Write
{
    pub fn new(output_handle: &'a mut O, buffer_capacity: usize) -> Self {
        debug_assert!(buffer_capacity % 8 == 0);
        Output {
            output_handle,
            output_bits: BitVec::with_capacity(buffer_capacity)
        }
    }
}

pub trait Push {
    fn push_bit(&mut self, bit: bool) -> Result<(), std::io::Error>;
    fn push_byte(&mut self, byte: u8) -> Result<(), std::io::Error>;
    fn flush (&mut self) -> Result<(), std::io::Error>;
}

impl<'a, O> Push for Output<'a, O>
where O: Write
{
    fn push_bit(&mut self, bit: bool) -> Result<(), std::io::Error>
    {
        if self.output_bits.len() == self.output_bits.capacity() {
            self.flush()?;
        }
        self.output_bits.push(bit);
        Ok(())
    }

    fn push_byte(&mut self, byte: u8) -> Result<(), std::io::Error>
    {
        for shft in (0..8).rev() {
            self.push_bit(((byte >> shft) & 1) != 0)?;
        }
        Ok(())
    }
    fn flush (&mut self) -> Result<(), std::io::Error>
    {
        if !self.output_bits.is_empty() {
            self.output_handle.write_all(&self.output_bits.get_bytes())?;
            self.output_bits.clear();
        }
        Ok(())
    }
}