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
129
130
131
132
// Currently panics on EOF.
// Needs improvement.
use std::io::{self, prelude::*};
pub struct BitReader {
buf: Vec<u8>,
pos: usize,
}
impl BitReader {
pub fn new(buf: Vec<u8>) -> Self {
Self { buf, pos: 0 }
}
// ReadBit
#[inline(always)]
pub fn read_bit(&mut self) -> bool {
let bit = (self.buf[self.pos >> 3] & (1 << (self.pos & 7))) != 0;
self.pos += 1;
bit
}
// SerializeBits
pub fn read_bits(&mut self, dst: &mut [u8], len: usize) {
for bit in 0..len {
let byte = &mut dst[bit >> 3];
let shift = bit & 7;
*byte = (*byte & !(1 << shift)) | (u8::from(self.read_bit()) << shift);
}
}
// SerializeInt
pub fn read_int(&mut self, max: u32) -> u32 {
let mut value = 0;
let mut mask = 1;
while (value + mask) < max && mask != 0 {
if self.read_bit() {
value |= mask;
}
mask *= 2;
}
value
}
// SerializeIntPacked
pub fn read_int_packed(&mut self) -> u32 {
/*
let mut src = &self.buf[..];
let bit_count_used_in_byte = self.pos & 7;
let bit_count_left_in_byte = 8 - (self.pos & 7);
let src_mask_byte_0 = ((1 << bit_count_left_in_byte) - 1) as u8;
let src_mask_byte_1 = ((1 << bit_count_used_in_byte) - 1) as u8;
let next_src_index = (bit_count_used_in_byte != 0) as usize;
let mut value: u32 = 0;
let mut it = 0;
let mut shift_count = 0;
while it < 5 {
self.pos += 8;
let byte = ((src[0] >> bit_count_used_in_byte) & src_mask_byte_0)
| ((src[next_src_index] & src_mask_byte_1) << (bit_count_left_in_byte & 7));
let next_byte_indicator = byte & 1;
let byte_as_word = (byte >> 1) as u32;
value = (byte_as_word << shift_count) | value;
src = &src[1..];
if next_byte_indicator == 0 {
break;
}
it += 1;
shift_count += 7;
}
value
*/
let mut value = 0;
for i in 0..5 {
let has_next = self.read_bit();
let mut part = 0;
for bit_shift in 0..7 {
part |= (self.read_bit() as u32) << bit_shift;
}
value |= part << (7 * i);
if !has_next {
break;
}
}
value
}
// EatByteAlign
pub fn eat_byte_align(&mut self) {
self.pos = (self.pos + 7) & !0x07;
}
// SerializeIntVectorPacked
pub fn read_int_vector_packed(&mut self) -> (i32, i32, i32) {
(self.rivp_item(), self.rivp_item(), self.rivp_item())
}
#[inline(always)]
fn rivp_item(&mut self) -> i32 {
let value = self.read_int_packed();
(value >> 1) as i32 * if value & 1 != 0 { 1 } else { -1 }
}
// SerializePositiveIntVectorPacked
pub fn read_positive_int_vector_packed(&mut self) -> (u32, u32, u32) {
(
self.read_int_packed(),
self.read_int_packed(),
self.read_int_packed(),
)
}
}
impl Read for BitReader {
fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
self.read_bits(dst, dst.len() * 8);
Ok(dst.len())
}
}