Make BitReader rely on passed slice size without the additional arguments.

[nihav.git] / nihav-core / src / io / bitreader.rs

diff --git a/nihav-core/src/io/bitreader.rs b/nihav-core/src/io/bitreader.rs
index ea5f27c078d8c4e9cb3aa69bb69eeaa47e3d149e..aa841556bb4df43c4121989ae15b6662a3fb6417 100644 (file)
--- a/nihav-core/src/io/bitreader.rs
+++ b/nihav-core/src/io/bitreader.rs
@@ -22,16 +22,15 @@ pub struct BitReader<'a> {
     cache: u64,
     bits:  u8,
     pos:   usize,
-    end:   usize,
     src:   &'a [u8],
     mode:  BitReaderMode,
 }
 
+#[allow(clippy::identity_op)]
 impl<'a> BitReader<'a> {
 
-    pub fn new(src: &'a [u8], size: usize, mode: BitReaderMode) -> Self {
-        if src.len() < size { panic!("size is less than needed"); }
-        BitReader{ cache: 0, pos: 0, bits: 0, end: size, src: src, mode: mode }
+    pub fn new(src: &'a [u8], mode: BitReaderMode) -> Self {
+        BitReader{ cache: 0, pos: 0, bits: 0, src, mode }
     }
 
     pub fn tell(&self) -> usize {
@@ -39,42 +38,42 @@ impl<'a> BitReader<'a> {
     }
 
     pub fn left(&self) -> isize {
-        ((self.end as isize) - (self.pos as isize)) * 8 + (self.bits as isize)
+        ((self.src.len() as isize) - (self.pos as isize)) * 8 + (self.bits as isize)
     }
 
     fn fill32be(&mut self, src: &[u8]) {
-        let nw = (((src[0] as u32) << 24) |
-                  ((src[1] as u32) << 16) |
-                  ((src[2] as u32) <<  8) |
-                  ((src[3] as u32) <<  0)) as u64;
-        self.cache |= nw << (32 - self.bits);
+        let nw = (u32::from(src[0]) << 24) |
+                 (u32::from(src[1]) << 16) |
+                 (u32::from(src[2]) <<  8) |
+                 (u32::from(src[3]) <<  0);
+        self.cache |= u64::from(nw) << (32 - 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);
+        let nw = (u32::from(src[1]) << 24) |
+                 (u32::from(src[0]) << 16) |
+                 (u32::from(src[3]) <<  8) |
+                 (u32::from(src[2]) <<  0);
+        self.cache |= u64::from(nw) << (32 - self.bits);
     }
 
     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;
+        let nw = (u32::from(src[3]) << 24) |
+                 (u32::from(src[2]) << 16) |
+                 (u32::from(src[1]) <<  8) |
+                 (u32::from(src[0]) <<  0);
         if lsb {
-            self.cache |= nw << self.bits;
+            self.cache |= u64::from(nw) << self.bits;
         } else {
-            self.cache |= nw << (32 - self.bits);
+            self.cache |= u64::from(nw) << (32 - self.bits);
         }
     }
 
     #[inline(always)]
     fn refill(&mut self) -> BitReaderResult<()> {
-        if self.pos >= self.end { return Err(BitstreamEnd) }
+        if self.pos >= self.src.len() { return Err(BitstreamEnd) }
         while self.bits <= 32 {
-            if self.pos + 4 <= self.end {
+            if self.pos + 4 <= self.src.len() {
                 let buf = &self.src[self.pos..];
                 match self.mode {
                     BitReaderMode::BE      => self.fill32be  (buf),
@@ -87,10 +86,10 @@ impl<'a> BitReader<'a> {
             } else {
                 let mut buf: [u8; 4] = [0, 0, 0, 0];
                 let mut newbits: u8 = 0;
-                for i in 0..3 {
-                    if self.pos < self.end {
-                        buf[i] = self.src[self.pos];
-                        self.pos = self.pos + 1;
+                for out in buf.iter_mut().take(3) {
+                    if self.pos < self.src.len() {
+                        *out = self.src[self.pos];
+                        self.pos += 1;
                         newbits += 8;
                     }
                 }
@@ -111,7 +110,7 @@ impl<'a> BitReader<'a> {
     fn read_cache(&mut self, nbits: u8) -> u32 {
         let res = match self.mode {
             BitReaderMode::LE => ((1u64 << nbits) - 1) & self.cache,
-            _                 => (self.cache as u64) >> (64 - nbits),
+            _                 => self.cache >> (64 - nbits),
         };
         res as u32
     }
@@ -183,14 +182,14 @@ impl<'a> BitReader<'a> {
 
     #[inline(always)]
     pub fn skip(&mut self, nbits: u32) -> BitReaderResult<()> {
-        if self.bits as u32 >= nbits {
+        if u32::from(self.bits) >= nbits {
             self.skip_cache(nbits as u8);
             return Ok(());
         }
-        let mut skip_bits = nbits - (self.bits as u32);
+        let mut skip_bits = nbits - u32::from(self.bits);
         self.reset_cache();
         self.pos += ((skip_bits / 32) * 4) as usize;
-        skip_bits = skip_bits & 0x1F;
+        skip_bits &= 0x1F;
         self.refill()?;
         if skip_bits > 0 {
             self.skip_cache(skip_bits as u8);
@@ -199,7 +198,7 @@ impl<'a> BitReader<'a> {
     }
 
     pub fn seek(&mut self, nbits: u32) -> BitReaderResult<()> {
-        if ((nbits + 7) >> 3) as usize > self.end { return Err(TooManyBitsRequested); }
+        if ((nbits + 7) >> 3) as usize > self.src.len() { return Err(TooManyBitsRequested); }
         self.reset_cache();
         self.pos = ((nbits / 32) * 4) as usize;
         self.skip(nbits & 0x1F)
@@ -223,8 +222,8 @@ pub fn reverse_bits(inval: u32, len: u8) -> u32 {
     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 = (ret << 4) | u32::from(REV_TAB[(val & 0xF) as usize]);
+        val >>= 4;
     }
     ret >> (32 - len)
 }
@@ -237,14 +236,14 @@ mod test {
     fn br_works() {
         const DATA: [u8; 18] = [0b00011011; 18];
         let src = &DATA;
-        let mut br = BitReader::new(src, src.len(), BitReaderMode::LE16MSB);
+        let mut br = BitReader::new(src, BitReaderMode::LE16MSB);
 
         for _ in 0..8 {
             assert_eq!(br.read(16).unwrap(), 0x1B1B);
         }
         const DATA2: [u8; 1] = [ 0b00011011 ];
         let src = &DATA2;
-        let mut br = BitReader::new(src, src.len(), BitReaderMode::LE);
+        let mut br = BitReader::new(src, BitReaderMode::LE);
         assert_eq!(br.read_s(5).unwrap(), -5);
     }
 }