brs/
bit_reader.rs

1// Currently panics on EOF.
2// Needs improvement.
3
4use std::io::{self, prelude::*};
5
6pub struct BitReader {
7    buf: Vec<u8>,
8    pos: usize,
9}
10
11impl BitReader {
12    pub fn new(buf: Vec<u8>) -> Self {
13        Self { buf, pos: 0 }
14    }
15
16    // ReadBit
17    #[inline(always)]
18    pub fn read_bit(&mut self) -> bool {
19        let bit = (self.buf[self.pos >> 3] & (1 << (self.pos & 7))) != 0;
20        self.pos += 1;
21        bit
22    }
23
24    // SerializeBits
25    pub fn read_bits(&mut self, dst: &mut [u8], len: usize) {
26        for bit in 0..len {
27            let byte = &mut dst[bit >> 3];
28            let shift = bit & 7;
29            *byte = (*byte & !(1 << shift)) | (u8::from(self.read_bit()) << shift);
30        }
31    }
32
33    // SerializeInt
34    pub fn read_int(&mut self, max: u32) -> u32 {
35        let mut value = 0;
36        let mut mask = 1;
37
38        while (value + mask) < max && mask != 0 {
39            if self.read_bit() {
40                value |= mask;
41            }
42            mask *= 2;
43        }
44
45        value
46    }
47
48    // SerializeIntPacked
49    pub fn read_int_packed(&mut self) -> u32 {
50        /*
51        let mut src = &self.buf[..];
52        let bit_count_used_in_byte = self.pos & 7;
53        let bit_count_left_in_byte = 8 - (self.pos & 7);
54        let src_mask_byte_0 = ((1 << bit_count_left_in_byte) - 1) as u8;
55        let src_mask_byte_1 = ((1 << bit_count_used_in_byte) - 1) as u8;
56        let next_src_index = (bit_count_used_in_byte != 0) as usize;
57
58        let mut value: u32 = 0;
59
60        let mut it = 0;
61        let mut shift_count = 0;
62
63        while it < 5 {
64            self.pos += 8;
65
66            let byte = ((src[0] >> bit_count_used_in_byte) & src_mask_byte_0)
67                | ((src[next_src_index] & src_mask_byte_1) << (bit_count_left_in_byte & 7));
68            let next_byte_indicator = byte & 1;
69            let byte_as_word = (byte >> 1) as u32;
70            value = (byte_as_word << shift_count) | value;
71            src = &src[1..];
72
73            if next_byte_indicator == 0 {
74                break;
75            }
76
77            it += 1;
78            shift_count += 7;
79        }
80
81        value
82        */
83
84        let mut value = 0;
85
86        for i in 0..5 {
87            let has_next = self.read_bit();
88            let mut part = 0;
89            for bit_shift in 0..7 {
90                part |= (self.read_bit() as u32) << bit_shift;
91            }
92            value |= part << (7 * i);
93            if !has_next {
94                break;
95            }
96        }
97
98        value
99    }
100
101    // EatByteAlign
102    pub fn eat_byte_align(&mut self) {
103        self.pos = (self.pos + 7) & !0x07;
104    }
105
106    // SerializeIntVectorPacked
107    pub fn read_int_vector_packed(&mut self) -> (i32, i32, i32) {
108        (self.rivp_item(), self.rivp_item(), self.rivp_item())
109    }
110
111    #[inline(always)]
112    fn rivp_item(&mut self) -> i32 {
113        let value = self.read_int_packed();
114        (value >> 1) as i32 * if value & 1 != 0 { 1 } else { -1 }
115    }
116
117    // SerializePositiveIntVectorPacked
118    pub fn read_positive_int_vector_packed(&mut self) -> (u32, u32, u32) {
119        (
120            self.read_int_packed(),
121            self.read_int_packed(),
122            self.read_int_packed(),
123        )
124    }
125}
126
127impl Read for BitReader {
128    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
129        self.read_bits(dst, dst.len() * 8);
130        Ok(dst.len())
131    }
132}
brs/bit_reader.rs

brs/
bit_reader.rs
