2 pub enum BitReaderMode {
10 pub enum BitReaderError {
16 use self::BitReaderError::*;
18 pub type BitReaderResult<T> = Result<T, BitReaderError>;
21 pub struct BitReader<'a> {
30 impl<'a> BitReader<'a> {
32 pub fn new(src: &'a [u8], size: usize, mode: BitReaderMode) -> Self {
33 if src.len() < size { panic!("size is less than needed"); }
34 BitReader{ cache: 0, pos: 0, bits: 0, end: size, src: src, mode: mode }
37 pub fn tell(&self) -> usize {
38 self.pos * 8 - (self.bits as usize)
41 pub fn left(&self) -> isize {
42 ((self.end as isize) - (self.pos as isize)) * 8 + (self.bits as isize)
45 fn fill32be(&mut self, src: &[u8]) {
46 let nw = (((src[0] as u32) << 24) |
47 ((src[1] as u32) << 16) |
48 ((src[2] as u32) << 8) |
49 ((src[3] as u32) << 0)) as u64;
50 self.cache |= nw << (32 - self.bits);
53 fn fill32le16(&mut self, src: &[u8]) {
54 let nw = (((src[1] as u32) << 24) |
55 ((src[0] as u32) << 16) |
56 ((src[3] as u32) << 8) |
57 ((src[2] as u32) << 0)) as u64;
58 self.cache |= nw << (32 - self.bits);
61 fn fill32le32(&mut self, src: &[u8], lsb: bool) {
62 let nw = (((src[3] as u32) << 24) |
63 ((src[2] as u32) << 16) |
64 ((src[1] as u32) << 8) |
65 ((src[0] as u32) << 0)) as u64;
67 self.cache |= nw << self.bits;
69 self.cache |= nw << (32 - self.bits);
73 fn refill(&mut self) -> BitReaderResult<()> {
74 if self.pos >= self.end { return Err(BitstreamEnd) }
75 while self.bits <= 32 {
76 if self.pos + 4 <= self.end {
77 let buf = &self.src[self.pos..];
79 BitReaderMode::BE => self.fill32be (buf),
80 BitReaderMode::LE16MSB => self.fill32le16(buf),
81 BitReaderMode::LE => self.fill32le32(buf, true),
82 BitReaderMode::LE32MSB => self.fill32le32(buf, false),
87 let mut buf: [u8; 4] = [0, 0, 0, 0];
88 let mut newbits: u8 = 0;
90 if self.pos < self.end {
91 buf[i] = self.src[self.pos];
92 self.pos = self.pos + 1;
96 if newbits == 0 { break; }
98 BitReaderMode::BE => self.fill32be (&buf),
99 BitReaderMode::LE16MSB => self.fill32le16(&buf),
100 BitReaderMode::LE => self.fill32le32(&buf, true),
101 BitReaderMode::LE32MSB => self.fill32le32(&buf, false),
103 self.bits += newbits;
109 fn read_cache(&mut self, nbits: u8) -> u32 {
110 let res = match self.mode {
111 BitReaderMode::LE => ((1u64 << nbits) - 1) & self.cache,
112 _ => (self.cache as u64) >> (64 - nbits),
117 fn read_cache_s(&mut self, nbits: u8) -> i32 {
118 let res = match self.mode {
119 BitReaderMode::LE => ((self.cache as i64) << (64 - nbits)) >> (64 - nbits),
120 _ => (self.cache as i64) >> (64 - nbits),
125 fn skip_cache(&mut self, nbits: u8) {
127 BitReaderMode::LE => self.cache >>= nbits,
128 _ => self.cache <<= nbits,
133 fn reset_cache(&mut self) {
138 pub fn read(&mut self, nbits: u8) -> BitReaderResult<u32> {
139 if nbits == 0 { return Ok(0) }
140 if nbits > 32 { return Err(TooManyBitsRequested) }
141 if self.bits < nbits {
142 if let Err(err) = self.refill() { return Err(err) }
143 if self.bits < nbits { return Err(BitstreamEnd) }
145 let res = self.read_cache(nbits);
146 self.skip_cache(nbits);
150 pub fn read_s(&mut self, nbits: u8) -> BitReaderResult<i32> {
151 if nbits == 0 || nbits > 32 { return Err(TooManyBitsRequested) }
152 if self.bits < nbits {
153 if let Err(err) = self.refill() { return Err(err) }
154 if self.bits < nbits { return Err(BitstreamEnd) }
156 let res = self.read_cache_s(nbits);
157 self.skip_cache(nbits);
161 pub fn read_bool(&mut self) -> BitReaderResult<bool> {
163 if let Err(err) = self.refill() { return Err(err) }
164 if self.bits < 1 { return Err(BitstreamEnd) }
166 let res = self.read_cache(1);
171 pub fn peek(&mut self, nbits: u8) -> u32 {
172 if nbits > 32 { return 0 }
173 if self.bits < nbits { let _ = self.refill(); }
174 self.read_cache(nbits)
177 pub fn skip(&mut self, nbits: u32) -> BitReaderResult<()> {
178 if self.bits as u32 >= nbits {
179 self.skip_cache(nbits as u8);
182 let mut skip_bits = nbits - (self.bits as u32);
184 self.pos += ((skip_bits / 32) * 4) as usize;
185 skip_bits = skip_bits & 0x1F;
188 self.skip_cache(skip_bits as u8);
193 pub fn seek(&mut self, nbits: u32) -> BitReaderResult<()> {
194 if ((nbits + 7) >> 3) as usize > self.end { return Err(TooManyBitsRequested); }
196 self.pos = ((nbits / 32) * 4) as usize;
197 self.skip(nbits & 0x1F)
207 const DATA: [u8; 18] = [0b00011011; 18];
209 let mut br = BitReader::new(src, src.len(), BitReaderMode::LE16MSB);
212 assert_eq!(br.read(16).unwrap(), 0x1B1B);
214 const DATA2: [u8; 1] = [ 0b00011011 ];
216 let mut br = BitReader::new(src, src.len(), BitReaderMode::LE);
217 assert_eq!(br.read_s(5).unwrap(), -5);