X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=src%2Fio%2Fbitreader.rs;h=b3e478edf64d4a6832eb09d160d6f3bb7b875871;hb=06fd8c8865256ab5348996a23afeeb512bc45835;hp=ba783eb7b1ef4e9e5343115b6536be30ff355709;hpb=a961f92b2a5f61d2e0776e9614a72dd5c8394071;p=nihav.git

diff --git a/src/io/bitreader.rs b/src/io/bitreader.rs
index ba783eb..b3e478e 100644
--- a/src/io/bitreader.rs
+++ b/src/io/bitreader.rs
@@ -50,21 +50,24 @@ impl<'a> BitReader<'a> {
         self.cache |= nw << (32 - self.bits);
     }
 
-    fn fill32le16(&mut self, src: &[u8], realbits: u8) {
-        let mut nw = (((src[1] as u32) << 24) |
-                      ((src[0] as u32) << 16) |
-                      ((src[3] as u32) <<  8) |
-                      ((src[2] as u32) <<  0)) as u64;
-        if realbits <= 16 { nw >>= 16; }
-        self.cache |= nw << self.bits;
+    fn fill32le16(&mut self, src: &[u8]) {
+        let nw = (((src[1] as u32) << 24) |
+                  ((src[0] as u32) << 16) |
+                  ((src[3] as u32) <<  8) |
+                  ((src[2] as u32) <<  0)) as u64;
+        self.cache |= nw << (32 - self.bits);
     }
 
-    fn fill32le32(&mut self, src: &[u8]) {
+    fn fill32le32(&mut self, src: &[u8], lsb: bool) {
         let nw = (((src[3] as u32) << 24) |
                   ((src[2] as u32) << 16) |
                   ((src[1] as u32) <<  8) |
                   ((src[0] as u32) <<  0)) as u64;
-        self.cache |= nw << self.bits;
+        if lsb {
+            self.cache |= nw << self.bits;
+        } else {
+            self.cache |= nw << (32 - self.bits);
+        }
     }
 
     fn refill(&mut self) -> BitReaderResult<()> {
@@ -74,9 +77,9 @@ impl<'a> BitReader<'a> {
                 let buf = &self.src[self.pos..];
                 match self.mode {
                     BitReaderMode::BE      => self.fill32be  (buf),
-                    BitReaderMode::LE16MSB => self.fill32le16(buf, 32),
-                    BitReaderMode::LE      => self.fill32le32(buf),
-                    BitReaderMode::LE32MSB => self.fill32le32(buf),
+                    BitReaderMode::LE16MSB => self.fill32le16(buf),
+                    BitReaderMode::LE      => self.fill32le32(buf, true),
+                    BitReaderMode::LE32MSB => self.fill32le32(buf, false),
                 }
                 self.pos  +=  4;
                 self.bits += 32;
@@ -93,9 +96,9 @@ impl<'a> BitReader<'a> {
                 if newbits == 0 { break; }
                 match self.mode {
                     BitReaderMode::BE      => self.fill32be  (&buf),
-                    BitReaderMode::LE16MSB => self.fill32le16(&buf, newbits),
-                    BitReaderMode::LE      => self.fill32le32(&buf),
-                    BitReaderMode::LE32MSB => self.fill32le32(&buf),
+                    BitReaderMode::LE16MSB => self.fill32le16(&buf),
+                    BitReaderMode::LE      => self.fill32le32(&buf, true),
+                    BitReaderMode::LE32MSB => self.fill32le32(&buf, false),
                 }
                 self.bits += newbits;
             }
@@ -155,6 +158,16 @@ impl<'a> BitReader<'a> {
         Ok(res)
     }
 
+    pub fn read_bool(&mut self) -> BitReaderResult<bool> {
+        if self.bits < 1 {
+            if let Err(err) = self.refill() { return Err(err) }
+            if self.bits < 1 { return Err(BitstreamEnd) }
+        }
+        let res = self.read_cache(1);
+        self.skip_cache(1);
+        Ok(res == 1)
+    }
+
     pub fn peek(&mut self, nbits: u8) -> u32 {
         if nbits > 32 { return 0 }
         if self.bits < nbits { let _ = self.refill(); }
@@ -183,6 +196,29 @@ impl<'a> BitReader<'a> {
         self.pos = ((nbits / 32) * 4) as usize;
         self.skip(nbits & 0x1F)
     }
+
+    pub fn align(&mut self) {
+        let pos = self.bits & 7;
+        if pos != 0 {
+            self.skip_cache(pos);
+        }
+    }
+}
+
+pub fn reverse_bits(inval: u32, len: u8) -> u32 {
+    if len == 0 { return 0; }
+    const REV_TAB: [u8; 16] = [
+        0b0000, 0b1000, 0b0100, 0b1100, 0b0010, 0b1010, 0b0110, 0b1110,
+        0b0001, 0b1001, 0b0101, 0b1101, 0b0011, 0b1011, 0b0111, 0b1111,
+    ];
+
+    let mut ret = 0;
+    let mut val = inval;
+    for _ in 0..8 {
+        ret = (ret << 4) | (REV_TAB[(val & 0xF) as usize] as u32);
+        val = val >> 4;
+    }
+    ret >> (32 - len)
 }
 
 #[cfg(test)]